Page MenuHomePhabricator
Files F5600253

No OneTemporary
Actions

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
This document is not UTF8. It was detected as ISO-8859-1 (Latin 1) and converted to UTF8 for display.
diff --git a/Applications/PluginGenerator/CMakeLists.txt b/Applications/PluginGenerator/CMakeLists.txt
index 009c9c9c02..42a3259edd 100644
--- a/Applications/PluginGenerator/CMakeLists.txt
+++ b/Applications/PluginGenerator/CMakeLists.txt
@@ -1,77 +1,77 @@
-cmake_minimum_required(VERSION 2.8.4)
+cmake_minimum_required(VERSION 2.8.5)
project(MITKPluginGenerator)
set(VERSION_MAJOR 1)
set(VERSION_MINOR 4)
set(VERSION_PATCH 0)
set(VERSION_STRING "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
set(standalone_build 1)
else()
set(standalone_build 0)
endif()
#-----------------------------------------------------------------------------
# Prerequisites
#-----------------------------------------------------------------------------
set(QT_DONT_USE_QTGUI 1)
set(QT_USE_QTNETWORK 1)
find_package(Qt 4.6.2 REQUIRED)
include(${QT_USE_FILE})
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/PluginGeneratorConfig.h.in"
"${CMAKE_CURRENT_BINARY_DIR}/PluginGeneratorConfig.h" @ONLY)
include_directories("${CMAKE_CURRENT_BINARY_DIR}")
#-----------------------------------------------------------------------------
# Executable
#-----------------------------------------------------------------------------
set(src_files
PluginGenerator.cpp
ctkCommandLineParser.cpp
)
qt4_wrap_cpp(src_files ctkCommandLineParser.h)
qt4_add_resources(src_files plugin_template.qrc project_template.qrc)
set(exec_target ${PROJECT_NAME})
add_executable(${exec_target} ${src_files})
target_link_libraries(${exec_target} ${QT_LIBRARIES})
if(NOT standalone_build)
# subproject support
add_dependencies(MITK-CoreUI ${exec_target})
endif()
#-----------------------------------------------------------------------------
# Win32 Convenience
#-----------------------------------------------------------------------------
if(WIN32 AND NOT standalone_build)
file(TO_NATIVE_PATH "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}" native_runtime_dir)
add_custom_target(NewPlugin start "MITK PluginGenerator" /D "${native_runtime_dir}" cmd /K ${exec_target}.exe -h
DEPENDS ${exec_target})
endif()
#-----------------------------------------------------------------------------
# Testing
#-----------------------------------------------------------------------------
if(NOT standalone_build)
# Test the plugin generator
include(mitkTestPluginGenerator)
endif()
#-----------------------------------------------------------------------------
# Packaging support
#-----------------------------------------------------------------------------
if(standalone_build)
include(SetupPackaging.cmake)
endif()
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt b/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
index 29f65bc1a5..68e42919c5 100644
--- a/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
+++ b/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
@@ -1,366 +1,366 @@
-cmake_minimum_required(VERSION 2.8.4)
+cmake_minimum_required(VERSION 2.8.5)
# Change project and application name to your own
set(MY_PROJECT_NAME $(project-name))
set(MY_APP_NAME $(project-app-name))
#-----------------------------------------------------------------------------
# Set a default build type if none was specified
#-----------------------------------------------------------------------------
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
message(STATUS "Setting build type to 'Debug' as none was specified.")
set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
# Set the possible values of build type for cmake-gui
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
endif()
#-----------------------------------------------------------------------------
# Superbuild Option - Enabled by default
#-----------------------------------------------------------------------------
option(${MY_PROJECT_NAME}_USE_SUPERBUILD "Build ${MY_PROJECT_NAME} and the projects it depends on via SuperBuild.cmake." ON)
if(${MY_PROJECT_NAME}_USE_SUPERBUILD)
project(${MY_PROJECT_NAME}-superbuild)
set(${MY_PROJECT_NAME}_SOURCE_DIR ${PROJECT_SOURCE_DIR})
set(${MY_PROJECT_NAME}_BINARY_DIR ${PROJECT_BINARY_DIR})
else()
project(${MY_PROJECT_NAME})
endif()
#-----------------------------------------------------------------------------
# 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
${${MY_PROJECT_NAME}_SOURCE_DIR}/CMake
${CMAKE_MODULE_PATH}
)
#-----------------------------------------------------------------------------
# CMake Function(s) and Macro(s)
#-----------------------------------------------------------------------------
include(MacroEmptyExternalProject)
#-----------------------------------------------------------------------------
# Output directories.
#-----------------------------------------------------------------------------
foreach(type LIBRARY RUNTIME ARCHIVE)
set(output_dir ${${MY_PROJECT_NAME}_BINARY_DIR}/bin)
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 Options (also shown during superbuild)
#-----------------------------------------------------------------------------
option(BUILD_SHARED_LIBS "Build ${MY_PROJECT_NAME} with shared libraries" ON)
option(WITH_COVERAGE "Enable/Disable coverage" OFF)
option(BUILD_TESTING "Test the project" ON)
option(${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS "Build all ${MY_PROJECT_NAME} plugins" OFF)
mark_as_advanced(${MY_PROJECT_NAME}_INSTALL_RPATH_RELATIVE
${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS
)
#-----------------------------------------------------------------------------
# Superbuild script
#-----------------------------------------------------------------------------
if(${MY_PROJECT_NAME}_USE_SUPERBUILD)
include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
return()
endif()
#*****************************************************************************
#**************************** END OF SUPERBUILD ****************************
#*****************************************************************************
#-----------------------------------------------------------------------------
# Prerequesites
#-----------------------------------------------------------------------------
find_package(MITK REQUIRED)
if(COMMAND mitkFunctionCheckMitkCompatibility)
mitkFunctionCheckMitkCompatibility(VERSIONS MITK_VERSION_PLUGIN_SYSTEM 1 REQUIRED)
else()
message(SEND_ERROR "Your MITK version is too old. Please use Git hash b86bf28 or newer")
endif()
link_directories(${MITK_LINK_DIRECTORIES})
#-----------------------------------------------------------------------------
# CMake Function(s) and Macro(s)
#-----------------------------------------------------------------------------
set(CMAKE_MODULE_PATH
${MITK_SOURCE_DIR}/CMake
${CMAKE_MODULE_PATH}
)
include(mitkFunctionCheckCompilerFlags)
include(mitkFunctionGetGccVersion)
include(mitkFunctionGetVersion)
#-----------------------------------------------------------------------------
# Set project specific options and variables (NOT available during superbuild)
#-----------------------------------------------------------------------------
set(${PROJECT_NAME}_VERSION_MAJOR "0")
set(${PROJECT_NAME}_VERSION_MINOR "1")
set(${PROJECT_NAME}_VERSION_PATCH "1")
set(${PROJECT_NAME}_VERSION_STRING "${${PROJECT_NAME}_VERSION_MAJOR}.${${PROJECT_NAME}_VERSION_MINOR}.${${PROJECT_NAME}_VERSION_PATCH}")
# Ask the user if a console window should be shown with the applications
option(${PROJECT_NAME}_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting GUI Applications" ON)
mark_as_advanced(${PROJECT_NAME}_SHOW_CONSOLE_WINDOW)
if(NOT UNIX AND NOT MINGW)
set(MITK_WIN32_FORCE_STATIC "STATIC")
endif()
set(${PROJECT_NAME}_MODULES_PACKAGE_DEPENDS_DIR "${PROJECT_SOURCE_DIR}/CMake/PackageDepends")
list(APPEND MODULES_PACKAGE_DEPENDS_DIRS ${${PROJECT_NAME}_MODULES_PACKAGE_DEPENDS_DIR})
#-----------------------------------------------------------------------------
# Get project version info
#-----------------------------------------------------------------------------
mitkFunctionGetVersion(${PROJECT_SOURCE_DIR} ${PROJECT_NAME})
#-----------------------------------------------------------------------------
# Installation preparation
#
# These should be set before any MITK install macros are used
#-----------------------------------------------------------------------------
# on Mac OSX all CTK plugins get copied into every
# application bundle (.app directory) specified here
set(MACOSX_BUNDLE_NAMES)
if(APPLE)
list(APPEND MACOSX_BUNDLE_NAMES ${MY_APP_NAME})
endif(APPLE)
#-----------------------------------------------------------------------------
# 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)
# The MITK module build system does not yet support default hidden visibility
set(VISIBILITY_CXX_FLAGS ) # "-fvisibility=hidden -fvisibility-inlines-hidden")
endif()
#-----------------------------------------------------------------------------
# Set coverage Flags
#-----------------------------------------------------------------------------
if(WITH_COVERAGE)
if(CMAKE_COMPILER_IS_GNUCXX)
set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG")
set(COVERAGE_CXX_FLAGS ${coverage_flags})
set(COVERAGE_C_FLAGS ${coverage_flags})
endif()
endif()
#-----------------------------------------------------------------------------
# Project C/CXX Flags
#-----------------------------------------------------------------------------
set(${PROJECT_NAME}_C_FLAGS "${MITK_C_FLAGS} ${COVERAGE_C_FLAGS}")
set(${PROJECT_NAME}_C_FLAGS_DEBUG ${MITK_C_FLAGS_DEBUG})
set(${PROJECT_NAME}_C_FLAGS_RELEASE ${MITK_C_FLAGS_RELEASE})
set(${PROJECT_NAME}_CXX_FLAGS "${MITK_CXX_FLAGS} ${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS}")
set(${PROJECT_NAME}_CXX_FLAGS_DEBUG ${MITK_CXX_FLAGS_DEBUG})
set(${PROJECT_NAME}_CXX_FLAGS_RELEASE ${MITK_CXX_FLAGS_RELEASE})
set(${PROJECT_NAME}_EXE_LINKER_FLAGS ${MITK_EXE_LINKER_FLAGS})
set(${PROJECT_NAME}_SHARED_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
set(${PROJECT_NAME}_MODULE_LINKER_FLAGS ${MITK_MODULE_LINKER_FLAGS})
#-----------------------------------------------------------------------------
# Set C/CXX Flags
#-----------------------------------------------------------------------------
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${${PROJECT_NAME}_C_FLAGS}")
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${${PROJECT_NAME}_C_FLAGS_DEBUG}")
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${${PROJECT_NAME}_C_FLAGS_RELEASE}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${${PROJECT_NAME}_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${${PROJECT_NAME}_CXX_FLAGS_DEBUG}")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${${PROJECT_NAME}_CXX_FLAGS_RELEASE}")
set(CMAKE_EXE_LINKER_FLAGS ${${PROJECT_NAME}_EXE_LINKER_FLAGS})
set(CMAKE_SHARED_LINKER_FLAGS ${${PROJECT_NAME}_SHARED_LINKER_FLAGS})
set(CMAKE_MODULE_LINKER_FLAGS ${${PROJECT_NAME}_MODULE_LINKER_FLAGS})
#-----------------------------------------------------------------------------
# Testing
#-----------------------------------------------------------------------------
if(BUILD_TESTING)
enable_testing()
include(CTest)
mark_as_advanced(TCL_TCLSH DART_ROOT)
# Setup file for setting custom ctest vars
configure_file(
CMake/CTestCustom.cmake.in
${CMAKE_CURRENT_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;
}
")
endif()
#-----------------------------------------------------------------------------
# ${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR
#-----------------------------------------------------------------------------
# If ${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR isn't defined, it means this project is
# *NOT* build using Superbuild. In that specific case, ${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR
# should default to PROJECT_BINARY_DIR
if(NOT DEFINED ${PROJECT_NAME}_SUPERBUILD_BINARY_DIR)
set(${PROJECT_NAME}_SUPERBUILD_BINARY_DIR ${PROJECT_BINARY_DIR})
endif()
#-----------------------------------------------------------------------------
# Qt support
#-----------------------------------------------------------------------------
if(MITK_USE_QT)
set(QT_QMAKE_EXECUTABLE ${MITK_QMAKE_EXECUTABLE})
add_definitions(-DQWT_DLL)
endif()
#-----------------------------------------------------------------------------
# MITK modules
#-----------------------------------------------------------------------------
# This project's directory holding module config files
#set(${PROJECT_NAME}_MODULES_CONF_DIR "${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}")
# Append this projects's module config directory to the global list
# (This is used to get include directories for the <module_name>Exports.h files right)
#list(APPEND MODULES_CONF_DIRS ${${PROJECT_NAME}_MODULES_CONF_DIR})
# Clean the modulesConf directory. This ensures that modules are sorted
# according to their dependencies in the Modules/CMakeLists.txt file
#file(GLOB _modules_conf_files ${${PROJECT_NAME}_MODULES_CONF_DIR}/*.cmake)
#if(_modules_conf_files)
# file(REMOVE ${_modules_conf_files})
#endif()
#add_subdirectory(Modules)
#-----------------------------------------------------------------------------
# CTK plugins
#-----------------------------------------------------------------------------
# The CMake code in this section *must* be in the top-level CMakeLists.txt file
macro(GetMyTargetLibraries all_target_libraries varname)
set(re_ctkplugin "^$(project-plugin-base)_[a-zA-Z0-9_]+$")
set(_tmp_list)
list(APPEND _tmp_list ${all_target_libraries})
ctkMacroListFilter(_tmp_list re_ctkplugin OUTPUT_VARIABLE ${varname})
endmacro()
include(${CMAKE_CURRENT_SOURCE_DIR}/Plugins/Plugins.cmake)
ctkMacroSetupPlugins(${PROJECT_PLUGINS}
BUILD_OPTION_PREFIX ${MY_PROJECT_NAME}_
BUILD_ALL ${${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS})
#-----------------------------------------------------------------------------
# Add subdirectories
#-----------------------------------------------------------------------------
add_subdirectory(Apps/$(project-app-name))
#-----------------------------------------------------------------------------
# Installation
#-----------------------------------------------------------------------------
# set MITK cpack variables
include(mitkSetupCPack)
# Customize CPack variables for this project
include(CPackSetup)
list(APPEND CPACK_CREATE_DESKTOP_LINKS "${MY_APP_NAME}")
configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
${PROJECT_BINARY_DIR}/${PROJECT_NAME}CPackOptions.cmake @ONLY)
set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}CPackOptions.cmake")
# include CPack model once all variables are set
include(CPack)
# Additional installation rules
include(mitkInstallRules)
#-----------------------------------------------------------------------------
# Last configuration steps
#-----------------------------------------------------------------------------
# If we are under Windows, create two batch files which correctly
# set up the environment for the application and for Visual Studio
if(WIN32)
include(mitkFunctionCreateWindowsBatchScript)
set(VS_SOLUTION_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln")
foreach(VS_BUILD_TYPE debug release)
mitkFunctionCreateWindowsBatchScript("${PROJECT_SOURCE_DIR}/CMake/StartVS.bat.in"
${PROJECT_BINARY_DIR}/StartVS_${VS_BUILD_TYPE}.bat
${VS_BUILD_TYPE})
endforeach()
endif(WIN32)
diff --git a/BlueBerry/CMake/FunctionCreateBlueBerryApplication.cmake b/BlueBerry/CMake/FunctionCreateBlueBerryApplication.cmake
index 05775d73ed..d3bee9dd1a 100644
--- a/BlueBerry/CMake/FunctionCreateBlueBerryApplication.cmake
+++ b/BlueBerry/CMake/FunctionCreateBlueBerryApplication.cmake
@@ -1,210 +1,212 @@
#!
#! Create a BlueBerry application.
#!
#! \brif This function will create a BlueBerry application together with all
#! necessary provisioning and configuration data and install support.
#!
#! \param NAME (required) The name of the executable.
#! \param DESCRIPTION (optional) A human-readable description of your application.
#! The usage depends on the CPack generator (on Windows, this is a descriptive
#! text for the created shortcuts).
#! \param SOURCES (optional) A list of source files to compile into your executable. Defaults
#! to <name>.cpp.
#! \param PLUGINS (optional) A list of required plug-ins. Defaults to all known plug-ins.
#! \param EXCLUDE_PLUGINS (optional) A list of plug-ins which should not be used. Mainly
#! useful if PLUGINS was not used.
#! \param LINK_LIBRARIES A list of libraries to be linked with the executable.
#! \param LIBRARY_DIRS A list of directories to pass through to MITK_INSTALL_TARGETS
#! \param SHOW_CONSOLE (option) Show the console output window (on Windows).
#! \param NO_PROVISIONING (option) Do not create provisioning files.
#! \param NO_INSTALL (option) Do not install this executable
#!
#! Assuming that there exists a file called <code>MyApp.cpp</code>, an example call looks like:
#! \code
#! FunctionCreateBlueBerryApplication(
#! NAME MyApp
#! DESCRIPTION "MyApp - New ways to explore medical data"
#! EXCLUDE_PLUGINS org.mitk.gui.qt.extapplication
#! SHOW_CONSOLE
#! )
#! \endcode
#!
function(FunctionCreateBlueBerryApplication)
macro_parse_arguments(_APP "NAME;DESCRIPTION;SOURCES;PLUGINS;EXCLUDE_PLUGINS;LINK_LIBRARIES;LIBRARY_DIRS" "SHOW_CONSOLE;NO_PROVISIONING;NO_INSTALL" ${ARGN})
if(NOT _APP_NAME)
message(FATAL_ERROR "NAME argument cannot be empty.")
endif()
if(NOT _APP_SOURCES)
set(_APP_SOURCES ${_APP_NAME}.cpp)
endif()
if(NOT _APP_PLUGINS)
ctkFunctionGetAllPluginTargets(_APP_PLUGINS)
else()
set(_plugins ${_APP_PLUGINS})
set(_APP_PLUGINS)
foreach(_plugin ${_plugins})
string(REPLACE "." "_" _plugin_target ${_plugin})
list(APPEND _APP_PLUGINS ${_plugin_target})
endforeach()
# get all plug-in dependencies
ctkFunctionGetPluginDependencies(_plugin_deps PLUGINS ${_APP_PLUGINS} ALL)
# add the dependencies to the list of application plug-ins
list(APPEND _APP_PLUGINS ${_plugin_deps})
endif()
#------------------------------------------------------------------------
# Prerequesites
#------------------------------------------------------------------------
find_package(MITK REQUIRED)
# -----------------------------------------------------------------------
# Set up include and link dirs for the executable
# -----------------------------------------------------------------------
include(${QT_USE_FILE})
include_directories(
${org_blueberry_osgi_INCLUDE_DIRS}
${Poco_INCLUDE_DIRS}
${mbilog_INCLUDE_DIRS}
)
link_directories(${MITK_LINK_DIRECTORIES})
# -----------------------------------------------------------------------
# Add executable icon (Windows)
# -----------------------------------------------------------------------
set(WINDOWS_ICON_RESOURCE_FILE "")
if(WIN32)
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/icons/${_APP_NAME}.rc")
set(WINDOWS_ICON_RESOURCE_FILE "${CMAKE_CURRENT_SOURCE_DIR}/icons/${_APP_NAME}.rc")
endif()
endif()
# -----------------------------------------------------------------------
# Create the executable and link libraries
# -----------------------------------------------------------------------
set(_app_compile_flags )
if(WIN32)
set(_app_compile_flags "${_app_compile_flags} -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN")
endif()
if(_APP_SHOW_CONSOLE)
add_executable(${_APP_NAME} MACOSX_BUNDLE ${_APP_SOURCES} ${WINDOWS_ICON_RESOURCE_FILE})
else()
add_executable(${_APP_NAME} MACOSX_BUNDLE WIN32 ${_APP_SOURCES} ${WINDOWS_ICON_RESOURCE_FILE})
endif()
set_target_properties(${_APP_NAME} PROPERTIES
COMPILE_FLAGS "${_app_compile_flags}")
target_link_libraries(${_APP_NAME} org_blueberry_osgi ${_APP_LINK_LIBRARIES})
if(WIN32)
target_link_libraries(${_APP_NAME} ${QT_QTCORE_LIBRARY} ${QT_QTMAIN_LIBRARY})
endif()
# -----------------------------------------------------------------------
# Add executable icon (Mac)
# -----------------------------------------------------------------------
if(APPLE)
- if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/icons/icon.icns")
- set_target_properties(${_APP_NAME} PROPERTIES MACOSX_BUNDLE_ICON_FILE "${CMAKE_CURRENT_SOURCE_DIR}/icons/icon.icns")
- file(COPY ${MACOSX_BUNDLE_ICON_FILE} DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.app/Contents/Resources/")
- file(INSTALL ${MACOSX_BUNDLE_ICON_FILE} DESTINATION "${_APP_NAME}.app/Contents/Resources/")
+ set(icon_name "icon.icns")
+ set(icon_full_path "${CMAKE_CURRENT_SOURCE_DIR}/icons/${icon_name}")
+ if(EXISTS "${icon_full_path}")
+ set_target_properties(${_APP_NAME} PROPERTIES MACOSX_BUNDLE_ICON_FILE "${icon_name}")
+ file(COPY ${icon_full_path} DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.app/Contents/Resources/")
+ INSTALL (FILES ${icon_full_path} DESTINATION "${_APP_NAME}.app/Contents/Resources/")
endif()
endif()
# -----------------------------------------------------------------------
# Set build time dependencies
# -----------------------------------------------------------------------
# This ensures that all enabled plug-ins are up-to-date when the
# executable is build.
if(_APP_PLUGINS)
ctkMacroGetAllProjectTargetLibraries("${_APP_PLUGINS}" _project_plugins)
if(_APP_EXCLUDE_PLUGINS)
set(_exclude_targets)
foreach(_exclude_plugin ${_APP_EXCLUDE_PLUGINS})
string(REPLACE "." "_" _exclude_target ${_exclude_plugin})
list(APPEND _exclude_targets ${_exclude_target})
endforeach()
list(REMOVE_ITEM _project_plugins ${_exclude_targets})
endif()
if(_project_plugins)
add_dependencies(${_APP_NAME} ${_project_plugins})
endif()
endif()
# -----------------------------------------------------------------------
# Additional files needed for the executable
# -----------------------------------------------------------------------
if(NOT _APP_NO_PROVISIONING)
# Create a provisioning file, listing all plug-ins
set(_prov_file "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.provisioning")
FunctionCreateProvisioningFile(FILE ${_prov_file}
PLUGINS ${_APP_PLUGINS}
EXCLUDE_PLUGINS ${_APP_EXCLUDE_PLUGINS}
)
endif()
# Create a .ini file for initial parameters
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_APP_NAME}.ini")
configure_file(${_APP_NAME}.ini
${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.ini)
endif()
# Create batch files for Windows platforms
if(WIN32)
foreach(BUILD_TYPE debug release)
mitkFunctionCreateWindowsBatchScript(start${_APP_NAME}.bat.in
${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/start${_APP_NAME}_${BUILD_TYPE}.bat
${BUILD_TYPE})
endforeach()
endif(WIN32)
# -----------------------------------------------------------------------
# Install support
# -----------------------------------------------------------------------
if(NOT _APP_NO_INSTALL)
# This installs all third-party CTK plug-ins
FunctionInstallThirdPartyCTKPlugins(${_APP_PLUGINS} EXCLUDE ${_APP_EXCLUDE_PLUGINS})
if(COMMAND BlueBerryApplicationInstallHook)
set(_real_app_plugins ${_APP_PLUGINS})
if(_APP_EXCLUDE_PLUGINS)
list(REMOVE_ITEM _real_app_plugins ${_APP_EXCLUDE_PLUGINS})
endif()
BlueBerryApplicationInstallHook(APP_NAME ${_APP_NAME} PLUGINS ${_real_app_plugins})
endif()
# Install the executable
MITK_INSTALL_TARGETS(EXECUTABLES ${_APP_NAME} LIBRARY_DIRS ${_APP_LIBRARY_DIRS} GLOB_PLUGINS )
if(NOT _APP_NO_PROVISIONING)
# Install the provisioning file
mitkFunctionInstallProvisioningFiles(${_prov_file})
endif()
# On Linux, create a shell script to start a relocatable application
if(UNIX AND NOT APPLE)
install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME ${_APP_NAME}.sh)
endif()
# Tell cpack the executables that you want in the start menu as links
set(MITK_CPACK_PACKAGE_EXECUTABLES ${MITK_CPACK_PACKAGE_EXECUTABLES} "${_APP_NAME};${_APP_DESCRIPTION}" CACHE INTERNAL "Collecting windows shortcuts to executables")
endif()
endfunction()
diff --git a/BlueBerry/CMakeLists.txt b/BlueBerry/CMakeLists.txt
index fbd75a0416..a28dbb6ed6 100644
--- a/BlueBerry/CMakeLists.txt
+++ b/BlueBerry/CMakeLists.txt
@@ -1,280 +1,280 @@
project(BlueBerry)
-cmake_minimum_required(VERSION 2.8.4)
+cmake_minimum_required(VERSION 2.8.5)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMake/")
include(MacroParseArguments)
include(MacroConvertSchema)
include(MacroOrganizeSources)
include(MacroCreateCTKPlugin)
include(MacroCreateQtHelp)
include(MacroInstallCTKPlugin)
include(FunctionCreateProvisioningFile)
if(MSVC)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4250 /wd4275 /wd4251 /wd4503")
endif()
if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
endif()
find_package(mbilog REQUIRED)
include_directories(${mbilog_INCLUDE_DIRS})
find_package(Qt4 4.6.2 REQUIRED)
if(QT_QMAKE_CHANGED)
set(QT_HELPGENERATOR_EXECUTABLE NOTFOUND)
set(QT_COLLECTIONGENERATOR_EXECUTABLE NOTFOUND)
set(QT_ASSISTANT_EXECUTABLE NOTFOUND)
set(QT_XMLPATTERNS_EXECUTABLE NOTFOUND)
endif()
find_program(QT_HELPGENERATOR_EXECUTABLE
NAMES qhelpgenerator qhelpgenerator-qt4 qhelpgenerator4
PATHS ${QT_BINARY_DIR}
NO_DEFAULT_PATH
)
find_program(QT_COLLECTIONGENERATOR_EXECUTABLE
NAMES qcollectiongenerator qcollectiongenerator-qt4 qcollectiongenerator4
PATHS ${QT_BINARY_DIR}
NO_DEFAULT_PATH
)
find_program(QT_ASSISTANT_EXECUTABLE
NAMES assistant-qt4 assistant4 assistant
PATHS ${QT_BINARY_DIR}
NO_DEFAULT_PATH
)
find_program(QT_XMLPATTERNS_EXECUTABLE
NAMES xmlpatterns
PATHS ${QT_BINARY_DIR}
NO_DEFAULT_PATH
)
option(BLUEBERRY_USE_QT_HELP "Enable support for integrating bundle documentation into Qt Help" ON)
mark_as_advanced(BLUEBERRY_USE_QT_HELP
QT_HELPGENERATOR_EXECUTABLE
QT_COLLECTIONGENERATOR_EXECUTABLE
QT_ASSISTANT_EXECUTABLE
QT_XMLPATTERNS_EXECUTABLE)
set(_doxygen_too_old 1)
if(BLUEBERRY_USE_QT_HELP)
find_package(Doxygen)
if(DOXYGEN_FOUND)
execute_process(COMMAND ${DOXYGEN_EXECUTABLE} --version
OUTPUT_VARIABLE _doxygen_version)
if(${_doxygen_version} VERSION_GREATER 1.6.0 OR
${_doxygen_version} VERSION_EQUAL 1.6.0)
set(_doxygen_too_old 0)
endif()
endif()
if(_doxygen_too_old)
message("Doxygen was not found or is too old. Version 1.6.0 or later is needed if BLUEBERRY_USE_QT_HELP is ON")
set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
endif()
if(NOT QT_HELPGENERATOR_EXECUTABLE)
message("You have enabled Qt Help support, but QT_HELPGENERATOR_EXECUTABLE is empty")
set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
endif()
if(NOT QT_XMLPATTERNS_EXECUTABLE)
message("You have enabled Qt Help support, but QT_XMLPATTERNS_EXECUTABLE is empty")
set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
endif()
endif(BLUEBERRY_USE_QT_HELP)
include(${QT_USE_FILE})
# ========= CTK specific CMake stuff ============
cmake_policy(SET CMP0012 NEW)
find_package(CTK REQUIRED)
# Extract all library names starting with org_blueberry_
macro(GetMyTargetLibraries all_target_libraries varname)
set(re_ctkplugin "^org_blueberry_[a-zA-Z0-9_]+$")
set(_tmp_list)
list(APPEND _tmp_list ${all_target_libraries})
ctkMacroListFilter(_tmp_list re_ctkplugin OUTPUT_VARIABLE ${varname})
endmacro()
# ================================================
option(BLUEBERRY_BUILD_ALL_PLUGINS "Build all BlueBerry plugins (overriding selection)" OFF)
mark_as_advanced(BLUEBERRY_BUILD_ALL_PLUGINS)
if(BLUEBERRY_BUILD_ALL_PLUGINS)
set(BLUEBERRY_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
endif()
option(BLUEBERRY_STATIC "Build all plugins as static libraries" OFF)
mark_as_advanced(BLUEBERRY_STATIC)
option(BLUEBERRY_DEBUG_SMARTPOINTER "Enable code for debugging smart pointers" OFF)
mark_as_advanced(BLUEBERRY_DEBUG_SMARTPOINTER)
find_package(Poco REQUIRED)
find_package(Ant)
find_package(Eclipse)
set(BLUEBERRY_SOURCE_DIR ${BlueBerry_SOURCE_DIR})
set(BLUEBERRY_BINARY_DIR ${BlueBerry_BINARY_DIR})
set(BLUEBERRY_PLUGINS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Bundles)
set(BLUEBERRY_PLUGINS_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Bundles)
set(OSGI_APP solstice)
set(OSGI_UI_APP solstice_ui)
if(Eclipse_DIR)
set(BLUEBERRY_DOC_TOOLS_DIR "${Eclipse_DIR}" CACHE PATH "Directory containing additional tools needed for generating the documentation")
else()
set(BLUEBERRY_DOC_TOOLS_DIR "" CACHE PATH "Directory containing additional tools needed for generating the documentation")
endif()
set(BLUEBERRY_DEBUG_POSTFIX d)
# Testing options
if(DEFINED BLUEBERRY_BUILD_TESTING)
option(BLUEBERRY_BUILD_TESTING "Build the BlueBerry tests." ${BLUEBERRY_BUILD_TESTING})
else()
option(BLUEBERRY_BUILD_TESTING "Build the BlueBerry tests." ${BUILD_TESTING})
endif()
if(WIN32)
set(_gui_testing_default "ON")
else()
set(_gui_testing_default "OFF")
endif()
option(BLUEBERRY_ENABLE_GUI_TESTING "Enable the BlueBerry GUI tests" ${_gui_testing_default})
mark_as_advanced(BLUEBERRY_ENABLE_GUI_TESTING)
if(BLUEBERRY_BUILD_TESTING)
enable_testing()
endif()
# Add CTK plugins
set(_ctk_plugins
Bundles/org.blueberry.osgi:ON
Bundles/org.blueberry.compat:OFF
Bundles/org.blueberry.core.runtime:OFF
Bundles/org.blueberry.core.expressions:OFF
Bundles/org.blueberry.solstice.common:OFF
Bundles/org.blueberry.core.commands:OFF
Bundles/org.blueberry.core.jobs:OFF
Bundles/org.blueberry.ui:OFF
Bundles/org.blueberry.ui.qt:OFF
Bundles/org.blueberry.ui.qt.help:OFF
Bundles/org.blueberry.ui.qt.log:ON
Bundles/org.blueberry.ui.qt.objectinspector:OFF
)
set(_ctk_test_plugins )
set(_ctk_plugins_include_dirs
${Poco_INCLUDE_DIRS}
)
set(_ctk_plugins_link_dirs
${Poco_LIBRARY_DIR}
)
include_directories(${_ctk_plugins_include_dirs})
link_directories(${_ctk_plugins_link_dirs})
if(BLUEBERRY_BUILD_TESTING)
include(berryTestingHelpers)
set(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}")
get_target_property(_is_macosx_bundle ${OSGI_APP} MACOSX_BUNDLE)
- if(APPLE AND _is_macosx_bundle)
+ if(APPLE AND _is_macosx_bundle)
set(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}.app/Contents/MacOS/${OSGI_APP}")
endif()
set(_ctk_testinfrastructure_plugins
Bundles/org.blueberry.test:ON
Bundles/org.blueberry.uitest:ON
)
set(_ctk_test_plugins
# Testing/org.blueberry.core.runtime.tests:ON
# Testing/org.blueberry.osgi.tests:ON
)
-
+
if(BLUEBERRY_ENABLE_GUI_TESTING)
# list(APPEND _ctk_test_plugins Testing/org.blueberry.ui.tests:ON)
set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_UI_APP}")
get_target_property(_is_macosx_bundle ${OSGI_UI_APP} MACOSX_BUNDLE)
if(APPLE AND _is_macosx_bundle)
set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_UI_APP}.app/Contents/MacOS/${OSGI_UI_APP}")
endif()
endif()
endif()
set(BLUEBERRY_TESTING_PROVISIONING_FILE "${BlueBerry_BINARY_DIR}/BlueBerryTesting.provisioning")
add_custom_target(BlueBerry)
ctkMacroSetupPlugins(${_ctk_plugins} ${_ctk_testinfrastructure_plugins} ${_ctk_test_plugins}
BUILD_OPTION_PREFIX BLUEBERRY_BUILD_
BUILD_ALL ${BLUEBERRY_BUILD_ALL_PLUGINS}
COMPACT_OPTIONS)
set(BLUEBERRY_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/BlueBerry.provisioning")
FunctionCreateProvisioningFile(
FILE ${BLUEBERRY_PROVISIONING_FILE}
PLUGINS ${_ctk_plugins}
)
FunctionCreateProvisioningFile(
FILE ${BLUEBERRY_TESTING_PROVISIONING_FILE}
INCLUDE ${BLUEBERRY_PROVISIONING_FILE}
PLUGINS ${_ctk_testinfrastructure_plugins} ${_ctk_test_plugins}
)
if(${CMAKE_PROJECT_NAME}_PLUGIN_LIBRARIES)
add_dependencies(BlueBerry ${${CMAKE_PROJECT_NAME}_PLUGIN_LIBRARIES})
endif()
set_property(TARGET ${${CMAKE_PROJECT_NAME}_PLUGIN_LIBRARIES} PROPERTY LABELS BlueBerry)
set(BB_PLUGIN_USE_FILE "${BlueBerry_BINARY_DIR}/BlueBerryPluginUseFile.cmake")
if(${PROJECT_NAME}_PLUGIN_LIBRARIES)
ctkFunctionGeneratePluginUseFile(${BB_PLUGIN_USE_FILE})
else()
file(REMOVE ${BB_PLUGIN_USE_FILE})
set(BB_PLUGIN_USE_FILE )
endif()
# CTK Plugin Exports
set(BB_PLUGIN_EXPORTS_FILE "${CMAKE_CURRENT_BINARY_DIR}/BlueBerryPluginExports.cmake")
GetMyTargetLibraries("${${PROJECT_NAME}_PLUGIN_LIBRARIES}" my_plugin_targets)
set(additional_export_targets mbilog PocoFoundation PocoUtil PocoXML)
if(BLUEBERRY_BUILD_TESTING)
list(APPEND additional_export_targets CppUnit)
endif()
export(TARGETS ${my_plugin_targets} ${additional_export_targets}
FILE ${BB_PLUGIN_EXPORTS_FILE})
add_subdirectory(Documentation)
set(BLUEBERRY_QTPLUGIN_PATH )
if(CTK_QTDESIGNERPLUGINS_DIR AND EXISTS ${CTK_QTDESIGNERPLUGINS_DIR})
set(BLUEBERRY_QTPLUGIN_PATH "${CTK_QTDESIGNERPLUGINS_DIR}")
endif()
configure_file(BlueBerryConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/BlueBerryConfig.cmake @ONLY)
diff --git a/CMake/MITKDashboardScript.TEMPLATE.cmake b/CMake/MITKDashboardScript.TEMPLATE.cmake
index e9ba8db825..be4f350417 100644
--- a/CMake/MITKDashboardScript.TEMPLATE.cmake
+++ b/CMake/MITKDashboardScript.TEMPLATE.cmake
@@ -1,145 +1,145 @@
#
# OS: Ubuntu 9.04 2.6.28-18-generic
# Hardware: x86_64 GNU/Linux
# GPU: NA
#
# Note: The specific version and processor type of this machine should be reported in the
# header above. Indeed, this file will be send to the dashboard as a NOTE file.
-cmake_minimum_required(VERSION 2.8.4)
+cmake_minimum_required(VERSION 2.8.5)
#
# Dashboard properties
#
set(MY_COMPILER "gcc-4.4.5")
# For Windows, e.g.
#set(MY_COMPILER "VC9.0")
set(CTEST_CMAKE_COMMAND "/usr/bin/cmake")
set(CTEST_CMAKE_GENERATOR "Unix Makefiles")
set(CTEST_DASHBOARD_ROOT "/opt/dartclients")
# For Windows, e.g.
#set(CTEST_CMAKE_COMMAND "cmake")
#set(CTEST_CMAKE_GENERATOR "Visual Studio 9 2008 Win64")
#set(CTEST_DASHBOARD_ROOT "C:/dartclients")
# The directory containing the Qt binaries
set(QT_BINARY_DIR "/usr/bin/")
# For Windows, e.g.
#set(QT_BINARY_DIR "V:/windows/x64/QT-4.7.0_VC9.0_Bin/bin")
#
# Dashboard options
#
set(WITH_KWSTYLE FALSE)
set(WITH_MEMCHECK FALSE)
set(WITH_COVERAGE FALSE)
set(WITH_DOCUMENTATION FALSE)
#set(DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY ) # for example: $ENV{HOME}/Projects/Doxygen
set(CTEST_BUILD_CONFIGURATION "Release")
set(CTEST_TEST_TIMEOUT 500)
if(UNIX OR MINGW)
set(CTEST_BUILD_FLAGS "-j4") # Use multiple CPU cores to build
else()
set(CTEST_BUILD_FLAGS "")
endif()
# experimental:
# - run_ctest() macro will be called *ONE* time
# - binary directory will *NOT* be cleaned
# continuous:
# - run_ctest() macro will be called EVERY 5 minutes ...
# - binary directory will *NOT* be cleaned
# - configure/build will be executed *ONLY* if the repository has been updated
# nightly:
# - run_ctest() macro will be called *ONE* time
# - binary directory *WILL BE* cleaned
set(SCRIPT_MODE "experimental") # "experimental", "continuous", "nightly"
#
# Project specific properties
#
# In order to shorten the global path length, the build directory for each DartClient
# uses the following abrevation sceme:
# For build configuration:
# Debug -> d
# Release -> r
# For scripte mode:
# continuous -> c
# nightly -> n
# experimental -> e
# Example directory: /MITK-sb-d-n/ for a nightly MITK superbuild in debug mode.
set(short_of_ctest_build_configuration "")
set(short_of_script_mode "")
string(SUBSTRING ${CTEST_BUILD_CONFIGURATION} 0 1 short_of_ctest_build_configuration)
string(SUBSTRING ${SCRIPT_MODE} 0 1 short_of_script_mode)
set(CTEST_SOURCE_DIRECTORY "${CTEST_DASHBOARD_ROOT}/MITK")
set(CTEST_BINARY_DIRECTORY "${CTEST_DASHBOARD_ROOT}/MITK-sb-${short_of_ctest_build_configuration}-${short_of_script_mode}")
# Create an initial cache file for MITK. This file is used to configure the MITK-Build. Use ADDITIONAL_CMAKECACHE_OPTION
# to configure the MITK-Superbuild. The
set(MITK_INITIAL_CACHE "
# Example how to set a boolean variable in the MITK-Build via this script:
#SET(MITK_ENABLE_TOF_HARDWARE \"TRUE\" CACHE INTERNAL \"Enable ToF Hardware\")
# Example how to set a path variable in the MITK-Build via this script:
#SET(MITK_PMD_LIB \"/home/kilgus/thomas/PMDSDK2/Linux_x86_64/bin/libpmdaccess2.so\" CACHE INTERNAL \"PMD lib\")
")
set(ADDITIONAL_CMAKECACHE_OPTION "
# Superbuild variables are not passed through to the MITK-Build (or any other build like ITK, VTK, ...)
# Use the MITK_INITIAL_CACHE the pass variables to the MITK-Build.
# add entries like this
#MITK_USE_OpenCV:BOOL=OFF
")
# List of test that should be explicitly disabled on this machine
set(TEST_TO_EXCLUDE_REGEX "")
# set any extra environment variables here
set(ENV{DISPLAY} ":0")
find_program(CTEST_COVERAGE_COMMAND NAMES gcov)
find_program(CTEST_MEMORYCHECK_COMMAND NAMES valgrind)
find_program(CTEST_GIT_COMMAND NAMES git)
#
# Git repository - Overwrite the default value provided by the driver script
#
# The git repository containing MITK code
#set(GIT_REPOSITORY "/home/username/MITK")
# The branch of the MITK git repository to check out
#set(GIT_BRANCH "bug-xxx-label")
##########################################
# WARNING: DO NOT EDIT BEYOND THIS POINT #
##########################################
#
# Convenient macro allowing to download a file
#
macro(downloadFile url dest)
file(DOWNLOAD "${url}" "${dest}" STATUS status)
list(GET status 0 error_code)
list(GET status 1 error_msg)
if(error_code)
message(FATAL_ERROR "error: Failed to download ${url} - ${error_msg}")
endif()
endmacro()
#
# Download and include setup script
#
if(NOT DEFINED GIT_BRANCH OR GIT_BRANCH STREQUAL "")
set(hb "HEAD")
else()
string(REGEX REPLACE "^origin/(.*)$" "\\1" _branch_name ${GIT_BRANCH})
set(hb "refs/heads/${_branch_name}")
endif()
set(url "http://mitk.org/git/?p=MITK.git;a=blob_plain;f=CMake/MITKDashboardSetup.cmake;hb=${hb}")
set(dest ${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}.setup)
downloadFile("${url}" "${dest}")
include(${dest})
diff --git a/CMake/MITKDashboardSetup.cmake b/CMake/MITKDashboardSetup.cmake
index d8ca933c66..f23ea044a9 100644
--- a/CMake/MITKDashboardSetup.cmake
+++ b/CMake/MITKDashboardSetup.cmake
@@ -1,137 +1,137 @@
# This file is intended to be included at the end of a custom MITKDashboardScript.TEMPLATE.cmake file
list(APPEND CTEST_NOTES_FILES "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
#
# Automatically determined properties
#
set(MY_OPERATING_SYSTEM "${CMAKE_HOST_SYSTEM}") # Windows 7, Linux-2.6.32, Darwin...
site_name(CTEST_SITE)
if(QT_BINARY_DIR)
set(QT_QMAKE_EXECUTABLE "${QT_BINARY_DIR}/qmake")
else()
set(QT_QMAKE_EXECUTABLE "qmake")
endif()
execute_process(COMMAND ${QT_QMAKE_EXECUTABLE} --version
OUTPUT_VARIABLE MY_QT_VERSION
RESULT_VARIABLE qmake_error)
if(qmake_error)
message(FATAL_ERROR "Error when executing ${QT_QMAKE_EXECUTABLE} --version\n${qmake_error}")
endif()
string(REGEX REPLACE ".*Qt version ([0-9.]+) .*" "\\1" MY_QT_VERSION ${MY_QT_VERSION})
#
# Project specific properties
#
if(NOT CTEST_BUILD_NAME)
set(CTEST_BUILD_NAME "${MY_OPERATING_SYSTEM}-${MY_COMPILER}-Qt-${MY_QT_VERSION}-${CTEST_BUILD_CONFIGURATION}")
endif()
set(PROJECT_BUILD_DIR "MITK-build")
set(CTEST_PATH "$ENV{PATH}")
if(WIN32)
set(VTK_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/VTK-build/bin/${CTEST_BUILD_CONFIGURATION}")
set(ITK_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/ITK-build/bin/${CTEST_BUILD_CONFIGURATION}")
set(BOOST_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/Boost-src/stage/lib")
set(GDCM_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/GDCM-build/bin/${CTEST_BUILD_CONFIGURATION}")
set(OPENCV_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/OpenCV-build/bin/${CTEST_BUILD_CONFIGURATION}")
set(SOFA_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/SOFA-build/bin/${CTEST_BUILD_CONFIGURATION}")
set(BLUEBERRY_OSGI_DIR "${CTEST_BINARY_DIRECTORY}/MITK-build/bin/BlueBerry/org.blueberry.osgi/bin/${CTEST_BUILD_CONFIGURATION}")
- set(CTEST_PATH "${CTEST_PATH};${QT_BINARY_DIR};${VTK_BINARY_DIR};${ITK_BINARY_DIR};${BOOST_BINARY_DIR};${GDCM_BINARY_DIR};${OPENCV_BINARY_DIR};${BLUEBERRY_OSGI_DIR}")
+ set(CTEST_PATH "${CTEST_PATH};${QT_BINARY_DIR};${VTK_BINARY_DIR};${ITK_BINARY_DIR};${BOOST_BINARY_DIR};${GDCM_BINARY_DIR};${OPENCV_BINARY_DIR};${SOFA_BINARY_DIR};${BLUEBERRY_OSGI_DIR}")
endif()
set(ENV{PATH} "${CTEST_PATH}")
set(SUPERBUILD_TARGETS "")
# If the dashscript doesn't define a GIT_REPOSITORY variable, let's define it here.
if(NOT DEFINED GIT_REPOSITORY OR GIT_REPOSITORY STREQUAL "")
set(GIT_REPOSITORY "http://git.mitk.org/MITK.git")
endif()
#
# Display build info
#
message("Site name: ${CTEST_SITE}")
message("Build name: ${CTEST_BUILD_NAME}")
message("Script Mode: ${SCRIPT_MODE}")
message("Coverage: ${WITH_COVERAGE}, MemCheck: ${WITH_MEMCHECK}")
#
# Set initial cache options
#
if(CMAKE_GENERATOR MATCHES "[Mm]ake")
set(CTEST_USE_LAUNCHERS 1)
else()
set(CTEST_USE_LAUNCHERS 0)
endif()
# Remove this if block after all dartclients work
if(DEFINED ADDITIONNAL_CMAKECACHE_OPTION)
message(WARNING "Rename ADDITIONNAL to ADDITIONAL in your dartlclient script: ${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
set(ADDITIONAL_CMAKECACHE_OPTION ${ADDITIONNAL_CMAKECACHE_OPTION})
endif()
if(NOT DEFINED MITK_USE_Boost)
set(MITK_USE_Boost 1)
endif()
if(NOT DEFINED MITK_USE_OpenCV)
set(MITK_USE_OpenCV 1)
endif()
if(NOT DEFINED MITK_USE_SOFA)
set(MITK_USE_SOFA 1)
endif()
if(NOT DEFINED MITK_BUILD_ALL_APPS)
set(MITK_BUILD_ALL_APPS TRUE)
endif()
if(NOT DEFINED BLUEBERRY_BUILD_ALL_PLUGINS)
set(BLUEBERRY_BUILD_ALL_PLUGINS TRUE)
endif()
if(NOT DEFINED MITK_BUILD_ALL_PLUGINS)
set(MITK_BUILD_ALL_PLUGINS TRUE)
endif()
if(NOT DEFINED MITK_BUILD_EXAMPLES)
set(MITK_BUILD_EXAMPLES TRUE)
endif()
set(INITIAL_CMAKECACHE_OPTIONS "
BLUEBERRY_BUILD_ALL_PLUGINS:BOOL=${MITK_BUILD_ALL_PLUGINS}
MITK_BUILD_ALL_PLUGINS:BOOL=${MITK_BUILD_ALL_PLUGINS}
MITK_BUILD_ALL_APPS:BOOL=${MITK_BUILD_ALL_APPS}
MITK_BUILD_EXAMPLES:BOOL=${MITK_BUILD_EXAMPLES}
SUPERBUILD_EXCLUDE_MITKBUILD_TARGET:BOOL=TRUE
MITK_USE_Boost:BOOL=${MITK_USE_Boost}
MITK_USE_OpenCV:BOOL=${MITK_USE_OpenCV}
MITK_USE_SOFA:BOOL=${MITK_USE_SOFA}
${ADDITIONAL_CMAKECACHE_OPTION}
")
# Write a cache file for populating the MITK initial cache (not the superbuild cache).
# This can be used to provide variables which are not passed through the
# superbuild process to the MITK configure step)
if(MITK_INITIAL_CACHE)
set(mitk_cache_file "${CTEST_SCRIPT_DIRECTORY}/mitk_initial_cache.txt")
file(WRITE "${mitk_cache_file}" "${MITK_INITIAL_CACHE}")
set(INITIAL_CMAKECACHE_OPTIONS "${INITIAL_CMAKECACHE_OPTIONS}
MITK_INITIAL_CACHE_FILE:INTERNAL=${mitk_cache_file}
")
endif()
#
# Download and include dashboard driver script
#
set(url "http://mitk.org/git/?p=MITK.git;a=blob_plain;f=CMake/MITKDashboardDriverScript.cmake;hb=${hb}")
set(dest ${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}.driver)
downloadFile("${url}" "${dest}")
include(${dest})
diff --git a/CMake/PackageDepends/MITK_ITK_Config.cmake b/CMake/PackageDepends/MITK_ITK_Config.cmake
index 6a855f50a0..e5fd53358f 100644
--- a/CMake/PackageDepends/MITK_ITK_Config.cmake
+++ b/CMake/PackageDepends/MITK_ITK_Config.cmake
@@ -1,19 +1,19 @@
find_package(ITK REQUIRED)
#
# for some reason this does not work on windows, probably an ITK bug
# ITK_BUILD_SHARED is OFF even in shared library builds
#
#if(ITK_FOUND AND NOT ITK_BUILD_SHARED)
# message(FATAL_ERROR "MITK only supports a ITK which was built with shared libraries. Turn on BUILD_SHARED_LIBS in your ITK config.")
#endif(ITK_FOUND AND NOT ITK_BUILD_SHARED)
+set(ITK_NO_IO_FACTORY_REGISTER_MANAGER 1)
+
include(${ITK_USE_FILE})
list(APPEND ALL_LIBRARIES ${ITK_LIBRARIES})
list(APPEND ALL_INCLUDE_DIRECTORIES ${ITK_INCLUDE_DIRS})
-if(ITK_USE_SYSTEM_GDCM)
- find_package(GDCM PATHS ${ITK_GDCM_DIR} REQUIRED)
- list(APPEND ALL_INCLUDE_DIRECTORIES ${GDCM_INCLUDE_DIRS})
- list(APPEND ALL_LIBRARIES ${GDCM_LIBRARIES})
-endif(ITK_USE_SYSTEM_GDCM)
-
+find_package(GDCM PATHS ${ITK_GDCM_DIR} REQUIRED)
+list(APPEND ALL_INCLUDE_DIRECTORIES ${GDCM_INCLUDE_DIRS})
+list(APPEND ALL_LIBRARIES ${GDCM_LIBRARIES})
+include(${GDCM_USE_FILE})
diff --git a/CMake/PackageDepends/MITK_SOFA_Config.cmake b/CMake/PackageDepends/MITK_SOFA_Config.cmake
index ef28d61b0c..98e7418cdd 100644
--- a/CMake/PackageDepends/MITK_SOFA_Config.cmake
+++ b/CMake/PackageDepends/MITK_SOFA_Config.cmake
@@ -1,4 +1,4 @@
-find_package(SOFA REQUIRED)
+find_package(SOFA REQUIRED CONFIG)
list(APPEND ALL_INCLUDE_DIRECTORIES ${SOFA_INCLUDE_DIRS})
list(APPEND ALL_LIBRARIES ${SOFA_LIBRARIES})
link_directories(${SOFA_LIBRARY_DIRS})
diff --git a/CMake/mitkMacroCreateModuleTests.cmake b/CMake/mitkMacroCreateModuleTests.cmake
index 7820e68174..e8cd18237f 100644
--- a/CMake/mitkMacroCreateModuleTests.cmake
+++ b/CMake/mitkMacroCreateModuleTests.cmake
@@ -1,90 +1,114 @@
#
# Create tests and testdriver for this module
#
# Usage: MITK_CREATE_MODULE_TESTS( [EXTRA_DRIVER_INIT init_code] )
#
# EXTRA_DRIVER_INIT is inserted as c++ code in the testdriver and will be executed before each test
#
macro(MITK_CREATE_MODULE_TESTS)
MACRO_PARSE_ARGUMENTS(MODULE_TEST
"EXTRA_DRIVER_INIT;EXTRA_DRIVER_INCLUDE;EXTRA_DEPENDS" "" ${ARGN})
if(BUILD_TESTING AND MODULE_IS_ENABLED)
set(OLD_MOC_H_FILES ${MOC_H_FILES})
set(MOC_H_FILES)
include(files.cmake)
include_directories(.)
if(DEFINED MOC_H_FILES)
QT4_WRAP_CPP(MODULE_TEST_GENERATED_MOC_CPP ${MOC_H_FILES})
endif(DEFINED MOC_H_FILES)
if (MODULE_TEST_EXTRA_DEPENDS)
MITK_USE_MODULE("${MODULE_TEST_EXTRA_DEPENDS}")
include_directories(${ALL_INCLUDE_DIRECTORIES})
endif()
set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "mitk::LoggingBackend::Register(); ${MODULE_TEST_EXTRA_DRIVER_INIT};")
set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "mitk::LoggingBackend::Unregister();")
if(NOT MODULE_TEST_EXTRA_DRIVER_INCLUDE)
# this is necessary to make the LoggingBackend calls available if nothing else is included
set(MODULE_TEST_EXTRA_DRIVER_INCLUDE "mitkLog.h")
endif(NOT MODULE_TEST_EXTRA_DRIVER_INCLUDE)
create_test_sourcelist(MODULETEST_SOURCE ${MODULE_NAME}TestDriver.cpp
- ${MODULE_TESTS} ${MODULE_IMAGE_TESTS} ${MODULE_CUSTOM_TESTS}
+ ${MODULE_TESTS} ${MODULE_IMAGE_TESTS} ${MODULE_SURFACE_TESTS} ${MODULE_CUSTOM_TESTS}
EXTRA_INCLUDE ${MODULE_TEST_EXTRA_DRIVER_INCLUDE}
)
set(TESTDRIVER ${MODULE_NAME}TestDriver)
add_executable(${TESTDRIVER} ${MODULETEST_SOURCE} ${MODULE_TEST_GENERATED_MOC_CPP} ${TEST_CPP_FILES})
target_link_libraries(${TESTDRIVER} ${MODULE_PROVIDES} ${ALL_LIBRARIES})
if(MODULE_SUBPROJECTS)
foreach(subproject ${MODULE_SUBPROJECTS})
add_dependencies(${subproject} ${TESTDRIVER})
endforeach()
endif()
#
# Now tell CMake which tests should be run. This is done automatically
# for all tests in ${KITNAME}_TESTS and ${KITNAME}_IMAGE_TESTS. The IMAGE_TESTS
# are run for each image in the TESTIMAGES list.
#
foreach( test ${MODULE_TESTS} )
get_filename_component(TName ${test} NAME_WE)
add_test(${TName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName})
# Add labels for CDash subproject support
if(MODULE_SUBPROJECTS)
set_property(TEST ${TName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
endif()
endforeach( test )
foreach(image ${MODULE_TESTIMAGES} ${ADDITIONAL_TEST_IMAGES} )
if(EXISTS ${image})
set(IMAGE_FULL_PATH ${image})
else(EXISTS ${image})
# todo: maybe search other paths as well
# yes, please in mitk/Testing/Data, too
set(IMAGE_FULL_PATH ${MITK_DATA_DIR}/${image})
endif(EXISTS ${image})
if(EXISTS ${IMAGE_FULL_PATH})
foreach( test ${MODULE_IMAGE_TESTS} )
get_filename_component(TName ${test} NAME_WE)
get_filename_component(ImageName ${IMAGE_FULL_PATH} NAME)
add_test(${TName}_${ImageName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName} ${IMAGE_FULL_PATH})
# Add labels for CDash subproject support
if(MODULE_SUBPROJECTS)
set_property(TEST ${TName}_${ImageName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
endif()
endforeach( test )
else(EXISTS ${IMAGE_FULL_PATH})
message("!!!!! No such file: ${IMAGE_FULL_PATH} !!!!!")
endif(EXISTS ${IMAGE_FULL_PATH})
endforeach( image )
+ foreach(surface ${MODULE_TESTSURFACES} ${ADDITIONAL_TEST_SURFACES} )
+ if(EXISTS ${surface})
+ set(SURFACE_FULL_PATH ${surface})
+ else(EXISTS ${surface})
+ # todo: maybe search other paths as well
+ # yes, please in mitk/Testing/Data, too
+ set(SURFACE_FULL_PATH ${MITK_DATA_DIR}/${surface})
+ endif(EXISTS ${surface})
+
+ if(EXISTS ${SURFACE_FULL_PATH})
+ foreach( test ${MODULE_SURFACE_TESTS} )
+ get_filename_component(TName ${test} NAME_WE)
+ get_filename_component(SurfaceName ${SURFACE_FULL_PATH} NAME)
+ add_test(${TName}_${SurfaceName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName} ${SURFACE_FULL_PATH})
+ # Add labels for CDash subproject support
+ if(MODULE_SUBPROJECTS)
+ set_property(TEST ${TName}_${SurfaceName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
+ endif()
+ endforeach( test )
+ else(EXISTS ${SURFACE_FULL_PATH})
+ message("!!!!! No such surface file: ${SURFACE_FULL_PATH} !!!!!")
+ endif(EXISTS ${SURFACE_FULL_PATH})
+ endforeach( surface )
+
set(MOC_H_FILES ${OLD_MOC_H_FILES})
endif(BUILD_TESTING AND MODULE_IS_ENABLED)
endmacro(MITK_CREATE_MODULE_TESTS)
diff --git a/CMake/mitkMacroInstallHelperApp.cmake b/CMake/mitkMacroInstallHelperApp.cmake
index 9ed4a5410a..1b4ae4ff2c 100644
--- a/CMake/mitkMacroInstallHelperApp.cmake
+++ b/CMake/mitkMacroInstallHelperApp.cmake
@@ -1,116 +1,116 @@
#! MITK specific cross plattform install macro
#!
#! Usage: MITK_INSTALL_HELPER_APP(target1 [target2] ....)
#!
macro(MITK_INSTALL_HELPER_APP)
MACRO_PARSE_ARGUMENTS(_install "TARGETS;EXECUTABLES;PLUGINS;LIBRARY_DIRS" "GLOB_PLUGINS" ${ARGN})
list(APPEND _install_TARGETS ${_install_DEFAULT_ARGS})
# TODO: how to supply to correct intermediate directory??
# CMAKE_CFG_INTDIR is not expanded to actual values inside the install(CODE "...") macro ...
set(intermediate_dir )
if(WIN32 AND NOT MINGW)
set(intermediate_dir Release)
endif()
set(DIRS
${VTK_RUNTIME_LIBRARY_DIRS}/${intermediate_dir}
- ${ITK_LIBRARY_DIRS}/${intermediate_dir}
+ ${ITK_DIR}/bin/${intermediate_dir}
${QT_LIBRARY_DIR}
${QT_LIBRARY_DIR}/../bin
${MITK_BINARY_DIR}/bin/${intermediate_dir}
${_install_LIBRARY_DIRS}
)
if(APPLE)
list(APPEND DIRS "/usr/lib")
endif(APPLE)
if(QT_LIBRARY_DIR MATCHES "^(/lib/|/lib32/|/lib64/|/usr/lib/|/usr/lib32/|/usr/lib64/|/usr/X11R6/)")
set(_qt_is_system_qt 1)
endif()
foreach(_target ${_install_EXECUTABLES})
set(_qt_plugins_install_dirs "")
set(_qt_conf_install_dirs "")
set(_target_locations "")
get_filename_component(_target_name ${_target} NAME)
if(APPLE)
if(NOT MACOSX_BUNDLE_NAMES)
set(_qt_conf_install_dirs bin)
set(_target_locations bin/${_target_name})
set(${_target_locations}_qt_plugins_install_dir bin)
install(PROGRAMS ${_target} DESTINATION bin)
else()
foreach(bundle_name ${MACOSX_BUNDLE_NAMES})
list(APPEND _qt_conf_install_dirs ${bundle_name}.app/Contents/Resources)
set(_current_target_location ${bundle_name}.app/Contents/MacOS/${_target_name})
list(APPEND _target_locations ${_current_target_location})
set(${_current_target_location}_qt_plugins_install_dir ${bundle_name}.app/Contents/MacOS)
install(PROGRAMS ${_target} DESTINATION ${bundle_name}.app/Contents/MacOS/)
endforeach()
endif(NOT MACOSX_BUNDLE_NAMES)
else()
set(_target_locations bin/${_target_name})
set(${_target_locations}_qt_plugins_install_dir bin)
set(_qt_conf_install_dirs bin)
install(PROGRAMS ${_target} DESTINATION bin)
if(UNIX AND NOT WIN32)
# Remove the rpath from helper applications. We assume that all dependencies
# are installed into the same location as the helper application.
install(CODE "file(RPATH_REMOVE
FILE \"\${CMAKE_INSTALL_PREFIX}/${_target_location}\")")
endif()
endif()
foreach(_target_location ${_target_locations})
if(NOT _qt_is_system_qt)
if(QT_PLUGINS_DIR)
if(WIN32)
install(DIRECTORY "${QT_PLUGINS_DIR}"
DESTINATION ${${_target_location}_qt_plugins_install_dir}
CONFIGURATIONS Release
FILES_MATCHING REGEX "[^4d]4?${CMAKE_SHARED_LIBRARY_SUFFIX}"
)
install(DIRECTORY "${QT_PLUGINS_DIR}"
DESTINATION ${${_target_location}_qt_plugins_install_dir}
CONFIGURATIONS Debug
FILES_MATCHING REGEX "d4?${CMAKE_SHARED_LIBRARY_SUFFIX}"
)
else(WIN32)
# install everything, see bug 7143
install(DIRECTORY "${QT_PLUGINS_DIR}"
DESTINATION ${${_target_location}_qt_plugins_install_dir}
FILES_MATCHING REGEX "${CMAKE_SHARED_LIBRARY_SUFFIX}"
)
endif(WIN32)
endif()
endif()
_fixup_target()
endforeach(_target_location)
if(NOT _qt_is_system_qt)
#--------------------------------------------------------------------------------
# install a qt.conf file
# this inserts some cmake code into the install script to write the file
set(_qt_conf_plugin_install_prefix .)
if(APPLE)
set(_qt_conf_plugin_install_prefix ./MacOS)
endif()
foreach(_qt_conf_install_dir ${_qt_conf_install_dirs})
install(CODE "file(WRITE \"\${CMAKE_INSTALL_PREFIX}/${_qt_conf_install_dir}/qt.conf\" \"
[Paths]
Prefix=${_qt_conf_plugin_install_prefix}
\")")
endforeach()
endif()
endforeach()
endmacro(MITK_INSTALL_HELPER_APP)
diff --git a/CMake/mitkSetupVariables.cmake b/CMake/mitkSetupVariables.cmake
index 111d6ffbc8..710238afe7 100644
--- a/CMake/mitkSetupVariables.cmake
+++ b/CMake/mitkSetupVariables.cmake
@@ -1,169 +1,169 @@
if(MITK_BUILD_ALL_PLUGINS)
set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
endif()
set(LIBPOSTFIX "")
# MITK_VERSION
set(MITK_VERSION_MAJOR "2013")
set(MITK_VERSION_MINOR "03")
-set(MITK_VERSION_PATCH "02")
+set(MITK_VERSION_PATCH "99")
set(MITK_VERSION_STRING "${MITK_VERSION_MAJOR}.${MITK_VERSION_MINOR}.${MITK_VERSION_PATCH}")
if(MITK_VERSION_PATCH STREQUAL "99")
set(MITK_VERSION_STRING "${MITK_VERSION_STRING}-${MITK_REVISION_SHORTID}")
endif()
# Needed early on for redirecting the BlueBerry documentation output dir
set(MITK_DOXYGEN_OUTPUT_DIR ${PROJECT_BINARY_DIR}/Documentation/Doxygen CACHE PATH
"Output directory for doxygen generated documentation." )
#-----------------------------------
# Configuration of module system
#-----------------------------------
set(MODULES_CONF_DIRNAME modulesConf)
set(MODULES_CONF_DIRS ${MITK_BINARY_DIR}/${MODULES_CONF_DIRNAME})
if(NOT UNIX AND NOT MINGW)
set(MITK_WIN32_FORCE_STATIC "STATIC" CACHE INTERNAL "Use this variable to always build static libraries on non-unix platforms")
endif()
# build the MITK_INCLUDE_DIRS variable
set(MITK_INCLUDE_DIRS
${ITK_INCLUDE_DIRS}
${VTK_INCLUDE_DIRS}
${PROJECT_BINARY_DIR} # contains mitkConfig.h and similar files
${MODULES_CONF_DIRS} # contains module *Exports.h files
)
set(CORE_DIRECTORIES Common DataManagement Algorithms IO Rendering Interactions Controllers Service)
foreach(d ${CORE_DIRECTORIES})
list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/Core/Code/${d})
endforeach()
#list(APPEND MITK_INCLUDE_DIRS
#${ITK_INCLUDE_DIRS}
#${VTK_INCLUDE_DIRS}
# )
foreach(d Utilities Utilities/ipPic Utilities/pic2vtk Utilities/tinyxml Utilities/mbilog)
list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/${d})
endforeach()
list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/Utilities/mbilog)
if(WIN32)
list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipPic/win32)
endif()
# additional include dirs variables
set(ANN_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ann/include)
set(IPSEGMENTATION_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipSegmentation)
# variables containing librariy names
set(MITK_CORE_LIBRARIES Mitk)
set(VTK_FOR_MITK_LIBRARIES
vtkGraphics
vtkCommon
vtkFiltering
vtkGraphics
vtkHybrid
vtkImaging
vtkIO
vtkParallel
vtkRendering
vtkVolumeRendering
vtkWidgets
${VTK_JPEG_LIBRARIES}
${VTK_PNG_LIBRARIES}
${VTK_ZLIB_LIBRARIES}
${VTK_EXPAT_LIBRARIES}
${VTK_FREETYPE_LIBRARIES}
)
# TODO: maybe solve this with lib depends mechanism of CMake
set(UTIL_FOR_MITK_LIBRARIES mitkIpPic mitkIpFunc mbilog)
set(LIBRARIES_FOR_MITK_CORE
${UTIL_FOR_MITK_LIBRARIES}
${VTK_FOR_MITK_LIBRARIES}
${ITK_LIBRARIES}
)
set(MITK_LIBRARIES
${MITK_CORE_LIBRARIES}
${LIBRARIES_FOR_MITK_CORE}
pic2vtk
ipSegmentation
ann
)
# variables used in CMake macros which are called from external projects
set(MITK_VTK_LIBRARY_DIRS ${VTK_LIBRARY_DIRS})
-set(MITK_ITK_LIBRARY_DIRS ${ITK_LIBRARY_DIRS})
+set(MITK_ITK_LIBRARY_DIRS ${ITK_DIR}/bin)
# variables containing link directories
set(MITK_LIBRARY_DIRS ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
set(MITK_LINK_DIRECTORIES
${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
- ${ITK_LIBRARY_DIRS}
+ ${ITK_DIR}/bin
${VTK_LIBRARY_DIRS}
${GDCM_LIBRARY_DIRS})
# Qt support
if(MITK_USE_QT)
find_package(Qt4 REQUIRED)
set(QMITK_INCLUDE_DIRS
${MITK_INCLUDE_DIRS}
${CMAKE_CURRENT_SOURCE_DIR}/Modules/Qmitk
${PROJECT_BINARY_DIR}/Modules/Qmitk
)
set(QMITK_LIBRARIES Qmitk ${MITK_LIBRARIES})
set(QMITK_LINK_DIRECTORIES ${MITK_LINK_DIRECTORIES})
endif()
if(MITK_BUILD_ALL_PLUGINS)
set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
endif()
# create a list of types for template instantiations of itk image access functions
function(_create_type_seq TYPES seq_var seqdim_var)
set(_seq )
set(_seq_dim )
string(REPLACE "," ";" _pixeltypes "${TYPES}")
foreach(_pixeltype ${_pixeltypes})
set(_seq "${_seq}(${_pixeltype})")
set(_seq_dim "${_seq_dim}((${_pixeltype},dim))")
endforeach()
set(${seq_var} "${_seq}" PARENT_SCOPE)
set(${seqdim_var} "${_seq_dim}" PARENT_SCOPE)
endfunction()
set(MITK_ACCESSBYITK_PIXEL_TYPES )
set(MITK_ACCESSBYITK_PIXEL_TYPES_SEQ )
set(MITK_ACCESSBYITK_TYPES_DIMN_SEQ )
# concatenate only the simple pixel types to the MITK_ACCESSBYITK_PIXEL_TYPE_SEQ list
# see Bug 12682 for detailed information
foreach(_type INTEGRAL FLOATING)
set(_typelist "${MITK_ACCESSBYITK_${_type}_PIXEL_TYPES}")
if(_typelist)
if(MITK_ACCESSBYITK_PIXEL_TYPES)
set(MITK_ACCESSBYITK_PIXEL_TYPES "${MITK_ACCESSBYITK_PIXEL_TYPES},${_typelist}")
else()
set(MITK_ACCESSBYITK_PIXEL_TYPES "${_typelist}")
endif()
endif()
_create_type_seq("${_typelist}"
MITK_ACCESSBYITK_${_type}_PIXEL_TYPES_SEQ
MITK_ACCESSBYITK_${_type}_TYPES_DIMN_SEQ)
set(MITK_ACCESSBYITK_PIXEL_TYPES_SEQ "${MITK_ACCESSBYITK_PIXEL_TYPES_SEQ}${MITK_ACCESSBYITK_${_type}_PIXEL_TYPES_SEQ}")
set(MITK_ACCESSBYITK_TYPES_DIMN_SEQ "${MITK_ACCESSBYITK_TYPES_DIMN_SEQ}${MITK_ACCESSBYITK_${_type}_TYPES_DIMN_SEQ}")
endforeach()
# separate processing of the COMPOSITE list to avoid its concatenation to to global list
_create_type_seq(${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ
MITK_ACCESSBYITK_COMPOSITE_TYPES_DIMN_SEQ)
set(MITK_ACCESSBYITK_DIMENSIONS_SEQ )
string(REPLACE "," ";" _dimensions "${MITK_ACCESSBYITK_DIMENSIONS}")
foreach(_dimension ${_dimensions})
set(MITK_ACCESSBYITK_DIMENSIONS_SEQ "${MITK_ACCESSBYITK_DIMENSIONS_SEQ}(${_dimension})")
endforeach()
diff --git a/CMakeExternals/CTK.cmake b/CMakeExternals/CTK.cmake
index 2ed5c14fb8..57cd030b92 100644
--- a/CMakeExternals/CTK.cmake
+++ b/CMakeExternals/CTK.cmake
@@ -1,83 +1,92 @@
#-----------------------------------------------------------------------------
# CTK
#-----------------------------------------------------------------------------
if(MITK_USE_CTK)
# Sanity checks
if(DEFINED CTK_DIR AND NOT EXISTS ${CTK_DIR})
message(FATAL_ERROR "CTK_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj CTK)
set(proj_DEPENDENCIES )
set(CTK_DEPENDS ${proj})
if(NOT DEFINED CTK_DIR)
- set(revision_tag fef76cef)
+ set(revision_tag 71c756a3)
#IF(${proj}_REVISION_TAG)
# SET(revision_tag ${${proj}_REVISION_TAG})
#ENDIF()
set(ctk_optional_cache_args )
if(MITK_USE_Python)
list(APPEND ctk_optional_cache_args
-DCTK_LIB_Scripting/Python/Widgets:BOOL=ON
-DCTK_ENABLE_Python_Wrapping:BOOL=ON
-DCTK_APP_ctkSimplePythonShell:BOOL=ON
+ -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
+ -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
+ -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
+ )
+ else()
+ list(APPEND ctk_optional_cache_args
+ -DCTK_LIB_Scripting/Python/Widgets:BOOL=OFF
+ -DCTK_ENABLE_Python_Wrapping:BOOL=OFF
+ -DCTK_APP_ctkSimplePythonShell:BOOL=OFF
)
endif()
if(MITK_USE_DCMTK)
list(APPEND ctk_optional_cache_args
-DDCMTK_DIR:PATH=${DCMTK_DIR}
)
list(APPEND proj_DEPENDENCIES DCMTK)
else()
list(APPEND ctk_optional_cache_args
-DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz
)
endif()
FOREACH(type RUNTIME ARCHIVE LIBRARY)
IF(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
LIST(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
ENDIF()
ENDFOREACH()
ExternalProject_Add(${proj}
SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
BINARY_DIR ${proj}-build
PREFIX ${proj}-cmake
URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_${revision_tag}.tar.gz
- URL_MD5 4d001d855cc3f722827a6cd95bfb7d9c
+ URL_MD5 25c219f2d881119312b8cd699b385259
UPDATE_COMMAND ""
INSTALL_COMMAND ""
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
${ctk_optional_cache_args}
-DDESIRED_QT_VERSION:STRING=4
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-DGit_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
-DGIT_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
-DCTK_LIB_CommandLineModules/Backend/LocalProcess:BOOL=ON
-DCTK_LIB_CommandLineModules/Frontend/QtGui:BOOL=ON
-DCTK_LIB_PluginFramework:BOOL=ON
-DCTK_LIB_DICOM/Widgets:BOOL=ON
-DCTK_PLUGIN_org.commontk.eventadmin:BOOL=ON
-DCTK_PLUGIN_org.commontk.configadmin:BOOL=ON
-DCTK_USE_GIT_PROTOCOL:BOOL=OFF
-DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz
DEPENDS ${proj_DEPENDENCIES}
)
set(CTK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
endif()
diff --git a/CMakeExternals/CableSwig.cmake b/CMakeExternals/CableSwig.cmake
index 759243ff91..73cc64f959 100644
--- a/CMakeExternals/CableSwig.cmake
+++ b/CMakeExternals/CableSwig.cmake
@@ -1,44 +1,44 @@
#-----------------------------------------------------------------------------
# CableSwig
#-----------------------------------------------------------------------------
if(MITK_USE_Python)
# Sanity checks
if(DEFINED CableSwig_DIR AND NOT EXISTS ${CableSwig_DIR})
message(FATAL_ERROR "CableSwig_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj CableSwig)
set(proj_DEPENDENCIES )
set(CableSwig_DEPENDS ${proj})
if(NOT DEFINED CableSwig_DIR)
set(additional_cmake_args )
ExternalProject_Add(${proj}
SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
BINARY_DIR ${proj}-build
PREFIX ${proj}-cmake
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CableSwig-ITK-3.20.0.tar.gz
+ URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CableSwig-ITK-3.20.0-v2.tar.gz
URL_MD5 893882bf8b4fbfbae3fe8c747a75f7a0
INSTALL_COMMAND ""
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
${additional_cmake_args}
-DBUILD_TESTING:BOOL=OFF
-DSWIG_BUILD_EXAMPLES:BOOL=OFF
DEPENDS ${proj_DEPENDENCIES}
)
set(CableSwig_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
endif()
diff --git a/CMakeExternals/GDCM.cmake b/CMakeExternals/GDCM.cmake
index f2d92b65a6..030e5653e3 100644
--- a/CMakeExternals/GDCM.cmake
+++ b/CMakeExternals/GDCM.cmake
@@ -1,58 +1,47 @@
#-----------------------------------------------------------------------------
# GDCM
#-----------------------------------------------------------------------------
# Sanity checks
if(DEFINED GDCM_DIR AND NOT EXISTS ${GDCM_DIR})
message(FATAL_ERROR "GDCM_DIR variable is defined but corresponds to non-existing directory")
endif()
# Check if an external ITK build tree was specified.
# If yes, use the GDCM from ITK, otherwise ITK will complain
if(ITK_DIR)
find_package(ITK)
if(ITK_GDCM_DIR)
set(GDCM_DIR ${ITK_GDCM_DIR})
endif()
endif()
set(proj GDCM)
set(proj_DEPENDENCIES )
set(GDCM_DEPENDS ${proj})
if(NOT DEFINED GDCM_DIR)
ExternalProject_Add(${proj}
SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
BINARY_DIR ${proj}-build
PREFIX ${proj}-cmake
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/gdcm-2.0.18.tar.gz
- URL_MD5 3c431bac0fe4da166f2b71c78f0d37a6
+ URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/gdcm-2.2.1.tar.gz
+ URL_MD5 67c6808a6f62796954f4131e24aaab2c
INSTALL_COMMAND ""
- PATCH_COMMAND ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchGDCM-2.0.18.cmake
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
- -DBUILD_SHARED_LIBS:BOOL=ON
-DGDCM_BUILD_SHARED_LIBS:BOOL=ON
- -DBUILD_TESTING:BOOL=OFF
- -DBUILD_EXAMPLES:BOOL=OFF
DEPENDS ${proj_DEPENDENCIES}
)
set(GDCM_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
- set(GDCM_IS_2_0_18 TRUE)
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
find_package(GDCM)
- if( GDCM_BUILD_VERSION EQUAL "18")
- set(GDCM_IS_2_0_18 TRUE)
- else()
- set(GDCM_IS_2_0_18 FALSE)
- endif()
-
endif()
diff --git a/CMakeExternals/ITK.cmake b/CMakeExternals/ITK.cmake
index 64d28cc45a..9bf1442f0f 100644
--- a/CMakeExternals/ITK.cmake
+++ b/CMakeExternals/ITK.cmake
@@ -1,82 +1,82 @@
#-----------------------------------------------------------------------------
# ITK
#-----------------------------------------------------------------------------
# Sanity checks
if(DEFINED ITK_DIR AND NOT EXISTS ${ITK_DIR})
message(FATAL_ERROR "ITK_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj ITK)
set(proj_DEPENDENCIES GDCM)
if(MITK_USE_Python)
list(APPEND proj_DEPENDENCIES CableSwig)
endif()
set(ITK_DEPENDS ${proj})
if(NOT DEFINED ITK_DIR)
set(additional_cmake_args )
if(MINGW)
set(additional_cmake_args
-DCMAKE_USE_WIN32_THREADS:BOOL=ON
-DCMAKE_USE_PTHREADS:BOOL=OFF)
endif()
if(MITK_USE_Python)
list(APPEND additional_cmake_args
- -DUSE_WRAP_ITK:BOOL=ON
- -DITK_USE_REVIEW:BOOL=ON
- -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
- -DPYTHON_DEBUG_LIBRARY=${PYTHON_DEBUG_LIBRARY}
- -DPYTHON_INCLUDE_DIR=${PYTHON_INCLUDE_DIR}
- -DPYTHON_LIBRARY=${PYTHON_LIBRARY}
+ -DITK_WRAPPING:BOOL=ON
+ #-DITK_USE_REVIEW:BOOL=ON
+ -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
+ -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
+ -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
#-DPYTHON_LIBRARIES=${PYTHON_LIBRARY}
#-DPYTHON_DEBUG_LIBRARIES=${PYTHON_DEBUG_LIBRARIES}
-DCableSwig_DIR:PATH=${CableSwig_DIR}
- -DWRAP_ITK_JAVA:BOOL=OFF
- -DWRAP_ITK_TCL:BOOL=OFF
- -DWRAP_unsigned_char:BOOL=ON
- #-DWRAP_double:BOOL=ON
- -DWRAP_rgb_unsigned_char:BOOL=ON
- #-DWRAP_rgba_unsigned_char:BOOL=ON
- -DWRAP_signed_char:BOOL=ON
+ #-DITK_WRAP_JAVA:BOOL=OFF
+ -DITK_WRAP_unsigned_char:BOOL=ON
+ #-DITK_WRAP_double:BOOL=ON
+ -DITK_WRAP_rgb_unsigned_char:BOOL=ON
+ #-DITK_WRAP_rgba_unsigned_char:BOOL=ON
+ -DITK_WRAP_signed_char:BOOL=ON
#-DWRAP_signed_long:BOOL=ON
- -DWRAP_signed_short:BOOL=ON
- -DWRAP_short:BOOL=ON
- -DWRAP_unsigned_long:BOOL=ON
+ -DITK_WRAP_signed_short:BOOL=ON
+ -DITK_WRAP_short:BOOL=ON
+ -DITK_WRAP_unsigned_long:BOOL=ON
+ )
+ else()
+ list(APPEND additional_cmake_args
+ -DUSE_WRAP_ITK:BOOL=OFF
)
endif()
- if(GDCM_IS_2_0_18)
- set(ITK_PATCH_COMMAND ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchITK-3.20.cmake)
- endif()
+ set(ITK_PATCH_COMMAND ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchITK-4.3.1.cmake)
ExternalProject_Add(${proj}
SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
BINARY_DIR ${proj}-build
PREFIX ${proj}-cmake
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/InsightToolkit-3.20.1.tar.gz
- URL_MD5 90342ffa78bd88ae48b3f62866fbf050
+ URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/InsightToolkit-4.3.2.tar.gz
+ URL_MD5 f25bb1561887be621d3954689f3944a6
INSTALL_COMMAND ""
PATCH_COMMAND ${ITK_PATCH_COMMAND}
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
${additional_cmake_args}
-DBUILD_TESTING:BOOL=OFF
-DBUILD_EXAMPLES:BOOL=OFF
-DITK_USE_SYSTEM_GDCM:BOOL=ON
-DGDCM_DIR:PATH=${GDCM_DIR}
DEPENDS ${proj_DEPENDENCIES}
)
set(ITK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
diff --git a/CMakeExternals/MITKData.cmake b/CMakeExternals/MITKData.cmake
index 1fcc8ff026..0a04a473f3 100644
--- a/CMakeExternals/MITKData.cmake
+++ b/CMakeExternals/MITKData.cmake
@@ -1,35 +1,36 @@
#-----------------------------------------------------------------------------
# MITK Data
#-----------------------------------------------------------------------------
# Sanity checks
if(DEFINED MITK_DATA_DIR AND NOT EXISTS ${MITK_DATA_DIR})
message(FATAL_ERROR "MITK_DATA_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj MITK-Data)
set(proj_DEPENDENCIES)
set(MITK-Data_DEPENDS ${proj})
if(BUILD_TESTING)
- set(revision_tag 062612b5)
+ set(revision_tag 5b7f4ef2)
+
ExternalProject_Add(${proj}
URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/MITK-Data_${revision_tag}.tar.gz
UPDATE_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
DEPENDS ${proj_DEPENDENCIES}
)
set(MITK_DATA_DIR ${ep_source_dir}/${proj})
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif(BUILD_TESTING)
diff --git a/CMakeExternals/MITKData.cmake.BACKUP.9452.cmake b/CMakeExternals/MITKData.cmake.BACKUP.9452.cmake
deleted file mode 100644
index c2dd0c371b..0000000000
--- a/CMakeExternals/MITKData.cmake.BACKUP.9452.cmake
+++ /dev/null
@@ -1,43 +0,0 @@
-#-----------------------------------------------------------------------------
-# MITK Data
-#-----------------------------------------------------------------------------
-
-# Sanity checks
-if(DEFINED MITK_DATA_DIR AND NOT EXISTS ${MITK_DATA_DIR})
- message(FATAL_ERROR "MITK_DATA_DIR variable is defined but corresponds to non-existing directory")
-endif()
-
-set(proj MITK-Data)
-set(proj_DEPENDENCIES)
-set(MITK-Data_DEPENDS ${proj})
-
-if(BUILD_TESTING)
-
-<<<<<<< HEAD
- set(revision_tag 16d96097)
-=======
- set(revision_tag 66dc8282)
->>>>>>> bug-14224-DefaultCalibrationFiles
-
- #if(${proj}_REVISION_TAG)
- # set(revision_tag ${${proj}_REVISION_TAG})
- #endif()
-
- ExternalProject_Add(${proj}
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/MITK-Data_${revision_tag}.tar.gz
- UPDATE_COMMAND ""
- CONFIGURE_COMMAND ""
- BUILD_COMMAND ""
- INSTALL_COMMAND ""
- DEPENDS ${proj_DEPENDENCIES}
- )
-
- set(MITK_DATA_DIR ${ep_source_dir}/${proj})
-
-else()
-
- mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
-
-endif(BUILD_TESTING)
-
-
diff --git a/CMakeExternals/MITKData.cmake.BASE.9452.cmake b/CMakeExternals/MITKData.cmake.BASE.9452.cmake
deleted file mode 100644
index a01699470f..0000000000
--- a/CMakeExternals/MITKData.cmake.BASE.9452.cmake
+++ /dev/null
@@ -1,39 +0,0 @@
-#-----------------------------------------------------------------------------
-# MITK Data
-#-----------------------------------------------------------------------------
-
-# Sanity checks
-if(DEFINED MITK_DATA_DIR AND NOT EXISTS ${MITK_DATA_DIR})
- message(FATAL_ERROR "MITK_DATA_DIR variable is defined but corresponds to non-existing directory")
-endif()
-
-set(proj MITK-Data)
-set(proj_DEPENDENCIES)
-set(MITK-Data_DEPENDS ${proj})
-
-if(BUILD_TESTING)
-
- set(revision_tag 55445f45)
-
- #if(${proj}_REVISION_TAG)
- # set(revision_tag ${${proj}_REVISION_TAG})
- #endif()
-
- ExternalProject_Add(${proj}
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/MITK-Data_${revision_tag}.tar.gz
- UPDATE_COMMAND ""
- CONFIGURE_COMMAND ""
- BUILD_COMMAND ""
- INSTALL_COMMAND ""
- DEPENDS ${proj_DEPENDENCIES}
- )
-
- set(MITK_DATA_DIR ${ep_source_dir}/${proj})
-
-else()
-
- mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
-
-endif(BUILD_TESTING)
-
-
diff --git a/CMakeExternals/MITKData.cmake.LOCAL.9452.cmake b/CMakeExternals/MITKData.cmake.LOCAL.9452.cmake
deleted file mode 100644
index 70ab82637a..0000000000
--- a/CMakeExternals/MITKData.cmake.LOCAL.9452.cmake
+++ /dev/null
@@ -1,39 +0,0 @@
-#-----------------------------------------------------------------------------
-# MITK Data
-#-----------------------------------------------------------------------------
-
-# Sanity checks
-if(DEFINED MITK_DATA_DIR AND NOT EXISTS ${MITK_DATA_DIR})
- message(FATAL_ERROR "MITK_DATA_DIR variable is defined but corresponds to non-existing directory")
-endif()
-
-set(proj MITK-Data)
-set(proj_DEPENDENCIES)
-set(MITK-Data_DEPENDS ${proj})
-
-if(BUILD_TESTING)
-
- set(revision_tag 16d96097)
-
- #if(${proj}_REVISION_TAG)
- # set(revision_tag ${${proj}_REVISION_TAG})
- #endif()
-
- ExternalProject_Add(${proj}
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/MITK-Data_${revision_tag}.tar.gz
- UPDATE_COMMAND ""
- CONFIGURE_COMMAND ""
- BUILD_COMMAND ""
- INSTALL_COMMAND ""
- DEPENDS ${proj_DEPENDENCIES}
- )
-
- set(MITK_DATA_DIR ${ep_source_dir}/${proj})
-
-else()
-
- mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
-
-endif(BUILD_TESTING)
-
-
diff --git a/CMakeExternals/MITKData.cmake.REMOTE.9452.cmake b/CMakeExternals/MITKData.cmake.REMOTE.9452.cmake
deleted file mode 100644
index a1de5f6636..0000000000
--- a/CMakeExternals/MITKData.cmake.REMOTE.9452.cmake
+++ /dev/null
@@ -1,39 +0,0 @@
-#-----------------------------------------------------------------------------
-# MITK Data
-#-----------------------------------------------------------------------------
-
-# Sanity checks
-if(DEFINED MITK_DATA_DIR AND NOT EXISTS ${MITK_DATA_DIR})
- message(FATAL_ERROR "MITK_DATA_DIR variable is defined but corresponds to non-existing directory")
-endif()
-
-set(proj MITK-Data)
-set(proj_DEPENDENCIES)
-set(MITK-Data_DEPENDS ${proj})
-
-if(BUILD_TESTING)
-
- set(revision_tag 66dc8282)
-
- #if(${proj}_REVISION_TAG)
- # set(revision_tag ${${proj}_REVISION_TAG})
- #endif()
-
- ExternalProject_Add(${proj}
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/MITK-Data_${revision_tag}.tar.gz
- UPDATE_COMMAND ""
- CONFIGURE_COMMAND ""
- BUILD_COMMAND ""
- INSTALL_COMMAND ""
- DEPENDS ${proj_DEPENDENCIES}
- )
-
- set(MITK_DATA_DIR ${ep_source_dir}/${proj})
-
-else()
-
- mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
-
-endif(BUILD_TESTING)
-
-
diff --git a/CMakeExternals/OpenCV.cmake b/CMakeExternals/OpenCV.cmake
index 8ac74e701c..0259ddaf09 100644
--- a/CMakeExternals/OpenCV.cmake
+++ b/CMakeExternals/OpenCV.cmake
@@ -1,77 +1,82 @@
#-----------------------------------------------------------------------------
# OpenCV
#-----------------------------------------------------------------------------
if(MITK_USE_OpenCV)
# Sanity checks
if(DEFINED OpenCV_DIR AND NOT EXISTS ${OpenCV_DIR})
message(FATAL_ERROR "OpenCV_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj OpenCV)
set(proj_DEPENDENCIES)
set(OpenCV_DEPENDS ${proj})
if(NOT DEFINED OpenCV_DIR)
set(additional_cmake_args )
if(MITK_USE_Python)
#message(STATUS "PYTHON_EXECUTABLE: ${PYTHON_EXECUTABLE}")
#message(STATUS "PYTHON_DEBUG_LIBRARY: ${PYTHON_DEBUG_LIBRARY}")
#message(STATUS "PYTHON_INCLUDE_DIR: ${PYTHON_INCLUDE_DIR}")
#message(STATUS "PYTHON_LIBRARY: ${PYTHON_LIBRARY}")
list(APPEND additional_cmake_args
-DBUILD_opencv_python:BOOL=ON
-DBUILD_NEW_PYTHON_SUPPORT:BOOL=ON
- -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
- -DPYTHON_DEBUG_LIBRARY=${PYTHON_DEBUG_LIBRARY}
- -DPYTHON_INCLUDE_DIR=${PYTHON_INCLUDE_DIR}
- -DPYTHON_LIBRARY=${PYTHON_LIBRARY}
+ -DPYTHON_DEBUG_LIBRARY:FILEPATH=${PYTHON_DEBUG_LIBRARY}
+ -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
+ -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
+ -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
#-DPYTHON_LIBRARIES=${PYTHON_LIBRARY}
#-DPYTHON_DEBUG_LIBRARIES=${PYTHON_DEBUG_LIBRARIES}
)
+ else()
+ list(APPEND additional_cmake_args
+ -DBUILD_opencv_python:BOOL=OFF
+ -DBUILD_NEW_PYTHON_SUPPORT:BOOL=OFF
+ )
endif()
# 12-05-02, muellerm, added QT usage by OpenCV if QT is used in MITK
# 12-09-11, muellerm, removed automatic usage again, since this will struggle with the MITK Qt application object
if(MITK_USE_QT)
list(APPEND additional_cmake_args
-DWITH_QT:BOOL=OFF
-DWITH_QT_OPENGL:BOOL=OFF
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
)
endif()
set(opencv_url ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/OpenCV-2.4.2.tar.bz2)
set(opencv_url_md5 d5d13c4a65dc96cdfaad54767e428215)
ExternalProject_Add(${proj}
SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
BINARY_DIR ${proj}-build
PREFIX ${proj}-cmake
URL ${opencv_url}
URL_MD5 ${opencv_url_md5}
INSTALL_COMMAND ""
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
-DBUILD_DOCS:BOOL=OFF
-DBUILD_TESTS:BOOL=OFF
-DBUILD_EXAMPLES:BOOL=OFF
-DBUILD_DOXYGEN_DOCS:BOOL=OFF
-DWITH_CUDA:BOOL=ON
${additional_cmake_args}
DEPENDS ${proj_DEPENDENCIES}
)
set(OpenCV_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
endif()
diff --git a/CMakeExternals/PatchGDCM-2.0.18.cmake b/CMakeExternals/PatchGDCM-2.0.18.cmake
deleted file mode 100644
index 24c681e4f4..0000000000
--- a/CMakeExternals/PatchGDCM-2.0.18.cmake
+++ /dev/null
@@ -1,13 +0,0 @@
-# Called by GDCM.cmake (ExternalProject_Add) as a patch for GDCM.
-# Changes CMake files to properly export link directories
-# (applies a change that is part of post-2.0.18 git master of gdcm)
-
-# read whole file
-file(STRINGS CMake/ExportConfiguration/GDCMConfig.cmake.in sourceCode NEWLINE_CONSUME)
-
-set(sourceCode "${sourceCode}\nSET(GDCM_LIBRARY_DIRS \"@GDCM_LIBRARY_DIRS@\")")
-
-# set variable CONTENTS, which is substituted in TEMPLATE_FILE
-set(CONTENTS ${sourceCode})
-configure_file(${TEMPLATE_FILE} CMake/ExportConfiguration/GDCMConfig.cmake.in @ONLY)
-
diff --git a/CMakeExternals/PatchITK-3.20.cmake b/CMakeExternals/PatchITK-3.20.cmake
deleted file mode 100644
index 7dd459d922..0000000000
--- a/CMakeExternals/PatchITK-3.20.cmake
+++ /dev/null
@@ -1,36 +0,0 @@
-# Called by ITK.cmake (ExternalProject_Add) as a patch for ITK to work witk GDCM 2.0.18
-
-# First patch
-# updates library dependencies
-# read whole file CMakeLists.txt
-file(STRINGS CMakeLists.txt sourceCode NEWLINE_CONSUME)
-
-# substitute dependency to gdcmMSFF by dependencies for more libraries
-string(REGEX REPLACE "gdcmMSFF" "gdcmMSFF gdcmDICT gdcmCommon gdcmDSED" sourceCode ${sourceCode})
-
-# set variable CONTENTS, which is substituted in TEMPLATE_FILE
-set(CONTENTS ${sourceCode})
-configure_file(${TEMPLATE_FILE} CMakeLists.txt @ONLY)
-
-# second patch
-# read whole file
-file(STRINGS Code/Common/itkLandmarkBasedTransformInitializer.h sourceCode2 NEWLINE_CONSUME)
-
-# backported fix from ITK4
-string(REGEX REPLACE "typedef typename ParametersType::ValueType +ParameterValueType;" "typedef typename TransformType::ScalarType ParameterValueType;" sourceCode2 ${sourceCode2})
-
-# set variable CONTENTS, which is substituted in TEMPLATE_FILE
-set(CONTENTS ${sourceCode2})
-configure_file(${TEMPLATE_FILE} Code/Common/itkLandmarkBasedTransformInitializer.h @ONLY)
-
-# third patch
-# read whole file
-file(STRINGS Code/Common/itkImageSource.h sourceCode3 NEWLINE_CONSUME)
-
-# remove ITK_NO_RETURN since the method sometimes returns which makes clang based builds crash
-string(REGEX REPLACE "ITK_NO_RETURN" "" sourceCode3 ${sourceCode3})
-
-# set variable CONTENTS, which is substituted in TEMPLATE_FILE
-set(CONTENTS ${sourceCode3})
-configure_file(${TEMPLATE_FILE} Code/Common/itkImageSource.h @ONLY)
-
diff --git a/CMakeExternals/PatchITK-4.3.1.cmake b/CMakeExternals/PatchITK-4.3.1.cmake
new file mode 100644
index 0000000000..30c3e9048c
--- /dev/null
+++ b/CMakeExternals/PatchITK-4.3.1.cmake
@@ -0,0 +1,13 @@
+# Called by ITK.cmake (ExternalProject_Add) as a patch for ITK to work with external GDCM 2.2.1
+
+set(path "Modules/ThirdParty/GDCM/itk-module-init.cmake")
+file(STRINGS ${path} contents NEWLINE_CONSUME)
+string(REPLACE "en" " include(\${GDCM_USE_FILE})\nen" contents ${contents})
+set(CONTENTS ${contents})
+configure_file(${TEMPLATE_FILE} ${path} @ONLY)
+
+set(path "Modules/ThirdParty/GDCM/src/CMakeLists.txt")
+file(STRINGS ${path} contents NEWLINE_CONSUME)
+string(REPLACE "SFF)" "SFF gdcmDSED gdcmCommon)" contents ${contents})
+set(CONTENTS ${contents})
+configure_file(${TEMPLATE_FILE} ${path} @ONLY)
diff --git a/CMakeExternals/PatchSOFA-rev8935.cmake b/CMakeExternals/PatchSOFA-rev8935.cmake
deleted file mode 100644
index b90a96266d..0000000000
--- a/CMakeExternals/PatchSOFA-rev8935.cmake
+++ /dev/null
@@ -1,13 +0,0 @@
-set(baseDir "framework/sofa/helper/system/")
-foreach(sourceFile "${baseDir}gl.h" "${baseDir}glu.h" "${baseDir}glut.h" "${baseDir}../gl/glfont.cpp")
- file(STRINGS ${sourceFile} sourceCode NEWLINE_CONSUME)
- string(REGEX REPLACE "<(Open)?GL(UT)?/" "<" sourceCode ${sourceCode})
- set(CONTENTS ${sourceCode})
- configure_file(${TEMPLATE_FILE} ${sourceFile} @ONLY)
-endforeach()
-
-set(sourceFile "modules/sofa/component/linearsolver/SSORPreconditioner.inl")
-file(STRINGS ${sourceFile} sourceCode NEWLINE_CONSUME)
-string(REGEX REPLACE "getM" "this->getM" sourceCode ${sourceCode})
-set(CONTENTS ${sourceCode})
-configure_file(${TEMPLATE_FILE} ${sourceFile} @ONLY)
diff --git a/CMakeExternals/PatchSOFA-rev9479.cmake b/CMakeExternals/PatchSOFA-rev9479.cmake
new file mode 100644
index 0000000000..403166f3f7
--- /dev/null
+++ b/CMakeExternals/PatchSOFA-rev9479.cmake
@@ -0,0 +1,72 @@
+file(STRINGS "cmake/preBuildConfig.cmake" preBuildConfig_cmake NEWLINE_CONSUME)
+string(REPLACE "DEBUG \"\${SOFA_BIN_DIR}" "DEBUG \"\${SOFA_BIN_DIR}/Debug" preBuildConfig_cmake "${preBuildConfig_cmake}")
+string(REPLACE "RELEASE \"\${SOFA_BIN_DIR}" "RELEASE \"\${SOFA_BIN_DIR}/Release" preBuildConfig_cmake "${preBuildConfig_cmake}")
+string(REPLACE "RELWITHDEBINFO \"\${SOFA_BIN_DIR}" "RELWITHDEBINFO \"\${SOFA_BIN_DIR}/RelWithDebInfo" preBuildConfig_cmake "${preBuildConfig_cmake}")
+string(REPLACE "MINSIZEREL \"\${SOFA_BIN_DIR}" "MINSIZEREL \"\${SOFA_BIN_DIR}/MinSizeRel" preBuildConfig_cmake "${preBuildConfig_cmake}")
+string(REPLACE "DEBUG \"\${SOFA_LIB_DIR}" "DEBUG \"\${SOFA_LIB_DIR}/Debug" preBuildConfig_cmake "${preBuildConfig_cmake}")
+string(REPLACE "RELEASE \"\${SOFA_LIB_DIR}" "RELEASE \"\${SOFA_LIB_DIR}/Release" preBuildConfig_cmake "${preBuildConfig_cmake}")
+string(REPLACE "RELWITHDEBINFO \"\${SOFA_LIB_DIR}" "RELWITHDEBINFO \"\${SOFA_LIB_DIR}/RelWithDebInfo" preBuildConfig_cmake "${preBuildConfig_cmake}")
+string(REPLACE "MINSIZEREL \"\${SOFA_LIB_DIR}" "MINSIZEREL \"\${SOFA_LIB_DIR}/MinSizeRel" preBuildConfig_cmake "${preBuildConfig_cmake}")
+file(WRITE "cmake/preBuildConfig.cmake" "${preBuildConfig_cmake}")
+
+file(APPEND "CMakeLists.txt" "\n\nconfigure_file(SOFAConfig.cmake.in SOFAConfig.cmake @ONLY)")
+
+file(WRITE "SOFAConfig.cmake.in"
+"add_definitions(-DSOFA_NO_OPENGL;-DSOFA_HAVE_EIGEN2;-DSOFA_XML_PARSER_TINYXML;-DTIXML_USE_STL;-DMINI_FLOWVR)
+
+set(SOFA_INCLUDE_DIRS \"@SOFA_EXTLIBS_DIR@/eigen-3.1.1;@SOFA_EXTLIBS_DIR@/miniBoost;@SOFA_EXTLIBS_DIR@/miniFlowVR/include;@SOFA_EXTLIBS_DIR@/newmat;@SOFA_EXTLIBS_DIR@/tinyxml;@SOFA_SRC_DIR@/framework;@SOFA_SRC_DIR@/modules\")
+
+set(SOFA_LIBRARY_DIRS \"@SOFA_LIB_DIR@\")
+
+set(SOFA_LIBRARIES
+ debug SofaBaseAnimationLoop_1_0d optimized SofaBaseAnimationLoop_1_0
+ debug SofaBaseCollision_1_0d optimized SofaBaseCollision_1_0
+ debug SofaBaseLinearSolver_1_0d optimized SofaBaseLinearSolver_1_0
+ debug SofaBaseMechanics_1_0d optimized SofaBaseMechanics_1_0
+ debug SofaBaseTopology_1_0d optimized SofaBaseTopology_1_0
+ debug SofaBaseVisual_1_0d optimized SofaBaseVisual_1_0
+ debug SofaBoundaryCondition_1_0d optimized SofaBoundaryCondition_1_0
+ debug SofaComponentAdvanced_1_0d optimized SofaComponentAdvanced_1_0
+ debug SofaComponentBase_1_0d optimized SofaComponentBase_1_0
+ debug SofaComponentCommon_1_0d optimized SofaComponentCommon_1_0
+ debug SofaComponentGeneral_1_0d optimized SofaComponentGeneral_1_0
+ debug SofaComponentMain_1_0d optimized SofaComponentMain_1_0
+ debug SofaComponentMisc_1_0d optimized SofaComponentMisc_1_0
+ debug SofaConstraint_1_0d optimized SofaConstraint_1_0
+ debug SofaCore_1_0d optimized SofaCore_1_0
+ debug SofaDefaultType_1_0d optimized SofaDefaultType_1_0
+ debug SofaDeformable_1_0d optimized SofaDeformable_1_0
+ debug SofaDenseSolver_1_0d optimized SofaDenseSolver_1_0
+ debug SofaEigen2Solver_1_0d optimized SofaEigen2Solver_1_0
+ debug SofaEngine_1_0d optimized SofaEngine_1_0
+ debug SofaEulerianFluid_1_0d optimized SofaEulerianFluid_1_0
+ debug SofaExplicitOdeSolver_1_0d optimized SofaExplicitOdeSolver_1_0
+ debug SofaExporter_1_0d optimized SofaExporter_1_0
+ debug SofaGraphComponent_1_0d optimized SofaGraphComponent_1_0
+ debug SofaHaptics_1_0d optimized SofaHaptics_1_0
+ debug SofaHelper_1_0d optimized SofaHelper_1_0
+ debug SofaImplicitOdeSolver_1_0d optimized SofaImplicitOdeSolver_1_0
+ debug SofaLoader_1_0d optimized SofaLoader_1_0
+ debug SofaMeshCollision_1_0d optimized SofaMeshCollision_1_0
+ debug SofaMisc_1_0d optimized SofaMisc_1_0
+ debug SofaMiscCollision_1_0d optimized SofaMiscCollision_1_0
+ debug SofaMiscEngine_1_0d optimized SofaMiscEngine_1_0
+ debug SofaMiscFem_1_0d optimized SofaMiscFem_1_0
+ debug SofaMiscForceField_1_0d optimized SofaMiscForceField_1_0
+ debug SofaMiscMapping_1_0d optimized SofaMiscMapping_1_0
+ debug SofaMiscSolver_1_0d optimized SofaMiscSolver_1_0
+ debug SofaMiscTopology_1_0d optimized SofaMiscTopology_1_0
+ debug SofaNonUniformFem_1_0d optimized SofaNonUniformFem_1_0
+ debug SofaObjectInteraction_1_0d optimized SofaObjectInteraction_1_0
+ debug SofaPreconditioner_1_0d optimized SofaPreconditioner_1_0
+ debug SofaRigid_1_0d optimized SofaRigid_1_0
+ debug SofaSimpleFem_1_0d optimized SofaSimpleFem_1_0
+ debug SofaSimulationCommon_1_0d optimized SofaSimulationCommon_1_0
+ debug SofaSimulationTree_1_0d optimized SofaSimulationTree_1_0
+ debug SofaSphFluid_1_0d optimized SofaSphFluid_1_0
+ debug SofaTopologyMapping_1_0d optimized SofaTopologyMapping_1_0
+ debug SofaUserInteraction_1_0d optimized SofaUserInteraction_1_0
+ debug SofaValidation_1_0d optimized SofaValidation_1_0
+ debug SofaVolumetricData_1_0d optimized SofaVolumetricData_1_0
+ debug tinyxml_1_0d optimized tinyxml_1_0
+)")
diff --git a/CMakeExternals/SOFA.cmake b/CMakeExternals/SOFA.cmake
index e1f77bd8c1..9f9c284a52 100644
--- a/CMakeExternals/SOFA.cmake
+++ b/CMakeExternals/SOFA.cmake
@@ -1,37 +1,65 @@
#-----------------------------------------------------------------------------
# SOFA
#-----------------------------------------------------------------------------
if(MITK_USE_SOFA)
# Sanity checks
if(DEFINED SOFA_DIR AND NOT EXISTS ${SOFA_DIR})
message(FATAL_ERROR "SOFA_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj SOFA)
set(proj_DEPENDENCIES)
set(SOFA_DEPENDS ${proj})
- set(SOFA_PATCH_COMMAND ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchSOFA-rev8935.cmake)
+ set(additional_cmake_args
+ -DSOFA-APPLICATION_MODELER:BOOL=OFF
+ -DSOFA-APPLICATION_RUN_SOFA:BOOL=OFF
+ -DSOFA-APPLICATION_SOFA_BATCH:BOOL=OFF
+ -DSOFA-EXTERNAL_HAVE_ZLIB:BOOL=OFF
+ -DSOFA-EXTERNAL_HAVE_PNG:BOOL=OFF
+ -DSOFA-LIB_COMPONENT_EIGEN2_SOLVER:BOOL=ON
+ -DSOFA-LIB_COMPONENT_OPENGL_VISUAL:BOOL=OFF
+ -DSOFA-LIB_GUI_GLUT:BOOL=OFF
+ -DSOFA-LIB_GUI_QTVIEWER:BOOL=OFF
+ -DSOFA-MISC_NO_OPENGL:BOOL=ON
+ -DSOFA-TUTORIAL_CHAIN_HYBRID:BOOL=OFF
+ -DSOFA-TUTORIAL_COMPOSITE_OBJECT:BOOL=OFF
+ -DSOFA-TUTORIAL_HOUSE_OF_CARDS:BOOL=OFF
+ -DSOFA-TUTORIAL_MIXED_PENDULUM:BOOL=OFF
+ -DSOFA-TUTORIAL_ONE_PARTICLE:BOOL=OFF
+ -DSOFA-TUTORIAL_ONE_TETRAHEDRON:BOOL=OFF)
+
+ set(SOFA_PATCH_COMMAND ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchSOFA-rev9479.cmake)
+ set(SOFA_PRECONFIGURE_COMMAND ${CMAKE_COMMAND} -G${gen} ${CMAKE_BINARY_DIR}/${proj}-src)
+ set(SOFA_CONFIGURE_COMMAND ${CMAKE_COMMAND} -G${gen} ${ep_common_args} ${additional_cmake_args} ${CMAKE_BINARY_DIR}/${proj}-src)
if(NOT DEFINED SOFA_DIR)
ExternalProject_Add(${proj}
SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
BINARY_DIR ${proj}-build
PREFIX ${proj}-cmake
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/SOFA_29180826.tar.gz
- URL_MD5 9e4bf55a3b872a1db53c9ad399faa6c0
+ URL http://mitk.org/download/thirdparty/SOFA-rev9479.tar.gz
+ URL_MD5 fa43e6183abb8fc36c86ec43a095fdc2
PATCH_COMMAND ${SOFA_PATCH_COMMAND}
INSTALL_COMMAND ""
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
${additional_cmake_args}
DEPENDS ${proj_DEPENDENCIES}
)
+ ExternalProject_Add_Step(${proj} preconfigure
+ COMMAND ${SOFA_PRECONFIGURE_COMMAND}
+ WORKING_DIRECTORY ${proj}-build
+ DEPENDEES patch
+ DEPENDERS configure
+ LOG 1
+ )
+
set(SOFA_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
else()
mitkMacroEmptyExternalProject(${proj} "${proj}_DEPENDENCIES}")
endif()
endif()
diff --git a/CMakeExternals/VTK.cmake b/CMakeExternals/VTK.cmake
index 33d6170d00..e8d0358959 100644
--- a/CMakeExternals/VTK.cmake
+++ b/CMakeExternals/VTK.cmake
@@ -1,94 +1,98 @@
#-----------------------------------------------------------------------------
# VTK
#-----------------------------------------------------------------------------
if(WIN32)
option(VTK_USE_SYSTEM_FREETYPE OFF)
else(WIN32)
option(VTK_USE_SYSTEM_FREETYPE ON)
endif(WIN32)
# Sanity checks
if(DEFINED VTK_DIR AND NOT EXISTS ${VTK_DIR})
message(FATAL_ERROR "VTK_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj VTK)
set(proj_DEPENDENCIES )
set(VTK_DEPENDS ${proj})
if(NOT DEFINED VTK_DIR)
set(additional_cmake_args )
if(MINGW)
set(additional_cmake_args
-DCMAKE_USE_WIN32_THREADS:BOOL=ON
-DCMAKE_USE_PTHREADS:BOOL=OFF
-DVTK_USE_VIDEO4WINDOWS:BOOL=OFF # no header files provided by MinGW
)
endif()
if(MITK_USE_Python)
list(APPEND additional_cmake_args
-DVTK_WRAP_PYTHON:BOOL=ON
-DVTK_USE_TK:BOOL=OFF
-DVTK_WINDOWS_PYTHON_DEBUGGABLE:BOOL=OFF
- -DPYTHON_DEBUG_LIBRARY=${PYTHON_DEBUG_LIBRARY}
- -DPYTHON_INCLUDE_DIR=${PYTHON_INCLUDE_DIR}
- -DPYTHON_LIBRARY=${PYTHON_LIBRARY}
- -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
+ -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
+ -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
+ -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
#-DPYTHON_LIBRARIES=${PYTHON_LIBRARY}
#-DPYTHON_DEBUG_LIBRARIES=${PYTHON_DEBUG_LIBRARIES}
)
+ else()
+ list(APPEND additional_cmake_args
+ -DVTK_WRAP_PYTHON:BOOL=OFF
+ -DVTK_WINDOWS_PYTHON_DEBUGGABLE:BOOL=OFF
+ )
endif()
if(MITK_USE_QT)
list(APPEND additional_cmake_args
-DDESIRED_QT_VERSION:STRING=4
-DVTK_USE_GUISUPPORT:BOOL=ON
-DVTK_USE_QVTK_QTOPENGL:BOOL=OFF
-DVTK_USE_QT:BOOL=ON
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
)
endif()
set(VTK_URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/vtk-5.10.0.tar.gz)
set(VTK_URL_MD5 a0363f78910f466ba8f1bd5ab5437cb9)
if(APPLE)
set(VTK_PATCH_COMMAND ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchVTK-5.10-Mac.cmake)
endif()
ExternalProject_Add(${proj}
SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
BINARY_DIR ${proj}-build
PREFIX ${proj}-cmake
URL ${VTK_URL}
URL_MD5 ${VTK_URL_MD5}
INSTALL_COMMAND ""
PATCH_COMMAND ${VTK_PATCH_COMMAND}
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
-DVTK_WRAP_TCL:BOOL=OFF
-DVTK_WRAP_PYTHON:BOOL=OFF
-DVTK_WRAP_JAVA:BOOL=OFF
-DBUILD_SHARED_LIBS:BOOL=ON
-DVTK_USE_PARALLEL:BOOL=ON
-DVTK_USE_CHARTS:BOOL=OFF
-DVTK_USE_QTCHARTS:BOOL=ON
-DVTK_USE_GEOVIS:BOOL=OFF
-DVTK_USE_SYSTEM_FREETYPE:BOOL=${VTK_USE_SYSTEM_FREETYPE}
-DVTK_USE_QVTK_QTOPENGL:BOOL=OFF
-DVTK_LEGACY_REMOVE:BOOL=ON
${additional_cmake_args}
DEPENDS ${proj_DEPENDENCIES}
)
set(VTK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f7fae2081b..424fc557ee 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,975 +1,982 @@
if(APPLE)
# With XCode 4.3, the SDK location changed. Older CMake
# versions are not able to find it.
cmake_minimum_required(VERSION 2.8.8)
else()
- cmake_minimum_required(VERSION 2.8.4)
+ cmake_minimum_required(VERSION 2.8.5)
endif()
#-----------------------------------------------------------------------------
# Set a default build type if none was specified
#-----------------------------------------------------------------------------
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
message(STATUS "Setting build type to 'Debug' as none was specified.")
set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
# Set the possible values of build type for cmake-gui
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
endif()
#-----------------------------------------------------------------------------
# Superbuild Option - Enabled by default
#-----------------------------------------------------------------------------
option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON)
if(MITK_USE_SUPERBUILD)
project(MITK-superbuild)
set(MITK_SOURCE_DIR ${PROJECT_SOURCE_DIR})
set(MITK_BINARY_DIR ${PROJECT_BINARY_DIR})
else()
project(MITK)
endif()
#-----------------------------------------------------------------------------
# Warn if source or build path is too long
#-----------------------------------------------------------------------------
if(WIN32)
set(_src_dir_length_max 50)
set(_bin_dir_length_max 50)
if(MITK_USE_SUPERBUILD)
set(_src_dir_length_max 43) # _src_dir_length_max - strlen(ITK-src)
set(_bin_dir_length_max 40) # _bin_dir_length_max - strlen(MITK-build)
endif()
string(LENGTH "${MITK_SOURCE_DIR}" _src_n)
string(LENGTH "${MITK_BINARY_DIR}" _bin_n)
# The warnings should be converted to errors
if(_src_n GREATER _src_dir_length_max)
message(WARNING "MITK source code directory path length is too long (${_src_n} > ${_src_dir_length_max})."
"Please move the MITK source code directory to a directory with a shorter path." )
endif()
if(_bin_n GREATER _bin_dir_length_max)
message(WARNING "MITK build directory path length is too long (${_bin_n} > ${_bin_dir_length_max})."
"Please move the MITK build directory to a directory with a shorter path." )
endif()
endif()
#-----------------------------------------------------------------------------
# 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)
include(mitkFunctionSuppressWarnings)
SUPPRESS_VC_DEPRECATED_WARNINGS()
#-----------------------------------------------------------------------------
# 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("Creating directory MITK_CMAKE_${type}_OUTPUT_DIRECTORY: ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
file(MAKE_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)
option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF)
set(MITK_BUILD_TUTORIAL OFF CACHE INTERNAL "Deprecated! Use MITK_BUILD_EXAMPLES instead!")
option(MITK_BUILD_EXAMPLES "Build the MITK Examples" ${MITK_BUILD_TUTORIAL})
option(MITK_USE_Boost "Use the Boost C++ library" OFF)
option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
option(MITK_USE_CTK "Use CTK in MITK" ${MITK_USE_BLUEBERRY})
option(MITK_USE_QT "Use Nokia's Qt library" ${MITK_USE_CTK})
option(MITK_USE_DCMTK "EXPERIMENTAL, superbuild only: Use DCMTK in MITK" ${MITK_USE_CTK})
option(MITK_DCMTK_BUILD_SHARED_LIBS "EXPERIMENTAL, superbuild only: build DCMTK as shared libs" OFF)
option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF)
option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF)
option(MITK_USE_SOFA "Use Simulation Open Framework Architecture" OFF)
option(MITK_USE_Python "Use Python wrapping in MITK" OFF)
set(MITK_USE_CableSwig ${MITK_USE_Python})
if(MITK_USE_Python)
FIND_PACKAGE(PythonLibs REQUIRED)
FIND_PACKAGE(PythonInterp REQUIRED)
endif()
mark_as_advanced(MITK_BUILD_ALL_APPS
MITK_USE_CTK
MITK_USE_DCMTK
)
if(MITK_USE_Boost)
option(MITK_USE_SYSTEM_Boost "Use the system Boost" OFF)
set(MITK_USE_Boost_LIBRARIES "" CACHE STRING "A semi-colon separated list of required Boost libraries")
endif()
if(MITK_USE_BLUEBERRY)
option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
mark_as_advanced(MITK_BUILD_ALL_PLUGINS)
if(NOT MITK_USE_CTK)
message("Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY")
set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE)
endif()
endif()
if(MITK_USE_CTK)
if(NOT MITK_USE_QT)
message("Forcing MITK_USE_QT to ON because of MITK_USE_CTK")
set(MITK_USE_QT ON CACHE BOOL "Use Nokia's Qt library in MITK" FORCE)
endif()
if(NOT MITK_USE_DCMTK)
message("Setting MITK_USE_DCMTK to ON because DCMTK needs to be build for CTK")
set(MITK_USE_DCMTK ON CACHE BOOL "Use DCMTK in MITK" FORCE)
endif()
endif()
if(MITK_USE_QT)
# find the package at the very beginning, so that QT4_FOUND is available
find_package(Qt4 4.6.2 REQUIRED)
endif()
+if(MITK_USE_SOFA)
+ set(SOFA_CMAKE_VERSION 2.8.8)
+ if(${CMAKE_VERSION} VERSION_LESS ${SOFA_CMAKE_VERSION} OR APPLE)
+ set(MITK_USE_SOFA OFF CACHE BOOL "" FORCE)
+ message(WARNING "Switched off MITK_USE_SOFA\n Minimum required CMake version: ${SOFA_CMAKE_VERSION}\n Installed CMake version: ${CMAKE_VERSION}")
+ endif()
+endif()
+
# Customize the default pixel types for multiplex macros
set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
"int, unsigned int, short, unsigned short, char, unsigned char"
CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros")
set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
"double, float"
CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros")
set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
"itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros")
set(MITK_ACCESSBYITK_DIMENSIONS
"2,3"
CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
mark_as_advanced(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
MITK_ACCESSBYITK_DIMENSIONS
)
# consistency checks
if(NOT MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES)
set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
"int, unsigned int, short, unsigned short, char, unsigned char"
CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
endif()
if(NOT MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES)
set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
"double, float"
CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
endif()
if(NOT MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES)
set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
"itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
endif()
if(NOT MITK_ACCESSBYITK_DIMENSIONS)
set(MITK_ACCESSBYITK_DIMENSIONS
"2,3"
CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
endif()
#-----------------------------------------------------------------------------
# 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-ToF
MITK-DTI
MITK-Registration
MITK-Modules # all modules not contained in a specific subproject
MITK-Plugins # all plugins not contained in a specific subproject
MITK-Examples
Unlabeled # special "subproject" catching all unlabeled targets and tests
)
# Configure CTestConfigSubProject.cmake that could be used by CTest scripts
configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in
${MITK_BINARY_DIR}/CTestConfigSubProject.cmake)
if(CTEST_PROJECT_ADDITIONAL_TARGETS)
# those targets will be executed at the end of the ctest driver script
# and they also get their own subproject label
set(subproject_list "${CTEST_PROJECT_SUBPROJECTS};${CTEST_PROJECT_ADDITIONAL_TARGETS}")
else()
set(subproject_list "${CTEST_PROJECT_SUBPROJECTS}")
endif()
# Generate Project.xml file expected by the CTest driver script
mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} MITK "${subproject_list}" ${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(CheckCXXSourceCompiles)
include(mitkFunctionCheckCompilerFlags)
include(mitkFunctionGetGccVersion)
include(MacroParseArguments)
include(mitkFunctionSuppressWarnings) # includes several functions
include(mitkFunctionOrganizeSources)
include(mitkFunctionGetVersion)
include(mitkFunctionGetVersionDescription)
include(mitkFunctionCreateWindowsBatchScript)
include(mitkFunctionInstallProvisioningFiles)
include(mitkFunctionInstallAutoLoadModules)
include(mitkFunctionCompileSnippets)
include(mitkMacroCreateModuleConf)
include(mitkMacroCreateModule)
include(mitkMacroCheckModule)
include(mitkMacroCreateModuleTests)
include(mitkFunctionAddCustomModuleTest)
include(mitkMacroUseModule)
include(mitkMacroMultiplexPicType)
include(mitkMacroInstall)
include(mitkMacroInstallHelperApp)
include(mitkMacroInstallTargets)
include(mitkMacroGenerateToolsLibrary)
include(mitkMacroGetLinuxDistribution)
#-----------------------------------------------------------------------------
# Prerequesites
#-----------------------------------------------------------------------------
find_package(ITK REQUIRED)
find_package(VTK REQUIRED)
-if(ITK_USE_SYSTEM_GDCM)
- find_package(GDCM PATHS ${ITK_GDCM_DIR} REQUIRED)
-endif()
+find_package(GDCM PATHS ${ITK_GDCM_DIR} REQUIRED)
+include(${GDCM_USE_FILE})
#-----------------------------------------------------------------------------
# Set MITK specific options and variables (NOT available during superbuild)
#-----------------------------------------------------------------------------
# ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and mitkWorkbench
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)
if(NOT MITK_FAST_TESTING)
if(DEFINED MITK_CTEST_SCRIPT_MODE
AND (MITK_CTEST_SCRIPT_MODE STREQUAL "continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "experimental") )
set(MITK_FAST_TESTING 1)
endif()
endif()
#-----------------------------------------------------------------------------
# Get MITK version info
#-----------------------------------------------------------------------------
mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK)
#-----------------------------------------------------------------------------
# Installation preparation
#
# These should be set before any MITK install macros are used
#-----------------------------------------------------------------------------
# on Mac OSX all BlueBerry plugins get copied into every
# application bundle (.app directory) specified here
if(MITK_USE_BLUEBERRY AND APPLE)
include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
foreach(mitk_app ${MITK_APPS})
# extract option_name
string(REPLACE "^^" "\\;" target_info ${mitk_app})
set(target_info_list ${target_info})
list(GET target_info_list 1 option_name)
list(GET target_info_list 0 app_name)
# check if the application is enabled
if(${option_name} OR MITK_BUILD_ALL_APPS)
set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} ${app_name})
endif()
endforeach()
endif()
#-----------------------------------------------------------------------------
# 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 "${COVERAGE_C_FLAGS}")
set(MITK_C_FLAGS_DEBUG )
set(MITK_C_FLAGS_RELEASE )
set(MITK_CXX_FLAGS "${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS}")
set(MITK_CXX_FLAGS_DEBUG )
set(MITK_CXX_FLAGS_RELEASE )
set(MITK_EXE_LINKER_FLAGS )
set(MITK_SHARED_LINKER_FLAGS )
include(mitkSetupC++0xVariables)
if(WIN32)
set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -D_WIN32_WINNT=0x0501 -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN")
endif()
if(NOT MSVC_VERSION)
foreach(_flag
-Wall
-Wextra
-Wpointer-arith
-Winvalid-pch
-Wcast-align
-Wwrite-strings
-Wno-error=gnu
-Woverloaded-virtual
-Wstrict-null-sentinel
#-Wold-style-cast
#-Wsign-promo
-fdiagnostics-show-option
)
mitkFunctionCheckCAndCXXCompilerFlags(${_flag} MITK_C_FLAGS MITK_CXX_FLAGS)
endforeach()
endif()
if(CMAKE_COMPILER_IS_GNUCXX)
mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" MITK_SHARED_LINKER_FLAGS)
mitkFunctionCheckCompilerFlags("-Wl,--as-needed" MITK_SHARED_LINKER_FLAGS)
if(MITK_USE_C++0x)
mitkFunctionCheckCompilerFlags("-std=c++0x" MITK_CXX_FLAGS)
endif()
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"))
mitkFunctionCheckCAndCXXCompilerFlags("-fstack-protector-all" MITK_C_FLAGS MITK_CXX_FLAGS)
endif()
if(MINGW)
# suppress warnings about auto imported symbols
set(MITK_SHARED_LINKER_FLAGS "-Wl,--enable-auto-import ${MITK_SHARED_LINKER_FLAGS}")
endif()
set(MITK_CXX_FLAGS_RELEASE "-D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}")
endif()
set(MITK_MODULE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
set(MITK_EXE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
#-----------------------------------------------------------------------------
# MITK Packages
#-----------------------------------------------------------------------------
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()
# Test the external project template
if(MITK_USE_BLUEBERRY)
include(mitkTestProjectTemplate)
endif()
# Test the package target
include(mitkPackageTest)
endif()
configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h)
#-----------------------------------------------------------------------------
# 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
#-----------------------------------------------------------------------------
include(mitkSetupVariables)
#-----------------------------------------------------------------------------
# Cleanup
#-----------------------------------------------------------------------------
file(GLOB _MODULES_CONF_FILES ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}/*.cmake)
if(_MODULES_CONF_FILES)
file(REMOVE ${_MODULES_CONF_FILES})
endif()
add_subdirectory(Utilities)
if(MITK_USE_BLUEBERRY)
# We need to hack a little bit because MITK applications may need
# to enable certain BlueBerry plug-ins. However, these plug-ins
# are validated separately from the MITK plug-ins and know nothing
# about potential MITK plug-in dependencies of the applications. Hence
# we cannot pass the MITK application list to the BlueBerry
# ctkMacroSetupPlugins call but need to extract the BlueBerry dependencies
# from the applications and set them explicitly.
include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
foreach(mitk_app ${MITK_APPS})
# extract target_dir and option_name
string(REPLACE "^^" "\\;" target_info ${mitk_app})
set(target_info_list ${target_info})
list(GET target_info_list 0 target_dir)
list(GET target_info_list 1 option_name)
# check if the application is enabled and if target_libraries.cmake exists
if((${option_name} OR MITK_BUILD_ALL_APPS) AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
foreach(_target_dep ${target_libraries})
if(_target_dep MATCHES org_blueberry_)
string(REPLACE _ . _app_bb_dep ${_target_dep})
# explicitly set the build option for the BlueBerry plug-in
set(BLUEBERRY_BUILD_${_app_bb_dep} ON CACHE BOOL "Build the ${_app_bb_dep} plug-in")
endif()
endforeach()
endif()
endforeach()
set(mbilog_DIR "${mbilog_BINARY_DIR}")
if(MITK_BUILD_ALL_PLUGINS)
set(BLUEBERRY_BUILD_ALL_PLUGINS ON)
endif()
set(BLUEBERRY_XPDOC_OUTPUT_DIR ${MITK_DOXYGEN_OUTPUT_DIR}/html/extension-points/html/)
add_subdirectory(BlueBerry)
set(BlueBerry_DIR ${CMAKE_CURRENT_BINARY_DIR}/BlueBerry
CACHE PATH "The directory containing a CMake configuration file for BlueBerry" FORCE)
include(mitkMacroCreateCTKPlugin)
endif()
#-----------------------------------------------------------------------------
# Set C/CXX and linker flags for MITK code
#-----------------------------------------------------------------------------
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${MITK_CXX_FLAGS_DEBUG}")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MITK_CXX_FLAGS_RELEASE}")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}")
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${MITK_C_FLAGS_DEBUG}")
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${MITK_C_FLAGS_RELEASE}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MITK_EXE_LINKER_FLAGS}")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MITK_SHARED_LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MITK_MODULE_LINKER_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} AND NOT subproject MATCHES "Unlabeled")
add_custom_target(${subproject})
endif()
endforeach()
#-----------------------------------------------------------------------------
# Add subdirectories
#-----------------------------------------------------------------------------
link_directories(${MITK_LINK_DIRECTORIES})
add_subdirectory(Core)
include(${CMAKE_CURRENT_BINARY_DIR}/Core/Code/CppMicroServices/CppMicroServicesConfig.cmake)
add_subdirectory(Modules)
if(MITK_USE_BLUEBERRY)
find_package(BlueBerry REQUIRED)
set(MITK_DEFAULT_SUBPROJECTS MITK-Plugins)
# Plug-in testing (needs some work to be enabled again)
if(BUILD_TESTING)
include(berryTestingHelpers)
set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp")
get_target_property(_is_macosx_bundle CoreApp MACOSX_BUNDLE)
if(APPLE AND _is_macosx_bundle)
set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp")
endif()
set(BLUEBERRY_TEST_APP_ID "org.mitk.qt.coreapplication")
endif()
include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake")
set(mitk_plugins_fullpath )
foreach(mitk_plugin ${MITK_EXT_PLUGINS})
list(APPEND mitk_plugins_fullpath Plugins/${mitk_plugin})
endforeach()
if(EXISTS ${MITK_PRIVATE_MODULES}/PluginList.cmake)
include(${MITK_PRIVATE_MODULES}/PluginList.cmake)
foreach(mitk_plugin ${MITK_PRIVATE_PLUGINS})
list(APPEND mitk_plugins_fullpath ${MITK_PRIVATE_MODULES}/${mitk_plugin})
endforeach()
endif()
# Specify which plug-ins belong to this project
macro(GetMyTargetLibraries all_target_libraries varname)
set(re_ctkplugin_mitk "^org_mitk_[a-zA-Z0-9_]+$")
set(re_ctkplugin_bb "^org_blueberry_[a-zA-Z0-9_]+$")
set(_tmp_list)
list(APPEND _tmp_list ${all_target_libraries})
ctkMacroListFilter(_tmp_list re_ctkplugin_mitk re_ctkplugin_bb OUTPUT_VARIABLE ${varname})
endmacro()
# Get infos about application directories and build options
include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
set(mitk_apps_fullpath )
foreach(mitk_app ${MITK_APPS})
list(APPEND mitk_apps_fullpath "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${mitk_app}")
endforeach()
ctkMacroSetupPlugins(${mitk_plugins_fullpath}
BUILD_OPTION_PREFIX MITK_BUILD_
APPS ${mitk_apps_fullpath}
BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
COMPACT_OPTIONS)
set(MITK_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkPluginUseFile.cmake")
if(${PROJECT_NAME}_PLUGIN_LIBRARIES)
ctkFunctionGeneratePluginUseFile(${MITK_PLUGIN_USE_FILE})
else()
file(REMOVE ${MITK_PLUGIN_USE_FILE})
set(MITK_PLUGIN_USE_FILE )
endif()
# 11.3.13, change, muellerm: activate python bundle if python and blueberry is active
if( MITK_USE_Python )
set(MITK_BUILD_org.mitk.gui.qt.python ON)
endif()
endif()
# Construct a list of paths containing runtime directories
# for MITK applications on Windows
set(MITK_RUNTIME_PATH
- "${VTK_LIBRARY_DIRS}/%VS_BUILD_TYPE%;${ITK_LIBRARY_DIRS}/%VS_BUILD_TYPE%;${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%"
+ "${VTK_LIBRARY_DIRS}/%VS_BUILD_TYPE%;${ITK_DIR}/bin/%VS_BUILD_TYPE%;${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%"
)
if(QT4_FOUND)
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${QT_LIBRARY_DIR}/../bin")
endif()
if(MITK_USE_BLUEBERRY)
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CTK_RUNTIME_LIBRARY_DIRS}/%VS_BUILD_TYPE%")
if(DEFINED CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY)
if(IS_ABSOLUTE "${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%")
else()
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%")
endif()
else()
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins/%VS_BUILD_TYPE%")
endif()
endif()
if(GDCM_DIR)
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${GDCM_DIR}/bin/%VS_BUILD_TYPE%")
endif()
if(OpenCV_DIR)
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${OpenCV_DIR}/bin/%VS_BUILD_TYPE%")
endif()
if(SOFA_DIR)
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${SOFA_DIR}/bin/%VS_BUILD_TYPE%")
endif()
# DCMTK is statically build
#if(DCMTK_DIR)
# set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${DCMTK_DIR}/bin/%VS_BUILD_TYPE%")
#endif()
if(MITK_USE_Boost AND MITK_USE_Boost_LIBRARIES AND NOT MITK_USE_SYSTEM_Boost)
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${Boost_LIBRARY_DIRS}")
endif()
#-----------------------------------------------------------------------------
# Python Wrapping
#-----------------------------------------------------------------------------
option(MITK_USE_Python "Build Python integration for MITK (requires CableSwig)." OFF)
if(MITK_USE_Python)
set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CTK_PYTHONQT_INSTALL_DIR}/bin")
endif()
#-----------------------------------------------------------------------------
# Documentation
#-----------------------------------------------------------------------------
add_subdirectory(Documentation)
#-----------------------------------------------------------------------------
# Installation
#-----------------------------------------------------------------------------
# set MITK cpack variables
# These are the default variables, which can be overwritten ( see below )
include(mitkSetupCPack)
set(use_default_config ON)
# MITK_APPS is set in Applications/AppList.cmake (included somewhere above
# if MITK_USE_BLUEBERRY is set to ON).
if(MITK_APPS)
set(activated_apps_no 0)
list(LENGTH MITK_APPS app_count)
# Check how many apps have been enabled
# If more than one app has been activated, the we use the
# default CPack configuration. Otherwise that apps configuration
# will be used, if present.
foreach(mitk_app ${MITK_APPS})
# extract option_name
string(REPLACE "^^" "\\;" target_info ${mitk_app})
set(target_info_list ${target_info})
list(GET target_info_list 1 option_name)
# check if the application is enabled
if(${option_name} OR MITK_BUILD_ALL_APPS)
MATH(EXPR activated_apps_no "${activated_apps_no} + 1")
endif()
endforeach()
if(app_count EQUAL 1 AND (activated_apps_no EQUAL 1 OR MITK_BUILD_ALL_APPS))
# Corner case if there is only one app in total
set(use_project_cpack ON)
elseif(activated_apps_no EQUAL 1 AND NOT MITK_BUILD_ALL_APPS)
# Only one app is enabled (no "build all" flag set)
set(use_project_cpack ON)
else()
# Less or more then one app is enabled
set(use_project_cpack OFF)
endif()
foreach(mitk_app ${MITK_APPS})
# extract target_dir and option_name
string(REPLACE "^^" "\\;" target_info ${mitk_app})
set(target_info_list ${target_info})
list(GET target_info_list 0 target_dir)
list(GET target_info_list 1 option_name)
# check if the application is enabled
if(${option_name} OR MITK_BUILD_ALL_APPS)
# check whether application specific configuration files will be used
if(use_project_cpack)
# use files if they exist
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
endif()
if(EXISTS "${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in")
set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/Applications/${target_dir}/CPackConfig.cmake")
configure_file(${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in
${CPACK_PROJECT_CONFIG_FILE} @ONLY)
set(use_default_config OFF)
endif()
endif()
# add link to the list
list(APPEND CPACK_CREATE_DESKTOP_LINKS "${target_dir}")
endif()
endforeach()
endif()
# if no application specific configuration file was used, use default
if(use_default_config)
configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY)
set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake")
endif()
# include CPack model once all variables are set
include(CPack)
# Additional installation rules
include(mitkInstallRules)
#-----------------------------------------------------------------------------
# Last configuration steps
#-----------------------------------------------------------------------------
# This is for installation support of external projects depending on
# MITK plugins and modules. 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).
set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
file(REMOVE ${MITK_EXPORTS_FILE})
set(targets_to_export)
get_property(module_targets GLOBAL PROPERTY MITK_MODULE_TARGETS)
if(module_targets)
list(APPEND targets_to_export ${module_targets})
endif()
if(MITK_USE_BLUEBERRY)
if(MITK_PLUGIN_LIBRARIES)
list(APPEND targets_to_export ${MITK_PLUGIN_LIBRARIES})
endif()
endif()
export(TARGETS ${targets_to_export} APPEND
FILE ${MITK_EXPORTS_FILE})
set(MITK_EXPORTED_TARGET_PROPERTIES )
foreach(target_to_export ${targets_to_export})
get_target_property(autoload_targets ${target_to_export} MITK_AUTOLOAD_TARGETS)
if(autoload_targets)
set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_TARGETS \"${autoload_targets}\")")
endif()
get_target_property(autoload_dir ${target_to_export} MITK_AUTOLOAD_DIRECTORY)
if(autoload_dir)
set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_DIRECTORY \"${autoload_dir}\")")
endif()
endforeach()
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)
set(VISIBILITY_AVAILABLE 0)
set(visibility_test_flag "")
mitkFunctionCheckCompilerFlags("-fvisibility=hidden" visibility_test_flag)
if(visibility_test_flag)
# The compiler understands -fvisiblity=hidden (probably gcc >= 4 or Clang)
set(VISIBILITY_AVAILABLE 1)
endif()
configure_file(mitkExportMacros.h.in ${MITK_BINARY_DIR}/mitkExportMacros.h)
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)
file(GLOB _MODULES_CONF_FILES RELATIVE ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME} ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}/*.cmake)
set(MITK_MODULE_NAMES)
foreach(_module ${_MODULES_CONF_FILES})
string(REPLACE Config.cmake "" _module_name ${_module})
list(APPEND MITK_MODULE_NAMES ${_module_name})
endforeach()
configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
# If we are under Windows, create two batch files which correctly
# set up the environment for the application and for Visual Studio
if(WIN32)
include(mitkFunctionCreateWindowsBatchScript)
set(VS_SOLUTION_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln")
foreach(VS_BUILD_TYPE debug release)
mitkFunctionCreateWindowsBatchScript("${MITK_SOURCE_DIR}/CMake/StartVS.bat.in"
${PROJECT_BINARY_DIR}/StartVS_${VS_BUILD_TYPE}.bat
${VS_BUILD_TYPE})
endforeach()
endif(WIN32)
#-----------------------------------------------------------------------------
# MITK Applications
#-----------------------------------------------------------------------------
# This must come after MITKConfig.h was generated, since applications
# might do a find_package(MITK REQUIRED).
add_subdirectory(Applications)
#-----------------------------------------------------------------------------
# MITK Examples
#-----------------------------------------------------------------------------
if(MITK_BUILD_EXAMPLES)
# This must come after MITKConfig.h was generated, since applications
# might do a find_package(MITK REQUIRED).
add_subdirectory(Examples)
endif()
diff --git a/Core/Code/Algorithms/itkLocalVariationImageFilter.h b/Core/Code/Algorithms/itkLocalVariationImageFilter.h
index e2e611010b..b7f4c45020 100644
--- a/Core/Code/Algorithms/itkLocalVariationImageFilter.h
+++ b/Core/Code/Algorithms/itkLocalVariationImageFilter.h
@@ -1,119 +1,119 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkLocalVariationImageFilter_h
#define __itkLocalVariationImageFilter_h
#include "itkImageToImageFilter.h"
#include "itkImage.h"
namespace itk
{
template<class TPixelType>
class SquaredEuclideanMetric
{
public:
static double Calc(TPixelType p);
};
/** \class LocalVariationImageFilter
* \brief Calculates the local variation in each pixel
*
* Reference: Tony F. Chan et al., The digital TV filter and nonlinear denoising
*
* \sa Image
* \sa Neighborhood
* \sa NeighborhoodOperator
* \sa NeighborhoodIterator
*
* \ingroup IntensityImageFilters
*/
template <class TInputImage, class TOutputImage>
class LocalVariationImageFilter :
public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
/** Extract dimension from input and output image. */
itkStaticConstMacro(InputImageDimension, unsigned int,
TInputImage::ImageDimension);
itkStaticConstMacro(OutputImageDimension, unsigned int,
TOutputImage::ImageDimension);
/** Convenient typedefs for simplifying declarations. */
typedef TInputImage InputImageType;
typedef TOutputImage OutputImageType;
/** Standard class typedefs. */
typedef LocalVariationImageFilter Self;
typedef ImageToImageFilter< InputImageType, OutputImageType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(LocalVariationImageFilter, ImageToImageFilter);
/** Image typedef support. */
typedef typename InputImageType::PixelType InputPixelType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef typename OutputImageType::RegionType OutputImageRegionType;
typedef typename InputImageType::SizeType InputSizeType;
/** MedianImageFilter needs a larger input requested region than
* the output requested region. As such, MedianImageFilter needs
* to provide an implementation for GenerateInputRequestedRegion()
* in order to inform the pipeline execution model.
*
* \sa ImageToImageFilter::GenerateInputRequestedRegion() */
virtual void GenerateInputRequestedRegion()
throw(InvalidRequestedRegionError);
protected:
LocalVariationImageFilter();
virtual ~LocalVariationImageFilter() {}
void PrintSelf(std::ostream& os, Indent indent) const;
/** MedianImageFilter can be implemented as a multithreaded filter.
* Therefore, this implementation provides a ThreadedGenerateData()
* routine which is called for each processing thread. The output
* image data is allocated automatically by the superclass prior to
* calling ThreadedGenerateData(). ThreadedGenerateData can only
* write to the portion of the output image specified by the
* parameter "outputRegionForThread"
*
* \sa ImageToImageFilter::ThreadedGenerateData(),
* ImageToImageFilter::GenerateData() */
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId );
+ ThreadIdType threadId );
private:
LocalVariationImageFilter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkLocalVariationImageFilter.txx"
#endif
#endif //LocalVariationImageFilter
diff --git a/Core/Code/Algorithms/itkLocalVariationImageFilter.txx b/Core/Code/Algorithms/itkLocalVariationImageFilter.txx
index 40f53ede2d..b92e2d0476 100644
--- a/Core/Code/Algorithms/itkLocalVariationImageFilter.txx
+++ b/Core/Code/Algorithms/itkLocalVariationImageFilter.txx
@@ -1,217 +1,217 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef _itkLocalVariationImageFilter_txx
#define _itkLocalVariationImageFilter_txx
#include "itkLocalVariationImageFilter.h"
#include "itkConstShapedNeighborhoodIterator.h"
#include "itkNeighborhoodInnerProduct.h"
#include "itkImageRegionIterator.h"
#include "itkNeighborhoodAlgorithm.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
#include "itkOffset.h"
#include "itkProgressReporter.h"
#include "itkVectorImage.h"
#include <vector>
#include <algorithm>
namespace itk
{
template <class TInputImage, class TOutputImage>
LocalVariationImageFilter<TInputImage, TOutputImage>
::LocalVariationImageFilter()
{}
template <class TInputImage, class TOutputImage>
void
LocalVariationImageFilter<TInputImage, TOutputImage>
::GenerateInputRequestedRegion() throw (InvalidRequestedRegionError)
{
// call the superclass' implementation of this method
Superclass::GenerateInputRequestedRegion();
// get pointers to the input and output
typename Superclass::InputImagePointer inputPtr =
const_cast< TInputImage * >( this->GetInput() );
typename Superclass::OutputImagePointer outputPtr = this->GetOutput();
if ( !inputPtr || !outputPtr )
{
return;
}
// get a copy of the input requested region (should equal the output
// requested region)
typename TInputImage::RegionType inputRequestedRegion;
inputRequestedRegion = inputPtr->GetRequestedRegion();
// pad the input requested region by 1
inputRequestedRegion.PadByRadius( 1 );
// crop the input requested region at the input's largest possible region
if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) )
{
inputPtr->SetRequestedRegion( inputRequestedRegion );
return;
}
else
{
// Couldn't crop the region (requested region is outside the largest
// possible region). Throw an exception.
// store what we tried to request (prior to trying to crop)
inputPtr->SetRequestedRegion( inputRequestedRegion );
// build an exception
InvalidRequestedRegionError e(__FILE__, __LINE__);
e.SetLocation(ITK_LOCATION);
e.SetDescription("Requested region outside possible region.");
e.SetDataObject(inputPtr);
throw e;
}
}
template<> double SquaredEuclideanMetric<itk::VariableLengthVector<float> >::
Calc(itk::VariableLengthVector<float> p)
{
return p.GetSquaredNorm();
}
template<> double SquaredEuclideanMetric<itk::VariableLengthVector<double> >::
Calc(itk::VariableLengthVector<double> p)
{
return p.GetSquaredNorm();
}
template<class TPixelType> double
SquaredEuclideanMetric<TPixelType>::Calc(TPixelType p)
{
return p*p;
}
template< class TInputImage, class TOutputImage>
void
LocalVariationImageFilter< TInputImage, TOutputImage>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId)
+ ThreadIdType threadId)
{
// Allocate output
typename OutputImageType::Pointer output = this->GetOutput();
typename InputImageType::ConstPointer input = this->GetInput();
itk::Size<InputImageDimension> size;
for( int i=0; i<InputImageDimension; i++)
size[i] = 1;
// Find the data-set boundary "faces"
NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<InputImageType> bC;
typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType
faceList = bC(input, outputRegionForThread, size);
// support progress methods/callbacks
ProgressReporter progress(
this, threadId, outputRegionForThread.GetNumberOfPixels());
ZeroFluxNeumannBoundaryCondition<InputImageType> nbc;
std::vector<InputPixelType> pixels;
// Process each of the boundary faces. These are N-d regions which border
// the edge of the buffer.
for ( typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType::iterator
fit=faceList.begin(); fit != faceList.end(); ++fit)
{
// iterators over output and input
ImageRegionIterator<OutputImageType>
output_image_it(output, *fit);
ImageRegionConstIterator<InputImageType>
input_image_it(input.GetPointer(), *fit);
// neighborhood iterator for input image
ConstShapedNeighborhoodIterator<InputImageType>
input_image_neighbors_it(size, input, *fit);
typename ConstShapedNeighborhoodIterator<InputImageType>::
OffsetType offset;
input_image_neighbors_it.OverrideBoundaryCondition(&nbc);
input_image_neighbors_it.ClearActiveList();
for(int i=0; i<InputImageDimension; i++)
{
offset.Fill(0);
offset[i] = -1;
input_image_neighbors_it.ActivateOffset(offset);
offset[i] = 1;
input_image_neighbors_it.ActivateOffset(offset);
}
input_image_neighbors_it.GoToBegin();
//const unsigned int neighborhoodSize = InputImageDimension*2;
while ( ! input_image_neighbors_it.IsAtEnd() )
{
// collect all the pixels in the neighborhood, note that we use
// GetPixel on the NeighborhoodIterator to honor the boundary conditions
typename OutputImageType::PixelType locVariation = 0;
typename ConstShapedNeighborhoodIterator<InputImageType>::
ConstIterator input_neighbors_it;
for (input_neighbors_it = input_image_neighbors_it.Begin();
! input_neighbors_it.IsAtEnd();
input_neighbors_it++)
{
typename TInputImage::PixelType diffVec =
input_neighbors_it.Get()-input_image_it.Get();
locVariation += SquaredEuclideanMetric
<typename TInputImage::PixelType>::Calc(diffVec);
}
locVariation = sqrt(locVariation + 0.0001);
output_image_it.Set(locVariation);
// update iterators
++input_image_neighbors_it;
++output_image_it;
++input_image_it;
// report progress
progress.CompletedPixel();
}
}
}
/**
* Standard "PrintSelf" method
*/
template <class TInputImage, class TOutput>
void
LocalVariationImageFilter<TInputImage, TOutput>
::PrintSelf(
std::ostream& os,
Indent indent) const
{
Superclass::PrintSelf( os, indent );
}
} // end namespace itk
#endif //_itkLocalVariationImageFilter_txx
diff --git a/Core/Code/Algorithms/itkMITKScalarImageToHistogramGenerator.h b/Core/Code/Algorithms/itkMITKScalarImageToHistogramGenerator.h
index 7e9789a1b8..166300f375 100644
--- a/Core/Code/Algorithms/itkMITKScalarImageToHistogramGenerator.h
+++ b/Core/Code/Algorithms/itkMITKScalarImageToHistogramGenerator.h
@@ -1,106 +1,100 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkMITKScalarImageToHistogramGenerator_h
#define __itkMITKScalarImageToHistogramGenerator_h
-#include "itkScalarImageToListAdaptor.h"
-#include "itkListSampleToHistogramGenerator.h"
-#include "itkObject.h"
+#include <itkImageToListSampleAdaptor.h>
+#include <itkSampleToHistogramFilter.h>
+#include <itkObject.h>
namespace itk {
namespace Statistics {
-template< class TImageType, class TMeasurementType =
- ITK_TYPENAME TImageType::PixelType>
+template <class TImageType, class TMeasurementType = typename TImageType::PixelType>
class MITKScalarImageToHistogramGenerator : public Object
{
public:
/** Standard typedefs */
typedef MITKScalarImageToHistogramGenerator Self;
typedef Object Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Run-time type information (and related methods). */
itkTypeMacro(MITKScalarImageToHistogramGenerator, Object);
/** standard New() method support */
itkNewMacro(Self);
- typedef TImageType ImageType;
- typedef itk::Statistics::ScalarImageToListAdaptor<
- ImageType
- > AdaptorType;
- typedef typename AdaptorType::Pointer AdaptorPointer;
- typedef typename ImageType::PixelType PixelType;
+ typedef TImageType ImageType;
+ typedef itk::Statistics::ImageToListSampleAdaptor<ImageType> AdaptorType;
+ typedef typename AdaptorType::Pointer AdaptorPointer;
+ typedef typename ImageType::PixelType PixelType;
- typedef itk::Statistics::ListSampleToHistogramGenerator<
- AdaptorType,
- TMeasurementType
- > GeneratorType;
+ typedef itk::Statistics::Histogram<TMeasurementType, itk::Statistics::DenseFrequencyContainer2> HistogramType;
+ typedef itk::Statistics::SampleToHistogramFilter<AdaptorType, HistogramType> GeneratorType;
- typedef typename GeneratorType::Pointer GeneratorPointer;
+ typedef typename GeneratorType::Pointer GeneratorPointer;
- typedef typename GeneratorType::HistogramType HistogramType;
- typedef typename HistogramType::Pointer HistogramPointer;
- typedef typename HistogramType::ConstPointer HistogramConstPointer;
+ typedef typename HistogramType::Pointer HistogramPointer;
+ typedef typename HistogramType::ConstPointer HistogramConstPointer;
public:
/** Triggers the Computation of the histogram */
void Compute( void );
/** Connects the input image for which the histogram is going to be computed */
void SetInput( const ImageType * );
/** Return the histogram. o
\warning This output is only valid after the Compute() method has been invoked
\sa Compute */
const HistogramType * GetOutput() const;
/** Set number of histogram bins */
void SetNumberOfBins( unsigned int numberOfBins );
/** Set marginal scale value to be passed to the histogram generator */
void SetMarginalScale( double marginalScale );
protected:
MITKScalarImageToHistogramGenerator();
virtual ~MITKScalarImageToHistogramGenerator() {};
void PrintSelf(std::ostream& os, Indent indent) const;
private:
AdaptorPointer m_ImageToListAdaptor;
GeneratorPointer m_HistogramGenerator;
};
} // end of namespace Statistics
} // end of namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMITKScalarImageToHistogramGenerator.txx"
#endif
#endif
diff --git a/Core/Code/Algorithms/itkMITKScalarImageToHistogramGenerator.txx b/Core/Code/Algorithms/itkMITKScalarImageToHistogramGenerator.txx
index 6b3ff138aa..cedb9f0482 100644
--- a/Core/Code/Algorithms/itkMITKScalarImageToHistogramGenerator.txx
+++ b/Core/Code/Algorithms/itkMITKScalarImageToHistogramGenerator.txx
@@ -1,112 +1,112 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef _itkMITKScalarImageToHistogramGenerator_txx
#define _itkMITKScalarImageToHistogramGenerator_txx
#include "itkMITKScalarImageToHistogramGenerator.h"
namespace itk {
namespace Statistics {
template < class TImage, class TMeasurementType >
MITKScalarImageToHistogramGenerator< TImage, TMeasurementType >
::MITKScalarImageToHistogramGenerator()
{
m_ImageToListAdaptor = AdaptorType::New();
m_HistogramGenerator = GeneratorType::New();
- m_HistogramGenerator->SetListSample( m_ImageToListAdaptor );
+ m_HistogramGenerator->SetInput( m_ImageToListAdaptor );
}
template < class TImage, class TMeasurementType >
void
MITKScalarImageToHistogramGenerator< TImage, TMeasurementType >
::SetInput( const ImageType * image )
{
m_ImageToListAdaptor->SetImage( image );
}
template < class TImage, class TMeasurementType >
const typename MITKScalarImageToHistogramGenerator< TImage, TMeasurementType >::HistogramType *
MITKScalarImageToHistogramGenerator< TImage, TMeasurementType >
::GetOutput() const
{
return m_HistogramGenerator->GetOutput();
}
template < class TImage, class TMeasurementType >
void
MITKScalarImageToHistogramGenerator< TImage, TMeasurementType >
::Compute()
{
m_HistogramGenerator->Update();
}
template < class TImage, class TMeasurementType >
void
MITKScalarImageToHistogramGenerator< TImage, TMeasurementType >
::SetNumberOfBins( unsigned int numberOfBins )
{
typename HistogramType::SizeType size;
size.Fill( numberOfBins );
- m_HistogramGenerator->SetNumberOfBins( size );
+ m_HistogramGenerator->SetHistogramSize( size );
}
template < class TImage, class TMeasurementType >
void
MITKScalarImageToHistogramGenerator< TImage, TMeasurementType >
::SetMarginalScale( double marginalScale )
{
m_HistogramGenerator->SetMarginalScale( marginalScale );
}
template < class TImage, class TMeasurementType >
void
MITKScalarImageToHistogramGenerator< TImage, TMeasurementType >
::PrintSelf(std::ostream& os, Indent indent) const
{
Superclass::PrintSelf(os,indent);
os << "ImageToListSample adaptor = " << m_ImageToListAdaptor << std::endl;
os << "HistogramGenerator = " << m_HistogramGenerator << std::endl;
}
} // end of namespace Statistics
} // end of namespace itk
#endif
diff --git a/Core/Code/Algorithms/itkTotalVariationSingleIterationImageFilter.h b/Core/Code/Algorithms/itkTotalVariationSingleIterationImageFilter.h
index 02c7b39a45..7182722248 100644
--- a/Core/Code/Algorithms/itkTotalVariationSingleIterationImageFilter.h
+++ b/Core/Code/Algorithms/itkTotalVariationSingleIterationImageFilter.h
@@ -1,132 +1,132 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkTotalVariationSingleIterationImageFilter_h
#define __itkTotalVariationSingleIterationImageFilter_h
#include "itkImageToImageFilter.h"
#include "itkImage.h"
namespace itk
{
/** \class TotalVariationSingleIterationImageFilter
* \brief Applies a total variation denoising filter to an image
*
* Reference: Tony F. Chan et al., The digital TV filter and nonlinear denoising
*
* \sa Image
* \sa Neighborhood
* \sa NeighborhoodOperator
* \sa NeighborhoodIterator
*
* \ingroup IntensityImageFilters
*/
template <class TInputImage, class TOutputImage>
class TotalVariationSingleIterationImageFilter :
public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
/** Extract dimension from input and output image. */
itkStaticConstMacro(InputImageDimension, unsigned int,
TInputImage::ImageDimension);
itkStaticConstMacro(OutputImageDimension, unsigned int,
TOutputImage::ImageDimension);
/** Convenient typedefs for simplifying declarations. */
typedef TInputImage InputImageType;
typedef TOutputImage OutputImageType;
typedef itk::Image<float,InputImageDimension> LocalVariationImageType;
/** Standard class typedefs. */
typedef TotalVariationSingleIterationImageFilter Self;
typedef ImageToImageFilter< InputImageType, OutputImageType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(TotalVariationSingleIterationImageFilter, ImageToImageFilter);
/** Image typedef support. */
typedef typename InputImageType::PixelType InputPixelType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef typename OutputImageType::RegionType OutputImageRegionType;
typedef typename InputImageType::SizeType InputSizeType;
/** A larger input requested region than
* the output requested region is required.
* Therefore, an implementation for GenerateInputRequestedRegion()
* is provided.
*
* \sa ImageToImageFilter::GenerateInputRequestedRegion() */
virtual void GenerateInputRequestedRegion()
throw(InvalidRequestedRegionError);
itkSetMacro(Lambda, double);
itkGetMacro(Lambda, double);
void SetOriginalImage(InputImageType* in)
{ this->m_OriginalImage = in; }
typename InputImageType::Pointer GetOriginialImage()
{ return this->m_OriginalImage; }
protected:
TotalVariationSingleIterationImageFilter();
virtual ~TotalVariationSingleIterationImageFilter() {}
void PrintSelf(std::ostream& os, Indent indent) const;
/** MedianImageFilter can be implemented as a multithreaded filter.
* Therefore, this implementation provides a ThreadedGenerateData()
* routine which is called for each processing thread. The output
* image data is allocated automatically by the superclass prior to
* calling ThreadedGenerateData(). ThreadedGenerateData can only
* write to the portion of the output image specified by the
* parameter "outputRegionForThread"
*
* \sa ImageToImageFilter::ThreadedGenerateData(),
* ImageToImageFilter::GenerateData() */
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId );
+ ThreadIdType threadId );
void BeforeThreadedGenerateData();
typename LocalVariationImageType::Pointer m_LocalVariation;
typename InputImageType::Pointer m_OriginalImage;
double m_Lambda;
private:
TotalVariationSingleIterationImageFilter(const Self&);
void operator=(const Self&);
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTotalVariationSingleIterationImageFilter.txx"
#endif
#endif //__itkTotalVariationSingleIterationImageFilter__
diff --git a/Core/Code/Algorithms/itkTotalVariationSingleIterationImageFilter.txx b/Core/Code/Algorithms/itkTotalVariationSingleIterationImageFilter.txx
index dd8b9aa972..71b826f7ed 100644
--- a/Core/Code/Algorithms/itkTotalVariationSingleIterationImageFilter.txx
+++ b/Core/Code/Algorithms/itkTotalVariationSingleIterationImageFilter.txx
@@ -1,295 +1,295 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef _itkTotalVariationSingleIterationImageFilter_txx
#define _itkTotalVariationSingleIterationImageFilter_txx
#include "itkTotalVariationSingleIterationImageFilter.h"
// itk includes
#include "itkConstShapedNeighborhoodIterator.h"
#include "itkNeighborhoodInnerProduct.h"
#include "itkImageRegionIterator.h"
#include "itkNeighborhoodAlgorithm.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
#include "itkOffset.h"
#include "itkProgressReporter.h"
#include "itkLocalVariationImageFilter.h"
// other includes
#include <vector>
#include <algorithm>
namespace itk
{
/**
* constructor
*/
template <class TInputImage, class TOutputImage>
TotalVariationSingleIterationImageFilter<TInputImage, TOutputImage>
::TotalVariationSingleIterationImageFilter()
{
m_Lambda = 1.0;
m_LocalVariation = LocalVariationImageType::New();
}
/**
* generate requested region
*/
template <class TInputImage, class TOutputImage>
void
TotalVariationSingleIterationImageFilter<TInputImage, TOutputImage>
::GenerateInputRequestedRegion() throw (InvalidRequestedRegionError)
{
// call the superclass' implementation of this method
Superclass::GenerateInputRequestedRegion();
// get pointers to the input and output
typename Superclass::InputImagePointer inputPtr =
const_cast< TInputImage * >( this->GetInput() );
typename Superclass::OutputImagePointer outputPtr = this->GetOutput();
if ( !inputPtr || !outputPtr )
{
return;
}
// get a copy of the input requested region (should equal the output
// requested region)
typename TInputImage::RegionType inputRequestedRegion;
inputRequestedRegion = inputPtr->GetRequestedRegion();
// pad the input requested region by 1
inputRequestedRegion.PadByRadius( 1 );
// crop the input requested region at the input's largest possible region
if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) )
{
inputPtr->SetRequestedRegion( inputRequestedRegion );
return;
}
else
{
// Couldn't crop the region (requested region is outside the largest
// possible region). Throw an exception.
// store what we tried to request (prior to trying to crop)
inputPtr->SetRequestedRegion( inputRequestedRegion );
// build an exception
InvalidRequestedRegionError e(__FILE__, __LINE__);
e.SetLocation(ITK_LOCATION);
e.SetDescription("Requested region outside possible region.");
e.SetDataObject(inputPtr);
throw e;
}
}
/**
* generate output
*/
template< class TInputImage, class TOutputImage>
void
TotalVariationSingleIterationImageFilter< TInputImage, TOutputImage>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId)
+ ThreadIdType threadId)
{
typename OutputImageType::Pointer output = this->GetOutput();
typename InputImageType::ConstPointer input = this->GetInput();
// Find the data-set boundary "faces"
itk::Size<InputImageDimension> size;
for( int i=0; i<InputImageDimension; i++)
size[i] = 1;
NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<InputImageType> bC;
typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType
faceList = bC(input, outputRegionForThread, size);
NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<LocalVariationImageType> lv_bC;
typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<LocalVariationImageType>::FaceListType
lv_faceList = lv_bC(m_LocalVariation, outputRegionForThread, size);
// support progress methods/callbacks
ProgressReporter progress(
this, threadId, outputRegionForThread.GetNumberOfPixels());
ZeroFluxNeumannBoundaryCondition<InputImageType> nbc;
ZeroFluxNeumannBoundaryCondition<LocalVariationImageType> lv_nbc;
std::vector<double> ws;
std::vector<double> hs;
typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType::iterator
lv_fit=lv_faceList.begin();
// Process each of the boundary faces. These are N-d regions which border
// the edge of the buffer.
for ( typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType::iterator
fit=faceList.begin(); fit != faceList.end(); ++fit)
{
// iterators over output, input, original and local variation image
ImageRegionIterator<OutputImageType> output_image_it =
ImageRegionIterator<OutputImageType>(output, *fit);
ImageRegionConstIterator<InputImageType> input_image_it =
ImageRegionConstIterator<InputImageType>(input, *fit);
ImageRegionConstIterator<InputImageType> orig_image_it =
ImageRegionConstIterator<InputImageType>(m_OriginalImage, *fit);
ImageRegionConstIterator<LocalVariationImageType> loc_var_image_it =
ImageRegionConstIterator<LocalVariationImageType>(
m_LocalVariation, *fit);
// neighborhood in input image
ConstShapedNeighborhoodIterator<InputImageType>
input_image_neighbors_it(size, input, *fit);
typename ConstShapedNeighborhoodIterator<InputImageType>::
OffsetType offset;
input_image_neighbors_it.OverrideBoundaryCondition(&nbc);
input_image_neighbors_it.ClearActiveList();
for(int i=0; i<InputImageDimension; i++)
{
offset.Fill(0);
offset[i] = -1;
input_image_neighbors_it.ActivateOffset(offset);
offset[i] = 1;
input_image_neighbors_it.ActivateOffset(offset);
}
input_image_neighbors_it.GoToBegin();
// neighborhood in local variation image
ConstShapedNeighborhoodIterator<LocalVariationImageType>
loc_var_image_neighbors_it(size, m_LocalVariation, *lv_fit);
loc_var_image_neighbors_it.OverrideBoundaryCondition(&lv_nbc);
loc_var_image_neighbors_it.ClearActiveList();
for(int i=0; i<InputImageDimension; i++)
{
offset.Fill(0);
offset[i] = -1;
loc_var_image_neighbors_it.ActivateOffset(offset);
offset[i] = 1;
loc_var_image_neighbors_it.ActivateOffset(offset);
}
loc_var_image_neighbors_it.GoToBegin();
const unsigned int neighborhoodSize = InputImageDimension*2;
ws.resize(neighborhoodSize);
while ( ! output_image_it.IsAtEnd() )
{
// 1 / ||nabla_alpha(u)||_a
double locvar_alpha_inv = 1.0/loc_var_image_it.Get();
// compute w_alphabetas
int count = 0;
double wsum = 0;
typename ConstShapedNeighborhoodIterator<LocalVariationImageType>::
ConstIterator loc_var_neighbors_it;
for (loc_var_neighbors_it = loc_var_image_neighbors_it.Begin();
! loc_var_neighbors_it.IsAtEnd();
loc_var_neighbors_it++)
{
// w_alphabeta(u) =
// 1 / ||nabla_alpha(u)||_a + 1 / ||nabla_beta(u)||_a
ws[count] =
locvar_alpha_inv + (1.0/(double)loc_var_neighbors_it.Get());
wsum += ws[count++];
}
// h_alphaalpha * u_alpha^zero
typename OutputImageType::PixelType res =
static_cast<typename OutputImageType::PixelType>(
((typename OutputImageType::PixelType)
orig_image_it.Get()) * (m_Lambda / (m_Lambda+wsum)));
// add the different h_alphabeta * u_beta
count = 0;
typename ConstShapedNeighborhoodIterator<InputImageType>::
ConstIterator input_neighbors_it;
for (input_neighbors_it = input_image_neighbors_it.Begin();
! input_neighbors_it.IsAtEnd();
input_neighbors_it++)
{
res += input_neighbors_it.Get() * (ws[count++] / (m_Lambda+wsum));
}
// set output result
output_image_it.Set( res );
// increment iterators
++output_image_it;
++input_image_it;
++orig_image_it;
++loc_var_image_it;
++input_image_neighbors_it;
++loc_var_image_neighbors_it;
// report progress
progress.CompletedPixel();
}
++lv_fit;
}
}
/**
* first calculate local variation in the image
*/
template< class TInputImage, class TOutputImage>
void
TotalVariationSingleIterationImageFilter< TInputImage, TOutputImage>
::BeforeThreadedGenerateData()
{
typedef typename itk::LocalVariationImageFilter
<TInputImage,LocalVariationImageType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(this->GetInput(0));
filter->SetNumberOfThreads(this->GetNumberOfThreads());
filter->Update();
this->m_LocalVariation = filter->GetOutput();
}
/**
* Standard "PrintSelf" method
*/
template <class TInputImage, class TOutput>
void
TotalVariationSingleIterationImageFilter<TInputImage, TOutput>
::PrintSelf(
std::ostream& os,
Indent indent) const
{
Superclass::PrintSelf( os, indent );
}
} // end namespace itk
#endif
diff --git a/Core/Code/Algorithms/mitkBaseDataSource.cpp b/Core/Code/Algorithms/mitkBaseDataSource.cpp
index 58361e82ff..bcaed5f97d 100644
--- a/Core/Code/Algorithms/mitkBaseDataSource.cpp
+++ b/Core/Code/Algorithms/mitkBaseDataSource.cpp
@@ -1,68 +1,63 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-
#include "mitkBaseDataSource.h"
-
+#include "mitkBaseData.h"
mitk::BaseDataSource::BaseDataSource()
{
- // Pure virtual functions may not be called in the constructor...
- // see ( see Bjarne Stroustrup's C++ PL 3rd ed section 15.4.3 )
- //OutputType::Pointer output = static_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
- //Superclass::SetNumberOfRequiredOutputs( 1 );
- //Superclass::SetNthOutput( 0, output.GetPointer() );
}
-
-
mitk::BaseDataSource::~BaseDataSource()
{
}
-
-
-void mitk::BaseDataSource::SetOutput( OutputType* output )
+void mitk::BaseDataSource::GraftOutput(OutputType* graft)
{
- this->SetNthOutput( 0, output );
+ this->GraftNthOutput(0, graft);
}
-
-
-void mitk::BaseDataSource::SetOutput( unsigned int idx, OutputType* output )
+void mitk::BaseDataSource::GraftOutput(const DataObjectIdentifierType& key, OutputType* graft)
{
- this->SetNthOutput(idx, output);
-}
+ if ( !graft )
+ {
+ itkExceptionMacro(<< "Requested to graft output that is a NULL pointer");
+ }
+ // we use the process object method since all our output may not be
+ // of the same type
+ itk::DataObject *output = this->ProcessObject::GetOutput(key);
+ // Call GraftImage to copy meta-information, regions, and the pixel container
+ output->Graft(graft);
+}
-mitk::BaseDataSource::OutputType* mitk::BaseDataSource::GetOutput()
+void mitk::BaseDataSource::GraftNthOutput(unsigned int idx, OutputType* graft)
{
- if ( this->GetNumberOfOutputs() < 1 )
- {
- return 0;
- }
- return static_cast<OutputType*> ( Superclass::GetOutput( 0 ) );
+ if ( idx >= this->GetNumberOfIndexedOutputs() )
+ {
+ itkExceptionMacro(<< "Requested to graft output " << idx
+ << " but this filter only has " << this->GetNumberOfIndexedOutputs() << " indexed Outputs.");
+ }
+ this->GraftOutput( this->MakeNameFromOutputIndex(idx), graft );
}
-
-
-mitk::BaseDataSource::OutputType* mitk::BaseDataSource::GetOutput ( unsigned int idx )
+bool mitk::BaseDataSource::Updating() const
{
- return static_cast<OutputType*> ( Superclass::GetOutput( idx ) );
+ return this->m_Updating;
}
-
+mitkBaseDataSourceGetOutputDefinitions(mitk::BaseDataSource)
diff --git a/Core/Code/Algorithms/mitkBaseDataSource.h b/Core/Code/Algorithms/mitkBaseDataSource.h
index 605d71ece1..0f16fb2af4 100644
--- a/Core/Code/Algorithms/mitkBaseDataSource.h
+++ b/Core/Code/Algorithms/mitkBaseDataSource.h
@@ -1,94 +1,162 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#ifndef _MITK_BASE_DATA_SOURCE_H
-#define _MITK_BASE_DATA_SOURCE_H
-
-#include "mitkBaseProcess.h"
-#include "mitkBaseData.h"
-
-namespace mitk
-{
+#ifndef MITK_BASE_DATA_SOURCE_H
+#define MITK_BASE_DATA_SOURCE_H
+
+#include <MitkExports.h>
+#include <mitkCommon.h>
+#include <itkProcessObject.h>
+
+#define mitkBaseDataSourceGetOutputDeclarations \
+ OutputType* GetOutput(); \
+ const OutputType* GetOutput() const; \
+ OutputType* GetOutput(DataObjectPointerArraySizeType idx); \
+ const OutputType* GetOutput(DataObjectPointerArraySizeType idx) const;
+
+#define mitkBaseDataSourceGetOutputDefinitions(className) \
+ className::OutputType* className::GetOutput(void) \
+ { \
+ return itkDynamicCastInDebugMode<OutputType*>( this->GetPrimaryOutput() ); \
+ } \
+ const className::OutputType* className::GetOutput(void) const \
+ { \
+ return itkDynamicCastInDebugMode<const OutputType*>( this->GetPrimaryOutput() ); \
+ } \
+ className::OutputType* className::GetOutput(DataObjectPointerArraySizeType idx) \
+ { \
+ OutputType* out = dynamic_cast<OutputType*>( this->ProcessObject::GetOutput(idx) ); \
+ if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL ) \
+ { \
+ itkWarningMacro (<< "Unable to convert output number " << idx << " to type " << typeid( OutputType ).name () ); \
+ } \
+ return out; \
+ } \
+ const className::OutputType* className::GetOutput(DataObjectPointerArraySizeType idx) const \
+ { \
+ const OutputType* out = dynamic_cast<const OutputType*>( this->ProcessObject::GetOutput(idx) ); \
+ if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL ) \
+ { \
+ itkWarningMacro (<< "Unable to convert output number " << idx << " to type " << typeid( OutputType ).name () ); \
+ } \
+ return out; \
+ }
+
+
+namespace mitk {
+
+class BaseData;
/**
- * @brief Superclass of all classes generating base data (instances of class
- * mitk::BaseData) as output.
+ * @brief Superclass of all classes generating some kind of mitk::BaseData.
*
+ * Superclass of all classes generating some kind of mitk::BaseData.
* In itk and vtk the generated result of a ProcessObject is only guaranteed
* to be up-to-date, when Update() of the ProcessObject or the generated
* DataObject is called immediately before access of the data stored in the
- * DataObject. This is also true for subclasses of mitk::BaseProcess and thus
- * for mitk::BaseDataSource.
+ * DataObject. This is also true for subclasses of mitk::BaseProcess. But
+ * many of the subclasses of mitk::BaseProcess define additional access
+ * functions to the generated output that guarantee an up-to-date result, see
+ * for example mitk::ImageSource.
* @ingroup Process
*/
-class MITK_CORE_EXPORT BaseDataSource : public BaseProcess
+class MITK_CORE_EXPORT BaseDataSource : public itk::ProcessObject
{
public:
- mitkClassMacro( BaseDataSource, BaseProcess );
-
- typedef mitk::BaseData OutputType;
-
- typedef OutputType::Pointer OutputTypePointer;
-
- /**
- * Allocates a new output object and returns it. This function
- * is pure virtual because mitk::BaseData contains pure virtual functions
- * and can not directly be instantiated. This must be done by subclasses, which
- * know which subclasses of mitk::BaseData they want to instantiate. Thus, these
- * classes have to set their output themselves via this->SetOutput(MakeOutput(0))
- * in the constructor!
- * @param idx the index of the output for which an object should be created
- * @returns the new object
- */
- virtual itk::DataObject::Pointer MakeOutput ( unsigned int idx ) = 0;
-
- /**
- * Allows to set the output of the base data source.
- * @param output the intended output of the base data source
- */
- virtual void SetOutput( OutputType* output );
-
- /**
- * Allows to set the n-th output of the base data source.
- * @param idx The index of the output
- * @param output The intended output of the base data source
- */
- virtual void SetOutput( unsigned int idx, OutputType* output );
-
- /**
- * Returns the output with index 0 of the base data source
- * @returns the output
- */
- virtual OutputType* GetOutput();
-
- /**
- * Returns the n'th output of the base data source
- * @param idx the index of the wanted output
- * @returns the output with index idx.
- */
- virtual OutputType* GetOutput ( unsigned int idx );
+
+ mitkClassMacro(BaseDataSource, itk::ProcessObject)
+
+ typedef BaseData OutputType;
+ typedef itk::DataObject::DataObjectIdentifierType DataObjectIdentifierType;
+
+ mitkBaseDataSourceGetOutputDeclarations
+
+ /** @brief Graft the specified BaseData onto this BaseDataSource's output.
+ *
+ * This method is used when a
+ * process object is implemented using a mini-pipeline which is
+ * defined in its GenerateData() method. The usage is:
+ *
+ * \code
+ * // setup the mini-pipeline to process the input to this filter
+ * firstFilterInMiniPipeline->SetInput( this->GetInput() );
+
+ * // setup the mini-pipeline to calculate the correct regions
+ * // and write to the appropriate bulk data block
+ * lastFilterInMiniPipeline->GraftOutput( this->GetOutput(0) );
+ *
+ * // execute the mini-pipeline
+ * lastFilterInMiniPipeline->Update();
+ *
+ * // graft the mini-pipeline output back onto this filter's output.
+ * // this is needed to get the appropriate regions passed back.
+ * this->GraftOutput( lastFilterInMiniPipeline->GetOutput(0) );
+ * \endcode
+ */
+ virtual void GraftOutput(OutputType* output);
+
+ /**
+ * Graft the specified base data object onto this BaseDataSource's named
+ * output. This is similar to the GraftOutput method except it
+ * allows you to specify which output is affected.
+ * See the GraftOutput for general usage information.
+ */
+ virtual void GraftOutput(const DataObjectIdentifierType & key, OutputType* output);
+
+ /** @brief Graft the specified base data object onto this BaseDataSource's idx'th
+ * output.
+ *
+ * This is the similar to GraftOutput method except is
+ * allows you specify which output is affected. The specified index
+ * must be a valid output number (less than
+ * ProcessObject::GetNumberOfOutputs()). See the GraftOutput for
+ * general usage information.
+ */
+ virtual void GraftNthOutput(unsigned int idx, OutputType* output);
+
+ /**
+ * @sa itk::ProcessObject::MakeOutput(DataObjectPointerArraySizeType)
+ */
+ virtual DataObjectPointer MakeOutput ( DataObjectPointerArraySizeType idx ) = 0;
+
+ /**
+ * @sa itk::ProcessObject::MakeOutput(const DataObjectIdentifierType&)
+ */
+ virtual DataObjectPointer MakeOutput(const DataObjectIdentifierType& name) = 0;
+
+ /**
+ * @brief Access itk::ProcessObject::m_Updating
+ *
+ * m_Updating indicates when the pipeline is executing.
+ * It prevents infinite recursion when pipelines have loops.
+ * \sa itk::ProcessObject::m_Updating
+ **/
+ bool Updating() const;
protected:
- BaseDataSource();
+ BaseDataSource();
+ virtual ~BaseDataSource();
- virtual ~BaseDataSource();
+ // purposely not implemented
+ static Pointer New();
};
-}
-#endif // #define _MITK_BASE_DATA_SOURCE_H
+} // namespace mitk
+
+#endif /* MITK_BASE_DATA_SOURCE_H */
diff --git a/Core/Code/Algorithms/mitkBaseProcess.cpp b/Core/Code/Algorithms/mitkBaseProcess.cpp
deleted file mode 100644
index b21da0de4a..0000000000
--- a/Core/Code/Algorithms/mitkBaseProcess.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#include "mitkBaseProcess.h"
-#include "mitkBaseData.h"
-
-
-#define MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
-
-mitk::BaseProcess::BaseProcess() : m_Unregistering(false), m_CalculatingExternalReferenceCount(false), m_ExternalReferenceCount(-1)
-{
-
-}
-
-mitk::BaseProcess::~BaseProcess()
-{
-
-}
-
-int mitk::BaseProcess::GetExternalReferenceCount() const
-{
- if(m_CalculatingExternalReferenceCount==false) //this is only needed because a smart-pointer to m_Outputs (private!!) must be created by calling GetOutputs.
- {
- m_CalculatingExternalReferenceCount = true;
-
- m_ExternalReferenceCount = -1;
-
- DataObjectPointerArray& outputs = const_cast<mitk::BaseProcess*>(this)->GetOutputs();
-
- int realReferenceCount = GetReferenceCount();
-
- unsigned int idx;
- for (idx = 0; idx < outputs.size(); ++idx)
- {
- //references of outputs that are not referenced from someone else (reference additional to the reference from this BaseProcess object) are interpreted as non-existent
- if((outputs[idx]) && (outputs[idx]->GetReferenceCount()==1))
- --realReferenceCount;
- }
- m_ExternalReferenceCount = realReferenceCount;
- if(m_ExternalReferenceCount<0)
- m_ExternalReferenceCount=0;
- }
- else
- return -1;
- m_CalculatingExternalReferenceCount = false; //do not move in if-part!!!
- return m_ExternalReferenceCount;
-}
-
-void mitk::BaseProcess::UnRegister() const
-{
-#ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
- if((m_Unregistering==false) && (m_CalculatingExternalReferenceCount==false))
- {
- m_Unregistering=true;
-
- int realReferenceCount = GetExternalReferenceCount()-1; //-1 because someone is trying to unregister us
- if(realReferenceCount<0)
- m_ExternalReferenceCount=realReferenceCount=0;
-
- if(realReferenceCount==0)
- {
- DataObjectPointerArray& outputs = const_cast<mitk::BaseProcess*>(this)->GetOutputs();
- //disconnect all outputs from us
- //size of outputs will not change until the very last output
- //is removed, because we remove from front to back
- unsigned int idx;
- for (idx = 0; idx < outputs.size(); ++idx)
- {
- const_cast<mitk::BaseProcess*>(this)->RemoveOutput(outputs[idx]);
- }
- //now the referenceCount should be one!
- int testReferenceCount=GetReferenceCount();
- if(testReferenceCount!=1)
- {
- itkWarningMacro(<<"Reference count of process object unexpectedly "
- << "not 1 before final unregister but " << testReferenceCount);
- }
- }
- m_Unregistering=false;
- }
- else
- {
- if(GetReferenceCount()==1)
- {
- //the calling UnRegister will do the last cleanup
- return;
- }
- }
-#endif
- Superclass::UnRegister();
-}
-
-/**
-* Set an output of this filter. This method specifically
-* does not do a Register()/UnRegister() because of the
-* desire to break the reference counting loop.
-*/
-void mitk::BaseProcess::SetNthOutput(unsigned int idx, itk::DataObject *output)
-{
-#ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
- output = dynamic_cast<mitk::BaseData*>(output);
-
- // does this change anything?
- if ( idx < GetOutputs().size() && output == GetOutputs()[idx])
- {
- return;
- }
-
- if (output)
- {
- dynamic_cast<mitk::BaseData*>(output)->ConnectSource(this, idx);
- }
-#endif
- this->Register();
- Superclass::SetNthOutput(idx, output);
- this->UnRegister();
-}
-
-/**
-* Adds an output to the first null position in the output list.
-* Expands the list memory if necessary
-*/
-void mitk::BaseProcess::AddOutput(itk::DataObject *output)
-{
-#ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
- unsigned int idx=0;
-
- output = dynamic_cast<mitk::BaseData*>(output);
-
- if (output)
- {
- dynamic_cast<mitk::BaseData*>(output)->ConnectSource(this, idx);
- }
-#endif
- Superclass::AddOutput(output);
-
-}
diff --git a/Core/Code/Algorithms/mitkBaseProcess.h b/Core/Code/Algorithms/mitkBaseProcess.h
index c04b835ae9..571ce66eed 100644
--- a/Core/Code/Algorithms/mitkBaseProcess.h
+++ b/Core/Code/Algorithms/mitkBaseProcess.h
@@ -1,110 +1,29 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef BASEPROCESS_H_HEADER_INCLUDED_C19BE6FC
#define BASEPROCESS_H_HEADER_INCLUDED_C19BE6FC
-#if(_MSC_VER==1200)
-#include <itkFixedArray.h>
-#endif
-
-#include <MitkExports.h>
-#include <mitkCommon.h>
-#include <itkProcessObject.h>
+#include "mitkBaseDataSource.h"
namespace mitk {
-class BaseData;
-
-//##Documentation
-//## @brief Superclass of all classes generating some kind of mitk::BaseData.
-//##
-//## Superclass of all classes generating some kind of mitk::BaseData.
-//## In itk and vtk the generated result of a ProcessObject is only guaranteed
-//## to be up-to-date, when Update() of the ProcessObject or the generated
-//## DataObject is called immediately before access of the data stored in the
-//## DataObject. This is also true for subclasses of mitk::BaseProcess. But
-//## many of the subclasses of mitk::BaseProcess define additional access
-//## functions to the generated output that guarantee an up-to-date result, see
-//## for example mitk::ImageSource.
-//## @ingroup Process
-class MITK_CORE_EXPORT BaseProcess : public itk::ProcessObject
-{
-public:
- mitkClassMacro(BaseProcess, itk::ProcessObject);
-
- //##Documentation
- //## @brief Access itk::ProcessObject::m_Updating
- //##
- //## m_Updating indicates when the pipeline is executing.
- //## It prevents infinite recursion when pipelines have loops.
- //## \sa itk::ProcessObject::m_Updating
- bool Updating() const
- {
- return m_Updating;
- }
-
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- virtual void UnRegister() const;
-
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- virtual int GetExternalReferenceCount() const;
-
-protected:
-
- BaseProcess();
-
- virtual ~BaseProcess();
-
- //##Documentation
- //## @brief Protected methods for setting outputs.
- //##
- //## Subclasses make use of them for getting output.
- //## These are only overwritten because of itk::DataObject::ConnectSource being
- //## private and non-virtual: the important stuff is done in
- //## mitk::BaseData::ConnectSource.
- virtual void SetNthOutput(unsigned int num, itk::DataObject *output);
-
- //##Documentation
- //## @brief Protected methods for setting outputs.
- //##
- //## Subclasses make use of them for getting output.
- //## These are only overwritten because of itk::DataObject::ConnectSource being
- //## private and non-virtual: the important stuff is done in
- //## mitk::BaseData::ConnectSource.
- virtual void AddOutput(itk::DataObject *output);
-
-private:
-
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- mutable bool m_Unregistering;
-
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- mutable bool m_CalculatingExternalReferenceCount;
-
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- mutable int m_ExternalReferenceCount;
-};
+DEPRECATED(typedef BaseDataSource BaseProcess);
} // namespace mitk
#endif /* BASEPROCESS_H_HEADER_INCLUDED_C19BE6FC */
diff --git a/Core/Code/Algorithms/mitkDataNodeSource.cpp b/Core/Code/Algorithms/mitkDataNodeSource.cpp
index 49f504cf3b..8c0a49c733 100644
--- a/Core/Code/Algorithms/mitkDataNodeSource.cpp
+++ b/Core/Code/Algorithms/mitkDataNodeSource.cpp
@@ -1,84 +1,71 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-
#include "mitkDataNodeSource.h"
-
mitk::DataNodeSource::DataNodeSource()
{
// Create the output.
- OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
- assert (output.IsNotNull());
- this->SetNumberOfOutputs( 1 );
- this->SetOutput(0, output.GetPointer());
+ OutputType::Pointer output = static_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
+ this->SetNthOutput(0, output.GetPointer());
}
-
-
-
mitk::DataNodeSource::~DataNodeSource()
{
}
-
-
-
-itk::DataObject::Pointer mitk::DataNodeSource::MakeOutput ( unsigned int /*idx*/ )
+itk::ProcessObject::DataObjectPointer mitk::DataNodeSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
return OutputType::New().GetPointer();
}
-
-
-void mitk::DataNodeSource::SetOutput( OutputType* output )
+itk::ProcessObject::DataObjectPointer mitk::DataNodeSource::MakeOutput( const DataObjectIdentifierType & name )
{
- this->itk::ProcessObject::SetNthOutput( 0, output );
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
+ {
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
+ }
+ return static_cast<itk::DataObject*>(OutputType::New().GetPointer());
}
-
-
-
-void mitk::DataNodeSource::SetOutput( unsigned int idx, OutputType* output )
+mitk::DataNodeSource::OutputType* mitk::DataNodeSource::GetOutput()
{
- this->itk::ProcessObject::SetNthOutput(idx, output);
+ return itkDynamicCastInDebugMode< OutputType * >( this->GetPrimaryOutput() );
}
-
-
-
-mitk::DataNodeSource::OutputType* mitk::DataNodeSource::GetOutput()
+const mitk::DataNodeSource::OutputType* mitk::DataNodeSource::GetOutput() const
{
- if ( this->GetNumberOfOutputs() < 1 )
- {
- return 0;
- }
- else
- {
- return dynamic_cast<OutputType*> ( this->GetOutput( 0 ) );
- }
+ return itkDynamicCastInDebugMode< const OutputType * >( this->GetPrimaryOutput() );
}
-
-
-
-mitk::DataNodeSource::OutputType* mitk::DataNodeSource::GetOutput ( unsigned int idx )
+mitk::DataNodeSource::OutputType* mitk::DataNodeSource::GetOutput(DataObjectPointerArraySizeType idx)
{
- return dynamic_cast<OutputType*> ( this->itk::ProcessObject::GetOutput( idx ) );
+ return static_cast<OutputType*>(Superclass::GetOutput(idx));
}
+const mitk::DataNodeSource::OutputType* mitk::DataNodeSource::GetOutput(DataObjectPointerArraySizeType idx) const
+{
+ const OutputType *out = dynamic_cast< const OutputType * >
+ ( this->ProcessObject::GetOutput(idx) );
+ if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL )
+ {
+ itkWarningMacro (<< "Unable to convert output number " << idx << " to type " << typeid( OutputType ).name () );
+ }
+ return out;
+}
diff --git a/Core/Code/Algorithms/mitkDataNodeSource.h b/Core/Code/Algorithms/mitkDataNodeSource.h
index 59797f0c36..c07410390f 100644
--- a/Core/Code/Algorithms/mitkDataNodeSource.h
+++ b/Core/Code/Algorithms/mitkDataNodeSource.h
@@ -1,90 +1,78 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_DATA_TREE_NODE_SOURCE_H
#define _MITK_DATA_TREE_NODE_SOURCE_H
#include "itkProcessObject.h"
#include "mitkDataNode.h"
namespace mitk
{
/**
* @brief Superclass of all classes generating data tree nodes (instances of class
* mitk::DataNode) as output.
*
* In itk and vtk the generated result of a ProcessObject is only guaranteed
* to be up-to-date, when Update() of the ProcessObject or the generated
* DataObject is called immediately before access of the data stored in the
* DataObject. This is also true for subclasses of mitk::BaseProcess and thus
* for mitk::DataNodeSource.
* @ingroup Process
*/
- class MITK_CORE_EXPORT DataNodeSource : public itk::ProcessObject
+class MITK_CORE_EXPORT DataNodeSource : public itk::ProcessObject
{
public:
- mitkClassMacro( DataNodeSource, itk::ProcessObject );
+ mitkClassMacro( DataNodeSource, itk::ProcessObject )
- itkNewMacro( Self );
+ itkNewMacro( Self )
typedef mitk::DataNode OutputType;
typedef OutputType::Pointer OutputTypePointer;
/**
* Allocates a new output object and returns it. Currently the
* index idx is not evaluated.
* @param idx the index of the output for which an object should be created
* @returns the new object
*/
- virtual itk::DataObject::Pointer MakeOutput ( unsigned int idx );
+ virtual DataObjectPointer MakeOutput ( DataObjectPointerArraySizeType idx );
/**
- * Allows to set the output of the base data source.
- * @param output the intended output of the base data source
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
*/
- virtual void SetOutput( OutputType* output );
+ virtual DataObjectPointer MakeOutput(const DataObjectIdentifierType &name);
- /**
- * Allows to set the n-th output of the base data source.
- * @param output the intended output of the base data source
- */
- virtual void SetOutput( unsigned int idx, OutputType* output );
-
- /**
- * Returns the output with index 0 of the base data source
- * @returns the output
- */
- virtual OutputType* GetOutput();
-
- /**
- * Returns the n'th output of the base data source
- * @param idx the index of the wanted output
- * @returns the output with index idx.
- */
- virtual OutputType* GetOutput ( unsigned int idx );
+ OutputType* GetOutput();
+ const OutputType* GetOutput() const;
+ OutputType* GetOutput(DataObjectPointerArraySizeType idx);
+ const OutputType* GetOutput(DataObjectPointerArraySizeType idx) const;
protected:
DataNodeSource();
virtual ~DataNodeSource();
};
}
#endif // #define _MITK_BASE_DATA_SOURCE_H
diff --git a/Core/Code/Algorithms/mitkExtractSliceFilter.cpp b/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
index 1347945728..19ce4201ea 100644
--- a/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
+++ b/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
@@ -1,482 +1,486 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkExtractSliceFilter.h"
#include <vtkImageData.h>
#include <vtkSmartPointer.h>
#include <vtkLinearTransform.h>
#include <vtkImageChangeInformation.h>
#include <mitkAbstractTransformGeometry.h>
#include <vtkGeneralTransform.h>
#include <mitkPlaneClipping.h>
mitk::ExtractSliceFilter::ExtractSliceFilter(vtkImageReslice* reslicer ){
if(reslicer == NULL){
m_Reslicer = vtkSmartPointer<vtkImageReslice>::New();
}
else
{
m_Reslicer = reslicer;
}
m_TimeStep = 0;
m_Reslicer->ReleaseDataFlagOn();
m_InterpolationMode = ExtractSliceFilter::RESLICE_NEAREST;
m_ResliceTransform = NULL;
m_InPlaneResampleExtentByGeometry = false;
m_OutPutSpacing = new mitk::ScalarType[2];
m_OutputDimension = 2;
m_ZSpacing = 1.0;
m_ZMin = 0;
m_ZMax = 0;
m_VtkOutputRequested = false;
}
mitk::ExtractSliceFilter::~ExtractSliceFilter(){
m_ResliceTransform = NULL;
m_WorldGeometry = NULL;
delete [] m_OutPutSpacing;
}
void mitk::ExtractSliceFilter::GenerateOutputInformation(){
+ Superclass::GenerateOutputInformation();
//TODO try figure out how to set the specs of the slice before it is actually extracted
/*Image::Pointer output = this->GetOutput();
Image::ConstPointer input = this->GetInput();
if (input.IsNull()) return;
unsigned int dimensions[2];
dimensions[0] = m_WorldGeometry->GetExtent(0);
dimensions[1] = m_WorldGeometry->GetExtent(1);
output->Initialize(input->GetPixelType(), 2, dimensions, 1);*/
}
void mitk::ExtractSliceFilter::GenerateInputRequestedRegion(){
//As we want all pixel information fo the image in our plane, the requested region
//is set to the largest possible region in the image.
//This is needed because an oblique plane has a larger extent then the image
//and the in pipeline it is checked via PropagateResquestedRegion(). But the
//extent of the slice is actually fitting because it is oblique within the image.
ImageToImageFilter::InputImagePointer input = const_cast< ImageToImageFilter::InputImageType* > ( this->GetInput() );
input->SetRequestedRegionToLargestPossibleRegion();
}
mitk::ScalarType* mitk::ExtractSliceFilter::GetOutputSpacing(){
return m_OutPutSpacing;
}
void mitk::ExtractSliceFilter::GenerateData(){
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
if (!input)
{
MITK_ERROR << "mitk::ExtractSliceFilter: No input image available. Please set the input!" << std::endl;
itkExceptionMacro("mitk::ExtractSliceFilter: No input image available. Please set the input!");
return;
}
if(!m_WorldGeometry)
{
MITK_ERROR << "mitk::ExtractSliceFilter: No Geometry for reslicing available." << std::endl;
itkExceptionMacro("mitk::ExtractSliceFilter: No Geometry for reslicing available.");
return;
}
const TimeSlicedGeometry *inputTimeGeometry = this->GetInput()->GetTimeSlicedGeometry();
if ( ( inputTimeGeometry == NULL )
|| ( inputTimeGeometry->GetTimeSteps() == 0 ) )
{
itkWarningMacro(<<"Error reading input image TimeSlicedGeometry.");
return;
}
// is it a valid timeStep?
if ( inputTimeGeometry->IsValidTime( m_TimeStep ) == false )
{
itkWarningMacro(<<"This is not a valid timestep: "<< m_TimeStep );
return;
}
// check if there is something to display.
if ( ! input->IsVolumeSet( m_TimeStep ) )
{
itkWarningMacro(<<"No volume data existent at given timestep "<< m_TimeStep );
return;
}
/*================#BEGIN setup vtkImageRslice properties================*/
Point3D origin;
Vector3D right, bottom, normal;
double widthInMM, heightInMM;
Vector2D extent;
const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(m_WorldGeometry);
if ( planeGeometry != NULL )
{
//if the worldGeomatry is a PlaneGeometry everthing is straight forward
origin = planeGeometry->GetOrigin();
right = planeGeometry->GetAxisVector( 0 );
bottom = planeGeometry->GetAxisVector( 1 );
normal = planeGeometry->GetNormal();
if ( m_InPlaneResampleExtentByGeometry )
{
// Resampling grid corresponds to the current world geometry. This
// means that the spacing of the output 2D image depends on the
// currently selected world geometry, and *not* on the image itself.
extent[0] = m_WorldGeometry->GetExtent( 0 );
extent[1] = m_WorldGeometry->GetExtent( 1 );
}
else
{
// Resampling grid corresponds to the input geometry. This means that
// the spacing of the output 2D image is directly derived from the
// associated input image, regardless of the currently selected world
// geometry.
Vector3D rightInIndex, bottomInIndex;
inputTimeGeometry->GetGeometry3D( m_TimeStep )->WorldToIndex( right, rightInIndex );
inputTimeGeometry->GetGeometry3D( m_TimeStep )->WorldToIndex( bottom, bottomInIndex );
extent[0] = rightInIndex.GetNorm();
extent[1] = bottomInIndex.GetNorm();
}
// Get the extent of the current world geometry and calculate resampling
// spacing therefrom.
widthInMM = m_WorldGeometry->GetExtentInMM( 0 );
heightInMM = m_WorldGeometry->GetExtentInMM( 1 );
m_OutPutSpacing[0] = widthInMM / extent[0];
m_OutPutSpacing[1] = heightInMM / extent[1];
right.Normalize();
bottom.Normalize();
normal.Normalize();
/*
* Transform the origin to center based coordinates.
* Note:
* This is needed besause vtk's origin is center based too (!!!) ( see 'The VTK book' page 88 )
* and the worldGeometry surrouding the image is no imageGeometry. So the worldGeometry
* has its origin at the corner of the voxel and needs to be transformed.
*/
origin += right * ( m_OutPutSpacing[0] * 0.5 );
origin += bottom * ( m_OutPutSpacing[1] * 0.5 );
//set the tranform for reslicing.
// Use inverse transform of the input geometry for reslicing the 3D image.
// This is needed if the image volume already transformed
if(m_ResliceTransform.IsNotNull())
m_Reslicer->SetResliceTransform(m_ResliceTransform->GetVtkTransform()->GetLinearInverse());
// Set background level to TRANSLUCENT (see Geometry2DDataVtkMapper3D),
// else the background of the image turns out gray
m_Reslicer->SetBackgroundLevel( -32768 );
}
else{
//Code for curved planes, mostly taken 1:1 from imageVtkMapper2D and not tested yet.
// Do we have an AbstractTransformGeometry?
// This is the case for AbstractTransformGeometry's (e.g. a ThinPlateSplineCurvedGeometry )
const mitk::AbstractTransformGeometry* abstractGeometry =
dynamic_cast< const AbstractTransformGeometry * >(m_WorldGeometry);
if(abstractGeometry != NULL)
{
m_ResliceTransform = abstractGeometry;
extent[0] = abstractGeometry->GetParametricExtent(0);
extent[1] = abstractGeometry->GetParametricExtent(1);
widthInMM = abstractGeometry->GetParametricExtentInMM(0);
heightInMM = abstractGeometry->GetParametricExtentInMM(1);
m_OutPutSpacing[0] = widthInMM / extent[0];
m_OutPutSpacing[1] = heightInMM / extent[1];
origin = abstractGeometry->GetPlane()->GetOrigin();
right = abstractGeometry->GetPlane()->GetAxisVector(0);
right.Normalize();
bottom = abstractGeometry->GetPlane()->GetAxisVector(1);
bottom.Normalize();
normal = abstractGeometry->GetPlane()->GetNormal();
normal.Normalize();
// Use a combination of the InputGeometry *and* the possible non-rigid
// AbstractTransformGeometry for reslicing the 3D Image
vtkSmartPointer<vtkGeneralTransform> composedResliceTransform = vtkSmartPointer<vtkGeneralTransform>::New();
composedResliceTransform->Identity();
composedResliceTransform->Concatenate(
inputTimeGeometry->GetGeometry3D( m_TimeStep )->GetVtkTransform()->GetLinearInverse() );
composedResliceTransform->Concatenate(
abstractGeometry->GetVtkAbstractTransform()
);
m_Reslicer->SetResliceTransform( composedResliceTransform );
// Set background level to BLACK instead of translucent, to avoid
// boundary artifacts (see Geometry2DDataVtkMapper3D)
m_Reslicer->SetBackgroundLevel( -1023 );
}
else
{
itkExceptionMacro("mitk::ExtractSliceFilter: No fitting geometry for reslice axis!");
return;
}
}
if(m_ResliceTransform.IsNotNull()){
//if the resliceTransform is set the reslice axis are recalculated.
//Thus the geometry information is not fitting. Therefor a unitSpacingFilter
//is used to set up a global spacing of 1 and compensate the transform.
vtkSmartPointer<vtkImageChangeInformation> unitSpacingImageFilter = vtkSmartPointer<vtkImageChangeInformation>::New() ;
unitSpacingImageFilter->ReleaseDataFlagOn();
unitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
unitSpacingImageFilter->SetInput( input->GetVtkImageData(m_TimeStep) );
m_Reslicer->SetInput(unitSpacingImageFilter->GetOutput() );
}
else
{
//if no tranform is set the image can be used directly
m_Reslicer->SetInput(input->GetVtkImageData(m_TimeStep));
}
/*setup the plane where vktImageReslice extracts the slice*/
//ResliceAxesOrigin is the ancor point of the plane
double originInVtk[3];
itk2vtk(origin, originInVtk);
m_Reslicer->SetResliceAxesOrigin(originInVtk);
//the cosines define the plane: x and y are the direction vectors, n is the planes normal
//this specifies a matrix 3x3
// x1 y1 n1
// x2 y2 n2
// x3 y3 n3
double cosines[9];
vnl2vtk(right.GetVnlVector(), cosines);//x
vnl2vtk(bottom.GetVnlVector(), cosines + 3);//y
vnl2vtk(normal.GetVnlVector(), cosines + 6);//n
m_Reslicer->SetResliceAxesDirectionCosines(cosines);
//we only have one slice, not a volume
m_Reslicer->SetOutputDimensionality(m_OutputDimension);
//set the interpolation mode for slicing
switch(this->m_InterpolationMode){
case RESLICE_NEAREST:
m_Reslicer->SetInterpolationModeToNearestNeighbor();
break;
case RESLICE_LINEAR:
m_Reslicer->SetInterpolationModeToLinear();
break;
case RESLICE_CUBIC:
m_Reslicer->SetInterpolationModeToCubic();
+ break;
default:
//the default interpolation used by mitk
m_Reslicer->SetInterpolationModeToNearestNeighbor();
}
/*========== BEGIN setup extent of the slice ==========*/
int xMin, xMax, yMin, yMax;
xMin = yMin = 0;
xMax = static_cast< int >( extent[0]);
yMax = static_cast< int >( extent[1]);
vtkFloatingPointType sliceBounds[6];
if (m_WorldGeometry->GetReferenceGeometry())
{
for ( int i = 0; i < 6; ++i )
{
sliceBounds[i] = 0.0;
}
if (this->GetClippedPlaneBounds( m_WorldGeometry->GetReferenceGeometry(), planeGeometry, sliceBounds ))
{
// Calculate output extent (integer values)
xMin = static_cast< int >( sliceBounds[0] / m_OutPutSpacing[0] + 0.5 );
xMax = static_cast< int >( sliceBounds[1] / m_OutPutSpacing[0] + 0.5 );
yMin = static_cast< int >( sliceBounds[2] / m_OutPutSpacing[1] + 0.5 );
yMax = static_cast< int >( sliceBounds[3] / m_OutPutSpacing[1] + 0.5 );
} // ELSE we use the default values
}
// Set the output extents! First included pixel index and last included pixel index
// xMax and yMax are one after the last pixel. so they have to be decremented by 1.
// In case we have a 2D image, xMax or yMax might be 0. in this case, do not decrement, but take 0.
m_Reslicer->SetOutputExtent(xMin, std::max(0, xMax-1), yMin, std::max(0, yMax-1), m_ZMin, m_ZMax );
/*========== END setup extent of the slice ==========*/
m_Reslicer->SetOutputOrigin( 0.0, 0.0, 0.0 );
m_Reslicer->SetOutputSpacing( m_OutPutSpacing[0], m_OutPutSpacing[1], m_ZSpacing );
//TODO check the following lines, they are responsible wether vtk error outputs appear or not
m_Reslicer->UpdateWholeExtent(); //this produces a bad allocation error for 2D images
//m_Reslicer->GetOutput()->UpdateInformation();
//m_Reslicer->GetOutput()->SetUpdateExtentToWholeExtent();
//start the pipeline
m_Reslicer->Update();
/*================ #END setup vtkImageRslice properties================*/
if(m_VtkOutputRequested){
return;
//no converting to mitk
//no mitk geometry will be set, as the output is vtkImageData only!!!
}
else
{
/*================ #BEGIN Get the slice from vtkImageReslice and convert it to mit::Image================*/
vtkImageData* reslicedImage;
reslicedImage = m_Reslicer->GetOutput();
if(!reslicedImage)
{
itkWarningMacro(<<"Reslicer returned empty image");
return;
}
mitk::Image::Pointer resultImage = this->GetOutput();
//initialize resultimage with the specs of the vtkImageData object returned from vtkImageReslice
if (reslicedImage->GetDataDimension() == 1)
{
// If original image was 2D, the slice might have an y extent of 0.
// Still i want to ensure here that Image is 2D
resultImage->Initialize(reslicedImage,1,-1,-1,1);
}
else
{
resultImage->Initialize(reslicedImage);
}
//transfer the voxel data
resultImage->SetVolume(reslicedImage->GetScalarPointer());
//set the geometry from current worldgeometry for the reusultimage
//this is needed that the image has the correct mitk geometry
//the originalGeometry is the Geometry of the result slice
- AffineGeometryFrame3D::Pointer originalGeometryAGF = m_WorldGeometry->Clone();
- Geometry2D::Pointer originalGeometry = dynamic_cast<Geometry2D*>( originalGeometryAGF.GetPointer() );
+
+// mitk::AffineGeometryFrame3D::Pointer originalGeometryAGF = m_WorldGeometry->Clone();
+// Geometry2D::Pointer originalGeometry = dynamic_cast<Geometry2D*>( originalGeometryAGF.GetPointer() );
+ Geometry2D::Pointer originalGeometry = m_WorldGeometry->Clone();
originalGeometry->GetIndexToWorldTransform()->SetMatrix(m_WorldGeometry->GetIndexToWorldTransform()->GetMatrix());
//the origin of the worldGeometry is transformed to center based coordinates to be an imageGeometry
Point3D sliceOrigin = originalGeometry->GetOrigin();
sliceOrigin += right * ( m_OutPutSpacing[0] * 0.5 );
sliceOrigin += bottom * ( m_OutPutSpacing[1] * 0.5 );
//a worldGeometry is no imageGeometry, thus it is manually set to true
originalGeometry->ImageGeometryOn();
/*At this point we have to adjust the geometry because the origin isn't correct.
The wrong origin is related to the rotation of the current world geometry plane.
This causes errors on transfering world to index coordinates. We just shift the
origin in each direction about the amount of the expanding (needed while rotating
the plane).
*/
Vector3D axis0 = originalGeometry->GetAxisVector(0);
Vector3D axis1 = originalGeometry->GetAxisVector(1);
axis0.Normalize();
axis1.Normalize();
//adapt the origin. Note that for orthogonal planes the minima are '0' and thus the origin stays the same.
sliceOrigin += (axis0 * (xMin * m_OutPutSpacing[0])) + (axis1 * (yMin * m_OutPutSpacing[1]));
originalGeometry->SetOrigin(sliceOrigin);
originalGeometry->Modified();
resultImage->SetGeometry( originalGeometry );
/*the bounds as well as the extent of the worldGeometry are not adapted correctly during crosshair rotation.
This is only a quick fix and has to be evaluated.
The new bounds are set via the max values of the calcuted slice extent. It will look like [ 0, x, 0, y, 0, 1].
*/
mitk::BoundingBox::BoundsArrayType boundsCopy;
boundsCopy[0] = boundsCopy[2] = boundsCopy[4] = 0;
boundsCopy[5] = 1;
boundsCopy[1] = xMax - xMin;
boundsCopy[3] = yMax - yMin;
resultImage->GetGeometry()->SetBounds(boundsCopy);
/*================ #END Get the slice from vtkImageReslice and convert it to mitk Image================*/
}
}
bool mitk::ExtractSliceFilter::GetClippedPlaneBounds(vtkFloatingPointType bounds[6]){
if(!m_WorldGeometry || !this->GetInput())
return false;
return this->GetClippedPlaneBounds(m_WorldGeometry->GetReferenceGeometry(), dynamic_cast< const PlaneGeometry * >( m_WorldGeometry ), bounds);
}
bool mitk::ExtractSliceFilter::GetClippedPlaneBounds( const Geometry3D *boundingGeometry,
const PlaneGeometry *planeGeometry, vtkFloatingPointType *bounds )
{
bool b = mitk::PlaneClipping::CalculateClippedPlaneBounds(boundingGeometry, planeGeometry, bounds);
return b;
}
diff --git a/Core/Code/Algorithms/mitkExtractSliceFilter.h b/Core/Code/Algorithms/mitkExtractSliceFilter.h
index 8dd9ac2a14..57b6d1813e 100644
--- a/Core/Code/Algorithms/mitkExtractSliceFilter.h
+++ b/Core/Code/Algorithms/mitkExtractSliceFilter.h
@@ -1,174 +1,174 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkExtractSliceFilter_h_Included
#define mitkExtractSliceFilter_h_Included
#include "MitkExports.h"
#include "mitkImageToImageFilter.h"
#include <vtkSmartPointer.h>
#include <vtkImageReslice.h>
#include <vtkMatrix4x4.h>
#include <vtkImageData.h>
#include <vtkPoints.h>
#include <vtkTransform.h>
#include <vtkAbstractTransform.h>
namespace mitk
{
/**
\brief ExtractSliceFilter extracts a 2D abitrary oriented slice from a 3D volume.
The filter can reslice in all orthogonal planes such as sagittal, coronal and axial,
and is also able to reslice a abitrary oriented oblique plane.
Curved planes are specified via an AbstractTransformGeometry as the input worldgeometry.
The convinient workflow is:
1. Set an image as input.
2. Set the worldGeometry2D. This defines a grid where the slice is being extracted
3. And then start the pipeline.
There are a few more properties that can be set to modify the behavior of the slicing.
The properties are:
- interpolation mode either Nearestneighbor, Linear or Cubic.
- a transform this is a convinient way to adapt the reslice axis for the case
that the image is transformed e.g. rotated.
- time step the time step in a timesliced volume.
- resample by geometry wether the resampling grid corresponds to the specs of the
worldgeometry or is directly derived from the input image
By default the properties are set to:
- interpolation mode Nearestneighbor.
- a transform NULL (No transform is set).
- time step 0.
- resample by geometry false (Corresponds to input image).
*/
class MITK_CORE_EXPORT ExtractSliceFilter : public ImageToImageFilter
{
public:
mitkClassMacro(ExtractSliceFilter, ImageToImageFilter);
itkNewMacro(ExtractSliceFilter);
mitkNewMacro1Param(Self, vtkImageReslice*);
/** \brief Set the axis where to reslice at.*/
void SetWorldGeometry(const Geometry2D* geometry ){
this->m_WorldGeometry = geometry;
this->Modified(); }
/** \brief Set the time step in the 4D volume */
void SetTimeStep( unsigned int timestep){ this->m_TimeStep = timestep; }
unsigned int GetTimeStep(){ return this->m_TimeStep; }
/** \brief Set a transform for the reslice axes.
* This transform is needed if the image volume itself is transformed. (Effects the reslice axis)
*/
void SetResliceTransformByGeometry(const Geometry3D* transform){ this->m_ResliceTransform = transform; }
/** \brief Resampling grid corresponds to: false->image true->worldgeometry*/
void SetInPlaneResampleExtentByGeometry(bool inPlaneResampleExtentByGeometry){ this->m_InPlaneResampleExtentByGeometry = inPlaneResampleExtentByGeometry; }
/** \brief Sets the output dimension of the slice*/
void SetOutputDimensionality(unsigned int dimension){ this->m_OutputDimension = dimension; }
/** \brief Set the spacing in z direction manually.
* Required if the outputDimension is > 2.
*/
void SetOutputSpacingZDirection(double zSpacing){ this->m_ZSpacing = zSpacing; }
/** \brief Set the extent in pixel for direction z manualy.
Required if the output dimension is > 2.
*/
void SetOutputExtentZDirection(int zMin, int zMax) { this->m_ZMin = zMin; this->m_ZMax = zMax; }
/** \brief Get the bounding box of the slice [xMin, xMax, yMin, yMax, zMin, zMax]
* The method uses the input of the filter to calculate the bounds.
* It is recommended to use
* GetClippedPlaneBounds(const Geometry3D*, const PlaneGeometry*, vtkFloatingPointType*)
* if you are not sure about the input.
*/
bool GetClippedPlaneBounds(double bounds[6]);
/** \brief Get the bounding box of the slice [xMin, xMax, yMin, yMax, zMin, zMax]*/
bool GetClippedPlaneBounds( const Geometry3D *boundingGeometry,
const PlaneGeometry *planeGeometry, vtkFloatingPointType *bounds );
/** \brief Get the spacing of the slice. returns mitk::ScalarType[2] */
mitk::ScalarType* GetOutputSpacing();
/** \brief Get Output as vtkImageData.
* Note:
* SetVtkOutputRequest(true) has to be called at least once before
* GetVtkOutput(). Otherwise the output is empty for the first update step.
*/
vtkImageData* GetVtkOutput(){ m_VtkOutputRequested = true; return m_Reslicer->GetOutput(); }
/** Set VtkOutPutRequest to suppress the convertion of the image.
* It is suggested to use this with GetVtkOutput().
* Note:
* SetVtkOutputRequest(true) has to be called at least once before
* GetVtkOutput(). Otherwise the output is empty for the first update step.
*/
void SetVtkOutputRequest(bool isRequested){ m_VtkOutputRequested = isRequested; }
/** \brief Get the reslices axis matrix.
* Note: the axis are recalculated when calling SetResliceTransformByGeometry.
*/
vtkMatrix4x4* GetResliceAxes(){
return this->m_Reslicer->GetResliceAxes();
}
- enum ResliceInterpolation { RESLICE_NEAREST, RESLICE_LINEAR, RESLICE_CUBIC };
+ enum ResliceInterpolation { RESLICE_NEAREST=0, RESLICE_LINEAR=1, RESLICE_CUBIC=3 };
void SetInterpolationMode( ExtractSliceFilter::ResliceInterpolation interpolation){ this->m_InterpolationMode = interpolation; }
protected:
ExtractSliceFilter(vtkImageReslice* reslicer = NULL);
virtual ~ExtractSliceFilter();
virtual void GenerateData();
virtual void GenerateOutputInformation();
virtual void GenerateInputRequestedRegion();
const Geometry2D* m_WorldGeometry;
vtkSmartPointer<vtkImageReslice> m_Reslicer;
unsigned int m_TimeStep;
unsigned int m_OutputDimension;
double m_ZSpacing;
int m_ZMin;
int m_ZMax;
ResliceInterpolation m_InterpolationMode;
Geometry3D::ConstPointer m_ResliceTransform;
bool m_InPlaneResampleExtentByGeometry;//Resampling grid corresponds to: false->image true->worldgeometry
mitk::ScalarType* m_OutPutSpacing;
bool m_VtkOutputRequested;
};
}
#endif // mitkExtractSliceFilter_h_Included
diff --git a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.h b/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.h
index dd5e74bdc5..4b64927f57 100644
--- a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.h
+++ b/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.h
@@ -1,226 +1,227 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKGEOMETRY2DDATATOSURFACEDATAFILTER_H_HEADER_INCLUDED_C10B22CD
#define MITKGEOMETRY2DDATATOSURFACEDATAFILTER_H_HEADER_INCLUDED_C10B22CD
#include "mitkSurfaceSource.h"
#include "mitkGeometry3D.h"
#include "vtkSystemIncludes.h"
class vtkPlaneSource;
class vtkTransformPolyDataFilter;
class vtkCubeSource;
class vtkTransform;
class vtkPlane;
class vtkCutter;
class vtkStripper;
class vtkPolyData;
class vtkPPolyDataNormals;
class vtkTriangleFilter;
class vtkTextureMapToPlane;
class vtkBox;
class vtkClipPolyData;
namespace mitk {
class Geometry2DData;
/** \brief Superclass of all classes having a Geometry2DData as input and
* generating Images as output
*
* Currently implemented for PlaneGeometry and AbstractTransformGeometry.
* Currently, this class does not really have subclasses, but does the job
* for itself. It checks which kind of Geometry2D is stored in the
* Geometry2DData and - if it knows how - it generates the respective
* Surface. Of course, this has the disadvantage that for any new type of
* Geometry2D this class (Geometry2DDataToSurfaceFilter) has to be
* changed/extended. The idea is to move the type specific generation code in
* subclasses, and internally (within this class) use a factory to create an
* instance of the required subclass and delegate the surface generation to
* it.
*
* \sa mitk::DeformablePlane
* \todo make extension easier
* \ingroup Process
*/
class MITK_CORE_EXPORT Geometry2DDataToSurfaceFilter : public SurfaceSource
{
public:
mitkClassMacro(Geometry2DDataToSurfaceFilter, SurfaceSource);
itkNewMacro(Self);
virtual void GenerateOutputInformation();
virtual void GenerateData();
const Geometry2DData *GetInput(void);
const Geometry2DData *GetInput(unsigned int idx);
virtual void SetInput(const Geometry2DData *image);
+ using itk::ProcessObject::SetInput;
virtual void SetInput(unsigned int index, const Geometry2DData *image);
/** \brief If \a true (default), use Geometry3D::GetParametricBounds() to define the resolution in parameter space,
* otherwise use m_XResolution and m_YResolution
*/
itkGetMacro(UseGeometryParametricBounds, bool);
/** \brief If \a true (default), use Geometry3D::GetParametricBounds() to define the resolution in parameter space,
* otherwise use m_XResolution and m_YResolution
*/
itkSetMacro(UseGeometryParametricBounds, bool);
/** \brief Get x-resolution in parameter space
*
* The m_PlaneSource will create this many sub-rectangles
* in x-direction (see vtkPlaneSource::SetXResolution)
* \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
* the x-bounds of Geometry3D::GetParametricBounds() are used.
* \sa m_XResolution
*/
itkGetMacro(XResolution, int);
/** \brief Set x-resolution in parameter space
*
* The m_PlaneSource will create this many sub-rectangles
* in x-direction (see vtkPlaneSource::SetXResolution)
* \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
* the x-bounds of Geometry3D::GetParametricBounds() are used.
* \sa m_XResolution
*/
itkSetMacro(XResolution, int);
/** \brief Get y-resolution in parameter space
*
* The m_PlaneSource will create this many sub-rectangles
* in y-direction (see vtkPlaneSource::SetYResolution)
* \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
* the y-bounds of Geometry3D::GetParametricBounds() are used.
* \sa m_YResolution
*/
itkGetMacro(YResolution, int);
/** \brief Set y-resolution in parameter space
*
* The m_PlaneSource will create this many sub-rectangles
* in y-direction (see vtkPlaneSource::SetYResolution)
* \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
* the y-bounds of Geometry3D::GetParametricBounds() are used.
* \sa m_YResolution
*/
itkSetMacro(YResolution, int);
/** \brief Get whether the Surface is at the origin and placed using the Geometry
*
* Default is \a false, i.e., the transform of the Geometry is the identity, thus
* the points within the Surface are at their final position. Otherwise
* (m_PlaceByGeometry==\a true), the first cornerpoint of the created Surface is
* at the origin and the actual position is determined by the transform of the
* Geometry.
* \sa m_PlaceByGeometry
*/
itkGetConstMacro(PlaceByGeometry, bool);
/** \brief Set whether the Surface is at the origin and placed using the Geometry
*
* Default is \a false, i.e., the transform of the Geometry is the identity, thus
* the points within the Surface are at their final position. Otherwise
* (m_PlaceByGeometry==\a true), the first cornerpoint of the created Surface is
* at the origin and the actual position is determined by the transform of the
* Geometry.
* \sa m_PlaceByGeometry
*/
itkSetMacro(PlaceByGeometry, bool);
itkBooleanMacro(PlaceByGeometry);
itkGetConstMacro( UseBoundingBox, bool );
itkSetMacro( UseBoundingBox, bool );
itkBooleanMacro( UseBoundingBox );
void SetBoundingBox( const BoundingBox *boundingBox );
const BoundingBox *GetBoundingBox() const;
protected:
Geometry2DDataToSurfaceFilter();
virtual ~Geometry2DDataToSurfaceFilter();
/** \brief Source to create the vtk-representation of the parameter space rectangle of the Geometry2D
*/
vtkPlaneSource* m_PlaneSource;
/** \brief Filter to create the vtk-representation of the Geometry2D, which is a
* transformation of the m_PlaneSource
*/
vtkTransformPolyDataFilter* m_VtkTransformPlaneFilter;
/** \brief If \a true, use Geometry3D::GetParametricBounds() to define the resolution in parameter space,
* otherwise use m_XResolution and m_YResolution
*/
bool m_UseGeometryParametricBounds;
/** \brief X-resolution in parameter space
*
* The m_PlaneSource will create this many sub-rectangles
* in x-direction (see vtkPlaneSource::SetXResolution)
* \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
* the x-bounds of Geometry3D::GetParametricBounds() are used.
* \sa m_XResolution
*/
int m_XResolution;
/** \brief Y-resolution in parameter space
*
* The m_PlaneSource will create this many sub-rectangles
* in y-direction (see vtkPlaneSource::SetYResolution)
* \note Only used, when GetUseGeometryParametricBounds() is \a false, otherwise the
* the y-bounds of Geometry3D::GetParametricBounds() are used.
*/
int m_YResolution;
/** \brief Define whether the Surface is at the origin and placed using the Geometry
*
* Default is \a false, i.e., the transform of the Geometry is the identity, thus
* the points within the Surface are at their final position. Otherwise
* (m_PlaceByGeometry==\a true), the first cornerpoint of the created Surface is
* at the origin and the actual position is determined by the transform of the
* Geometry.
*/
bool m_PlaceByGeometry;
bool m_UseBoundingBox;
BoundingBox::ConstPointer m_BoundingBox;
vtkCubeSource *m_CubeSource;
vtkTransform *m_Transform;
vtkTransformPolyDataFilter *m_PolyDataTransformer;
vtkPlane *m_Plane;
vtkCutter *m_PlaneCutter;
vtkStripper *m_PlaneStripper;
vtkPolyData *m_PlanePolyData;
vtkPPolyDataNormals * m_NormalsUpdater;
vtkTriangleFilter *m_PlaneTriangler;
vtkTextureMapToPlane *m_TextureMapToPlane;
vtkBox *m_Box;
vtkClipPolyData *m_PlaneClipper;
};
} // namespace mitk
#endif /* MITKGEOMETRY2DDATATOSURFACEDATAFILTER_H_HEADER_INCLUDED_C10B22CD */
diff --git a/Core/Code/Algorithms/mitkImageSource.cpp b/Core/Code/Algorithms/mitkImageSource.cpp
index 1259f6f19a..321e32ed89 100644
--- a/Core/Code/Algorithms/mitkImageSource.cpp
+++ b/Core/Code/Algorithms/mitkImageSource.cpp
@@ -1,266 +1,200 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImageSource.h"
mitk::ImageSource::ImageSource()
{
// Create the output. We use static_cast<> here because we know the default
// output must be of type TOutputImage
OutputImageType::Pointer output
= static_cast<OutputImageType*>(this->MakeOutput(0).GetPointer());
Superclass::SetNumberOfRequiredOutputs(1);
Superclass::SetNthOutput(0, output.GetPointer());
}
-/**
- *
- */
-mitk::ImageSource::DataObjectPointer mitk::ImageSource::MakeOutput(unsigned int)
+itk::DataObject::Pointer mitk::ImageSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
- return static_cast<itk::DataObject*>(OutputImageType::New().GetPointer());
-}
-
-/**
- *
- */
-mitk::ImageSource::OutputImageType* mitk::ImageSource::GetOutput()
-{
- if (this->GetNumberOfOutputs() < 1)
- {
- return 0;
- }
-
- return static_cast<OutputImageType*>
- (this->BaseProcess::GetOutput(0));
-}
-
-
-/**
- *
- */
-mitk::ImageSource::OutputImageType* mitk::ImageSource::GetOutput(unsigned int idx)
-{
- return static_cast<OutputImageType*>
- (this->ProcessObject::GetOutput(idx));
-}
-
-
-/**
- *
- */
-void mitk::ImageSource::SetOutput(OutputImageType *output)
-{
- itkWarningMacro(<< "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead." );
- BaseProcess::SetNthOutput(0, output);
+ return static_cast<itk::DataObject *>(mitk::Image::New().GetPointer());
}
-/**
- *
- */
-void mitk::ImageSource::GraftOutput(OutputImageType *graft)
+itk::DataObject::Pointer mitk::ImageSource::MakeOutput( const DataObjectIdentifierType & name )
{
- this->GraftNthOutput(0, graft);
-}
-
-
-/**
- *
- */
-void mitk::ImageSource::GraftNthOutput(unsigned int idx, OutputImageType* graft)
-{
- itkWarningMacro(<< "GraftNthOutput(): This method is not yet implemented for mitk. Implement it before using!!" );
- assert(false);
- if (idx < this->GetNumberOfOutputs())
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
{
- OutputImageType * output = this->GetOutput(idx);
-
- if (output && graft)
- {
- // grab a handle to the bulk data of the specified data object
-// output->SetPixelContainer( graft->GetPixelContainer() ); @FIXME!!!!
-
- // copy the region ivars of the specified data object
- output->SetRequestedRegion( graft );//graft->GetRequestedRegion() );
-// output->SetLargestPossibleRegion( graft->GetLargestPossibleRegion() ); @FIXME!!!!
-// output->SetBufferedRegion( graft->GetBufferedRegion() ); @FIXME!!!!
-
- // copy the meta-information
- output->CopyInformation( graft );
- }
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
}
+ return static_cast<itk::DataObject *>(mitk::Image::New().GetPointer());
}
+
//----------------------------------------------------------------------------
-int mitk::ImageSource::SplitRequestedRegion(int i, int num, OutputImageRegionType& splitRegion)
+unsigned int mitk::ImageSource::SplitRequestedRegion(unsigned int i, unsigned int num, OutputImageRegionType& splitRegion)
{
// Get the output pointer
OutputImageType * outputPtr = this->GetOutput();
const SlicedData::SizeType& requestedRegionSize
= outputPtr->GetRequestedRegion().GetSize();
int splitAxis;
SlicedData::IndexType splitIndex;
SlicedData::SizeType splitSize;
// Initialize the splitRegion to the output requested region
splitRegion = outputPtr->GetRequestedRegion();
splitIndex = splitRegion.GetIndex();
splitSize = splitRegion.GetSize();
// split on the outermost dimension available
splitAxis = outputPtr->GetDimension() - 1;
while (requestedRegionSize[splitAxis] == 1)
{
--splitAxis;
if (splitAxis < 0)
{ // cannot split
itkDebugMacro(" Cannot Split");
return 1;
}
}
// determine the actual number of pieces that will be generated
SlicedData::SizeType::SizeValueType range = requestedRegionSize[splitAxis];
- int valuesPerThread = (int)ceil(range/(double)num);
- int maxThreadIdUsed = (int)ceil(range/(double)valuesPerThread) - 1;
+ unsigned int valuesPerThread = itk::Math::Ceil< unsigned int>(range / (double)num);
+ unsigned int maxThreadIdUsed = itk::Math::Ceil< unsigned int>(range / (double)valuesPerThread) - 1;
// Split the region
if (i < maxThreadIdUsed)
{
splitIndex[splitAxis] += i*valuesPerThread;
splitSize[splitAxis] = valuesPerThread;
}
if (i == maxThreadIdUsed)
{
splitIndex[splitAxis] += i*valuesPerThread;
// last thread needs to process the "rest" dimension being split
splitSize[splitAxis] = splitSize[splitAxis] - i*valuesPerThread;
}
// set the split region ivars
splitRegion.SetIndex( splitIndex );
splitRegion.SetSize( splitSize );
itkDebugMacro(" Split Piece: " << splitRegion );
return maxThreadIdUsed + 1;
}
//----------------------------------------------------------------------------
void mitk::ImageSource::AllocateOutputs()
{
OutputImagePointer outputPtr;
// Allocate the output memory
for (unsigned int i=0; i < this->GetNumberOfOutputs(); i++)
{
outputPtr = this->GetOutput(i);
// outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion()); @FIXME???
// outputPtr->Allocate(); @FIXME???
}
}
//----------------------------------------------------------------------------
void mitk::ImageSource::GenerateData()
{
// Call a method that can be overriden by a subclass to allocate
// memory for the filter's outputs
this->AllocateOutputs();
// Call a method that can be overridden by a subclass to perform
// some calculations prior to splitting the main computations into
// separate threads
this->BeforeThreadedGenerateData();
// Set up the multithreaded processing
ThreadStruct str;
str.Filter = this;
this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads());
this->GetMultiThreader()->SetSingleMethod(this->ThreaderCallback, &str);
// multithread the execution
this->GetMultiThreader()->SingleMethodExecute();
// Call a method that can be overridden by a subclass to perform
// some calculations after all the threads have completed
this->AfterThreadedGenerateData();
}
//----------------------------------------------------------------------------
// The execute method created by the subclass.
-void mitk::ImageSource::ThreadedGenerateData(const OutputImageRegionType&, int)
+void mitk::ImageSource::ThreadedGenerateData(const OutputImageRegionType&, itk::ThreadIdType)
{
itkExceptionMacro("subclass should override this method!!!");
}
// Callback routine used by the threading library. This routine just calls
// the ThreadedGenerateData method after setting the correct region for this
// thread.
ITK_THREAD_RETURN_TYPE mitk::ImageSource::ThreaderCallback( void *arg )
{
ThreadStruct *str;
- int total, threadId, threadCount;
+ itk::ThreadIdType total, threadId, threadCount;
threadId = ((itk::MultiThreader::ThreadInfoStruct *)(arg))->ThreadID;
threadCount = ((itk::MultiThreader::ThreadInfoStruct *)(arg))->NumberOfThreads;
str = (ThreadStruct *)(((itk::MultiThreader::ThreadInfoStruct *)(arg))->UserData);
// execute the actual method with appropriate output region
// first find out how many pieces extent can be split into.
SlicedData::RegionType splitRegion;
total = str->Filter->SplitRequestedRegion(threadId, threadCount,
splitRegion);
if (threadId < total)
{
str->Filter->ThreadedGenerateData(splitRegion, threadId);
}
// else
// {
// otherwise don't use this thread. Sometimes the threads dont
// break up very well and it is just as efficient to leave a
// few threads idle.
// }
return ITK_THREAD_RETURN_VALUE;
}
void mitk::ImageSource::PrepareOutputs()
{
Superclass::PrepareOutputs();
}
-/*void* mitk::ImageSource::GetData()
-{
- Update();
- return GetOutput()->GetData();
-}*/
-
vtkImageData* mitk::ImageSource::GetVtkImageData()
{
Update();
return GetOutput()->GetVtkImageData();
}
+
+mitkBaseDataSourceGetOutputDefinitions(mitk::ImageSource)
diff --git a/Core/Code/Algorithms/mitkImageSource.h b/Core/Code/Algorithms/mitkImageSource.h
index 8bd1a71def..1c63c40255 100644
--- a/Core/Code/Algorithms/mitkImageSource.h
+++ b/Core/Code/Algorithms/mitkImageSource.h
@@ -1,260 +1,261 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef IMAGESOURCE_H_HEADER_INCLUDED_C1E7D6EC
#define IMAGESOURCE_H_HEADER_INCLUDED_C1E7D6EC
#include <MitkExports.h>
-#include "mitkBaseProcess.h"
+#include "mitkBaseDataSource.h"
#include "mitkImage.h"
+
namespace mitk {
-//##Documentation
-//## @brief Superclass of all classes generating Images (instances of class
-//## Image) as output.
-//##
-//## In itk and vtk the generated result of a ProcessObject is only guaranteed
-//## to be up-to-date, when Update() of the ProcessObject or the generated
-//## DataObject is called immediately before access of the data stored in the
-//## DataObject. This is also true for subclasses of mitk::BaseProcess and thus
-//## for mitk::ImageSource. But there are also three access methods provided
-//## that guarantee an up-to-date result (by first calling Update and then
-//## returning the result of GetOutput()): GetData(), GetPic() and
-//## GetVtkImageData().
-//## @ingroup Process
-class MITK_CORE_EXPORT ImageSource : public BaseProcess
+/**
+ * @brief Superclass of all classes generating Images (instances of class
+ * Image) as output.
+ *
+ * In itk and vtk the generated result of a ProcessObject is only guaranteed
+ * to be up-to-date, when Update() of the ProcessObject or the generated
+ * DataObject is called immediately before access of the data stored in the
+ * DataObject. This is also true for subclasses of mitk::BaseProcess and thus
+ * for mitk::ImageSource. But there are also three access methods provided
+ * that guarantee an up-to-date result (by first calling Update and then
+ * returning the result of GetOutput()): GetData(), GetPic() and
+ * GetVtkImageData().
+ * @ingroup Process
+ */
+class MITK_CORE_EXPORT ImageSource : public BaseDataSource
{
public:
- mitkClassMacro(ImageSource,BaseProcess);
-
- /** @brief Smart Pointer type to a DataObject. */
- typedef itk::DataObject::Pointer DataObjectPointer;
+ mitkClassMacro(ImageSource,BaseDataSource)
/** @brief Method for creation through the object factory. */
- itkNewMacro(Self);
+ itkNewMacro(Self)
/** @brief Some convenient typedefs. */
typedef mitk::Image OutputImageType;
+ typedef OutputImageType OutputType;
typedef OutputImageType::Pointer OutputImagePointer;
typedef SlicedData::RegionType OutputImageRegionType;
- /** @brief Get the image output of this process object. */
- OutputImageType * GetOutput(void);
- OutputImageType * GetOutput(unsigned int idx);
-
- /** @brief Set the image output of this process object.
- *
- * This call is slated
- * to be removed from ITK. You should GraftOutput() and possible
- * DataObject::DisconnectPipeline() to properly change the output. */
- void SetOutput(OutputImageType *output);
-
- /** @brief Graft the specified DataObject onto this ProcessObject's output.
+ /**
+ * @brief Get the output data of this image source object.
*
- * This method grabs a handle to the specified DataObject's bulk
- * data to used as its output's own bulk data. It also copies the
- * region ivars (RequestedRegion, BufferedRegion,
- * LargestPossibleRegion) and meta-data (Spacing, Origin) from the
- * specified data object into this filter's output data object. Most
- * importantly, however, it leaves the Source ivar untouched so the
- * original pipeline routing is intact. This method is used when a
- * process object is implemented using a mini-pipeline which is
- * defined in its GenerateData() method. The usage is:
+ * The output of this
+ * function is not valid until an appropriate Update() method has
+ * been called, either explicitly or implicitly. Both the filter
+ * itself and the data object have Update() methods, and both
+ * methods update the data. Here are three ways to use
+ * GetOutput() and make sure the data is valid. In these
+ * examples, \a image is a pointer to some Image object, and the
+ * particular ProcessObjects involved are filters. The same
+ * examples apply to non-image (e.g. Mesh) data as well.
*
* \code
- * // setup the mini-pipeline to process the input to this filter
- * firstFilterInMiniPipeline->SetInput( this->GetInput() );
-
- * // setup the mini-pipeline to calculate the correct regions
- * // and write to the appropriate bulk data block
- * lastFilterInMiniPipeline->GraftOutput( this->GetOutput() );
+ * anotherFilter->SetInput( someFilter->GetOutput() );
+ * anotherFilter->Update();
+ * \endcode
*
- * // execute the mini-pipeline
- * lastFilterInMiniPipeline->Update();
+ * In this situation, \a someFilter and \a anotherFilter are said
+ * to constitute a \b pipeline.
*
- * // graft the mini-pipeline output back onto this filter's output.
- * // this is needed to get the appropriate regions passed back.
- * this->GraftOutput( lastFilterInMiniPipeline->GetOutput() );
+ * \code
+ * image = someFilter->GetOutput();
+ * image->Update();
* \endcode
*
- * For proper pipeline execution, a filter using a mini-pipeline
- * must implement the GenerateInputRequestedRegion(),
- * GenerateOutputRequestedRegion(), GenerateOutputInformation() and
- * EnlargeOutputRequestedRegion() methods as necessary to reflect
- * how the mini-pipeline will execute (in other words, the outer
- * filter's pipeline mechanism must be consistent with what the
- * mini-pipeline will do).
- * */
- virtual void GraftOutput(OutputImageType *output);
-
- /** @brief Graft the specified data object onto this ProcessObject's idx'th
- * output.
+ * \code
+ * someFilter->Update();
+ * image = someFilter->GetOutput();
+ * \endcode
+ * (In the above example, the two lines of code can be in
+ * either order.)
+ *
+ * Note that Update() is not called automatically except within a
+ * pipeline as in the first example. When \b streaming (using a
+ * StreamingImageFilter) is activated, it may be more efficient to
+ * use a pipeline than to call Update() once for each filter in
+ * turn.
*
- * This is the similar to GraftOutput method except is
- * allows you specify which output is affected. The specified index
- * must be a valid output number (less than
- * ProcessObject::GetNumberOfOutputs()). See the GraftOutput for
- * general usage information. */
- virtual void GraftNthOutput(unsigned int idx, OutputImageType *output);
+ * For an image, the data generated is for the requested
+ * Region, which can be set using ImageBase::SetRequestedRegion().
+ * By default, the largest possible region is requested.
+ *
+ * For Filters which have multiple outputs of different types, the
+ * GetOutput() method assumes the output is of OutputImageType. For
+ * the GetOutput(DataObjectPointerArraySizeType) method, a dynamic_cast is performed
+ * incase the filter has outputs of different types or image
+ * types. Derived classes should have named get methods for these
+ * outputs.
+ */
+ mitkBaseDataSourceGetOutputDeclarations
/** @brief Make a DataObject of the correct type to used as the specified
* output.
*
* Every ProcessObject subclass must be able to create a
* DataObject that can be used as a specified output. This method
* is automatically called when DataObject::DisconnectPipeline() is
* called. DataObject::DisconnectPipeline, disconnects a data object
* from being an output of its current source. When the data object
* is disconnected, the ProcessObject needs to construct a replacement
* output data object so that the ProcessObject is in a valid state.
* So DataObject::DisconnectPipeline eventually calls
* ProcessObject::MakeOutput. Note that MakeOutput always returns a
* SmartPointer to a DataObject. If a subclass of ImageSource has
* multiple outputs of different types, then that class must provide
* an implementation of MakeOutput(). */
- virtual DataObjectPointer MakeOutput(unsigned int idx);
-// virtual void* GetData();
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
+
+ /**
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
+ */
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
virtual vtkImageData* GetVtkImageData();
protected:
ImageSource();
virtual ~ImageSource() {}
/** @brief A version of GenerateData() specific for image processing
* filters.
*
* This implementation will split the processing across
* multiple threads. The buffer is allocated by this method. Then
* the BeforeThreadedGenerateData() method is called (if
* provided). Then, a series of threads are spawned each calling
* ThreadedGenerateData(). After all the threads have completed
* processing, the AfterThreadedGenerateData() method is called (if
* provided). If an image processing filter cannot be threaded, the
* filter should provide an implementation of GenerateData(). That
* implementation is responsible for allocating the output buffer.
* If a filter an be threaded, it should NOT provide a
* GenerateData() method but should provide a ThreadedGenerateData()
* instead.
*
* \sa ThreadedGenerateData() */
virtual void GenerateData();
/** @brief If an imaging filter can be implemented as a multithreaded
* algorithm, the filter will provide an implementation of
* ThreadedGenerateData().
*
* This superclass will automatically split
* the output image into a number of pieces, spawn multiple threads,
* and call ThreadedGenerateData() in each thread. Prior to spawning
* threads, the BeforeThreadedGenerateData() method is called. After
* all the threads have completed, the AfterThreadedGenerateData()
* method is called. If an image processing filter cannot support
* threading, that filter should provide an implementation of the
* GenerateData() method instead of providing an implementation of
* ThreadedGenerateData(). If a filter provides a GenerateData()
* method as its implementation, then the filter is responsible for
* allocating the output data. If a filter provides a
* ThreadedGenerateData() method as its implementation, then the
* output memory will allocated automatically by this superclass.
* The ThreadedGenerateData() method should only produce the output
* specified by "outputThreadRegion"
* parameter. ThreadedGenerateData() cannot write to any other
* portion of the output image (as this is responsibility of a
* different thread).
*
* \sa GenerateData(), SplitRequestedRegion() */
virtual
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId );
+ itk::ThreadIdType threadId );
/** @brief This method is intentionally left blank.
*
* ImageSource's need not
* Initialize their containers. The Image::Allocate() method (called
* from GenerateData()) will resize the container if more memory is
* needed. Otherwise, the memory can be reused.
*/
virtual void PrepareOutputs();
/** @brief The GenerateData method normally allocates the buffers for all of the
* outputs of a filter.
*
* Some filters may want to override this default
* behavior. For example, a filter may have multiple outputs with
* varying resolution. Or a filter may want to process data in place by
* grafting its input to its output.*/
virtual void AllocateOutputs();
/** @brief If an imaging filter needs to perform processing after the buffer
* has been allocated but before threads are spawned, the filter can
* can provide an implementation for BeforeThreadedGenerateData().
*
* The execution flow in the default GenerateData() method will be:
* 1) Allocate the output buffer
* 2) Call BeforeThreadedGenerateData()
* 3) Spawn threads, calling ThreadedGenerateData() in each thread.
* 4) Call AfterThreadedGenerateData()
* Note that this flow of control is only available if a filter provides
* a ThreadedGenerateData() method and NOT a GenerateData() method. */
- virtual void BeforeThreadedGenerateData() {};
+ virtual void BeforeThreadedGenerateData() {}
/** @brief If an imaging filter needs to perform processing after all
* processing threads have completed, the filter can can provide an
* implementation for AfterThreadedGenerateData().
*
* The execution
* flow in the default GenerateData() method will be:
* 1) Allocate the output buffer
* 2) Call BeforeThreadedGenerateData()
* 3) Spawn threads, calling ThreadedGenerateData() in each thread.
* 4) Call AfterThreadedGenerateData()
* Note that this flow of control is only available if a filter provides
* a ThreadedGenerateData() method and NOT a GenerateData() method. */
- virtual void AfterThreadedGenerateData() {};
+ virtual void AfterThreadedGenerateData() {}
/** @brief Split the output's RequestedRegion into "num" pieces, returning
* region "i" as "splitRegion".
*
* This method is called "num" times. The
* regions must not overlap. The method returns the number of pieces that
* the routine is capable of splitting the output RequestedRegion,
* i.e. return value is less than or equal to "num". */
virtual
- int SplitRequestedRegion(int i, int num, OutputImageRegionType& splitRegion);
+ unsigned int SplitRequestedRegion(unsigned int i, unsigned int num, OutputImageRegionType& splitRegion);
/** @brief Static function used as a "callback" by the MultiThreader.
*
* The threading library will call this routine for each thread, which will delegate the
* control to ThreadedGenerateData(). */
static ITK_THREAD_RETURN_TYPE ThreaderCallback( void *arg );
/** @brief Internal structure used for passing image data into the threading library */
struct ThreadStruct
{
Pointer Filter;
};
private:
+ ImageSource(const Self &); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
} // namespace mitk
#endif /* IMAGESOURCE_H_HEADER_INCLUDED_C1E7D6EC */
diff --git a/Core/Code/Algorithms/mitkImageToImageFilter.cpp b/Core/Code/Algorithms/mitkImageToImageFilter.cpp
index 159f465877..72a8b27ce2 100644
--- a/Core/Code/Algorithms/mitkImageToImageFilter.cpp
+++ b/Core/Code/Algorithms/mitkImageToImageFilter.cpp
@@ -1,111 +1,112 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImageToImageFilter.h"
mitk::ImageToImageFilter::ImageToImageFilter()
{
// Modify superclass default values, can be overridden by subclasses
this->SetNumberOfRequiredInputs(1);
}
mitk::ImageToImageFilter::~ImageToImageFilter()
{
}
/**
*
*/
void mitk::ImageToImageFilter::SetInput(const mitk::ImageToImageFilter::InputImageType *input)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(0,
const_cast< mitk::ImageToImageFilter::InputImageType * >( input ) );
}
/**
* Connect one of the operands for pixel-wise addition
*/
void mitk::ImageToImageFilter::SetInput( unsigned int index, const mitk::ImageToImageFilter::InputImageType * image )
{
if( index+1 > this->GetNumberOfInputs() )
{
this->SetNumberOfRequiredInputs( index + 1 );
}
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(index,
const_cast< mitk::ImageToImageFilter::InputImageType *>( image ) );
}
/**
*
*/
const mitk::ImageToImageFilter::InputImageType *mitk::ImageToImageFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return static_cast<const mitk::ImageToImageFilter::InputImageType * >
(this->ProcessObject::GetInput(0) );
}
/**
*
*/
const mitk::ImageToImageFilter::InputImageType *mitk::ImageToImageFilter::GetInput(unsigned int idx)
{
return static_cast< const mitk::ImageToImageFilter::InputImageType * >
(this->ProcessObject::GetInput(idx));
}
+
//-----------------------------------------------------------------------
//
void mitk::ImageToImageFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
for (unsigned int idx = 0; idx < this->GetNumberOfInputs(); ++idx)
{
if (this->GetInput(idx))
{
mitk::ImageToImageFilter::InputImagePointer input =
const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput(idx) );
// Use the function object RegionCopier to copy the output region
// to the input. The default region copier has default implementations
// to handle the cases where the input and output are the same
// dimension, the input a higher dimension than the output, and the
// input a lower dimension than the output.
InputImageRegionType inputRegion;
// this->CallCopyRegion(inputRegion, this->GetOutput()->GetRequestedRegion()); @FIXME ??
// input->SetRequestedRegion( inputRegion ); @FIXME ??
input->SetRequestedRegion( this->GetOutput() ); // ersatz. @FIXME ??
}
}
}
void mitk::ImageToImageFilter::PrintSelf(std::ostream& os, itk::Indent indent) const
{
Superclass::PrintSelf(os, indent);
}
diff --git a/Core/Code/Algorithms/mitkImageToImageFilter.h b/Core/Code/Algorithms/mitkImageToImageFilter.h
index c407d368f4..aed47fd240 100644
--- a/Core/Code/Algorithms/mitkImageToImageFilter.h
+++ b/Core/Code/Algorithms/mitkImageToImageFilter.h
@@ -1,84 +1,84 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef IMAGETOIMAGEFILTER_H_HEADER_INCLUDED_C1E5E869
#define IMAGETOIMAGEFILTER_H_HEADER_INCLUDED_C1E5E869
#include <MitkExports.h>
#include "mitkImageSource.h"
namespace mitk {
//##Documentation
//## @brief Superclass of all classes having one or more Images as input and
//## generating Images as output
//## @ingroup Process
class MITK_CORE_EXPORT ImageToImageFilter : public ImageSource
{
public:
mitkClassMacro(ImageToImageFilter,ImageSource);
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Superclass typedefs. */
typedef Superclass::OutputImageRegionType OutputImageRegionType;
/** Some convenient typedefs. */
typedef mitk::Image InputImageType;
typedef InputImageType::Pointer InputImagePointer;
typedef InputImageType::ConstPointer InputImageConstPointer;
typedef SlicedData::RegionType InputImageRegionType;
+ using itk::ProcessObject::SetInput;
/** Set/Get the image input of this process object. */
virtual void SetInput( const InputImageType *image);
virtual void SetInput( unsigned int, const InputImageType * image);
const InputImageType * GetInput(void);
const InputImageType * GetInput(unsigned int idx);
-
protected:
ImageToImageFilter();
virtual ~ImageToImageFilter();
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
/** What is the input requested region that is required to produce the
* output requested region? The base assumption for image processing
* filters is that the input requested region can be set to match the
* output requested region. If a filter requires more input (for instance
* a filter that uses neighborhoods needs more input than output to avoid
* introducing artificial boundary conditions) or less input (for instance
* a magnify filter) will have to override this method. In doing so, it
* should call its superclass' implementation as its first step. Note that
* this imaging filters operate differently than the classes to this
* point in the class hierachy. Up till now, the base assumption has been
* that the largest possible region will be requested of the input.
*
* \sa ProcessObject::GenerateInputRequestedRegion(),
* ImageSource::GenerateInputRequestedRegion() */
virtual void GenerateInputRequestedRegion();
private:
void operator=(const Self&); //purposely not implemented
};
} // namespace mitk
#endif /* IMAGETOIMAGEFILTER_H_HEADER_INCLUDED_C1E5E869 */
diff --git a/Core/Code/Algorithms/mitkPointSetSource.cpp b/Core/Code/Algorithms/mitkPointSetSource.cpp
index f4c3862335..9552083742 100644
--- a/Core/Code/Algorithms/mitkPointSetSource.cpp
+++ b/Core/Code/Algorithms/mitkPointSetSource.cpp
@@ -1,91 +1,49 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetSource.h"
mitk::PointSetSource::PointSetSource()
{
// Create the output.
- OutputType::Pointer output = dynamic_cast<OutputType*>(this->MakeOutput(0).GetPointer());
+ itk::DataObject::Pointer output = this->MakeOutput(0);
Superclass::SetNumberOfRequiredInputs(0);
Superclass::SetNumberOfRequiredOutputs(1);
- Superclass::SetNthOutput(0, output.GetPointer());
+ Superclass::SetNthOutput(0, output);
}
-
-
-
mitk::PointSetSource::~PointSetSource()
{
}
-
-
-
-itk::DataObject::Pointer mitk::PointSetSource::MakeOutput ( unsigned int /*idx */)
+itk::DataObject::Pointer mitk::PointSetSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
return OutputType::New().GetPointer();
}
-
-
-
-void mitk::PointSetSource::SetOutput( OutputType* output )
-{
- itkWarningMacro(<< "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead." );
- this->ProcessObject::SetNthOutput( 0, output );
-}
-
-
-
-
-void mitk::PointSetSource::GraftOutput(OutputType *graft)
-{
- this->GraftNthOutput(0, graft);
-}
-
-void mitk::PointSetSource::GraftNthOutput(unsigned int /*idx*/, OutputType* /*graft*/)
-{
- itkWarningMacro(<< "GraftNthOutput(): This method is not yet implemented for mitk. Implement it before using!!" );
- assert(false);
-}
-
-
-
-mitk::PointSetSource::OutputType* mitk::PointSetSource::GetOutput()
+itk::DataObject::Pointer mitk::PointSetSource::MakeOutput( const DataObjectIdentifierType & name )
{
- if ( this->GetNumberOfOutputs() < 1 )
- {
- return 0;
- }
- else
- {
- return dynamic_cast<OutputType*>
- (this->BaseProcess::GetOutput(0));
- }
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
+ {
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
+ }
+ return OutputType::New().GetPointer();
}
-
-
-
-mitk::PointSetSource::OutputType* mitk::PointSetSource::GetOutput ( unsigned int idx )
-{
- return dynamic_cast<OutputType*> ( this->ProcessObject::GetOutput( idx ) );
-}
-
-
+mitkBaseDataSourceGetOutputDefinitions(mitk::PointSetSource)
diff --git a/Core/Code/Algorithms/mitkPointSetSource.h b/Core/Code/Algorithms/mitkPointSetSource.h
index 107f646a67..2a7fd1421f 100644
--- a/Core/Code/Algorithms/mitkPointSetSource.h
+++ b/Core/Code/Algorithms/mitkPointSetSource.h
@@ -1,86 +1,74 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_POINT_SET_SOURCE_H
#define _MITK_POINT_SET_SOURCE_H
-#include "mitkBaseProcess.h"
+#include "mitkBaseDataSource.h"
#include "mitkPointSet.h"
namespace mitk
{
/**
* @brief Superclass of all classes generating point sets (instances of class
* mitk::PointSet) as output.
*
* In itk and vtk the generated result of a ProcessObject is only guaranteed
* to be up-to-date, when Update() of the ProcessObject or the generated
* DataObject is called immediately before access of the data stored in the
* DataObject.
* @ingroup Process
*/
-class MITK_CORE_EXPORT PointSetSource : public BaseProcess
+class MITK_CORE_EXPORT PointSetSource : public BaseDataSource
{
public:
- mitkClassMacro( PointSetSource, BaseProcess );
+ mitkClassMacro( PointSetSource, BaseDataSource )
- itkNewMacro( Self );
+ itkNewMacro( Self )
typedef PointSet OutputType;
typedef OutputType::Pointer OutputTypePointer;
- /**
+ mitkBaseDataSourceGetOutputDeclarations
+
+ /**
* Allocates a new output object and returns it. Currently the
* index idx is not evaluated.
* @param idx the index of the output for which an object should be created
* @returns the new object
*/
- virtual itk::DataObject::Pointer MakeOutput ( unsigned int idx );
-
- /**
- * Allows to set the output of the point set source.
- * @param output the intended output of the point set source
- */
- virtual void SetOutput( OutputType* output );
-
- virtual void GraftOutput(OutputType *output);
- virtual void GraftNthOutput(unsigned int idx, OutputType *output);
-
- /**
- * Returns the output with index 0 of the point set source
- * @returns the output
- */
- virtual OutputType* GetOutput();
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
/**
- * Returns the n'th output of the point set source
- * @param idx the index of the wanted output
- * @returns the output with index idx.
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
*/
- virtual OutputType* GetOutput ( unsigned int idx );
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
protected:
PointSetSource();
virtual ~PointSetSource();
};
}
#endif // #define _MITK_POINT_SET_SOURCE_H
diff --git a/Core/Code/Algorithms/mitkPointSetToPointSetFilter.h b/Core/Code/Algorithms/mitkPointSetToPointSetFilter.h
index 2658b37190..5e92acbc4f 100644
--- a/Core/Code/Algorithms/mitkPointSetToPointSetFilter.h
+++ b/Core/Code/Algorithms/mitkPointSetToPointSetFilter.h
@@ -1,91 +1,93 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _mitkpointsettopointsetfilter_h
#define _mitkpointsettopointsetfilter_h
#include <MitkExports.h>
#include "mitkPointSetSource.h"
namespace mitk
{
/**
* @brief Superclass of all classes/algorithms having one or more PointSets
* as input and output
* @ingroup Process
*/
class MITK_CORE_EXPORT PointSetToPointSetFilter : public PointSetSource
{
public:
mitkClassMacro( PointSetToPointSetFilter, PointSetSource );
itkNewMacro( Self );
typedef mitk::PointSet InputType;
typedef mitk::PointSet OutputType;
typedef InputType::Pointer InputTypePointer;
typedef InputType::ConstPointer InputTypeConstPointer;
+
+ using itk::ProcessObject::SetInput;
/**
* Sets the input of this process object
* @param input the input
*/
virtual void SetInput( const InputType* input );
/**
* Sets the input n'th of this process object
* @param idx the number associated with the given input
*/
virtual void SetInput( const unsigned int& idx, const InputType* input );
/**
* @returns the input tree of the process object
*/
const InputType * GetInput( void );
/**
* @param idx the index of the input to return
* @returns the input object with the given index
*/
const InputType * GetInput( const unsigned int& idx );
protected:
/**
* A default constructor
*/
PointSetToPointSetFilter();
/**
* The destructor
*/
virtual ~PointSetToPointSetFilter();
private:
void operator=( const Self& ); //purposely not implemented
}
;
} //end of namespace mitk
#endif
diff --git a/Core/Code/Algorithms/mitkRGBToRGBACastImageFilter.cpp b/Core/Code/Algorithms/mitkRGBToRGBACastImageFilter.cpp
index 7ad8c60669..eebd163c28 100644
--- a/Core/Code/Algorithms/mitkRGBToRGBACastImageFilter.cpp
+++ b/Core/Code/Algorithms/mitkRGBToRGBACastImageFilter.cpp
@@ -1,232 +1,232 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkRGBToRGBACastImageFilter.h"
#include "mitkImageTimeSelector.h"
#include "mitkProperties.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageToItk.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkImageIOBase.h>
#include <itkRGBAPixel.h>
mitk::RGBToRGBACastImageFilter::RGBToRGBACastImageFilter()
{
- this->SetNumberOfInputs(1);
+ this->SetNumberOfIndexedInputs(1);
this->SetNumberOfRequiredInputs(1);
m_InputTimeSelector = mitk::ImageTimeSelector::New();
m_OutputTimeSelector = mitk::ImageTimeSelector::New();
}
mitk::RGBToRGBACastImageFilter::~RGBToRGBACastImageFilter()
{
}
bool mitk::RGBToRGBACastImageFilter::IsRGBImage( const mitk::Image *image )
{
const mitk::PixelType &inputPixelType = image->GetPixelType();
- if ( (inputPixelType.GetPixelTypeId() == itk::ImageIOBase::RGB )
- && ( (inputPixelType.GetTypeId() == typeid( unsigned char) )
- || (inputPixelType.GetTypeId() == typeid( unsigned short) )
- || (inputPixelType.GetTypeId() == typeid( float) )
- || (inputPixelType.GetTypeId() == typeid( double) )
+ if ( (inputPixelType.GetPixelType() == itk::ImageIOBase::RGB )
+ && ( (inputPixelType.GetComponentType() == itk::ImageIOBase::UCHAR )
+ || (inputPixelType.GetComponentType() == itk::ImageIOBase::USHORT )
+ || (inputPixelType.GetComponentType() == itk::ImageIOBase::FLOAT )
+ || (inputPixelType.GetComponentType() == itk::ImageIOBase::DOUBLE )
)
)
{
return true;
}
return false;
}
void mitk::RGBToRGBACastImageFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::Image* output = this->GetOutput();
mitk::Image* input = const_cast< mitk::Image * > ( this->GetInput() );
if ( !output->IsInitialized() )
{
return;
}
input->SetRequestedRegionToLargestPossibleRegion();
//GenerateTimeInInputRegion(output, input);
}
void mitk::RGBToRGBACastImageFilter::GenerateOutputInformation()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
itkDebugMacro(<<"GenerateOutputInformation()");
// Initialize RGBA output with same pixel type as input image
const mitk::PixelType &inputPixelType = input->GetPixelType();
typedef itk::Image< UCRGBPixelType > UCRGBItkImageType;
typedef itk::Image< USRGBPixelType > USRGBItkImageType;
typedef itk::Image< FloatRGBPixelType > FloatCRGBItkImageType;
typedef itk::Image< DoubleRGBPixelType > DoubleRGBItkImageType;
if ( inputPixelType == mitk::MakePixelType< UCRGBItkImageType>() )
{
const mitk::PixelType refPtype = MakePixelType<UCRGBItkImageType>();
output->Initialize( refPtype, *input->GetTimeSlicedGeometry() );
}
else if ( inputPixelType == mitk::MakePixelType< USRGBItkImageType>( ) )
{
const mitk::PixelType refPtype = MakePixelType<USRGBItkImageType>();
output->Initialize( refPtype, *input->GetTimeSlicedGeometry() );
}
else if ( inputPixelType == mitk::MakePixelType< FloatCRGBItkImageType>( ) )
{
const mitk::PixelType refPtype = MakePixelType<FloatCRGBItkImageType>();
output->Initialize( refPtype, *input->GetTimeSlicedGeometry() );
}
else if ( inputPixelType == mitk::MakePixelType< DoubleRGBItkImageType>( ) )
{
const mitk::PixelType refPtype = MakePixelType<DoubleRGBItkImageType>();
output->Initialize( refPtype, *input->GetTimeSlicedGeometry() );
}
output->SetPropertyList(input->GetPropertyList()->Clone());
m_TimeOfHeaderInitialization.Modified();
}
void mitk::RGBToRGBACastImageFilter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if( !output->IsInitialized() )
{
return;
}
m_InputTimeSelector->SetInput(input);
m_OutputTimeSelector->SetInput(this->GetOutput());
mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
ScalarType timeInMS;
int timestep=0;
int tstart=outputRegion.GetIndex(3);
int tmax=tstart+outputRegion.GetSize(3);
int t;
for(t=tstart;t<tmax;++t)
{
timeInMS = outputTimeGeometry->TimeStepToMS( t );
timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
m_InputTimeSelector->SetTimeNr(timestep);
m_InputTimeSelector->UpdateLargestPossibleRegion();
m_OutputTimeSelector->SetTimeNr(t);
m_OutputTimeSelector->UpdateLargestPossibleRegion();
mitk::Image *image = m_InputTimeSelector->GetOutput();
const mitk::PixelType &pixelType = image->GetPixelType();
// Check if the pixel type is supported
if ( pixelType == MakePixelType< itk::Image<UCRGBPixelType> >() )
{
AccessFixedPixelTypeByItk_2( image, InternalCast, (UCRGBPixelType), this, 255 );
}
else if ( pixelType == MakePixelType< itk::Image< USRGBPixelType> >() )
{
AccessFixedPixelTypeByItk_2( image, InternalCast, (USRGBPixelType), this, 65535 );
}
else if ( pixelType == MakePixelType< itk::Image< FloatRGBPixelType> >() )
{
AccessFixedPixelTypeByItk_2( image, InternalCast, (FloatRGBPixelType), this, 1.0 );
}
else if ( pixelType == MakePixelType< itk::Image< DoubleRGBPixelType> >() )
{
AccessFixedPixelTypeByItk_2( image, InternalCast, (DoubleRGBPixelType), this, 1.0 );
}
else
{
// Otherwise, write warning and graft input to output
// ...TBD...
}
}
m_TimeOfHeaderInitialization.Modified();
}
template < typename TPixel, unsigned int VImageDimension >
void mitk::RGBToRGBACastImageFilter::InternalCast(
itk::Image< TPixel, VImageDimension > *inputItkImage,
mitk::RGBToRGBACastImageFilter *addComponentFilter,
typename TPixel::ComponentType defaultAlpha )
{
typedef TPixel InputPixelType;
typedef itk::RGBAPixel< typename TPixel::ComponentType > OutputPixelType;
typedef itk::Image< InputPixelType, VImageDimension > InputImageType;
typedef itk::Image< OutputPixelType, VImageDimension > OutputImageType;
typedef itk::ImageRegionConstIterator< InputImageType > InputImageIteratorType;
typedef itk::ImageRegionIteratorWithIndex< OutputImageType > OutputImageIteratorType;
typename mitk::ImageToItk< OutputImageType >::Pointer outputimagetoitk =
mitk::ImageToItk< OutputImageType >::New();
outputimagetoitk->SetInput(addComponentFilter->m_OutputTimeSelector->GetOutput());
outputimagetoitk->Update();
typename OutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
// create the iterators
typename InputImageType::RegionType inputRegionOfInterest =
inputItkImage->GetLargestPossibleRegion();
InputImageIteratorType inputIt( inputItkImage, inputRegionOfInterest );
OutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
for ( inputIt.GoToBegin(), outputIt.GoToBegin();
!inputIt.IsAtEnd();
++inputIt, ++outputIt )
{
typename InputPixelType::Iterator pixelInputIt = inputIt.Get().Begin();
typename OutputPixelType::Iterator pixelOutputIt = outputIt.Get().Begin();
*pixelOutputIt++ = *pixelInputIt++;
*pixelOutputIt++ = *pixelInputIt++;
*pixelOutputIt++ = *pixelInputIt++;
*pixelOutputIt = defaultAlpha;
}
}
diff --git a/Core/Code/Algorithms/mitkSurfaceSource.cpp b/Core/Code/Algorithms/mitkSurfaceSource.cpp
index 68900b0295..f70b4f1930 100644
--- a/Core/Code/Algorithms/mitkSurfaceSource.cpp
+++ b/Core/Code/Algorithms/mitkSurfaceSource.cpp
@@ -1,90 +1,51 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSurfaceSource.h"
#include "mitkSurface.h"
mitk::SurfaceSource::SurfaceSource()
{
// Create the output. We use static_cast<> here because we know the default
// output must be of type TOutputImage
- mitk::Surface::Pointer output
- = static_cast<mitk::Surface*>(this->MakeOutput(0).GetPointer());
+ itk::DataObject::Pointer output = this->MakeOutput(0);
Superclass::SetNumberOfRequiredOutputs(1);
- Superclass::SetNthOutput(0, output.GetPointer());
+ Superclass::SetNthOutput(0, output);
}
mitk::SurfaceSource::~SurfaceSource()
{
}
-mitk::SurfaceSource::DataObjectPointer mitk::SurfaceSource::MakeOutput(unsigned int /*idx*/)
+itk::DataObject::Pointer mitk::SurfaceSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
- return static_cast<itk::DataObject*>(mitk::Surface::New().GetPointer());
+ return OutputType::New().GetPointer();
}
-mitk::Surface* mitk::SurfaceSource::GetOutput()
-{
- if (this->GetNumberOfOutputs() < 1)
- {
- return 0;
- }
-
- return static_cast<mitk::Surface*>
- (this->BaseProcess::GetOutput(0));
-}
-
-mitk::Surface* mitk::SurfaceSource::GetOutput(unsigned int idx)
-{
- return static_cast<mitk::Surface*>
- (this->ProcessObject::GetOutput(idx));
-}
-void mitk::SurfaceSource::SetOutput(mitk::Surface* output)
+itk::DataObject::Pointer mitk::SurfaceSource::MakeOutput( const DataObjectIdentifierType & name )
{
- itkWarningMacro(<< "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead." );
- BaseProcess::SetNthOutput(0, output);
-}
-
-void mitk::SurfaceSource::GraftOutput(mitk::Surface* graft)
-{
- this->GraftNthOutput(0, graft);
-}
-
-void mitk::SurfaceSource::GraftNthOutput(unsigned int idx, mitk::Surface *graft)
-{
- if (idx < this->GetNumberOfOutputs())
- {
- mitk::Surface * output = this->GetOutput(idx);
-
- if (output && graft)
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
{
- // grab a handle to the bulk data of the specified data object
- // output->SetPixelContainer( graft->GetPixelContainer() ); @FIXME!!!!
-
- // copy the region ivars of the specified data object
- output->SetRequestedRegion( graft );//graft->GetRequestedRegion() );
- // output->SetLargestPossibleRegion( graft->GetLargestPossibleRegion() ); @FIXME!!!!
- // output->SetBufferedRegion( graft->GetBufferedRegion() ); @FIXME!!!!
-
- // copy the meta-information
- output->CopyInformation( graft );
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
}
- }
+ return static_cast<itk::DataObject *>(mitk::Surface::New().GetPointer());
}
+mitkBaseDataSourceGetOutputDefinitions(mitk::SurfaceSource)
diff --git a/Core/Code/Algorithms/mitkSurfaceSource.h b/Core/Code/Algorithms/mitkSurfaceSource.h
index 0789918769..197164161a 100644
--- a/Core/Code/Algorithms/mitkSurfaceSource.h
+++ b/Core/Code/Algorithms/mitkSurfaceSource.h
@@ -1,66 +1,72 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKSURFACEDATASOURCE_H_HEADER_INCLUDED_C10B4740
#define MITKSURFACEDATASOURCE_H_HEADER_INCLUDED_C10B4740
-#include "mitkBaseProcess.h"
+#include "mitkBaseDataSource.h"
namespace mitk {
class Surface;
-//##Documentation
-//## @brief Superclass of all classes generating surfaces (instances of class
-//## Surface) as output.
-//##
-//## In itk and vtk the generated result of a ProcessObject is only guaranteed
-//## to be up-to-date, when Update() of the ProcessObject or the generated
-//## DataObject is called immediately before access of the data stored in the
-//## DataObject. This is also true for subclasses of mitk::BaseProcess and thus
-//## for mitk::SurfaceSource.
-//## @ingroup Process
-class MITK_CORE_EXPORT SurfaceSource : public BaseProcess
+
+/**
+ * @brief Superclass of all classes generating surfaces (instances of class
+ * Surface) as output.
+ *
+ * In itk and vtk the generated result of a ProcessObject is only guaranteed
+ * to be up-to-date, when Update() of the ProcessObject or the generated
+ * DataObject is called immediately before access of the data stored in the
+ * DataObject. This is also true for subclasses of mitk::BaseProcess and thus
+ * for mitk::SurfaceSource.
+ * @ingroup Process
+ */
+class MITK_CORE_EXPORT SurfaceSource : public BaseDataSource
{
public:
- mitkClassMacro(SurfaceSource, BaseProcess);
-
- itkNewMacro(Self);
-
- typedef itk::DataObject::Pointer DataObjectPointer;
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ mitkClassMacro(SurfaceSource, BaseDataSource)
+ itkNewMacro(Self)
- void SetOutput(mitk::Surface* output);
+ typedef Surface OutputType;
- mitk::Surface* GetOutput();
+ mitkBaseDataSourceGetOutputDeclarations
- mitk::Surface* GetOutput(unsigned int idx);
+ /**
+ * Allocates a new output object and returns it. Currently the
+ * index idx is not evaluated.
+ * @param idx the index of the output for which an object should be created
+ * @returns the new object
+ */
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
- virtual void GraftOutput(mitk::Surface* graft);
-
- virtual void GraftNthOutput(unsigned int idx, mitk::Surface *graft);
+ /**
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
+ */
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
protected:
SurfaceSource();
virtual ~SurfaceSource();
};
} // namespace mitk
-
-
#endif /* MITKSURFACEDATASOURCE_H_HEADER_INCLUDED_C10B4740 */
diff --git a/Core/Code/Algorithms/mitkSurfaceToSurfaceFilter.cpp b/Core/Code/Algorithms/mitkSurfaceToSurfaceFilter.cpp
index 94c735eb96..5a08da2ef8 100644
--- a/Core/Code/Algorithms/mitkSurfaceToSurfaceFilter.cpp
+++ b/Core/Code/Algorithms/mitkSurfaceToSurfaceFilter.cpp
@@ -1,85 +1,79 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSurfaceToSurfaceFilter.h"
#include "mitkSurface.h"
mitk::SurfaceToSurfaceFilter::SurfaceToSurfaceFilter()
: SurfaceSource()
{
}
mitk::SurfaceToSurfaceFilter::~SurfaceToSurfaceFilter()
{
}
void mitk::SurfaceToSurfaceFilter::SetInput( const mitk::Surface* surface )
{
this->SetInput( 0, const_cast<mitk::Surface*>( surface ) );
}
void mitk::SurfaceToSurfaceFilter::SetInput( unsigned int idx, const mitk::Surface* surface )
{
if ( this->GetInput(idx) != surface )
{
this->SetNthInput( idx, const_cast<mitk::Surface*>( surface ) );
this->CreateOutputsForAllInputs(idx);
this->Modified();
}
}
const mitk::Surface* mitk::SurfaceToSurfaceFilter::GetInput()
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const mitk::Surface*>(this->ProcessObject::GetInput(0));
}
const mitk::Surface* mitk::SurfaceToSurfaceFilter::GetInput( unsigned int idx)
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const mitk::Surface*>(this->ProcessObject::GetInput(idx));
}
void mitk::SurfaceToSurfaceFilter::CreateOutputsForAllInputs(unsigned int /*idx*/)
{
- this->SetNumberOfOutputs( this->GetNumberOfInputs() );
- for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
+ this->SetNumberOfIndexedOutputs( this->GetNumberOfIndexedInputs() );
+ for (unsigned int idx = 0; idx < this->GetNumberOfIndexedInputs(); ++idx)
{
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->GetOutput( idx )->Graft( this->GetInput( idx) );
}
this->Modified();
}
-
-
-void mitk::SurfaceToSurfaceFilter::RemoveInputs(mitk::Surface* input)
-{
- this->RemoveInput(input);
-}
diff --git a/Core/Code/Algorithms/mitkSurfaceToSurfaceFilter.h b/Core/Code/Algorithms/mitkSurfaceToSurfaceFilter.h
index 7b37fd8a8c..ba6bc04ece 100644
--- a/Core/Code/Algorithms/mitkSurfaceToSurfaceFilter.h
+++ b/Core/Code/Algorithms/mitkSurfaceToSurfaceFilter.h
@@ -1,66 +1,65 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKSURFACETOSURFACEFILTER_H_HEADER_INCLUDED_C10B4740
#define MITKSURFACETOSURFACEFILTER_H_HEADER_INCLUDED_C10B4740
#include "mitkSurfaceSource.h"
namespace mitk {
class Surface;
//##Documentation
//## @brief Superclass of all classes getting surfaces (instances of class
//## Surface) as input and generating surfaces as output.
//##
//## In itk and vtk the generated result of a ProcessObject is only guaranteed
//## to be up-to-date, when Update() of the ProcessObject or the generated
//## DataObject is called immediately before access of the data stored in the
//## DataObject. This is also true for subclasses of mitk::BaseProcess and thus
//## for mitk::mitkSurfaceToSurfaceFilter.
//## @ingroup Process
class MITK_CORE_EXPORT SurfaceToSurfaceFilter : public mitk::SurfaceSource
{
public:
mitkClassMacro(SurfaceToSurfaceFilter, mitk::SurfaceSource);
itkNewMacro(Self);
typedef itk::DataObject::Pointer DataObjectPointer;
+ using itk::ProcessObject::SetInput;
virtual void SetInput( const mitk::Surface* surface );
virtual void SetInput( unsigned int idx, const mitk::Surface* surface );
virtual const mitk::Surface* GetInput();
virtual const mitk::Surface* GetInput( unsigned int idx );
virtual void CreateOutputsForAllInputs(unsigned int idx);
- virtual void RemoveInputs(mitk::Surface* input);
-
protected:
SurfaceToSurfaceFilter();
virtual ~SurfaceToSurfaceFilter();
};
} // namespace mitk
#endif /* MITKSURFACETOSURFACEFILTER_H_HEADER_INCLUDED_C10B4740 */
diff --git a/Core/Code/CMakeLists.txt b/Core/Code/CMakeLists.txt
index 9bbee2b90b..5b97f1cb72 100644
--- a/Core/Code/CMakeLists.txt
+++ b/Core/Code/CMakeLists.txt
@@ -1,85 +1,74 @@
#FIND_PACKAGE(OpenGL)
#IF(NOT OPENGL_FOUND)
# MESSAGE("GL is required for MITK rendering")
#ENDIF(NOT OPENGL_FOUND )
# Configure the C++ Micro Services Code for MITK
find_package(ITK REQUIRED)
include(${ITK_USE_FILE})
set(US_NAMESPACE "mitk")
set(US_HEADER_PREFIX "mitk")
set(US_BASECLASS_NAME "itk::LightObject")
set(US_BASECLASS_HEADER "mitkServiceBaseObject.h")
set(US_BASECLASS_PACKAGE "ITK")
set(US_ENABLE_THREADING_SUPPORT 1)
set(US_ENABLE_AUTOLOADING_SUPPORT 1)
set(US_EMBEDDING_LIBRARY Mitk)
set(US_BUILD_TESTING ${BUILD_TESTING})
if(BUILD_TESTING)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/Common)
set(US_TEST_LABELS MITK-Core)
endif()
add_subdirectory(CppMicroServices)
include(${CMAKE_CURRENT_BINARY_DIR}/CppMicroServices/CppMicroServicesConfig.cmake)
set(TOOL_CPPS "")
# temporary suppress warnings in the following files until image accessors are fully integrated.
set_source_files_properties( DataManagement/mitkImage.cpp COMPILE_FLAGS -DMITK_NO_DEPRECATED_WARNINGS )
set_source_files_properties( Controllers/mitkSliceNavigationController.cpp COMPILE_FLAGS -DMITK_NO_DEPRECATED_WARNINGS )
MITK_CREATE_MODULE( Mitk
INCLUDE_DIRS
${CppMicroServices_INCLUDE_DIRS} Algorithms Common DataManagement Controllers
Interactions Interfaces IO Rendering ${MITK_BINARY_DIR}
INTERNAL_INCLUDE_DIRS
${OPENGL_INCLUDE_DIR} ${IPSEGMENTATION_INCLUDE_DIR} ${ANN_INCLUDE_DIR}
${CppMicroServices_INTERNAL_INCLUDE_DIRS}
DEPENDS mbilog tinyxml
DEPENDS_INTERNAL pic2vtk
- PACKAGE_DEPENDS ITK VTK OpenGL
+ PACKAGE_DEPENDS ITK GDCM VTK OpenGL
EXPORT_DEFINE MITK_CORE_EXPORT
WARNINGS_AS_ERRORS
)
# this is needed for libraries which link to Mitk and need
# symbols from explicitly instantiated templates like
# mitk::SurfaceVtkWriter<vtkSTLWriter> which is referenced in
# QmitkCommonFunctionality in the QmitkExt library.
if(MINGW)
get_target_property(_mitkCore_MINGW_linkflags Mitk LINK_FLAGS)
if(NOT _mitkCore_MINGW_linkflags)
set(_mitkCore_MINGW_linkflags "")
endif(NOT _mitkCore_MINGW_linkflags)
set_target_properties(Mitk PROPERTIES LINK_FLAGS "${_mitkCore_MINGW_linkflags} -Wl,--export-all-symbols")
endif(MINGW)
# replacing Mitk by Mitk [due to removing the PROVIDES macro
TARGET_LINK_LIBRARIES(Mitk ${LIBRARIES_FOR_${KITNAME}_CORE} ${IPFUNC_LIBRARY} ipSegmentation ann)
#TARGET_LINK_LIBRARIES(Mitk ${OPENGL_LIBRARIES} )
TARGET_LINK_LIBRARIES(Mitk gdcmCommon gdcmIOD gdcmDSED)
if(MSVC_IDE OR MSVC_VERSION OR MINGW)
target_link_libraries(Mitk psapi.lib)
endif(MSVC_IDE OR MSVC_VERSION OR MINGW)
-
-# verify ITK has been built with GDCM >= 2.0.14
-set(GDCM_FULL_VERSION "${GDCM_MAJOR_VERSION}.${GDCM_MINOR_VERSION}.${GDCM_BUILD_VERSION}")
-set(MITK_REQUIRED_GDCM_VERSION "2.0.14")
-if(GDCM_FULL_VERSION VERSION_LESS MITK_REQUIRED_GDCM_VERSION)
- message(SEND_ERROR "Mitk: MITK requires ITK with at least GDCM version ${MITK_REQUIRED_GDCM_VERSION}.\nFound version ${GDCM_FULL_VERSION} (GDCM NOT found if you don't see a version here)")
-else(GDCM_FULL_VERSION VERSION_LESS MITK_REQUIRED_GDCM_VERSION)
- message(STATUS "Mitk: Found GDCM version ${GDCM_FULL_VERSION}")
-endif(GDCM_FULL_VERSION VERSION_LESS MITK_REQUIRED_GDCM_VERSION)
-
-
# build tests?
OPTION(BUILD_TESTING "Build the MITK Core tests." ON)
IF(BUILD_TESTING)
ENABLE_TESTING()
ADD_SUBDIRECTORY(Testing)
ENDIF(BUILD_TESTING)
diff --git a/Core/Code/Common/mitkCommon.h b/Core/Code/Common/mitkCommon.h
index a9ca22ed31..590e46efd6 100644
--- a/Core/Code/Common/mitkCommon.h
+++ b/Core/Code/Common/mitkCommon.h
@@ -1,145 +1,145 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITK_COMMON_H_DEFINED
#define MITK_COMMON_H_DEFINED
#ifdef _MSC_VER
// This warns about truncation to 255 characters in debug/browse info
#pragma warning (disable : 4786)
#pragma warning (disable : 4068 ) /* disable unknown pragma warnings */
#endif
//add only those headers here that are really necessary for all classes!
#include "itkObject.h"
#include "mitkConfig.h"
#include "mitkLogMacros.h"
#include "mitkExportMacros.h"
#include "mitkExceptionMacro.h"
#ifndef MITK_UNMANGLE_IPPIC
#define mitkIpPicDescriptor mitkIpPicDescriptor
#endif
typedef unsigned int MapperSlotId;
#define mitkClassMacro(className,SuperClassName) \
typedef className Self; \
typedef SuperClassName Superclass; \
typedef itk::SmartPointer<Self> Pointer; \
typedef itk::SmartPointer<const Self> ConstPointer; \
itkTypeMacro(className,SuperClassName)
/**
* Macro for Constructors with one parameter for classes derived from itk::Lightobject
**/
#define mitkNewMacro1Param(classname,type) \
static Pointer New(type _arg) \
{ \
Pointer smartPtr = new classname ( _arg ); \
smartPtr->UnRegister(); \
return smartPtr; \
} \
/**
* Macro for Constructors with two parameters for classes derived from itk::Lightobject
**/
#define mitkNewMacro2Param(classname,typea,typeb) \
static Pointer New(typea _arga, typeb _argb) \
{ \
Pointer smartPtr = new classname ( _arga, _argb ); \
smartPtr->UnRegister(); \
return smartPtr; \
} \
/**
* Macro for Constructors with three parameters for classes derived from itk::Lightobject
**/
#define mitkNewMacro3Param(classname,typea,typeb,typec) \
static Pointer New(typea _arga, typeb _argb, typec _argc) \
{ \
Pointer smartPtr = new classname ( _arga, _argb, _argc ); \
smartPtr->UnRegister(); \
return smartPtr; \
} \
/**
* Macro for Constructors with four parameters for classes derived from itk::Lightobject
**/
#define mitkNewMacro4Param(classname,typea,typeb,typec,typed) \
static Pointer New(typea _arga, typeb _argb, typec _argc, typed _argd) \
{ \
Pointer smartPtr = new classname ( _arga, _argb, _argc, _argd ); \
smartPtr->UnRegister(); \
return smartPtr; \
} \
/**
* Macro for Constructors with five parameters for classes derived from itk::Lightobject
**/
#define mitkNewMacro5Param(classname,typea,typeb,typec,typed,typee) \
static Pointer New(typea _arga, typeb _argb, typec _argc, typed _argd, typee _arge) \
{ \
Pointer smartPtr = new classname ( _arga, _argb, _argc, _argd, _arge ); \
smartPtr->UnRegister(); \
return smartPtr; \
} \
/**
* Macro for Constructors with six parameters for classes derived from itk::Lightobject
**/
#define mitkNewMacro6Param(classname,typea,typeb,typec,typed,typee, typef) \
static Pointer New(typea _arga, typeb _argb, typec _argc, typed _argd, typee _arge, typef _argf) \
{ \
Pointer smartPtr = new classname ( _arga, _argb, _argc, _argd, _arge, _argf ); \
smartPtr->UnRegister(); \
return smartPtr; \
} \
/** Get a smart const pointer to an object. Creates the member
* Get"name"() (e.g., GetPoints()). */
#define mitkGetObjectMacroConst(name,type) \
virtual type * Get##name () const \
{ \
itkDebugMacro("returning " #name " address " << this->m_##name ); \
return this->m_##name.GetPointer(); \
}
/** Creates a Clone() method for "Classname". Returns a smartPtr of a clone of the
calling object*/
#define mitkCloneMacro(classname) \
- virtual Pointer Clone() const \
+ virtual itk::LightObject::Pointer InternalClone() const \
{ \
Pointer smartPtr = new classname(*this); \
smartPtr->UnRegister(); \
- return smartPtr; \
+ return smartPtr.GetPointer(); \
}
/** cross-platform deprecation macro
\todo maybe there is something in external toolkits (ITK, VTK,...) that we could reulse -- would be much preferable
*/
#ifdef MITK_NO_DEPRECATED_WARNINGS
#define DEPRECATED(func) func
#elif defined(__GNUC__)
#define DEPRECATED(...) __VA_ARGS__ __attribute__((deprecated))
#elif defined(_MSC_VER)
#define DEPRECATED(...) __declspec(deprecated) ##__VA_ARGS__
#else
#pragma message("WARNING: You need to implement DEPRECATED for your compiler!")
#define DEPRECATED(func) func
#endif
#endif // MITK_COMMON_H_DEFINED
diff --git a/Core/Code/Common/mitkCoreObjectFactory.cpp b/Core/Code/Common/mitkCoreObjectFactory.cpp
index 64f7f805dc..3b4cbe8a99 100644
--- a/Core/Code/Common/mitkCoreObjectFactory.cpp
+++ b/Core/Code/Common/mitkCoreObjectFactory.cpp
@@ -1,403 +1,403 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkConfig.h"
#include "mitkCoreObjectFactory.h"
#include "mitkAffineInteractor.h"
#include "mitkColorProperty.h"
#include "mitkDataNode.h"
#include "mitkEnumerationProperty.h"
#include "mitkGeometry2DData.h"
#include "mitkGeometry2DDataMapper2D.h"
#include "mitkGeometry2DDataVtkMapper3D.h"
#include "mitkGeometry3D.h"
#include "mitkGeometryData.h"
#include "mitkImage.h"
#include <mitkImageVtkMapper2D.h>
#include "mitkLevelWindowProperty.h"
#include "mitkLookupTable.h"
#include "mitkLookupTableProperty.h"
#include "mitkPlaneGeometry.h"
#include "mitkPointSet.h"
-#include "mitkPointSetGLMapper2D.h"
+#include "mitkPointSetVtkMapper2D.h"
#include "mitkPointSetVtkMapper3D.h"
#include "mitkPolyDataGLMapper2D.h"
#include "mitkProperties.h"
#include "mitkPropertyList.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkSmartPointerProperty.h"
#include "mitkStringProperty.h"
#include "mitkSurface.h"
#include "mitkSurface.h"
#include "mitkSurfaceGLMapper2D.h"
#include "mitkSurfaceVtkMapper3D.h"
#include "mitkTimeSlicedGeometry.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkVolumeDataVtkMapper3D.h"
#include "mitkVtkInterpolationProperty.h"
#include "mitkVtkRepresentationProperty.h"
#include "mitkVtkResliceInterpolationProperty.h"
//#include "mitkPicFileIOFactory.h"
#include "mitkPointSetIOFactory.h"
#include "mitkItkImageFileIOFactory.h"
#include "mitkSTLFileIOFactory.h"
#include "mitkVtkSurfaceIOFactory.h"
#include "mitkVtkImageIOFactory.h"
#include "mitkVtiFileIOFactory.h"
//#include "mitkPicVolumeTimeSeriesIOFactory.h"
#include "mitkImageWriterFactory.h"
#include "mitkPointSetWriterFactory.h"
#include "mitkSurfaceVtkWriterFactory.h"
mitk::CoreObjectFactory::FileWriterList mitk::CoreObjectFactory::m_FileWriters;
void mitk::CoreObjectFactory::RegisterExtraFactory(CoreObjectFactoryBase* factory) {
MITK_DEBUG << "CoreObjectFactory: registering extra factory of type " << factory->GetNameOfClass();
m_ExtraFactories.insert(CoreObjectFactoryBase::Pointer(factory));
}
void mitk::CoreObjectFactory::UnRegisterExtraFactory(CoreObjectFactoryBase *factory)
{
MITK_DEBUG << "CoreObjectFactory: un-registering extra factory of type " << factory->GetNameOfClass();
try
{
m_ExtraFactories.erase(factory);
}
catch( std::exception const& e)
{
MITK_ERROR << "Caugt exception while unregistering: " << e.what();
}
}
mitk::CoreObjectFactory::Pointer mitk::CoreObjectFactory::GetInstance() {
static mitk::CoreObjectFactory::Pointer instance;
if (instance.IsNull())
{
instance = mitk::CoreObjectFactory::New();
}
return instance;
}
#include <mitkDataNodeFactory.h>
void mitk::CoreObjectFactory::SetDefaultProperties(mitk::DataNode* node)
{
if(node==NULL)
return;
mitk::DataNode::Pointer nodePointer = node;
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
if(image.IsNotNull() && image->IsInitialized())
{
mitk::ImageVtkMapper2D::SetDefaultProperties(node);
mitk::VolumeDataVtkMapper3D::SetDefaultProperties(node);
}
mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(node->GetData());
if(surface.IsNotNull())
{
mitk::SurfaceGLMapper2D::SetDefaultProperties(node);
mitk::SurfaceVtkMapper3D::SetDefaultProperties(node);
}
mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
if(pointSet.IsNotNull())
{
- mitk::PointSetGLMapper2D::SetDefaultProperties(node);
+ mitk::PointSetVtkMapper2D::SetDefaultProperties(node);
mitk::PointSetVtkMapper3D::SetDefaultProperties(node);
}
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
(*it)->SetDefaultProperties(node);
}
}
mitk::CoreObjectFactory::CoreObjectFactory()
{
static bool alreadyDone = false;
if (!alreadyDone)
{
MITK_DEBUG << "CoreObjectFactory c'tor" << std::endl;
// FIXME itk::ObjectFactoryBase::RegisterFactory( PicFileIOFactory::New() );
itk::ObjectFactoryBase::RegisterFactory( PointSetIOFactory::New() );
itk::ObjectFactoryBase::RegisterFactory( STLFileIOFactory::New() );
itk::ObjectFactoryBase::RegisterFactory( VtkSurfaceIOFactory::New() );
itk::ObjectFactoryBase::RegisterFactory( VtkImageIOFactory::New() );
itk::ObjectFactoryBase::RegisterFactory( VtiFileIOFactory::New() );
itk::ObjectFactoryBase::RegisterFactory( ItkImageFileIOFactory::New() );
// FIXME itk::ObjectFactoryBase::RegisterFactory( PicVolumeTimeSeriesIOFactory::New() );
mitk::SurfaceVtkWriterFactory::RegisterOneFactory();
mitk::PointSetWriterFactory::RegisterOneFactory();
mitk::ImageWriterFactory::RegisterOneFactory();
CreateFileExtensionsMap();
alreadyDone = true;
}
}
mitk::Mapper::Pointer mitk::CoreObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
{
mitk::Mapper::Pointer newMapper = NULL;
mitk::Mapper::Pointer tmpMapper = NULL;
// check whether extra factories provide mapper
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
tmpMapper = (*it)->CreateMapper(node,id);
if(tmpMapper.IsNotNull())
newMapper = tmpMapper;
}
if (newMapper.IsNull())
{
mitk::BaseData *data = node->GetData();
if ( id == mitk::BaseRenderer::Standard2D )
{
if((dynamic_cast<Image*>(data)!=NULL))
{
newMapper = mitk::ImageVtkMapper2D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<Geometry2DData*>(data)!=NULL))
{
newMapper = mitk::Geometry2DDataMapper2D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<Surface*>(data)!=NULL))
{
newMapper = mitk::SurfaceGLMapper2D::New();
// cast because SetDataNode is not virtual
mitk::SurfaceGLMapper2D *castedMapper = dynamic_cast<mitk::SurfaceGLMapper2D*>(newMapper.GetPointer());
castedMapper->SetDataNode(node);
}
else if((dynamic_cast<PointSet*>(data)!=NULL))
{
- newMapper = mitk::PointSetGLMapper2D::New();
+ newMapper = mitk::PointSetVtkMapper2D::New();
newMapper->SetDataNode(node);
}
}
else if ( id == mitk::BaseRenderer::Standard3D )
{
if((dynamic_cast<Image*>(data) != NULL))
{
newMapper = mitk::VolumeDataVtkMapper3D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<Geometry2DData*>(data)!=NULL))
{
newMapper = mitk::Geometry2DDataVtkMapper3D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<Surface*>(data)!=NULL))
{
newMapper = mitk::SurfaceVtkMapper3D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<PointSet*>(data)!=NULL))
{
newMapper = mitk::PointSetVtkMapper3D::New();
newMapper->SetDataNode(node);
}
}
}
return newMapper;
}
/*
// @deprecated
//
#define EXTERNAL_FILE_EXTENSIONS \
"All known formats(*.dcm *.DCM *.dc3 *.DC3 *.gdcm *.ima *.mhd *.mps *.nii *.pic *.pic.gz *.bmp *.png *.jpg *.tiff *.pvtk *.stl *.vtk *.vtp *.vtu *.obj *.vti *.hdr *.nrrd *.nhdr );;" \
"DICOM files(*.dcm *.DCM *.dc3 *.DC3 *.gdcm);;" \
"DKFZ Pic (*.seq *.pic *.pic.gz *.seq.gz);;" \
"NRRD Vector Images (*.nrrd *.nhdr);;" \
"Point sets (*.mps);;" \
"Sets of 2D slices (*.pic *.pic.gz *.bmp *.png *.dcm *.gdcm *.ima *.tiff);;" \
"Surface files (*.stl *.vtk *.vtp *.obj);;" \
"NIfTI format (*.nii)"
#define SAVE_FILE_EXTENSIONS "all (*.pic *.mhd *.vtk *.vti *.hdr *.png *.tiff *.jpg *.hdr *.bmp *.dcm *.gipl *.nii *.nrrd *.nhdr *.spr *.lsm *.dwi *.hdwi *.qbi *.hqbi)"
*/
/**
* @brief This method gets the supported (open) file extensions as string. This string is can then used by the QT QFileDialog widget.
* @return The c-string that contains the file extensions
*
*/
const char* mitk::CoreObjectFactory::GetFileExtensions()
{
MultimapType aMap;
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ )
{
aMap = (*it)->GetFileExtensionsMap();
this->MergeFileExtensions(m_FileExtensionsMap, aMap);
}
this->CreateFileExtensions(m_FileExtensionsMap, m_FileExtensions);
return m_FileExtensions.c_str();
}
/**
* @brief Merge the input map into the fileExtensionsMap. Duplicate entries are removed
* @param fileExtensionsMap the existing map, it contains value pairs like ("*.dcm", "DICOM files"),("*.dc3", "DICOM files").
* This map is extented/merged with the values from the input map.
* @param inputMap the input map, it contains value pairs like ("*.dcm", "DICOM files"),("*.dc3", "DICOM files") returned by
* the extra factories.
*
*/
void mitk::CoreObjectFactory::MergeFileExtensions(MultimapType& fileExtensionsMap, MultimapType inputMap)
{
bool duplicateFound = false;
std::pair<MultimapType::iterator, MultimapType::iterator> pairOfIter;
for (MultimapType::iterator it = inputMap.begin(); it != inputMap.end(); ++it)
{
duplicateFound = false;
pairOfIter = fileExtensionsMap.equal_range((*it).first);
for (MultimapType::iterator it2 = pairOfIter.first; it2 != pairOfIter.second; ++it2)
{
//cout << " [" << (*it).first << ", " << (*it).second << "]" << endl;
std::string aString = (*it2).second;
if (aString.compare((*it).second) == 0)
{
//cout << " DUP!! [" << (*it).first << ", " << (*it).second << "]" << endl;
duplicateFound = true;
break;
}
}
if (!duplicateFound)
{
fileExtensionsMap.insert(std::pair<std::string, std::string>((*it).first, (*it).second));
}
}
}
/**
* @brief get the defined (open) file extension map
* @return the defined (open) file extension map
*/
mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetFileExtensionsMap()
{
return m_FileExtensionsMap;
}
/**
* @brief initialize the file extension entries for open and save
*/
void mitk::CoreObjectFactory::CreateFileExtensionsMap()
{
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DCM", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dc3", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DC3", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq", "DKFZ Pic"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic", "DKFZ Pic"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic.gz", "DKFZ Pic"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.mhd", "MetaImage"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq.gz", "DKFZ Pic"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdr", "Analyze Format"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.img", "Analyze Format"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.img.gz", "Analyze Format"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nrrd", "Nearly Raw Raster Data"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nhdr", "NRRD with detached header"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.mps", "Point sets"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic.gz", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.bmp", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.png", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpg", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpeg", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.ima", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tiff", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tif", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.stl", "Surface files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Surface files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtp", "Surface files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.obj", "Surface files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "NIfTI format"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii.gz", "NIfTI format"));
//m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic", "DKFZ Pic"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.mhd", "MetaImage"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Surface Files"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vti", "VTK Image Data Files"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdr", "Analyze Format"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.png", "Sets of 2D slices"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tiff", "Sets of 2D slices"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tif", "Sets of 2D slices"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpg", "Sets of 2D slices"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpeg", "Sets of 2D slices"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.bmp", "Sets of 2D slices"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "Sets of 2D slices"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.gipl", "UMDS GIPL Format Files"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "NIfTI format"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nrrd", "Nearly Raw Raster Data"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nhdr", "NRRD with detached header"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.lsm", "Microscope Images"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
}
/**
* @brief This method gets the supported (save) file extensions as string. This string is can then used by the QT QFileDialog widget.
* @return The c-string that contains the (save) file extensions
*
*/
const char* mitk::CoreObjectFactory::GetSaveFileExtensions() {
MultimapType aMap;
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ )
{
aMap = (*it)->GetSaveFileExtensionsMap();
this->MergeFileExtensions(m_SaveFileExtensionsMap, aMap);
}
this->CreateFileExtensions(m_SaveFileExtensionsMap, m_SaveFileExtensions);
return m_SaveFileExtensions.c_str();
};
/**
* @brief get the defined (save) file extension map
* @return the defined (save) file extension map
*/
mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetSaveFileExtensionsMap()
{
return m_SaveFileExtensionsMap;
}
mitk::CoreObjectFactory::FileWriterList mitk::CoreObjectFactory::GetFileWriters() {
FileWriterList allWriters = m_FileWriters;
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
FileWriterList list2 = (*it)->GetFileWriters();
allWriters.merge(list2);
}
return allWriters;
}
void mitk::CoreObjectFactory::MapEvent(const mitk::Event*, const int) {
}
diff --git a/Core/Code/Common/mitkException.h b/Core/Code/Common/mitkException.h
index 05276676be..3b4133e782 100644
--- a/Core/Code/Common/mitkException.h
+++ b/Core/Code/Common/mitkException.h
@@ -1,113 +1,113 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKEXCEPTION_H_INCLUDED
#define MITKEXCEPTION_H_INCLUDED
#include <MitkExports.h>
-#include <itkExceptionObject.h>
+#include <itkMacro.h>
#include <vector>
namespace mitk {
/**Documentation
* \brief An object of this class represents an exception of MITK.
* Please don't instantiate exceptions manually, but use the
* exception macros (file mitkExceptionMacro.h) instead.
* Simple use in your code is:
*
* mitkThrow() << "optional exception message";
*
* You can also define specialized exceptions which must inherit
* from this class. Please always use the mitkExceptionClassMacro
* when implementing specialized exceptions. A simple implementation
* can look like:
*
* class MyException : public mitk::Exception
* {
* public:
* mitkExceptionClassMacro(MyException,mitk::Exception);
* };
*
* You can then throw your specialized exceptions by using the macro
*
* mitkThrowException(MyException) << "optional exception message";
*/
class MITK_CORE_EXPORT Exception : public itk::ExceptionObject
{
public:
Exception(const char *file, unsigned int lineNumber=0,
const char *desc="None", const char *loc="Unknown") :
itk::ExceptionObject(file,lineNumber,desc,loc){}
virtual ~Exception() throw() {}
itkTypeMacro(ClassName, SuperClassName);
/** \brief Adds rethrow data to this exception. */
void AddRethrowData(const char *file, unsigned int lineNumber, const char *message);
/** \return Returns how often the exception was rethrown. */
int GetNumberOfRethrows();
/** @return Returns the rethrow data of the specified rethrow number. Returns empty data, if the rethrowNumber doesn't exist.
* @param rethrowNumber The internal number of the rethrow.
* @param file (returnvalue) This varaiable will be filled with the file of the specified rethrow.
* @param file (returnvalue) This varaiable will be filled with the line of the specified rethrow.
* @param file (returnvalue) This varaiable will be filled with the message of the specified rethrow.
*/
void GetRethrowData(int rethrowNumber, std::string &file, int &line, std::string &message);
/** \brief Definition of the bit shift operator for this class.*/
template <class T> inline Exception& operator<<(const T& data)
{
std::stringstream ss;
ss << this->GetDescription() << data;
this->SetDescription(ss.str());
return *this;
}
/** \brief Definition of the bit shift operator for this class (for non const data).*/
template <class T> inline Exception& operator<<(T& data)
{
std::stringstream ss;
ss << this->GetDescription() << data;
this->SetDescription(ss.str());
return *this;
}
/** \brief Definition of the bit shift operator for this class (for functions).*/
inline Exception& operator<<(std::ostream& (*func)(std::ostream&))
{
std::stringstream ss;
ss << this->GetDescription() << func;
this->SetDescription(ss.str());
return *this;
}
protected:
struct ReThrowData
{
std::string RethrowClassname;
unsigned int RethrowLine;
std::string RethrowMessage;
};
std::vector<ReThrowData> m_RethrowData;
};
} // namespace mitk
#endif
diff --git a/Core/Code/Common/mitkTestingMacros.h b/Core/Code/Common/mitkTestingMacros.h
index 7c6e991324..8bf909a5cb 100644
--- a/Core/Code/Common/mitkTestingMacros.h
+++ b/Core/Code/Common/mitkTestingMacros.h
@@ -1,139 +1,139 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <exception>
#include <string>
#include <iostream>
-#include <itkExceptionObject.h>
+#include <itkMacro.h>
#include <mitkTestManager.h>
namespace mitk {
/** \brief Indicate a failed test. */
class TestFailedException : public std::exception {
public:
TestFailedException() {}
};
}
/**
*
* \brief Output some text without generating a terminating newline. Include
*
* */
#define MITK_TEST_OUTPUT_NO_ENDL(x) \
std::cout x ;
/** \brief Output some text. */
#define MITK_TEST_OUTPUT(x) \
MITK_TEST_OUTPUT_NO_ENDL(x << "\n")
/** \brief Do some general test preparations. Must be called first in the
main test function. */
#define MITK_TEST_BEGIN(testName) \
std::string mitkTestName(#testName); \
mitk::TestManager::GetInstance()->Initialize(); \
try {
/** \brief Fail and finish test with message MSG */
#define MITK_TEST_FAILED_MSG(MSG) \
MITK_TEST_OUTPUT(MSG) \
throw mitk::TestFailedException();
/** \brief Must be called last in the main test function. */
#define MITK_TEST_END() \
} catch (mitk::TestFailedException ex) { \
MITK_TEST_OUTPUT(<< "Further test execution skipped.") \
mitk::TestManager::GetInstance()->TestFailed(); \
} catch (std::exception ex) { \
MITK_TEST_OUTPUT(<< "std::exception occured " << ex.what()) \
mitk::TestManager::GetInstance()->TestFailed(); \
} \
if (mitk::TestManager::GetInstance()->NumberOfFailedTests() > 0) { \
MITK_TEST_OUTPUT(<< mitkTestName << ": [DONE FAILED] , subtests passed: " << \
mitk::TestManager::GetInstance()->NumberOfPassedTests() << " failed: " << \
mitk::TestManager::GetInstance()->NumberOfFailedTests() ) \
return EXIT_FAILURE; \
} else { \
MITK_TEST_OUTPUT(<< mitkTestName << ": " \
<< mitk::TestManager::GetInstance()->NumberOfPassedTests() \
<< " tests [DONE PASSED]") \
return EXIT_SUCCESS; \
} \
#define MITK_TEST_CONDITION(COND,MSG) \
MITK_TEST_OUTPUT_NO_ENDL(<< MSG) \
if ( ! (COND) ) { \
mitk::TestManager::GetInstance()->TestFailed(); \
MITK_TEST_OUTPUT(<< " [FAILED]\n" << "In " << __FILE__ \
<< ", line " << __LINE__ \
<< ": " #COND " : [FAILED]") \
} else { \
MITK_TEST_OUTPUT(<< " [PASSED]") \
mitk::TestManager::GetInstance()->TestPassed(); \
}
#define MITK_TEST_CONDITION_REQUIRED(COND,MSG) \
MITK_TEST_OUTPUT_NO_ENDL(<< MSG) \
if ( ! (COND) ) { \
MITK_TEST_FAILED_MSG(<< " [FAILED]\n" << " +--> in " << __FILE__ \
<< ", line " << __LINE__ \
<< ", expression is false: \"" #COND "\"") \
} else { \
MITK_TEST_OUTPUT(<< " [PASSED]") \
mitk::TestManager::GetInstance()->TestPassed(); \
}
/**
* \brief Begin block which should be checked for exceptions
*
* This macro, together with MITK_TEST_FOR_EXCEPTION_END, can be used
* to test whether a code block throws an expected exception. The test FAILS if the
* exception is NOT thrown. A simple example:
*
MITK_TEST_FOR_EXCEPTION_BEGIN(itk::ImageFileReaderException)
typedef itk::ImageFileReader< itk::Image<unsigned char,2> > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName("/tmp/not-existing");
reader->Update();
MITK_TEST_FOR_EXCEPTION_END(itk::ImageFileReaderException)
*
*/
#define MITK_TEST_FOR_EXCEPTION_BEGIN(EXCEPTIONCLASS) \
try {
#define MITK_TEST_FOR_EXCEPTION_END(EXCEPTIONCLASS) \
mitk::TestManager::GetInstance()->TestFailed(); \
MITK_TEST_OUTPUT( << "Expected an '" << #EXCEPTIONCLASS << "' exception. [FAILED]") \
} \
catch (EXCEPTIONCLASS) { \
MITK_TEST_OUTPUT( << "Caught an expected '" << #EXCEPTIONCLASS \
<< "' exception. [PASSED]") \
mitk::TestManager::GetInstance()->TestPassed(); \
}
/**
* \brief Simplified version of MITK_TEST_FOR_EXCEPTION_BEGIN / END for
* a single statement
*/
#define MITK_TEST_FOR_EXCEPTION(EXCEPTIONCLASS, STATEMENT) \
MITK_TEST_FOR_EXCEPTION_BEGIN(EXCEPTIONCLASS) \
STATEMENT ; \
MITK_TEST_FOR_EXCEPTION_END(EXCEPTIONCLASS)
diff --git a/Core/Code/Controllers/mitkSliceNavigationController.cpp b/Core/Code/Controllers/mitkSliceNavigationController.cpp
index 2d6219fc19..3e91b3e586 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.cpp
+++ b/Core/Code/Controllers/mitkSliceNavigationController.cpp
@@ -1,737 +1,772 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSliceNavigationController.h"
#include "mitkBaseRenderer.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkPlaneGeometry.h"
#include "mitkOperation.h"
#include "mitkOperationActor.h"
#include "mitkStateEvent.h"
#include "mitkCrosshairPositionEvent.h"
#include "mitkPositionEvent.h"
#include "mitkInteractionConst.h"
#include "mitkAction.h"
#include "mitkGlobalInteraction.h"
#include "mitkEventMapper.h"
#include "mitkFocusManager.h"
#include "mitkVtkPropRenderer.h"
#include "mitkRenderingManager.h"
#include "mitkInteractionConst.h"
#include "mitkPointOperation.h"
#include "mitkPlaneOperation.h"
#include "mitkUndoController.h"
#include "mitkOperationEvent.h"
#include "mitkNodePredicateDataType.h"
#include "mitkStatusBar.h"
#include "mitkMemoryUtilities.h"
#include <itkCommand.h>
namespace mitk {
SliceNavigationController::SliceNavigationController( const char *type )
: BaseController( type ),
m_InputWorldGeometry( NULL ),
m_CreatedWorldGeometry( NULL ),
m_ViewDirection( Axial ),
m_DefaultViewDirection( Axial ),
m_RenderingManager( NULL ),
m_Renderer( NULL ),
m_Top( false ),
m_FrontSide( false ),
m_Rotated( false ),
m_BlockUpdate( false ),
m_SliceLocked( false ),
m_SliceRotationLocked( false ),
m_OldPos(0)
{
typedef itk::SimpleMemberCommand< SliceNavigationController > SNCCommandType;
SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
sliceStepperChangedCommand = SNCCommandType::New();
timeStepperChangedCommand = SNCCommandType::New();
sliceStepperChangedCommand->SetCallbackFunction(
this, &SliceNavigationController::SendSlice );
timeStepperChangedCommand->SetCallbackFunction(
this, &SliceNavigationController::SendTime );
m_Slice->AddObserver( itk::ModifiedEvent(), sliceStepperChangedCommand );
m_Time->AddObserver( itk::ModifiedEvent(), timeStepperChangedCommand );
m_Slice->SetUnitName( "mm" );
m_Time->SetUnitName( "ms" );
m_Top = false;
m_FrontSide = false;
m_Rotated = false;
}
SliceNavigationController::~SliceNavigationController()
{
}
void
SliceNavigationController::SetInputWorldGeometry( const Geometry3D *geometry )
{
if ( geometry != NULL )
{
if ( const_cast< BoundingBox * >( geometry->GetBoundingBox())
->GetDiagonalLength2() < eps )
{
itkWarningMacro( "setting an empty bounding-box" );
geometry = NULL;
}
}
if ( m_InputWorldGeometry != geometry )
{
m_InputWorldGeometry = geometry;
this->Modified();
}
}
RenderingManager *
SliceNavigationController::GetRenderingManager() const
{
mitk::RenderingManager* renderingManager = m_RenderingManager.GetPointer();
if (renderingManager != NULL)
return renderingManager;
if ( m_Renderer != NULL )
{
renderingManager = m_Renderer->GetRenderingManager();
if (renderingManager != NULL)
return renderingManager;
}
return mitk::RenderingManager::GetInstance();
}
void SliceNavigationController::SetViewDirectionToDefault()
{
m_ViewDirection = m_DefaultViewDirection;
}
void SliceNavigationController::Update()
{
if ( !m_BlockUpdate )
{
if ( m_ViewDirection == Axial )
{
this->Update( Axial, false, false, true );
}
else
{
this->Update( m_ViewDirection );
}
}
}
void
SliceNavigationController::Update(
SliceNavigationController::ViewDirection viewDirection,
bool top, bool frontside, bool rotated )
{
const TimeSlicedGeometry* worldTimeSlicedGeometry =
dynamic_cast< const TimeSlicedGeometry * >(
m_InputWorldGeometry.GetPointer() );
if( m_BlockUpdate ||
m_InputWorldGeometry.IsNull() ||
( (worldTimeSlicedGeometry != NULL) && (worldTimeSlicedGeometry->GetTimeSteps() == 0) )
)
{
return;
}
m_BlockUpdate = true;
if ( m_LastUpdateTime < m_InputWorldGeometry->GetMTime() )
{
Modified();
}
this->SetViewDirection( viewDirection );
this->SetTop( top );
this->SetFrontSide( frontside );
this->SetRotated( rotated );
if ( m_LastUpdateTime < GetMTime() )
{
m_LastUpdateTime = GetMTime();
// initialize the viewplane
SlicedGeometry3D::Pointer slicedWorldGeometry = NULL;
m_CreatedWorldGeometry = NULL;
switch ( viewDirection )
{
case Original:
if ( worldTimeSlicedGeometry != NULL )
{
m_CreatedWorldGeometry = static_cast< TimeSlicedGeometry * >(
m_InputWorldGeometry->Clone().GetPointer() );
worldTimeSlicedGeometry = m_CreatedWorldGeometry.GetPointer();
slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
m_CreatedWorldGeometry->GetGeometry3D( this->GetTime()->GetPos() ) );
if ( slicedWorldGeometry.IsNotNull() )
{
break;
}
}
else
{
const SlicedGeometry3D *worldSlicedGeometry =
dynamic_cast< const SlicedGeometry3D * >(
m_InputWorldGeometry.GetPointer());
if ( worldSlicedGeometry != NULL )
{
slicedWorldGeometry = static_cast< SlicedGeometry3D * >(
m_InputWorldGeometry->Clone().GetPointer());
break;
}
}
//else: use Axial: no "break" here!!
case Axial:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(
m_InputWorldGeometry, PlaneGeometry::Axial,
top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Frontal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry,
PlaneGeometry::Frontal, top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Sagittal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry,
PlaneGeometry::Sagittal, top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
default:
itkExceptionMacro("unknown ViewDirection");
}
m_Slice->SetPos( 0 );
m_Slice->SetSteps( (int)slicedWorldGeometry->GetSlices() );
if ( m_CreatedWorldGeometry.IsNull() )
{
// initialize TimeSlicedGeometry
m_CreatedWorldGeometry = TimeSlicedGeometry::New();
}
if ( worldTimeSlicedGeometry == NULL )
{
m_CreatedWorldGeometry->InitializeEvenlyTimed( slicedWorldGeometry, 1 );
m_Time->SetSteps( 0 );
m_Time->SetPos( 0 );
m_Time->InvalidateRange();
}
else
{
m_BlockUpdate = true;
m_Time->SetSteps( worldTimeSlicedGeometry->GetTimeSteps() );
m_Time->SetPos( 0 );
const TimeBounds &timeBounds = worldTimeSlicedGeometry->GetTimeBounds();
m_Time->SetRange( timeBounds[0], timeBounds[1] );
m_BlockUpdate = false;
assert( worldTimeSlicedGeometry->GetGeometry3D( this->GetTime()->GetPos() ) != NULL );
slicedWorldGeometry->SetTimeBounds(
worldTimeSlicedGeometry->GetGeometry3D( this->GetTime()->GetPos() )->GetTimeBounds() );
//@todo implement for non-evenly-timed geometry!
m_CreatedWorldGeometry->InitializeEvenlyTimed(
slicedWorldGeometry, worldTimeSlicedGeometry->GetTimeSteps() );
}
}
// unblock update; we may do this now, because if m_BlockUpdate was already
// true before this method was entered, then we will never come here.
m_BlockUpdate = false;
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry and time/slice data.
this->SendCreatedWorldGeometry();
this->SendSlice();
this->SendTime();
// Adjust the stepper range of slice stepper according to geometry
this->AdjustSliceStepperRange();
}
void
SliceNavigationController::SendCreatedWorldGeometry()
{
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry.
if ( !m_BlockUpdate )
{
this->InvokeEvent( GeometrySendEvent(m_CreatedWorldGeometry, 0) );
}
}
void
SliceNavigationController::SendCreatedWorldGeometryUpdate()
{
if ( !m_BlockUpdate )
{
this->InvokeEvent(
GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
}
}
void
SliceNavigationController::SendSlice()
{
if ( !m_BlockUpdate )
{
if ( m_CreatedWorldGeometry.IsNotNull() )
{
this->InvokeEvent(
GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
// send crosshair event
crosshairPositionEvent.Send();
// Request rendering update for all views
this->GetRenderingManager()->RequestUpdateAll();
}
}
}
void
SliceNavigationController::SendTime()
{
if ( !m_BlockUpdate )
{
if ( m_CreatedWorldGeometry.IsNotNull() )
{
this->InvokeEvent(
GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()) );
// Request rendering update for all views
this->GetRenderingManager()->RequestUpdateAll();
}
}
}
void
SliceNavigationController::SetGeometry( const itk::EventObject & )
{
}
void
SliceNavigationController
::SetGeometryTime( const itk::EventObject &geometryTimeEvent )
{
const SliceNavigationController::GeometryTimeEvent *timeEvent =
dynamic_cast< const SliceNavigationController::GeometryTimeEvent * >(
&geometryTimeEvent);
assert( timeEvent != NULL );
TimeSlicedGeometry *timeSlicedGeometry = timeEvent->GetTimeSlicedGeometry();
assert( timeSlicedGeometry != NULL );
if ( m_CreatedWorldGeometry.IsNotNull() )
{
int timeStep = (int) timeEvent->GetPos();
ScalarType timeInMS;
timeInMS = timeSlicedGeometry->TimeStepToMS( timeStep );
timeStep = m_CreatedWorldGeometry->MSToTimeStep( timeInMS );
this->GetTime()->SetPos( timeStep );
}
}
void
SliceNavigationController
::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
{
const SliceNavigationController::GeometrySliceEvent* sliceEvent =
dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(
&geometrySliceEvent);
assert(sliceEvent!=NULL);
this->GetSlice()->SetPos(sliceEvent->GetPos());
}
void
SliceNavigationController::SelectSliceByPoint( const Point3D &point )
{
//@todo add time to PositionEvent and use here!!
SlicedGeometry3D* slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
m_CreatedWorldGeometry->GetGeometry3D( this->GetTime()->GetPos() ) );
if ( slicedWorldGeometry )
{
int bestSlice = -1;
double bestDistance = itk::NumericTraits<double>::max();
int s, slices;
slices = slicedWorldGeometry->GetSlices();
if ( slicedWorldGeometry->GetEvenlySpaced() )
{
mitk::Geometry2D *plane = slicedWorldGeometry->GetGeometry2D( 0 );
const Vector3D &direction = slicedWorldGeometry->GetDirectionVector();
Point3D projectedPoint;
plane->Project( point, projectedPoint );
// Check whether the point is somewhere within the slice stack volume;
// otherwise, the defualt slice (0) will be selected
if ( direction[0] * (point[0] - projectedPoint[0])
+ direction[1] * (point[1] - projectedPoint[1])
+ direction[2] * (point[2] - projectedPoint[2]) >= 0 )
{
bestSlice = (int)(plane->Distance( point )
/ slicedWorldGeometry->GetSpacing()[2] + 0.5);
}
}
else
{
Point3D projectedPoint;
for ( s = 0; s < slices; ++s )
{
slicedWorldGeometry->GetGeometry2D( s )->Project( point, projectedPoint );
Vector3D distance = projectedPoint - point;
ScalarType currentDistance = distance.GetSquaredNorm();
if ( currentDistance < bestDistance )
{
bestDistance = currentDistance;
bestSlice = s;
}
}
}
if ( bestSlice >= 0 )
{
this->GetSlice()->SetPos( bestSlice );
}
else
{
this->GetSlice()->SetPos( 0 );
}
this->SendCreatedWorldGeometryUpdate();
}
}
void
SliceNavigationController::ReorientSlices( const Point3D &point,
const Vector3D &normal )
{
PlaneOperation op( OpORIENT, point, normal );
m_CreatedWorldGeometry->ExecuteOperation( &op );
this->SendCreatedWorldGeometryUpdate();
}
void SliceNavigationController::ReorientSlices(const mitk::Point3D &point,
const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1 )
{
PlaneOperation op( OpORIENT, point, axisVec0, axisVec1 );
m_CreatedWorldGeometry->ExecuteOperation( &op );
this->SendCreatedWorldGeometryUpdate();
}
const mitk::TimeSlicedGeometry *
SliceNavigationController::GetCreatedWorldGeometry()
{
return m_CreatedWorldGeometry;
}
const mitk::Geometry3D *
SliceNavigationController::GetCurrentGeometry3D()
{
if ( m_CreatedWorldGeometry.IsNotNull() )
{
return m_CreatedWorldGeometry->GetGeometry3D( this->GetTime()->GetPos() );
}
else
{
return NULL;
}
}
const mitk::PlaneGeometry *
SliceNavigationController::GetCurrentPlaneGeometry()
{
const mitk::SlicedGeometry3D *slicedGeometry =
dynamic_cast< const mitk::SlicedGeometry3D * >
( this->GetCurrentGeometry3D() );
if ( slicedGeometry )
{
const mitk::PlaneGeometry *planeGeometry =
dynamic_cast< mitk::PlaneGeometry * >
( slicedGeometry->GetGeometry2D(this->GetSlice()->GetPos()) );
return planeGeometry;
}
else
{
return NULL;
}
}
void
SliceNavigationController::SetRenderer( BaseRenderer *renderer )
{
m_Renderer = renderer;
}
BaseRenderer *
SliceNavigationController::GetRenderer() const
{
return m_Renderer;
}
void
SliceNavigationController::AdjustSliceStepperRange()
{
const mitk::SlicedGeometry3D *slicedGeometry =
dynamic_cast< const mitk::SlicedGeometry3D * >
( this->GetCurrentGeometry3D() );
const Vector3D &direction = slicedGeometry->GetDirectionVector();
int c = 0;
int i, k = 0;
for ( i = 0; i < 3; ++i )
{
if ( fabs( (float) direction[i] ) < 0.000000001 ) { ++c; }
else { k = i; }
}
if ( c == 2 )
{
ScalarType min = m_InputWorldGeometry->GetOrigin()[k];
ScalarType max = min + m_InputWorldGeometry->GetExtentInMM( k );
m_Slice->SetRange( min, max );
}
else
{
m_Slice->InvalidateRange();
}
}
void
SliceNavigationController::ExecuteOperation( Operation *operation )
{
// switch on type
// - select best slice for a given point
// - rotate created world geometry according to Operation->SomeInfo()
if ( !operation )
{
return;
}
switch ( operation->GetOperationType() )
{
case OpMOVE: // should be a point operation
{
if ( !m_SliceLocked ) //do not move the cross position
{
// select a slice
PointOperation *po = dynamic_cast< PointOperation * >( operation );
if ( po && po->GetIndex() == -1 )
{
this->SelectSliceByPoint( po->GetPoint() );
}
else if ( po && po->GetIndex() != -1 ) // undo case because index != -1, index holds the old position of this slice
{
this->GetSlice()->SetPos( po->GetIndex() );
}
}
break;
}
case OpRESTOREPLANEPOSITION:
{
m_CreatedWorldGeometry->ExecuteOperation( operation );
this->SendCreatedWorldGeometryUpdate();
break;
}
default:
{
// do nothing
break;
}
}
}
+mitk::DataNode::Pointer SliceNavigationController::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes,mitk::Point3D worldposition)
+{
+ mitk::DataNode::Pointer node;
+ int maxlayer = -32768;
+ bool isHelper (false);
+ if(nodes.IsNotNull())
+ {
+ for (unsigned int x = 0; x < nodes->size(); x++)
+ {
+ nodes->at(x)->GetBoolProperty("helper object", isHelper);
+ if(nodes->at(x)->GetData()->GetGeometry()->IsInside(worldposition) && isHelper == false)
+ {
+ int layer = 0;
+ if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
+ if(layer > maxlayer)
+ {
+ if(static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(m_Renderer))
+ {
+ node = nodes->at(x);
+ maxlayer = layer;
+ }
+ }
+ }
+ }
+ }
+ return node;
+}
// Relict from the old times, when automous decisions were accepted
// behavior. Remains in here, because some RenderWindows do exist outside
// of StdMultiWidgets.
bool
SliceNavigationController
::ExecuteAction( Action* action, StateEvent const* stateEvent )
{
bool ok = false;
const PositionEvent* posEvent = dynamic_cast< const PositionEvent * >(
stateEvent->GetEvent() );
if ( posEvent != NULL )
{
if ( m_CreatedWorldGeometry.IsNull() )
{
return true;
}
switch (action->GetActionId())
{
case AcMOVE:
{
BaseRenderer *baseRenderer = posEvent->GetSender();
if ( !baseRenderer )
{
baseRenderer = const_cast<BaseRenderer *>(
GlobalInteraction::GetInstance()->GetFocus() );
}
if ( baseRenderer )
if ( baseRenderer->GetMapperID() == 1 )
{
PointOperation doOp(OpMOVE, posEvent->GetWorldPosition());
this->ExecuteOperation( &doOp );
// If click was performed in this render window than we have to update the status bar information about position and pixel value.
if(baseRenderer == m_Renderer)
{
{
std::string statusText;
TNodePredicateDataType<mitk::Image>::Pointer isImageData = TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer nodes = baseRenderer->GetDataStorage()->GetSubset(isImageData).GetPointer();
mitk::Point3D worldposition = posEvent->GetWorldPosition();
- int maxlayer = -32768;
+ //int maxlayer = -32768;
mitk::Image::Pointer image3D;
- // find image with largest layer, that is the image shown on top in the render window
- for (unsigned int x = 0; x < nodes->size(); x++)
- {
- //Just consider image data that is no helper object. E.g. do not consider nodes created for the slice interpolation
- bool isHelper (false);
- nodes->at(x)->GetBoolProperty("helper object", isHelper);
+ mitk::DataNode::Pointer node;
+ mitk::DataNode::Pointer topSourceNode;
+
+ bool isBinary (false);
- if(nodes->at(x)->GetData()->GetGeometry()->IsInside(worldposition) && isHelper == false)
+ node = this->GetTopLayerNode(nodes,worldposition);
+ if(node.IsNotNull())
+ {
+ node->GetBoolProperty("binary", isBinary);
+ if(isBinary)
{
- int layer = 0;
- if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
- if(layer > maxlayer)
+ mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = baseRenderer->GetDataStorage()->GetSources(node, NULL, true);
+ if(!sourcenodes->empty())
{
- if(static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(m_Renderer))
- {
- image3D = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
- maxlayer = layer;
- }
+ topSourceNode = this->GetTopLayerNode(sourcenodes,worldposition);
+ }
+ if(topSourceNode.IsNotNull())
+ {
+ image3D = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
+ }
+ else
+ {
+ image3D = dynamic_cast<mitk::Image*>(node->GetData());
}
}
+ else
+ {
+ image3D = dynamic_cast<mitk::Image*>(node->GetData());
+ }
}
-
std::stringstream stream;
stream.imbue(std::locale::classic());
// get the position and gray value from the image and build up status bar text
if(image3D.IsNotNull())
{
Index3D p;
image3D->GetGeometry()->WorldToIndex(worldposition, p);
stream.precision(2);
stream<<"Position: <" << std::fixed <<worldposition[0] << ", " << std::fixed << worldposition[1] << ", " << std::fixed << worldposition[2] << "> mm";
stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
mitk::ScalarType pixelValue = image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep());
if (fabs(pixelValue)>1000000 || fabs(pixelValue) < 0.01)
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific<< pixelValue <<" ";
}
else
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< pixelValue <<" ";
}
}
else
{
stream << "No image information at this position!";
}
statusText = stream.str();
mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
}
}
ok = true;
break;
}
}
default:
ok = true;
break;
}
return ok;
}
const DisplayPositionEvent *displPosEvent =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( displPosEvent != NULL )
{
return true;
}
return false;
}
} // namespace
diff --git a/Core/Code/Controllers/mitkSliceNavigationController.h b/Core/Code/Controllers/mitkSliceNavigationController.h
index 213cb4119e..13dc103ed5 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.h
+++ b/Core/Code/Controllers/mitkSliceNavigationController.h
@@ -1,555 +1,558 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F
#define SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F
#include <MitkExports.h>
#include "mitkBaseController.h"
#include "mitkRenderingManager.h"
#include "mitkTimeSlicedGeometry.h"
#include "mitkMessage.h"
#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop
#include <itkCommand.h>
#include <sstream>
#include "mitkRestorePlanePositionOperation.h"
+#include "mitkDataStorage.h"
namespace mitk {
#define mitkTimeSlicedGeometryEventMacro( classname , super ) \
class MITK_CORE_EXPORT classname : public super { \
public: \
typedef classname Self; \
typedef super Superclass; \
classname(TimeSlicedGeometry* aTimeSlicedGeometry, unsigned int aPos) \
: Superclass(aTimeSlicedGeometry, aPos) {} \
virtual ~classname() {} \
virtual const char * GetEventName() const { return #classname; } \
virtual bool CheckEvent(const ::itk::EventObject* e) const \
{ return dynamic_cast<const Self*>(e); } \
virtual ::itk::EventObject* MakeObject() const \
{ return new Self(GetTimeSlicedGeometry(), GetPos()); } \
private: \
void operator=(const Self&); \
}
class PlaneGeometry;
class Geometry3D;
class BaseRenderer;
/**
* \brief Controls the selection of the slice the associated BaseRenderer
* will display
*
* A SliceNavigationController takes a Geometry3D as input world geometry
* (TODO what are the exact requirements?) and generates a TimeSlicedGeometry
* as output. The TimeSlicedGeometry holds a number of SlicedGeometry3Ds and
* these in turn hold a series of Geometry2Ds. One of these Geometry2Ds is
* selected as world geometry for the BaseRenderers associated to 2D views.
*
* The SliceNavigationController holds has Steppers (one for the slice, a
* second for the time step), which control the selection of a single
* Geometry2D from the TimeSlicedGeometry. SliceNavigationController generates
* ITK events to tell observers, like a BaseRenderer, when the selected slice
* or timestep changes.
*
* SliceNavigationControllers are registered as listeners to GlobalInteraction
* by the QmitkStdMultiWidget. In ExecuteAction, the controllers react to
* PositionEvents by setting the steppers to the slice which is nearest to the
* point of the PositionEvent.
*
* Example:
* \code
* // Initialization
* sliceCtrl = mitk::SliceNavigationController::New();
*
* // Tell the navigator the geometry to be sliced (with geometry a
* // Geometry3D::ConstPointer)
* sliceCtrl->SetInputWorldGeometry(geometry.GetPointer());
*
* // Tell the navigator in which direction it shall slice the data
* sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial);
*
* // Connect one or more BaseRenderer to this navigator, i.e.: events sent
* // by the navigator when stepping through the slices (e.g. by
* // sliceCtrl->GetSlice()->Next()) will be received by the BaseRenderer
* // (in this example only slice-changes, see also ConnectGeometryTimeEvent
* // and ConnectGeometryEvents.)
* sliceCtrl->ConnectGeometrySliceEvent(renderer.GetPointer());
*
* //create a world geometry and send the information to the connected renderer(s)
* sliceCtrl->Update();
* \endcode
*
*
* You can connect visible navigators to a SliceNavigationController, e.g., a
* QmitkSliderNavigator (for Qt):
*
* \code
* // Create the visible navigator (a slider with a spin-box)
* QmitkSliderNavigator* navigator =
* new QmitkSliderNavigator(parent, "slidernavigator");
*
* // Connect the navigator to the slice-stepper of the
* // SliceNavigationController. For initialization (position, mininal and
* // maximal values) the values of the SliceNavigationController are used.
* // Thus, accessing methods of a navigator is normally not necessary, since
* // everything can be set via the (Qt-independent) SliceNavigationController.
* // The QmitkStepperAdapter converts the Qt-signals to Qt-independent
* // itk-events.
* new QmitkStepperAdapter(navigator, sliceCtrl->GetSlice(), "navigatoradaptor");
* \endcode
*
* If you do not want that all renderwindows are updated when a new slice is
* selected, you can use a specific RenderingManager, which updates only those
* renderwindows that should be updated. This is sometimes useful when a 3D view
* does not need to be updated when the slices in some 2D views are changed.
* QmitkSliderNavigator (for Qt):
*
* \code
* // create a specific RenderingManager
* mitk::RenderingManager::Pointer myManager = mitk::RenderingManager::New();
*
* // tell the RenderingManager to update only renderwindow1 and renderwindow2
* myManager->AddRenderWindow(renderwindow1);
* myManager->AddRenderWindow(renderwindow2);
*
* // tell the SliceNavigationController of renderwindow1 and renderwindow2
* // to use the specific RenderingManager instead of the global one
* renderwindow1->GetSliceNavigationController()->SetRenderingManager(myManager);
* renderwindow2->GetSliceNavigationController()->SetRenderingManager(myManager);
* \endcode
*
* \todo implement for non-evenly-timed geometry!
* \ingroup NavigationControl
*/
class MITK_CORE_EXPORT SliceNavigationController : public BaseController
{
public:
mitkClassMacro(SliceNavigationController,BaseController);
itkNewMacro(Self);
mitkNewMacro1Param(Self, const char *);
/**
* \brief Possible view directions, \a Original will uses
* the Geometry2D instances in a SlicedGeometry3D provided
* as input world geometry (by SetInputWorldGeometry).
*/
enum ViewDirection
{
#ifdef _MSC_VER
Transversal, // deprecated
#endif
Axial = 0,
Sagittal,
Frontal,
Original
};
#ifdef __GNUC__
__attribute__ ((deprecated)) static const ViewDirection Transversal = ViewDirection(Axial);
#endif
/**
* \brief Set the input world geometry out of which the
* geometries for slicing will be created.
*/
void SetInputWorldGeometry(const mitk::Geometry3D* geometry);
itkGetConstObjectMacro(InputWorldGeometry, mitk::Geometry3D);
/**
* \brief Access the created geometry
*/
itkGetConstObjectMacro(CreatedWorldGeometry, mitk::Geometry3D);
/**
* \brief Set the desired view directions
*
* \sa ViewDirection
* \sa Update(ViewDirection viewDirection, bool top = true,
* bool frontside = true, bool rotated = false)
*/
itkSetEnumMacro(ViewDirection, ViewDirection);
itkGetEnumMacro(ViewDirection, ViewDirection);
/**
* \brief Set the default view direction
*
* This is used to re-initialize the view direction of the SNC to the
* default value with SetViewDirectionToDefault()
*
* \sa ViewDirection
* \sa Update(ViewDirection viewDirection, bool top = true,
* bool frontside = true, bool rotated = false)
*/
itkSetEnumMacro(DefaultViewDirection, ViewDirection);
itkGetEnumMacro(DefaultViewDirection, ViewDirection);
virtual void SetViewDirectionToDefault();
/**
* \brief Do the actual creation and send it to the connected
* observers (renderers)
*
*/
virtual void Update();
/**
* \brief Extended version of Update, additionally allowing to
* specify the direction/orientation of the created geometry.
*
*/
virtual void Update(ViewDirection viewDirection, bool top = true,
bool frontside = true, bool rotated = false);
/**
* \brief Send the created geometry to the connected
* observers (renderers)
*
* Called by Update().
*/
virtual void SendCreatedWorldGeometry();
/**
* \brief Tell observers to re-read the currently selected 2D geometry
*
* Called by mitk::SlicesRotator during rotation.
*/
virtual void SendCreatedWorldGeometryUpdate();
/**
* \brief Send the currently selected slice to the connected
* observers (renderers)
*
* Called by Update().
*/
virtual void SendSlice();
/**
* \brief Send the currently selected time to the connected
* observers (renderers)
*
* Called by Update().
*/
virtual void SendTime();
/**
* \brief Set the RenderingManager to be used
*
* If \a NULL, the default RenderingManager will be used.
*/
itkSetObjectMacro(RenderingManager, RenderingManager);
mitk::RenderingManager* GetRenderingManager() const;
#pragma GCC visibility push(default)
itkEventMacro( UpdateEvent, itk::AnyEvent );
#pragma GCC visibility pop
class MITK_CORE_EXPORT TimeSlicedGeometryEvent : public itk::AnyEvent
{
public:
typedef TimeSlicedGeometryEvent Self;
typedef itk::AnyEvent Superclass;
TimeSlicedGeometryEvent(
TimeSlicedGeometry* aTimeSlicedGeometry, unsigned int aPos)
: m_TimeSlicedGeometry(aTimeSlicedGeometry), m_Pos(aPos)
{}
virtual ~TimeSlicedGeometryEvent()
{}
virtual const char * GetEventName() const
{ return "TimeSlicedGeometryEvent"; }
virtual bool CheckEvent(const ::itk::EventObject* e) const
{ return dynamic_cast<const Self*>(e); }
virtual ::itk::EventObject* MakeObject() const
{ return new Self(m_TimeSlicedGeometry, m_Pos); }
TimeSlicedGeometry* GetTimeSlicedGeometry() const
{ return m_TimeSlicedGeometry; }
unsigned int GetPos() const
{ return m_Pos; }
private:
TimeSlicedGeometry::Pointer m_TimeSlicedGeometry;
unsigned int m_Pos;
// TimeSlicedGeometryEvent(const Self&);
void operator=(const Self&); //just hide
};
mitkTimeSlicedGeometryEventMacro(
GeometrySendEvent,TimeSlicedGeometryEvent );
mitkTimeSlicedGeometryEventMacro(
GeometryUpdateEvent, TimeSlicedGeometryEvent );
mitkTimeSlicedGeometryEventMacro(
GeometryTimeEvent, TimeSlicedGeometryEvent );
mitkTimeSlicedGeometryEventMacro(
GeometrySliceEvent, TimeSlicedGeometryEvent );
template <typename T>
void ConnectGeometrySendEvent(T* receiver)
{
typedef typename itk::ReceptorMemberCommand<T>::Pointer
ReceptorMemberCommandPointer;
ReceptorMemberCommandPointer eventReceptorCommand =
itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometry);
unsigned long tag = AddObserver(GeometrySendEvent(NULL,0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
}
template <typename T>
void ConnectGeometryUpdateEvent(T* receiver)
{
typedef typename itk::ReceptorMemberCommand<T>::Pointer
ReceptorMemberCommandPointer;
ReceptorMemberCommandPointer eventReceptorCommand =
itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::UpdateGeometry);
unsigned long tag = AddObserver(GeometryUpdateEvent(NULL,0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
}
template <typename T>
void ConnectGeometrySliceEvent(T* receiver, bool connectSendEvent=true)
{
typedef typename itk::ReceptorMemberCommand<T>::Pointer
ReceptorMemberCommandPointer;
ReceptorMemberCommandPointer eventReceptorCommand =
itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometrySlice);
unsigned long tag = AddObserver(GeometrySliceEvent(NULL,0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
if(connectSendEvent)
ConnectGeometrySendEvent(receiver);
}
template <typename T>
void ConnectGeometryTimeEvent(T* receiver, bool connectSendEvent=true)
{
typedef typename itk::ReceptorMemberCommand<T>::Pointer
ReceptorMemberCommandPointer;
ReceptorMemberCommandPointer eventReceptorCommand =
itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometryTime);
unsigned long tag = AddObserver(GeometryTimeEvent(NULL,0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
if(connectSendEvent)
ConnectGeometrySendEvent(receiver);
}
template <typename T>
void ConnectGeometryEvents(T* receiver)
{
//connect sendEvent only once
ConnectGeometrySliceEvent(receiver, false);
ConnectGeometryTimeEvent(receiver);
}
// use a templated method to get the right offset when casting to void*
template <typename T>
void Disconnect(T* receiver)
{
ObserverTagsMapType::iterator i = m_ReceiverToObserverTagsMap.find(static_cast<void*>(receiver));
if (i == m_ReceiverToObserverTagsMap.end()) return;
const std::list<unsigned long>& tags = i->second;
for (std::list<unsigned long>::const_iterator tagIter = tags.begin();
tagIter != tags.end(); ++tagIter)
{
RemoveObserver(*tagIter);
}
m_ReceiverToObserverTagsMap.erase(i);
}
Message<> crosshairPositionEvent;
/**
* \brief To connect multiple SliceNavigationController, we can
* act as an observer ourselves: implemented interface
* \warning not implemented
*/
virtual void SetGeometry(const itk::EventObject & geometrySliceEvent);
/**
* \brief To connect multiple SliceNavigationController, we can
* act as an observer ourselves: implemented interface
*/
virtual void SetGeometrySlice(const itk::EventObject & geometrySliceEvent);
/**
* \brief To connect multiple SliceNavigationController, we can
* act as an observer ourselves: implemented interface
*/
virtual void SetGeometryTime(const itk::EventObject & geometryTimeEvent);
/** \brief Positions the SNC according to the specified point */
void SelectSliceByPoint( const mitk::Point3D &point );
/** \brief Returns the TimeSlicedGeometry created by the SNC. */
const mitk::TimeSlicedGeometry *GetCreatedWorldGeometry();
/** \brief Returns the Geometry3D of the currently selected time step. */
const mitk::Geometry3D *GetCurrentGeometry3D();
/** \brief Returns the currently selected Plane in the current
* Geometry3D (if existent).
*/
const mitk::PlaneGeometry *GetCurrentPlaneGeometry();
/** \brief Sets the BaseRenderer associated with this SNC (if any). While
* the BaseRenderer is not directly used by SNC, this is a convenience
* method to enable BaseRenderer access via the SNC. */
void SetRenderer( BaseRenderer *renderer );
/** \brief Gets the BaseRenderer associated with this SNC (if any). While
* the BaseRenderer is not directly used by SNC, this is a convenience
* method to enable BaseRenderer access via the SNC. Returns NULL if no
* BaseRenderer has been specified*/
BaseRenderer *GetRenderer() const;
/** \brief Re-orients the slice stack. All slices will be oriented to the given normal vector.
The given point (world coordinates) defines the selected slice.
Careful: The resulting axis vectors are not clearly defined this way. If you want to define them clearly, use
ReorientSlices (const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1).
*/
void ReorientSlices(
const mitk::Point3D &point, const mitk::Vector3D &normal );
/** \brief Re-orients the slice stack so that all planes are oriented according to the
* given axis vectors. The given Point eventually defines selected slice.
*/
void ReorientSlices(
const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1 );
virtual bool ExecuteAction(
Action* action, mitk::StateEvent const* stateEvent);
void ExecuteOperation(Operation* operation);
/**
* \brief Feature option to lock planes during mouse interaction.
* This option flag disables the mouse event which causes the center
* cross to move near by.
*/
itkSetMacro(SliceLocked, bool);
itkGetMacro(SliceLocked, bool);
itkBooleanMacro(SliceLocked);
/**
* \brief Feature option to lock slice rotation.
*
* This option flag disables separately the rotation of a slice which is
* implemented in mitkSliceRotator.
*/
itkSetMacro(SliceRotationLocked, bool);
itkGetMacro(SliceRotationLocked, bool);
itkBooleanMacro(SliceRotationLocked);
/**
* \brief Adjusts the numerical range of the slice stepper according to
* the current geometry orientation of this SNC's SlicedGeometry.
*/
void AdjustSliceStepperRange();
protected:
SliceNavigationController(const char * type = NULL);
virtual ~SliceNavigationController();
+
+ mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes,mitk::Point3D worldposition);
/*
template <class T>
static void buildstring( mitkIpPicDescriptor *pic, itk::Point<int, 3> p, std::string &s, T = 0)
{
std::string value;
std::stringstream stream;
stream.imbue(std::locale::classic());
stream<<s<<"; Pixelvalue: ";
if ( (p[0]>=0 && p[1] >=0 && p[2]>=0) && (unsigned int)p[0] < pic->n[0] && (unsigned int)p[1] < pic->n[1] && (unsigned int)p[2] < pic->n[2] )
{
if(pic->bpe!=24)
{
stream<<(((T*) pic->data)[ p[0] + p[1]*pic->n[0] + p[2]*pic->n[0]*pic->n[1] ]);
}
else
{
stream<<(((T*) pic->data)[p[0]*3 + 0 + p[1]*pic->n[0]*3 + p[2]*pic->n[0]*pic->n[1]*3 ]);
stream<<(((T*) pic->data)[p[0]*3 + 1 + p[1]*pic->n[0]*3 + p[2]*pic->n[0]*pic->n[1]*3 ]);
stream<<(((T*) pic->data)[p[0]*3 + 2 + p[1]*pic->n[0]*3 + p[2]*pic->n[0]*pic->n[1]*3 ]);
}
s = stream.str();
}
else
{
s+= "point out of data";
}
};
*/
mitk::Geometry3D::ConstPointer m_InputWorldGeometry;
mitk::Geometry3D::Pointer m_ExtendedInputWorldGeometry;
mitk::TimeSlicedGeometry::Pointer m_CreatedWorldGeometry;
ViewDirection m_ViewDirection;
ViewDirection m_DefaultViewDirection;
mitk::RenderingManager::Pointer m_RenderingManager;
mitk::BaseRenderer *m_Renderer;
itkSetMacro(Top, bool);
itkGetMacro(Top, bool);
itkBooleanMacro(Top);
itkSetMacro(FrontSide, bool);
itkGetMacro(FrontSide, bool);
itkBooleanMacro(FrontSide);
itkSetMacro(Rotated, bool);
itkGetMacro(Rotated, bool);
itkBooleanMacro(Rotated);
bool m_Top;
bool m_FrontSide;
bool m_Rotated;
bool m_BlockUpdate;
bool m_SliceLocked;
bool m_SliceRotationLocked;
unsigned int m_OldPos;
typedef std::map<void*, std::list<unsigned long> > ObserverTagsMapType;
ObserverTagsMapType m_ReceiverToObserverTagsMap;
};
} // namespace mitk
#endif /* SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F */
diff --git a/Core/Code/DataManagement/itkVtkAbstractTransform.h b/Core/Code/DataManagement/itkVtkAbstractTransform.h
index b58f14cce4..15511cac8c 100644
--- a/Core/Code/DataManagement/itkVtkAbstractTransform.h
+++ b/Core/Code/DataManagement/itkVtkAbstractTransform.h
@@ -1,94 +1,104 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKVTKABSTRACTTRANSFORM_H_HEADER_INCLUDED_C1C68A2C
#define MITKVTKABSTRACTTRANSFORM_H_HEADER_INCLUDED_C1C68A2C
#include <MitkExports.h>
#include "itkTransform.h"
class vtkAbstractTransform;
namespace itk {
//##Documentation
//## @brief Adapter from vtkAbstractTransform to itk::Transform<TScalarType, 3, 3>
//## @ingroup Geometry
template <class TScalarType>
class VtkAbstractTransform : public itk::Transform<TScalarType, 3, 3>
{
public:
typedef VtkAbstractTransform Self;
typedef Transform< TScalarType, 3, 3 > Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef typename Superclass::OutputPointType OutputPointType;
typedef typename Superclass::OutputVectorType OutputVectorType;
typedef typename Superclass::OutputVnlVectorType OutputVnlVectorType;
typedef typename Superclass::OutputCovariantVectorType OutputCovariantVectorType;
typedef typename Superclass::InputPointType InputPointType;
typedef typename Superclass::InputVectorType InputVectorType;
typedef typename Superclass::InputVnlVectorType InputVnlVectorType;
typedef typename Superclass::InputCovariantVectorType InputCovariantVectorType;
+ typedef typename Superclass::ParametersType ParametersType;
+ typedef typename Superclass::JacobianType JacobianType;
itkNewMacro(Self);
//##Documentation
//## @brief Get the vtkAbstractTransform (stored in m_VtkAbstractTransform)
virtual vtkAbstractTransform* GetVtkAbstractTransform() const;
//##Documentation
//## @brief Get the inverse vtkAbstractTransform (stored in m_InverseVtkAbstractTransform)
virtual vtkAbstractTransform* GetInverseVtkAbstractTransform() const;
//##Documentation
//## @brief Set the vtkAbstractTransform (stored in m_VtkAbstractTransform)
virtual void SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform);
+ using Superclass::TransformVector;
+ using Superclass::TransformCovariantVector;
+
virtual OutputPointType TransformPoint(const InputPointType & ) const;
- virtual OutputVectorType TransformVector(const InputVectorType &) const;
+ virtual OutputVectorType TransformVector(const InputVectorType &) const;
virtual OutputVnlVectorType TransformVector(const InputVnlVectorType &) const;
virtual OutputCovariantVectorType TransformCovariantVector(const InputCovariantVectorType &) const;
- virtual InputPointType BackTransform(const OutputPointType &point ) const;
- virtual InputVectorType BackTransform(const OutputVectorType &vector) const;
+ virtual InputPointType BackTransform(const OutputPointType &point ) const;
+ virtual InputVectorType BackTransform(const OutputVectorType &vector) const;
virtual InputVnlVectorType BackTransform(const OutputVnlVectorType &vector) const;
virtual InputCovariantVectorType BackTransform(const OutputCovariantVectorType &vector) const;
+ virtual void SetParameters(const ParametersType&);
+ virtual void SetFixedParameters(const ParametersType&);
+ virtual void ComputeJacobianWithRespectToParameters(const InputPointType&, JacobianType&) const;
+ virtual void ComputeJacobianWithRespectToPosition(const InputPointType&, JacobianType&) const;
+
virtual unsigned long GetMTime() const;
protected:
VtkAbstractTransform();
virtual ~VtkAbstractTransform();
//##Documentation
//## @brief Instance of the vtkAbstractTransform
vtkAbstractTransform* m_VtkAbstractTransform;
//##Documentation
//## @brief Instance of the vtkAbstractTransform
vtkAbstractTransform* m_InverseVtkAbstractTransform;
mutable unsigned long m_LastVtkAbstractTransformTimeStamp;
};
} // namespace itk
#ifndef MITK_MANUAL_INSTANTIATION
#include "itkVtkAbstractTransform.txx"
#endif
#endif /* MITKVTKABSTRACTTRANSFORM_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Core/Code/DataManagement/itkVtkAbstractTransform.txx b/Core/Code/DataManagement/itkVtkAbstractTransform.txx
index 15d4926011..9c377717b0 100644
--- a/Core/Code/DataManagement/itkVtkAbstractTransform.txx
+++ b/Core/Code/DataManagement/itkVtkAbstractTransform.txx
@@ -1,227 +1,250 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "itkVtkAbstractTransform.h"
#include <vtkAbstractTransform.h>
#include <mitkVector.h>
namespace itk {
template <class TScalarType>
itk::VtkAbstractTransform<TScalarType>::VtkAbstractTransform() :
- Superclass(3, 0),
m_VtkAbstractTransform(NULL), m_InverseVtkAbstractTransform(NULL),
m_LastVtkAbstractTransformTimeStamp(0)
{
}
template <class TScalarType>
itk::VtkAbstractTransform<TScalarType>::~VtkAbstractTransform()
{
if(m_VtkAbstractTransform!=NULL)
m_VtkAbstractTransform->UnRegister(NULL);
}
template <class TScalarType>
vtkAbstractTransform* itk::VtkAbstractTransform<TScalarType>::GetVtkAbstractTransform() const
{
return m_VtkAbstractTransform;
}
template <class TScalarType>
vtkAbstractTransform* itk::VtkAbstractTransform<TScalarType>::GetInverseVtkAbstractTransform() const
{
return m_InverseVtkAbstractTransform;
}
template <class TScalarType>
void itk::VtkAbstractTransform<TScalarType>::SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform)
{
if(m_VtkAbstractTransform==aVtkAbstractTransform)
return;
if(m_VtkAbstractTransform!=NULL)
m_VtkAbstractTransform->UnRegister(NULL);
m_VtkAbstractTransform=aVtkAbstractTransform;
if(m_VtkAbstractTransform!=NULL)
{
m_VtkAbstractTransform->Register(NULL);
m_InverseVtkAbstractTransform=m_VtkAbstractTransform->GetInverse(); // memory managed by m_VtkAbstractTransform
}
m_LastVtkAbstractTransformTimeStamp = m_VtkAbstractTransform->GetMTime();
this->Modified();
}
// Transform a point
template<class TScalarType>
typename itk::VtkAbstractTransform<TScalarType>::OutputPointType
itk::VtkAbstractTransform<TScalarType>::
TransformPoint(const InputPointType &point) const
{
assert(m_VtkAbstractTransform!=NULL);
OutputPointType outputpoint;
vnl_vector<TScalarType> vnl_vec;
float vtkpt[3];
mitk::itk2vtk(point, vtkpt);
m_VtkAbstractTransform->TransformPoint(vtkpt, vtkpt);
mitk::vtk2itk(vtkpt, outputpoint);
return outputpoint;
}
// Transform a vector
template<class TScalarType>
typename itk::VtkAbstractTransform<TScalarType>::OutputVectorType
itk::VtkAbstractTransform<TScalarType>::
TransformVector(const InputVectorType &vect) const
{
assert(m_VtkAbstractTransform!=NULL);
OutputVectorType outputvector;
vnl_vector<TScalarType> vnl_vec;
float vtkpt[3]={0,0,0};
float vtkvec[3];
- mitk::vnl2vtk<TScalarType, float>(vect.Get_vnl_vector(), vtkvec);
+ mitk::vnl2vtk<TScalarType, float>(vect.GetVnlVector(), vtkvec);
m_VtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
mitk::vtk2itk(vtkvec, outputvector);
return outputvector;
}
// Transform a vnl_vector_fixed
template<class TScalarType>
typename itk::VtkAbstractTransform<TScalarType>::OutputVnlVectorType
itk::VtkAbstractTransform<TScalarType>::
TransformVector(const InputVnlVectorType &vect) const
{
assert(m_VtkAbstractTransform!=NULL);
OutputVnlVectorType outputvector;
float vtkpt[3]={0,0,0};
float vtkvec[3];
mitk::vnl2vtk<TScalarType, float>(vect, vtkvec);
m_VtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
mitk::vtk2itk(vtkvec, outputvector);
return outputvector;
}
// Transform a CovariantVector
template<class TScalarType>
typename itk::VtkAbstractTransform<TScalarType>::OutputCovariantVectorType
itk::VtkAbstractTransform<TScalarType>::
TransformCovariantVector(const InputCovariantVectorType &/*vec*/) const
{
itkExceptionMacro( << "implement before using!" );
OutputCovariantVectorType result; // Converted vector
// for (unsigned int i = 0; i < NDimensions; i++)
// {
// result[i] = NumericTraits<ScalarType>::Zero;
// for (unsigned int j = 0; j < NDimensions; j++)
// {
// result[i] += m_Inverse[j][i]*vec[j]; // Inverse transposed
// }
// }
return result;
}
// Back transform a point
template<class TScalarType>
typename VtkAbstractTransform<TScalarType>::InputPointType
itk::VtkAbstractTransform<TScalarType>::
BackTransform(const OutputPointType &point) const
{
assert(m_VtkAbstractTransform!=NULL);
OutputPointType outputpoint;
float vtkpt[3];
mitk::itk2vtk(point, vtkpt);
m_InverseVtkAbstractTransform->TransformPoint(vtkpt, vtkpt);
mitk::vtk2itk(vtkpt, outputpoint);
return outputpoint;
}
// Back transform a vector
template<class TScalarType>
typename VtkAbstractTransform<TScalarType>::InputVectorType
itk::VtkAbstractTransform<TScalarType>::
BackTransform(const OutputVectorType &vect ) const
{
assert(m_VtkAbstractTransform!=NULL);
OutputVectorType outputvector;
float vtkpt[3]={0,0,0};
float vtkvec[3];
mitk::itk2vtk(vect, vtkvec);
m_InverseVtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
mitk::vtk2itk(vtkvec, outputvector);
return outputvector;
}
// Back transform a vnl_vector
template<class TScalarType>
typename VtkAbstractTransform<TScalarType>::InputVnlVectorType
itk::VtkAbstractTransform<TScalarType>::
BackTransform(const OutputVnlVectorType &vect ) const
{
assert(m_InverseVtkAbstractTransform!=NULL);
OutputVnlVectorType outputvector;
float vtkpt[3]={0,0,0};
float vtkvec[3];
mitk::itk2vtk(vect, vtkvec);
m_InverseVtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
mitk::vtk2itk(vtkvec, outputvector);
return outputvector;
}
// Back Transform a CovariantVector
template<class TScalarType>
typename VtkAbstractTransform<TScalarType>::InputCovariantVectorType
itk::VtkAbstractTransform<TScalarType>::
BackTransform(const OutputCovariantVectorType &vec) const
{
itkExceptionMacro( << "implement before using!" );
// for (unsigned int i = 0; i < NDimensions; i++)
// {
// result[i] = NumericTraits<ScalarType>::Zero;
// for (unsigned int j = 0; j < NDimensions; j++)
// {
// result[i] += m_Matrix[j][i]*vec[j]; // Direct matrix transposed
// }
// }
return vec;
}
template<class TScalarType>
unsigned long
itk::VtkAbstractTransform<TScalarType>::GetMTime() const
{
if((m_VtkAbstractTransform != NULL) && (m_LastVtkAbstractTransformTimeStamp < m_VtkAbstractTransform->GetMTime()))
{
m_LastVtkAbstractTransformTimeStamp=m_VtkAbstractTransform->GetMTime();
this->Modified();
}
return Superclass::GetMTime();
}
+template <class TScalarType>
+void itk::VtkAbstractTransform<TScalarType>::SetParameters(const ParametersType&)
+{
+ // TODO
+}
+
+template <class TScalarType>
+void itk::VtkAbstractTransform<TScalarType>::SetFixedParameters(const ParametersType&)
+{
+ // TODO
+}
+
+template <class TScalarType>
+void itk::VtkAbstractTransform<TScalarType>::ComputeJacobianWithRespectToParameters(const InputPointType&, JacobianType&) const
+{
+ // TODO
+}
+
+template <class TScalarType>
+void itk::VtkAbstractTransform<TScalarType>::ComputeJacobianWithRespectToPosition(const InputPointType&, JacobianType&) const
+{
+ // TODO
+}
+
} // namespace itk
diff --git a/Core/Code/DataManagement/mitkAbstractTransformGeometry.cpp b/Core/Code/DataManagement/mitkAbstractTransformGeometry.cpp
index 65b97a5586..3750473639 100644
--- a/Core/Code/DataManagement/mitkAbstractTransformGeometry.cpp
+++ b/Core/Code/DataManagement/mitkAbstractTransformGeometry.cpp
@@ -1,270 +1,283 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkAbstractTransformGeometry.h"
#include <vtkAbstractTransform.h>
mitk::AbstractTransformGeometry::AbstractTransformGeometry() : m_Plane(NULL), m_FrameGeometry(NULL)
{
Initialize();
}
mitk::AbstractTransformGeometry::AbstractTransformGeometry(const AbstractTransformGeometry& other) : Superclass(other)
{
if(other.m_ParametricBoundingBox.IsNotNull())
{
this->SetParametricBounds(m_ParametricBoundingBox->GetBounds());
}
this->SetPlane(other.m_Plane);
this->SetFrameGeometry(other.m_FrameGeometry);
}
mitk::AbstractTransformGeometry::~AbstractTransformGeometry()
{
}
void mitk::AbstractTransformGeometry::Initialize()
{
Superclass::Initialize();
m_ItkVtkAbstractTransform = itk::VtkAbstractTransform<ScalarType>::New();
}
vtkAbstractTransform* mitk::AbstractTransformGeometry::GetVtkAbstractTransform() const
{
return m_ItkVtkAbstractTransform->GetVtkAbstractTransform();
}
mitk::ScalarType mitk::AbstractTransformGeometry::GetParametricExtentInMM(int direction) const
{
if(m_Plane.IsNull())
{
itkExceptionMacro(<<"m_Plane is NULL.");
}
return m_Plane->GetExtentInMM(direction);
}
const mitk::Transform3D* mitk::AbstractTransformGeometry::GetParametricTransform() const
{
return m_ItkVtkAbstractTransform;
}
bool mitk::AbstractTransformGeometry::Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const
{
assert(m_BoundingBox.IsNotNull());
mitk::Point2D pt2d_mm;
bool isInside;
isInside = Map(pt3d_mm, pt2d_mm);
Map(pt2d_mm, projectedPt3d_mm);
return isInside;
//Point3D pt3d_units;
//pt3d_units = m_ItkVtkAbstractTransform->BackTransform(pt3d_mm);
//pt3d_units[2] = 0;
//projectedPt3d_mm = m_ItkVtkAbstractTransform->TransformPoint(pt3d_units);
//return const_cast<BoundingBox*>(m_BoundingBox.GetPointer())->IsInside(pt3d_units);
}
bool mitk::AbstractTransformGeometry::Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const
{
assert((m_ItkVtkAbstractTransform.IsNotNull()) && (m_Plane.IsNotNull()));
Point3D pt3d_units;
pt3d_units = m_ItkVtkAbstractTransform->BackTransform(pt3d_mm);
return m_Plane->Map(pt3d_units, pt2d_mm);
}
void mitk::AbstractTransformGeometry::Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const
{
assert((m_ItkVtkAbstractTransform.IsNotNull()) && (m_Plane.IsNotNull()));
m_Plane->Map(pt2d_mm, pt3d_mm);
pt3d_mm = m_ItkVtkAbstractTransform->TransformPoint(pt3d_mm);
}
bool mitk::AbstractTransformGeometry::Project(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const
{
itkExceptionMacro("not implemented yet - replace GetIndexToWorldTransform by m_ItkVtkAbstractTransform->GetInverseVtkAbstractTransform()");
assert(m_BoundingBox.IsNotNull());
Vector3D vec3d_units;
- vec3d_units = GetIndexToWorldTransform()->BackTransform(vec3d_mm);
+ vec3d_units = GetIndexToWorldTransform()->GetInverseMatrix() * vec3d_mm;
vec3d_units[2] = 0;
projectedVec3d_mm = GetIndexToWorldTransform()->TransformVector(vec3d_units);
Point3D pt3d_units;
- pt3d_units = GetIndexToWorldTransform()->BackTransformPoint(atPt3d_mm);
+ mitk::ScalarType temp[3];
+ unsigned int i, j;
+
+ for (j = 0; j < 3; ++j)
+ temp[j] = atPt3d_mm[j] - GetIndexToWorldTransform()->GetOffset()[j];
+
+ for (i = 0; i < 3; ++i)
+ {
+ pt3d_units[i] = 0.0;
+
+ for (j = 0; j < 3; ++j)
+ pt3d_units[i] += GetIndexToWorldTransform()->GetInverseMatrix()[i][j] * temp[j];
+ }
+
return const_cast<BoundingBox*>(m_BoundingBox.GetPointer())->IsInside(pt3d_units);
}
bool mitk::AbstractTransformGeometry::Project(const mitk::Vector3D &/*vec3d_mm*/, mitk::Vector3D &/*projectedVec3d_mm*/) const
{
MITK_WARN << "Need additional point! No standard value defined. Please use Project(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm). Unfortunatley this one is not implemented at the moment. Sorry :(";
itkExceptionMacro("not implemented yet - replace GetIndexToWorldTransform by m_ItkVtkAbstractTransform->GetInverseVtkAbstractTransform()");
return false;
}
bool mitk::AbstractTransformGeometry::Map(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const
{
assert((m_ItkVtkAbstractTransform.IsNotNull()) && (m_Plane.IsNotNull()));
float vtkpt[3], vtkvec[3];
itk2vtk(atPt3d_mm, vtkpt);
itk2vtk(vec3d_mm, vtkvec);
m_ItkVtkAbstractTransform->GetInverseVtkAbstractTransform()->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
mitk::Vector3D vec3d_units;
vtk2itk(vtkvec, vec3d_units);
return m_Plane->Map(atPt3d_mm, vec3d_units, vec2d_mm);
}
void mitk::AbstractTransformGeometry::Map(const mitk::Point2D & atPt2d_mm, const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const
{
m_Plane->Map(atPt2d_mm, vec2d_mm, vec3d_mm);
Point3D atPt3d_mm;
Map(atPt2d_mm, atPt3d_mm);
float vtkpt[3], vtkvec[3];
itk2vtk(atPt3d_mm, vtkpt);
itk2vtk(vec3d_mm, vtkvec);
m_ItkVtkAbstractTransform->GetVtkAbstractTransform()->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
vtk2itk(vtkvec, vec3d_mm);
}
void mitk::AbstractTransformGeometry::IndexToWorld(const mitk::Point2D &pt_units, mitk::Point2D &pt_mm) const
{
m_Plane->IndexToWorld(pt_units, pt_mm);
}
void mitk::AbstractTransformGeometry::WorldToIndex(const mitk::Point2D &pt_mm, mitk::Point2D &pt_units) const
{
m_Plane->WorldToIndex(pt_mm, pt_units);
}
void mitk::AbstractTransformGeometry::IndexToWorld(const mitk::Point2D & /*atPt2d_units*/, const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const
{
MITK_WARN<<"Warning! Call of the deprecated function AbstractTransformGeometry::IndexToWorld(point, vec, vec). Use AbstractTransformGeometry::IndexToWorld(vec, vec) instead!";
this->IndexToWorld(vec_units, vec_mm);
}
void mitk::AbstractTransformGeometry::IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const
{
m_Plane->IndexToWorld(vec_units, vec_mm);
}
void mitk::AbstractTransformGeometry::WorldToIndex(const mitk::Point2D & /*atPt2d_mm*/, const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const
{
MITK_WARN<<"Warning! Call of the deprecated function AbstractTransformGeometry::WorldToIndex(point, vec, vec). Use AbstractTransformGeometry::WorldToIndex(vec, vec) instead!";
this->WorldToIndex(vec_mm, vec_units);
}
void mitk::AbstractTransformGeometry::WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const
{
m_Plane->WorldToIndex(vec_mm, vec_units);
}
bool mitk::AbstractTransformGeometry::IsAbove(const mitk::Point3D& pt3d_mm) const
{
assert((m_ItkVtkAbstractTransform.IsNotNull()) && (m_Plane.IsNotNull()));
Point3D pt3d_ParametricWorld;
pt3d_ParametricWorld = m_ItkVtkAbstractTransform->BackTransform(pt3d_mm);
Point3D pt3d_ParametricUnits;
((Geometry3D*)m_Plane)->WorldToIndex(pt3d_ParametricWorld, pt3d_ParametricUnits);
return (pt3d_ParametricUnits[2] > m_ParametricBoundingBox->GetBounds()[4]);
}
void mitk::AbstractTransformGeometry::SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform)
{
m_ItkVtkAbstractTransform->SetVtkAbstractTransform(aVtkAbstractTransform);
}
void mitk::AbstractTransformGeometry::SetPlane(const mitk::PlaneGeometry* aPlane)
{
if(aPlane!=NULL)
{
m_Plane = static_cast<mitk::PlaneGeometry*>(aPlane->Clone().GetPointer());
BoundingBox::BoundsArrayType b=m_Plane->GetBoundingBox()->GetBounds();
SetParametricBounds(b);
CalculateFrameGeometry();
}
else
{
if(m_Plane.IsNull())
return;
m_Plane=NULL;
}
Modified();
}
void mitk::AbstractTransformGeometry::CalculateFrameGeometry()
{
if((m_Plane.IsNull()) || (m_FrameGeometry.IsNotNull()))
return;
//@warning affine-transforms and bounding-box should be set by specific sub-classes!
SetBounds(m_Plane->GetBoundingBox()->GetBounds());
}
void mitk::AbstractTransformGeometry::SetFrameGeometry(const mitk::Geometry3D* frameGeometry)
{
if((frameGeometry != NULL) && (frameGeometry->IsValid()))
{
m_FrameGeometry = static_cast<mitk::Geometry3D*>(frameGeometry->Clone().GetPointer());
SetIndexToWorldTransform(m_FrameGeometry->GetIndexToWorldTransform());
SetBounds(m_FrameGeometry->GetBounds());
}
else
{
m_FrameGeometry = NULL;
}
}
unsigned long mitk::AbstractTransformGeometry::GetMTime() const
{
if(Superclass::GetMTime()<m_ItkVtkAbstractTransform->GetMTime())
return m_ItkVtkAbstractTransform->GetMTime();
return Superclass::GetMTime();
}
void mitk::AbstractTransformGeometry::SetOversampling(float oversampling)
{
if(m_Plane.IsNull())
{
itkExceptionMacro(<< "m_Plane is not set.");
}
mitk::BoundingBox::BoundsArrayType bounds = m_Plane->GetBounds();
bounds[1]*=oversampling; bounds[3]*=oversampling; bounds[5]*=oversampling;
SetParametricBounds(bounds);
}
-mitk::AffineGeometryFrame3D::Pointer mitk::AbstractTransformGeometry::Clone() const
+itk::LightObject::Pointer mitk::AbstractTransformGeometry::InternalClone() const
{
Self::Pointer newGeometry = new AbstractTransformGeometry(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
diff --git a/Core/Code/DataManagement/mitkAbstractTransformGeometry.h b/Core/Code/DataManagement/mitkAbstractTransformGeometry.h
index 41c8b9cf9d..861a0bcd35 100644
--- a/Core/Code/DataManagement/mitkAbstractTransformGeometry.h
+++ b/Core/Code/DataManagement/mitkAbstractTransformGeometry.h
@@ -1,192 +1,192 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKVTKABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define MITKVTKABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#include <MitkExports.h>
#include "mitkGeometry2D.h"
#include "mitkPlaneGeometry.h"
#include "itkVtkAbstractTransform.h"
class vtkAbstractTransform;
namespace mitk {
//##Documentation
//## @brief Describes a geometry defined by an vtkAbstractTransform and a plane
//##
//## vtkAbstractTransform is the most general transform in vtk (superclass for
//## all vtk geometric transformations). It defines an arbitrary 3D transformation,
//## i.e., a transformation of 3D space into 3D space. In contrast,
//## AbstractTransformGeometry (since it is a subclass of Geometry2D) describes a
//## 2D manifold in 3D space. The 2D manifold is defined as the manifold that results
//## from transforming a rectangle (given in m_Plane as a PlaneGeometry) by the
//## vtkAbstractTransform (given in m_VtkAbstractTransform).
//## The PlaneGeometry m_Plane is used to define the parameter space. 2D coordinates are
//## first mapped by the PlaneGeometry and the resulting 3D coordinates are put into
//## the vtkAbstractTransform.
//## @note This class is the superclass of concrete geometries. Since there is no
//## write access to the vtkAbstractTransform and m_Plane, this class is somehow
//## abstract. For full write access from extern, use ExternAbstractTransformGeometry.
//## @note The bounds of the PlaneGeometry are used as the parametric bounds.
//## @sa ExternAbstractTransformGeometry
//## @ingroup Geometry
class MITK_CORE_EXPORT AbstractTransformGeometry : public Geometry2D
{
public:
mitkClassMacro(AbstractTransformGeometry, Geometry2D);
itkNewMacro(Self);
//##Documentation
//## @brief Get the vtkAbstractTransform (stored in m_VtkAbstractTransform)
virtual vtkAbstractTransform* GetVtkAbstractTransform() const;
virtual unsigned long GetMTime() const;
//##Documentation
//## @brief Get the rectangular area that is used for transformation by
//## m_VtkAbstractTransform and therewith defines the 2D manifold described by
//## AbstractTransformGeometry
itkGetConstObjectMacro(Plane, PlaneGeometry);
/**
* \brief projects the given point onto the curved plane
*/
virtual bool Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const;
/**
* \brief projects a given vector starting from given point onto the curved plane
* \warning no satisfiyng implementation existing yet
*/
virtual bool Project(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
/**
* \brief projects a given vector starting from standard point onto the curved plane
* \warning no satisfying implementation existing yet
*/
virtual bool Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const;
virtual void Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const;
virtual bool Map(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const;
virtual void Map(const mitk::Point2D & atPt2d_mm, const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const;
virtual void IndexToWorld(const mitk::Point2D &pt_units, mitk::Point2D &pt_mm) const;
virtual void WorldToIndex(const mitk::Point2D &pt_mm, mitk::Point2D &pt_units) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## @deprecated First parameter (Point2D) is not used. If possible, please use void IndexToWorld(const mitk::Vector2D& vec_units, mitk::Vector2D& vec_mm) const.
//## For further information about coordinates types, please see the Geometry documentation
virtual void IndexToWorld(const mitk::Point2D &atPt2d_units, const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## For further information about coordinates types, please see the Geometry documentation
virtual void IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## @deprecated First parameter (Point2D) is not used. If possible, please use void WorldToIndex(const mitk::Vector2D& vec_mm, mitk::Vector2D& vec_units) const.
//## For further information about coordinates types, please see the Geometry documentation
virtual void WorldToIndex(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## For further information about coordinates types, please see the Geometry documentation
virtual void WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
virtual bool IsAbove(const Point3D& pt3d_mm) const;
virtual mitk::ScalarType GetParametricExtentInMM(int direction) const;
virtual const Transform3D* GetParametricTransform() const;
//##Documentation
//## @brief Change the parametric bounds to @a oversampling times
//## the bounds of m_Plane.
//##
//## The change is done once (immediately). Later changes of the bounds
//## of m_Plane will not influence the parametric bounds. (Consequently,
//## there is no method to get the oversampling.)
virtual void SetOversampling(float oversampling);
virtual void Initialize();
//##Documentation
//## @brief Calculates the standard part of a Geometry3D
//## (IndexToWorldTransform and bounding box) around the
//## curved geometry. Has to be implemented in subclasses.
//##
//## \sa SetFrameGeometry
virtual void CalculateFrameGeometry();
//##Documentation
//## @brief Set the frame geometry which is used as the standard
//## part of an Geometry3D (IndexToWorldTransform and bounding box)
//##
//## Maybe used as a hint within which the interpolation shall occur
//## by concrete sub-classes.
//## \sa CalculateFrameGeometry
virtual void SetFrameGeometry(const mitk::Geometry3D* frameGeometry);
- virtual AffineGeometryFrame3D::Pointer Clone() const;
+ virtual itk::LightObject::Pointer InternalClone() const;
protected:
AbstractTransformGeometry();
AbstractTransformGeometry(const AbstractTransformGeometry& other);
virtual ~AbstractTransformGeometry();
//##Documentation
//## @brief Set the vtkAbstractTransform (stored in m_VtkAbstractTransform)
//##
//## Protected in this class, made public in ExternAbstractTransformGeometry.
virtual void SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform);
//##Documentation
//## @brief Set the rectangular area that is used for transformation by
//## m_VtkAbstractTransform and therewith defines the 2D manifold described by
//## ExternAbstractTransformGeometry
//##
//## Protected in this class, made public in ExternAbstractTransformGeometry.
//## @note The bounds of the PlaneGeometry are used as the parametric bounds.
//## @note The PlaneGeometry is cloned, @em not linked/referenced.
virtual void SetPlane(const mitk::PlaneGeometry* aPlane);
//##Documentation
//## @brief The rectangular area that is used for transformation by
//## m_VtkAbstractTransform and therewith defines the 2D manifold described by
//## AbstractTransformGeometry.
mitk::PlaneGeometry::Pointer m_Plane;
itk::VtkAbstractTransform<ScalarType>::Pointer m_ItkVtkAbstractTransform;
mitk::Geometry3D::Pointer m_FrameGeometry;
};
} // namespace mitk
#endif /* MITKVTKABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Core/Code/DataManagement/mitkAnnotationProperty.cpp b/Core/Code/DataManagement/mitkAnnotationProperty.cpp
index 0ce2f6eb60..64e425329e 100644
--- a/Core/Code/DataManagement/mitkAnnotationProperty.cpp
+++ b/Core/Code/DataManagement/mitkAnnotationProperty.cpp
@@ -1,124 +1,118 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkAnnotationProperty.h"
mitk::AnnotationProperty::AnnotationProperty()
{
}
mitk::AnnotationProperty::AnnotationProperty(
const char *label, const Point3D &position )
: m_Label( "" ),
m_Position( position )
{
if ( label != NULL )
{
m_Label = label;
}
}
mitk::AnnotationProperty::AnnotationProperty(
const std::string &label, const Point3D &position )
: m_Label( label ),
m_Position( position )
{
}
mitk::AnnotationProperty::AnnotationProperty(
const char *label, ScalarType x, ScalarType y, ScalarType z )
: m_Label( "" )
{
if ( label != NULL )
{
m_Label = label;
}
m_Position[0] = x;
m_Position[1] = y;
m_Position[2] = z;
}
mitk::AnnotationProperty::AnnotationProperty(
const std::string &label, ScalarType x, ScalarType y, ScalarType z )
: m_Label( label )
{
m_Position[0] = x;
m_Position[1] = y;
m_Position[2] = z;
}
mitk::AnnotationProperty::AnnotationProperty(const mitk::AnnotationProperty& other)
: BaseProperty(other)
, m_Label(other.m_Label)
, m_Position(other.m_Position)
{
}
const mitk::Point3D &mitk::AnnotationProperty::GetPosition() const
{
return m_Position;
}
void mitk::AnnotationProperty::SetPosition( const mitk::Point3D &position )
{
if (m_Position != position)
{
m_Position = position;
this->Modified();
}
}
bool mitk::AnnotationProperty::IsEqual( const BaseProperty &property ) const
{
return ( (this->m_Label == static_cast<const Self&>(property).m_Label )
&& (this->m_Position == static_cast<const Self&>(property).m_Position ) );
}
bool mitk::AnnotationProperty::Assign( const BaseProperty &property )
{
this->m_Label = static_cast<const Self&>(property).m_Label;
this->m_Position = static_cast<const Self&>(property).m_Position;
return true;
}
std::string mitk::AnnotationProperty::GetValueAsString() const
{
std::stringstream myStr;
myStr << this->GetLabel() << this->GetPosition();
return myStr.str();
}
-mitk::AnnotationProperty::Pointer mitk::AnnotationProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::AnnotationProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkAnnotationProperty.h b/Core/Code/DataManagement/mitkAnnotationProperty.h
index 73ecab4daa..518032c10f 100644
--- a/Core/Code/DataManagement/mitkAnnotationProperty.h
+++ b/Core/Code/DataManagement/mitkAnnotationProperty.h
@@ -1,93 +1,91 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKANNOTATIONPROPERTY_H_HEADER_INCLUDED
#define MITKANNOTATIONPROPERTY_H_HEADER_INCLUDED
#include <MitkExports.h>
#include "mitkBaseProperty.h"
#include "mitkVector.h"
#include <itkConfigure.h>
#include <string>
namespace mitk {
/**
* \brief Property for annotations
* \ingroup DataManagement
*/
class MITK_CORE_EXPORT AnnotationProperty : public BaseProperty
{
public:
mitkClassMacro(AnnotationProperty, BaseProperty)
typedef std::string ValueType;
itkNewMacro( AnnotationProperty );
mitkNewMacro2Param( AnnotationProperty,
const char *, const Point3D & );
mitkNewMacro2Param( AnnotationProperty,
const std::string &, const Point3D & );
mitkNewMacro4Param( AnnotationProperty,
const char *, ScalarType, ScalarType, ScalarType );
mitkNewMacro4Param( AnnotationProperty,
const std::string &, ScalarType, ScalarType, ScalarType );
- Pointer Clone() const;
-
itkGetStringMacro( Label );
itkSetStringMacro( Label );
const Point3D &GetPosition() const;
void SetPosition( const Point3D &position );
virtual std::string GetValueAsString() const;
virtual BaseProperty& operator=(const BaseProperty& other) { return Superclass::operator=(other); } \
using BaseProperty::operator =;
protected:
std::string m_Label;
Point3D m_Position;
AnnotationProperty();
AnnotationProperty( const char *label, const Point3D &position );
AnnotationProperty( const std::string &label, const Point3D &position );
AnnotationProperty( const char *label, ScalarType x, ScalarType y, ScalarType z );
AnnotationProperty( const std::string &label, ScalarType x, ScalarType y, ScalarType z );
AnnotationProperty(const AnnotationProperty& other);
private:
// purposely not implemented
AnnotationProperty& operator=(const AnnotationProperty&);
itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty& property) const;
virtual bool Assign(const BaseProperty & property);
};
} // namespace mitk
#endif /* MITKANNOTATIONPROPERTY_H_HEADER_INCLUDED */
diff --git a/Core/Code/DataManagement/mitkBaseData.cpp b/Core/Code/DataManagement/mitkBaseData.cpp
index a3393b30f1..77050f2a9d 100644
--- a/Core/Code/DataManagement/mitkBaseData.cpp
+++ b/Core/Code/DataManagement/mitkBaseData.cpp
@@ -1,362 +1,283 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBaseData.h"
#include <itkObjectFactoryBase.h>
-#define MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
-
mitk::BaseData::BaseData() :
- m_RequestedRegionInitialized(false), m_SmartSourcePointer(NULL),
- m_SourceOutputIndexDuplicate(0), m_Initialized(true),
- m_Unregistering(false), m_CalculatingExternalReferenceCount(false),
- m_ExternalReferenceCount(-1)
+ m_RequestedRegionInitialized(false),
+ m_SourceOutputIndexDuplicate(0), m_Initialized(true)
{
m_TimeSlicedGeometry = TimeSlicedGeometry::New();
m_PropertyList = PropertyList::New();
}
mitk::BaseData::BaseData( const BaseData &other ):
itk::DataObject(), mitk::OperationActor(),
m_RequestedRegionInitialized(other.m_RequestedRegionInitialized),
-m_SmartSourcePointer(other.m_SmartSourcePointer),
m_SourceOutputIndexDuplicate(other.m_SourceOutputIndexDuplicate),
-m_Initialized(other.m_Initialized), m_Unregistering(other.m_Unregistering),
-m_CalculatingExternalReferenceCount(other.m_CalculatingExternalReferenceCount),
-m_ExternalReferenceCount(other.m_ExternalReferenceCount)
+m_Initialized(other.m_Initialized)
{
m_TimeSlicedGeometry = dynamic_cast<mitk::TimeSlicedGeometry*>(other.m_TimeSlicedGeometry->Clone().GetPointer());
m_PropertyList = other.m_PropertyList->Clone();
}
mitk::BaseData::~BaseData()
{
- m_SmartSourcePointer = NULL;
+
}
void mitk::BaseData::InitializeTimeSlicedGeometry(unsigned int timeSteps)
{
mitk::TimeSlicedGeometry::Pointer timeGeometry = this->GetTimeSlicedGeometry();
mitk::Geometry3D::Pointer g3d = mitk::Geometry3D::New();
g3d->Initialize();
if ( timeSteps > 1 )
{
mitk::ScalarType timeBounds[] = {0.0, 1.0};
g3d->SetTimeBounds( timeBounds );
}
// The geometry is propagated automatically to the other items,
// if EvenlyTimed is true...
timeGeometry->InitializeEvenlyTimed( g3d.GetPointer(), timeSteps );
}
void mitk::BaseData::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if(m_TimeSlicedGeometry.IsNotNull())
m_TimeSlicedGeometry->UpdateInformation();
}
const mitk::TimeSlicedGeometry* mitk::BaseData::GetUpdatedTimeSlicedGeometry()
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetTimeSlicedGeometry();
}
void mitk::BaseData::Expand( unsigned int timeSteps )
{
if( m_TimeSlicedGeometry.IsNotNull() )
m_TimeSlicedGeometry->ExpandToNumberOfTimeSteps( timeSteps );
}
const mitk::Geometry3D* mitk::BaseData::GetUpdatedGeometry(int t)
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetGeometry(t);
}
void mitk::BaseData::SetGeometry(Geometry3D* aGeometry3D)
{
if(aGeometry3D!=NULL)
{
TimeSlicedGeometry::Pointer timeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(aGeometry3D);
if ( timeSlicedGeometry.IsNotNull() )
m_TimeSlicedGeometry = timeSlicedGeometry;
else
{
timeSlicedGeometry = TimeSlicedGeometry::New();
m_TimeSlicedGeometry = timeSlicedGeometry;
timeSlicedGeometry->InitializeEvenlyTimed(aGeometry3D, 1);
}
Modified();
}
else if( m_TimeSlicedGeometry.IsNotNull() )
{
m_TimeSlicedGeometry = NULL;
Modified();
}
return;
}
void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D)
{
SetGeometry(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()));
}
void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D, unsigned int time)
{
if (m_TimeSlicedGeometry)
{
m_TimeSlicedGeometry->SetGeometry3D(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()), time);
}
}
bool mitk::BaseData::IsEmptyTimeStep(unsigned int) const
{
return IsInitialized() == false;
}
bool mitk::BaseData::IsEmpty() const
{
if(IsInitialized() == false)
return true;
const TimeSlicedGeometry* timeGeometry = const_cast<BaseData*>(this)->GetUpdatedTimeSlicedGeometry();
if(timeGeometry == NULL)
return true;
unsigned int timeSteps = timeGeometry->GetTimeSteps();
for ( unsigned int t = 0 ; t < timeSteps ; ++t )
{
if(IsEmptyTimeStep(t) == false)
return false;
}
return true;
}
-itk::SmartPointer<mitk::BaseProcess> mitk::BaseData::GetSource() const
-{
- return static_cast<mitk::BaseProcess*>(Superclass::GetSource().GetPointer());
-}
-
-int mitk::BaseData::GetExternalReferenceCount() const
+itk::SmartPointer<mitk::BaseDataSource> mitk::BaseData::GetSource() const
{
- if(m_CalculatingExternalReferenceCount==false) //this is only needed because a smart-pointer to m_Outputs (private!!) must be created by calling GetOutputs.
- {
- m_CalculatingExternalReferenceCount = true;
-
- m_ExternalReferenceCount = -1;
-
- int realReferenceCount = GetReferenceCount();
-
- if(GetSource().IsNull())
- {
- m_ExternalReferenceCount = realReferenceCount;
- m_CalculatingExternalReferenceCount = false;
- return m_ExternalReferenceCount;
- }
-
- mitk::BaseProcess::DataObjectPointerArray outputs = m_SmartSourcePointer->GetOutputs();
-
- unsigned int idx;
- for (idx = 0; idx < outputs.size(); ++idx)
- {
- //references of outputs that are not referenced from someone else (reference additional to the reference from this BaseProcess object) are interpreted as non-existent
- if(outputs[idx]==this)
- --realReferenceCount;
- }
- m_ExternalReferenceCount = realReferenceCount;
- if(m_ExternalReferenceCount<0)
- m_ExternalReferenceCount=0;
- m_CalculatingExternalReferenceCount = false;
- }
- else
- return -1;
- return m_ExternalReferenceCount;
-}
-
-void mitk::BaseData::UnRegister() const
-{
-#ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
- if(GetReferenceCount()>1)
- {
- Superclass::UnRegister();
- if((m_Unregistering==false) && (m_SmartSourcePointer.IsNotNull()))
- {
- m_Unregistering=true;
- // the order of the following boolean statement is important:
- // this->GetSource() returns a SmartPointer,
- // which increases and afterwards decreases the reference count,
- // which may result in an ExternalReferenceCount of 0, causing
- // BaseProcess::UnRegister() to destroy us (also we already
- // about to do that).
- if((this->m_SmartSourcePointer->GetExternalReferenceCount()==0) || (this->GetSource().IsNull()))
- m_SmartSourcePointer=NULL; // now the reference count is zero and this object has been destroyed; thus nothing may be done after this line!!
- else
- m_Unregistering=false;
- }
- }
- else
-#endif
- Superclass::UnRegister(); // now the reference count is zero and this object has been destroyed; thus nothing may be done after this line!!
-}
-
-void mitk::BaseData::ConnectSource(itk::ProcessObject *arg, unsigned int idx) const
-{
-#ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
- itkDebugMacro( "connecting source " << arg
- << ", source output index " << idx);
-
- if ( GetSource().GetPointer() != arg || m_SourceOutputIndexDuplicate != idx)
- {
- m_SmartSourcePointer = dynamic_cast<mitk::BaseProcess*>(arg);
- m_SourceOutputIndexDuplicate = idx;
- Modified();
- }
-#endif
+ return static_cast<mitk::BaseDataSource*>(Superclass::GetSource().GetPointer());
}
mitk::PropertyList::Pointer mitk::BaseData::GetPropertyList() const
{
return m_PropertyList;
}
mitk::BaseProperty::Pointer mitk::BaseData::GetProperty(const char *propertyKey) const
{
return m_PropertyList->GetProperty(propertyKey);
}
void mitk::BaseData::SetProperty(const char *propertyKey,
BaseProperty* propertyValue)
{
m_PropertyList->SetProperty(propertyKey, propertyValue);
}
void mitk::BaseData::SetPropertyList(PropertyList *pList)
{
m_PropertyList = pList;
}
void mitk::BaseData::SetOrigin(const mitk::Point3D& origin)
{
mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
assert(timeSlicedGeometry!=NULL);
mitk::Geometry3D* geometry;
unsigned int steps = timeSlicedGeometry->GetTimeSteps();
for(unsigned int timestep = 0; timestep < steps; ++timestep)
{
geometry = GetGeometry(timestep);
if(geometry != NULL)
{
geometry->SetOrigin(origin);
}
if(GetTimeSlicedGeometry()->GetEvenlyTimed())
{
GetTimeSlicedGeometry()->InitializeEvenlyTimed(geometry, steps);
break;
}
}
}
unsigned long mitk::BaseData::GetMTime() const
{
unsigned long time = Superclass::GetMTime();
if(m_TimeSlicedGeometry.IsNotNull())
{
if((time < m_TimeSlicedGeometry->GetMTime()))
{
Modified();
return Superclass::GetMTime();
}
//unsigned long geometryTime = m_TimeSlicedGeometry->GetMTime();
//if(time < geometryTime)
//{
// return geometryTime;
//}
}
return time;
}
+void mitk::BaseData::Graft(const itk::DataObject*)
+{
+ itkExceptionMacro(<< "Graft not implemented for mitk::BaseData subclass " << this->GetNameOfClass())
+}
+
void mitk::BaseData::CopyInformation( const itk::DataObject* data )
{
const Self* bd = dynamic_cast<const Self*>(data);
if (bd != NULL)
{
m_TimeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(bd->GetTimeSlicedGeometry()->Clone().GetPointer());
m_PropertyList = bd->GetPropertyList()->Clone();
}
else
{
// pointer could not be cast back down; this can be the case if your filters input
// and output objects differ in type; then you have to write your own GenerateOutputInformation method
itkExceptionMacro(<< "mitk::BaseData::CopyInformation() cannot cast "
<< typeid(data).name() << " to "
<< typeid(Self*).name() );
}
}
bool mitk::BaseData::IsInitialized() const
{
return m_Initialized;
}
void mitk::BaseData::Clear()
{
this->ClearData();
this->InitializeEmpty();
}
void mitk::BaseData::ClearData()
{
if(m_Initialized)
{
ReleaseData();
m_Initialized = false;
}
}
void mitk::BaseData::ExecuteOperation(mitk::Operation* /*operation*/)
{
//empty by default. override if needed!
}
void mitk::BaseData::PrintSelf(std::ostream& os, itk::Indent indent) const
{
os << std::endl;
os << indent << " TimeSlicedGeometry: ";
if(GetTimeSlicedGeometry() == NULL)
os << "NULL" << std::endl;
else
GetTimeSlicedGeometry()->Print(os, indent);
}
diff --git a/Core/Code/DataManagement/mitkBaseData.h b/Core/Code/DataManagement/mitkBaseData.h
index 73ff102752..6b67252301 100644
--- a/Core/Code/DataManagement/mitkBaseData.h
+++ b/Core/Code/DataManagement/mitkBaseData.h
@@ -1,388 +1,367 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
#define BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
#include <itkDataObject.h>
#include "mitkBaseProcess.h"
#include "mitkTimeSlicedGeometry.h"
#include <MitkExports.h>
#include "mitkOperationActor.h"
#include "mitkPropertyList.h"
namespace mitk {
//class BaseProcess;
//##Documentation
//## @brief Base of all data objects
//##
//## Base of all data objects, e.g., images, contours, surfaces etc. Inherits
//## from itk::DataObject and thus can be included in a pipeline.
//## Inherits also from OperationActor and can be used as a destination for Undo
//## @ingroup Data
class MITK_CORE_EXPORT BaseData : public itk::DataObject, public OperationActor
{
public:
mitkClassMacro(BaseData,itk::DataObject)
//##Documentation
//## @brief Return the TimeSlicedGeometry of the data as const pointer.
//##
//## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
//## be sure that the geometry is up-to-date.
//##
//## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
const mitk::TimeSlicedGeometry* GetTimeSlicedGeometry() const
{
return m_TimeSlicedGeometry.GetPointer();
}
//##Documentation
//## @brief Return the TimeSlicedGeometry of the data as pointer.
//##
//## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
//## be sure that the geometry is up-to-date.
//##
//## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
mitk::TimeSlicedGeometry* GetTimeSlicedGeometry()
{
return m_TimeSlicedGeometry.GetPointer();
}
//##Documentation
//## @brief Return the Geometry3D of the data.
//##
//## The method does not simply return the value of the m_TimeSlicedGeometry
//## member. Before doing this, it makes sure that the TimeSlicedGeometry
//## is up-to-date (by setting the update extent to largest possible and
//## calling UpdateOutputInformation).
const mitk::TimeSlicedGeometry* GetUpdatedTimeSlicedGeometry();
//##Documentation
//## @brief Expands the TimeSlicedGeometry to a number of TimeSteps.
//##
//## The method expands the TimeSlicedGeometry to the given number of TimeSteps,
//## filling newly created elements with empty geometries. Sub-classes should override
//## this method to handle the elongation of their data vectors, too.
//## Note that a shrinking is neither possible nor intended.
virtual void Expand( unsigned int timeSteps );
//##Documentation
//## @brief Return the Geometry3D of the data at time \a t.
//##
//## The method does not simply return
//## m_TimeSlicedGeometry->GetGeometry(t).
//## Before doing this, it makes sure that the Geometry3D is up-to-date
//## (by setting the update extent appropriately and calling
//## UpdateOutputInformation).
//##
//## @todo Appropriate setting of the update extent is missing.
const mitk::Geometry3D* GetUpdatedGeometry(int t=0);
//##Documentation
//## @brief Return the geometry, which is a TimeSlicedGeometry, of the data
//## as non-const pointer.
//##
//## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
//## be sure that the geometry is up-to-date.
//##
//## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
mitk::Geometry3D* GetGeometry(int t=0) const
{
if(m_TimeSlicedGeometry.IsNull())
return NULL;
return m_TimeSlicedGeometry->GetGeometry3D(t);
}
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- virtual void UnRegister() const;
-
- //##Documentation
- //## @brief for internal use only. Helps to deal with the
- //## weak-pointer-problem.
- virtual int GetExternalReferenceCount() const;
-
//##Documentation
//## @brief Update the information for this BaseData (the geometry in particular)
//## so that it can be used as an output of a BaseProcess.
//##
//## This method is used in the pipeline mechanism to propagate information and
//## initialize the meta data associated with a BaseData. Any implementation
//## of this method in a derived class is assumed to call its source's
//## BaseProcess::UpdateOutputInformation() which determines modified
//## times, LargestPossibleRegions, and any extra meta data like spacing,
//## origin, etc. Default implementation simply call's it's source's
//## UpdateOutputInformation().
//## \note Implementations of this methods in derived classes must take care
//## that the geometry is updated by calling
//## GetTimeSlicedGeometry()->UpdateInformation()
//## \em after calling its source's BaseProcess::UpdateOutputInformation().
void UpdateOutputInformation();
//##Documentation
//## @brief Set the RequestedRegion to the LargestPossibleRegion.
//##
//## This forces a filter to produce all of the output in one execution
//## (i.e. not streaming) on the next call to Update().
- void SetRequestedRegionToLargestPossibleRegion()=0;
+ virtual void SetRequestedRegionToLargestPossibleRegion()=0;
//##Documentation
//## @brief Determine whether the RequestedRegion is outside of the BufferedRegion.
//##
//## This method returns true if the RequestedRegion
//## is outside the BufferedRegion (true if at least one pixel is
//## outside). This is used by the pipeline mechanism to determine
//## whether a filter needs to re-execute in order to satisfy the
//## current request. If the current RequestedRegion is already
//## inside the BufferedRegion from the previous execution (and the
//## current filter is up to date), then a given filter does not need
//## to re-execute
- bool RequestedRegionIsOutsideOfTheBufferedRegion()=0;
+ virtual bool RequestedRegionIsOutsideOfTheBufferedRegion()=0;
//##Documentation
//## @brief Verify that the RequestedRegion is within the LargestPossibleRegion.
//##
//## If the RequestedRegion is not within the LargestPossibleRegion,
//## then the filter cannot possibly satisfy the request. This method
//## returns true if the request can be satisfied (even if it will be
//## necessary to process the entire LargestPossibleRegion) and
//## returns false otherwise. This method is used by
//## PropagateRequestedRegion(). PropagateRequestedRegion() throws a
//## InvalidRequestedRegionError exception if the requested region is
//## not within the LargestPossibleRegion.
virtual bool VerifyRequestedRegion() = 0;
//##Documentation
//## @brief Copy information from the specified data set.
//##
//## This method is part of the pipeline execution model. By default, a
//## BaseProcess will copy meta-data from the first input to all of its
//## outputs. See ProcessObject::GenerateOutputInformation(). Each
//## subclass of DataObject is responsible for being able to copy
//## whatever meta-data it needs from another DataObject.
//## The default implementation of this method copies the time sliced geometry
//## and the property list of an object. If a subclass overrides this
//## method, it should always call its superclass' version.
void CopyInformation(const itk::DataObject* data);
//##Documentation
//## @brief Check whether the data has been initialized, i.e.,
//## at least the Geometry and other header data has been set
//##
//## \warning Set to \a true by default for compatibility reasons.
//## Set m_Initialized=false in constructors of sub-classes that
//## support distinction between initialized and uninitialized state.
virtual bool IsInitialized() const;
//##Documentation
//## @brief Calls ClearData() and InitializeEmpty();
//## \warning Only use in subclasses that reimplemented these methods.
//## Just calling Clear from BaseData will reset an object to a not initialized,
//## invalid state.
virtual void Clear();
//##Documentation
//## @brief Check whether object contains data (at
//## a specified time), e.g., a set of points may be empty
//##
//## \warning Returns IsInitialized()==false by default for
//## compatibility reasons. Override in sub-classes that
//## support distinction between empty/non-empty state.
virtual bool IsEmptyTimeStep(unsigned int t) const;
//##Documentation
//## @brief Check whether object contains data (at
//## least at one point in time), e.g., a set of points
//## may be empty
//##
//## \warning Returns IsInitialized()==false by default for
//## compatibility reasons. Override in sub-classes that
//## support distinction between empty/non-empty state.
virtual bool IsEmpty() const;
//##Documentation
//## @brief Set the requested region from this data object to match the requested
//## region of the data object passed in as a parameter.
//##
//## This method is implemented in the concrete subclasses of BaseData.
- void SetRequestedRegion(itk::DataObject *data)=0;
+ virtual void SetRequestedRegion(const itk::DataObject *data)=0;
//##Documentation
//##@brief overwrite if the Data can be called by an Interactor (StateMachine).
//##
//## Empty by default. Overwrite and implement all the necessary operations here
//## and get the necessary information from the parameter operation.
void ExecuteOperation(Operation* operation);
//##Documentation
//## @brief Set the Geometry3D of the data, which will be referenced (not copied!).
//## Assumes the data object has only 1 time step ( is a 3D object ).
//##
//## For convenience (and historic) reasons, it is also possible to set a complete
//## mitk::TimeSlicedGeometry*, which will be referenced (not copied!).
//##
//## @warning This method will normally be called internally by the sub-class of BaseData
//## during initialization.
//## \sa SetClonedGeometry
virtual void SetGeometry(Geometry3D* aGeometry3D);
//##Documentation
//## @brief Set a clone of the provided geometry as Geometry3D of the data.
//## Assumes the data object has only 1 time step ( is a 3D object )
//##
//## \sa SetGeometry
virtual void SetClonedGeometry(const Geometry3D* aGeometry3D);
//##Documentation
//## @brief Set a clone of the provided geometry as Geometry3D of a given time step.
//##
//## \sa SetGeometry
virtual void SetClonedGeometry(const Geometry3D* aGeometry3D, unsigned int time);
//##Documentation
//## @brief Get the data's property list
//## @sa GetProperty
//## @sa m_PropertyList
mitk::PropertyList::Pointer GetPropertyList() const;
//##Documentation
//## @brief Set the data's property list
//## @sa SetProperty
//## @sa m_PropertyList
void SetPropertyList(PropertyList* propertyList);
//##Documentation
//## @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList,
//## and set it to this, respectively;
//## @sa GetPropertyList
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
mitk::BaseProperty::Pointer GetProperty(const char *propertyKey) const;
void SetProperty(const char *propertyKey, BaseProperty* property);
//##Documentation
//## @brief Convenience method for setting the origin of
//## the Geometry3D instances of all time steps
//##
//## \warning Geometries contained in the Geometry3D will
//## \em not be changed, e.g. in case the Geometry3D is a
//## SlicedGeometry3D the origin will \em not be propagated
//## to the contained slices. The sub-class SlicedData
//## does this for the case that the SlicedGeometry3D is
//## evenly spaced.
virtual void SetOrigin(const Point3D& origin);
/** \brief Get the process object that generated this data object.
*
* If there is no process object, then the data object has
* been disconnected from the pipeline, or the data object
* was created manually. (Note: we cannot use the GetObjectMacro()
* defined in itkMacro because the mutual dependency of
* DataObject and ProcessObject causes compile problems. Also,
* a forward reference smart pointer is returned, not a smart pointer,
* because of the circular dependency between the process and data object.)
*
* GetSource() returns a SmartPointer and not a WeakPointer
* because it is assumed the code calling GetSource() wants to hold a
* long term reference to the source. */
- itk::SmartPointer<mitk::BaseProcess> GetSource() const;
+ itk::SmartPointer<mitk::BaseDataSource> GetSource() const;
//##Documentation
//## @brief Get the number of time steps from the Timeslicedgeometry
//## As the base data has not a data vector given by itself, the number
//## of time steps is defined over the time sliced geometry. In sub classes,
//## a better implementation could be over the length of the data vector.
unsigned int GetTimeSteps() const
{
return m_TimeSlicedGeometry->GetTimeSteps();
}
//##Documentation
//## @brief Get the modified time of the last change of the contents
//## this data object or its geometry.
virtual unsigned long GetMTime() const;
+ /**
+ * \sa itk::ProcessObject::Graft
+ */
+ virtual void Graft(const DataObject*);
+
protected:
BaseData();
BaseData(const BaseData &other);
~BaseData();
//##Documentation
//## @brief Initialize the TimeSlicedGeometry for a number of time steps.
//## The TimeSlicedGeometry is initialized empty and evenly timed.
//## In many cases it will be necessary to overwrite this in sub-classes.
virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 );
//##Documentation
//## @brief reset to non-initialized state, release memory
virtual void ClearData();
//##Documentation
//## @brief Pure virtual; Must be used in subclasses to get a data object to a
//## valid state. Should at least create one empty object and call
//## Superclass::InitializeTimeSlicedGeometry() to ensure an existing valid geometry
virtual void InitializeEmpty(){}
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
bool m_RequestedRegionInitialized;
bool m_LastRequestedRegionWasOutsideOfTheBufferedRegion;
- mutable itk::SmartPointer<mitk::BaseProcess> m_SmartSourcePointer;
mutable unsigned int m_SourceOutputIndexDuplicate;
- //##Documentation
- //## @brief for internal use only. Helps to deal with the
- //## weak-pointer-problem.
- virtual void ConnectSource(itk::ProcessObject *arg, unsigned int idx) const;
bool m_Initialized;
private:
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- mutable bool m_Unregistering;
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- mutable bool m_CalculatingExternalReferenceCount;
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- mutable int m_ExternalReferenceCount;
//##Documentation
//## @brief PropertyList, f.e. to hold pic-tags, tracking-data,..
//##
PropertyList::Pointer m_PropertyList;
TimeSlicedGeometry::Pointer m_TimeSlicedGeometry;
- //##Documentation
- //## @brief Helps to deal with the weak-pointer-problem.
- friend class mitk::BaseProcess;
};
} // namespace mitk
#endif /* BASEDATA_H_HEADER_INCLUDED_C1EBB6FA */
diff --git a/Core/Code/DataManagement/mitkBaseDataTestImplementation.h b/Core/Code/DataManagement/mitkBaseDataTestImplementation.h
index 647e81f273..d14baaaa15 100644
--- a/Core/Code/DataManagement/mitkBaseDataTestImplementation.h
+++ b/Core/Code/DataManagement/mitkBaseDataTestImplementation.h
@@ -1,59 +1,59 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef BASEDATAIMPLEMENTATION_H_HEADER_INCLUDED
#define BASEDATAIMPLEMENTATION_H_HEADER_INCLUDED
#include "mitkBaseData.h"
namespace mitk {
//##Documentation
//## @brief Implementation of BaseData (for testing)
//##
//## As BaseData is an abstract class, we need an implementation for testing its methods
//## @ingroup Data
class BaseDataTestImplementation : public BaseData
{
public:
mitkClassMacro(BaseDataTestImplementation, BaseData);
itkNewMacro(Self);
mitkCloneMacro(BaseDataTestImplementation);
virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps /* = 1 */ )
{
Superclass::InitializeTimeSlicedGeometry(timeSteps);
}
protected:
virtual bool VerifyRequestedRegion(){return false;};
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion(){return false;};
virtual void SetRequestedRegionToLargestPossibleRegion(){};
- virtual void SetRequestedRegion(itk::DataObject * /*data*/){};
+ virtual void SetRequestedRegion( const itk::DataObject * /*data*/){};
BaseDataTestImplementation(){};
virtual ~BaseDataTestImplementation(){};
};
} // namespace
#endif // BASEDATA_H_HEADER_INCLUDED
diff --git a/Core/Code/DataManagement/mitkBaseProperty.cpp b/Core/Code/DataManagement/mitkBaseProperty.cpp
index abc07dc500..a2712f05d9 100644
--- a/Core/Code/DataManagement/mitkBaseProperty.cpp
+++ b/Core/Code/DataManagement/mitkBaseProperty.cpp
@@ -1,66 +1,60 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBaseProperty.h"
mitk::BaseProperty::BaseProperty()
{
}
mitk::BaseProperty::BaseProperty(const mitk::BaseProperty&)
: itk::Object()
{
}
mitk::BaseProperty::~BaseProperty()
{
}
std::string mitk::BaseProperty::GetValueAsString() const
{
return std::string("n/a");
}
mitk::BaseProperty& mitk::BaseProperty::operator=(const BaseProperty& rhs)
{
AssignProperty(rhs);
return *this;
}
bool mitk::BaseProperty::AssignProperty(const BaseProperty& rhs)
{
if (this == &rhs) return true; // no self assignment
if (typeid(*this) == typeid(rhs) && Assign(rhs))
{
this->Modified();
return true;
}
return false;
}
-mitk::BaseProperty::Pointer mitk::BaseProperty::Clone() const
-{
- Pointer result = dynamic_cast<BaseProperty*>(this->InternalClone().GetPointer());
- return result;
-}
-
bool mitk::BaseProperty::operator==(const BaseProperty& property) const
{
return (typeid(*this) == typeid(property) && IsEqual(property));
}
diff --git a/Core/Code/DataManagement/mitkBaseProperty.h b/Core/Code/DataManagement/mitkBaseProperty.h
index f88ca0e912..475d174b00 100644
--- a/Core/Code/DataManagement/mitkBaseProperty.h
+++ b/Core/Code/DataManagement/mitkBaseProperty.h
@@ -1,106 +1,103 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef BASEPROPERTY_H_HEADER_INCLUDED_C1F4DF54
#define BASEPROPERTY_H_HEADER_INCLUDED_C1F4DF54
#include <string>
#include <itkObjectFactory.h>
#include <MitkExports.h>
#include <mitkCommon.h>
namespace mitk {
/*! \brief Abstract base class for properties
\ingroup DataManagement
Base class for properties. Properties are arbitrary additional information
(to define a new type of information you have to define a subclass of
BaseProperty) that can be added to a PropertyList.
Concrete subclasses of BaseProperty should define Set-/Get-methods to assess
the property value, which should be stored by value (not by reference).
Subclasses must implement an operator==(const BaseProperty& property), which
is used by PropertyList to check whether a property has been changed.
*/
class MITK_CORE_EXPORT BaseProperty : public itk::Object
{
public:
mitkClassMacro(BaseProperty,itk::Object)
-
- Pointer Clone() const;
+ itkCloneMacro(Self)
/*! @brief Subclasses must implement IsEqual(const BaseProperty&) to support comparison.
operator== which is used by PropertyList to check whether a property has been changed.
*/
bool operator==(const BaseProperty& property) const;
/*! @brief Assigns property to this BaseProperty instance.
Subclasses must implement Assign(const BaseProperty&) and call the superclass
Assign method for proper handling of polymorphic assignments. The assignment
operator of the subclass should be disabled and the baseclass operator should
be made visible using "using" statements.
*/
BaseProperty& operator=(const BaseProperty& property);
/*! @brief Assigns property to this BaseProperty instance.
This method is identical to the assignment operator, except for the return type.
It allows to directly check if the assignemnt was successfull.
*/
bool AssignProperty(const BaseProperty & property);
virtual std::string GetValueAsString() const;
protected:
BaseProperty();
BaseProperty(const BaseProperty& other);
virtual ~BaseProperty();
private:
/*!
Override this method in subclasses to implement a meaningful comparison. The property
argument is guaranteed to be castable to the type of the implementing subclass.
*/
virtual bool IsEqual(const BaseProperty& property) const = 0;
/*!
Override this method in subclasses to implement a meaningful assignment. The property
argument is guaranteed to be castable to the type of the implementing subclass.
@warning This is not yet exception aware/safe and if this method returns false,
this property's state might be undefined.
@return True if the argument could be assigned to this property.
*/
virtual bool Assign(const BaseProperty& ) = 0;
-
- virtual itk::LightObject::Pointer InternalClone() const = 0;
};
} // namespace mitk
#endif /* BASEPROPERTY_H_HEADER_INCLUDED_C1F4DF54 */
diff --git a/Core/Code/DataManagement/mitkClippingProperty.cpp b/Core/Code/DataManagement/mitkClippingProperty.cpp
index 74d6c22c5b..ff2c3bd66d 100644
--- a/Core/Code/DataManagement/mitkClippingProperty.cpp
+++ b/Core/Code/DataManagement/mitkClippingProperty.cpp
@@ -1,131 +1,125 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkClippingProperty.h"
namespace mitk
{
ClippingProperty::ClippingProperty()
: m_ClippingEnabled( false )
{
}
ClippingProperty::ClippingProperty(const ClippingProperty& other)
: BaseProperty(other)
, m_ClippingEnabled(other.m_ClippingEnabled)
, m_Origin(other.m_Origin)
, m_Normal(other.m_Normal)
{
}
ClippingProperty::ClippingProperty(
const Point3D &origin, const Vector3D &normal )
: m_ClippingEnabled( true ),
m_Origin( origin ),
m_Normal( normal )
{
}
bool ClippingProperty::GetClippingEnabled() const
{
return m_ClippingEnabled;
}
void ClippingProperty::SetClippingEnabled( bool enabled )
{
if (m_ClippingEnabled != enabled)
{
m_ClippingEnabled = enabled;
this->Modified();
}
}
const Point3D &ClippingProperty::GetOrigin() const
{
return m_Origin;
}
void ClippingProperty::SetOrigin( const Point3D &origin )
{
if (m_Origin != origin)
{
m_Origin = origin;
this->Modified();
}
}
const Vector3D &ClippingProperty::GetNormal() const
{
return m_Normal;
}
void ClippingProperty::SetNormal( const Vector3D &normal )
{
if (m_Normal != normal)
{
m_Normal = normal;
this->Modified();
}
}
bool ClippingProperty::IsEqual( const BaseProperty &property ) const
{
return ((this->m_ClippingEnabled == static_cast<const Self&>(property).m_ClippingEnabled) &&
(this->m_Origin == static_cast<const Self&>(property).m_Origin ) &&
(this->m_Normal == static_cast<const Self&>(property).m_Normal ) );
}
bool ClippingProperty::Assign( const BaseProperty &property )
{
this->m_ClippingEnabled = static_cast<const Self&>(property).m_ClippingEnabled;
this->m_Origin = static_cast<const Self&>(property).m_Origin;
this->m_Normal = static_cast<const Self&>(property).m_Normal;
return true;
}
std::string ClippingProperty::GetValueAsString() const
{
std::stringstream myStr;
myStr << this->GetClippingEnabled() << this->GetOrigin() << this->GetNormal();
return myStr.str();
}
-ClippingProperty::Pointer ClippingProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer ClippingProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
} // namespace
diff --git a/Core/Code/DataManagement/mitkClippingProperty.h b/Core/Code/DataManagement/mitkClippingProperty.h
index 29a848117f..11bdc678fc 100644
--- a/Core/Code/DataManagement/mitkClippingProperty.h
+++ b/Core/Code/DataManagement/mitkClippingProperty.h
@@ -1,97 +1,95 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKCLIPPINGPROPERTY_H_HEADER_INCLUDED
#define MITKCLIPPINGPROPERTY_H_HEADER_INCLUDED
#include <MitkExports.h>
#include "mitkBaseProperty.h"
#include "mitkVector.h"
#include <itkConfigure.h>
#include <string>
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* \brief Property for clipping datasets; currently only
* clipping planes are possible
* \ingroup DataManagement
*/
class MITK_CORE_EXPORT ClippingProperty : public BaseProperty
{
public:
mitkClassMacro(ClippingProperty, BaseProperty)
typedef std::string ValueType;
itkNewMacro( ClippingProperty );
mitkNewMacro2Param( ClippingProperty,
const Point3D &, const Vector3D & );
- Pointer Clone() const;
-
bool GetClippingEnabled() const;
void SetClippingEnabled( bool enabled );
const Point3D &GetOrigin() const;
void SetOrigin( const Point3D &origin );
const Vector3D &GetNormal() const;
void SetNormal( const Vector3D &normal );
virtual std::string GetValueAsString() const;
using BaseProperty::operator =;
protected:
bool m_ClippingEnabled;
Point3D m_Origin;
Vector3D m_Normal;
ClippingProperty();
ClippingProperty(const ClippingProperty& other);
ClippingProperty( const Point3D &origin, const Vector3D &normal );
private:
// purposely not implemented
ClippingProperty& operator=(const ClippingProperty&);
virtual bool IsEqual(const BaseProperty& property) const;
virtual bool Assign(const BaseProperty& property);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif /* MITKCLIPPINGPROPERTY_H_HEADER_INCLUDED */
diff --git a/Core/Code/DataManagement/mitkColorProperty.cpp b/Core/Code/DataManagement/mitkColorProperty.cpp
index ca48514c96..c5675294ad 100644
--- a/Core/Code/DataManagement/mitkColorProperty.cpp
+++ b/Core/Code/DataManagement/mitkColorProperty.cpp
@@ -1,105 +1,99 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <sstream>
#include "mitkColorProperty.h"
mitk::ColorProperty::ColorProperty()
: m_Color()
{
}
mitk::ColorProperty::ColorProperty(const mitk::ColorProperty& other)
: BaseProperty(other)
, m_Color(other.m_Color)
{
}
mitk::ColorProperty::ColorProperty(const float color[3]) : m_Color(color)
{
}
mitk::ColorProperty::ColorProperty(const float red, const float green, const float blue)
{
m_Color.Set(red, green, blue);
}
mitk::ColorProperty::ColorProperty(const mitk::Color & color) : m_Color(color)
{
}
bool mitk::ColorProperty::IsEqual(const BaseProperty& property) const
{
return this->m_Color == static_cast<const Self&>(property).m_Color;
}
bool mitk::ColorProperty::Assign(const BaseProperty& property)
{
this->m_Color = static_cast<const Self&>(property).m_Color;
return true;
}
const mitk::Color & mitk::ColorProperty::GetColor() const
{
return m_Color;
}
void mitk::ColorProperty::SetColor(const mitk::Color & color )
{
if(m_Color!=color)
{
m_Color = color;
Modified();
}
}
void mitk::ColorProperty::SetValue(const mitk::Color & color )
{
SetColor(color);
}
void mitk::ColorProperty::SetColor( float red, float green, float blue )
{
float tmp[3] = { red, green, blue };
SetColor(mitk::Color(tmp));
}
std::string mitk::ColorProperty::GetValueAsString() const {
std::stringstream myStr;
myStr.imbue(std::locale::classic());
myStr << GetValue() ;
return myStr.str();
}
const mitk::Color & mitk::ColorProperty::GetValue() const
{
return GetColor();
}
-mitk::ColorProperty::Pointer mitk::ColorProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::ColorProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkColorProperty.h b/Core/Code/DataManagement/mitkColorProperty.h
index 2b89db9844..3faf9a0a1f 100644
--- a/Core/Code/DataManagement/mitkColorProperty.h
+++ b/Core/Code/DataManagement/mitkColorProperty.h
@@ -1,98 +1,96 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKCOLORPROPERTY_H_HEADER_INCLUDED_C17953D1
#define MITKCOLORPROPERTY_H_HEADER_INCLUDED_C17953D1
#include <MitkExports.h>
#include "mitkBaseProperty.h"
#include <itkRGBPixel.h>
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
//##Documentation
//## @brief Standard RGB color typedef (float)
//##
//## Standard RGB color typedef to get rid of template argument (float).
//## @ingroup Property
typedef itk::RGBPixel< float > Color;
//##Documentation
//## @brief RGB color property
//##
//## @ingroup DataManagement
class MITK_CORE_EXPORT ColorProperty : public BaseProperty
{
protected:
mitk::Color m_Color;
ColorProperty();
ColorProperty(const ColorProperty& other);
ColorProperty(const float red, const float green, const float blue);
ColorProperty(const float color[3]);
ColorProperty(const mitk::Color & color);
public:
mitkClassMacro(ColorProperty, BaseProperty)
itkNewMacro(ColorProperty);
mitkNewMacro1Param(ColorProperty, const float*);
mitkNewMacro1Param(ColorProperty, const mitk::Color&);
mitkNewMacro3Param(ColorProperty, const float, const float, const float);
- Pointer Clone() const;
-
typedef mitk::Color ValueType;
const mitk::Color & GetColor() const;
const mitk::Color & GetValue() const;
std::string GetValueAsString() const;
void SetColor(const mitk::Color & color );
void SetValue(const mitk::Color & color );
void SetColor( float red, float green, float blue );
using BaseProperty::operator=;
private:
// purposely not implemented
ColorProperty& operator=(const ColorProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty& property) const;
virtual bool Assign(const BaseProperty & property);
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif /* MITKCOLORPROPERTY_H_HEADER_INCLUDED_C17953D1 */
diff --git a/Core/Code/DataManagement/mitkDataNode.cpp b/Core/Code/DataManagement/mitkDataNode.cpp
index 30b0ab3a5f..7c61d404b1 100644
--- a/Core/Code/DataManagement/mitkDataNode.cpp
+++ b/Core/Code/DataManagement/mitkDataNode.cpp
@@ -1,564 +1,564 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkDataNode.h"
#include "mitkCoreObjectFactory.h"
#include <vtkTransform.h>
#include "mitkProperties.h"
#include "mitkStringProperty.h"
#include "mitkGroupTagProperty.h"
#include "mitkSmartPointerProperty.h"
//#include "mitkMaterialProperty.h"
#include "mitkColorProperty.h"
#include "mitkLevelWindowProperty.h"
#include "mitkGeometry3D.h"
#include "mitkRenderingManager.h"
#include "mitkGlobalInteraction.h"
#include "mitkEventMapper.h"
#include "mitkGenericProperty.h"
#include "mitkCoreObjectFactory.h"
mitk::Mapper* mitk::DataNode::GetMapper(MapperSlotId id) const
{
if( (id >= m_Mappers.size()) || (m_Mappers[id].IsNull()) )
{
if(id >= m_Mappers.capacity())
{
// int i, size=id-m_Mappers.capacity()+10;
m_Mappers.resize(id+10);
}
m_Mappers[id] = CoreObjectFactory::GetInstance()->CreateMapper(const_cast<DataNode*>(this),id);
}
return m_Mappers[id];
}
mitk::BaseData* mitk::DataNode::GetData() const
{
return m_Data;
}
mitk::Interactor* mitk::DataNode::GetInteractor() const
{
return m_Interactor;
}
void mitk::DataNode::SetData(mitk::BaseData* baseData)
{
if(m_Data!=baseData)
{
m_Data=baseData;
m_Mappers.clear();
m_Mappers.resize(10);
mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(this);
m_DataReferenceChangedTime.Modified();
Modified();
//inform the interactor about the change
if (m_Interactor.IsNotNull())
m_Interactor->DataChanged();
}
}
void mitk::DataNode::SetInteractor(mitk::Interactor* interactor)
{
m_Interactor = interactor;
if(m_Interactor.IsNotNull())
m_Interactor->SetDataNode(this);
}
mitk::DataNode::DataNode() : m_Data(NULL), m_PropertyListModifiedObserverTag(0)
{
m_Mappers.resize(10);
m_PropertyList = PropertyList::New();
// subscribe for modified event
itk::MemberCommand<mitk::DataNode>::Pointer _PropertyListModifiedCommand =
itk::MemberCommand<mitk::DataNode>::New();
_PropertyListModifiedCommand->SetCallbackFunction(this, &mitk::DataNode::PropertyListModified);
m_PropertyListModifiedObserverTag = m_PropertyList->AddObserver(itk::ModifiedEvent(), _PropertyListModifiedCommand);
}
mitk::DataNode::~DataNode()
{
if(m_PropertyList.IsNotNull())
// remove modified event listener
m_PropertyList->RemoveObserver(m_PropertyListModifiedObserverTag);
Interactor* interactor = this->GetInteractor();
if ( interactor )
{
mitk::GlobalInteraction::GetInstance()->RemoveInteractor( interactor );
}
m_Mappers.clear();
m_Data = NULL;
}
mitk::DataNode& mitk::DataNode::operator=(const DataNode& right)
{
mitk::DataNode* node=mitk::DataNode::New();
node->SetData(right.GetData());
return *node;
}
mitk::DataNode& mitk::DataNode::operator=(mitk::BaseData* right)
{
mitk::DataNode* node=mitk::DataNode::New();
node->SetData(right);
return *node;
}
#if (_MSC_VER > 1200) || !defined(_MSC_VER)
MBI_STD::istream& mitk::operator>>( MBI_STD::istream& i, mitk::DataNode::Pointer& dtn )
#endif
#if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
MBI_STD::istream& operator>>( MBI_STD::istream& i, mitk::DataNode::Pointer& dtn )
#endif
{
dtn = mitk::DataNode::New();
//i >> av.get();
return i;
}
#if (_MSC_VER > 1200) || !defined(_MSC_VER)
MBI_STD::ostream& mitk::operator<<( MBI_STD::ostream& o, mitk::DataNode::Pointer& dtn)
#endif
#if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
MBI_STD::ostream& operator<<( MBI_STD::ostream& o, mitk::DataNode::Pointer& dtn)
#endif
{
if(dtn->GetData()!=NULL)
o<<dtn->GetData()->GetNameOfClass();
else
o<<"empty data";
return o;
}
void mitk::DataNode::SetMapper(MapperSlotId id, mitk::Mapper* mapper)
{
m_Mappers[id] = mapper;
if (mapper!=NULL)
mapper->SetDataNode(this);
}
void mitk::DataNode::UpdateOutputInformation()
{
if (this->GetSource())
{
this->GetSource()->UpdateOutputInformation();
}
}
void mitk::DataNode::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::DataNode::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::DataNode::VerifyRequestedRegion()
{
return true;
}
-void mitk::DataNode::SetRequestedRegion(itk::DataObject * /*data*/)
+void mitk::DataNode::SetRequestedRegion( const itk::DataObject * /*data*/)
{
}
void mitk::DataNode::CopyInformation(const itk::DataObject * /*data*/)
{
}
mitk::PropertyList* mitk::DataNode::GetPropertyList(const mitk::BaseRenderer* renderer) const
{
if(renderer==NULL)
return m_PropertyList;
mitk::PropertyList::Pointer & propertyList = m_MapOfPropertyLists[renderer];
if(propertyList.IsNull())
propertyList = mitk::PropertyList::New();
assert(m_MapOfPropertyLists[renderer].IsNotNull());
return propertyList;
}
void mitk::DataNode::ConcatenatePropertyList(PropertyList *pList, bool replace)
{
m_PropertyList->ConcatenatePropertyList(pList, replace);
}
mitk::BaseProperty* mitk::DataNode::GetProperty(const char *propertyKey, const mitk::BaseRenderer* renderer) const
{
if(propertyKey==NULL)
return NULL;
//renderer specified?
if (renderer)
{
std::map<const mitk::BaseRenderer*,mitk::PropertyList::Pointer>::const_iterator it;
//check for the renderer specific property
it=m_MapOfPropertyLists.find(renderer);
if(it!=m_MapOfPropertyLists.end()) //found
{
mitk::BaseProperty::Pointer property;
property=it->second->GetProperty(propertyKey);
if(property.IsNotNull())//found an enabled property in the render specific list
return property;
else //found a renderer specific list, but not the desired property
return m_PropertyList->GetProperty(propertyKey); //return renderer unspecific property
}
else //didn't find the property list of the given renderer
{
//return the renderer unspecific property if there is one
return m_PropertyList->GetProperty(propertyKey);
}
}
else //no specific renderer given; use the renderer independent one
{
mitk::BaseProperty::Pointer property;
property=m_PropertyList->GetProperty(propertyKey);
if(property.IsNotNull())
return property;
}
//only to satisfy compiler!
return NULL;
}
mitk::DataNode::GroupTagList mitk::DataNode::GetGroupTags() const
{
GroupTagList groups;
const PropertyList::PropertyMap* propertyMap = m_PropertyList->GetMap();
for ( PropertyList::PropertyMap::const_iterator groupIter = propertyMap->begin(); // m_PropertyList is created in the constructor, so we don't check it here
groupIter != propertyMap->end();
++groupIter )
{
const BaseProperty* bp = groupIter->second;
if ( dynamic_cast<const GroupTagProperty*>(bp) )
{
groups.insert( groupIter->first );
}
}
return groups;
}
bool mitk::DataNode::GetBoolProperty(const char* propertyKey, bool& boolValue, mitk::BaseRenderer* renderer) const
{
mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty*>(GetProperty(propertyKey, renderer));
if(boolprop.IsNull())
return false;
boolValue = boolprop->GetValue();
return true;
}
bool mitk::DataNode::GetIntProperty(const char* propertyKey, int &intValue, mitk::BaseRenderer* renderer) const
{
mitk::IntProperty::Pointer intprop = dynamic_cast<mitk::IntProperty*>(GetProperty(propertyKey, renderer));
if(intprop.IsNull())
return false;
intValue = intprop->GetValue();
return true;
}
bool mitk::DataNode::GetFloatProperty(const char* propertyKey, float &floatValue, mitk::BaseRenderer* renderer) const
{
mitk::FloatProperty::Pointer floatprop = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey, renderer));
if(floatprop.IsNull())
return false;
floatValue = floatprop->GetValue();
return true;
}
bool mitk::DataNode::GetStringProperty(const char* propertyKey, std::string& string, mitk::BaseRenderer* renderer) const
{
mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty*>(GetProperty(propertyKey, renderer));
if(stringProp.IsNull())
{
return false;
}
else
{
//memcpy((void*)string, stringProp->GetValue(), strlen(stringProp->GetValue()) + 1 ); // looks dangerous
string = stringProp->GetValue();
return true;
}
}
bool mitk::DataNode::GetColor(float rgb[3], mitk::BaseRenderer* renderer, const char* propertyKey) const
{
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetProperty(propertyKey, renderer));
if(colorprop.IsNull())
return false;
memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
return true;
}
bool mitk::DataNode::GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const char* propertyKey) const
{
mitk::FloatProperty::Pointer opacityprop = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey, renderer));
if(opacityprop.IsNull())
return false;
opacity=opacityprop->GetValue();
return true;
}
bool mitk::DataNode::GetLevelWindow(mitk::LevelWindow &levelWindow, mitk::BaseRenderer* renderer, const char* propertyKey) const
{
mitk::LevelWindowProperty::Pointer levWinProp = dynamic_cast<mitk::LevelWindowProperty*>(GetProperty(propertyKey, renderer));
if(levWinProp.IsNull())
return false;
levelWindow=levWinProp->GetLevelWindow();
return true;
}
void mitk::DataNode::SetColor(const mitk::Color &color, mitk::BaseRenderer* renderer, const char* propertyKey)
{
mitk::ColorProperty::Pointer prop;
prop = mitk::ColorProperty::New(color);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetColor(float red, float green, float blue, mitk::BaseRenderer* renderer, const char* propertyKey)
{
float color[3];
color[0]=red;
color[1]=green;
color[2]=blue;
SetColor(color, renderer, propertyKey);
}
void mitk::DataNode::SetColor(const float rgb[3], mitk::BaseRenderer* renderer, const char* propertyKey)
{
mitk::ColorProperty::Pointer prop;
prop = mitk::ColorProperty::New(rgb);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetVisibility(bool visible, mitk::BaseRenderer* renderer, const char* propertyKey)
{
mitk::BoolProperty::Pointer prop;
prop = mitk::BoolProperty::New(visible);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetOpacity(float opacity, mitk::BaseRenderer* renderer, const char* propertyKey)
{
mitk::FloatProperty::Pointer prop;
prop = mitk::FloatProperty::New(opacity);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetLevelWindow(mitk::LevelWindow levelWindow, mitk::BaseRenderer* renderer, const char* propertyKey)
{
mitk::LevelWindowProperty::Pointer prop;
prop = mitk::LevelWindowProperty::New(levelWindow);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetIntProperty(const char* propertyKey, int intValue, mitk::BaseRenderer* renderer)
{
GetPropertyList(renderer)->SetProperty(propertyKey, mitk::IntProperty::New(intValue));
}
void mitk::DataNode::SetBoolProperty( const char* propertyKey, bool boolValue, mitk::BaseRenderer* renderer/*=NULL*/ )
{
GetPropertyList(renderer)->SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
}
void mitk::DataNode::SetFloatProperty( const char* propertyKey, float floatValue, mitk::BaseRenderer* renderer/*=NULL*/ )
{
GetPropertyList(renderer)->SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
}
void mitk::DataNode::SetStringProperty( const char* propertyKey, const char* stringValue, mitk::BaseRenderer* renderer/*=NULL*/ )
{
GetPropertyList(renderer)->SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
}
void mitk::DataNode::SetProperty(const char *propertyKey,
BaseProperty* propertyValue,
const mitk::BaseRenderer* renderer)
{
GetPropertyList(renderer)->SetProperty(propertyKey, propertyValue);
}
void mitk::DataNode::ReplaceProperty(const char *propertyKey,
BaseProperty* propertyValue,
const mitk::BaseRenderer* renderer)
{
GetPropertyList(renderer)->ReplaceProperty(propertyKey, propertyValue);
}
void mitk::DataNode::AddProperty(const char *propertyKey,
BaseProperty* propertyValue,
const mitk::BaseRenderer* renderer,
bool overwrite)
{
if((overwrite) || (GetProperty(propertyKey, renderer) == NULL))
{
SetProperty(propertyKey, propertyValue, renderer);
}
}
vtkLinearTransform* mitk::DataNode::GetVtkTransform(int t) const
{
assert(m_Data.IsNotNull());
mitk::Geometry3D* geometry = m_Data->GetGeometry(t);
if(geometry == NULL)
return NULL;
return geometry->GetVtkTransform();
}
unsigned long mitk::DataNode::GetMTime() const
{
unsigned long time = Superclass::GetMTime();
if(m_Data.IsNotNull())
{
if((time < m_Data->GetMTime()) ||
((m_Data->GetSource().IsNotNull()) && (time < m_Data->GetSource()->GetMTime()))
)
{
Modified();
return Superclass::GetMTime();
}
}
return time;
}
void mitk::DataNode::SetSelected(bool selected, mitk::BaseRenderer* renderer)
{
mitk::BoolProperty::Pointer selectedProperty = dynamic_cast<mitk::BoolProperty*>(GetProperty("selected"));
if ( selectedProperty.IsNull() )
{
selectedProperty = mitk::BoolProperty::New();
selectedProperty->SetValue(false);
SetProperty("selected", selectedProperty, renderer);
}
if( selectedProperty->GetValue() != selected )
{
selectedProperty->SetValue(selected);
itk::ModifiedEvent event;
InvokeEvent( event );
}
}
/*
class SelectedEvent : public itk::ModifiedEvent
{
public:
typedef SelectedEvent Self;
typedef itk::ModifiedEvent Superclass;
SelectedEvent(DataNode* dataNode)
{ m_DataNode = dataNode; };
DataNode* GetDataNode()
{ return m_DataNode; };
virtual const char * GetEventName() const
{ return "SelectedEvent"; }
virtual bool CheckEvent(const ::itk::EventObject* e) const
{ return dynamic_cast<const Self*>(e); }
virtual ::itk::EventObject* MakeObject() const
{ return new Self(m_DataNode); }
private:
DataNode* m_DataNode;
SelectedEvent(const Self& event)
{ m_DataNode = event.m_DataNode; };
void operator=(const Self& event)
{ m_DataNode = event.m_DataNode; }
};
*/
bool mitk::DataNode::IsSelected(mitk::BaseRenderer* renderer)
{
bool selected;
if ( !GetBoolProperty("selected", selected, renderer) )
return false;
return selected;
}
void mitk::DataNode::SetInteractorEnabled( const bool& enabled )
{
if ( m_Interactor.IsNull() )
{
itkWarningMacro("Interactor is NULL. Couldn't enable or disable interaction.");
return;
}
if ( enabled )
mitk::GlobalInteraction::GetInstance()->AddInteractor( m_Interactor.GetPointer() );
else
mitk::GlobalInteraction::GetInstance()->RemoveInteractor( m_Interactor.GetPointer() );
}
void mitk::DataNode::EnableInteractor()
{
SetInteractorEnabled( true );
}
void mitk::DataNode::DisableInteractor()
{
SetInteractorEnabled( false );
}
bool mitk::DataNode::IsInteractorEnabled() const
{
return mitk::GlobalInteraction::GetInstance()->InteractorRegistered( m_Interactor.GetPointer() );
}
void mitk::DataNode::SetDataInteractor(const DataInteractor::Pointer& interactor)
{
m_DataInteractor = interactor;
Modified();
}
mitk::DataInteractor::Pointer mitk::DataNode::GetDataInteractor() const
{
return m_DataInteractor;
}
void mitk::DataNode::PropertyListModified( const itk::Object* /*caller*/, const itk::EventObject& )
{
Modified();
}
diff --git a/Core/Code/DataManagement/mitkDataNode.h b/Core/Code/DataManagement/mitkDataNode.h
index 921d4cad6c..6f39881565 100644
--- a/Core/Code/DataManagement/mitkDataNode.h
+++ b/Core/Code/DataManagement/mitkDataNode.h
@@ -1,533 +1,533 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef DATATREENODE_H_HEADER_INCLUDED_C1E14338
#define DATATREENODE_H_HEADER_INCLUDED_C1E14338
#include "mitkImageSource.h"
#include "mitkBaseData.h"
//#include "mitkMapper.h"
#include "mitkInteractor.h"
#include "mitkDataInteractor.h"
#ifdef MBI_NO_STD_NAMESPACE
#define MBI_STD
#include <iostream.h>
#include <fstream.h>
#else
#define MBI_STD std
#include <iostream>
#include <fstream>
#endif
#include "mitkStringProperty.h"
#include "mitkColorProperty.h"
#include "mitkPropertyList.h"
//#include "mitkMapper.h"
#include <map>
#include <set>
#include "mitkLevelWindow.h"
class vtkLinearTransform;
namespace mitk {
class BaseRenderer;
class Mapper;
//##Documentation
//## @brief Class for nodes of the DataTree
//##
//## Contains the data (instance of BaseData), a list of mappers, which can
//## draw the data, a transform (vtkTransform) and a list of properties
//## (PropertyList).
//## @ingroup DataManagement
//##
//## @todo clean up all the GetProperty methods. There are too many different flavours... Can most probably be reduced to <tt>bool GetProperty<type>(type&)</tt>
//##
//## @warning Change in semantics of SetProperty() since Aug 25th 2006. Check your usage of this method if you do
//## more with properties than just call <tt>SetProperty( "key", new SomeProperty("value") )</tt>.
class MITK_CORE_EXPORT DataNode : public itk::DataObject
{
public:
typedef mitk::Geometry3D::Pointer Geometry3DPointer;
typedef std::vector< itk::SmartPointer< Mapper > > MapperVector;
typedef std::map<const mitk::BaseRenderer*,mitk::PropertyList::Pointer> MapOfPropertyLists;
typedef std::set<std::string> GroupTagList;
mitkClassMacro(DataNode, itk::DataObject);
itkNewMacro(Self);
mitk::Mapper* GetMapper(MapperSlotId id) const;
//##Documentation
//## @brief Get the data object (instance of BaseData, e.g., an Image)
//## managed by this DataNode
BaseData* GetData() const;
//##Documentation
//## @brief Get the transformation applied prior to displaying the data as
//## a vtkTransform
//## \deprecated use GetData()->GetGeometry()->GetVtkTransform() instead
vtkLinearTransform* GetVtkTransform(int t=0) const;
//##Documentation
//## @brief Get the Interactor.
//## @deprecatedSince{2013_03} Use DataInteractor and GetDataInteractor instead.
Interactor* GetInteractor() const;
//##Documentation
//## @brief Set the data object (instance of BaseData, e.g., an Image)
//## managed by this DataNode
//## @warning the actor-mode of the vtkInteractor does not work any more, if the transform of the
//## data-tree-node is connected to the transform of the basedata via vtkTransform->SetInput.
virtual void SetData(mitk::BaseData* baseData);
//##Documentation
//## @brief Set the Interactor.
//## @deprecatedSince{2013_03} Use DataInteractor and SetDataInteractor instead.
virtual void SetInteractor(Interactor* interactor);
virtual void SetDataInteractor(const DataInteractor::Pointer& interactor);
virtual DataInteractor::Pointer GetDataInteractor() const;
mitk::DataNode& operator=(const DataNode& right);
mitk::DataNode& operator=(BaseData* right);
virtual void SetMapper(MapperSlotId id, mitk::Mapper* mapper);
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion( const itk::DataObject *data);
virtual void CopyInformation(const itk::DataObject *data);
//##Documentation
//## @brief Set the property (instance of BaseProperty) with key @a propertyKey in the PropertyList
//## of the @a renderer (if NULL, use BaseRenderer-independent PropertyList). This is set-by-value.
//##
//## @warning Change in semantics since Aug 25th 2006. Check your usage of this method if you do
//## more with properties than just call <tt>SetProperty( "key", new SomeProperty("value") )</tt>.
//##
//## @sa GetProperty
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
void SetProperty(const char *propertyKey, BaseProperty* property, const mitk::BaseRenderer* renderer = NULL);
//##Documentation
//## @brief Replace the property (instance of BaseProperty) with key @a propertyKey in the PropertyList
//## of the @a renderer (if NULL, use BaseRenderer-independent PropertyList). This is set-by-reference.
//##
//## If @a renderer is @a NULL the property is set in the BaseRenderer-independent
//## PropertyList of this DataNode.
//## @sa GetProperty
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
void ReplaceProperty(const char *propertyKey, BaseProperty* property, const mitk::BaseRenderer* renderer = NULL);
//##Documentation
//## @brief Add the property (instance of BaseProperty) if it does
//## not exist (or always if \a overwrite is \a true)
//## with key @a propertyKey in the PropertyList
//## of the @a renderer (if NULL, use BaseRenderer-independent
//## PropertyList). This is set-by-value.
//##
//## For \a overwrite == \a false the property is \em not changed
//## if it already exists. For \a overwrite == \a true the method
//## is identical to SetProperty.
//##
//## @sa SetProperty
//## @sa GetProperty
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
void AddProperty(const char *propertyKey, BaseProperty* property, const mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
//##Documentation
//## @brief Get the PropertyList of the @a renderer. If @a renderer is @a
//## NULL, the BaseRenderer-independent PropertyList of this DataNode
//## is returned.
//## @sa GetProperty
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
mitk::PropertyList* GetPropertyList(const mitk::BaseRenderer* renderer = NULL) const;
//##Documentation
//## @brief Add values from another PropertyList.
//##
//## Overwrites values in m_PropertyList only when possible (i.e. when types are compatible).
//## If you want to allow for object type changes (replacing a "visible":BoolProperty with "visible":IntProperty,
//## set the @param replace.
//##
//## @param replace true: if @param pList contains a property "visible" of type ColorProperty and our m_PropertyList also has a "visible" property of a different type (e.g. BoolProperty), change the type, i.e. replace the objects behind the pointer.
//##
//## @sa SetProperty
//## @sa ReplaceProperty
//## @sa m_PropertyList
void ConcatenatePropertyList(PropertyList* pList, bool replace = false);
//##Documentation
//## @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList
//## of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
//##
//## If @a renderer is @a NULL or the @a propertyKey cannot be found
//## in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent
//## PropertyList of this DataNode is queried.
//## @sa GetPropertyList
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
mitk::BaseProperty* GetProperty(const char *propertyKey, const mitk::BaseRenderer* renderer = NULL) const;
//##Documentation
//## @brief Get the property of type T with key @a propertyKey from the PropertyList
//## of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
//##
//## If @a renderer is @a NULL or the @a propertyKey cannot be found
//## in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent
//## PropertyList of this DataNode is queried.
//## @sa GetPropertyList
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
template <typename T>
bool GetProperty(itk::SmartPointer<T> &property, const char *propertyKey, const mitk::BaseRenderer* renderer = NULL) const
{
property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
return property.IsNotNull();
}
//##Documentation
//## @brief Get the property of type T with key @a propertyKey from the PropertyList
//## of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
//##
//## If @a renderer is @a NULL or the @a propertyKey cannot be found
//## in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent
//## PropertyList of this DataNode is queried.
//## @sa GetPropertyList
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
template <typename T>
bool GetProperty(T* &property, const char *propertyKey, const mitk::BaseRenderer* renderer = NULL) const
{
property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
return property!=NULL;
}
//##Documentation
//## @brief Convenience access method for GenericProperty<T> properties
//## (T being the type of the second parameter)
//## @return @a true property was found
template <typename T>
bool GetPropertyValue(const char* propertyKey, T & value, mitk::BaseRenderer* renderer=NULL) const
{
GenericProperty<T>* gp= dynamic_cast<GenericProperty<T>*>(GetProperty(propertyKey, renderer));
if ( gp != NULL )
{
value = gp->GetValue();
return true;
}
return false;
}
// @brief Get a set of all group tags from this node's property list
GroupTagList GetGroupTags() const;
//##Documentation
//## @brief Convenience access method for bool properties (instances of
//## BoolProperty)
//## @return @a true property was found
bool GetBoolProperty(const char* propertyKey, bool &boolValue, mitk::BaseRenderer* renderer = NULL) const;
//##Documentation
//## @brief Convenience access method for int properties (instances of
//## IntProperty)
//## @return @a true property was found
bool GetIntProperty(const char* propertyKey, int &intValue, mitk::BaseRenderer* renderer=NULL) const;
//##Documentation
//## @brief Convenience access method for float properties (instances of
//## FloatProperty)
//## @return @a true property was found
bool GetFloatProperty(const char* propertyKey, float &floatValue, mitk::BaseRenderer* renderer = NULL) const;
//##Documentation
//## @brief Convenience access method for string properties (instances of
//## StringProperty)
//## @return @a true property was found
bool GetStringProperty(const char* propertyKey, std::string& string, mitk::BaseRenderer* renderer = NULL) const;
//##Documentation
//## @brief Convenience access method for color properties (instances of
//## ColorProperty)
//## @return @a true property was found
bool GetColor(float rgb[3], mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "color") const;
//##Documentation
//## @brief Convenience access method for level-window properties (instances of
//## LevelWindowProperty)
//## @return @a true property was found
bool GetLevelWindow(mitk::LevelWindow &levelWindow, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "levelwindow") const;
//##
//##Documentation
//## @brief set the node as selected
void SetSelected(bool selected, mitk::BaseRenderer* renderer=NULL);
//##
//##Documentation
//## @brief set the node as selected
//## @return @a true node is selected
bool IsSelected(mitk::BaseRenderer* renderer=NULL);
//##Documentation
//## @brief Convenience access method for accessing the name of an object (instance of
//## StringProperty with property-key "name")
//## @return @a true property was found
bool GetName(std::string& nodeName, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "name") const
{
return GetStringProperty(propertyKey, nodeName, renderer);
}
//##Documentation
//## @brief Extra convenience access method for accessing the name of an object (instance of
//## StringProperty with property-key "name").
//##
//## This method does not take the renderer specific
//## propertylists into account, because the name of an object should never be renderer specific.
//## @returns a std::string with the name of the object (content of "name" Property).
//## If there is no "name" Property, an empty string will be returned.
virtual std::string GetName() const
{
mitk::StringProperty* sp = dynamic_cast<mitk::StringProperty*>(this->GetProperty("name"));
if (sp == NULL)
return "";
return sp->GetValue();
}
//##Documentation
//## @brief Extra convenience access method to set the name of an object.
//##
//## The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name".
virtual void SetName( const char* name)
{
if (name == NULL)
return;
this->SetProperty("name", StringProperty::New(name));
}
//##Documentation
//## @brief Extra convenience access method to set the name of an object.
//##
//## The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name".
virtual void SetName( const std::string name)
{
this->SetName(name.c_str());
}
//##Documentation
//## @brief Convenience access method for visibility properties (instances
//## of BoolProperty with property-key "visible")
//## @return @a true property was found
//## @sa IsVisible
bool GetVisibility(bool &visible, mitk::BaseRenderer* renderer, const char* propertyKey = "visible") const
{
return GetBoolProperty(propertyKey, visible, renderer);
}
//##Documentation
//## @brief Convenience access method for opacity properties (instances of
//## FloatProperty)
//## @return @a true property was found
bool GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const char* propertyKey = "opacity") const;
//##Documentation
//## @brief Convenience access method for boolean properties (instances
//## of BoolProperty). Return value is the value of the property. If the property is
//## not found, the value of @a defaultIsOn is returned.
//##
//## Thus, the return value has a different meaning than in the
//## GetBoolProperty method!
//## @sa GetBoolProperty
bool IsOn(const char* propertyKey, mitk::BaseRenderer* renderer, bool defaultIsOn = true) const
{
if(propertyKey==NULL)
return defaultIsOn;
GetBoolProperty(propertyKey, defaultIsOn, renderer);
return defaultIsOn;
}
//##Documentation
//## @brief Convenience access method for visibility properties (instances
//## of BoolProperty). Return value is the visibility. Default is
//## visible==true, i.e., true is returned even if the property (@a
//## propertyKey) is not found.
//##
//## Thus, the return value has a different meaning than in the
//## GetVisibility method!
//## @sa GetVisibility
//## @sa IsOn
bool IsVisible(mitk::BaseRenderer* renderer, const char* propertyKey = "visible", bool defaultIsOn = true) const
{
return IsOn(propertyKey, renderer, defaultIsOn);
}
//##Documentation
//## @brief Convenience method for setting color properties (instances of
//## ColorProperty)
void SetColor(const mitk::Color &color, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "color");
//##Documentation
//## @brief Convenience method for setting color properties (instances of
//## ColorProperty)
void SetColor(float red, float green, float blue, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "color");
//##Documentation
//## @brief Convenience method for setting color properties (instances of
//## ColorProperty)
void SetColor(const float rgb[3], mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "color");
//##Documentation
//## @brief Convenience method for setting visibility properties (instances
//## of BoolProperty)
//## @param visible If set to true, the data will be rendered. If false, the render will skip this data.
//## @param renderer Specify a renderer if the visibility shall be specific to a renderer
//## @param propertykey Can be used to specify a user defined name of the visibility propery.
void SetVisibility(bool visible, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "visible");
//##Documentation
//## @brief Convenience method for setting opacity properties (instances of
//## FloatProperty)
void SetOpacity(float opacity, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "opacity");
//##Documentation
//## @brief Convenience method for setting level-window properties
//## (instances of LevelWindowProperty)
void SetLevelWindow(mitk::LevelWindow levelWindow, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "levelwindow");
//##Documentation
//## @brief Convenience method for setting int properties (instances of
//## IntProperty)
void SetIntProperty(const char* propertyKey, int intValue, mitk::BaseRenderer* renderer=NULL);
//##Documentation
//## @brief Convenience method for setting int properties (instances of
//## IntProperty)
void SetBoolProperty(const char* propertyKey, bool boolValue, mitk::BaseRenderer* renderer=NULL);
//##Documentation
//## @brief Convenience method for setting int properties (instances of
//## IntProperty)
void SetFloatProperty(const char* propertyKey, float floatValue, mitk::BaseRenderer* renderer=NULL);
//##Documentation
//## @brief Convenience method for setting int properties (instances of
//## IntProperty)
void SetStringProperty(const char* propertyKey, const char* string, mitk::BaseRenderer* renderer=NULL);
//##Documentation
//## @brief Get the timestamp of the last change of the contents of this node or
//## the referenced BaseData.
virtual unsigned long GetMTime() const;
//##Documentation
//## @brief Get the timestamp of the last change of the reference to the
//## BaseData.
unsigned long GetDataReferenceChangedTime() const
{
return m_DataReferenceChangedTime.GetMTime();
}
//##Documentation
//## @brief Adds or removes the associated interactor to mitk::GLobalInteraction.
//##
virtual void SetInteractorEnabled( const bool& enabled );
//##Documentation
//## @brief Adds the interactor to mitk::GlobalInteraction
//##
virtual void EnableInteractor();
//##Documentation
//## @brief Removes the Interactor from mitk::GlobalInteraction
//##
virtual void DisableInteractor();
//##Documentation
//## @brief Tests, if the interactor is already added to mitk::GlobalInteraction
//##
virtual bool IsInteractorEnabled() const;
protected:
DataNode();
virtual ~DataNode();
//##
//## Invoked when the property list was modified. Calls Modified() of the DataNode
virtual void PropertyListModified(const itk::Object *caller, const itk::EventObject &event);
//##Documentation
//## @brief Mapper-slots
mutable MapperVector m_Mappers;
//##Documentation
//## @brief The data object (instance of BaseData, e.g., an Image) managed
//## by this DataNode
BaseData::Pointer m_Data;
//##Documentation
//## @brief BaseRenderer-independent PropertyList
//##
//## Properties herein can be overwritten specifically for each BaseRenderer
//## by the BaseRenderer-specific properties defined in m_MapOfPropertyLists.
PropertyList::Pointer m_PropertyList;
//##Documentation
//## @brief Map associating each BaseRenderer with its own PropertyList
mutable MapOfPropertyLists m_MapOfPropertyLists;
//##Documentation
//## @brief Interactor, that handles the Interaction
Interactor::Pointer m_Interactor; // TODO: INTERACTION_LEGACY
DataInteractor::Pointer m_DataInteractor;
//##Documentation
//## @brief Timestamp of the last change of m_Data
itk::TimeStamp m_DataReferenceChangedTime;
unsigned long m_PropertyListModifiedObserverTag;
};
#if (_MSC_VER > 1200) || !defined(_MSC_VER)
MITK_CORE_EXPORT MBI_STD::istream& operator>>( MBI_STD::istream& i, DataNode::Pointer& dtn );
MITK_CORE_EXPORT MBI_STD::ostream& operator<<( MBI_STD::ostream& o, DataNode::Pointer& dtn);
#endif
} // namespace mitk
#if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
MITK_CORE_EXPORT MBI_STD::istream& operator>>( MBI_STD::istream& i, mitk::DataNode::Pointer& dtn );
MITK_CORE_EXPORT MBI_STD::ostream& operator<<( MBI_STD::ostream& o, mitk::DataNode::Pointer& dtn);
#endif
#endif /* DATATREENODE_H_HEADER_INCLUDED_C1E14338 */
diff --git a/Core/Code/DataManagement/mitkDataNodeFactory.cpp b/Core/Code/DataManagement/mitkDataNodeFactory.cpp
index d1cc2c92c8..aefff0c901 100644
--- a/Core/Code/DataManagement/mitkDataNodeFactory.cpp
+++ b/Core/Code/DataManagement/mitkDataNodeFactory.cpp
@@ -1,492 +1,490 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkConfig.h>
#include <mitkDataNodeFactory.h>
#include <mitkBaseDataIOFactory.h>
#include <mitkCoreObjectFactory.h>
#include <mitkITKImageImport.h>
// C-Standard library includes
#include <stdlib.h>
#include <locale.h>
// STL-related includes
#include <vector>
#include <map>
#include <istream>
#include <cstdlib>
#include <locale>
// VTK-related includes
#include <vtkSTLReader.h>
#include <vtkOBJReader.h>
#include <vtkPolyData.h>
#include <vtkPolyDataNormals.h>
#include <vtkDataReader.h>
#include <vtkPolyDataReader.h>
#include <vtkStructuredPointsReader.h>
#include <vtkStructuredPoints.h>
#include <vtkLookupTable.h>
#include <vtkPointData.h>
#include <vtkXMLImageDataReader.h>
// ITK-related includes
#include <itksys/SystemTools.hxx>
#include <itksys/Directory.hxx>
#include <itkImage.h>
#include <itkImageSeriesReader.h>
#include <itkImageFileReader.h>
#include <itkImageIOFactory.h>
#include <itkImageIORegion.h>
#include <itkImageSeriesReader.h>
-#include <itkDICOMImageIO2.h>
-#include <itkDICOMSeriesFileNames.h>
#include <itkGDCMImageIO.h>
#ifdef NOMINMAX
# define DEF_NOMINMAX
# undef NOMINMAX
#endif
#include <itkGDCMSeriesFileNames.h>
#ifdef DEF_NOMINMAX
# ifndef NOMINMAX
# define NOMINMAX
# endif
# undef DEF_NOMINMAX
#endif
#include <itkNumericSeriesFileNames.h>
#include <itkCommand.h>
// MITK-related includes
#include "mitkSurface.h"
#include "mitkPointSet.h"
#include "mitkStringProperty.h"
#include "mitkProperties.h"
//#include "mitkMaterialProperty.h"
#include "mitkLevelWindowProperty.h"
#include "mitkVtkRepresentationProperty.h"
#include "mitkVtkInterpolationProperty.h"
#include "mitkVtkScalarModeProperty.h"
#include "mitkImage.h"
#include "mitkLookupTableProperty.h"
#include "mitkLookupTable.h"
#include "mitkImageChannelSelector.h"
#include "mitkImageSliceSelector.h"
#include "mitkCoreObjectFactory.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include "mitkProgressBar.h"
#include <mitkDicomSeriesReader.h>
bool mitk::DataNodeFactory::m_TextureInterpolationActive = false; // default value for texture interpolation if nothing is defined in global options (see QmitkMainTemplate.ui.h)
mitk::DataNodeFactory::DataNodeFactory()
{
m_Serie = false;
m_OldProgress = 0;
this->Modified();
//ensure that a CoreObjectFactory has been instantiated
mitk::CoreObjectFactory::GetInstance();
}
mitk::DataNodeFactory::~DataNodeFactory()
{}
void mitk::DataNodeFactory::SetImageSerie(bool serie)
{
m_Serie = serie;
}
void mitk::DataNodeFactory::GenerateData()
{
// IF filename is something.pic, and something.pic does not exist, try to read something.pic.gz
// if there are both, something.pic and something.pic.gz, only the requested file is read
// not only for images, but for all formats
std::ifstream exists(m_FileName.c_str());
if (!exists)
{
std::string testfilename = m_FileName + ".gz";
std::ifstream exists(testfilename.c_str());
if (exists.good())
{
m_FileName += ".gz";
}
else
{
testfilename = m_FileName + ".GZ";
std::ifstream exists(testfilename.c_str());
if (exists.good())
{
m_FileName += ".GZ";
}
else
{
std::string message("File does not exist, or cannot be read. Filename = ");
message += m_FileName;
MITK_ERROR << message;
itkExceptionMacro( << message );
}
}
}
// part for DICOM
// const char *numbers = "0123456789.";
// std::string::size_type first_non_number;
// first_non_number = itksys::SystemTools::GetFilenameName(m_FileName).find_first_not_of ( numbers );
if (DicomSeriesReader::IsDicom(this->m_FileName) /*|| first_non_number == std::string::npos*/)
{
this->ReadFileSeriesTypeDCM();
}
else
{
bool usedNewDTNF = false;
// the mitkBaseDataIO class returns a pointer of a vector of BaseData objects
std::vector<mitk::BaseData::Pointer> baseDataVector = mitk::BaseDataIO::LoadBaseDataFromFile( m_FileName, m_FilePrefix, m_FilePattern, m_Serie );
if( !baseDataVector.empty() )
this->ResizeOutputs((unsigned int)baseDataVector.size());
for(int i=0; i<(int)baseDataVector.size(); i++)
{
mitk::BaseData::Pointer baseData = baseDataVector.at(i);
if( baseData.IsNotNull() )
{
usedNewDTNF = true;
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(baseData);
this->SetDefaultCommonProperties( node );
- this->SetOutput(i, node);
+ this->SetOutput(this->MakeNameFromOutputIndex(i), node);
}
}
if(!usedNewDTNF && ( m_FileName != "" ) && !(m_Serie == false))
ReadFileSeriesTypeITKImageSeriesReader();
}
}
void mitk::DataNodeFactory::ResizeOutputs( const unsigned int& num )
{
unsigned int prevNum = this->GetNumberOfOutputs();
- this->SetNumberOfOutputs( num );
+ this->SetNumberOfIndexedOutputs( num );
for ( unsigned int i = prevNum; i < num; ++i )
{
this->SetNthOutput( i, this->MakeOutput( i ).GetPointer() );
}
}
bool mitk::DataNodeFactory::FileNameEndsWith( const std::string& name )
{
if (m_FileName.size() < name.size()) return false;
return m_FileName.substr(m_FileName.size() - name.size()) == name;
}
bool mitk::DataNodeFactory::FilePatternEndsWith( const std::string& name )
{
return m_FilePattern.find( name ) != std::string::npos;
}
std::string mitk::DataNodeFactory::GetBaseFileName()
{
return itksys::SystemTools::GetFilenameName( m_FileName );
}
std::string mitk::DataNodeFactory::GetBaseFilePrefix()
{
return itksys::SystemTools::GetFilenameName( m_FilePrefix );
}
std::string mitk::DataNodeFactory::GetDirectory()
{
if ( !m_FileName.empty() ) return itksys::SystemTools::GetFilenamePath( m_FileName );
if ( !m_FilePrefix.empty() ) return itksys::SystemTools::GetFilenamePath( m_FilePrefix );
return std::string();
}
void mitk::DataNodeFactory::ReadFileSeriesTypeDCM()
{
const char* previousCLocale = setlocale(LC_NUMERIC, NULL);
setlocale(LC_NUMERIC, "C");
std::locale previousCppLocale( std::cin.getloc() );
std::locale l( "C" );
std::cin.imbue(l);
if ( DicomSeriesReader::IsPhilips3DDicom(this->GetFileName()) )
{
MITK_INFO << "it is a Philips3D US Dicom file" << std::endl;
this->ResizeOutputs(1);
- DataNode::Pointer node = this->GetOutput(0);
+ DataNode::Pointer node = this->GetOutput();
mitk::DicomSeriesReader::StringContainer stringvec;
stringvec.push_back(this->GetFileName());
if (DicomSeriesReader::LoadDicomSeries(stringvec, *node))
{
node->SetName(this->GetBaseFileName());
}
setlocale(LC_NUMERIC, previousCLocale);
std::cin.imbue(previousCppLocale);
return;
}
DicomSeriesReader::FileNamesGrouping imageBlocks = DicomSeriesReader::GetSeries(this->GetDirectory(), true, this->m_SeriesRestrictions); // true = group gantry tilt images
const unsigned int size = imageBlocks.size();
this->ResizeOutputs(size);
ProgressBar::GetInstance()->AddStepsToDo(size);
ProgressBar::GetInstance()->Progress();
unsigned int outputIndex = 0u;
const DicomSeriesReader::FileNamesGrouping::const_iterator n_end = imageBlocks.end();
for (DicomSeriesReader::FileNamesGrouping::const_iterator n_it = imageBlocks.begin(); n_it != n_end; ++n_it)
{
const std::string &uid = n_it->first;
DataNode::Pointer node = this->GetOutput(outputIndex);
const DicomSeriesReader::ImageBlockDescriptor& imageBlockDescriptor( n_it->second );
MITK_INFO << "--------------------------------------------------------------------------------";
MITK_INFO << "DataNodeFactory: Loading DICOM series " << outputIndex << ": Series UID " << imageBlockDescriptor.GetSeriesInstanceUID() << std::endl;
MITK_INFO << " " << imageBlockDescriptor.GetFilenames().size() << " '" << imageBlockDescriptor.GetModality() << "' files (" << imageBlockDescriptor.GetSOPClassUIDAsString() << ") loaded into 1 mitk::Image";
MITK_INFO << " multi-frame: " << (imageBlockDescriptor.IsMultiFrameImage()?"Yes":"No");
MITK_INFO << " reader support: " << DicomSeriesReader::ReaderImplementationLevelToString(imageBlockDescriptor.GetReaderImplementationLevel());
MITK_INFO << " pixel spacing type: " << DicomSeriesReader::PixelSpacingInterpretationToString( imageBlockDescriptor.GetPixelSpacingType() );
MITK_INFO << " gantry tilt corrected: " << (imageBlockDescriptor.HasGantryTiltCorrected()?"Yes":"No");
MITK_INFO << " 3D+t: " << (imageBlockDescriptor.HasMultipleTimePoints()?"Yes":"No");
MITK_INFO << "--------------------------------------------------------------------------------";
if (DicomSeriesReader::LoadDicomSeries(n_it->second.GetFilenames(), *node, true, true, true))
{
std::string nodeName(uid);
std::string studyDescription;
if ( node->GetStringProperty( "dicom.study.StudyDescription", studyDescription ) )
{
nodeName = studyDescription;
std::string seriesDescription;
if ( node->GetStringProperty( "dicom.series.SeriesDescription", seriesDescription ) )
{
nodeName += "/" + seriesDescription;
}
}
node->SetName(nodeName);
++outputIndex;
}
else
{
MITK_ERROR << "DataNodeFactory: Skipping series " << outputIndex << " due to some unspecified error..." << std::endl;
}
ProgressBar::GetInstance()->Progress();
}
setlocale(LC_NUMERIC, previousCLocale);
std::cin.imbue(previousCppLocale);
}
void mitk::DataNodeFactory::ReadFileSeriesTypeITKImageSeriesReader()
{
typedef itk::Image<int, 3> ImageType;
typedef itk::ImageSeriesReader< ImageType > ReaderType;
typedef itk::NumericSeriesFileNames NameGenerator;
if ( ! this->GenerateFileList() )
{
itkWarningMacro( "Sorry, file list could not be generated!" );
return ;
}
if ( m_MatchedFileNames.size() == 0 )
{
itkWarningMacro( "Sorry, no files matched the given filename ("<< m_FileName <<")!" );
return ;
}
//
// Finally, initialize the ITK-reader and load the files!
//
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileNames( m_MatchedFileNames );
try
{
reader->Update();
ResizeOutputs( reader->GetNumberOfOutputs() );
for ( unsigned int i = 0; i < reader->GetNumberOfOutputs(); ++i )
{
//Initialize mitk image from itk
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk( reader->GetOutput( i ) );
image->SetVolume( reader->GetOutput( i )->GetBufferPointer() );
//add the mitk image to the node
mitk::DataNode::Pointer node = this->GetOutput( i );
node->SetData( image );
mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( m_FileName );
node->SetProperty( "name", nameProp );
}
}
catch ( const std::exception & e )
{
itkWarningMacro( << e.what() );
return ;
}
}
mitk::ColorProperty::Pointer mitk::DataNodeFactory::DefaultColorForOrgan( const std::string& organ )
{
static bool initialized = false;
static std::map< std::string, std::string > s_ColorMap;
if (!initialized)
{
// all lowercase here, please!
s_ColorMap.insert( std::make_pair( "ankle", "0xe38686") );
s_ColorMap.insert( std::make_pair( "appendix", "0xe38686") );
s_ColorMap.insert( std::make_pair( "blood vessels", "0xff3131") );
s_ColorMap.insert( std::make_pair( "bronchial tree", "0x3168ff") );
s_ColorMap.insert( std::make_pair( "bone", "0xd5d5d5") );
s_ColorMap.insert( std::make_pair( "brain", "0xff9cca") );
s_ColorMap.insert( std::make_pair( "coccyx", "0xe38686") );
s_ColorMap.insert( std::make_pair( "colon", "0xe38686") );
s_ColorMap.insert( std::make_pair( "cyst", "0xe38686") );
s_ColorMap.insert( std::make_pair( "elbow", "0xe38686") );
s_ColorMap.insert( std::make_pair( "eye", "0xe38686") );
s_ColorMap.insert( std::make_pair( "fallopian tube", "0xe38686") );
s_ColorMap.insert( std::make_pair( "fat", "0xff2bee") );
s_ColorMap.insert( std::make_pair( "hand", "0xe38686") );
s_ColorMap.insert( std::make_pair( "gall bladder", "0x567f18") );
s_ColorMap.insert( std::make_pair( "heart", "0xeb1d32") );
s_ColorMap.insert( std::make_pair( "hip", "0xe38686") );
s_ColorMap.insert( std::make_pair( "kidney", "0xd33f00") );
s_ColorMap.insert( std::make_pair( "knee", "0xe38686") );
s_ColorMap.insert( std::make_pair( "larynx", "0xe38686") );
s_ColorMap.insert( std::make_pair( "liver", "0xffcc3d") );
s_ColorMap.insert( std::make_pair( "lung", "0x6bdcff") );
s_ColorMap.insert( std::make_pair( "lymph node", "0xff0000") );
s_ColorMap.insert( std::make_pair( "muscle", "0xff456a") );
s_ColorMap.insert( std::make_pair( "nerve", "0xffea4f") );
s_ColorMap.insert( std::make_pair( "nose", "0xe38686") );
s_ColorMap.insert( std::make_pair( "oesophagus", "0xe38686") );
s_ColorMap.insert( std::make_pair( "ovaries", "0xe38686") );
s_ColorMap.insert( std::make_pair( "pancreas", "0xf9ab3d") );
s_ColorMap.insert( std::make_pair( "pelvis", "0xe38686") );
s_ColorMap.insert( std::make_pair( "penis", "0xe38686") );
s_ColorMap.insert( std::make_pair( "pharynx", "0xe38686") );
s_ColorMap.insert( std::make_pair( "prostate", "0xe38686") );
s_ColorMap.insert( std::make_pair( "rectum", "0xe38686") );
s_ColorMap.insert( std::make_pair( "sacrum", "0xe38686") );
s_ColorMap.insert( std::make_pair( "seminal vesicle", "0xe38686") );
s_ColorMap.insert( std::make_pair( "shoulder", "0xe38686") );
s_ColorMap.insert( std::make_pair( "spinal cord", "0xf5f93d") );
s_ColorMap.insert( std::make_pair( "spleen", "0xf96c3d") );
s_ColorMap.insert( std::make_pair( "stomach", "0xf96c3d") );
s_ColorMap.insert( std::make_pair( "teeth", "0xfffcd8") );
s_ColorMap.insert( std::make_pair( "testicles", "0xe38686") );
s_ColorMap.insert( std::make_pair( "thyroid", "0xfff694") );
s_ColorMap.insert( std::make_pair( "tongue", "0xe38686") );
s_ColorMap.insert( std::make_pair( "tumor", "0x937011") );
s_ColorMap.insert( std::make_pair( "urethra", "0xf8ff32") );
s_ColorMap.insert( std::make_pair( "urinary bladder", "0xf8ff32") );
s_ColorMap.insert( std::make_pair( "uterus", "0xe38686") );
s_ColorMap.insert( std::make_pair( "vagina", "0xe38686") );
s_ColorMap.insert( std::make_pair( "vertebra", "0xe38686") );
s_ColorMap.insert( std::make_pair( "wrist", "0xe38686") );
initialized = true;
}
std::string lowercaseOrgan(organ);
for(unsigned int i = 0; i < organ.length(); i++)
{
lowercaseOrgan[i] = tolower(lowercaseOrgan[i]);
}
std::map< std::string, std::string >::iterator iter = s_ColorMap.find( lowercaseOrgan );
if ( iter != s_ColorMap.end() )
{
std::string hexColor = iter->second;
std::string hexRed = std::string("0x") + hexColor.substr( 2, 2 );
std::string hexGreen = std::string("0x") + hexColor.substr( 4, 2 );
std::string hexBlue = std::string("0x") + hexColor.substr( 6, 2 );
long int red = strtol( hexRed.c_str(), NULL, 16 );
long int green = strtol( hexGreen.c_str(), NULL, 16 );
long int blue = strtol( hexBlue.c_str(), NULL, 16 );
return ColorProperty::New( (float)red/ 255.0, (float)green/ 255.0, (float)blue/ 255.0 );
}
else
{
// a default color (green)
return ColorProperty::New( 0.0, 1.0, 0.0 );
}
}
void mitk::DataNodeFactory::SetDefaultCommonProperties(mitk::DataNode::Pointer &node)
{
// path
mitk::StringProperty::Pointer pathProp = mitk::StringProperty::New( itksys::SystemTools::GetFilenamePath( m_FileName ) );
node->SetProperty( StringProperty::PATH, pathProp );
// name already defined?
mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(node->GetProperty("name"));
if(nameProp.IsNull() || (strcmp(nameProp->GetValue(),"No Name!")==0))
{
// name already defined in BaseData
mitk::StringProperty::Pointer baseDataNameProp = dynamic_cast<mitk::StringProperty*>(node->GetData()->GetProperty("name").GetPointer() );
if(baseDataNameProp.IsNull() || (strcmp(baseDataNameProp->GetValue(),"No Name!")==0))
{
// name neither defined in node, nor in BaseData -> name = filename
if (FileNameEndsWith( ".gz" ))
m_FileName = m_FileName.substr( 0, m_FileName.length()-3 );
nameProp = mitk::StringProperty::New( itksys::SystemTools::GetFilenameWithoutLastExtension( m_FileName ) );
node->SetProperty( "name", nameProp );
}
else
{
// name defined in BaseData!
nameProp = mitk::StringProperty::New( baseDataNameProp->GetValue() );
node->SetProperty( "name", nameProp );
}
}
// visibility
if(!node->GetProperty("visible"))
node->SetVisibility(true);
}
diff --git a/Core/Code/DataManagement/mitkDisplayGeometry.cpp b/Core/Code/DataManagement/mitkDisplayGeometry.cpp
index 518a99ca0a..c3ba22a36a 100644
--- a/Core/Code/DataManagement/mitkDisplayGeometry.cpp
+++ b/Core/Code/DataManagement/mitkDisplayGeometry.cpp
@@ -1,635 +1,635 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkDisplayGeometry.h"
-mitk::AffineGeometryFrame3D::Pointer mitk::DisplayGeometry::Clone() const
+itk::LightObject::Pointer mitk::DisplayGeometry::InternalClone() const
{
itkExceptionMacro(<<"calling mitk::DisplayGeometry::Clone does not make much sense.");
}
bool mitk::DisplayGeometry::IsValid() const
{
return m_Valid && m_WorldGeometry.IsNotNull() && m_WorldGeometry->IsValid();
}
unsigned long mitk::DisplayGeometry::GetMTime() const
{
if((m_WorldGeometry.IsNotNull()) && (Geometry2D::GetMTime() < m_WorldGeometry->GetMTime()))
{
Modified();
}
return Geometry2D::GetMTime();
}
const mitk::TimeBounds& mitk::DisplayGeometry::GetTimeBounds() const
{
if(m_WorldGeometry.IsNull())
{
return m_TimeBounds;
}
return m_WorldGeometry->GetTimeBounds();
}
// size definition methods
void mitk::DisplayGeometry::SetWorldGeometry(const Geometry2D* aWorldGeometry)
{
m_WorldGeometry = aWorldGeometry;
Modified();
}
bool mitk::DisplayGeometry::SetOriginInMM(const Vector2D& origin_mm)
{
m_OriginInMM = origin_mm;
WorldToDisplay(m_OriginInMM, m_OriginInDisplayUnits);
Modified();
return !this->RefitVisibleRect();
}
mitk::Vector2D mitk::DisplayGeometry::GetOriginInMM() const
{
return m_OriginInMM;
}
mitk::Vector2D mitk::DisplayGeometry::GetOriginInDisplayUnits() const
{
return m_OriginInDisplayUnits;
}
void mitk::DisplayGeometry::SetSizeInDisplayUnits(unsigned int width, unsigned int height, bool keepDisplayedRegion)
{
Vector2D oldSizeInMM( m_SizeInMM );
Point2D oldCenterInMM;
if(keepDisplayedRegion)
{
Point2D centerInDisplayUnits;
centerInDisplayUnits[0] = m_SizeInDisplayUnits[0]*0.5;
centerInDisplayUnits[1] = m_SizeInDisplayUnits[1]*0.5;
DisplayToWorld(centerInDisplayUnits, oldCenterInMM);
}
m_SizeInDisplayUnits[0]=width;
m_SizeInDisplayUnits[1]=height;
if(m_SizeInDisplayUnits[0] <= 0)
m_SizeInDisplayUnits[0] = 1;
if(m_SizeInDisplayUnits[1] <= 0)
m_SizeInDisplayUnits[1] = 1;
DisplayToWorld(m_SizeInDisplayUnits, m_SizeInMM);
if(keepDisplayedRegion)
{
Point2D positionOfOldCenterInCurrentDisplayUnits;
WorldToDisplay(oldCenterInMM, positionOfOldCenterInCurrentDisplayUnits);
Point2D currentNewCenterInDisplayUnits;
currentNewCenterInDisplayUnits[0] = m_SizeInDisplayUnits[0]*0.5;
currentNewCenterInDisplayUnits[1] = m_SizeInDisplayUnits[1]*0.5;
Vector2D shift;
shift=positionOfOldCenterInCurrentDisplayUnits.GetVectorFromOrigin()-currentNewCenterInDisplayUnits;
MoveBy(shift);
Zoom(m_SizeInMM.GetNorm()/oldSizeInMM.GetNorm(), currentNewCenterInDisplayUnits);
}
Modified();
}
mitk::Vector2D mitk::DisplayGeometry::GetSizeInDisplayUnits() const
{
return m_SizeInDisplayUnits;
}
mitk::Vector2D mitk::DisplayGeometry::GetSizeInMM() const
{
return m_SizeInMM;
}
unsigned int mitk::DisplayGeometry::GetDisplayWidth() const
{
assert(m_SizeInDisplayUnits[0] >= 0);
return (unsigned int)m_SizeInDisplayUnits[0];
}
unsigned int mitk::DisplayGeometry::GetDisplayHeight() const
{
assert(m_SizeInDisplayUnits[1] >= 0);
return (unsigned int)m_SizeInDisplayUnits[1];
}
// zooming, panning, restriction of both
void mitk::DisplayGeometry::SetConstrainZoomingAndPanning(bool constrain)
{
m_ConstrainZoomingAndPanning = constrain;
if (m_ConstrainZoomingAndPanning)
{
this->RefitVisibleRect();
}
}
bool mitk::DisplayGeometry::GetConstrainZommingAndPanning() const
{
return m_ConstrainZoomingAndPanning;
}
bool mitk::DisplayGeometry::SetScaleFactor(ScalarType mmPerDisplayUnit)
{
if(mmPerDisplayUnit<0.0001)
{
mmPerDisplayUnit=0.0001;
}
m_ScaleFactorMMPerDisplayUnit = mmPerDisplayUnit;
assert(m_ScaleFactorMMPerDisplayUnit < ScalarTypeNumericTraits::infinity());
DisplayToWorld(m_SizeInDisplayUnits, m_SizeInMM);
return !this->RefitVisibleRect();
}
mitk::ScalarType mitk::DisplayGeometry::GetScaleFactorMMPerDisplayUnit() const
{
return m_ScaleFactorMMPerDisplayUnit;
}
// Zooms with a factor (1.0=identity) around the specified center in display units
bool mitk::DisplayGeometry::Zoom(ScalarType factor, const Point2D& centerInDisplayUnits)
{
assert(factor > 0);
if ( SetScaleFactor(m_ScaleFactorMMPerDisplayUnit/factor) )
{
return SetOriginInMM(m_OriginInMM-centerInDisplayUnits.GetVectorFromOrigin()*(1-factor)*m_ScaleFactorMMPerDisplayUnit);
}
else
{
return false;
}
}
// Zooms with a factor (1.0=identity) around the specified center, but tries (if its within view contraints) to match the center in display units with the center in world coordinates.
bool mitk::DisplayGeometry::ZoomWithFixedWorldCoordinates(ScalarType factor, const Point2D& focusDisplayUnits, const Point2D& focusUnitsInMM )
{
assert(factor > 0);
SetScaleFactor(m_ScaleFactorMMPerDisplayUnit/factor);
SetOriginInMM(focusUnitsInMM.GetVectorFromOrigin()-focusDisplayUnits.GetVectorFromOrigin()*m_ScaleFactorMMPerDisplayUnit);
return true;
}
bool mitk::DisplayGeometry::MoveBy(const Vector2D& shiftInDisplayUnits)
{
SetOriginInMM(m_OriginInMM+shiftInDisplayUnits*m_ScaleFactorMMPerDisplayUnit);
Modified();
return !this->RefitVisibleRect();
}
void mitk::DisplayGeometry::Fit()
{
if((m_WorldGeometry.IsNull()) || (m_WorldGeometry->IsValid() == false)) return;
/// \FIXME: try to remove all the casts
int width=(int)m_SizeInDisplayUnits[0];
int height=(int)m_SizeInDisplayUnits[1];
ScalarType w = width;
ScalarType h = height;
const ScalarType& widthInMM = m_WorldGeometry->GetParametricExtentInMM(0);
const ScalarType& heightInMM = m_WorldGeometry->GetParametricExtentInMM(1);
ScalarType aspRatio=((ScalarType)widthInMM)/heightInMM;
ScalarType x = (ScalarType)w/widthInMM;
ScalarType y = (ScalarType)h/heightInMM;
if (x > y)
{
w = (int) (aspRatio*h);
}
else
{
h = (int) (w/aspRatio);
}
if(w>0)
{
SetScaleFactor(widthInMM/w);
}
Vector2D origin_display;
origin_display[0]=-(width-w)/2.0;
origin_display[1]=-(height-h)/2.0;
SetOriginInMM(origin_display*m_ScaleFactorMMPerDisplayUnit);
this->RefitVisibleRect();
Modified();
}
// conversion methods
void mitk::DisplayGeometry::DisplayToWorld(const Point2D &pt_display, Point2D &pt_mm) const
{
pt_mm[0]=m_ScaleFactorMMPerDisplayUnit*pt_display[0]+m_OriginInMM[0];
pt_mm[1]=m_ScaleFactorMMPerDisplayUnit*pt_display[1]+m_OriginInMM[1];
}
void mitk::DisplayGeometry::WorldToDisplay(const Point2D &pt_mm, Point2D &pt_display) const
{
pt_display[0]=(pt_mm[0]-m_OriginInMM[0])*(1.0/m_ScaleFactorMMPerDisplayUnit);
pt_display[1]=(pt_mm[1]-m_OriginInMM[1])*(1.0/m_ScaleFactorMMPerDisplayUnit);
}
void mitk::DisplayGeometry::DisplayToWorld(const Vector2D &vec_display, Vector2D &vec_mm) const
{
vec_mm=vec_display*m_ScaleFactorMMPerDisplayUnit;
}
void mitk::DisplayGeometry::WorldToDisplay(const Vector2D &vec_mm, Vector2D &vec_display) const
{
vec_display=vec_mm*(1.0/m_ScaleFactorMMPerDisplayUnit);
}
void mitk::DisplayGeometry::ULDisplayToMM(const Point2D &pt_ULdisplay, Point2D &pt_mm) const
{
ULDisplayToDisplay(pt_ULdisplay, pt_mm);
DisplayToWorld(pt_mm, pt_mm);
}
void mitk::DisplayGeometry::MMToULDisplay(const Point2D &pt_mm, Point2D &pt_ULdisplay) const
{
WorldToDisplay(pt_mm, pt_ULdisplay);
DisplayToULDisplay(pt_ULdisplay, pt_ULdisplay);
}
void mitk::DisplayGeometry::ULDisplayToMM(const Vector2D &vec_ULdisplay, Vector2D &vec_mm) const
{
ULDisplayToDisplay(vec_ULdisplay, vec_mm);
DisplayToWorld(vec_mm, vec_mm);
}
void mitk::DisplayGeometry::MMToULDisplay(const Vector2D &vec_mm, Vector2D &vec_ULdisplay) const
{
WorldToDisplay(vec_mm, vec_ULdisplay);
DisplayToULDisplay(vec_ULdisplay, vec_ULdisplay);
}
void mitk::DisplayGeometry::ULDisplayToDisplay(const Point2D &pt_ULdisplay, Point2D &pt_display) const
{
pt_display[0]=pt_ULdisplay[0];
pt_display[1]=GetDisplayHeight()-pt_ULdisplay[1];
}
void mitk::DisplayGeometry::DisplayToULDisplay(const Point2D &pt_display, Point2D &pt_ULdisplay) const
{
ULDisplayToDisplay(pt_display, pt_ULdisplay);
}
void mitk::DisplayGeometry::ULDisplayToDisplay(const Vector2D &vec_ULdisplay, Vector2D &vec_display) const
{
vec_display[0]= vec_ULdisplay[0];
vec_display[1]=-vec_ULdisplay[1];
}
void mitk::DisplayGeometry::DisplayToULDisplay(const Vector2D &vec_display, Vector2D &vec_ULdisplay) const
{
ULDisplayToDisplay(vec_display, vec_ULdisplay);
}
bool mitk::DisplayGeometry::Project(const Point3D &pt3d_mm, Point3D &projectedPt3d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Project(pt3d_mm, projectedPt3d_mm);
}
else
{
return false;
}
}
bool mitk::DisplayGeometry::Project(const Point3D & atPt3d_mm, const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Project(atPt3d_mm, vec3d_mm, projectedVec3d_mm);
}
else
{
return false;
}
}
bool mitk::DisplayGeometry::Project(const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Project(vec3d_mm, projectedVec3d_mm);
}
else
{
return false;
}
}
bool mitk::DisplayGeometry::Map(const Point3D &pt3d_mm, Point2D &pt2d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Map(pt3d_mm, pt2d_mm);
}
else
{
return false;
}
}
void mitk::DisplayGeometry::Map(const Point2D &pt2d_mm, Point3D &pt3d_mm) const
{
if(m_WorldGeometry.IsNull()) return;
m_WorldGeometry->Map(pt2d_mm, pt3d_mm);
}
bool mitk::DisplayGeometry::Map(const Point3D & atPt3d_mm, const Vector3D &vec3d_mm, Vector2D &vec2d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Map(atPt3d_mm, vec3d_mm, vec2d_mm);
}
else
{
return false;
}
}
void mitk::DisplayGeometry::Map(const Point2D & atPt2d_mm, const Vector2D &vec2d_mm, Vector3D &vec3d_mm) const
{
if(m_WorldGeometry.IsNull()) return;
m_WorldGeometry->Map(atPt2d_mm, vec2d_mm, vec3d_mm);
}
// protected methods
mitk::DisplayGeometry::DisplayGeometry()
:m_ScaleFactorMMPerDisplayUnit(1.0)
,m_WorldGeometry(NULL)
,m_ConstrainZoomingAndPanning(true)
,m_MaxWorldViewPercentage(1.0)
,m_MinWorldViewPercentage(0.1)
{
m_OriginInMM.Fill(0.0);
m_OriginInDisplayUnits.Fill(0.0);
m_SizeInMM.Fill(1.0);
m_SizeInDisplayUnits.Fill(10.0);
}
mitk::DisplayGeometry::~DisplayGeometry()
{
}
bool mitk::DisplayGeometry::RefitVisibleRect()
{
// do nothing if not asked to
if (!m_ConstrainZoomingAndPanning) return false;
// don't allow recursion (need to be fixed, singleton)
static bool inRecalculate = false;
if (inRecalculate) return false;
inRecalculate = true;
// rename some basic measures of the current viewport and world geometry (MM = milimeters Px = Pixels = display units)
float displayXMM = m_OriginInMM[0];
float displayYMM = m_OriginInMM[1];
float displayWidthPx = m_SizeInDisplayUnits[0];
float displayHeightPx = m_SizeInDisplayUnits[1];
float displayWidthMM = m_SizeInDisplayUnits[0] * m_ScaleFactorMMPerDisplayUnit;
float displayHeightMM = m_SizeInDisplayUnits[1] * m_ScaleFactorMMPerDisplayUnit;
float worldWidthMM = m_WorldGeometry->GetParametricExtentInMM(0);
float worldHeightMM = m_WorldGeometry->GetParametricExtentInMM(1);
// reserve variables for the correction logic to save a corrected origin and zoom factor
Vector2D newOrigin = m_OriginInMM;
bool correctPanning = false;
float newScaleFactor = m_ScaleFactorMMPerDisplayUnit;
bool correctZooming = false;
// start of the correction logic
// zoom to big means:
// at a given percentage of the world's width/height should be visible. Otherwise
// the whole screen could show only one pixel
//
// zoom to small means:
// zooming out should be limited at the point where the smaller of the world's sides is completely visible
bool zoomXtooSmall = displayWidthPx * m_ScaleFactorMMPerDisplayUnit > m_MaxWorldViewPercentage * worldWidthMM;
bool zoomXtooBig = displayWidthPx * m_ScaleFactorMMPerDisplayUnit < m_MinWorldViewPercentage * worldWidthMM;
bool zoomYtooSmall = displayHeightPx * m_ScaleFactorMMPerDisplayUnit > m_MaxWorldViewPercentage * worldHeightMM;
bool zoomYtooBig = displayHeightPx * m_ScaleFactorMMPerDisplayUnit < m_MinWorldViewPercentage * worldHeightMM;
// constrain zooming in both direction
if ( zoomXtooBig && zoomYtooBig)
{
double fx = worldWidthMM * m_MinWorldViewPercentage / displayWidthPx;
double fy = worldHeightMM * m_MinWorldViewPercentage / displayHeightPx;
newScaleFactor = fx < fy ? fx : fy;
correctZooming = true;
}
// constrain zooming in x direction
else if ( zoomXtooBig )
{
newScaleFactor = worldWidthMM * m_MinWorldViewPercentage / displayWidthPx;
correctZooming = true;
}
// constrain zooming in y direction
else if ( zoomYtooBig )
{
newScaleFactor = worldHeightMM * m_MinWorldViewPercentage / displayHeightPx;
correctZooming = true;
}
// constrain zooming out
// we stop zooming out at these situations:
//
// *** display
// --- image
//
// **********************
// * * x side maxed out
// * *
// *--------------------*
// *| |*
// *| |*
// *--------------------*
// * *
// * *
// * *
// **********************
//
// **********************
// * |------| * y side maxed out
// * | | *
// * | | *
// * | | *
// * | | *
// * | | *
// * | | *
// * | | *
// * |------| *
// **********************
//
// In both situations we center the not-maxed out direction
//
if ( zoomXtooSmall && zoomYtooSmall )
{
// determine and set the bigger scale factor
float fx = worldWidthMM * m_MaxWorldViewPercentage / displayWidthPx;
float fy = worldHeightMM * m_MaxWorldViewPercentage / displayHeightPx;
newScaleFactor = fx > fy ? fx : fy;
correctZooming = true;
}
// actually execute correction
if (correctZooming)
{
SetScaleFactor(newScaleFactor);
}
displayWidthMM = m_SizeInDisplayUnits[0] * m_ScaleFactorMMPerDisplayUnit;
displayHeightMM = m_SizeInDisplayUnits[1] * m_ScaleFactorMMPerDisplayUnit;
// constrain panning
if(worldWidthMM<displayWidthMM)
{
// zoomed out too much in x (but tolerated because y is still ok)
// --> center x
newOrigin[0] = (worldWidthMM - displayWidthMM) / 2.0;
correctPanning = true;
}
else
{
// make sure left display border inside our world
if (displayXMM < 0)
{
newOrigin[0] = 0;
correctPanning = true;
}
// make sure right display border inside our world
else if (displayXMM + displayWidthMM > worldWidthMM)
{
newOrigin[0] = worldWidthMM - displayWidthMM;
correctPanning = true;
}
}
if (worldHeightMM<displayHeightMM)
{
// zoomed out too much in y (but tolerated because x is still ok)
// --> center y
newOrigin[1] = (worldHeightMM - displayHeightMM) / 2.0;
correctPanning = true;
}
else
{
// make sure top display border inside our world
if (displayYMM + displayHeightMM > worldHeightMM)
{
newOrigin[1] = worldHeightMM - displayHeightMM;
correctPanning = true;
}
// make sure bottom display border inside our world
else
if (displayYMM < 0)
{
newOrigin[1] = 0;
correctPanning = true;
}
}
if (correctPanning)
{
SetOriginInMM( newOrigin );
}
inRecalculate = false;
if ( correctPanning || correctZooming )
{
Modified();
}
// return true if any correction has been made
return correctPanning || correctZooming;
}
void mitk::DisplayGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
{
if(m_WorldGeometry.IsNull())
{
os << indent << " WorldGeometry: " << "NULL" << std::endl;
}
else
{
m_WorldGeometry->Print(os, indent);
os << indent << " OriginInMM: " << m_OriginInMM << std::endl;
os << indent << " OriginInDisplayUnits: " << m_OriginInDisplayUnits << std::endl;
os << indent << " SizeInMM: " << m_SizeInMM << std::endl;
os << indent << " SizeInDisplayUnits: " << m_SizeInDisplayUnits << std::endl;
os << indent << " ScaleFactorMMPerDisplayUni: " << m_ScaleFactorMMPerDisplayUnit << std::endl;
}
Superclass::PrintSelf(os,indent);
}
diff --git a/Core/Code/DataManagement/mitkDisplayGeometry.h b/Core/Code/DataManagement/mitkDisplayGeometry.h
index 042e0a16a7..1278202c50 100644
--- a/Core/Code/DataManagement/mitkDisplayGeometry.h
+++ b/Core/Code/DataManagement/mitkDisplayGeometry.h
@@ -1,240 +1,240 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkDisplayGeometry_h
#define mitkDisplayGeometry_h
#include "mitkGeometry2D.h"
namespace mitk
{
/**
\brief Describes the geometry on the display/screen for 2D display.
The main purpose of this class is to convert between display coordinates
(in display-units) and world coordinates (in mm).
DisplayGeometry depends on the size of the display area (widget width and
height, m_SizeInDisplayUnits) and on a Geometry2D (m_WoldGeometry). It
represents a recangular view on this world-geometry. E.g., you can tell
the DisplayGeometry to fit the world-geometry in the display area by
calling Fit(). Provides methods for zooming and panning.
Zooming and panning can be restricted within reasonable bounds by setting
the ConstrainZoomingAndPanning flag. In these cases you can re-define what
bounds you accept as "reasonable" by calling
\warning \em Units refers to the units of the underlying world-geometry.
Take care, whether these are really the units you want to convert to.
E.g., when you want to convert a point \a pt_display (which is 2D) given
in display coordinates into a point in units of a BaseData-object @a datum
(the requested point is 3D!), use
\code
displaygeometry->DisplayToWorld(pt_display, pt2d_mm);
displaygeometry->Map(pt2d_mm, pt3d_mm);
datum->GetGeometry()->WorldToIndex(pt3d_mm, pt3d_datum_units);
\endcode
Even, if you want to convert the 2D point \a pt_display into a 2D point in
units on a certain 2D geometry \a certaingeometry, it is safer to use
\code
displaygeometry->DisplayToWorld(pt_display, pt_mm);
certaingeometry->WorldToIndex(pt_mm, pt_certain_geometry_units);
\endcode
unless you can be sure that the underlying geometry of \a displaygeometry
is really the \a certaingeometry.
\ingroup Geometry
*/
class MITK_CORE_EXPORT DisplayGeometry : public Geometry2D
{
public:
mitkClassMacro(DisplayGeometry,Geometry2D);
/// Method for creation through the object factory.
itkNewMacro(Self);
/// \brief duplicates the geometry, NOT useful for this sub-class
- virtual AffineGeometryFrame3D::Pointer Clone() const;
+ virtual itk::LightObject::Pointer InternalClone() const;
virtual bool IsValid() const;
/// \return this objects modified time.
virtual unsigned long GetMTime() const;
virtual const TimeBounds& GetTimeBounds() const;
// size definition methods
virtual void SetWorldGeometry(const Geometry2D* aWorldGeometry);
itkGetConstObjectMacro(WorldGeometry, Geometry2D);
/// \return if new origin was within accepted limits
virtual bool SetOriginInMM(const Vector2D& origin_mm);
virtual Vector2D GetOriginInMM() const;
virtual Vector2D GetOriginInDisplayUnits() const;
/**
\brief Set the size of the display in display units.
This method must be called every time the display is resized (normally, the GUI-toolkit
informs about resizing).
\param keepDisplayedRegion: if \a true (the default), the displayed contents is zoomed/shrinked
so that the displayed region is (approximately) the same as before: The point at the center will
be kept at the center and the length of the diagonal of the displayed region \em in \em units
will also be kept.
When the aspect ration changes, the displayed region includes the old displayed region, but
cannot be exaclty the same.
*/
virtual void SetSizeInDisplayUnits(unsigned int width, unsigned int height, bool keepDisplayedRegion=true);
virtual Vector2D GetSizeInDisplayUnits() const;
virtual Vector2D GetSizeInMM() const;
unsigned int GetDisplayWidth() const;
unsigned int GetDisplayHeight() const;
// zooming, panning, restriction of both
virtual void SetConstrainZoomingAndPanning(bool constrain);
virtual bool GetConstrainZommingAndPanning() const;
/// what percentage of the world should be visible at maximum zoom out (default 1.0, i.e. 100% of width or height)
itkGetMacro(MaxWorldViewPercentage, float);
itkSetMacro(MaxWorldViewPercentage, float);
/// what percentage of the world should be visible at maximum zoom in (default 0.1, i.e. 10% of width or height)
itkGetMacro(MinWorldViewPercentage, float);
itkSetMacro(MinWorldViewPercentage, float);
virtual bool SetScaleFactor(ScalarType mmPerDisplayUnit);
ScalarType GetScaleFactorMMPerDisplayUnit() const;
/**
* \brief Zooms with a factor (1.0=identity) to/from the specified center in display units
* \return true if zoom request was within accepted limits
*/
virtual bool Zoom(ScalarType factor, const Point2D& centerInDisplayUnits);
/**
* \brief Zooms with a factor (1.0=identity) to/from the specified center, trying to preserve the center of zoom in world coordiantes
*
* Same zoom as mentioned above but tries (if it's within view contraints) to match the center in display units with the center in world coordinates.
*
* \return true if zoom request was within accepted limits
*/
virtual bool ZoomWithFixedWorldCoordinates(ScalarType factor, const Point2D& focusDisplayUnits, const Point2D& focusUnitsInMM );
// \return true if move request was within accepted limits
virtual bool MoveBy(const Vector2D& shiftInDisplayUnits);
// \brief align display with world, make world completely visible
virtual void Fit();
// conversion methods
virtual void DisplayToWorld(const Point2D &pt_display, Point2D &pt_mm) const;
virtual void WorldToDisplay(const Point2D &pt_mm, Point2D &pt_display) const;
virtual void DisplayToWorld(const Vector2D &vec_display, Vector2D &vec_mm) const;
virtual void WorldToDisplay(const Vector2D &vec_mm, Vector2D &vec_display) const;
virtual void ULDisplayToMM(const Point2D &pt_ULdisplay, Point2D &pt_mm) const;
virtual void MMToULDisplay(const Point2D &pt_mm, Point2D &pt_ULdisplay) const;
virtual void ULDisplayToMM(const Vector2D &vec_ULdisplay, Vector2D &vec_mm) const;
virtual void MMToULDisplay(const Vector2D &vec_mm, Vector2D &vec_ULdisplay) const;
virtual void ULDisplayToDisplay(const Point2D &pt_ULdisplay, Point2D &pt_display) const;
virtual void DisplayToULDisplay(const Point2D &pt_display, Point2D &pt_ULdisplay) const;
virtual void ULDisplayToDisplay(const Vector2D &vec_ULdisplay, Vector2D &vec_display) const;
virtual void DisplayToULDisplay(const Vector2D &vec_display, Vector2D &vec_ULdisplay) const;
/**
* \brief projects the given point onto current 2D world geometry plane
*/
virtual bool Project(const Point3D &pt3d_mm, Point3D &projectedPt3d_mm) const;
/**
* \brief projects the given vector onto current 2D world geometry plane.
* \warning DEPRECATED, please use Project(const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) instead
*/
virtual bool Project(const Point3D & atPt3d_mm, const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) const;
/**
* \brief projects the given vector onto current 2D world geometry plane
*/
virtual bool Project(const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) const;
virtual bool Map(const Point3D &pt3d_mm, Point2D &pt2d_mm) const;
virtual void Map(const Point2D &pt2d_mm, Point3D &pt3d_mm) const;
virtual bool Map(const Point3D & atPt3d_mm, const Vector3D &vec3d_mm, Vector2D &vec2d_mm) const;
virtual void Map(const Point2D & atPt2d_mm, const Vector2D &vec2d_mm, Vector3D &vec3d_mm) const;
protected:
DisplayGeometry();
virtual ~DisplayGeometry();
/**
\brief Called after zooming/panning to restrict these operations to sensible measures.
\return true if a correction in either zooming or panning was made
Enforces a couple of constraints on the relation of the current viewport and the current world geometry.
The basic logic in this lengthy method is:
<ol>
<li> Make display region big enough (in case of too large zoom factors)
<li> Make display region small enough (so that the image cannot be scaled into a single screen pixel
<li> Correct panning for each border (left, right, bottom, top)
</ol>
The little more complicated implementation is illustrated in the code itself.
*/
virtual bool RefitVisibleRect();
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
Vector2D m_OriginInMM;
Vector2D m_OriginInDisplayUnits;
ScalarType m_ScaleFactorMMPerDisplayUnit;
Vector2D m_SizeInMM;
Vector2D m_SizeInDisplayUnits;
Geometry2D::ConstPointer m_WorldGeometry;
bool m_ConstrainZoomingAndPanning;
float m_MaxWorldViewPercentage;
float m_MinWorldViewPercentage;
};
} // namespace
#endif // include guard
diff --git a/Core/Code/DataManagement/mitkEnumerationProperty.cpp b/Core/Code/DataManagement/mitkEnumerationProperty.cpp
index 7abecbdb2f..4ae81f1618 100644
--- a/Core/Code/DataManagement/mitkEnumerationProperty.cpp
+++ b/Core/Code/DataManagement/mitkEnumerationProperty.cpp
@@ -1,211 +1,205 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkEnumerationProperty.h"
#include <algorithm>
// static map members of EnumerationProperty. These Maps point to per-classname-maps of ID <-> String. Accessed by GetEnumIds() and GetEnumString().
mitk::EnumerationProperty::IdMapForClassNameContainerType mitk::EnumerationProperty::s_IdMapForClassName;
mitk::EnumerationProperty::StringMapForClassNameContainerType mitk::EnumerationProperty::s_StringMapForClassName;
mitk::EnumerationProperty::EnumerationProperty()
{
m_CurrentValue = 0;
}
mitk::EnumerationProperty::EnumerationProperty(const EnumerationProperty& other)
: BaseProperty(other)
, m_CurrentValue(other.m_CurrentValue)
{
}
bool mitk::EnumerationProperty::AddEnum( const std::string& name, const IdType& id )
{
if ( ( ! IsValidEnumerationValue( name ) ) && ( ! IsValidEnumerationValue( id ) ) )
{
GetEnumIds().insert( std::make_pair( id, name ) );
GetEnumStrings().insert( std::make_pair( name, id ) );
return true;
}
else
{
return false;
}
}
bool mitk::EnumerationProperty::SetValue( const std::string& name )
{
if ( IsValidEnumerationValue( name ) )
{
m_CurrentValue = GetEnumId( name );
Modified();
return true;
}
else
{
return false;
}
}
bool mitk::EnumerationProperty::SetValue( const IdType& id )
{
if ( IsValidEnumerationValue( id ) )
{
m_CurrentValue = id;
Modified();
return true;
}
else
{
return false;
}
}
mitk::EnumerationProperty::IdType mitk::EnumerationProperty::GetValueAsId() const
{
return m_CurrentValue;
}
std::string mitk::EnumerationProperty::GetValueAsString() const
{
return GetEnumString( m_CurrentValue );
}
void mitk::EnumerationProperty::Clear()
{
GetEnumIds().clear();
GetEnumStrings().clear();
m_CurrentValue = 0;
}
mitk::EnumerationProperty::EnumIdsContainerType::size_type mitk::EnumerationProperty::Size() const
{
return GetEnumIds().size();
}
mitk::EnumerationProperty::EnumConstIterator mitk::EnumerationProperty::Begin() const
{
return GetEnumIds().begin();
}
mitk::EnumerationProperty::EnumConstIterator mitk::EnumerationProperty::End() const
{
return GetEnumIds().end();
}
std::string mitk::EnumerationProperty::GetEnumString( const IdType& id ) const
{
if ( IsValidEnumerationValue( id ) )
{
return GetEnumIds().find( id )->second;
}
else
{
return "invalid enum id or enums empty";
}
}
mitk::EnumerationProperty::IdType mitk::EnumerationProperty::GetEnumId( const std::string& name ) const
{
if ( IsValidEnumerationValue( name ) )
{
return GetEnumStrings().find( name )->second;
}
else
{
return 0;
}
}
bool mitk::EnumerationProperty::IsEqual( const BaseProperty& property ) const
{
const Self& other = static_cast<const Self&>(property);
return this->Size() == other.Size() && this->GetValueAsId() == other.GetValueAsId() &&
std::equal( this->Begin(), this->End(), other.Begin() );
}
bool mitk::EnumerationProperty::Assign( const BaseProperty& property )
{
const Self& other = static_cast<const Self&>(property);
this->GetEnumIds() = other.GetEnumIds();
this->GetEnumStrings() = other.GetEnumStrings();
this->m_CurrentValue = other.m_CurrentValue;
this->Size() == other.Size() && this->GetValueAsId() == other.GetValueAsId() &&
std::equal( this->Begin(), this->End(), other.Begin() );
return true;
}
bool mitk::EnumerationProperty::IsValidEnumerationValue( const IdType& val ) const
{
return ( GetEnumIds().find( val ) != GetEnumIds().end() );
}
bool mitk::EnumerationProperty::IsValidEnumerationValue( const std::string& val ) const
{
return ( GetEnumStrings().find( val ) != GetEnumStrings().end() );
}
mitk::EnumerationProperty::EnumIdsContainerType& mitk::EnumerationProperty::GetEnumIds()
{
std::string className = this->GetNameOfClass(); // virtual!
return s_IdMapForClassName[ className ];
}
const mitk::EnumerationProperty::EnumIdsContainerType& mitk::EnumerationProperty::GetEnumIds() const
{
std::string className = this->GetNameOfClass(); // virtual!
return s_IdMapForClassName[ className ];
}
mitk::EnumerationProperty::EnumStringsContainerType& mitk::EnumerationProperty::GetEnumStrings()
{
std::string className = this->GetNameOfClass(); // virtual!
return s_StringMapForClassName[ className ];
}
const mitk::EnumerationProperty::EnumStringsContainerType& mitk::EnumerationProperty::GetEnumStrings() const
{
std::string className = this->GetNameOfClass(); // virtual!
return s_StringMapForClassName[ className ];
}
-mitk::EnumerationProperty::Pointer mitk::EnumerationProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::EnumerationProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkEnumerationProperty.h b/Core/Code/DataManagement/mitkEnumerationProperty.h
index f5b1dfa974..55fc03f379 100644
--- a/Core/Code/DataManagement/mitkEnumerationProperty.h
+++ b/Core/Code/DataManagement/mitkEnumerationProperty.h
@@ -1,230 +1,226 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_ENUMERATION_PROPERTY__H_
#define _MITK_ENUMERATION_PROPERTY__H_
#include "mitkBaseProperty.h"
#include <map>
#include <string>
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* This class may be used to store properties similar to enumeration values.
* Each enumeration value is identified via a string representation and a
* id. Note, that both string representation and id MUST be unique. This is checked
* when inserting a new enumeration value. Please note that you have to add valid
* enumeration values before you may use the Get/SetValue methods.
*
* To use the class enumeration property you have 2 choices:
*
* 1. Directly use the class and add your possible enumeration values via
* AddEnum(name, id). NOte that the ids do not have to be in any order, they
* just have to be unique. The current value is set via SetValue(...) and
* retrieved via GetValueAsId() or GetValueAsString().
* 2. Create a subclass, which adds the possible enumeration values in its
* constructor and maybe adds some additional convenience functions to
* set/get the value. NOte that you should override AddEnum(...) as protected
* so that the user may not add additional invalid enumeration values.
* As example see mitk::VtkRepresentationProperty or mitk::VtkInterpolationProperty
*
* @ingroup DataManagement
*/
class MITK_CORE_EXPORT EnumerationProperty : public BaseProperty
{
public:
mitkClassMacro( EnumerationProperty, BaseProperty );
itkNewMacro(EnumerationProperty);
/**
* Represents the unique id which is asigned to each enumeration value
*/
typedef unsigned int IdType;
/**
* Type used to store a mapping from enumeration id to enumeration string/
* description
*/
typedef std::map<IdType, std::string> EnumIdsContainerType;
/**
* Type used to store a mapping from enumeration string/description to
* enumeration id
*/
typedef std::map<std::string, IdType> EnumStringsContainerType;
/**
* Type used for iterators over all defined enumeration values.
*/
typedef EnumIdsContainerType::const_iterator EnumConstIterator;
- Pointer Clone() const;
-
-
/**
* Adds an enumeration value into the enumeration. The name and id provided
* must be unique. This is checked while adding the new enumeration value.
* If it is not unique, false is returned. If addition was successful, true
* is returned.
* @param name the unique string representation of the enumeration value
* @param id the unique integer representation of the enumeration value
* @returns true, if the name/id combination was successfully added to the
* enumeration values or true otherwise
*/
virtual bool AddEnum( const std::string& name, const IdType& id );
/**
* Sets the current value of the enumeration
* @param name the string representation of the enumeration value to set
* @returns true if the value was successfully set (i.e. it was valid), or
* false, if the name provided is incalid.
*/
virtual bool SetValue( const std::string& name );
/**
* Sets the current value of the enumeration
* @param id the integer representation of the enumeration value to set
* @returns true if the value was successfully set (i.e. it was valid), or
* false, if the id provided is invalid.
*/
virtual bool SetValue( const IdType& id );
/**
* Returns the id of the current enumeration value. If it was not yet set,
* the return value is unspecified
*/
virtual IdType GetValueAsId() const;
/**
* Returns the string representation of the current enumeration value. If it
* was not yet set, the return value is unspecified
*/
virtual std::string GetValueAsString() const;
/**
* Clears all possible enumeration values and the current enumeration value.
*/
virtual void Clear();
/**
* Determines the number of enumeration values which have been added via
* AddEnum(...).
* @returns the number of enumeration values associated with this Enumeration
* Property
*/
virtual EnumIdsContainerType::size_type Size() const;
/**
* Provides access to the set of known enumeration values. The string representation
* may be accessed via iterator->second, the id may be access via iterator->first
* @returns an iterator over all enumeration values.
*/
virtual EnumConstIterator Begin() const;
/**
* Specifies the end of the range of the known enumeration values.
* @returns an iterator pointing past the last known element of the possible
* enumeration values.
*/
virtual EnumConstIterator End() const;
/**
* Returns the string representation for the given id.
* @param id the id for which the string representation should be determined
* if id is invalid, the return value is unspecified.
* @returns the string representation of the given enumeration value
*/
virtual std::string GetEnumString( const IdType& id ) const;
/**
* Returns the integer representation for the given string.
* @param name the enumeration name for which the integer representation should be determined
* if the name is invalid, the return value is unspecified.
* @returns the integer representation of the given enumeration value
*/
virtual IdType GetEnumId( const std::string& name ) const;
/**
* Determines if a given integer representation of an enumeration value
* is valid or not
* @param val the integer value to check
* @returns true if the given value is valid or false otherwise
*/
virtual bool IsValidEnumerationValue( const IdType& val ) const;
/**
* Determines if a given string representation of an enumeration value
* is valid or not
* @param val the string to check
* @returns true if the given value is valid or false otherwise
*/
virtual bool IsValidEnumerationValue( const std::string& val ) const;
const EnumIdsContainerType& GetEnumIds() const;
const EnumStringsContainerType& GetEnumStrings() const;
EnumIdsContainerType& GetEnumIds();
EnumStringsContainerType& GetEnumStrings();
using BaseProperty::operator=;
protected:
/**
* Default constructor. The current value of the enumeration is undefined.
*/
EnumerationProperty();
EnumerationProperty(const EnumerationProperty&);
virtual bool IsEqual( const BaseProperty& property ) const;
virtual bool Assign( const BaseProperty& property );
+ itk::LightObject::Pointer InternalClone() const;
+
+
private:
// purposely not implemented
EnumerationProperty& operator=(const EnumerationProperty&);
-
- itk::LightObject::Pointer InternalClone() const;
-
IdType m_CurrentValue;
typedef std::map<std::string, EnumIdsContainerType> IdMapForClassNameContainerType;
typedef std::map<std::string, EnumStringsContainerType> StringMapForClassNameContainerType;
static IdMapForClassNameContainerType s_IdMapForClassName;
static StringMapForClassNameContainerType s_StringMapForClassName;
-
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace
#endif
diff --git a/Core/Code/DataManagement/mitkGenericProperty.h b/Core/Code/DataManagement/mitkGenericProperty.h
index 4f867e0880..3437bc9973 100644
--- a/Core/Code/DataManagement/mitkGenericProperty.h
+++ b/Core/Code/DataManagement/mitkGenericProperty.h
@@ -1,156 +1,146 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKGENERICPROPERTY_H_HEADER_INCLUDED_C1061CEE
#define MITKGENERICPROPERTY_H_HEADER_INCLUDED_C1061CEE
#include <string>
#include <sstream>
#include <stdlib.h>
#include "mitkVector.h"
#include <MitkExports.h>
#include "mitkBaseProperty.h"
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/*!
@ brief Template class for generating properties for int, float, bool, etc.
This class template can be instantiated for all classes/internal types that fulfills
these requirements:
- an operator<< so that the properties value can be put into a std::stringstream
- an operator== so that two properties can be checked for equality
Note: you must use the macro mitkSpecializeGenericProperty to provide specializations
for concrete types (e.g. BoolProperty). Please see mitkProperties.h for examples. If you
don't use the mitkSpecializeGenericProperty Macro, GetNameOfClass() returns a wrong name.
*/
template <typename T>
class MITK_EXPORT GenericProperty : public BaseProperty
{
public:
mitkClassMacro(GenericProperty, BaseProperty);
mitkNewMacro1Param(GenericProperty<T>, T);
+ itkCloneMacro(Self)
typedef T ValueType;
- Pointer Clone() const
- {
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
- }
-
itkSetMacro(Value,T);
itkGetConstMacro(Value,T);
virtual std::string GetValueAsString() const
{
std::stringstream myStr;
myStr << GetValue() ;
return myStr.str();
}
using BaseProperty::operator=;
protected:
GenericProperty() {}
GenericProperty(T x)
: m_Value(x) {}
GenericProperty(const GenericProperty& other)
: BaseProperty(other)
, m_Value(other.m_Value)
{}
T m_Value;
private:
// purposely not implemented
GenericProperty& operator=(const GenericProperty&);
virtual itk::LightObject::Pointer InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
virtual bool IsEqual(const BaseProperty& other) const
{
return (this->m_Value == static_cast<const Self&>(other).m_Value);
}
virtual bool Assign(const BaseProperty& other)
{
this->m_Value = static_cast<const Self&>(other).m_Value;
return true;
}
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
/**
* Generates a specialized subclass of mitk::GenericProperty.
* This way, GetNameOfClass() returns the value provided by PropertyName.
* Please see mitkProperties.h for examples.
* @param PropertyName the name of the subclass of GenericProperty
* @param Type the value type of the GenericProperty
* @param Export the export macro for DLL usage
*/
#define mitkDeclareGenericProperty(PropertyName,Type,Export) \
class Export PropertyName: public GenericProperty< Type > \
{ \
public: \
mitkClassMacro(PropertyName, GenericProperty< Type >); \
itkNewMacro(PropertyName); \
mitkNewMacro1Param(PropertyName, Type); \
- Pointer Clone() const; \
using BaseProperty::operator=; \
protected: \
PropertyName(); \
PropertyName(const PropertyName&); \
PropertyName(Type x); \
private: \
itk::LightObject::Pointer InternalClone() const; \
};
#define mitkDefineGenericProperty(PropertyName,Type,DefaultValue) \
mitk::PropertyName::PropertyName() : Superclass(DefaultValue) { } \
mitk::PropertyName::PropertyName(const PropertyName& other) : GenericProperty< Type >(other) {} \
mitk::PropertyName::PropertyName(Type x) : Superclass(x) {} \
- mitk::PropertyName::Pointer mitk::PropertyName::Clone() const { \
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer()); \
- return result; \
- } \
itk::LightObject::Pointer mitk::PropertyName::InternalClone() const { \
itk::LightObject::Pointer result(new Self(*this)); \
return result; \
} \
#endif /* MITKGENERICPROPERTY_H_HEADER_INCLUDED_C1061CEE */
diff --git a/Core/Code/DataManagement/mitkGeometry2D.cpp b/Core/Code/DataManagement/mitkGeometry2D.cpp
index 950cbb8c05..6f23c91710 100644
--- a/Core/Code/DataManagement/mitkGeometry2D.cpp
+++ b/Core/Code/DataManagement/mitkGeometry2D.cpp
@@ -1,284 +1,284 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkGeometry2D.h"
#include <vtkTransform.h>
mitk::Geometry2D::Geometry2D()
: m_ScaleFactorMMPerUnitX( 1.0 ),
m_ScaleFactorMMPerUnitY( 1.0 ),
m_ReferenceGeometry( NULL )
{
}
mitk::Geometry2D::Geometry2D(const Geometry2D& other)
: Geometry3D(other), m_ScaleFactorMMPerUnitX( other.m_ScaleFactorMMPerUnitX),
m_ScaleFactorMMPerUnitY( other.m_ScaleFactorMMPerUnitY),
m_ReferenceGeometry( other.m_ReferenceGeometry )
{
}
mitk::Geometry2D::~Geometry2D()
{
}
void
mitk::Geometry2D::SetIndexToWorldTransform(
mitk::AffineTransform3D* transform)
{
Superclass::SetIndexToWorldTransform(transform);
m_ScaleFactorMMPerUnitX=GetExtentInMM(0)/GetExtent(0);
m_ScaleFactorMMPerUnitY=GetExtentInMM(1)/GetExtent(1);
assert(m_ScaleFactorMMPerUnitX<ScalarTypeNumericTraits::infinity());
assert(m_ScaleFactorMMPerUnitY<ScalarTypeNumericTraits::infinity());
}
void
mitk::Geometry2D::SetExtentInMM(int direction, ScalarType extentInMM)
{
Superclass::SetExtentInMM(direction, extentInMM);
m_ScaleFactorMMPerUnitX=GetExtentInMM(0)/GetExtent(0);
m_ScaleFactorMMPerUnitY=GetExtentInMM(1)/GetExtent(1);
assert(m_ScaleFactorMMPerUnitX<ScalarTypeNumericTraits::infinity());
assert(m_ScaleFactorMMPerUnitY<ScalarTypeNumericTraits::infinity());
}
bool
mitk::Geometry2D::Map(
const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const
{
assert(m_BoundingBox.IsNotNull());
Point3D pt3d_units;
BackTransform(pt3d_mm, pt3d_units);
pt2d_mm[0]=pt3d_units[0]*m_ScaleFactorMMPerUnitX;
pt2d_mm[1]=pt3d_units[1]*m_ScaleFactorMMPerUnitY;
pt3d_units[2]=0;
return const_cast<BoundingBox*>(m_BoundingBox.GetPointer())->IsInside(pt3d_units);
}
void
mitk::Geometry2D::Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const
{
Point3D pt3d_units;
pt3d_units[0]=pt2d_mm[0]/m_ScaleFactorMMPerUnitX;
pt3d_units[1]=pt2d_mm[1]/m_ScaleFactorMMPerUnitY;
pt3d_units[2]=0;
pt3d_mm = GetParametricTransform()->TransformPoint(pt3d_units);
}
void
mitk::Geometry2D::IndexToWorld(
const mitk::Point2D &/*pt_units*/, mitk::Point2D &/*pt_mm*/) const
{
itkExceptionMacro(<< "No general transform possible (only affine) ==> no general" \
" IndexToWorld(const mitk::Point2D &pt_mm, mitk::Point2D &pt_units)" \
" possible. Has to be implemented in sub-class.");
}
void
mitk::Geometry2D::WorldToIndex(
const mitk::Point2D &/*pt_mm*/, mitk::Point2D &/*pt_units*/) const
{
itkExceptionMacro(<< "No general back transform possible (only affine) ==> no general" \
" WorldToIndex(const mitk::Point2D &pt_mm, mitk::Point2D &pt_units)" \
" possible. Has to be implemented in sub-class.");
}
void
mitk::Geometry2D::IndexToWorld(const mitk::Point2D &/*atPt2d_units*/,
const mitk::Vector2D &/*vec_units*/, mitk::Vector2D &/*vec_mm*/) const
{
itkExceptionMacro(<< "No general transform possible (only affine) ==> no general" \
" IndexToWorld(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units)" \
" possible. Has to be implemented in sub-class.");
}
void
mitk::Geometry2D::WorldToIndex(const mitk::Point2D &/*atPt2d_mm*/,
const mitk::Vector2D &/*vec_mm*/, mitk::Vector2D &/*vec_units*/) const
{
itkExceptionMacro(<< "No general back transform possible (only affine) ==> no general" \
" WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units)" \
" possible. Has to be implemented in sub-class.");
}
void
mitk::Geometry2D::SetSizeInUnits(mitk::ScalarType width, mitk::ScalarType height)
{
ScalarType bounds[6]={0, width, 0, height, 0, 1};
ScalarType extent, newextentInMM;
if(GetExtent(0)>0)
{
extent = GetExtent(0);
if(width>extent)
newextentInMM = GetExtentInMM(0)/width*extent;
else
newextentInMM = GetExtentInMM(0)*extent/width;
SetExtentInMM(0, newextentInMM);
}
if(GetExtent(1)>0)
{
extent = GetExtent(1);
if(width>extent)
newextentInMM = GetExtentInMM(1)/height*extent;
else
newextentInMM = GetExtentInMM(1)*extent/height;
SetExtentInMM(1, newextentInMM);
}
SetBounds(bounds);
}
bool
mitk::Geometry2D::Project(
const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const
{
assert(m_BoundingBox.IsNotNull());
Point3D pt3d_units;
BackTransform(pt3d_mm, pt3d_units);
pt3d_units[2] = 0;
projectedPt3d_mm = GetParametricTransform()->TransformPoint(pt3d_units);
return const_cast<BoundingBox*>(m_BoundingBox.GetPointer())->IsInside(pt3d_units);
}
bool
mitk::Geometry2D::Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const
{
assert(m_BoundingBox.IsNotNull());
Vector3D vec3d_units;
BackTransform(vec3d_mm, vec3d_units);
vec3d_units[2] = 0;
projectedVec3d_mm = GetParametricTransform()->TransformVector(vec3d_units);
return true;
}
bool
mitk::Geometry2D::Project(const mitk::Point3D & atPt3d_mm,
const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const
{
MITK_WARN << "Deprecated function! Call Project(vec3D,vec3D) instead.";
assert(m_BoundingBox.IsNotNull());
Vector3D vec3d_units;
BackTransform(atPt3d_mm, vec3d_mm, vec3d_units);
vec3d_units[2] = 0;
projectedVec3d_mm = GetParametricTransform()->TransformVector(vec3d_units);
Point3D pt3d_units;
BackTransform(atPt3d_mm, pt3d_units);
return const_cast<BoundingBox*>(m_BoundingBox.GetPointer())->IsInside(pt3d_units);
}
bool
mitk::Geometry2D::Map(const mitk::Point3D & atPt3d_mm,
const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const
{
Point2D pt2d_mm_start, pt2d_mm_end;
Point3D pt3d_mm_end;
bool inside=Map(atPt3d_mm, pt2d_mm_start);
pt3d_mm_end = atPt3d_mm+vec3d_mm;
inside&=Map(pt3d_mm_end, pt2d_mm_end);
vec2d_mm=pt2d_mm_end-pt2d_mm_start;
return inside;
}
void
mitk::Geometry2D::Map(const mitk::Point2D &/*atPt2d_mm*/,
const mitk::Vector2D &/*vec2d_mm*/, mitk::Vector3D &/*vec3d_mm*/) const
{
//@todo implement parallel to the other Map method!
assert(false);
}
mitk::ScalarType
mitk::Geometry2D::SignedDistance(const mitk::Point3D& pt3d_mm) const
{
Point3D projectedPoint;
Project(pt3d_mm, projectedPoint);
Vector3D direction = pt3d_mm-projectedPoint;
ScalarType distance = direction.GetNorm();
if(IsAbove(pt3d_mm) == false)
distance*=-1.0;
return distance;
}
bool
mitk::Geometry2D::IsAbove(const mitk::Point3D& pt3d_mm) const
{
Point3D pt3d_units;
Geometry3D::WorldToIndex(pt3d_mm, pt3d_units);
return (pt3d_units[2] > m_BoundingBox->GetBounds()[4]);
}
-mitk::AffineGeometryFrame3D::Pointer
-mitk::Geometry2D::Clone() const
+itk::LightObject::Pointer
+mitk::Geometry2D::InternalClone() const
{
Self::Pointer newGeometry = new Geometry2D(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
void
mitk::Geometry2D::PrintSelf(std::ostream& os, itk::Indent indent) const
{
Superclass::PrintSelf(os,indent);
os << indent << " ScaleFactorMMPerUnitX: "
<< m_ScaleFactorMMPerUnitX << std::endl;
os << indent << " ScaleFactorMMPerUnitY: "
<< m_ScaleFactorMMPerUnitY << std::endl;
}
void
mitk::Geometry2D::SetReferenceGeometry( mitk::Geometry3D *geometry )
{
m_ReferenceGeometry = geometry;
}
mitk::Geometry3D *
mitk::Geometry2D::GetReferenceGeometry() const
{
return m_ReferenceGeometry;
}
bool
mitk::Geometry2D::HasReferenceGeometry() const
{
return ( m_ReferenceGeometry != NULL );
}
diff --git a/Core/Code/DataManagement/mitkGeometry2D.h b/Core/Code/DataManagement/mitkGeometry2D.h
index 7b8d936eed..45bb00953a 100644
--- a/Core/Code/DataManagement/mitkGeometry2D.h
+++ b/Core/Code/DataManagement/mitkGeometry2D.h
@@ -1,273 +1,273 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef GEOMETRY2D_H_HEADER_INCLUDED_C1F4D8E0
#define GEOMETRY2D_H_HEADER_INCLUDED_C1F4D8E0
#include <MitkExports.h>
#include "mitkGeometry3D.h"
namespace mitk {
/**
* \brief Describes the geometry of a two-dimensional object
*
* Describes a two-dimensional manifold, i.e., to put it simply,
* an object that can be described using a 2D coordinate-system.
*
* Geometry2D can map points between 3D world coordinates
* (in mm) and the described 2D coordinate-system (in mm) by first projecting
* the 3D point onto the 2D manifold and then calculating the 2D-coordinates
* (in mm). These 2D-mm-coordinates can be further converted into
* 2D-unit-coordinates (e.g., pixels), giving a parameter representation of
* the object with parameter values inside a rectangle
* (e.g., [0,0]..[width, height]), which is the bounding box (bounding range
* in z-direction always [0]..[1]).
*
* A Geometry2D describes the 2D representation within a 3D object and is
* therefore itself a Geometry3D (derived from Geometry3D). For example,
* a single CT-image (slice) is 2D in the sense that you can access the
* pixels using 2D-coordinates, but is also 3D, as the pixels are really
* voxels, thus have an extension (thickness) in the 3rd dimension.
*
* Most often, instances of Geometry2D will be used to descibe a plane,
* which is represented by the sub-class PlaneGeometry, but curved
* surfaces are also possible.
*
* Optionally, a reference Geometry3D can be specified, which usually would
* be the geometry associated with the underlying dataset. This is currently
* used for calculating the intersection of inclined / rotated planes
* (represented as Geometry2D) with the bounding box of the associated
* Geometry3D.
*
* \warning The Geometry2Ds are not necessarily up-to-date and not even
* initialized. As described in the previous paragraph, one of the
* Generate-/Copy-/UpdateOutputInformation methods have to initialize it.
* mitk::BaseData::GetGeometry2D() makes sure, that the Geometry2D is
* up-to-date before returning it (by setting the update extent appropriately
* and calling UpdateOutputInformation).
*
* Rule: everything is in mm (or ms for temporal information) if not
* stated otherwise.
* \ingroup Geometry
*/
class MITK_CORE_EXPORT Geometry2D : public mitk::Geometry3D
{
public:
mitkClassMacro(Geometry2D, mitk::Geometry3D);
itkNewMacro(Self);
/**
* \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
* geometry. The result is a 2D point in mm (\a pt2d_mm).
*
* The result is a 2D point in mm (\a pt2d_mm) relative to the upper-left
* corner of the geometry. To convert this point into units (e.g., pixels
* in case of an image), use WorldToIndex.
* \return true projection was possible
* \sa Project(const mitk::Point3D &pt3d_mm, mitk::Point3D
* &projectedPt3d_mm)
*/
virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const;
/**
* \brief Converts a 2D point given in mm (\a pt2d_mm) relative to the
* upper-left corner of the geometry into the corresponding
* world-coordinate (a 3D point in mm, \a pt3d_mm).
*
* To convert a 2D point given in units (e.g., pixels in case of an
* image) into a 2D point given in mm (as required by this method), use
* IndexToWorld.
*/
virtual void Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const;
/**
* \brief Convert a 2D point given in units (e.g., pixels in case of an
* image) into a 2D point given in mm
*/
virtual void IndexToWorld(
const mitk::Point2D &pt_units, mitk::Point2D &pt_mm) const;
/**
* \brief Convert a 2D point given in mm into a 2D point given in mm
* (e.g., pixels in case of an image)
*/
virtual void WorldToIndex(
const mitk::Point2D &pt_mm, mitk::Point2D &pt_units) const;
/**
* \brief Convert a 2D vector given in units (e.g., pixels in case of an
* image) into a 2D vector given in mm
* \warning strange: in contrast to vtkTransform the class itk::Transform
* does not have the parameter, \em where the vector that is to be
* transformed is located. This method here should also need this
* information for general transforms.
*/
virtual void IndexToWorld(
const mitk::Point2D &atPt2d_units, const mitk::Vector2D &vec_units,
mitk::Vector2D &vec_mm) const;
/**
* \brief Convert a 2D vector given in mm into a 2D point vector in mm
* (e.g., pixels in case of an image)
* \warning strange: in contrast to vtkTransform the class itk::Transform
* does not have the parameter, \em where the vector that is to be
* transformed is located. This method here should also need this
* information for general transforms.
*/
virtual void WorldToIndex(
const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec_mm,
mitk::Vector2D &vec_units) const;
/**
* \brief Set the width and height of this 2D-geometry in units by calling
* SetBounds. This does \a not change the extent in mm!
*
* For an image, this is the number of pixels in x-/y-direction.
* \note In contrast to calling SetBounds directly, this does \a not change
* the extent in mm!
*/
virtual void SetSizeInUnits(mitk::ScalarType width, mitk::ScalarType height);
/**
* \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
* geometry. The result is a 3D point in mm (\a projectedPt3d_mm).
*
* \return true projection was possible
*/
virtual bool Project(const mitk::Point3D &pt3d_mm,
mitk::Point3D &projectedPt3d_mm) const;
/**
* \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
* geometry. The result is a 2D vector in mm (\a vec2d_mm).
*
* The result is a 2D vector in mm (\a vec2d_mm) relative to the
* upper-left
* corner of the geometry. To convert this point into units (e.g., pixels
* in case of an image), use WorldToIndex.
* \return true projection was possible
* \sa Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D
* &projectedVec3d_mm)
*/
virtual bool Map(const mitk::Point3D & atPt3d_mm,
const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const;
/**
* \brief Converts a 2D vector given in mm (\a vec2d_mm) relative to the
* upper-left corner of the geometry into the corresponding
* world-coordinate (a 3D vector in mm, \a vec3d_mm).
*
* To convert a 2D vector given in units (e.g., pixels in case of an
* image) into a 2D vector given in mm (as required by this method), use
* IndexToWorld.
*/
virtual void Map(const mitk::Point2D & atPt2d_mm,
const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const;
/**
* \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
* geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
*
* DEPRECATED. Use Project(vector,vector) instead
*
* \return true projection was possible
*/
virtual bool Project(const mitk::Point3D & atPt3d_mm,
const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
/**
* \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
* geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
*
* \return true projection was possible
*/
virtual bool Project( const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
/**
* \brief Distance of the point from the geometry
* (bounding-box \em not considered)
*
*/
inline ScalarType Distance(const Point3D& pt3d_mm) const
{
return fabs(SignedDistance(pt3d_mm));
}
/**
* \brief Signed distance of the point from the geometry
* (bounding-box \em not considered)
*
*/
virtual ScalarType SignedDistance(const Point3D& pt3d_mm) const;
/**
* \brief Test if the point is above the geometry
* (bounding-box \em not considered)
*
*/
virtual bool IsAbove(const Point3D& pt3d_mm) const;
virtual void SetIndexToWorldTransform(mitk::AffineTransform3D* transform);
virtual void SetExtentInMM(int direction, ScalarType extentInMM);
- virtual AffineGeometryFrame3D::Pointer Clone() const;
+ virtual itk::LightObject::Pointer InternalClone() const;
/**
* \brief Set the geometrical frame of reference in which this Geometry2D
* is placed.
*
* This would usually be the Geometry3D of the underlying dataset, but
* setting it is optional.
*/
void SetReferenceGeometry( mitk::Geometry3D *geometry );
/**
* \brief Get the geometrical frame of reference for this Geometry2D.
*/
Geometry3D *GetReferenceGeometry() const;
bool HasReferenceGeometry() const;
protected:
Geometry2D();
Geometry2D(const Geometry2D& other);
virtual ~Geometry2D();
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
/**
* \brief factor to convert x-coordinates from mm to units and vice versa
*
*/
mutable mitk::ScalarType m_ScaleFactorMMPerUnitX;
/**
* \brief factor to convert y-coordinates from mm to units and vice versa
*
*/
mutable mitk::ScalarType m_ScaleFactorMMPerUnitY;
mitk::Geometry3D *m_ReferenceGeometry;
};
} // namespace mitk
#endif /* GEOMETRY2D_H_HEADER_INCLUDED_C1F4D8E0 */
diff --git a/Core/Code/DataManagement/mitkGeometry2DData.cpp b/Core/Code/DataManagement/mitkGeometry2DData.cpp
index 23fe99f6d0..215dcde56d 100644
--- a/Core/Code/DataManagement/mitkGeometry2DData.cpp
+++ b/Core/Code/DataManagement/mitkGeometry2DData.cpp
@@ -1,90 +1,90 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkGeometry2DData.h"
#include "mitkBaseProcess.h"
mitk::Geometry2DData::Geometry2DData()
{
}
mitk::Geometry2DData::~Geometry2DData()
{
}
void mitk::Geometry2DData::SetGeometry(mitk::Geometry3D *geometry)
{
if(geometry==NULL)
SetGeometry2D(NULL);
else
{
Geometry2D* geometry2d = dynamic_cast<Geometry2D*>(geometry);
if(geometry2d==NULL)
itkExceptionMacro(<<"Trying to set a geometry which is not a Geometry2D into Geometry2DData.");
SetGeometry2D(geometry2d);
}
}
void mitk::Geometry2DData::SetGeometry2D(mitk::Geometry2D *geometry2d)
{
if(geometry2d != NULL)
{
TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
if(timeSlicedGeometry == NULL)
{
Superclass::SetGeometry(geometry2d);
return;
}
timeSlicedGeometry->InitializeEvenlyTimed(geometry2d, 1);
Modified();
}
else
Superclass::SetGeometry(geometry2d);
}
void mitk::Geometry2DData::UpdateOutputInformation()
{
Superclass::UpdateOutputInformation();
}
void mitk::Geometry2DData::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::Geometry2DData::RequestedRegionIsOutsideOfTheBufferedRegion()
{
if(GetGeometry2D()==NULL) return true;
return false;
}
bool mitk::Geometry2DData::VerifyRequestedRegion()
{
if(GetGeometry2D()==NULL) return false;
return true;
}
-void mitk::Geometry2DData::SetRequestedRegion(itk::DataObject *)
+void mitk::Geometry2DData::SetRequestedRegion( const itk::DataObject *)
{
}
void mitk::Geometry2DData::CopyInformation(const itk::DataObject *)
{
}
diff --git a/Core/Code/DataManagement/mitkGeometry2DData.h b/Core/Code/DataManagement/mitkGeometry2DData.h
index 44d6bc8793..dae7bfb049 100644
--- a/Core/Code/DataManagement/mitkGeometry2DData.h
+++ b/Core/Code/DataManagement/mitkGeometry2DData.h
@@ -1,77 +1,77 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKGEOMETRY2DDATA_H_HEADER_INCLUDED_C19C01E2
#define MITKGEOMETRY2DDATA_H_HEADER_INCLUDED_C19C01E2
#include <MitkExports.h>
#include "mitkBaseData.h"
#include "mitkGeometryData.h"
#include "mitkGeometry2D.h"
namespace mitk {
//##Documentation
//## @brief Data class containing Geometry2D objects
//## @ingroup Geometry
//##
class MITK_CORE_EXPORT Geometry2DData : public GeometryData
{
public:
mitkClassMacro(Geometry2DData, GeometryData);
itkNewMacro(Self);
//##Documentation
//## @brief Set the reference to a Geometry2D that is stored
//## by the object
//##
//## @warning Accepts only instances of Geometry2D or sub-classes.
virtual void SetGeometry(mitk::Geometry3D *geometry);
//##Documentation
//## @brief Set the reference to the Geometry2D that is stored
//## by the object
virtual void SetGeometry2D(mitk::Geometry2D* geometry2d);
//##Documentation
//## @brief Get the reference to the Geometry2D that is stored
//## by the object
virtual mitk::Geometry2D * GetGeometry2D() const
{
return static_cast<mitk::Geometry2D *>(GetGeometry());
};
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion( const itk::DataObject *data);
virtual void CopyInformation(const itk::DataObject *data);
protected:
Geometry2DData();
virtual ~Geometry2DData();
};
} // namespace mitk
#endif /* MITKGEOMETRY2DDATA_H_HEADER_INCLUDED_C19C01E2 */
diff --git a/Core/Code/DataManagement/mitkGeometry3D.cpp b/Core/Code/DataManagement/mitkGeometry3D.cpp
index a5c7ff1c52..5dbfecde2a 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.cpp
+++ b/Core/Code/DataManagement/mitkGeometry3D.cpp
@@ -1,772 +1,771 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <sstream>
#include "mitkGeometry3D.h"
#include "mitkMatrixConvert.h"
#include "mitkRotationOperation.h"
#include "mitkRestorePlanePositionOperation.h"
#include "mitkPointOperation.h"
#include "mitkInteractionConst.h"
//#include "mitkStatusBar.h"
#include <vtkMatrixToLinearTransform.h>
#include <vtkMatrix4x4.h>
// Standard constructor for the New() macro. Sets the geometry to 3 dimensions
mitk::Geometry3D::Geometry3D()
: m_ParametricBoundingBox(NULL),
m_ImageGeometry(false), m_Valid(true), m_FrameOfReferenceID(0), m_IndexToWorldTransformLastModified(0)
{
FillVector3D(m_FloatSpacing, 1,1,1);
m_VtkMatrix = vtkMatrix4x4::New();
m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
Initialize();
}
mitk::Geometry3D::Geometry3D(const Geometry3D& other) : Superclass(), mitk::OperationActor(), m_ParametricBoundingBox(other.m_ParametricBoundingBox),m_TimeBounds(other.m_TimeBounds),
m_ImageGeometry(other.m_ImageGeometry), m_Valid(other.m_Valid), m_FrameOfReferenceID(other.m_FrameOfReferenceID), m_IndexToWorldTransformLastModified(other.m_IndexToWorldTransformLastModified), m_RotationQuaternion( other.m_RotationQuaternion ) , m_Origin(other.m_Origin)
{
// AffineGeometryFrame
SetBounds(other.GetBounds());
//SetIndexToObjectTransform(other.GetIndexToObjectTransform());
//SetObjectToNodeTransform(other.GetObjectToNodeTransform());
//SetIndexToWorldTransform(other.GetIndexToWorldTransform());
// this is not used in AffineGeometryFrame of ITK, thus there are not Get and Set methods
// m_IndexToNodeTransform = other.m_IndexToNodeTransform;
// m_InvertedTransform = TransformType::New();
// m_InvertedTransform = TransformType::New();
// m_InvertedTransform->DeepCopy(other.m_InvertedTransform);
m_VtkMatrix = vtkMatrix4x4::New();
m_VtkMatrix->DeepCopy(other.m_VtkMatrix);
if (other.m_ParametricBoundingBox.IsNotNull())
{
m_ParametricBoundingBox = other.m_ParametricBoundingBox->DeepCopy();
}
FillVector3D(m_FloatSpacing,other.m_FloatSpacing[0],other.m_FloatSpacing[1],other.m_FloatSpacing[2]);
m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
m_VtkIndexToWorldTransform->DeepCopy(other.m_VtkIndexToWorldTransform);
m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
other.InitializeGeometry(this);
}
mitk::Geometry3D::~Geometry3D()
{
m_VtkMatrix->Delete();
m_VtkIndexToWorldTransform->Delete();
}
static void CopySpacingFromTransform(mitk::AffineTransform3D* transform, mitk::Vector3D& spacing, float floatSpacing[3])
{
mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = transform->GetMatrix().GetVnlMatrix();
spacing[0]=vnlmatrix.get_column(0).magnitude();
spacing[1]=vnlmatrix.get_column(1).magnitude();
spacing[2]=vnlmatrix.get_column(2).magnitude();
floatSpacing[0]=spacing[0];
floatSpacing[1]=spacing[1];
floatSpacing[2]=spacing[2];
}
void mitk::Geometry3D::Initialize()
{
float b[6] = {0,1,0,1,0,1};
SetFloatBounds(b);
m_IndexToObjectTransform = TransformType::New();
m_ObjectToNodeTransform = TransformType::New();
if(m_IndexToWorldTransform.IsNull())
m_IndexToWorldTransform = TransformType::New();
else
m_IndexToWorldTransform->SetIdentity();
CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
m_VtkMatrix->Identity();
m_TimeBounds[0]=ScalarTypeNumericTraits::NonpositiveMin(); m_TimeBounds[1]=ScalarTypeNumericTraits::max();
m_FrameOfReferenceID = 0;
m_ImageGeometry = false;
}
void mitk::Geometry3D::TransferItkToVtkTransform()
{
// copy m_IndexToWorldTransform into m_VtkIndexToWorldTransform
TransferItkTransformToVtkMatrix(m_IndexToWorldTransform.GetPointer(), m_VtkMatrix);
m_VtkIndexToWorldTransform->Modified();
}
void mitk::Geometry3D::TransferVtkToItkTransform()
{
TransferVtkMatrixToItkTransform(m_VtkMatrix, m_IndexToWorldTransform.GetPointer());
CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
}
void mitk::Geometry3D::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix)
{
m_VtkMatrix->DeepCopy(vtkmatrix);
TransferVtkToItkTransform();
}
void mitk::Geometry3D::SetTimeBounds(const TimeBounds& timebounds)
{
if(m_TimeBounds != timebounds)
{
m_TimeBounds = timebounds;
Modified();
}
}
void mitk::Geometry3D::SetFloatBounds(const float bounds[6])
{
mitk::BoundingBox::BoundsArrayType b;
const float *input = bounds;
int i=0;
for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++;
SetBoundsArray(b, m_BoundingBox);
}
void mitk::Geometry3D::SetFloatBounds(const double bounds[6])
{
mitk::BoundingBox::BoundsArrayType b;
const double *input = bounds;
int i=0;
for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++;
SetBoundsArray(b, m_BoundingBox);
}
void mitk::Geometry3D::SetParametricBounds(const BoundingBox::BoundsArrayType& bounds)
{
SetBoundsArray(bounds, m_ParametricBoundingBox);
}
void mitk::Geometry3D::WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const
{
BackTransform(pt_mm, pt_units);
}
void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const
{
pt_mm = m_IndexToWorldTransform->TransformPoint(pt_units);
}
void mitk::Geometry3D::WorldToIndex(const mitk::Point3D & /*atPt3d_mm*/, const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
{
MITK_WARN<<"Warning! Call of the deprecated function Geometry3D::WorldToIndex(point, vec, vec). Use Geometry3D::WorldToIndex(vec, vec) instead!";
//BackTransform(atPt3d_mm, vec_mm, vec_units);
this->WorldToIndex(vec_mm, vec_units);
}
void mitk::Geometry3D::WorldToIndex( const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
{
BackTransform( vec_mm, vec_units);
}
void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &/*atPt3d_units*/, const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
{
MITK_WARN<<"Warning! Call of the deprecated function Geometry3D::IndexToWorld(point, vec, vec). Use Geometry3D::IndexToWorld(vec, vec) instead!";
//vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
this->IndexToWorld(vec_units, vec_mm);
}
void mitk::Geometry3D::IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
{
vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
}
void mitk::Geometry3D::SetIndexToWorldTransform(mitk::AffineTransform3D* transform)
{
if(m_IndexToWorldTransform.GetPointer() != transform)
{
Superclass::SetIndexToWorldTransform(transform);
CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
TransferItkToVtkTransform();
Modified();
}
}
-mitk::AffineGeometryFrame3D::Pointer mitk::Geometry3D::Clone() const
+itk::LightObject::Pointer mitk::Geometry3D::InternalClone() const
{
Self::Pointer newGeometry = new Self(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
/*
void mitk::Geometry3D::InitializeGeometry(Geometry3D * newGeometry) const
{
Superclass::InitializeGeometry(newGeometry);
newGeometry->SetTimeBounds(m_TimeBounds);
//newGeometry->GetVtkTransform()->SetMatrix(m_VtkIndexToWorldTransform->GetMatrix()); IW
//newGeometry->TransferVtkToItkTransform(); //MH
newGeometry->SetFrameOfReferenceID(GetFrameOfReferenceID());
newGeometry->m_ImageGeometry = m_ImageGeometry;
}
*/
void mitk::Geometry3D::SetExtentInMM(int direction, ScalarType extentInMM)
{
ScalarType len = GetExtentInMM(direction);
if(fabs(len - extentInMM)>=mitk::eps)
{
AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
if(len>extentInMM)
vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)/len*extentInMM);
else
vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)*extentInMM/len);
Matrix3D matrix;
matrix = vnlmatrix;
m_IndexToWorldTransform->SetMatrix(matrix);
Modified();
}
}
mitk::BoundingBox::Pointer mitk::Geometry3D::CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const
{
mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
mitk::BoundingBox::PointIdentifier pointid=0;
unsigned char i;
if(transform!=NULL)
{
mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
transform->GetInverse(inverse);
for(i=0; i<8; ++i)
pointscontainer->InsertElement( pointid++, inverse->TransformPoint( GetCornerPoint(i) ));
}
else
{
for(i=0; i<8; ++i)
pointscontainer->InsertElement( pointid++, GetCornerPoint(i) );
}
mitk::BoundingBox::Pointer result = mitk::BoundingBox::New();
result->SetPoints(pointscontainer);
result->ComputeBoundingBox();
return result;
}
#include <vtkTransform.h>
void mitk::Geometry3D::ExecuteOperation(Operation* operation)
{
vtkTransform *vtktransform = vtkTransform::New();
vtktransform->SetMatrix(m_VtkMatrix);
switch (operation->GetOperationType())
{
case OpNOTHING:
break;
case OpMOVE:
{
mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
if (pointOp == NULL)
{
//mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
return;
}
mitk::Point3D newPos = pointOp->GetPoint();
ScalarType data[3];
vtktransform->GetPosition(data);
vtktransform->PostMultiply();
vtktransform->Translate(newPos[0], newPos[1], newPos[2]);
vtktransform->PreMultiply();
break;
}
case OpSCALE:
{
mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
if (pointOp == NULL)
{
//mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
return;
}
mitk::Point3D newScale = pointOp->GetPoint();
ScalarType data[3];
/* calculate new scale: newscale = oldscale * (oldscale + scaletoadd)/oldscale */
data[0] = 1 + (newScale[0] / GetMatrixColumn(0).magnitude());
data[1] = 1 + (newScale[1] / GetMatrixColumn(1).magnitude());
data[2] = 1 + (newScale[2] / GetMatrixColumn(2).magnitude());
mitk::Point3D center = const_cast<mitk::BoundingBox*>(m_BoundingBox.GetPointer())->GetCenter();
ScalarType pos[3];
vtktransform->GetPosition(pos);
vtktransform->PostMultiply();
vtktransform->Translate(-pos[0], -pos[1], -pos[2]);
vtktransform->Translate(-center[0], -center[1], -center[2]);
vtktransform->PreMultiply();
vtktransform->Scale(data[0], data[1], data[2]);
vtktransform->PostMultiply();
vtktransform->Translate(+center[0], +center[1], +center[2]);
vtktransform->Translate(pos[0], pos[1], pos[2]);
vtktransform->PreMultiply();
break;
}
case OpROTATE:
{
mitk::RotationOperation *rotateOp = dynamic_cast<mitk::RotationOperation *>(operation);
if (rotateOp == NULL)
{
//mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
return;
}
Vector3D rotationVector = rotateOp->GetVectorOfRotation();
Point3D center = rotateOp->GetCenterOfRotation();
ScalarType angle = rotateOp->GetAngleOfRotation();
vtktransform->PostMultiply();
vtktransform->Translate(-center[0], -center[1], -center[2]);
vtktransform->RotateWXYZ(angle, rotationVector[0], rotationVector[1], rotationVector[2]);
vtktransform->Translate(center[0], center[1], center[2]);
vtktransform->PreMultiply();
break;
}
case OpRESTOREPLANEPOSITION:
{
//Copy necessary to avoid vtk warning
vtkMatrix4x4* matrix = vtkMatrix4x4::New();
TransferItkTransformToVtkMatrix(dynamic_cast<mitk::RestorePlanePositionOperation*>(operation)->GetTransform().GetPointer(), matrix);
vtktransform->SetMatrix(matrix);
break;
}
default:
vtktransform->Delete();
return;
}
m_VtkMatrix->DeepCopy(vtktransform->GetMatrix());
TransferVtkToItkTransform();
Modified();
vtktransform->Delete();
}
void mitk::Geometry3D::BackTransform(const mitk::Point3D &in, mitk::Point3D& out) const
{
ScalarType temp[3];
unsigned int i, j;
const TransformType::OffsetType& offset = m_IndexToWorldTransform->GetOffset();
// Remove offset
for (j = 0; j < 3; j++)
{
temp[j] = in[j] - offset[j];
}
// Get WorldToIndex transform
if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
{
m_InvertedTransform = TransformType::New();
if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
{
itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
}
m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
}
// Check for valid matrix inversion
const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
if(inverse.GetVnlMatrix().has_nans())
{
itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
<< m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
<< inverse );
}
// Transform point
for (i = 0; i < 3; i++)
{
out[i] = 0.0;
for (j = 0; j < 3; j++)
{
out[i] += inverse[i][j]*temp[j];
}
}
}
void mitk::Geometry3D::BackTransform(const mitk::Point3D &/*at*/, const mitk::Vector3D &in, mitk::Vector3D& out) const
{
MITK_INFO<<"Warning! Call of the deprecated function Geometry3D::BackTransform(point, vec, vec). Use Geometry3D::BackTransform(vec, vec) instead!";
//// Get WorldToIndex transform
//if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
//{
// m_InvertedTransform = TransformType::New();
// if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
// {
// itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
// }
// m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
//}
//// Check for valid matrix inversion
//const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
//if(inverse.GetVnlMatrix().has_nans())
//{
// itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
// << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
// << inverse );
//}
//// Transform vector
//for (unsigned int i = 0; i < 3; i++)
//{
// out[i] = 0.0;
// for (unsigned int j = 0; j < 3; j++)
// {
// out[i] += inverse[i][j]*in[j];
// }
//}
this->BackTransform(in, out);
}
void mitk::Geometry3D::BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const
{
// Get WorldToIndex transform
if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
{
m_InvertedTransform = TransformType::New();
if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
{
itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
}
m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
}
// Check for valid matrix inversion
const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
if(inverse.GetVnlMatrix().has_nans())
{
itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
<< m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
<< inverse );
}
// Transform vector
for (unsigned int i = 0; i < 3; i++)
{
out[i] = 0.0;
for (unsigned int j = 0; j < 3; j++)
{
out[i] += inverse[i][j]*in[j];
}
}
}
const float* mitk::Geometry3D::GetFloatSpacing() const
{
return m_FloatSpacing;
}
void mitk::Geometry3D::SetSpacing(const mitk::Vector3D& aSpacing)
{
if(mitk::Equal(m_Spacing, aSpacing) == false)
{
assert(aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0);
m_Spacing = aSpacing;
AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
mitk::VnlVector col;
col = vnlmatrix.get_column(0); col.normalize(); col*=aSpacing[0]; vnlmatrix.set_column(0, col);
col = vnlmatrix.get_column(1); col.normalize(); col*=aSpacing[1]; vnlmatrix.set_column(1, col);
col = vnlmatrix.get_column(2); col.normalize(); col*=aSpacing[2]; vnlmatrix.set_column(2, col);
Matrix3D matrix;
matrix = vnlmatrix;
AffineTransform3D::Pointer transform = AffineTransform3D::New();
transform->SetMatrix(matrix);
transform->SetOffset(m_IndexToWorldTransform->GetOffset());
SetIndexToWorldTransform(transform.GetPointer());
itk2vtk(m_Spacing, m_FloatSpacing);
}
}
void mitk::Geometry3D::SetOrigin(const Point3D & origin)
{
if(origin!=GetOrigin())
{
m_Origin = origin;
m_IndexToWorldTransform->SetOffset(m_Origin.GetVectorFromOrigin());
Modified();
TransferItkToVtkTransform();
}
}
void mitk::Geometry3D::Translate(const Vector3D & vector)
{
if((vector[0] != 0) || (vector[1] != 0) || (vector[2] != 0))
{
this->SetOrigin(m_Origin + vector);
// m_IndexToWorldTransform->SetOffset(m_IndexToWorldTransform->GetOffset()+vector);
// TransferItkToVtkTransform();
// Modified();
}
}
void mitk::Geometry3D::SetIdentity()
{
m_IndexToWorldTransform->SetIdentity();
m_Origin.Fill(0);
Modified();
TransferItkToVtkTransform();
}
void mitk::Geometry3D::Compose( const mitk::AffineGeometryFrame3D::TransformType * other, bool pre )
{
m_IndexToWorldTransform->Compose(other, pre);
CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
Modified();
TransferItkToVtkTransform();
}
void mitk::Geometry3D::Compose( const vtkMatrix4x4 * vtkmatrix, bool pre )
{
mitk::AffineGeometryFrame3D::TransformType::Pointer itkTransform = mitk::AffineGeometryFrame3D::TransformType::New();
TransferVtkMatrixToItkTransform(vtkmatrix, itkTransform.GetPointer());
Compose(itkTransform, pre);
}
const std::string mitk::Geometry3D::GetTransformAsString( TransformType* transformType )
{
std::ostringstream out;
out << '[';
for( int i=0; i<3; ++i )
{
out << '[';
for( int j=0; j<3; ++j )
out << transformType->GetMatrix().GetVnlMatrix().get(i, j) << ' ';
out << ']';
}
out << "][";
for( int i=0; i<3; ++i )
out << transformType->GetOffset()[i] << ' ';
out << "]\0";
return out.str();
}
void mitk::Geometry3D::PrintSelf(std::ostream& os, itk::Indent indent) const
{
os << indent << " IndexToWorldTransform: ";
if(m_IndexToWorldTransform.IsNull())
os << "NULL" << std::endl;
else
{
// from itk::MatrixOffsetTransformBase
unsigned int i, j;
os << std::endl;
os << indent << "Matrix: " << std::endl;
for (i = 0; i < 3; i++)
{
os << indent.GetNextIndent();
for (j = 0; j < 3; j++)
{
os << m_IndexToWorldTransform->GetMatrix()[i][j] << " ";
}
os << std::endl;
}
os << indent << "Offset: " << m_IndexToWorldTransform->GetOffset() << std::endl;
os << indent << "Center: " << m_IndexToWorldTransform->GetCenter() << std::endl;
os << indent << "Translation: " << m_IndexToWorldTransform->GetTranslation() << std::endl;
os << indent << "Inverse: " << std::endl;
for (i = 0; i < 3; i++)
{
os << indent.GetNextIndent();
for (j = 0; j < 3; j++)
{
os << m_IndexToWorldTransform->GetInverseMatrix()[i][j] << " ";
}
os << std::endl;
}
// from itk::ScalableAffineTransform
os << indent << "Scale : ";
for (i = 0; i < 3; i++)
{
os << m_IndexToWorldTransform->GetScale()[i] << " ";
}
os << std::endl;
}
os << indent << " BoundingBox: ";
if(m_BoundingBox.IsNull())
os << "NULL" << std::endl;
else
{
os << indent << "( ";
for (unsigned int i=0; i<3; i++)
{
os << m_BoundingBox->GetBounds()[2*i] << "," << m_BoundingBox->GetBounds()[2*i+1] << " ";
}
os << " )" << std::endl;
}
os << indent << " Origin: " << m_Origin << std::endl;
os << indent << " ImageGeometry: " << m_ImageGeometry << std::endl;
os << indent << " Spacing: " << m_Spacing << std::endl;
os << indent << " TimeBounds: " << m_TimeBounds << std::endl;
}
mitk::Point3D mitk::Geometry3D::GetCornerPoint(int id) const
{
assert(id >= 0);
assert(m_BoundingBox.IsNotNull());
BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
Point3D cornerpoint;
switch(id)
{
case 0: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[4]); break;
case 1: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[5]); break;
case 2: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[4]); break;
case 3: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[5]); break;
case 4: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[4]); break;
case 5: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[5]); break;
case 6: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[4]); break;
case 7: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[5]); break;
default:
{
itkExceptionMacro(<<"A cube only has 8 corners. These are labeled 0-7.");
- return NULL;
}
}
if(m_ImageGeometry)
{
// Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
// bounding box. The bounding box itself is no image, so it is corner-based
FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5);
}
return m_IndexToWorldTransform->TransformPoint(cornerpoint);
}
mitk::Point3D mitk::Geometry3D::GetCornerPoint(bool xFront, bool yFront, bool zFront) const
{
assert(m_BoundingBox.IsNotNull());
BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
Point3D cornerpoint;
cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
if(m_ImageGeometry)
{
// Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
// bounding box. The bounding box itself is no image, so it is corner-based
FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5);
}
return m_IndexToWorldTransform->TransformPoint(cornerpoint);
}
void
mitk::Geometry3D::ResetSubTransforms()
{
}
void
mitk::Geometry3D::ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry )
{
// If Geometry is switched to ImageGeometry, you have to put an offset to the origin, because
// imageGeometries origins are pixel-center-based
// ... and remove the offset, if you switch an imageGeometry back to a normal geometry
// For more information please see the Geometry documentation page
if(m_ImageGeometry == isAnImageGeometry)
return;
const BoundingBox::BoundsArrayType& boundsarray =
this->GetBoundingBox()->GetBounds();
Point3D originIndex;
FillVector3D(originIndex, boundsarray[0], boundsarray[2], boundsarray[4]);
if(isAnImageGeometry == true)
FillVector3D( originIndex,
originIndex[0] + 0.5,
originIndex[1] + 0.5,
originIndex[2] + 0.5 );
else
FillVector3D( originIndex,
originIndex[0] - 0.5,
originIndex[1] - 0.5,
originIndex[2] - 0.5 );
Point3D originWorld;
originWorld = GetIndexToWorldTransform()
->TransformPoint( originIndex );
// instead could as well call IndexToWorld(originIndex,originWorld);
SetOrigin(originWorld);
this->SetImageGeometry(isAnImageGeometry);
}
bool mitk::Geometry3D::Is2DConvertable()
{
bool isConvertableWithoutLoss = true;
do
{
if (this->GetSpacing()[2] != 1)
{
isConvertableWithoutLoss = false;
break;
}
if (this->GetOrigin()[2] != 0)
{
isConvertableWithoutLoss = false;
break;
}
mitk::Vector3D col0, col1, col2;
- col0.Set_vnl_vector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
- col1.Set_vnl_vector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
- col2.Set_vnl_vector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
+ col0.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
+ col1.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
+ col2.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
if ((col0[2] != 0) || (col1[2] != 0) || (col2[0] != 0) || (col2[1] != 0) || (col2[2] != 1))
{
isConvertableWithoutLoss = false;
break;
}
} while (0);
return isConvertableWithoutLoss;
}
diff --git a/Core/Code/DataManagement/mitkGeometry3D.h b/Core/Code/DataManagement/mitkGeometry3D.h
index 3734994d50..3f5bdd424e 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.h
+++ b/Core/Code/DataManagement/mitkGeometry3D.h
@@ -1,670 +1,669 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
#define GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
#include <MitkExports.h>
#include <mitkCommon.h>
#include "mitkVector.h"
#include "mitkOperationActor.h"
#include <itkIndex.h>
#include <itkBoundingBox.h>
#include <itkQuaternionRigidTransform.h>
#include <itkAffineGeometryFrame.h>
class vtkLinearTransform;
class vtkMatrixToLinearTransform;
class vtkMatrix4x4;
namespace mitk {
//##Documentation
//## @brief Standard 3D-BoundingBox typedef
//##
//## Standard 3D-BoundingBox typedef to get rid of template arguments (3D, type).
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBox;
//##Documentation
//## @brief Standard typedef for time-bounds
typedef itk::FixedArray<ScalarType,2> TimeBounds;
typedef itk::FixedArray<ScalarType, 3> FixedArrayType;
typedef itk::AffineGeometryFrame<ScalarType, 3> AffineGeometryFrame3D;
//##Documentation
//## @brief Describes the geometry of a data object
//##
//## At least, it can return the bounding box of the data object.
//##
//## The class holds
//## \li a bounding box which is axes-parallel in intrinsic coordinates
//## (often integer indices of pixels), to be accessed by
//## GetBoundingBox()
//## \li a transform to convert intrinsic coordinates into a
//## world-coordinate system with coordinates in millimeters
//## and milliseconds (all are floating point values), to
//## be accessed by GetIndexToWorldTransform()
//## \li a life span, i.e. a bounding box in time in ms (with
//## start and end time), to be accessed by GetTimeBounds().
//## The default is minus infinity to plus infinity.
//##
//## Geometry3D and its sub-classes allow converting between
//## intrinsic coordinates (called index or unit coordinates)
//## and world-coordinates (called world or mm coordinates),
//## e.g. WorldToIndex.
//## In case you need integer index coordinates, provide an
//## mitk::Index3D (or itk::Index) as target variable to
//## WorldToIndex, otherwise you will get a continuous index
//## (floating point values).
//##
//## An important sub-class is SlicedGeometry3D, which descibes
//## data objects consisting of slices, e.g., objects of type Image.
//## Conversions between world coordinates (in mm) and unit coordinates
//## (e.g., pixels in the case of an Image) can be performed.
//##
//## For more information on related classes, see \ref Geometry.
//##
//## Geometry3D instances referring to an Image need a slightly
//## different definition of corners, see SetImageGeometry. This
//## is usualy automatically called by Image.
//##
//## Geometry3D have to be initialized in the method GenerateOutputInformation()
//## of BaseProcess (or CopyInformation/ UpdateOutputInformation of BaseData,
//## if possible, e.g., by analyzing pic tags in Image) subclasses. See also
//## itk::ProcessObject::GenerateOutputInformation(),
//## itk::DataObject::CopyInformation() and
//## itk::DataObject::UpdateOutputInformation().
//##
//## Rule: everything is in mm (ms) if not stated otherwise.
//## @ingroup Geometry
class MITK_CORE_EXPORT Geometry3D : public AffineGeometryFrame3D, public OperationActor
{
public:
mitkClassMacro(Geometry3D, AffineGeometryFrame3D);
typedef itk::QuaternionRigidTransform< ScalarType > QuaternionTransformType;
typedef QuaternionTransformType::VnlQuaternionType VnlQuaternionType;
/** Method for creation through the object factory. */
itkNewMacro(Self);
// a bit of a misuse, but we want only doxygen to see the following:
#ifdef DOXYGEN_SKIP
//##Documentation
//## @brief Get the transformation used to convert from index
//## to world coordinates
itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
#endif
//## @brief Set the transformation used to convert from index
//## to world coordinates
virtual void SetIndexToWorldTransform(mitk::AffineTransform3D* transform);
//##Documentation
//## @brief Convenience method for setting the ITK transform
//## (m_IndexToWorldTransform) via an vtkMatrix4x4
//## \sa SetIndexToWorldTransform
virtual void SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix);
#ifdef DOXYGEN_SKIP
//##Documentation
//## @brief Get bounding box (in index/unit coordinates)
itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
//##Documentation
//## @brief Get bounding box (in index/unit coordinates) as a BoundsArrayType
const BoundsArrayType GetBounds() const
{
assert(m_BoundingBox.IsNotNull());
return m_BoundingBox->GetBounds();
}
//##Documentation
//## \brief Set the bounding box (in index/unit coordinates)
//##
//## Only possible via the BoundsArray to make clear that a
//## copy of the bounding-box is stored, not a reference to it.
virtual void SetBounds(const BoundsArrayType& bounds);
#endif
//##Documentation
//## @brief Set the bounding box (in index/unit coordinates) via a float array
virtual void SetFloatBounds(const float bounds[6]);
//##Documentation
//## @brief Set the bounding box (in index/unit coordinates) via a double array
virtual void SetFloatBounds(const double bounds[6]);
//##Documentation
//## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
//##Documentation
//## @brief Checks, if the given geometry can be converted to 2D without information loss
//## e.g. when a 2D image is saved, the matrix is usually cropped to 2x2, and when you load it back to MITK
//## it will be filled with standard values. This function checks, if information would be lost during this
//## procedure
virtual bool Is2DConvertable();
//##Documentation
//## @brief Get the time bounds (in ms)
itkGetConstReferenceMacro(TimeBounds, TimeBounds);
//##Documentation
//## @brief Set the time bounds (in ms)
virtual void SetTimeBounds(const TimeBounds& timebounds);
//##Documentation
//## @brief Get the position of the corner number \a id (in world coordinates)
//##
//## See SetImageGeometry for how a corner is defined on images.
Point3D GetCornerPoint(int id) const;
//##Documentation
//## @brief Get the position of a corner (in world coordinates)
//##
//## See SetImageGeometry for how a corner is defined on images.
Point3D GetCornerPoint(bool xFront=true, bool yFront=true, bool zFront=true) const;
//##Documentation
//## @brief Get vector along bounding-box in the specified @a direction in mm
//##
//## The length of the vector is the size of the bounding-box in the
//## specified @a direction in mm
//## \sa GetMatrixColumn
Vector3D GetAxisVector(unsigned int direction) const
{
Vector3D frontToBack;
- frontToBack.Set_vnl_vector(m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction));
+ frontToBack.SetVnlVector(m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction));
frontToBack *= GetExtent(direction);
return frontToBack;
}
//##Documentation
//## @brief Get the center of the bounding-box in mm
//##
Point3D GetCenter() const
{
assert(m_BoundingBox.IsNotNull());
return m_IndexToWorldTransform->TransformPoint(m_BoundingBox->GetCenter());
}
//##Documentation
//## @brief Get the squared length of the diagonal of the bounding-box in mm
//##
double GetDiagonalLength2() const
{
Vector3D diagonalvector = GetCornerPoint()-GetCornerPoint(false, false, false);
return diagonalvector.GetSquaredNorm();
}
//##Documentation
//## @brief Get the length of the diagonal of the bounding-box in mm
//##
double GetDiagonalLength() const
{
return sqrt(GetDiagonalLength2());
}
//##Documentation
//## @brief Get a VnlVector along bounding-box in the specified
//## @a direction, length is spacing
//##
//## \sa GetAxisVector
VnlVector GetMatrixColumn(unsigned int direction) const
{
return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction);
}
#ifdef DOXYGEN_SKIP
//##Documentation
//## @brief Get the extent of the bounding box (in index/unit coordinates)
//##
//## To access the extent in mm use GetExtentInMM
ScalarType GetExtent(unsigned int direction) const;
#endif
//##Documentation
//## @brief Get the extent of the bounding-box in the specified @a direction in mm
//##
//## Equals length of GetAxisVector(direction).
ScalarType GetExtentInMM(int direction) const
{
return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction).magnitude()*GetExtent(direction);
}
//##Documentation
//## @brief Set the extent of the bounding-box in the specified @a direction in mm
//##
//## @note This changes the matrix in the transform, @a not the bounds, which are given in units!
virtual void SetExtentInMM(int direction, ScalarType extentInMM);
//##Documentation
//## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
vtkLinearTransform* GetVtkTransform() const
{
return (vtkLinearTransform*)m_VtkIndexToWorldTransform;
}
//##Documentation
//## @brief Set the origin, i.e. the upper-left corner of the plane
//##
virtual void SetOrigin(const Point3D& origin);
//##Documentation
//## @brief Translate the origin by a vector
//##
virtual void Translate(const Vector3D& vector);
//##Documentation
//## @brief Set the transform to identity
//##
virtual void SetIdentity();
//##Documentation
//## @brief Compose new IndexToWorldTransform with a given transform.
//##
//## This method composes m_IndexToWorldTransform with another transform,
//## modifying self to be the composition of self and other.
//## If the argument pre is true, then other is precomposed with self;
//## that is, the resulting transformation consists of first applying
//## other to the source, followed by self. If pre is false or omitted,
//## then other is post-composed with self; that is the resulting
//## transformation consists of first applying self to the source,
//## followed by other.
virtual void Compose( const AffineGeometryFrame3D::TransformType * other, bool pre = 0 );
//##Documentation
//## @brief Compose new IndexToWorldTransform with a given vtkMatrix4x4.
//##
//## Converts the vtkMatrix4x4 into a itk-transform and calls the previous method.
virtual void Compose( const vtkMatrix4x4 * vtkmatrix, bool pre = 0 );
//##Documentation
//## @brief Get the origin, e.g. the upper-left corner of the plane
const Point3D& GetOrigin() const
{
return m_Origin;
}
//##Documentation
//## @brief Get the origin as VnlVector
//##
//## \sa GetOrigin
VnlVector GetOriginVnl() const
{
- return const_cast<Self*>(this)->m_Origin.Get_vnl_vector();
+ return const_cast<Self*>(this)->m_Origin.GetVnlVector();
}
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em point to (continuous!) index coordinates
//## \warning If you need (discrete) integer index coordinates (e.g., for iterating easily over an image),
//## use WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index).
//## For further information about coordinates types, please see the Geometry documentation
void WorldToIndex(const mitk::Point3D& pt_mm, mitk::Point3D& pt_units) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em point to world coordinates (in mm)
//## For further information about coordinates types, please see the Geometry documentation
void IndexToWorld(const mitk::Point3D& pt_units, mitk::Point3D& pt_mm) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## @deprecated First parameter (Point3D) is not used. If possible, please use void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const.
//## For further information about coordinates types, please see the Geometry documentation
void WorldToIndex(const mitk::Point3D& atPt3d_mm, const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## For further information about coordinates types, please see the Geometry documentation
void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## @deprecated First parameter (Point3D) is not used. If possible, please use void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const.
//## For further information about coordinates types, please see the Geometry documentation
void IndexToWorld(const mitk::Point3D& atPt3d_units, const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## For further information about coordinates types, please see the Geometry documentation
void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em point to (discrete!) index coordinates.
//## This method rounds to integer indices!
//## For further information about coordinates types, please see the Geometry documentation
template <unsigned int VIndexDimension>
void WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index) const
{
typedef itk::Index<VIndexDimension> IndexType;
mitk::Point3D pt_units;
this->WorldToIndex(pt_mm, pt_units);
int i, dim=index.GetIndexDimension();
if(dim>3)
{
index.Fill(0);
dim=3;
}
for(i=0;i<dim;++i){
- //index[i]=itk::Math::RoundHalfIntegerUp<typename IndexType::IndexValueType >( pt_units[i] );
- index[i]=itk::Math::RoundHalfIntegerUp( pt_units[i] );
+ index[i]=itk::Math::RoundHalfIntegerUp<typename IndexType::IndexValueType>( pt_units[i] );
}
}
//##Documentation
//## @brief Deprecated for use with ITK version 3.10 or newer.
//## Convert world coordinates (in mm) of a \em point to
//## ITK physical coordinates (in mm, but without a possible rotation)
//##
//## This method is useful if you have want to access an mitk::Image
//## via an itk::Image. ITK v3.8 and older did not support rotated (tilted)
//## images, i.e., ITK images are always parallel to the coordinate axes.
//## When accessing a (possibly rotated) mitk::Image via an itk::Image
//## the rotational part of the transformation in the Geometry3D is
//## simply discarded; in other word: only the origin and spacing is
//## used by ITK, not the complete matrix available in MITK.
//## With WorldToItkPhysicalPoint you can convert an MITK world
//## coordinate (including the rotation) into a coordinate that
//## can be used with the ITK image as a ITK physical coordinate
//## (excluding the rotation).
template<class TCoordRep>
void WorldToItkPhysicalPoint(const mitk::Point3D& pt_mm,
itk::Point<TCoordRep, 3>& itkPhysicalPoint) const
{
mitk::vtk2itk(pt_mm, itkPhysicalPoint);
}
//##Documentation
//## @brief Deprecated for use with ITK version 3.10 or newer.
//## Convert ITK physical coordinates of a \em point (in mm,
//## but without a rotation) into MITK world coordinates (in mm)
//##
//## For more information, see WorldToItkPhysicalPoint.
template<class TCoordRep>
void ItkPhysicalPointToWorld(const itk::Point<TCoordRep, 3>& itkPhysicalPoint,
mitk::Point3D& pt_mm) const
{
mitk::vtk2itk(itkPhysicalPoint, pt_mm);
}
//##Documentation
//## @brief Initialize the Geometry3D
virtual void Initialize();
//##Documentation
//## @brief Is this an ImageGeometry?
//##
//## For more information, see SetImageGeometry
itkGetConstMacro(ImageGeometry, bool);
//##Documentation
//## @brief Define that this Geometry3D is refering to an Image
//##
//## A geometry referring to an Image needs a slightly different
//## definition of the position of the corners (see GetCornerPoint).
//## The position of a voxel is defined by the position of its center.
//## If we would use the origin (position of the (center of) the first
//## voxel) as a corner and display this point, it would seem to be
//## \em not at the corner but a bit within the image. Even worse for
//## the opposite corner of the image: here the corner would appear
//## outside the image (by half of the voxel diameter). Thus, we have
//## to correct for this and to be able to do that, we need to know
//## that the Geometry3D is referring to an Image.
itkSetMacro(ImageGeometry, bool);
itkBooleanMacro(ImageGeometry);
//##Documentation
//## @brief Is this Geometry3D in a state that is valid?
virtual bool IsValid() const
{
return m_Valid;
}
//##Documentation
//## @brief Test whether the point \a p (world coordinates in mm) is
//## inside the bounding box
bool IsInside(const mitk::Point3D& p) const
{
mitk::Point3D index;
WorldToIndex(p, index);
return IsIndexInside(index);
}
//##Documentation
//## @brief Test whether the point \a p ((continous!)index coordinates in units) is
//## inside the bounding box
bool IsIndexInside(const mitk::Point3D& index) const
{
bool inside = false;
//if it is an image geometry, we need to convert the index to discrete values
//this is done by applying the rounding function also used in WorldToIndex (see line 323)
if (m_ImageGeometry)
{
mitk::Point3D discretIndex;
- discretIndex[0]=itk::Math::RoundHalfIntegerUp( index[0] );
- discretIndex[1]=itk::Math::RoundHalfIntegerUp( index[1] );
- discretIndex[2]=itk::Math::RoundHalfIntegerUp( index[2] );
+ discretIndex[0]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[0] );
+ discretIndex[1]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[1] );
+ discretIndex[2]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[2] );
inside = m_BoundingBox->IsInside(discretIndex);
//we have to check if the index is at the upper border of each dimension,
// because the boundingbox is not centerbased
if (inside)
{
const BoundingBox::BoundsArrayType& bounds = m_BoundingBox->GetBounds();
if((discretIndex[0] == bounds[1]) ||
(discretIndex[1] == bounds[3]) ||
(discretIndex[2] == bounds[5]))
inside = false;
}
}
else
inside = m_BoundingBox->IsInside(index);
return inside;
}
//##Documentation
//## @brief Convenience method for working with ITK indices
template <unsigned int VIndexDimension>
bool IsIndexInside(const itk::Index<VIndexDimension> &index) const
{
int i, dim=index.GetIndexDimension();
Point3D pt_index;
pt_index.Fill(0);
for ( i = 0; i < dim; ++i )
{
pt_index[i] = index[i];
}
return IsIndexInside(pt_index);
}
//##Documentation
//## @brief Get the spacing (size of a pixel).
//##
itkGetConstReferenceMacro(Spacing, mitk::Vector3D);
//##Documentation
//## @brief Get the spacing as a float[3] array.
const float* GetFloatSpacing() const;
//##Documentation
//## @brief Set the spacing (m_Spacing)
virtual void SetSpacing(const mitk::Vector3D& aSpacing);
//##Documentation
//## @brief Get the DICOM FrameOfReferenceID referring to the
//## used world coordinate system
itkGetConstMacro(FrameOfReferenceID, unsigned int);
//##Documentation
//## @brief Set the DICOM FrameOfReferenceID referring to the
//## used world coordinate system
itkSetMacro(FrameOfReferenceID, unsigned int);
//##Documentation
//## @brief Copy the ITK transform
//## (m_IndexToWorldTransform) to the VTK transform
//## \sa SetIndexToWorldTransform
void TransferItkToVtkTransform();
//##Documentation
//## @brief Copy the VTK transform
//## to the ITK transform (m_IndexToWorldTransform)
//## \sa SetIndexToWorldTransform
void TransferVtkToItkTransform();
//##Documentation
//## @brief Get the parametric bounding-box
//##
//## See AbstractTransformGeometry for an example usage of this.
itkGetConstObjectMacro(ParametricBoundingBox, BoundingBox);
//##Documentation
//## @brief Get the parametric bounds
//##
//## See AbstractTransformGeometry for an example usage of this.
const BoundingBox::BoundsArrayType& GetParametricBounds() const
{
assert(m_ParametricBoundingBox.IsNotNull());
return m_ParametricBoundingBox->GetBounds();
}
//##Documentation
//## @brief Get the parametric extent
//##
//## See AbstractTransformGeometry for an example usage of this.
mitk::ScalarType GetParametricExtent(int direction) const
{
assert(direction>=0 && direction<3);
assert(m_ParametricBoundingBox.IsNotNull());
BoundingBoxType::BoundsArrayType bounds = m_ParametricBoundingBox->GetBounds();
return bounds[direction*2+1]-bounds[direction*2];
}
//##Documentation
//## @brief Get the parametric extent in mm
//##
//## See AbstractTransformGeometry for an example usage of this.
virtual mitk::ScalarType GetParametricExtentInMM(int direction) const
{
return GetExtentInMM(direction);
}
//##Documentation
//## @brief Get the parametric transform
//##
//## See AbstractTransformGeometry for an example usage of this.
virtual const Transform3D* GetParametricTransform() const
{
return m_IndexToWorldTransform;
}
//##Documentation
//## @brief Calculates a bounding-box around the geometry relative
//## to a coordinate system defined by a transform
//##
mitk::BoundingBox::Pointer CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const;
//##Documentation
//## @brief clones the geometry
//##
//## Overwrite in all sub-classes.
//## Normally looks like:
//## \code
//## Self::Pointer newGeometry = new Self(*this);
//## newGeometry->UnRegister();
//## return newGeometry.GetPointer();
//## \endcode
- virtual AffineGeometryFrame3D::Pointer Clone() const;
+ virtual itk::LightObject::Pointer InternalClone() const;
//##Documentation
//##@brief executes affine operations (translate, rotate, scale)
virtual void ExecuteOperation(Operation* operation);
protected:
Geometry3D();
Geometry3D(const Geometry3D& other);
static const std::string GetTransformAsString( TransformType* transformType );
virtual ~Geometry3D();
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
virtual void BackTransform(const mitk::Point3D& in, mitk::Point3D& out) const;
//##Documentation
//## @brief Deprecated
virtual void BackTransform(const mitk::Point3D& at, const mitk::Vector3D& in, mitk::Vector3D& out) const;
//Without redundant parameter Point3D
virtual void BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const;
//##Documentation
//## @brief Set the parametric bounds
//##
//## Protected in this class, made public in some sub-classes, e.g.,
//## ExternAbstractTransformGeometry.
virtual void SetParametricBounds(const BoundingBox::BoundsArrayType& bounds);
/** Resets sub-transforms that compose m_IndexToWorldTransform, by using
* the current value of m_IndexToWorldTransform and setting the rotation
* component to zero. */
virtual void ResetSubTransforms();
mutable mitk::BoundingBox::Pointer m_ParametricBoundingBox;
mutable mitk::TimeBounds m_TimeBounds;
vtkMatrix4x4* m_VtkMatrix;
bool m_ImageGeometry;
//##Documentation
//## @brief Spacing of the data. Only significant if the geometry describes
//## an Image (m_ImageGeometry==true).
mitk::Vector3D m_Spacing;
bool m_Valid;
unsigned int m_FrameOfReferenceID;
static const std::string INDEX_TO_OBJECT_TRANSFORM;
static const std::string OBJECT_TO_NODE_TRANSFORM;
static const std::string INDEX_TO_NODE_TRANSFORM;
static const std::string INDEX_TO_WORLD_TRANSFORM;
private:
mutable TransformType::Pointer m_InvertedTransform;
mutable unsigned long m_IndexToWorldTransformLastModified;
VnlQuaternionType m_RotationQuaternion;
float m_FloatSpacing[3];
vtkMatrixToLinearTransform* m_VtkIndexToWorldTransform;
//##Documentation
//## @brief Origin, i.e. upper-left corner of the plane
//##
Point3D m_Origin;
};
} // namespace mitk
#endif /* GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkGeometryData.cpp b/Core/Code/DataManagement/mitkGeometryData.cpp
index e30d4597a2..c935d6a297 100644
--- a/Core/Code/DataManagement/mitkGeometryData.cpp
+++ b/Core/Code/DataManagement/mitkGeometryData.cpp
@@ -1,64 +1,64 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkGeometryData.h"
#include "mitkBaseProcess.h"
mitk::GeometryData::GeometryData()
{
}
mitk::GeometryData::~GeometryData()
{
}
void mitk::GeometryData::UpdateOutputInformation()
{
Superclass::UpdateOutputInformation();
}
void mitk::GeometryData::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::GeometryData::RequestedRegionIsOutsideOfTheBufferedRegion()
{
if(GetGeometry()!=NULL) return true;
return false;
}
bool mitk::GeometryData::VerifyRequestedRegion()
{
if(GetGeometry()==NULL) return false;
return true;
}
-void mitk::GeometryData::SetRequestedRegion(itk::DataObject *)
+void mitk::GeometryData::SetRequestedRegion( const itk::DataObject *)
{
}
void mitk::GeometryData::CopyInformation(const itk::DataObject *)
{
}
diff --git a/Core/Code/DataManagement/mitkGeometryData.h b/Core/Code/DataManagement/mitkGeometryData.h
index 8d0bf7e41d..3ee09e818e 100644
--- a/Core/Code/DataManagement/mitkGeometryData.h
+++ b/Core/Code/DataManagement/mitkGeometryData.h
@@ -1,57 +1,57 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKGEOMETRYDATA_H_HEADER_INCLUDED_C19C01E2
#define MITKGEOMETRYDATA_H_HEADER_INCLUDED_C19C01E2
#include "mitkBaseData.h"
namespace mitk {
//##Documentation
//## @brief Data class only having a Geometry3D but not containing
//## any specific data.
//##
//## Only implements pipeline methods which are abstract in BaseData.
//## @ingroup Geometry
class MITK_CORE_EXPORT GeometryData : public BaseData
{
public:
mitkClassMacro(GeometryData, BaseData);
itkNewMacro(Self);
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion( const itk::DataObject *data);
virtual void CopyInformation(const itk::DataObject *data);
protected:
GeometryData();
virtual ~GeometryData();
};
} // namespace mitk
#endif /* MITKGEOMETRYDATA_H_HEADER_INCLUDED_C19C01E2 */
diff --git a/Core/Code/DataManagement/mitkGroupTagProperty.cpp b/Core/Code/DataManagement/mitkGroupTagProperty.cpp
index 6b78c083fb..0c93e446d3 100644
--- a/Core/Code/DataManagement/mitkGroupTagProperty.cpp
+++ b/Core/Code/DataManagement/mitkGroupTagProperty.cpp
@@ -1,52 +1,46 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkGroupTagProperty.h"
mitk::GroupTagProperty::GroupTagProperty()
: mitk::BaseProperty()
{
}
mitk::GroupTagProperty::GroupTagProperty(const GroupTagProperty& other)
: mitk::BaseProperty(other)
{
}
bool mitk::GroupTagProperty::IsEqual(const BaseProperty& /*property*/) const
{
// if other property is also a GroupTagProperty, then it is equal to us, because tags have no value themselves
return true;
}
bool mitk::GroupTagProperty::Assign(const BaseProperty& /*property*/)
{
return true;
}
-mitk::GroupTagProperty::Pointer mitk::GroupTagProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::GroupTagProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkGroupTagProperty.h b/Core/Code/DataManagement/mitkGroupTagProperty.h
index 2bb258642e..44afe7eebf 100644
--- a/Core/Code/DataManagement/mitkGroupTagProperty.h
+++ b/Core/Code/DataManagement/mitkGroupTagProperty.h
@@ -1,71 +1,69 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef GROUPTAGPROPERTY_H_HEADER_INCLUDED_C1F4DF54
#define GROUPTAGPROPERTY_H_HEADER_INCLUDED_C1F4DF54
#include <mitkBaseProperty.h>
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/*! @brief Property class that has no value.
@ingroup DataManagement
The GroupTag property is used to tag a datatree node to show, that it is member of a
group of datatree nodes. This can be used to build groups of datatreenodes without the
need to contain them in a specific hiearchic order in the datatree
*/
class MITK_CORE_EXPORT GroupTagProperty : public BaseProperty
{
public:
mitkClassMacro(GroupTagProperty, BaseProperty);
itkNewMacro(GroupTagProperty);
- Pointer Clone() const;
-
using BaseProperty::operator=;
protected:
GroupTagProperty();
GroupTagProperty(const GroupTagProperty&);
private:
// purposely not implemented
GroupTagProperty& operator=(const GroupTagProperty&);
itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty& property) const;
virtual bool Assign(const BaseProperty& property);
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif /* GROUPTAGPROPERTY_H_HEADER_INCLUDED_C1F4DF54 */
diff --git a/Core/Code/DataManagement/mitkITKImageImport.h b/Core/Code/DataManagement/mitkITKImageImport.h
index 80695fab48..d2f2ebb7ab 100644
--- a/Core/Code/DataManagement/mitkITKImageImport.h
+++ b/Core/Code/DataManagement/mitkITKImageImport.h
@@ -1,177 +1,194 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKITKIMAGEIMPORT_H_HEADER_INCLUDED_C1E4861D
#define MITKITKIMAGEIMPORT_H_HEADER_INCLUDED_C1E4861D
#include <MitkExports.h>
#include "mitkImageSource.h"
#include "itkImageToImageFilterDetail.h"
namespace mitk {
-//##Documentation
-//## @brief Pipelined import of itk::Image
-//##
-//## The image data contained in the itk::Image is referenced,
-//## not copied.
-//## The easiest way of use is by the function
-//## mitk::ImportItkImage
-//## \code
-//## mitkImage = mitk::ImportItkImage(itkImage);
-//## \endcode
-//## \sa ImportItkImage
-//## @ingroup Adaptor
+/**
+* @brief Pipelined import of itk::Image
+*
+* The image data contained in the itk::Image is referenced,
+* not copied.
+* The easiest way of use is by the function
+* mitk::ImportItkImage
+* \code
+* mitkImage = mitk::ImportItkImage(itkImage);
+* \endcode
+* \sa ImportItkImage
+* @ingroup Adaptor
+*/
template <class TInputImage>
class MITK_EXPORT ITKImageImport : public ImageSource
{
public:
- mitkClassMacro(ITKImageImport,ImageSource);
- itkNewMacro(Self);
+ mitkClassMacro(ITKImageImport,ImageSource)
+ itkNewMacro(Self)
- //##Documentation
- //## \brief The type of the input image.
+ /// \brief The type of the input image.
typedef TInputImage InputImageType;
typedef typename InputImageType::Pointer InputImagePointer;
typedef typename InputImageType::ConstPointer InputImageConstPointer;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef typename InputImageType::PixelType InputImagePixelType;
/** ImageDimension constants */
itkStaticConstMacro(InputImageDimension, unsigned int,
TInputImage::ImageDimension);
itkStaticConstMacro(RegionDimension, unsigned int,
mitk::SlicedData::RegionDimension);
- //##Documentation
- //## \brief Set the input itk::Image of this image importer.
+ /** \brief Set the input itk::Image of this image importer. */
InputImageType * GetInput(void);
- //##Documentation
- //## \brief Set the input itk::Image of this image importer.
+ /** \brief Set the input itk::Image of this image importer. */
void SetInput(const InputImageType*);
-
- //##Documentation
- //## \brief Set the Geometry of the result image (optional)
- //##
- //## The Geometry has to fit the dimension and size of
- //## the input image. The Geometry will be cloned, not
- //## referenced!
- //##
- //## Providing the Geometry is optional.
- //## The default behavior is to set the geometry by
- //## the itk::Image::GetDirection() information.
+ using itk::ProcessObject::SetInput;
+
+ /**
+ * \brief Set the Geometry of the result image (optional)
+ *
+ * The Geometry has to fit the dimension and size of
+ * the input image. The Geometry will be cloned, not
+ * referenced!
+ *
+ * Providing the Geometry is optional.
+ * The default behavior is to set the geometry by
+ * the itk::Image::GetDirection() information.
+ */
void SetGeometry(const Geometry3D* geometry);
protected:
ITKImageImport();
virtual ~ITKImageImport();
virtual void GenerateOutputInformation();
virtual void GenerateInputRequestedRegion();
virtual void GenerateData();
- virtual void SetNthOutput(unsigned int num, itk::DataObject *output);
+ virtual void SetNthOutput(DataObjectPointerArraySizeType num, itk::DataObject *output);
/** Typedef for the region copier function object that converts an
* output region to an input region. */
typedef itk::ImageToImageFilterDetail::ImageRegionCopier<itkGetStaticConstMacro(InputImageDimension),
- itkGetStaticConstMacro(RegionDimension)> OutputToInputRegionCopierType;
+ itkGetStaticConstMacro(RegionDimension)> OutputToInputRegionCopierType;
Geometry3D::Pointer m_Geometry;
};
-//##Documentation
-//## @brief Imports an itk::Image (with a specific type) as an mitk::Image.
-//## @ingroup Adaptor
-//##
-//## Instantiates instance of ITKImageImport.
-//## mitk::ITKImageImport does not cast pixel types etc., it just imports
-//## image data. If you get a compile error, try image.GetPointer().
-//##
-//## \param update: if \a true, fill mitk::Image, which will execute the
-//## up-stream pipeline connected to the input itk::Image. Otherwise you
-//## need to make sure that Update() is called on the mitk::Image before
-//## its data is being used, e.g., by connecting it to an mitk-pipeline
-//## and call Update of a downstream filter at some time.
-//## \sa itk::Image::CastToMitkImage
+/**
+* @brief Imports an itk::Image (with a specific type) as an mitk::Image.
+* @ingroup Adaptor
+*
+* Instantiates instance of ITKImageImport.
+* mitk::ITKImageImport does not cast pixel types etc., it just imports
+* image data. If you get a compile error, try image.GetPointer().
+*
+* \param update: if \a true, fill mitk::Image, which will execute the
+* up-stream pipeline connected to the input itk::Image. Otherwise you
+* need to make sure that Update() is called on the mitk::Image before
+* its data is being used, e.g., by connecting it to an mitk-pipeline
+* and call Update of a downstream filter at some time.
+* \sa itk::Image::CastToMitkImage
+*/
template <typename ItkOutputImageType>
Image::Pointer ImportItkImage(const itk::SmartPointer<ItkOutputImageType>& itkimage, const Geometry3D* geometry = NULL, bool update = true);
-//##Documentation
-//## @brief Imports an itk::Image (with a specific type) as an mitk::Image.
-//## @ingroup Adaptor
-//##
-//## Instantiates instance of ITKImageImport
-//## mitk::ITKImageImport does not cast pixel types etc., it just imports
-//## image data. If you get a compile error, try image.GetPointer().
-//##
-//## \param update: if \a true, fill mitk::Image, which will execute the
-//## up-stream pipeline connected to the input itk::Image. Otherwise you
-//## need to make sure that Update() is called on the mitk::Image before
-//## its data is being used, e.g., by connecting it to an mitk-pipeline
-//## and call Update of a downstream filter at some time.
-//## \sa itk::Image::CastToMitkImage
-//## \sa GrabItkImageMemory
+/**
+* @brief Imports an itk::Image (with a specific type) as an mitk::Image.
+* @ingroup Adaptor
+*
+* Instantiates instance of ITKImageImport
+* mitk::ITKImageImport does not cast pixel types etc., it just imports
+* image data. If you get a compile error, try image.GetPointer().
+*
+* \param update: if \a true, fill mitk::Image, which will execute the
+* up-stream pipeline connected to the input itk::Image. Otherwise you
+* need to make sure that Update() is called on the mitk::Image before
+* its data is being used, e.g., by connecting it to an mitk-pipeline
+* and call Update of a downstream filter at some time.
+*
+*
+* \note If the source (itk image) and the target (mitk image) do not share the same scope, the mitk::GrabItkImageMemory function
+* has to be used instead. Otherwise the image memory managed by the itk image is lost at a scope level change. This affects especially the
+* usage in combination with AccessByItk macros as in following example code
+*
+* \snippet Testing/mitkGrabItkImageMemoryTest.cpp OutOfScopeCall
+*
+* which calls an ITK-like filter
+*
+* \snippet Testing/mitkGrabItkImageMemoryTest.cpp ItkThresholdFilter
+*
+*
+* \sa itk::Image::CastToMitkImage
+* \sa GrabItkImageMemory
+*/
template <typename ItkOutputImageType>
Image::Pointer ImportItkImage(const ItkOutputImageType* itkimage, const Geometry3D* geometry = NULL, bool update = true);
-//##Documentation
-//## @brief Grabs the memory of an itk::Image (with a specific type)
-//## and puts it into an mitk::Image.
-//## @ingroup Adaptor
-//##
-//## The memory is managed by the mitk::Image after calling this
-//## function. The itk::Image remains valid until the mitk::Image
-//## decides to free the memory.
-//## \param update: if \a true, fill mitk::Image, which will execute the
-//## up-stream pipeline connected to the input itk::Image. Otherwise you
-//## need to make sure that Update() is called on the mitk::Image before
-//## its data is being used, e.g., by connecting it to an mitk-pipeline
-//## and call Update of a downstream filter at some time.
-//## \sa ImportItkImage
+/**
+* @brief Grabs the memory of an itk::Image (with a specific type)
+* and puts it into an mitk::Image.
+* @ingroup Adaptor
+*
+* The memory is managed by the mitk::Image after calling this
+* function. The itk::Image remains valid until the mitk::Image
+* decides to free the memory.
+* \param update: if \a true, fill mitk::Image, which will execute the
+* up-stream pipeline connected to the input itk::Image. Otherwise you
+* need to make sure that Update() is called on the mitk::Image before
+* its data is being used, e.g., by connecting it to an mitk-pipeline
+* and call Update of a downstream filter at some time.
+* \sa ImportItkImage
+*/
template <typename ItkOutputImageType>
Image::Pointer GrabItkImageMemory(itk::SmartPointer<ItkOutputImageType>& itkimage, mitk::Image* mitkImage = NULL, const Geometry3D* geometry = NULL, bool update = true);
-//##Documentation
-//## @brief Grabs the memory of an itk::Image (with a specific type)
-//## and puts it into an mitk::Image.
-//## @ingroup Adaptor
-//##
-//## The memory is managed by the mitk::Image after calling this
-//## function. The itk::Image remains valid until the mitk::Image
-//## decides to free the memory.
-//## \param update: if \a true, fill mitk::Image, which will execute the
-//## up-stream pipeline connected to the input itk::Image. Otherwise you
-//## need to make sure that Update() is called on the mitk::Image before
-//## its data is being used, e.g., by connecting it to an mitk-pipeline
-//## and call Update of a downstream filter at some time.
-//## \sa ImportItkImage
+/**
+* @brief Grabs the memory of an itk::Image (with a specific type)
+* and puts it into an mitk::Image.
+* @ingroup Adaptor
+*
+* The memory is managed by the mitk::Image after calling this
+* function. The itk::Image remains valid until the mitk::Image
+* decides to free the memory.
+* \param update: if \a true, fill mitk::Image, which will execute the
+* up-stream pipeline connected to the input itk::Image. Otherwise you
+* need to make sure that Update() is called on the mitk::Image before
+* its data is being used, e.g., by connecting it to an mitk-pipeline
+* and call Update of a downstream filter at some time.
+* \sa ImportItkImage
+*/
template <typename ItkOutputImageType>
Image::Pointer GrabItkImageMemory(ItkOutputImageType* itkimage, mitk::Image* mitkImage = NULL, const Geometry3D* geometry = NULL, bool update = true);
} // namespace mitk
#ifndef MITK_MANUAL_INSTANTIATION
#include "mitkITKImageImport.txx"
#endif
#endif /* MITKITKIMAGEIMPORT_H_HEADER_INCLUDED_C1E4861D */
diff --git a/Core/Code/DataManagement/mitkITKImageImport.txx b/Core/Code/DataManagement/mitkITKImageImport.txx
index 7d01282b76..4123b34f20 100644
--- a/Core/Code/DataManagement/mitkITKImageImport.txx
+++ b/Core/Code/DataManagement/mitkITKImageImport.txx
@@ -1,177 +1,177 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkITKImageImport_txx
#define __mitkITKImageImport_txx
#include "mitkITKImageImport.h"
template <class TInputImage>
mitk::ITKImageImport<TInputImage>::ITKImageImport()
{
}
template <class TInputImage>
mitk::ITKImageImport<TInputImage>::~ITKImageImport()
{
}
template <class TInputImage>
typename mitk::ITKImageImport<TInputImage>::InputImageType *
mitk::ITKImageImport<TInputImage>::GetInput(void)
{
return static_cast<TInputImage*>(
this->ProcessObject::GetInput(0));
}
template <class TInputImage>
void mitk::ITKImageImport<TInputImage>::SetInput(const InputImageType* input)
{
this->ProcessObject::SetNthInput(0, const_cast<TInputImage*>(input) );
}
template <class TInputImage>
void mitk::ITKImageImport<TInputImage>::SetGeometry(const Geometry3D* geometry)
{
if(geometry != NULL)
{
m_Geometry = static_cast<mitk::Geometry3D*>(geometry->Clone().GetPointer());
}
else
{
m_Geometry = NULL;
}
Modified();
}
template <class TInputImage>
void mitk::ITKImageImport<TInputImage>::GenerateOutputInformation()
{
InputImageConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
itkDebugMacro(<<"GenerateOutputInformation()");
output->InitializeByItk(input.GetPointer());
if(m_Geometry.IsNotNull())
{
output->SetGeometry(m_Geometry);
}
}
template <class TInputImage>
void mitk::ITKImageImport<TInputImage>::GenerateData()
{
InputImageConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
output->SetImportChannel((void*)input->GetBufferPointer(), 0, mitk::Image::ReferenceMemory);
}
template <class TInputImage>
void mitk::ITKImageImport<TInputImage>::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
// Input is an image, cast away the constness so we can set
// the requested region.
InputImagePointer input =
const_cast< TInputImage * > ( this->GetInput() );
// Use the function object RegionCopier to copy the output region
// to the input. The default region copier has default implementations
// to handle the cases where the input and output are the same
// dimension, the input a higher dimension than the output, and the
// input a lower dimension than the output.
InputImageRegionType inputRegion;
OutputToInputRegionCopierType regionCopier;
regionCopier(inputRegion, this->GetOutput()->GetRequestedRegion());
input->SetRequestedRegion( inputRegion );
}
template <class TInputImage>
-void mitk::ITKImageImport<TInputImage>::SetNthOutput(unsigned int idx, itk::DataObject *output)
+void mitk::ITKImageImport<TInputImage>::SetNthOutput(DataObjectPointerArraySizeType idx, itk::DataObject *output)
{
if((output == NULL) && (idx == 0))
{
// we are disconnected from our output:
// copy buffer of input to output, because we
// cannot guarantee that the input (to which our
// output is refering) will stay alive.
InputImageConstPointer input = this->GetInput();
mitk::Image::Pointer currentOutput = this->GetOutput();
if(input.IsNotNull() && currentOutput.IsNotNull())
currentOutput->SetChannel(input->GetBufferPointer());
}
Superclass::SetNthOutput(idx, output);
}
template <typename ItkOutputImageType>
mitk::Image::Pointer mitk::ImportItkImage(const itk::SmartPointer<ItkOutputImageType>& itkimage, const Geometry3D* geometry, bool update)
{
typename mitk::ITKImageImport<ItkOutputImageType>::Pointer importer = mitk::ITKImageImport<ItkOutputImageType>::New();
importer->SetInput(itkimage);
importer->SetGeometry(geometry);
if(update)
importer->Update();
return importer->GetOutput();
}
template <typename ItkOutputImageType>
mitk::Image::Pointer mitk::ImportItkImage(const ItkOutputImageType* itkimage, const Geometry3D* geometry, bool update)
{
typename mitk::ITKImageImport<ItkOutputImageType>::Pointer importer = mitk::ITKImageImport<ItkOutputImageType>::New();
importer->SetInput(itkimage);
importer->SetGeometry(geometry);
if(update)
importer->Update();
return importer->GetOutput();
}
template <typename ItkOutputImageType>
mitk::Image::Pointer mitk::GrabItkImageMemory(itk::SmartPointer<ItkOutputImageType>& itkimage, mitk::Image* mitkImage, const Geometry3D* geometry, bool update)
{
return GrabItkImageMemory( itkimage.GetPointer(), mitkImage, geometry, update );
}
template <typename ItkOutputImageType>
mitk::Image::Pointer mitk::GrabItkImageMemory(ItkOutputImageType* itkimage, mitk::Image* mitkImage, const Geometry3D* geometry, bool update)
{
if(update)
itkimage->Update();
mitk::Image::Pointer resultImage;
if(mitkImage != NULL)
{
resultImage = mitkImage;
}
else
{
resultImage = mitk::Image::New();
}
resultImage->InitializeByItk( itkimage );
resultImage->SetImportVolume( itkimage->GetBufferPointer(), 0, 0,
Image::ManageMemory );
itkimage->GetPixelContainer()->ContainerManageMemoryOff();
if(geometry != NULL)
resultImage->SetGeometry(static_cast<mitk::Geometry3D*>(geometry->Clone().GetPointer()));
return resultImage;
}
#endif //__mitkITKImageImport_txx
diff --git a/Core/Code/DataManagement/mitkImage.cpp b/Core/Code/DataManagement/mitkImage.cpp
index d06fed5c33..8746b2ec51 100644
--- a/Core/Code/DataManagement/mitkImage.cpp
+++ b/Core/Code/DataManagement/mitkImage.cpp
@@ -1,1284 +1,1285 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImage.h"
#include "mitkImageStatisticsHolder.h"
#include "mitkPixelTypeMultiplex.h"
#include <vtkImageData.h>
#include <cmath>
#define FILL_C_ARRAY( _arr, _size, _value) for(unsigned int i=0u; i<_size; i++) \
{ _arr[i] = _value; }
mitk::Image::Image() :
m_Dimension(0), m_Dimensions(NULL), m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL),
m_ImageStatistics(NULL)
{
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
m_Initialized = false;
}
mitk::Image::Image(const Image &other) : SlicedData(other), m_Dimension(0), m_Dimensions(NULL),
m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL), m_ImageStatistics(NULL)
{
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
this->Initialize( other.GetPixelType(), other.GetDimension(), other.GetDimensions());
//Since the above called "Initialize" method doesn't take the geometry into account we need to set it
//here manually
this->SetGeometry(dynamic_cast<mitk::TimeSlicedGeometry*>(other.GetTimeSlicedGeometry()->Clone().GetPointer()));
if (this->GetDimension() > 3)
{
const unsigned int time_steps = this->GetDimension(3);
for (unsigned int i = 0u; i < time_steps; ++i)
{
ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(i);
this->SetVolume(volume->GetData(), i);
}
}
else
{
ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(0);
this->SetVolume(volume->GetData(), 0);
}
}
mitk::Image::~Image()
{
Clear();
m_ReferenceCountLock.Lock();
m_ReferenceCount = 3;
m_ReferenceCountLock.Unlock();
m_ReferenceCountLock.Lock();
m_ReferenceCount = 0;
m_ReferenceCountLock.Unlock();
if(m_OffsetTable != NULL)
delete [] m_OffsetTable;
if(m_ImageStatistics != NULL)
delete m_ImageStatistics;
}
const mitk::PixelType mitk::Image::GetPixelType(int n) const
{
return this->m_ImageDescriptor->GetChannelTypeById(n);
}
unsigned int mitk::Image::GetDimension() const
{
return m_Dimension;
}
unsigned int mitk::Image::GetDimension(int i) const
{
if((i>=0) && (i<(int)m_Dimension))
return m_Dimensions[i];
return 1;
}
void* mitk::Image::GetData()
{
if(m_Initialized==false)
{
if(GetSource().IsNull())
return NULL;
if(GetSource()->Updating()==false)
GetSource()->UpdateOutputInformation();
}
m_CompleteData=GetChannelData();
// update channel's data
// if data was not available at creation point, the m_Data of channel descriptor is NULL
// if data present, it won't be overwritten
m_ImageDescriptor->GetChannelDescriptor(0).SetData(m_CompleteData->GetData());
return m_CompleteData->GetData();
}
template <class T>
void AccessPixel( const mitk::PixelType ptype, void* data, const unsigned int offset, double& value )
{
value = 0.0;
if( data == NULL ) return;
if(ptype.GetBpe() != 24)
{
value = (double) (((T*) data)[ offset ]);
}
else
{
const unsigned int rgboffset = 3 * offset;
double returnvalue = (((T*) data)[rgboffset ]);
returnvalue += (((T*) data)[rgboffset + 1]);
returnvalue += (((T*) data)[rgboffset + 2]);
value = returnvalue;
}
}
double mitk::Image::GetPixelValueByIndex(const mitk::Index3D &position, unsigned int timestep)
{
double value = 0;
if (this->GetTimeSteps() < timestep)
{
timestep = this->GetTimeSteps();
}
value = 0.0;
const unsigned int* imageDims = this->m_ImageDescriptor->GetDimensions();
const mitk::PixelType ptype = this->m_ImageDescriptor->GetChannelTypeById(0);
// Comparison ?>=0 not needed since all position[i] and timestep are unsigned int
// (position[0]>=0 && position[1] >=0 && position[2]>=0 && timestep>=0)
// bug-11978 : we still need to catch index with negative values
if ( position[0] < 0 ||
position[1] < 0 ||
position[2] < 0 )
{
MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
}
// check if the given position is inside the index range of the image, the 3rd dimension needs to be compared only if the dimension is not 0
else if ( (unsigned int)position[0] >= imageDims[0] ||
(unsigned int)position[1] >= imageDims[1] ||
( imageDims[2] && (unsigned int)position[2] >= imageDims[2] ))
{
MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
}
else
{
const unsigned int offset = position[0] + position[1]*imageDims[0] + position[2]*imageDims[0]*imageDims[1] + timestep*imageDims[0]*imageDims[1]*imageDims[2];
mitkPixelTypeMultiplex3( AccessPixel, ptype, this->GetData(), offset, value );
}
return value;
}
double mitk::Image::GetPixelValueByWorldCoordinate(const mitk::Point3D& position, unsigned int timestep)
{
double value = 0.0;
if (this->GetTimeSteps() < timestep)
{
timestep = this->GetTimeSteps();
}
Index3D itkIndex;
this->GetGeometry()->WorldToIndex(position, itkIndex);
value = this->GetPixelValueByIndex( itkIndex, timestep);
return value;
}
mitk::ImageVtkAccessor* mitk::Image::GetVtkImageData(int t, int n)
{
if(m_Initialized==false)
{
if(GetSource().IsNull())
return NULL;
if(GetSource()->Updating()==false)
GetSource()->UpdateOutputInformation();
}
ImageDataItemPointer volume=GetVolumeData(t, n);
if(volume.GetPointer()==NULL || volume->GetVtkImageData(this) == NULL)
return NULL;
float *fspacing = const_cast<float *>(GetSlicedGeometry(t)->GetFloatSpacing());
double dspacing[3] = {fspacing[0],fspacing[1],fspacing[2]};
volume->GetVtkImageData(this)->SetSpacing( dspacing );
return volume->GetVtkImageData(this);
}
mitk::Image::ImageDataItemPointer mitk::Image::GetSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidSlice(s,t,n)==false) return NULL;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// slice directly available?
int pos=GetSliceIndex(s,t,n);
if(m_Slices[pos].GetPointer()!=NULL)
return m_Slices[pos];
// is slice available as part of a volume that is available?
ImageDataItemPointer sl, ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
{
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// is slice available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
{
sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// slice is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir mussen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, s);
m_RequestedRegion.SetIndex(3, t);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, 1);
m_RequestedRegion.SetSize(3, 1);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
if(IsSliceSet(s,t,n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetSliceData(s,t,n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateSliceData(s,t,n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
mitk::Image::ImageDataItemPointer mitk::Image::GetVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidVolume(t,n)==false) return NULL;
ImageDataItemPointer ch, vol;
// volume directly available?
int pos=GetVolumeIndex(t,n);
vol=m_Volumes[pos];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return vol;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is volume available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
{
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
vol->SetComplete(true);
return m_Volumes[pos]=vol;
}
// let's see if all slices of the volume are set, so that we can (could) combine them to a volume
bool complete=true;
unsigned int s;
for(s=0;s<m_Dimensions[2];++s)
{
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
{
complete=false;
break;
}
}
if(complete)
{
// if there is only single slice we do not need to combine anything
if(m_Dimensions[2]<=1)
{
ImageDataItemPointer sl;
sl=GetSliceData(0,t,n,data,importMemoryManagement);
vol=new ImageDataItem(*sl, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory);
vol->SetComplete(true);
}
else
{
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
vol=m_Volumes[pos];
// ok, let's combine the slices!
if(vol.GetPointer()==NULL)
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
vol->SetComplete(true);
size_t size=m_OffsetTable[2]*(ptypeSize);
for(s=0;s<m_Dimensions[2];++s)
{
int posSl;
ImageDataItemPointer sl;
posSl=GetSliceIndex(s,t,n);
sl=m_Slices[posSl];
if(sl->GetParent()!=vol)
{
// copy data of slices in volume
size_t offset = ((size_t) s)*size;
std::memcpy(static_cast<char*>(vol->GetData())+offset, sl->GetData(), size);
// FIXME mitkIpPicDescriptor * pic = sl->GetPicDescriptor();
// replace old slice with reference to volume
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*size);
sl->SetComplete(true);
//mitkIpFuncCopyTags(sl->GetPicDescriptor(), pic);
m_Slices[posSl]=sl;
}
}
//if(vol->GetPicDescriptor()->info->tags_head==NULL)
// mitkIpFuncCopyTags(vol->GetPicDescriptor(), m_Slices[GetSliceIndex(0,t,n)]->GetPicDescriptor());
}
return m_Volumes[pos]=vol;
}
// volume is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir muessen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, 0);
m_RequestedRegion.SetIndex(3, t);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, m_Dimensions[2]);
m_RequestedRegion.SetSize(3, 1);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
if(IsVolumeSet(t,n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetVolumeData(t,n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateVolumeData(t,n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
mitk::Image::ImageDataItemPointer mitk::Image::GetChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidChannel(n)==false) return NULL;
ImageDataItemPointer ch, vol;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return ch;
// let's see if all volumes are set, so that we can (could) combine them to a channel
if(IsChannelSet(n))
{
// if there is only one time frame we do not need to combine anything
if(m_Dimensions[3]<=1)
{
vol=GetVolumeData(0,n,data,importMemoryManagement);
ch=new ImageDataItem(*vol, m_ImageDescriptor, m_ImageDescriptor->GetNumberOfDimensions(), data, importMemoryManagement == ManageMemory);
ch->SetComplete(true);
}
else
{
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ch=m_Channels[n];
// ok, let's combine the volumes!
if(ch.GetPointer()==NULL)
ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
ch->SetComplete(true);
size_t size=m_OffsetTable[m_Dimension-1]*(ptypeSize);
unsigned int t;
ImageDataItemPointerArray::iterator slicesIt = m_Slices.begin()+n*m_Dimensions[2]*m_Dimensions[3];
for(t=0;t<m_Dimensions[3];++t)
{
int posVol;
ImageDataItemPointer vol;
posVol=GetVolumeIndex(t,n);
vol=GetVolumeData(t,n,data,importMemoryManagement);
if(vol->GetParent()!=ch)
{
// copy data of volume in channel
size_t offset = ((size_t) t)*m_OffsetTable[3]*(ptypeSize);
std::memcpy(static_cast<char*>(ch->GetData())+offset, vol->GetData(), size);
// REVEIW FIX mitkIpPicDescriptor * pic = vol->GetPicDescriptor();
// replace old volume with reference to channel
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, offset);
vol->SetComplete(true);
//mitkIpFuncCopyTags(vol->GetPicDescriptor(), pic);
m_Volumes[posVol]=vol;
// get rid of slices - they may point to old volume
ImageDataItemPointer dnull=NULL;
for(unsigned int i = 0; i < m_Dimensions[2]; ++i, ++slicesIt)
{
assert(slicesIt != m_Slices.end());
*slicesIt = dnull;
}
}
}
// REVIEW FIX
// if(ch->GetPicDescriptor()->info->tags_head==NULL)
// mitkIpFuncCopyTags(ch->GetPicDescriptor(), m_Volumes[GetVolumeIndex(0,n)]->GetPicDescriptor());
}
return m_Channels[n]=ch;
}
// channel is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir muessen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, 0);
m_RequestedRegion.SetIndex(3, 0);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, m_Dimensions[2]);
m_RequestedRegion.SetSize(3, m_Dimensions[3]);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
// did it work?
if(IsChannelSet(n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetChannelData(n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateChannelData(n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
bool mitk::Image::IsSliceSet(int s, int t, int n) const
{
if(IsValidSlice(s,t,n)==false) return false;
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()!=NULL)
return true;
ImageDataItemPointer ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return true;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
return false;
}
bool mitk::Image::IsVolumeSet(int t, int n) const
{
if(IsValidVolume(t,n)==false) return false;
ImageDataItemPointer ch, vol;
// volume directly available?
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return true;
// is volume available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
// let's see if all slices of the volume are set, so that we can (could) combine them to a volume
unsigned int s;
for(s=0;s<m_Dimensions[2];++s)
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
return false;
return true;
}
bool mitk::Image::IsChannelSet(int n) const
{
if(IsValidChannel(n)==false) return false;
ImageDataItemPointer ch, vol;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
// let's see if all volumes are set, so that we can (could) combine them to a channel
unsigned int t;
for(t=0;t<m_Dimensions[3];++t)
if(IsVolumeSet(t,n)==false)
return false;
return true;
}
bool mitk::Image::SetSlice(const void *data, int s, int t, int n)
{
// const_cast is no risk for ImportMemoryManagementType == CopyMemory
return SetImportSlice(const_cast<void*>(data), s, t, n, CopyMemory);
}
bool mitk::Image::SetVolume(const void *data, int t, int n)
{
// const_cast is no risk for ImportMemoryManagementType == CopyMemory
return SetImportVolume(const_cast<void*>(data), t, n, CopyMemory);
}
bool mitk::Image::SetChannel(const void *data, int n)
{
// const_cast is no risk for ImportMemoryManagementType == CopyMemory
return SetImportChannel(const_cast<void*>(data), n, CopyMemory);
}
bool mitk::Image::SetImportSlice(void *data, int s, int t, int n, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidSlice(s,t,n)==false) return false;
ImageDataItemPointer sl;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
if(IsSliceSet(s,t,n))
{
sl=GetSliceData(s,t,n,data,importMemoryManagement);
if(sl->GetManageMemory()==false)
{
sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
if(sl.GetPointer()==NULL) return false;
}
if ( sl->GetData() != data )
std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
sl->Modified();
//we have changed the data: call Modified()!
Modified();
}
else
{
sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
if(sl.GetPointer()==NULL) return false;
if ( sl->GetData() != data )
std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
//we just added a missing slice, which is not regarded as modification.
//Therefore, we do not call Modified()!
}
return true;
}
bool mitk::Image::SetImportVolume(void *data, int t, int n, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidVolume(t,n)==false) return false;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ImageDataItemPointer vol;
if(IsVolumeSet(t,n))
{
vol=GetVolumeData(t,n,data,importMemoryManagement);
if(vol->GetManageMemory()==false)
{
vol=AllocateVolumeData(t,n,data,importMemoryManagement);
if(vol.GetPointer()==NULL) return false;
}
if ( vol->GetData() != data )
std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
vol->Modified();
vol->SetComplete(true);
//we have changed the data: call Modified()!
Modified();
}
else
{
vol=AllocateVolumeData(t,n,data,importMemoryManagement);
if(vol.GetPointer()==NULL) return false;
if ( vol->GetData() != data )
{
std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
}
vol->SetComplete(true);
this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( vol->GetData() );
//we just added a missing Volume, which is not regarded as modification.
//Therefore, we do not call Modified()!
}
return true;
}
bool mitk::Image::SetImportChannel(void *data, int n, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidChannel(n)==false) return false;
// channel descriptor
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ImageDataItemPointer ch;
if(IsChannelSet(n))
{
ch=GetChannelData(n,data,importMemoryManagement);
if(ch->GetManageMemory()==false)
{
ch=AllocateChannelData(n,data,importMemoryManagement);
if(ch.GetPointer()==NULL) return false;
}
if ( ch->GetData() != data )
std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
ch->Modified();
ch->SetComplete(true);
//we have changed the data: call Modified()!
Modified();
}
else
{
ch=AllocateChannelData(n,data,importMemoryManagement);
if(ch.GetPointer()==NULL) return false;
if ( ch->GetData() != data )
std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
ch->SetComplete(true);
this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( ch->GetData() );
//we just added a missing Channel, which is not regarded as modification.
//Therefore, we do not call Modified()!
}
return true;
}
void mitk::Image::Initialize()
{
ImageDataItemPointerArray::iterator it, end;
for( it=m_Slices.begin(), end=m_Slices.end(); it!=end; ++it )
{
(*it)=NULL;
}
for( it=m_Volumes.begin(), end=m_Volumes.end(); it!=end; ++it )
{
(*it)=NULL;
}
for( it=m_Channels.begin(), end=m_Channels.end(); it!=end; ++it )
{
(*it)=NULL;
}
m_CompleteData = NULL;
if( m_ImageStatistics == NULL)
{
m_ImageStatistics = new mitk::ImageStatisticsHolder( this );
}
SetRequestedRegionToLargestPossibleRegion();
}
void mitk::Image::Initialize(const mitk::ImageDescriptor::Pointer inDesc)
{
// store the descriptor
this->m_ImageDescriptor = inDesc;
// initialize image
this->Initialize( inDesc->GetChannelDescriptor(0).GetPixelType(), inDesc->GetNumberOfDimensions(), inDesc->GetDimensions(), 1 );
}
void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, const unsigned int *dimensions, unsigned int channels)
{
Clear();
m_Dimension=dimension;
if(!dimensions)
itkExceptionMacro(<< "invalid zero dimension image");
unsigned int i;
for(i=0;i<dimension;++i)
{
if(dimensions[i]<1)
itkExceptionMacro(<< "invalid dimension[" << i << "]: " << dimensions[i]);
}
// create new array since the old was deleted
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
// initialize the first four dimensions to 1, the remaining 4 to 0
FILL_C_ARRAY(m_Dimensions, 4, 1u);
FILL_C_ARRAY((m_Dimensions+4), 4, 0u);
// copy in the passed dimension information
std::memcpy(m_Dimensions, dimensions, sizeof(unsigned int)*m_Dimension);
this->m_ImageDescriptor = mitk::ImageDescriptor::New();
this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
for(i=0;i<4;++i)
{
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize (i, m_Dimensions[i]);
}
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize(i, channels);
if(m_LargestPossibleRegion.GetNumberOfPixels()==0)
{
delete [] m_Dimensions;
m_Dimensions = NULL;
return;
}
for( unsigned int i=0u; i<channels; i++)
{
this->m_ImageDescriptor->AddNewChannel( type );
}
PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
planegeometry->InitializeStandardPlane(m_Dimensions[0], m_Dimensions[1]);
SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(planegeometry, m_Dimensions[2]);
if(dimension>=4)
{
TimeBounds timebounds;
timebounds[0] = 0.0;
timebounds[1] = 1.0;
slicedGeometry->SetTimeBounds(timebounds);
}
TimeSlicedGeometry::Pointer timeSliceGeometry = TimeSlicedGeometry::New();
timeSliceGeometry->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
timeSliceGeometry->ImageGeometryOn();
SetGeometry(timeSliceGeometry);
ImageDataItemPointer dnull=NULL;
m_Channels.assign(GetNumberOfChannels(), dnull);
m_Volumes.assign(GetNumberOfChannels()*m_Dimensions[3], dnull);
m_Slices.assign(GetNumberOfChannels()*m_Dimensions[3]*m_Dimensions[2], dnull);
ComputeOffsetTable();
Initialize();
m_Initialized = true;
}
void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int channels, int tDim )
{
unsigned int dimensions[5];
dimensions[0] = (unsigned int)(geometry.GetExtent(0)+0.5);
dimensions[1] = (unsigned int)(geometry.GetExtent(1)+0.5);
dimensions[2] = (unsigned int)(geometry.GetExtent(2)+0.5);
dimensions[3] = 0;
dimensions[4] = 0;
unsigned int dimension = 2;
if ( dimensions[2] > 1 )
dimension = 3;
if ( tDim > 0)
{
dimensions[3] = tDim;
}
else
{
const mitk::TimeSlicedGeometry* timeGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>(&geometry);
if ( timeGeometry != NULL )
{
dimensions[3] = timeGeometry->GetTimeSteps();
}
}
if ( dimensions[3] > 1 )
dimension = 4;
Initialize( type, dimension, dimensions, channels );
SetGeometry(static_cast<Geometry3D*>(geometry.Clone().GetPointer()));
mitk::BoundingBox::BoundsArrayType bounds = geometry.GetBoundingBox()->GetBounds();
if( (bounds[0] != 0.0) || (bounds[2] != 0.0) || (bounds[4] != 0.0) )
{
SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
mitk::Point3D origin; origin.Fill(0.0);
slicedGeometry->IndexToWorld(origin, origin);
bounds[1]-=bounds[0]; bounds[3]-=bounds[2]; bounds[5]-=bounds[4];
bounds[0] = 0.0; bounds[2] = 0.0; bounds[4] = 0.0;
this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
slicedGeometry->SetBounds(bounds);
- slicedGeometry->GetIndexToWorldTransform()->SetOffset(origin.Get_vnl_vector().data_block());
+ slicedGeometry->GetIndexToWorldTransform()->SetOffset(origin.GetVnlVector().data_block());
GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
}
}
void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
{
SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(static_cast<Geometry2D*>(geometry2d.Clone().GetPointer()), sDim, flipped);
Initialize(type, *slicedGeometry, channels, tDim);
}
void mitk::Image::Initialize(const mitk::Image* image)
{
Initialize(image->GetPixelType(), *image->GetTimeSlicedGeometry());
}
void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim, int pDim)
{
if(vtkimagedata==NULL) return;
m_Dimension=vtkimagedata->GetDataDimension();
unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
if(m_Dimension<4)
{
unsigned int *p;
for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
*p=1;
}
if(pDim>=0)
{
tmpDimensions[1]=pDim;
if(m_Dimension < 2)
m_Dimension = 2;
}
if(sDim>=0)
{
tmpDimensions[2]=sDim;
if(m_Dimension < 3)
m_Dimension = 3;
}
if(tDim>=0)
{
tmpDimensions[3]=tDim;
if(m_Dimension < 4)
m_Dimension = 4;
}
switch ( vtkimagedata->GetScalarType() )
{
case VTK_BIT:
case VTK_CHAR:
//pixelType.Initialize(typeid(char), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<char>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_CHAR:
//pixelType.Initialize(typeid(unsigned char), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned char>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_SHORT:
//pixelType.Initialize(typeid(short), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<short>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_SHORT:
//pixelType.Initialize(typeid(unsigned short), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned short>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_INT:
//pixelType.Initialize(typeid(int), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<int>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_INT:
//pixelType.Initialize(typeid(unsigned int), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned int>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_LONG:
//pixelType.Initialize(typeid(long), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<long>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_LONG:
//pixelType.Initialize(typeid(unsigned long), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned long>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_FLOAT:
//pixelType.Initialize(typeid(float), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<float>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_DOUBLE:
//pixelType.Initialize(typeid(double), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<double>(), m_Dimension, tmpDimensions, channels);
break;
default:
break;
}
/*
Initialize(pixelType,
m_Dimension,
tmpDimensions,
channels);
*/
const double *spacinglist = vtkimagedata->GetSpacing();
Vector3D spacing;
FillVector3D(spacing, spacinglist[0], 1.0, 1.0);
if(m_Dimension>=2)
spacing[1]=spacinglist[1];
if(m_Dimension>=3)
spacing[2]=spacinglist[2];
// access origin of vtkImage
Point3D origin;
vtkFloatingPointType vtkorigin[3];
vtkimagedata->GetOrigin(vtkorigin);
FillVector3D(origin, vtkorigin[0], 0.0, 0.0);
if(m_Dimension>=2)
origin[1]=vtkorigin[1];
if(m_Dimension>=3)
origin[2]=vtkorigin[2];
SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetGeometry2D(0));
planeGeometry->SetOrigin(origin);
// re-initialize SlicedGeometry3D
slicedGeometry->SetOrigin(origin);
slicedGeometry->SetSpacing(spacing);
GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
delete [] tmpDimensions;
}
bool mitk::Image::IsValidSlice(int s, int t, int n) const
{
if(m_Initialized)
return ((s>=0) && (s<(int)m_Dimensions[2]) && (t>=0) && (t< (int) m_Dimensions[3]) && (n>=0) && (n< (int)GetNumberOfChannels()));
else
return false;
}
bool mitk::Image::IsValidVolume(int t, int n) const
{
if(m_Initialized)
return IsValidSlice(0, t, n);
else
return false;
}
bool mitk::Image::IsValidChannel(int n) const
{
if(m_Initialized)
return IsValidSlice(0, 0, n);
else
return false;
}
void mitk::Image::ComputeOffsetTable()
{
if(m_OffsetTable!=NULL)
delete [] m_OffsetTable;
m_OffsetTable=new size_t[m_Dimension>4 ? m_Dimension+1 : 4+1];
unsigned int i;
size_t num=1;
m_OffsetTable[0] = 1;
for (i=0; i < m_Dimension; ++i)
{
num *= m_Dimensions[i];
m_OffsetTable[i+1] = num;
}
for (;i < 4; ++i)
m_OffsetTable[i+1] = num;
}
bool mitk::Image::IsValidTimeStep(int t) const
{
return ( ( m_Dimension >= 4 && t <= (int)m_Dimensions[3] && t > 0 ) || (t == 0) );
}
void mitk::Image::Expand(unsigned int timeSteps)
{
if(timeSteps < 1) itkExceptionMacro(<< "Invalid timestep in Image!");
Superclass::Expand(timeSteps);
}
int mitk::Image::GetSliceIndex(int s, int t, int n) const
{
if(IsValidSlice(s,t,n)==false) return false;
return ((size_t)s)+((size_t) t)*m_Dimensions[2]+((size_t) n)*m_Dimensions[3]*m_Dimensions[2]; //??
}
int mitk::Image::GetVolumeIndex(int t, int n) const
{
if(IsValidVolume(t,n)==false) return false;
return ((size_t)t)+((size_t) n)*m_Dimensions[3]; //??
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
int pos;
pos=GetSliceIndex(s,t,n);
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is slice available as part of a volume that is available?
ImageDataItemPointer sl, ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if(vol.GetPointer()!=NULL)
{
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// is slice available as part of a channel that is available?
ch=m_Channels[n];
if(ch.GetPointer()!=NULL)
{
sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// allocate new volume (instead of a single slice to keep data together!)
m_Volumes[GetVolumeIndex(t,n)]=vol=AllocateVolumeData(t,n,NULL,importMemoryManagement);
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
////ALTERNATIVE:
//// allocate new slice
//sl=new ImageDataItem(*m_PixelType, 2, m_Dimensions);
//m_Slices[pos]=sl;
//return vol;
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
int pos;
pos=GetVolumeIndex(t,n);
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is volume available as part of a channel that is available?
ImageDataItemPointer ch, vol;
ch=m_Channels[n];
if(ch.GetPointer()!=NULL)
{
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data,importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
return m_Volumes[pos]=vol;
}
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
// allocate new volume
if(importMemoryManagement == CopyMemory)
{
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
if(data != NULL)
std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
}
else
{
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, data, importMemoryManagement == ManageMemory);
}
m_Volumes[pos]=vol;
return vol;
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
ImageDataItemPointer ch;
// allocate new channel
if(importMemoryManagement == CopyMemory)
{
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
if(data != NULL)
std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
}
else
{
ch=new ImageDataItem(this->m_ImageDescriptor, data, importMemoryManagement == ManageMemory);
}
m_Channels[n]=ch;
return ch;
}
unsigned int* mitk::Image::GetDimensions() const
{
return m_Dimensions;
}
void mitk::Image::Clear()
{
Superclass::Clear();
delete [] m_Dimensions;
m_Dimensions = NULL;
}
void mitk::Image::SetGeometry(Geometry3D* aGeometry3D)
{
// Please be aware of the 0.5 offset/pixel-center issue! See Geometry documentation for further information
if(aGeometry3D->GetImageGeometry()==false)
{
MITK_INFO << "WARNING: Applied a non-image geometry onto an image. Please be SURE that this geometry is pixel-center-based! If it is not, you need to call Geometry3D->ChangeImageGeometryConsideringOriginOffset(true) before calling image->setGeometry(..)\n";
}
Superclass::SetGeometry(aGeometry3D);
GetTimeSlicedGeometry()->ImageGeometryOn();
}
void mitk::Image::PrintSelf(std::ostream& os, itk::Indent indent) const
{
unsigned char i;
if(m_Initialized)
{
os << indent << " Dimension: " << m_Dimension << std::endl;
os << indent << " Dimensions: ";
for(i=0; i < m_Dimension; ++i)
os << GetDimension(i) << " ";
os << std::endl;
for(unsigned int ch=0; ch < this->m_ImageDescriptor->GetNumberOfChannels(); ch++)
{
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(ch);
os << indent << " Channel: " << this->m_ImageDescriptor->GetChannelName(ch) << std::endl;
- os << indent << " PixelType: " << chPixelType.GetTypeId().name() << std::endl;
+ os << indent << " PixelType: " << chPixelType.GetPixelTypeAsString() << std::endl;
os << indent << " BitsPerElement: " << chPixelType.GetSize() << std::endl;
+ os << indent << " ComponentType: " << chPixelType.GetComponentTypeAsString() << std::endl;
os << indent << " NumberOfComponents: " << chPixelType.GetNumberOfComponents() << std::endl;
os << indent << " BitsPerComponent: " << chPixelType.GetBitsPerComponent() << std::endl;
}
}
else
{
os << indent << " Image not initialized: m_Initialized: false" << std::endl;
}
Superclass::PrintSelf(os,indent);
}
bool mitk::Image::IsRotated() const
{
const mitk::Geometry3D* geo = this->GetGeometry();
bool ret = false;
if(geo)
{
const vnl_matrix_fixed<float, 3, 3> & mx = geo->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
float ref = 0;
for(short k = 0; k < 3; ++k)
ref += mx[k][k];
ref/=1000; // Arbitrary value; if a non-diagonal (nd) element is bigger then this, matrix is considered nd.
for(short i = 0; i < 3; ++i)
{
for(short j = 0; j < 3; ++j)
{
if(i != j)
{
if(std::abs(mx[i][j]) > ref) // matrix is nd
ret = true;
}
}
}
}
return ret;
}
#include "mitkImageStatisticsHolder.h"
//##Documentation
mitk::ScalarType mitk::Image::GetScalarValueMin(int t) const
{
return m_ImageStatistics->GetScalarValueMin(t);
}
//##Documentation
//## \brief Get the maximum for scalar images
mitk::ScalarType mitk::Image::GetScalarValueMax(int t) const
{
return m_ImageStatistics->GetScalarValueMax(t);
}
//##Documentation
//## \brief Get the second smallest value for scalar images
mitk::ScalarType mitk::Image::GetScalarValue2ndMin(int t) const
{
return m_ImageStatistics->GetScalarValue2ndMin(t);
}
mitk::ScalarType mitk::Image::GetScalarValueMinNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetScalarValueMinNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetScalarValue2ndMinNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetScalarValue2ndMinNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetScalarValue2ndMax(int t) const
{
return m_ImageStatistics->GetScalarValue2ndMax(t);
}
mitk::ScalarType mitk::Image::GetScalarValueMaxNoRecompute( unsigned int t) const
{
return m_ImageStatistics->GetScalarValueMaxNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetScalarValue2ndMaxNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetScalarValue2ndMaxNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetCountOfMinValuedVoxels(int t ) const
{
return m_ImageStatistics->GetCountOfMinValuedVoxels(t);
}
mitk::ScalarType mitk::Image::GetCountOfMaxValuedVoxels(int t) const
{
return m_ImageStatistics->GetCountOfMaxValuedVoxels(t);
}
unsigned int mitk::Image::GetCountOfMaxValuedVoxelsNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetCountOfMaxValuedVoxelsNoRecompute(t);
}
unsigned int mitk::Image::GetCountOfMinValuedVoxelsNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetCountOfMinValuedVoxelsNoRecompute(t);
}
diff --git a/Core/Code/DataManagement/mitkImageAccessByItk.h b/Core/Code/DataManagement/mitkImageAccessByItk.h
index 9e7ca01ceb..1bf58e33ce 100644
--- a/Core/Code/DataManagement/mitkImageAccessByItk.h
+++ b/Core/Code/DataManagement/mitkImageAccessByItk.h
@@ -1,624 +1,624 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKIMAGEACCESSBYITK_H_HEADER_INCLUDED
#define MITKIMAGEACCESSBYITK_H_HEADER_INCLUDED
#include <itkCastImageFilter.h>
#include <mitkImageToItk.h>
#include <mitkPPArgCount.h>
#include <mitkPPSeqForEach.h>
#include <mitkPPSeqForEachProduct.h>
#include <mitkPPSeqToTuple.h>
#include <mitkPPCat.h>
#include <mitkPPExpand.h>
#include <mitkPPTupleRem.h>
#include <mitkPPStringize.h>
#include <sstream>
namespace mitk {
/**
* \brief Exception class thrown in #AccessByItk macros.
*
* This exception can be thrown by the invocation of the #AccessByItk macros,
* if the MITK image is of non-expected dimension or pixel type.
*
* \ingroup Adaptor
*/
class AccessByItkException : public virtual std::runtime_error
{
public:
AccessByItkException(const std::string& msg) : std::runtime_error(msg) {}
~AccessByItkException() throw() {}
};
}
#ifndef DOXYGEN_SKIP
#define _accessByItkPixelTypeException(pixelType, pixelTypeSeq) \
{ \
std::string msg("Pixel type "); \
- msg.append(pixelType.GetItkTypeAsString()); \
+ msg.append(pixelType.GetPixelTypeAsString()); \
msg.append(" is not in " MITK_PP_STRINGIZE(pixelTypeSeq)); \
throw mitk::AccessByItkException(msg); \
}
#define _accessByItkDimensionException(dim, validDims) \
{ \
std::stringstream msg; \
msg << "Dimension " << (dim) << " is not in " << validDims ; \
throw mitk::AccessByItkException(msg.str()); \
}
#define _checkSpecificDimensionIter(r, mitkImage, dim) \
if (mitkImage->GetDimension() == dim); else
#define _checkSpecificDimension(mitkImage, dimSeq) \
MITK_PP_SEQ_FOR_EACH(_checkSpecificDimensionIter, mitkImage, dimSeq) \
_accessByItkDimensionException(mitkImage->GetDimension(), MITK_PP_STRINGIZE(dimSeq))
#define _msvc_expand_bug(macro, arg) MITK_PP_EXPAND(macro arg)
//-------------------------------- 0-Arg Versions --------------------------------------
#define _accessByItk(itkImageTypeFunction, pixeltype, dimension) \
if ( pixelType == mitk::MakePixelType< itk::Image<pixeltype, dimension> >() && constImage->GetDimension() == dimension) \
{\
typedef itk::Image<pixeltype, dimension> ImageType; \
typedef mitk::ImageToItk<ImageType> ImageToItkType; \
itk::SmartPointer<ImageToItkType> imagetoitk = ImageToItkType::New(); \
imagetoitk->SetInput(nonConstImage); \
imagetoitk->Update(); \
itkImageTypeFunction(imagetoitk->GetOutput()); \
} else
#define _accessByItkArgs(itkImageTypeFunction, type) \
(itkImageTypeFunction, MITK_PP_TUPLE_REM(2)type)
// product will be of the form (itkImageTypeFunction)(short)(2) for pixel type short and dimension 2
#ifdef _MSC_VER
#define _accessByItkProductIter(r, product) \
_msvc_expand_bug(_accessByItk, _msvc_expand_bug(_accessByItkArgs, (MITK_PP_SEQ_HEAD(product), MITK_PP_SEQ_TO_TUPLE(MITK_PP_SEQ_TAIL(product)))))
#else
#define _accessByItkProductIter(r, product) \
MITK_PP_EXPAND(_accessByItk _accessByItkArgs(MITK_PP_SEQ_HEAD(product), MITK_PP_SEQ_TO_TUPLE(MITK_PP_SEQ_TAIL(product))))
#endif
#define _accessFixedTypeByItk(itkImageTypeFunction, pixelTypeSeq, dimSeq) \
MITK_PP_SEQ_FOR_EACH_PRODUCT(_accessByItkProductIter, ((itkImageTypeFunction))(pixelTypeSeq)(dimSeq))
//-------------------------------- n-Arg Versions --------------------------------------
#define _accessByItk_n(itkImageTypeFunction, pixeltype, dimension, args) \
if ( pixelType == mitk::MakePixelType< itk::Image<pixeltype, dimension> >() && constImage->GetDimension() == dimension) \
{ \
typedef itk::Image<pixeltype, dimension> ImageType; \
typedef mitk::ImageToItk<ImageType> ImageToItkType; \
itk::SmartPointer<ImageToItkType> imagetoitk = ImageToItkType::New(); \
imagetoitk->SetInput(nonConstImage); \
imagetoitk->Update(); \
itkImageTypeFunction(imagetoitk->GetOutput(), MITK_PP_TUPLE_REM(MITK_PP_SEQ_HEAD(args))MITK_PP_SEQ_TAIL(args)); \
} else
#define _accessByItkArgs_n(itkImageTypeFunction, type, args) \
(itkImageTypeFunction, MITK_PP_TUPLE_REM(2) type, args)
// product will be of the form ((itkImageTypeFunction)(3)(a,b,c))(short)(2)
// for the variable argument list a,b,c and for pixel type short and dimension 2
#ifdef _MSC_VER
#define _accessByItkProductIter_n(r, product) \
_msvc_expand_bug(_accessByItk_n, _msvc_expand_bug(_accessByItkArgs_n, (MITK_PP_SEQ_HEAD(MITK_PP_SEQ_HEAD(product)), MITK_PP_SEQ_TO_TUPLE(MITK_PP_SEQ_TAIL(product)), MITK_PP_SEQ_TAIL(MITK_PP_SEQ_HEAD(product)))))
#else
#define _accessByItkProductIter_n(r, product) \
MITK_PP_EXPAND(_accessByItk_n _accessByItkArgs_n(MITK_PP_SEQ_HEAD(MITK_PP_SEQ_HEAD(product)), MITK_PP_SEQ_TO_TUPLE(MITK_PP_SEQ_TAIL(product)), MITK_PP_SEQ_TAIL(MITK_PP_SEQ_HEAD(product))))
#endif
#define _accessFixedTypeByItk_n(itkImageTypeFunction, pixelTypeSeq, dimSeq, va_tuple) \
MITK_PP_SEQ_FOR_EACH_PRODUCT(_accessByItkProductIter_n, (((itkImageTypeFunction)(MITK_PP_ARG_COUNT va_tuple) va_tuple))(pixelTypeSeq)(dimSeq))
#endif //DOXYGEN_SKIP
/**
* \brief Access a MITK image by an ITK image
*
* Define a templated function or method (\a itkImageTypeFunction)
* within which the mitk-image (\a mitkImage) is accessed:
* \code
* template < typename TPixel, unsigned int VImageDimension >
* void ExampleFunction( itk::Image<TPixel, VImageDimension>* itkImage );
* \endcode
*
* The itk::Image passed to the function/method has the same
* data-pointer as the mitk-image. So you have full read- and write-
* access to the data vector of the mitk-image using the itk-image.
* Call by:
* \code
* mitk::Image* inputMitkImage = ...
* try
* {
* AccessByItk(inputMitkImage, ExampleFunction);
* }
* catch (const mitk::AccessByItkException& e)
* {
* // mitk::Image is of wrong pixel type or dimension,
* // insert error handling here
* }
* \endcode
*
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \note If your inputMitkImage is an mitk::Image::Pointer, use
* inputMitkImage.GetPointer()
* \note If you need to pass additional parameters to your
* access-function (\a itkImageTypeFunction), use #AccessByItk_n.
* \note If you know the dimension of your input mitk-image,
* it is better to use AccessFixedDimensionByItk (less code
* is generated).
* \sa AccessFixedDimensionByItk
* \sa AccessFixedTypeByItk
* \sa AccessFixedPixelTypeByItk
* \sa AccessByItk_n
*
* \ingroup Adaptor
*/
#define AccessByItk(mitkImage, itkImageTypeFunction) \
AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ)
/**
* \brief Access a mitk-image with known pixeltype (but unknown dimension) by an itk-image.
*
* For usage, see #AccessByItk.
*
* \param pixelTypeSeq A sequence of pixel types, like (short)(char)(int)
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* If the image has a different pixel type, a mitk::AccessByItkException exception is
* thrown. If you do not know the pixel type for sure, use #AccessByItk.
*
* \sa AccessByItk
* \sa AccessFixedDimensionByItk
* \sa AccessFixedTypeByItk
* \sa AccessFixedPixelTypeByItk_n
*
* \ingroup Adaptor
*/
#define AccessFixedPixelTypeByItk(mitkImage, itkImageTypeFunction, pixelTypeSeq) \
AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, pixelTypeSeq, MITK_ACCESSBYITK_DIMENSIONS_SEQ)
/**
* \brief Access a mitk-image with an integral pixel type by an itk-image
*
* See #AccessByItk for details.
*
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \sa AccessFixedPixelTypeByItk
* \sa AccessByItk
* \sa AccessIntegralPixelTypeByItk_n
*/
#define AccessIntegralPixelTypeByItk(mitkImage, itkImageTypeFunction) \
AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ)
/**
* \brief Access a mitk-image with a floating point pixel type by an ITK image
*
* See #AccessByItk for details.
*
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \sa AccessFixedPixelTypeByItk
* \sa AccessByItk
* \sa AccessFloatingPixelTypeByItk_n
*/
#define AccessFloatingPixelTypeByItk(mitkImage, itkImageTypeFunction) \
AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ)
/**
* \brief Access a mitk-image with known dimension by an itk-image
*
* For usage, see #AccessByItk.
*
* \param dimension Dimension of the mitk-image. If the image has a different dimension,
* a mitk::AccessByItkException exception is thrown.
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \note If you do not know the dimension for sure, use #AccessByItk.
*
* \sa AccessByItk
* \sa AccessFixedDimensionByItk_n
* \sa AccessFixedTypeByItk
* \sa AccessFixedPixelTypeByItk
*
* \ingroup Adaptor
*/
#define AccessFixedDimensionByItk(mitkImage, itkImageTypeFunction, dimension) \
AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ, (dimension))
/**
* \brief Access a mitk-image with known type (pixel type and dimension) by an itk-image.
*
* The provided mitk-image must be in the set of types created by taking the
* cartesian product of the pixel type sequence and the dimension sequence.
* For example, a call to
* \code
* AccessFixedTypeByItk(myMitkImage, MyAccessFunction, (short)(int), (2)(3))
* \endcode
* asserts that the type of myMitkImage (pixeltype,dim) is in the set {(short,2),(short,3),(int,2),(int,3)}.
* For more information, see #AccessByItk.
*
* \param pixelTypeSeq A sequence of pixel types, like (short)(char)(int).
* \param dimSeq A sequence of dimensions, like (2)(3).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* If the image has a different dimension or pixel type,
* a mitk::AccessByItkException exception is thrown.
*
* \note If you do not know the dimension for sure, use #AccessByItk.
*
* \sa AccessByItk
* \sa AccessFixedDimensionByItk
* \sa AccessFixedTypeByItk_n
* \sa AccessFixedPixelTypeByItk
*
* \ingroup Adaptor
*/
#define AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq) \
{ \
const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \
const mitk::Image* constImage = mitkImage; \
mitk::Image* nonConstImage = const_cast<mitk::Image*>(constImage); \
nonConstImage->Update(); \
_checkSpecificDimension(nonConstImage, dimSeq); \
_accessFixedTypeByItk(itkImageTypeFunction, pixelTypeSeq, dimSeq) \
_accessByItkPixelTypeException(nonConstImage->GetPixelType(), pixelTypeSeq) \
}
//------------------------------ n-Arg Access Macros -----------------------------------
/**
* \brief Access a MITK image by an ITK image with one or more parameters.
*
* Define a templated function or method (\a itkImageTypeFunction) with one ore more
* additional parameters, within which the mitk-image (\a mitkImage) is accessed:
* \code
* template < typename TPixel, unsigned int VImageDimension >
* void ExampleFunction( itk::Image<TPixel, VImageDimension>* itkImage, SomeType param);
* \endcode
*
* The itk::Image passed to the function/method has the same
* data-pointer as the mitk-image. So you have full read- and write-
* access to the data vector of the mitk-image using the itk-image.
* Call by:
* \code
* SomeType param = ...
* mitk::Image* inputMitkImage = ...
* try
* {
* AccessByItk_n(inputMitkImage, ExampleFunction, (param));
* }
* catch (const mitk::AccessByItkException& e)
* {
* // mitk::Image is of wrong pixel type or dimension,
* // insert error handling here
* }
* \endcode
*
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \note If your inputMitkImage is an mitk::Image::Pointer, use
* inputMitkImage.GetPointer()
* \note If you know the dimension of your input mitk-image,
* it is better to use AccessFixedDimensionByItk_n (less code
* is generated).
* \sa AccessFixedDimensionByItk_n
* \sa AccessFixedTypeByItk_n
* \sa AccessFixedPixelTypeByItk_n
* \sa AccessByItk
*
* \ingroup Adaptor
*/
#define AccessByItk_n(mitkImage, itkImageTypeFunction, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ, va_tuple)
/**
* \brief Access a mitk-image with known pixeltype (but unknown dimension) by an itk-image
* with one or more parameters.
*
* For usage, see #AccessByItk_n.
*
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param pixelTypeSeq A sequence of pixel types, like (short)(char)(int).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* If the image has a different pixel type, a mitk::AccessByItkException exception is
* thrown. If you do not know the pixel type for sure, use #AccessByItk_n.
*
* \sa AccessByItk_n
* \sa AccessFixedDimensionByItk_n
* \sa AccessFixedTypeByItk_n
* \sa AccessFixedPixelTypeByItk
*
* \ingroup Adaptor
*/
#define AccessFixedPixelTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, MITK_ACCESSBYITK_DIMENSIONS_SEQ, va_tuple)
/**
* \brief Access an mitk::Image with an integral pixel type by an ITK image with
* one or more parameters.
*
* See #AccessByItk_n for details.
*
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \sa AccessFixedPixelTypeByItk_n
* \sa AccessByItk_n
* \sa AccessIntegralPixelTypeByItk
*/
#define AccessIntegralPixelTypeByItk_n(mitkImage, itkImageTypeFunction, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ, va_tuple)
/**
* \brief Access an mitk::Image with a floating point pixel type by an ITK image
* with one or more parameters.
*
* See #AccessByItk_n for details.
*
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \sa AccessFixedPixelTypeByItk_n
* \sa AccessByItk_n
* \sa AccessFloatingPixelTypeByItk
*/
#define AccessFloatingPixelTypeByItk_n(mitkImage, itkImageTypeFunction, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ, va_tuple)
/**
* \brief Access a mitk-image with known dimension by an itk-image with
* one or more parameters.
*
* For usage, see #AccessByItk_n.
*
* \param dimension Dimension of the mitk-image. If the image has a different dimension,
* a mitk::AccessByItkException exception is thrown.
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \note If you do not know the dimension for sure, use #AccessByItk_n.
*
* \sa AccessByItk_n
* \sa AccessFixedDimensionByItk
* \sa AccessFixedTypeByItk_n
* \sa AccessFixedPixelTypeByItk_n
*
* \ingroup Adaptor
*/
#define AccessFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ, (dimension), va_tuple)
/**
* \brief Access a mitk-image with known type (pixel type and dimension) by an itk-image
* with one or more parameters.
*
* For usage, see AccessFixedTypeByItk.
*
* \param pixelTypeSeq A sequence of pixel types, like (short)(char)(int).
* \param dimSeq A sequence of dimensions, like (2)(3).
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* If the image has a different dimension or pixel type,
* a mitk::AccessByItkException exception is thrown.
*
* \note If you do not know the dimension for sure, use #AccessByItk_n.
*
* \sa AccessByItk_n
* \sa AccessFixedDimensionByItk_n
* \sa AccessFixedTypeByItk
* \sa AccessFixedPixelTypeByItk_n
*
* \ingroup Adaptor
*/
#define AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, va_tuple) \
{ \
const mitk::PixelType& pixelType = mitkImage->GetPixelType(); \
const mitk::Image* constImage = mitkImage; \
mitk::Image* nonConstImage = const_cast<mitk::Image*>(constImage); \
nonConstImage->Update(); \
_checkSpecificDimension(nonConstImage, dimSeq); \
_accessFixedTypeByItk_n(itkImageTypeFunction, pixelTypeSeq, dimSeq, va_tuple) \
_accessByItkPixelTypeException(nonConstImage->GetPixelType(), pixelTypeSeq) \
}
//------------------------- For back-wards compatibility -------------------------------
#define AccessByItk_1(mitkImage, itkImageTypeFunction, arg1) AccessByItk_n(mitkImage, itkImageTypeFunction, (arg1))
#define AccessFixedPixelTypeByItk_1(mitkImage, itkImageTypeFunction, pixelTypeSeq, arg1) AccessFixedPixelTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, (arg1))
#define AccessFixedDimensionByItk_1(mitkImage, itkImageTypeFunction, dimension, arg1) AccessFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, (arg1))
#define AccessFixedTypeByItk_1(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, arg1) AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, (arg1))
#define AccessByItk_2(mitkImage, itkImageTypeFunction, arg1, arg2) AccessByItk_n(mitkImage, itkImageTypeFunction, (arg1,arg2))
#define AccessFixedPixelTypeByItk_2(mitkImage, itkImageTypeFunction, pixelTypeSeq, arg1, arg2) AccessFixedPixelTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, (arg1,arg2))
#define AccessFixedDimensionByItk_2(mitkImage, itkImageTypeFunction, dimension, arg1, arg2) AccessFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, (arg1,arg2))
#define AccessFixedTypeByItk_2(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, arg1, arg2) AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, (arg1,arg2))
#define AccessByItk_3(mitkImage, itkImageTypeFunction, arg1, arg2, arg3) AccessByItk_n(mitkImage, itkImageTypeFunction, (arg1,arg2,arg3))
#define AccessFixedPixelTypeByItk_3(mitkImage, itkImageTypeFunction, pixelTypeSeq, arg1, arg2, arg3) AccessFixedPixelTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, (arg1,arg2,arg3))
#define AccessFixedDimensionByItk_3(mitkImage, itkImageTypeFunction, dimension, arg1, arg2, arg3) AccessFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, (arg1,arg2,arg3))
#define AccessFixedTypeByItk_3(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, arg1, arg2, arg3) AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, (arg1,arg2,arg3))
//----------------------------- Access two MITK Images ---------------------------------
#ifndef DOXYGEN_SKIP
#define _accessTwoImagesByItk(itkImageTypeFunction, pixeltype1, dim1, pixeltype2, dim2) \
if (pixelType1 == mitk::MakePixelType< itk::Image<pixeltype1,dim1> >() && \
pixelType2 == mitk::MakePixelType< itk::Image<pixeltype2,dim2> >() && \
constImage1->GetDimension() == dim1 && constImage2->GetDimension() == dim2) \
{ \
typedef itk::Image<pixeltype1,dim1> ImageType1; \
typedef itk::Image<pixeltype2,dim2> ImageType2; \
typedef mitk::ImageToItk<ImageType1> ImageToItkType1; \
typedef mitk::ImageToItk<ImageType2> ImageToItkType2; \
itk::SmartPointer<ImageToItkType1> imagetoitk1 = ImageToItkType1::New(); \
imagetoitk1->SetInput(nonConstImage1); \
imagetoitk1->Update(); \
itk::SmartPointer<ImageToItkType2> imagetoitk2 = ImageToItkType2::New(); \
imagetoitk2->SetInput(nonConstImage2); \
imagetoitk2->Update(); \
itkImageTypeFunction(imagetoitk1->GetOutput(), imagetoitk2->GetOutput()); \
} else
#define _accessTwoImagesByItkArgs2(itkImageTypeFunction, type1, type2) \
(itkImageTypeFunction, MITK_PP_TUPLE_REM(2) type1, MITK_PP_TUPLE_REM(2) type2)
#define _accessTwoImagesByItkArgs(product) \
MITK_PP_EXPAND(_accessTwoImagesByItkArgs2 MITK_PP_EXPAND((MITK_PP_SEQ_HEAD(product), MITK_PP_TUPLE_REM(2) MITK_PP_SEQ_TO_TUPLE(MITK_PP_SEQ_TAIL(product)))))
// product is of the form (itkImageTypeFunction)((short,2))((char,2))
#ifdef _MSC_VER
#define _accessTwoImagesByItkIter(r, product) \
MITK_PP_EXPAND(_accessTwoImagesByItk _msvc_expand_bug(_accessTwoImagesByItkArgs2, (MITK_PP_SEQ_HEAD(product), _msvc_expand_bug(MITK_PP_TUPLE_REM(2), MITK_PP_EXPAND(MITK_PP_SEQ_TO_TUPLE (MITK_PP_SEQ_TAIL(product)))))))
#else
#define _accessTwoImagesByItkIter(r, product) \
MITK_PP_EXPAND(_accessTwoImagesByItk _accessTwoImagesByItkArgs(product))
#endif
#define _accessTwoImagesByItkForEach(itkImageTypeFunction, tseq1, tseq2) \
MITK_PP_SEQ_FOR_EACH_PRODUCT(_accessTwoImagesByItkIter, ((itkImageTypeFunction))(tseq1)(tseq2))
#endif // DOXYGEN_SKIP
/**
* \brief Access two mitk-images with known dimension by itk-images
*
* Define a templated function or method (\a itkImageTypeFunction)
* within which the mitk-images (\a mitkImage1 and \a mitkImage2) are accessed:
* \code
* template <typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
* void ExampleFunctionTwoImages(itk::Image<TPixel1, VImageDimension1>* itkImage1, itk::Image<TPixel2, VImageDimension2>* itkImage2);
* \endcode
*
* The itk::Image passed to the function/method has the same
* data-pointer as the mitk-image. So you have full read- and write-
* access to the data vector of the mitk-image using the itk-image.
* Call by:
* \code
* mitk::Image* inputMitkImage1 = ...
* mitk::Image* inputMitkImage2 = ...
* try
* {
* AccessTwoImagesFixedDimensionByItk(inputMitkImage1, inputMitkImage2, ExampleFunctionTwoImages, 3);
* }
* catch (const mitk::AccessByItkException& e)
* {
* // mitk::Image arguments are of wrong pixel type or dimension,
* // insert error handling here
* }
* \endcode
*
* \note If your inputMitkImage1 or inputMitkImage2 is a mitk::Image::Pointer, use
* inputMitkImage1.GetPointer().
*
* \param mitkImage1 The first MITK input image.
* \param mitkImage1 The second MITK input image.
* \param itkImageTypeFunction The name of the template access-function to be called.
* \param dimension Dimension of the two mitk-images.
*
* \throws mitk::AccessByItkException If mitkImage1 and mitkImage2 have different dimensions or
* one of the images is of unsupported pixel type or dimension.
*
* \sa #AccessByItk
*
* \ingroup Adaptor
*/
#define AccessTwoImagesFixedDimensionByItk(mitkImage1, mitkImage2, itkImageTypeFunction, dimension) \
{ \
const mitk::PixelType& pixelType1 = mitkImage1->GetPixelType(); \
const mitk::PixelType& pixelType2 = mitkImage2->GetPixelType(); \
const mitk::Image* constImage1 = mitkImage1; \
const mitk::Image* constImage2 = mitkImage2; \
mitk::Image* nonConstImage1 = const_cast<mitk::Image*>(constImage1); \
mitk::Image* nonConstImage2 = const_cast<mitk::Image*>(constImage2); \
nonConstImage1->Update(); \
nonConstImage2->Update(); \
_checkSpecificDimension(mitkImage1, (dimension)); \
_checkSpecificDimension(mitkImage2, (dimension)); \
_accessTwoImagesByItkForEach(itkImageTypeFunction, MITK_ACCESSBYITK_TYPES_DIMN_SEQ(dimension), MITK_ACCESSBYITK_TYPES_DIMN_SEQ(dimension)) \
{ \
std::string msg("Pixel type "); \
msg.append(pixelType1.GetComponentTypeAsString() ); \
msg.append(" or pixel type "); \
msg.append(pixelType2.GetComponentTypeAsString() ); \
msg.append(" is not in " MITK_PP_STRINGIZE(MITK_ACCESSBYITK_TYPES_DIMN_SEQ(dimension))); \
throw mitk::AccessByItkException(msg); \
} \
}
#endif // of MITKIMAGEACCESSBYITK_H_HEADER_INCLUDED
diff --git a/Core/Code/DataManagement/mitkImageCastPart2.cpp b/Core/Code/DataManagement/mitkImageCastPart2.cpp
index eae4ec24b4..47b17b7c1d 100644
--- a/Core/Code/DataManagement/mitkImageCastPart2.cpp
+++ b/Core/Code/DataManagement/mitkImageCastPart2.cpp
@@ -1,40 +1,40 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkImageCast.h>
#include <mitkImageAccessByItk.h>
#include <mitkInstantiateAccessFunctions.h>
#include <itkImage.h>
#include <itkCastImageFilter.h>
namespace mitk
{
#ifndef DOXYGEN_SKIP
template <typename ItkOutputImageType> void CastToItkImage(const mitk::Image * mitkImage, itk::SmartPointer<ItkOutputImageType>& itkOutputImage)
{
- AccessFixedDimensionByItk_1(mitkImage, _CastToItkImage2Access, ::itk::GetImageDimension<ItkOutputImageType>::ImageDimension, itkOutputImage);
+ AccessFixedDimensionByItk_1(mitkImage, _CastToItkImage2Access, ItkOutputImageType::ImageDimension, itkOutputImage);
}
#endif //DOXYGEN_SKIP
#define InstantiateAccessFunction_CastToItkImage(pixelType, dim) \
template MITK_CORE_EXPORT void CastToItkImage(const mitk::Image *, itk::SmartPointer<itk::Image<pixelType,dim> >&);
InstantiateAccessFunction(CastToItkImage)
}
diff --git a/Core/Code/DataManagement/mitkImageCastPart4.cpp b/Core/Code/DataManagement/mitkImageCastPart4.cpp
index 6c2211ac13..7503af1702 100644
--- a/Core/Code/DataManagement/mitkImageCastPart4.cpp
+++ b/Core/Code/DataManagement/mitkImageCastPart4.cpp
@@ -1,154 +1,154 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkImageCast.h>
#include <mitkImageAccessByItk.h>
#include <itkRGBPixel.h>
#include <itkImage.h>
#include <itkCastImageFilter.h>
#include <itkDiffusionTensor3D.h>
namespace mitk
{
#ifndef DOXYGEN_SKIP
template <typename ItkOutputImageType> void CastToItkImage(const mitk::Image * mitkImage, itk::SmartPointer<ItkOutputImageType>& itkOutputImage)
{
- AccessFixedDimensionByItk_1(mitkImage, _CastToItkImage2Access, ::itk::GetImageDimension<ItkOutputImageType>::ImageDimension, itkOutputImage);
+ AccessFixedDimensionByItk_1(mitkImage, _CastToItkImage2Access, (ItkOutputImageType::ImageDimension), itkOutputImage);
}
#endif //DOXYGEN_SKIP
typedef itk::Image<itk::RGBPixel<unsigned char>, 2> itkImageRGBUC2;
typedef itk::Image<itk::DiffusionTensor3D<float>, 2> itkImageDTIF2;
typedef itk::Image<itk::DiffusionTensor3D<double>, 2> itkImageDTID2;
template <> void MITK_CORE_EXPORT CastToItkImage<itkImageRGBUC2>(const mitk::Image * mitkImage, itk::SmartPointer<itkImageRGBUC2>& itkOutputImage)
{
typedef itkImageRGBUC2 ItkOutputImageType;
- AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::RGBPixel<unsigned char>), (::itk::GetImageDimension<ItkOutputImageType>::ImageDimension), itkOutputImage);
+ AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::RGBPixel<unsigned char>), (ItkOutputImageType::ImageDimension), itkOutputImage);
}
template <> void MITK_CORE_EXPORT CastToItkImage<itkImageDTIF2>(const mitk::Image * mitkImage, itk::SmartPointer<itkImageDTIF2>& itkOutputImage)
{
typedef itkImageDTIF2 ItkOutputImageType;
- AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::DiffusionTensor3D<float>), (::itk::GetImageDimension<ItkOutputImageType>::ImageDimension), itkOutputImage);
+ AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::DiffusionTensor3D<float>), (ItkOutputImageType::ImageDimension), itkOutputImage);
}
template <> void MITK_CORE_EXPORT CastToItkImage<itkImageDTID2>(const mitk::Image * mitkImage, itk::SmartPointer<itkImageDTID2>& itkOutputImage)
{
typedef itkImageDTID2 ItkOutputImageType;
- AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::DiffusionTensor3D<double>), (::itk::GetImageDimension<ItkOutputImageType>::ImageDimension), itkOutputImage);
+ AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::DiffusionTensor3D<double>), (ItkOutputImageType::ImageDimension), itkOutputImage);
}
typedef itk::Image<itk::RGBPixel<unsigned char>, 3> itkImageRGBUC3;
typedef itk::Image<itk::DiffusionTensor3D<float>, 3> itkImageDTIF3;
typedef itk::Image<itk::DiffusionTensor3D<double>, 3> itkImageDTID3;
template <> void MITK_CORE_EXPORT CastToItkImage<itkImageRGBUC3>(const mitk::Image * mitkImage, itk::SmartPointer<itkImageRGBUC3>& itkOutputImage)
{
typedef itkImageRGBUC3 ItkOutputImageType;
- AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::RGBPixel<unsigned char>), (::itk::GetImageDimension<ItkOutputImageType>::ImageDimension), itkOutputImage);
+ AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::RGBPixel<unsigned char>), (ItkOutputImageType::ImageDimension), itkOutputImage);
}
template <> void MITK_CORE_EXPORT CastToItkImage<itkImageDTIF3>(const mitk::Image * mitkImage, itk::SmartPointer<itkImageDTIF3>& itkOutputImage)
{
typedef itkImageDTIF3 ItkOutputImageType;
- AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::DiffusionTensor3D<float>), (::itk::GetImageDimension<ItkOutputImageType>::ImageDimension), itkOutputImage);
+ AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::DiffusionTensor3D<float>), (ItkOutputImageType::ImageDimension), itkOutputImage);
}
template <> void MITK_CORE_EXPORT CastToItkImage<itkImageDTID3>(const mitk::Image * mitkImage, itk::SmartPointer<itkImageDTID3>& itkOutputImage)
{
typedef itkImageDTID3 ItkOutputImageType;
- AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::DiffusionTensor3D<double>), (::itk::GetImageDimension<ItkOutputImageType>::ImageDimension), itkOutputImage);
+ AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (itk::DiffusionTensor3D<double>), (ItkOutputImageType::ImageDimension), itkOutputImage);
}
#define TYPE_VECS(HUN) \
TYPE_TEN_VECS(HUN) \
TYPE_TEN_VECS(HUN + 10) \
TYPE_TEN_VECS(HUN + 20) \
TYPE_TEN_VECS(HUN + 30) \
TYPE_TEN_VECS(HUN + 40) \
TYPE_TEN_VECS(HUN + 50) \
TYPE_TEN_VECS(HUN + 60) \
TYPE_TEN_VECS(HUN + 70) \
TYPE_TEN_VECS(HUN + 80) \
TYPE_TEN_VECS(HUN + 90) \
#define TYPE_TEN_VECS(HUN) \
TYPE_N_VEC(HUN + 1) \
TYPE_N_VEC(HUN + 2) \
TYPE_N_VEC(HUN + 3) \
TYPE_N_VEC(HUN + 4) \
TYPE_N_VEC(HUN + 5) \
TYPE_N_VEC(HUN + 6) \
TYPE_N_VEC(HUN + 7) \
TYPE_N_VEC(HUN + 8) \
TYPE_N_VEC(HUN + 9) \
TYPE_N_VEC(HUN + 10) \
#define TYPE_N_VEC(N_DIRS) \
_TYPE_N_VEC(N_DIRS,double) \
_TYPE_N_VEC(N_DIRS,float) \
_TYPE_N_VEC(N_DIRS,short) \
#define _TYPE_N_VEC(N_DIRS,PIXTYPE) \
template <> void MITK_CORE_EXPORT CastToItkImage<itk::Image<itk::Vector<PIXTYPE,N_DIRS>, 2> >(const mitk::Image * mitkImage, itk::SmartPointer<itk::Image<itk::Vector<PIXTYPE,N_DIRS>, 2> >& itkOutputImage) \
{ \
typedef itk::Vector<PIXTYPE,N_DIRS> VECTORTYPE; \
typedef itk::Image<VECTORTYPE, 2> ItkOutputImageType2; \
- AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (VECTORTYPE), (::itk::GetImageDimension<ItkOutputImageType2>::ImageDimension), itkOutputImage); \
+ AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (VECTORTYPE), (ItkOutputImageType2::ImageDimension), itkOutputImage); \
} \
template <> void MITK_CORE_EXPORT CastToItkImage<itk::Image<itk::Vector<PIXTYPE,N_DIRS>, 3> >(const mitk::Image * mitkImage, itk::SmartPointer<itk::Image<itk::Vector<PIXTYPE,N_DIRS>, 3> >& itkOutputImage) \
{ \
typedef itk::Vector<PIXTYPE,N_DIRS> VECTORTYPE; \
typedef itk::Image<VECTORTYPE, 3> ItkOutputImageType3; \
- AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (VECTORTYPE), (::itk::GetImageDimension<ItkOutputImageType3>::ImageDimension), itkOutputImage); \
+ AccessFixedTypeByItk_1(mitkImage, _CastToItkImage2Access, (VECTORTYPE), (ItkOutputImageType3::ImageDimension), itkOutputImage); \
} \
// the following lines allow for fixed-size vector images up to a certain size limit
// (commented out for shorter compile times)
//TYPE_VECS(000)
//TYPE_VECS(100)
//TYPE_VECS(200)
//TYPE_VECS(300)
//TYPE_VECS(400)
//TYPE_VECS(500)
//TYPE_VECS(600)
//TYPE_VECS(700)
// allow for fixed-size vectors of specific length
// (inspired by itkPointshell.cpp, precompiled q-ball configs)
//TYPE_TEN_VECS(0)
//TYPE_N_VEC(11)
//TYPE_N_VEC(12)
TYPE_N_VEC(2)
TYPE_N_VEC(3)
TYPE_N_VEC(6)
TYPE_N_VEC(42)
TYPE_N_VEC(92)
TYPE_N_VEC(162)
TYPE_N_VEC(252)
TYPE_N_VEC(362)
TYPE_N_VEC(492)
TYPE_N_VEC(642)
TYPE_N_VEC(812)
TYPE_N_VEC(1002)
#ifndef DOXYGEN_SKIP
#endif //DOXYGEN_SKIP
}
diff --git a/Core/Code/DataManagement/mitkImageDataItem.cpp b/Core/Code/DataManagement/mitkImageDataItem.cpp
index 87c8436b7b..740c9294f2 100644
--- a/Core/Code/DataManagement/mitkImageDataItem.cpp
+++ b/Core/Code/DataManagement/mitkImageDataItem.cpp
@@ -1,268 +1,268 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImageDataItem.h"
#include "mitkMemoryUtilities.h"
#include <vtkImageData.h>
#include <vtkPointData.h>
#include <vtkBitArray.h>
#include <vtkCharArray.h>
#include <vtkDoubleArray.h>
#include <vtkFloatArray.h>
#include <vtkIntArray.h>
#include <vtkLongArray.h>
#include <vtkShortArray.h>
#include <vtkUnsignedCharArray.h>
#include <vtkUnsignedIntArray.h>
#include <vtkUnsignedLongArray.h>
#include <vtkUnsignedShortArray.h>
#include <mitkImageVtkAccessor.h>
#include <mitkImage.h>
mitk::ImageDataItem::ImageDataItem(const ImageDataItem& aParent, const mitk::ImageDescriptor::Pointer desc, unsigned int dimension, void *data, bool manageMemory, size_t offset) :
m_Data(NULL), m_ManageMemory(false), m_VtkImageData(NULL), m_Offset(offset), m_IsComplete(false), m_Size(0),
m_Parent(&aParent)
{
m_PixelType = new mitk::PixelType(aParent.GetPixelType());
m_Data = static_cast<unsigned char*>(aParent.m_Data)+offset;
// compute size
//const unsigned int *dims = desc->GetDimensions();
m_Dimension = dimension;
for( unsigned int i=0; i<dimension; i++)
m_Dimensions[i] = desc->GetDimensions()[i];
this->ComputeItemSize(m_Dimensions,dimension);
if(data != NULL)
{
memcpy(m_Data, data, m_Size);
if(manageMemory)
{
delete [] (unsigned char*) data;
}
}
m_ReferenceCountLock.Lock();
m_ReferenceCount = 0;
m_ReferenceCountLock.Unlock();
}
mitk::ImageDataItem::~ImageDataItem()
{
if(m_VtkImageData!=NULL)
m_VtkImageData->Delete();
if(m_Parent.IsNull())
{
if(m_ManageMemory)
delete [] m_Data;
}
delete m_PixelType;
}
mitk::ImageDataItem::ImageDataItem(const mitk::ImageDescriptor::Pointer desc, void *data, bool manageMemory)
: m_Data((unsigned char*)data), m_ManageMemory(manageMemory), m_VtkImageData(NULL), m_Offset(0), m_IsComplete(false), m_Size(0)
{
m_PixelType = new mitk::PixelType(desc->GetChannelDescriptor(0).GetPixelType());
// compute size
const unsigned int *dimensions = desc->GetDimensions();
m_Dimension = desc->GetNumberOfDimensions();
for( unsigned int i=0; i<m_Dimension; i++)
m_Dimensions[i] = dimensions[i];
this->ComputeItemSize(m_Dimensions, m_Dimension );
if(m_Data == NULL)
{
m_Data = mitk::MemoryUtilities::AllocateElements<unsigned char>( m_Size );
m_ManageMemory = true;
}
m_ReferenceCountLock.Lock();
m_ReferenceCount = 0;
m_ReferenceCountLock.Unlock();
}
mitk::ImageDataItem::ImageDataItem(const mitk::PixelType& type, unsigned int dimension, unsigned int *dimensions, void *data, bool manageMemory) :
m_Data((unsigned char*)data), m_ManageMemory(manageMemory), m_VtkImageData(NULL), m_Offset(0), m_IsComplete(false), m_Size(0),
m_Parent(NULL)
{
m_PixelType = new mitk::PixelType(type);
m_Dimension = dimension;
for( unsigned int i=0; i<m_Dimension; i++)
m_Dimensions[i] = dimensions[i];
this->ComputeItemSize(dimensions, dimension);
if(m_Data == NULL)
{
m_Data = mitk::MemoryUtilities::AllocateElements<unsigned char>( m_Size );
m_ManageMemory = true;
}
m_ReferenceCountLock.Lock();
m_ReferenceCount = 0;
m_ReferenceCountLock.Unlock();
}
mitk::ImageDataItem::ImageDataItem(const ImageDataItem &other)
: itk::LightObject(), m_PixelType(other.m_PixelType), m_ManageMemory(other.m_ManageMemory), m_Offset(other.m_Offset),
m_IsComplete(other.m_IsComplete), m_Size(other.m_Size)
{
}
void mitk::ImageDataItem::ComputeItemSize(const unsigned int *dimensions, unsigned int dimension)
{
m_Size = m_PixelType->GetSize();
for( unsigned int i=0; i<dimension; i++)
{
m_Size *= *(dimensions+i);
}
}
void mitk::ImageDataItem::ConstructVtkImageData(ImagePointer iP) const
{
mitk::ImageVtkAccessor *inData = ImageVtkAccessor::New(iP,this); //vtkImageData::New();
vtkDataArray *scalars = NULL;
const unsigned int *dims = m_Dimensions;
const unsigned int dim = m_Dimension;
unsigned long size = 0;
if ( dim == 1 )
{
inData->SetDimensions( dims[0] -1, 1, 1);
size = dims[0];
inData->SetOrigin( ((float) dims[0]) / 2.0f, 0, 0 );
}
else
if ( dim == 2 )
{
inData->SetDimensions( dims[0] , dims[1] , 1 );
size = dims[0] * dims[1];
inData->SetOrigin( ((float) dims[0]) / 2.0f, ((float) dims[1]) / 2.0f, 0 );
}
else
if ( dim >= 3 )
{
inData->SetDimensions( dims[0], dims[1], dims[2] );
size = dims[0] * dims[1] * dims[2];
// Test
//inData->SetOrigin( (float) dims[0] / 2.0f, (float) dims[1] / 2.0f, (float) dims[2] / 2.0f );
inData->SetOrigin( 0, 0, 0 );
}
else
{
inData->Delete () ;
return;
}
inData->SetNumberOfScalarComponents(m_PixelType->GetNumberOfComponents());
/* if ( ( m_PixelType.GetType() == mitkIpPicInt || m_PixelType.GetType() == mitkIpPicUInt ) && m_PixelType.GetBitsPerComponent() == 1 )
{
inData->SetScalarType( VTK_BIT );
scalars = vtkBitArray::New();
}
- else*/ if ( m_PixelType->GetTypeId() == typeid(char) )
+ else*/ if ( m_PixelType->GetComponentType() == itk::ImageIOBase::CHAR )
{
inData->SetScalarType( VTK_CHAR );
scalars = vtkCharArray::New();
}
- else if ( m_PixelType->GetTypeId() == typeid(unsigned char))
+ else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::UCHAR)
{
inData->SetScalarType( VTK_UNSIGNED_CHAR );
scalars = vtkUnsignedCharArray::New();
}
- else if ( m_PixelType->GetTypeId() == typeid(short) )
+ else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::SHORT )
{
inData->SetScalarType( VTK_SHORT );
scalars = vtkShortArray::New();
}
- else if ( m_PixelType->GetTypeId() == typeid(unsigned short) )
+ else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::USHORT )
{
inData->SetScalarType( VTK_UNSIGNED_SHORT );
scalars = vtkUnsignedShortArray::New();
}
- else if ( m_PixelType->GetTypeId() == typeid(int) )
+ else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::INT )
{
inData->SetScalarType( VTK_INT );
scalars = vtkIntArray::New();
}
- else if ( m_PixelType->GetTypeId() == typeid(unsigned int) )
+ else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::UINT )
{
inData->SetScalarType( VTK_UNSIGNED_INT );
scalars = vtkUnsignedIntArray::New();
}
- else if ( m_PixelType->GetTypeId() == typeid(long int) )
+ else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::LONG )
{
inData->SetScalarType( VTK_LONG );
scalars = vtkLongArray::New();
}
- else if ( m_PixelType->GetTypeId() == typeid(unsigned long int) )
+ else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::ULONG )
{
inData->SetScalarType( VTK_UNSIGNED_LONG );
scalars = vtkUnsignedLongArray::New();
}
- else if ( m_PixelType->GetTypeId() == typeid(float) )
+ else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::FLOAT )
{
inData->SetScalarType( VTK_FLOAT );
scalars = vtkFloatArray::New();
}
- else if ( m_PixelType->GetTypeId() == typeid(double) )
+ else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::DOUBLE )
{
inData->SetScalarType( VTK_DOUBLE );
scalars = vtkDoubleArray::New();
}
else
{
inData->Delete();
return;
}
m_VtkImageData = inData;
// allocate the new scalars
scalars->SetNumberOfComponents(m_VtkImageData->GetNumberOfScalarComponents());
scalars->SetVoidArray(m_Data, size * m_VtkImageData->GetNumberOfScalarComponents(), 1);
m_VtkImageData->GetPointData()->SetScalars(scalars);
scalars->Delete();
}
void mitk::ImageDataItem::Modified() const
{
if(m_VtkImageData)
m_VtkImageData->Modified();
}
mitk::ImageVtkAccessor* mitk::ImageDataItem::GetVtkImageData(mitk::ImagePointer iP) const
{
if(m_VtkImageData==NULL)
ConstructVtkImageData(iP);
return m_VtkImageData;
}
diff --git a/Core/Code/DataManagement/mitkImageDescriptor.cpp b/Core/Code/DataManagement/mitkImageDescriptor.cpp
index a0a3c9c7de..725bcae6bc 100644
--- a/Core/Code/DataManagement/mitkImageDescriptor.cpp
+++ b/Core/Code/DataManagement/mitkImageDescriptor.cpp
@@ -1,120 +1,120 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImageDescriptor.h"
mitk::ImageDescriptor::ImageDescriptor()
{
//initialize the dimensions array
for(unsigned int i=0; i<MAX_IMAGE_DIMENSIONS; i++)
{
m_Dimensions[i] = 1;
}
this->m_NumberOfChannels = 0;
}
// FIXME manage memory flag
void mitk::ImageDescriptor::AddNewChannel(mitk::PixelType ptype, const char *name)
{
size_t elems = 1;
for( unsigned int i=0; i<this->m_NumberOfDimensions; i++)
elems *= this->m_Dimensions[i];
mitk::ChannelDescriptor desc(ptype, elems);
this->m_ChannelDesc.push_back( desc );
if( name == 0)
- m_ChannelNames.push_back( "Unnamed ["+ptype.GetItkTypeAsString()+"]");
+ m_ChannelNames.push_back( "Unnamed ["+ptype.GetPixelTypeAsString()+"]");
else
m_ChannelNames.push_back(name);
this->m_NumberOfChannels++;
return;
}
void mitk::ImageDescriptor::Initialize(const ImageDescriptor::Pointer refDescriptor, unsigned int channel)
{
// initialize the members holding dimension information
this->m_NumberOfChannels = refDescriptor->GetNumberOfChannels();
this->m_NumberOfDimensions = refDescriptor->GetNumberOfDimensions();
const unsigned int *refDims = refDescriptor->GetDimensions();
// copy the dimension information
for( unsigned int i=0; i< this->m_NumberOfDimensions; i++)
{
this->m_Dimensions[i] = refDims[i];
}
// get the channel descriptor and store them and so the name of the channel
mitk::ChannelDescriptor desc = refDescriptor->GetChannelDescriptor(channel);
this->m_ChannelDesc.push_back( desc );
this->m_ChannelNames.push_back( refDescriptor->GetChannelName(channel) );
}
void mitk::ImageDescriptor::Initialize(const unsigned int *dims, const unsigned int dim)
{
this->m_NumberOfDimensions = dim;
// copy the dimension information
for( unsigned int i=0; i< this->m_NumberOfDimensions; i++)
{
this->m_Dimensions[i] = dims[i];
}
}
mitk::ChannelDescriptor mitk::ImageDescriptor::GetChannelDescriptor(unsigned int id) const
{
return this->m_ChannelDesc[id];
}
mitk::PixelType mitk::ImageDescriptor::GetChannelTypeByName(const char *name) const
{
unsigned int idFound = 0;
const std::string search_str(name);
for( ConstChannelNamesIter iter = this->m_ChannelNames.begin();
iter < this->m_ChannelNames.end(); iter++)
{
if( search_str.compare( *iter ) ) idFound = iter - this->m_ChannelNames.begin();
}
return (m_ChannelDesc[idFound]).GetPixelType();
}
mitk::PixelType mitk::ImageDescriptor::GetChannelTypeById(const unsigned int id) const
{
if( id > this->m_NumberOfChannels )
{
throw std::invalid_argument("The given id exceeds the number of active channel.");
}
else
{
mitk::ChannelDescriptor refDesc = this->m_ChannelDesc[id];
return refDesc.GetPixelType();//
}
}
const std::string mitk::ImageDescriptor::GetChannelName(unsigned int id) const
{
if( id > this->m_ChannelNames.size() )
return "Out-of-range-access";
else
return this->m_ChannelNames.at( id );
}
diff --git a/Core/Code/DataManagement/mitkImageToItk.h b/Core/Code/DataManagement/mitkImageToItk.h
index 8156f80af8..b522039375 100644
--- a/Core/Code/DataManagement/mitkImageToItk.h
+++ b/Core/Code/DataManagement/mitkImageToItk.h
@@ -1,119 +1,120 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef IMAGETOITK_H_HEADER_INCLUDED_C1C2FCD2
#define IMAGETOITK_H_HEADER_INCLUDED_C1C2FCD2
#if(_MSC_VER==1200)
#include <itkFixedCenterOfRotationAffineTransform.h>
#endif
#include <itkImage.h>
#include <itkImageSource.h>
#include "mitkImage.h"
#include "mitkImageDataItem.h"
#include "mitkImageWriteAccessor.h"
namespace mitk
{
/**
* Create itk::ImageSource for mitk::Image
* \ingroup Adaptor
*
* \warning 2D MITK images will get a 2D identity matrix in ITK
* \todo Get clear about how to handle directed ITK 2D images in ITK
*/
template <class TOutputImage>
class ImageToItk : public itk::ImageSource< TOutputImage >
{
protected:
mitk::Image::Pointer m_MitkImage;
mitk::ImageDataItem::Pointer m_ImageDataItem;
public:
typedef ImageToItk Self;
typedef itk::ImageSource<TOutputImage> Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Superclass typedefs. */
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
/** Some convenient typedefs. */
typedef mitk::Image InputImageType;
typedef InputImageType::Pointer InputImagePointer;
typedef InputImageType::ConstPointer InputImageConstPointer;
typedef SlicedData::RegionType InputImageRegionType;
typedef typename TOutputImage::SizeType SizeType;
typedef typename TOutputImage::IndexType IndexType;
typedef typename TOutputImage::RegionType RegionType;
typedef typename TOutputImage::PixelType PixelType;
virtual void SetInput(mitk::Image *input);
virtual void SetInput(unsigned int index, mitk::Image * image);
virtual void UpdateOutputInformation();
itkGetMacro( Channel, int );
itkSetMacro( Channel, int );
itkSetMacro( CopyMemFlag, bool );
itkGetMacro( CopyMemFlag, bool );
itkBooleanMacro( CopyMemFlag );
protected:
+ using itk::ProcessObject::SetInput;
mitk::Image * GetInput(void);
mitk::Image * GetInput(unsigned int idx);
ImageToItk(): m_CopyMemFlag(false), m_Channel(0)
{
}
virtual ~ImageToItk()
{
}
void PrintSelf(std::ostream& os, itk::Indent indent) const;
virtual void GenerateData();
virtual void GenerateOutputInformation();
private:
bool m_CopyMemFlag;
int m_Channel;
//ImageToItk(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
} // end namespace mitk
#ifndef ITK_MANUAL_INSTANTIATION
#include "mitkImageToItk.txx"
#endif
#endif // IMAGETOITK_H_HEADER_INCLUDED_C1C2FCD2
diff --git a/Core/Code/DataManagement/mitkLandmarkBasedCurvedGeometry.h b/Core/Code/DataManagement/mitkLandmarkBasedCurvedGeometry.h
index 07571f1a18..f7363d421f 100644
--- a/Core/Code/DataManagement/mitkLandmarkBasedCurvedGeometry.h
+++ b/Core/Code/DataManagement/mitkLandmarkBasedCurvedGeometry.h
@@ -1,60 +1,60 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKLANDMARKBASEDCURVEDGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define MITKLANDMARKBASEDCURVEDGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#include "mitkAbstractTransformGeometry.h"
#include "mitkPointSet.h"
namespace mitk {
//##Documentation
//## @brief Superclass of AbstractTransformGeometry sub-classes defined
//## by a set of landmarks.
//##
//## @ingroup Geometry
class MITK_CORE_EXPORT LandmarkBasedCurvedGeometry : public AbstractTransformGeometry
{
public:
mitkClassMacro(LandmarkBasedCurvedGeometry, AbstractTransformGeometry);
//##Documentation
//## @brief Set the landmarks through which the geometry shall pass
itkSetConstObjectMacro(TargetLandmarks, mitk::PointSet::DataType::PointsContainer);
//##Documentation
//## @brief Get the landmarks through which the geometry shall pass
itkGetConstObjectMacro(TargetLandmarks, mitk::PointSet::DataType::PointsContainer);
virtual void ComputeGeometry() = 0;
- virtual AffineGeometryFrame3D::Pointer Clone() const = 0;
+ virtual itk::LightObject::Pointer InternalClone() const = 0;
protected:
LandmarkBasedCurvedGeometry();
LandmarkBasedCurvedGeometry(const LandmarkBasedCurvedGeometry& other);
virtual ~LandmarkBasedCurvedGeometry();
mitk::PointSet::DataType::PointsContainer::ConstPointer m_TargetLandmarks;
};
} // namespace mitk
-#endif /* MITKLANDMARKBASEDCURVEDGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
+#endif
diff --git a/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp b/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
index 2b2db24763..439780cafc 100644
--- a/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
+++ b/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
@@ -1,82 +1,83 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLandmarkProjectorBasedCurvedGeometry.h"
#include <vtkAbstractTransform.h>
mitk::LandmarkProjectorBasedCurvedGeometry::LandmarkProjectorBasedCurvedGeometry()
: m_LandmarkProjector(NULL), m_InterpolatingAbstractTransform(NULL)
{
}
mitk::LandmarkProjectorBasedCurvedGeometry::LandmarkProjectorBasedCurvedGeometry(const mitk::LandmarkProjectorBasedCurvedGeometry& other) : Superclass(other)
{
this->SetLandmarkProjector(other.m_LandmarkProjector);
this->ComputeGeometry();
}
mitk::LandmarkProjectorBasedCurvedGeometry::~LandmarkProjectorBasedCurvedGeometry()
{
if(m_InterpolatingAbstractTransform!=NULL)
m_InterpolatingAbstractTransform->Delete();
}
void mitk::LandmarkProjectorBasedCurvedGeometry::SetLandmarkProjector(mitk::LandmarkProjector* aLandmarkProjector)
{
itkDebugMacro("setting LandmarkProjector to " << aLandmarkProjector );
if(m_LandmarkProjector != aLandmarkProjector)
{
m_LandmarkProjector = aLandmarkProjector;
if(m_LandmarkProjector.IsNotNull())
{
if(m_FrameGeometry.IsNotNull())
m_LandmarkProjector->SetFrameGeometry(m_FrameGeometry);
if(m_InterpolatingAbstractTransform == NULL)
{
itkWarningMacro(<<"m_InterpolatingAbstractTransform not set.");
}
m_LandmarkProjector->SetInterpolatingAbstractTransform(GetInterpolatingAbstractTransform());
SetVtkAbstractTransform(m_LandmarkProjector->GetCompleteAbstractTransform());
}
Modified();
}
}
void mitk::LandmarkProjectorBasedCurvedGeometry::SetFrameGeometry(const mitk::Geometry3D* frameGeometry)
{
Superclass::SetFrameGeometry(frameGeometry);
if(m_LandmarkProjector.IsNotNull())
m_LandmarkProjector->SetFrameGeometry(frameGeometry);
}
void mitk::LandmarkProjectorBasedCurvedGeometry::ComputeGeometry()
{
if(m_LandmarkProjector.IsNull())
{
itkExceptionMacro(<< "m_LandmarkProjector is not set.");
}
m_LandmarkProjector->ProjectLandmarks(m_TargetLandmarks);
SetPlane(m_LandmarkProjector->GetParameterPlane());
}
-mitk::AffineGeometryFrame3D::Pointer mitk::LandmarkProjectorBasedCurvedGeometry::Clone() const
+
+itk::LightObject::Pointer mitk::LandmarkProjectorBasedCurvedGeometry::InternalClone() const
{
- mitk::AffineGeometryFrame3D::Pointer newGeometry = new LandmarkProjectorBasedCurvedGeometry(*this);
+ itk::LightObject::Pointer newGeometry = new LandmarkProjectorBasedCurvedGeometry(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
diff --git a/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.h b/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.h
index 6b487c4bb1..b3b94d60c9 100644
--- a/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.h
+++ b/Core/Code/DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.h
@@ -1,61 +1,61 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKLANDMARKPROJECTORBASEDCURVEDGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define MITKLANDMARKPROJECTORBASEDCURVEDGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#include "mitkLandmarkBasedCurvedGeometry.h"
#include "mitkLandmarkProjector.h"
namespace mitk {
//##Documentation
//## @brief Superclass of AbstractTransformGeometry sub-classes defined
//## by a set of landmarks.
//##
//## @ingroup Geometry
class MITK_CORE_EXPORT LandmarkProjectorBasedCurvedGeometry : public LandmarkBasedCurvedGeometry
{
public:
mitkClassMacro(LandmarkProjectorBasedCurvedGeometry, LandmarkBasedCurvedGeometry);
void SetLandmarkProjector(mitk::LandmarkProjector* aLandmarkProjector);
itkGetConstObjectMacro(LandmarkProjector, mitk::LandmarkProjector);
virtual void SetFrameGeometry(const mitk::Geometry3D* frameGeometry);
virtual void ComputeGeometry();
itkGetConstMacro(InterpolatingAbstractTransform, vtkAbstractTransform*);
- mitk::AffineGeometryFrame3D::Pointer Clone() const;
+ itk::LightObject::Pointer InternalClone() const;
protected:
LandmarkProjectorBasedCurvedGeometry();
LandmarkProjectorBasedCurvedGeometry(const LandmarkProjectorBasedCurvedGeometry& other);
virtual ~LandmarkProjectorBasedCurvedGeometry();
mitk::LandmarkProjector::Pointer m_LandmarkProjector;
vtkAbstractTransform* m_InterpolatingAbstractTransform;
};
} // namespace mitk
#endif /* MITKLANDMARKPROJECTORBASEDCURVEDGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Core/Code/DataManagement/mitkLevelWindow.cpp b/Core/Code/DataManagement/mitkLevelWindow.cpp
index 1c096796bd..f6d7c6385b 100644
--- a/Core/Code/DataManagement/mitkLevelWindow.cpp
+++ b/Core/Code/DataManagement/mitkLevelWindow.cpp
@@ -1,442 +1,442 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLevelWindow.h"
#include "mitkImageSliceSelector.h"
#include "mitkImageStatisticsHolder.h"
#include <algorithm>
void mitk::LevelWindow::EnsureConsistency()
{
// Check if total range is ok
{
if ( m_RangeMin > m_RangeMax )
std::swap(m_RangeMin,m_RangeMax);
if (m_RangeMin == m_RangeMax )
m_RangeMin = m_RangeMax - 1;
}
// Check if current window is ok
{
if ( m_LowerWindowBound > m_UpperWindowBound )
std::swap(m_LowerWindowBound,m_UpperWindowBound);
if ( m_LowerWindowBound < m_RangeMin ) m_LowerWindowBound = m_RangeMin;
if ( m_UpperWindowBound < m_RangeMin ) m_UpperWindowBound = m_RangeMin;
if ( m_LowerWindowBound > m_RangeMax ) m_LowerWindowBound = m_RangeMax;
if ( m_UpperWindowBound > m_RangeMax ) m_UpperWindowBound = m_RangeMax;
if (m_LowerWindowBound == m_UpperWindowBound )
{
if(m_LowerWindowBound == m_RangeMin )
m_UpperWindowBound++;
else
m_LowerWindowBound--;
}
}
}
mitk::LevelWindow::LevelWindow(mitk::ScalarType level, mitk::ScalarType window)
: m_LowerWindowBound( level - window / 2.0 ), m_UpperWindowBound( level + window / 2.0 ),
m_RangeMin( -2048.0 ), m_RangeMax( 4096.0 ),
m_DefaultLowerBound( -2048.0 ), m_DefaultUpperBound( 4096.0 ),
m_Fixed( false )
{
SetDefaultLevelWindow(level, window);
}
mitk::LevelWindow::LevelWindow(const mitk::LevelWindow& levWin)
: m_LowerWindowBound( levWin.GetLowerWindowBound() )
, m_UpperWindowBound( levWin.GetUpperWindowBound() )
, m_RangeMin( levWin.GetRangeMin() )
, m_RangeMax( levWin.GetRangeMax() )
, m_DefaultLowerBound( levWin.GetDefaultLowerBound() )
, m_DefaultUpperBound( levWin.GetDefaultUpperBound() )
, m_Fixed( levWin.GetFixed() )
{
}
mitk::LevelWindow::~LevelWindow()
{
}
mitk::ScalarType mitk::LevelWindow::GetLevel() const
{
return (m_UpperWindowBound-m_LowerWindowBound) / 2.0 + m_LowerWindowBound;
}
mitk::ScalarType mitk::LevelWindow::GetWindow() const
{
return (m_UpperWindowBound-m_LowerWindowBound);
}
mitk::ScalarType mitk::LevelWindow::GetDefaultLevel() const
{
return ((m_DefaultUpperBound+m_DefaultLowerBound)/2.0);
}
mitk::ScalarType mitk::LevelWindow::GetDefaultWindow() const
{
return ((m_DefaultUpperBound-m_DefaultLowerBound));
}
void mitk::LevelWindow::ResetDefaultLevelWindow()
{
SetLevelWindow(GetDefaultLevel(), GetDefaultWindow());
}
mitk::ScalarType mitk::LevelWindow::GetLowerWindowBound() const
{
return m_LowerWindowBound;
}
mitk::ScalarType mitk::LevelWindow::GetUpperWindowBound() const
{
return m_UpperWindowBound;
}
void mitk::LevelWindow::SetDefaultLevelWindow(mitk::ScalarType level, mitk::ScalarType window)
{
SetDefaultBoundaries((level-(window/2.0)), (level+(window/2.0)));
}
void mitk::LevelWindow::SetLevelWindow(mitk::ScalarType level, mitk::ScalarType window, bool expandRangesIfNecessary)
{
SetWindowBounds( (level-(window/2.0)), (level+(window/2.0)), expandRangesIfNecessary );
}
void mitk::LevelWindow::SetWindowBounds(mitk::ScalarType lowerBound, mitk::ScalarType upperBound, bool expandRangesIfNecessary)
{
if ( IsFixed() ) return;
m_LowerWindowBound = lowerBound;
m_UpperWindowBound = upperBound;
if (expandRangesIfNecessary)
{
/* if caller is sure he wants exactly that level/window, we make sure the limits match */
if (m_LowerWindowBound > m_UpperWindowBound)
std::swap(m_LowerWindowBound, m_UpperWindowBound);
if ( m_LowerWindowBound < m_RangeMin )
{
m_RangeMin = m_LowerWindowBound;
}
if ( m_UpperWindowBound > m_RangeMax )
{
m_RangeMax = m_UpperWindowBound;
}
}
EnsureConsistency();
}
void mitk::LevelWindow::SetRangeMinMax(mitk::ScalarType min, mitk::ScalarType max)
{
if ( IsFixed() ) return;
m_RangeMin = min;
m_RangeMax = max;
EnsureConsistency();
}
void mitk::LevelWindow::SetDefaultBoundaries(mitk::ScalarType low, mitk::ScalarType up)
{
if ( IsFixed() ) return;
m_DefaultLowerBound = low;
m_DefaultUpperBound = up;
// Check if default window is ok
{
if ( m_DefaultLowerBound > m_DefaultUpperBound )
std::swap(m_DefaultLowerBound,m_DefaultUpperBound);
if (m_DefaultLowerBound == m_DefaultUpperBound )
m_DefaultLowerBound--;
}
EnsureConsistency();
}
void mitk::LevelWindow::SetToMaxWindowSize()
{
SetWindowBounds( m_RangeMin , m_RangeMax );
}
mitk::ScalarType mitk::LevelWindow::GetRangeMin() const
{
return m_RangeMin;
}
mitk::ScalarType mitk::LevelWindow::GetRangeMax() const
{
return m_RangeMax;
}
mitk::ScalarType mitk::LevelWindow::GetRange() const
{
return m_RangeMax - m_RangeMin;
}
mitk::ScalarType mitk::LevelWindow::GetDefaultUpperBound() const
{
return m_DefaultUpperBound;
}
mitk::ScalarType mitk::LevelWindow::GetDefaultLowerBound() const
{
return m_DefaultLowerBound;
}
void mitk::LevelWindow::ResetDefaultRangeMinMax()
{
SetRangeMinMax(m_DefaultLowerBound, m_DefaultUpperBound);
}
/*!
This method initializes a mitk::LevelWindow from an mitk::Image. The algorithm is as follows:
Default to taking the central image slice for quick analysis.
Compute the smallest (minValue), second smallest (min2ndValue), second largest (max2ndValue), and
largest (maxValue) data value by traversing the pixel values only once. In the
same scan it also computes the count of minValue values and maxValue values.
After that a basic histogram with specific information about the
extrems is complete.
If minValue == maxValue, the center slice is uniform and the above scan is repeated for
the complete image, not just one slice
Next, special cases of images with only 1, 2 or 3 distinct data values
have hand assigned level window ranges.
Next the level window is set relative to the inner range IR = lengthOf([min2ndValue, max2ndValue])
For count(minValue) > 20% the smallest values are frequent and should be
distinct from the min2ndValue and larger values (minValue may be std:min, may signify
something special) hence the lower end of the level window is set to min2ndValue - 0.5 * IR
For count(minValue) <= 20% the smallest values are not so important and can
blend with the next ones => min(level window) = min2ndValue
And analog for max(level window):
count(max2ndValue) > 20%: max(level window) = max2ndValue + 0.5 * IR
count(max2ndValue) < 20%: max(level window) = max2ndValue
In both 20%+ cases the level window bounds are clamped to the [minValue, maxValue] range
In consequence the level window maximizes contrast with minimal amount of
computation and does do useful things if the data contains std::min or
std:max values or has only 1 or 2 or 3 data values.
*/
void mitk::LevelWindow::SetAuto(const mitk::Image* image, bool /*tryPicTags*/, bool guessByCentralSlice)
{
if ( IsFixed() )
return;
if ( image == NULL || !image->IsInitialized() ) return;
const mitk::Image* wholeImage = image;
ScalarType minValue = 0.0;
ScalarType maxValue = 0.0;
ScalarType min2ndValue = 0.0;
ScalarType max2ndValue = 0.0;
mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
if ( guessByCentralSlice )
{
sliceSelector->SetInput(image);
sliceSelector->SetSliceNr(image->GetDimension(2)/2);
sliceSelector->SetTimeNr(image->GetDimension(3)/2);
sliceSelector->SetChannelNr(image->GetDimension(4)/2);
sliceSelector->Update();
image = sliceSelector->GetOutput();
if ( image == NULL || !image->IsInitialized() ) return;
minValue = image->GetStatistics()->GetScalarValueMin();
maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute();
min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
if ( minValue == maxValue )
{
// guessByCentralSlice seems to have failed, lets look at all data
image = wholeImage;
minValue = image->GetStatistics()->GetScalarValueMin();
maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute();
min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
}
}
else
{
const_cast<Image*>(image)->Update();
minValue = image->GetStatistics()->GetScalarValueMin(0);
maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute(0);
min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute(0);
max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute(0);
for (unsigned int i = 1; i < image->GetDimension(3); ++i)
{
ScalarType minValueTemp = image->GetStatistics()->GetScalarValueMin(i);
if (minValue > minValueTemp)
minValue = minValueTemp;
ScalarType maxValueTemp = image->GetStatistics()->GetScalarValueMaxNoRecompute(i);
if (maxValue < maxValueTemp)
maxValue = maxValueTemp;
ScalarType min2ndValueTemp = image->GetStatistics()->GetScalarValue2ndMinNoRecompute(i);
if (min2ndValue > min2ndValueTemp)
min2ndValue = min2ndValueTemp;
ScalarType max2ndValueTemp = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute(i);
if (max2ndValue > max2ndValueTemp)
max2ndValue = max2ndValueTemp;
}
}
// Fix for bug# 344 Level Window wird bei Eris Cut bildern nicht richtig gesetzt
- if ( image->GetPixelType().GetPixelTypeId()==itk::ImageIOBase::SCALAR
- && image->GetPixelType().GetTypeId() == typeid(int)
+ if ( image->GetPixelType().GetPixelType()==itk::ImageIOBase::SCALAR
+ && image->GetPixelType().GetComponentType() == itk::ImageIOBase::INT
&& image->GetPixelType().GetBpe() >= 8)
{
// the windows compiler complains about ambiguos 'pow' call, therefore static casting to (double, int)
if (minValue == -( pow( (double) 2.0, static_cast<int>(image->GetPixelType().GetBpe()/2) ) ) )
{
minValue = min2ndValue;
}
}
// End fix
//// uniform image
if ( minValue == maxValue )
{
minValue = maxValue-1;
}
else
{
//Due to bug #8690 level window now is no longer of fixed range by default but the range adapts according to levelwindow interaction
//This is done because the range should be a little bit larger from the beginning so that the scale doesn't start to resize right from the beginning
double additionalRange = 0.15*(maxValue-minValue);
minValue -= additionalRange;
maxValue += additionalRange;
}
SetRangeMinMax(minValue, maxValue);
SetDefaultBoundaries(minValue, maxValue);
/*
if ( tryPicTags ) // level and window will be set by informations provided directly by the mitkIpPicDescriptor
{
if ( SetAutoByPicTags(const_cast<Image*>(image)->GetPic()) )
{
return;
}
}
*/
unsigned int numPixelsInDataset = image->GetDimensions()[0];
for ( unsigned int k=0; k<image->GetDimension(); ++k ) numPixelsInDataset *= image->GetDimensions()[k];
unsigned int minCount = image->GetStatistics()->GetCountOfMinValuedVoxelsNoRecompute();
unsigned int maxCount = image->GetStatistics()->GetCountOfMaxValuedVoxelsNoRecompute();
float minCountFraction = minCount/float(numPixelsInDataset);
float maxCountFraction = maxCount/float(numPixelsInDataset);
//// binary image
if ( min2ndValue == maxValue )
{
// noop; full range is fine
}
//// triple value image, put middle value in center of gray level ramp
else if ( min2ndValue == max2ndValue )
{
ScalarType minDelta = std::min(min2ndValue-minValue, maxValue-min2ndValue);
minValue = min2ndValue - minDelta;
maxValue = min2ndValue + minDelta;
}
// now we can assume more than three distict scalar values
else
{
ScalarType innerRange = max2ndValue - min2ndValue;
if ( minCountFraction > 0.2 ) //// lots of min values -> make different from rest, but not miles away
{
ScalarType halfInnerRangeGapMinValue = min2ndValue - innerRange/2.0;
minValue = std::max(minValue, halfInnerRangeGapMinValue);
}
else //// few min values -> focus on innerRange
{
minValue = min2ndValue;
}
if ( maxCountFraction > 0.2 ) //// lots of max values -> make different from rest
{
ScalarType halfInnerRangeGapMaxValue = max2ndValue + innerRange/2.0;
maxValue = std::min(maxValue, halfInnerRangeGapMaxValue);
}
else //// few max values -> focus on innerRange
{
maxValue = max2ndValue;
}
}
SetWindowBounds(minValue, maxValue);
SetDefaultLevelWindow((maxValue - minValue) / 2 + minValue, maxValue - minValue);
}
void mitk::LevelWindow::SetFixed( bool fixed )
{
m_Fixed = fixed;
}
bool mitk::LevelWindow::GetFixed() const
{
return m_Fixed;
}
bool mitk::LevelWindow::IsFixed() const
{
return m_Fixed;
}
bool mitk::LevelWindow::operator==(const mitk::LevelWindow& levWin) const
{
if ( m_RangeMin == levWin.GetRangeMin() &&
m_RangeMax == levWin.GetRangeMax() &&
m_LowerWindowBound == levWin.GetLowerWindowBound() && m_UpperWindowBound == levWin.GetUpperWindowBound() &&
m_DefaultLowerBound == levWin.GetDefaultLowerBound() && m_DefaultUpperBound == levWin.GetDefaultUpperBound() && m_Fixed == levWin.IsFixed() ) {
return true;
}
else {
return false;
}
}
bool mitk::LevelWindow::operator!=(const mitk::LevelWindow& levWin) const
{
return ! ( (*this) == levWin);
}
mitk::LevelWindow& mitk::LevelWindow::operator=(const mitk::LevelWindow& levWin)
{
if (this == &levWin) {
return *this;
}
else {
m_RangeMin = levWin.GetRangeMin();
m_RangeMax = levWin.GetRangeMax();
m_LowerWindowBound= levWin.GetLowerWindowBound();
m_UpperWindowBound= levWin.GetUpperWindowBound();
m_DefaultLowerBound = levWin.GetDefaultLowerBound();
m_DefaultUpperBound = levWin.GetDefaultUpperBound();
m_Fixed = levWin.GetFixed();
return *this;
}
}
diff --git a/Core/Code/DataManagement/mitkLevelWindowProperty.cpp b/Core/Code/DataManagement/mitkLevelWindowProperty.cpp
index 63d687bc71..c46fecf837 100755
--- a/Core/Code/DataManagement/mitkLevelWindowProperty.cpp
+++ b/Core/Code/DataManagement/mitkLevelWindowProperty.cpp
@@ -1,92 +1,86 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLevelWindowProperty.h"
mitk::LevelWindowProperty::LevelWindowProperty()
{
}
mitk::LevelWindowProperty::LevelWindowProperty(const mitk::LevelWindowProperty& other)
: BaseProperty(other)
, m_LevWin(other.m_LevWin)
{
}
mitk::LevelWindowProperty::LevelWindowProperty(const mitk::LevelWindow &levWin)
{
SetLevelWindow(levWin);
}
mitk::LevelWindowProperty::~LevelWindowProperty()
{
}
bool mitk::LevelWindowProperty::IsEqual(const BaseProperty& property) const
{
return this->m_LevWin == static_cast<const Self&>(property).m_LevWin;
}
bool mitk::LevelWindowProperty::Assign(const BaseProperty& property)
{
this->m_LevWin = static_cast<const Self&>(property).m_LevWin;
return true;
}
const mitk::LevelWindow & mitk::LevelWindowProperty::GetLevelWindow() const
{
return m_LevWin;
}
const mitk::LevelWindow & mitk::LevelWindowProperty::GetValue() const
{
return GetLevelWindow();
}
void mitk::LevelWindowProperty::SetLevelWindow(const mitk::LevelWindow &levWin)
{
if(m_LevWin != levWin)
{
m_LevWin = levWin;
Modified();
}
}
void mitk::LevelWindowProperty::SetValue(const ValueType& levWin)
{
SetLevelWindow(levWin);
}
std::string mitk::LevelWindowProperty::GetValueAsString() const
{
std::stringstream myStr;
myStr << "L:" << m_LevWin.GetLevel() << " W:" << m_LevWin.GetWindow();
return myStr.str();
}
-mitk::LevelWindowProperty::Pointer mitk::LevelWindowProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::LevelWindowProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkLevelWindowProperty.h b/Core/Code/DataManagement/mitkLevelWindowProperty.h
index 00d665e8b5..3ca5dacfb0 100755
--- a/Core/Code/DataManagement/mitkLevelWindowProperty.h
+++ b/Core/Code/DataManagement/mitkLevelWindowProperty.h
@@ -1,89 +1,87 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKLEVELWINDOWPROPERTY_H_HEADER_INCLUDED_C10EEAA8
#define MITKLEVELWINDOWPROPERTY_H_HEADER_INCLUDED_C10EEAA8
#include "mitkBaseProperty.h"
#include "mitkLevelWindow.h"
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
//##Documentation
//## @brief Property for level/window data
//##
//## @ingroup DataManagement
class MITK_CORE_EXPORT LevelWindowProperty : public BaseProperty
{
protected:
LevelWindow m_LevWin;
LevelWindowProperty();
LevelWindowProperty(const LevelWindowProperty& other);
LevelWindowProperty(const mitk::LevelWindow &levWin);
public:
mitkClassMacro(LevelWindowProperty, BaseProperty);
itkNewMacro(LevelWindowProperty);
mitkNewMacro1Param(LevelWindowProperty, const mitk::LevelWindow&);
typedef LevelWindow ValueType;
- Pointer Clone() const;
-
virtual ~LevelWindowProperty();
const mitk::LevelWindow & GetLevelWindow() const;
const mitk::LevelWindow & GetValue() const;
void SetLevelWindow(const LevelWindow &levWin);
void SetValue(const ValueType& levWin);
virtual std::string GetValueAsString() const;
using BaseProperty::operator=;
private:
// purposely not implemented
LevelWindowProperty& operator=(const LevelWindowProperty&);
itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty& property) const;
virtual bool Assign(const BaseProperty& property);
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif /* MITKLEVELWINDOWPROPERTY_H_HEADER_INCLUDED_C10EEAA8 */
diff --git a/Core/Code/DataManagement/mitkLine.h b/Core/Code/DataManagement/mitkLine.h
index 75e38fafb3..1a55b657b9 100644
--- a/Core/Code/DataManagement/mitkLine.h
+++ b/Core/Code/DataManagement/mitkLine.h
@@ -1,428 +1,428 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKLINE_H_HEADER_INCLUDED_C19C01E2
#define MITKLINE_H_HEADER_INCLUDED_C19C01E2
#include "mitkVector.h"
#include <vnl/vnl_vector.h>
#include <vnl/vnl_cross.h>
#include <itkTransform.h>
#include <itkMatrix.h>
namespace mitk {
//##Documentation
//## @brief Descibes a line
//## @ingroup Geometry
template <class TCoordRep, unsigned int NPointDimension=3>
class Line
{
public:
Line()
{
m_Point.Fill(0);
m_Direction.Fill(0);
};
//##Documentation
//## @brief Define line by point and direction
//##
//## Length of direction defines the the length of the line
Line( const itk::Point<TCoordRep,NPointDimension>& point, const itk::Vector<TCoordRep,NPointDimension>& direction )
{
this->m_Point = point;
this->m_Direction = direction;
}
//##Documentation
//## @brief Get start point of the line
const itk::Point<TCoordRep,NPointDimension>& GetPoint() const
{
return m_Point;
}
//##Documentation
//## @brief Get start point of the line
itk::Point<TCoordRep,NPointDimension>& GetPoint()
{
return m_Point;
}
//##Documentation
//## @brief Get point on the line with parameter @a t
//##
//## @return m_Point+t*m_Direction
const itk::Point<TCoordRep,NPointDimension> GetPoint(TCoordRep t) const
{
return m_Point+m_Direction*t;
}
//##Documentation
//## @brief Set/change start point of the line
void SetPoint( const itk::Point<TCoordRep,NPointDimension>& point1 )
{
itk::Vector<TCoordRep,NPointDimension> point2;
point2 = m_Point + m_Direction;
m_Point = point1;
m_Direction = point2 - point1;
}
//##Documentation
//## @brief Get the direction vector of the line
const itk::Vector<TCoordRep,NPointDimension>& GetDirection() const
{
return m_Direction;
}
//##Documentation
//## @brief Get the direction vector of the line
itk::Vector<TCoordRep,NPointDimension>& GetDirection()
{
return m_Direction;
}
//##Documentation
//## @brief Set the direction vector of the line
void SetDirection( const itk::Vector<TCoordRep,NPointDimension>& direction )
{
m_Direction = direction;
}
//##Documentation
//## @brief Define line by point and direction
//##
//## Length of direction defines the the length of the line
void Set( const itk::Point<TCoordRep,NPointDimension>& point, const itk::Vector<TCoordRep,NPointDimension>& direction ) {
this->m_Point = point;
this->m_Direction = direction;
}
//##Documentation
//## @brief Define line by two points
void SetPoints( const itk::Point<TCoordRep,NPointDimension>& point1, const itk::Point<TCoordRep,NPointDimension>& point2 ) {
this->m_Point = point1;
//this->m_Direction.sub( point2, point1 );
m_Direction = point2 - point1;
}
//##Documentation
//## @brief Set/change start point of the line
void SetPoint1( const itk::Point<TCoordRep,NPointDimension>& point1 ) {
itk::Vector<TCoordRep,NPointDimension> point2;
point2 = m_Point + m_Direction;
m_Point = point1;
m_Direction = point2 - point1;
}
//##Documentation
//## @brief Get start point of the line
const itk::Point<TCoordRep,NPointDimension>& GetPoint1() const
{
return m_Point;
}
//##Documentation
//## @brief Set/change end point of the line
void SetPoint2( const itk::Point<TCoordRep,NPointDimension>& point2 )
{
m_Direction = point2 - m_Point;
}
//##Documentation
//## @brief Get end point of the line
itk::Point<TCoordRep,NPointDimension> GetPoint2() const
{
itk::Point<TCoordRep,NPointDimension> point2;
point2 = m_Point+m_Direction;
return point2;
}
//##Documentation
//## @brief Transform the line with a Transform
void Transform(itk::Transform<TCoordRep, NPointDimension, NPointDimension>& transform)
{
m_Direction = transform.TransformVector(m_Direction);
m_Point = transform.TransformPoint(m_Point);
}
//##Documentation
//## @brief Transform the line with a matrix
//##
//## Only the direction will be changed, not the start point.
void Transform( const itk::Matrix<TCoordRep, NPointDimension, NPointDimension>& matrix )
{
m_Direction = matrix*m_Direction;
}
//##Documentation
//## @brief Distance between two lines
double Distance( const Line<TCoordRep,NPointDimension>& line ) const;
//##Documentation
//## @brief Distance of a point from the line
double Distance( const itk::Point<TCoordRep,NPointDimension>& point ) const
{
itk::Vector<TCoordRep,NPointDimension> diff;
diff = Project(point)-point;
return diff.GetNorm();
}
//##Documentation
//## @brief Project a point on the line
itk::Point<TCoordRep,NPointDimension> Project( const itk::Point<TCoordRep,NPointDimension>& point ) const
{
if(m_Direction.GetNorm()==0)
return this->m_Point;
itk::Vector<TCoordRep,NPointDimension> diff;
diff = point-this->m_Point;
itk::Vector<TCoordRep,NPointDimension> normalizedDirection = m_Direction;
normalizedDirection.Normalize();
- normalizedDirection *= dot_product(diff.Get_vnl_vector(), normalizedDirection.Get_vnl_vector());
+ normalizedDirection *= dot_product(diff.GetVnlVector(), normalizedDirection.GetVnlVector());
return this->m_Point + normalizedDirection;
}
//##Documentation
//## @brief Test if a point is part of the line
//##
//## Length of the direction vector defines the length of the line
bool IsPartOfStraightLine( const itk::Point<TCoordRep,NPointDimension>& point ) const
{
if( Distance( point ) > eps )
return false;
itk::Vector<TCoordRep,NPointDimension> diff;
diff = point - this->m_Point;
if( diff*m_Direction < 0 )
return false;
if( diff.GetSquaredNorm() <= m_Direction.GetSquaredNorm() )
return true;
return false;
}
//##Documentation
//## @brief Test if a point is part of the line (line having infinite length)
bool IsPartOfLine( const itk::Point<TCoordRep,NPointDimension>& point ) const {
if ( Distance( point ) < eps )
return true;
return false;
}
//##Documentation
//## @brief Test if a lines is parallel to this line
bool IsParallel( const Line<TCoordRep,NPointDimension>& line) const
{
vnl_vector<TCoordRep> normal;
- normal = vnl_cross_3d( m_Direction.Get_vnl_vector(), line.GetDirection().Get_vnl_vector() );
+ normal = vnl_cross_3d( m_Direction.GetVnlVector(), line.GetDirection().GetVnlVector() );
if ( normal.squared_magnitude() < eps )
return true;
return false;
}
//##Documentation
//## @brief Test if a line is part of the line (line having infinite length)
bool IsPartOfLine( const Line<TCoordRep,NPointDimension>& line ) const
{
return ( Distance( line.GetPoint() ) < 0 ) && ( IsParallel( line ) );
}
//##Documentation
//## @brief Test if the two lines are identical
//##
//## Start point and direction and length of direction vector must be
//## equal for identical lines.
bool operator==( const Line<TCoordRep,NPointDimension>& line ) const
{
itk::Vector<TCoordRep,NPointDimension> diff;
diff = GetPoint1()-line.GetPoint1();
if(diff.GetSquaredNorm() > eps)
return false;
diff = GetPoint2()-line.GetPoint2();
if(diff.GetSquaredNorm() > eps)
return false;
return true;
}
//##Documentation
//## @brief Set the line by another line
inline const Line<TCoordRep,NPointDimension>& operator=( const Line<TCoordRep,NPointDimension>& line )
{
m_Point = line.GetPoint();
m_Direction = line.GetDirection();
return *this;
}
//##Documentation
//## @brief Test if two lines are not identical
//##
//## \sa operator==
bool operator!=( const Line<TCoordRep,NPointDimension>& line ) const
{
return !((*this)==line);
}
//##Documentation
//## @brief Calculates the intersection points of a straight line in 2D
//## with a rectangle
//##
//## @param x1,y1,x2,y2 rectangle
//## @param p,d straight line: p point on it, d direction of line
//## @param s1 first intersection point (valid only if s_num>0)
//## @param s2 second intersection point (valid only if s_num==2)
//## @return number of intersection points (0<=s_num<=2)
static int RectangleLineIntersection(
TCoordRep x1, TCoordRep y1,
TCoordRep x2, TCoordRep y2,
itk::Point< TCoordRep, 2 > p, itk::Vector< TCoordRep, 2 > d,
itk::Point< TCoordRep, 2 > &s1, itk::Point< TCoordRep, 2 > &s2 )
{
int s_num;
TCoordRep t;
s_num=0;
/*test if intersecting with the horizontal axis*/
if(fabs(d[0])>eps)
{
t=(x1-p[0])/d[0];
itk::Point<TCoordRep,2> l=p+d*t;
if((l[1]>=y1) && (l[1]<y2))
{ // yes, intersection point within the bounds of the border-line
if(s_num) s2=l; else s1=l; ++s_num;
}
}
if(fabs(d[0])>eps)
{
t=(x2-p[0])/d[0];
itk::Point<TCoordRep,2> l=p+d*t;
if((l[1]>=y1) && (l[1]<y2))
{ // yes, intersection point within the bounds of the border-line
if(s_num) s2=l; else s1=l; ++s_num;
}
}
/*test if intersecting with the vertical axis*/
if(fabs(d[1])>eps)
{
t=(y1-p[1])/d[1];
itk::Point<TCoordRep,2> l=p+d*t;
if((l[0]>=x1) && (l[0]<x2))
{ // yes, intersection point within the bounds of the border-line
if(s_num) s2=l; else s1=l; ++s_num;
}
}
if(fabs(d[1])>eps)
{
t=(y2-p[1])/d[1];
itk::Point<TCoordRep,2> l=p+d*t;
if((l[0]>=x1) && (l[0]<x2))
{ // yes, intersection point within the bounds of the border-line
if(s_num) s2=l; else s1=l; ++s_num;
}
}
return s_num;
}
/**
* \brief Calculates the intersection points of a straight line in 3D with
* a box.
*
* \param x1,y1,z1 first corner of the box
* \param x2,y2,z2 second corner of the box
* \param p,d straight line: p point on it, d direction of line
* \param s1 first intersection point (valid only if s_num>0)
* \param s2 second intersection point (valid only if s_num==2)
* \return number of intersection points (0<=s_num<=2)
*/
static int BoxLineIntersection(
TCoordRep x1, TCoordRep y1, TCoordRep z1,
TCoordRep x2, TCoordRep y2, TCoordRep z2,
itk::Point< TCoordRep, 3 > p, itk::Vector< TCoordRep, 3 > d,
itk::Point< TCoordRep, 3 > &s1, itk::Point< TCoordRep, 3 > &s2 )
{
int num = 0;
ScalarType box[6];
box[0] = x1; box[1] = x2;
box[2] = y1; box[3] = y2;
box[4] = z1; box[5] = z2;
itk::Point< TCoordRep, 3 > point;
int i, j;
for ( i = 0; i < 6; ++i )
{
j = i / 2;
if ( fabs( d[j] ) > eps )
{
ScalarType lambda = (box[i] - p[j]) / d[j];
point = p + d * lambda;
int k = (j + 1) % 3;
int l = (j + 2) % 3;
if ( (point[k] >= box[k*2]) && (point[k] <= box[k*2+1])
&& (point[l] >= box[l*2]) && (point[l] <= box[l*2+1]) )
{
if ( num == 0 )
{
s1 = point;
}
else
{
s2 = point;
}
++num;
}
}
}
return num;
}
protected:
itk::Point<TCoordRep,NPointDimension> m_Point;
itk::Vector<TCoordRep,NPointDimension> m_Direction;
};
typedef Line<ScalarType, 3> Line3D;
} // namespace mitk
#endif /* MITKLINE_H_HEADER_INCLUDED_C19C01E2 */
diff --git a/Core/Code/DataManagement/mitkLookupTable.cpp b/Core/Code/DataManagement/mitkLookupTable.cpp
index 3e08d0f8ec..d0de567536 100644
--- a/Core/Code/DataManagement/mitkLookupTable.cpp
+++ b/Core/Code/DataManagement/mitkLookupTable.cpp
@@ -1,315 +1,309 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLookupTable.h"
#include <itkProcessObject.h>
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
mitk::LookupTable::LookupTable()
{
m_LookupTable = vtkLookupTable::New();
this->SetRequestedRegionToLargestPossibleRegion();
}
mitk::LookupTable::LookupTable(const LookupTable& other)
: itk::DataObject()
, m_LookupTable(vtkLookupTable::New())
{
m_LookupTable->DeepCopy(other.m_LookupTable);
}
mitk::LookupTable::~LookupTable()
{
if ( m_LookupTable )
{
m_LookupTable->Delete();
m_LookupTable = NULL;
}
}
void mitk::LookupTable::SetVtkLookupTable( vtkLookupTable* lut )
{
if(m_LookupTable == lut)
{
return;
}
if(m_LookupTable)
{
m_LookupTable->UnRegister(NULL);
m_LookupTable = NULL;
}
if(lut)
{
lut->Register(NULL);
}
m_LookupTable = lut;
this->Modified();
}
void mitk::LookupTable::ChangeOpacityForAll( float opacity )
{
int noValues = m_LookupTable->GetNumberOfTableValues ();
vtkFloatingPointType rgba[ 4 ];
for ( int i = 0;i < noValues;i++ )
{
m_LookupTable->GetTableValue ( i, rgba );
rgba[ 3 ] = opacity;
m_LookupTable->SetTableValue ( i, rgba );
}
this->Modified(); // need to call modiefied, since LookupTableProperty seems to be unchanged so no widget-updat is executed
}
void mitk::LookupTable::ChangeOpacity(int index, float opacity )
{
int noValues = m_LookupTable->GetNumberOfTableValues ();
if (index>noValues)
{
MITK_INFO << "could not change opacity. index exceed size of lut ... " << std::endl;
return;
}
vtkFloatingPointType rgba[ 4 ];
m_LookupTable->GetTableValue ( index, rgba );
rgba[ 3 ] = opacity;
m_LookupTable->SetTableValue ( index, rgba );
this->Modified(); // need to call modiefied, since LookupTableProperty seems to be unchanged so no widget-updat is executed
}
vtkLookupTable* mitk::LookupTable::GetVtkLookupTable() const
{
return m_LookupTable;
};
mitk::LookupTable::RawLookupTableType * mitk::LookupTable::GetRawLookupTable() const
{
if (m_LookupTable==NULL) MITK_INFO << "uuups..." << std::endl;
return m_LookupTable->GetPointer( 0 );
};
/*!
* \brief equality operator inplementation
*/
bool mitk::LookupTable::operator==( const mitk::LookupTable& other ) const
{
if ( m_LookupTable == other.GetVtkLookupTable())
return true;
vtkLookupTable* olut = other.GetVtkLookupTable();
if (olut == NULL)
return false;
bool equal = (m_LookupTable->GetNumberOfColors() == olut->GetNumberOfColors())
&& (m_LookupTable->GetTableRange()[0] == olut->GetTableRange()[0])
&& (m_LookupTable->GetTableRange()[1] == olut->GetTableRange()[1])
&& (m_LookupTable->GetHueRange()[0] == olut->GetHueRange()[0])
&& (m_LookupTable->GetHueRange()[1] == olut->GetHueRange()[1])
&& (m_LookupTable->GetSaturationRange()[0] == olut->GetSaturationRange()[0])
&& (m_LookupTable->GetSaturationRange()[1] == olut->GetSaturationRange()[1])
&& (m_LookupTable->GetValueRange()[0] == olut->GetValueRange()[0])
&& (m_LookupTable->GetValueRange()[1] == olut->GetValueRange()[1])
&& (m_LookupTable->GetAlphaRange()[0] == olut->GetAlphaRange()[0])
&& (m_LookupTable->GetAlphaRange()[1] == olut->GetAlphaRange()[1])
&& (m_LookupTable->GetRamp() == olut->GetRamp())
&& (m_LookupTable->GetScale() == olut->GetScale())
&& (m_LookupTable->GetAlpha() == olut->GetAlpha())
&& (m_LookupTable->GetTable()->GetNumberOfTuples() == olut->GetTable()->GetNumberOfTuples());
if (equal == false)
return false;
//for (vtkIdType i=0; i < m_LookupTable->GetTable()->GetNumberOfTuples(); i++)
//{
// if (m_LookupTable->GetTable()->GetTuple(i) != olut->GetTable()->GetTuple(i))
// return false;
//}
for (vtkIdType i=0; i < m_LookupTable->GetNumberOfTableValues(); i++)
{
//double v0_1 = m_LookupTable->GetTableValue(i)[0]; double v0_2 = olut->GetTableValue(i)[0];
//double v1_1 = m_LookupTable->GetTableValue(i)[1]; double v1_2 = olut->GetTableValue(i)[1];
//double v2_1 = m_LookupTable->GetTableValue(i)[2]; double v2_2 = olut->GetTableValue(i)[2];
//double v3_1 = m_LookupTable->GetTableValue(i)[3]; double v3_2 = olut->GetTableValue(i)[3];
bool tvequal = (m_LookupTable->GetTableValue(i)[0] == olut->GetTableValue(i)[0])
&& (m_LookupTable->GetTableValue(i)[1] == olut->GetTableValue(i)[1])
&& (m_LookupTable->GetTableValue(i)[2] == olut->GetTableValue(i)[2])
&& (m_LookupTable->GetTableValue(i)[3] == olut->GetTableValue(i)[3]);
if (tvequal == false)
return false;
}
return true;
}
/*!
* \brief un-equality operator implementation
*/
bool mitk::LookupTable::operator!=( const mitk::LookupTable& other ) const
{
return !(*this == other);
}
/*!
* \brief assignment operator implementation
*/
mitk::LookupTable& mitk::LookupTable::operator=( const mitk::LookupTable& LookupTable )
{
if ( this == &LookupTable )
{
return * this;
}
else
{
m_LookupTable = LookupTable.GetVtkLookupTable();
return *this;
}
}
void mitk::LookupTable::UpdateOutputInformation( )
{
if ( this->GetSource( ) )
{
this->GetSource( ) ->UpdateOutputInformation( );
}
}
void mitk::LookupTable::SetRequestedRegionToLargestPossibleRegion( )
{}
bool mitk::LookupTable::RequestedRegionIsOutsideOfTheBufferedRegion( )
{
return false;
}
bool mitk::LookupTable::VerifyRequestedRegion( )
{
//normally we should check if the requested region lies within the
//largest possible region. Since for lookup-tables we assume, that the
//requested region is always the largest possible region, we can always
//return true!
return true;
}
-void mitk::LookupTable::SetRequestedRegion( itk::DataObject *)
+void mitk::LookupTable::SetRequestedRegion(const itk::DataObject *)
{
//not implemented, since we always want to have the RequestedRegion
//to be set to LargestPossibleRegion
}
void mitk::LookupTable::CreateColorTransferFunction(vtkColorTransferFunction*& colorFunction)
{
if(colorFunction==NULL)
colorFunction = vtkColorTransferFunction::New();
mitk::LookupTable::RawLookupTableType *rgba = GetRawLookupTable();
int i, num_of_values=m_LookupTable->GetNumberOfTableValues();
vtkFloatingPointType *cols;
vtkFloatingPointType *colsHead;
colsHead=cols=(vtkFloatingPointType *)malloc(sizeof(vtkFloatingPointType)*num_of_values*3);
for(i=0;i<num_of_values;++i)
{
*cols=*rgba/255.0; ++cols; ++rgba;
*cols=*rgba/255.0; ++cols; ++rgba;
*cols=*rgba/255.0; ++cols; ++rgba;
++rgba;
}
colorFunction->BuildFunctionFromTable(m_LookupTable->GetTableRange()[0], m_LookupTable->GetTableRange()[1], num_of_values-1, colsHead);
free(colsHead);
}
void mitk::LookupTable::CreateOpacityTransferFunction(vtkPiecewiseFunction*& opacityFunction)
{
if(opacityFunction==NULL)
opacityFunction = vtkPiecewiseFunction::New();
mitk::LookupTable::RawLookupTableType *rgba = GetRawLookupTable();
int i, num_of_values=m_LookupTable->GetNumberOfTableValues();
vtkFloatingPointType *alphas;
vtkFloatingPointType *alphasHead;
alphasHead=alphas=(vtkFloatingPointType*)malloc(sizeof(vtkFloatingPointType)*num_of_values);
rgba+=3;
for(i=0;i<num_of_values;++i)
{
*alphas=*rgba * 1024.0; ++alphas; rgba+=4;
}
opacityFunction->BuildFunctionFromTable(m_LookupTable->GetTableRange()[0], m_LookupTable->GetTableRange()[1], num_of_values-1, alphasHead);
free(alphasHead);
}
void mitk::LookupTable::CreateGradientTransferFunction(vtkPiecewiseFunction*& gradientFunction)
{
if(gradientFunction==NULL)
gradientFunction = vtkPiecewiseFunction::New();
mitk::LookupTable::RawLookupTableType *rgba = GetRawLookupTable();
int i, num_of_values=m_LookupTable->GetNumberOfTableValues();
vtkFloatingPointType *alphas;
vtkFloatingPointType *alphasHead;
alphasHead=alphas=(vtkFloatingPointType*)malloc(sizeof(vtkFloatingPointType)*num_of_values);
rgba+=3;
for(i=0;i<num_of_values;++i)
{
*alphas=*rgba * 1024.0; ++alphas; rgba+=4;
}
gradientFunction->BuildFunctionFromTable(m_LookupTable->GetTableRange()[0], m_LookupTable->GetTableRange()[1], num_of_values-1, alphasHead);
free(alphasHead);
}
void mitk::LookupTable::PrintSelf(std::ostream &os, itk::Indent indent) const
{
os << indent;
m_LookupTable->PrintHeader(os, vtkIndent());
}
-mitk::LookupTable::Pointer mitk::LookupTable::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::LookupTable::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkLookupTable.h b/Core/Code/DataManagement/mitkLookupTable.h
index d489310eb6..022a5ef5f9 100644
--- a/Core/Code/DataManagement/mitkLookupTable.h
+++ b/Core/Code/DataManagement/mitkLookupTable.h
@@ -1,139 +1,137 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKLookupTable_H_HEADER_INCLUDED_C1EBD53D
#define MITKLookupTable_H_HEADER_INCLUDED_C1EBD53D
#include <MitkExports.h>
#include <mitkCommon.h>
#include "vtkLookupTable.h"
#include <itkDataObject.h>
#include <itkObjectFactory.h>
class vtkColorTransferFunction;
class vtkPiecewiseFunction;
namespace mitk
{
//##
//##Documentation
//## @brief LookupTable containing a vtkLookupTable
//## @ingroup Data
//##
class MITK_CORE_EXPORT LookupTable : public itk::DataObject
{
public:
/**
*@brief Some convenient typedefs.
*/
typedef unsigned char RawLookupTableType;
mitkClassMacro( LookupTable, itk::DataObject );
itkNewMacro( Self );
- Pointer Clone() const;
-
/**
* @returns the associated vtkLookupTable
*/
virtual vtkLookupTable* GetVtkLookupTable() const;
virtual RawLookupTableType * GetRawLookupTable() const;
virtual void SetVtkLookupTable( vtkLookupTable* lut );
virtual void ChangeOpacityForAll( float opacity );
virtual void ChangeOpacity(int index, float opacity );
/*!
* \brief equality operator implementation
*/
virtual bool operator==( const mitk::LookupTable& LookupTable ) const;
/*!
* \brief non equality operator implementation
*/
virtual bool operator!=( const LookupTable& LookupTable ) const;
/*!
* \brief implementation necessary because operator made
* private in itk::Object
*/
virtual LookupTable& operator=( const LookupTable& LookupTable );
/**
* Updates the output information of the current object by calling
* updateOutputInformation of the data objects source object.
*/
virtual void UpdateOutputInformation( );
/**
* Sets the requested Region to the largest possible region.
* This method is not implemented, since this is the default
* behaviour of the itk pipeline and we do not support the
* requested-region mechanism for lookup-tables
*/
virtual void SetRequestedRegionToLargestPossibleRegion( );
/**
* Checks, if the requested region lies outside of the buffered region by
* calling verifyRequestedRegion().
*/
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion( );
/**
* Checks if the requested region is completely contained in
* the buffered region. Since we always want to process the lookup
* table as a whole, this method always returns true
*/
virtual bool VerifyRequestedRegion( );
/**
* This method has no effect for lookup tables, since we do
* not support the region-mechanism
*/
- virtual void SetRequestedRegion( itk::DataObject *data );
+ virtual void SetRequestedRegion(const itk::DataObject *data );
LookupTable();
virtual ~LookupTable();
void CreateColorTransferFunction(vtkColorTransferFunction*& colorFunction);
void CreateOpacityTransferFunction(vtkPiecewiseFunction*& opacityFunction);
void CreateGradientTransferFunction(vtkPiecewiseFunction*& gradientFunction);
protected:
void PrintSelf(std::ostream &os, itk::Indent indent) const;
LookupTable(const LookupTable& other);
vtkLookupTable* m_LookupTable;
private:
virtual itk::LightObject::Pointer InternalClone() const;
};
} // namespace mitk
#endif /* LookupTable_H_HEADER_INCLUDED_C1EBD53D */
diff --git a/Core/Code/DataManagement/mitkMemoryUtilities.h b/Core/Code/DataManagement/mitkMemoryUtilities.h
index 2b42415e8b..d366fa5bff 100644
--- a/Core/Code/DataManagement/mitkMemoryUtilities.h
+++ b/Core/Code/DataManagement/mitkMemoryUtilities.h
@@ -1,98 +1,97 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_MEMORY_UTILITIES_H_
#define _MITK_MEMORY_UTILITIES_H_
#include <itkMacro.h>
-#include <itkExceptionObject.h>
#include <MitkExports.h>
namespace mitk
{
class MITK_CORE_EXPORT MemoryUtilities
{
public:
/**
* Returns the memory usage of the current process in bytes.
* On linux, this refers to the virtual memory allocated by
* the process (the VIRT column in top).
* On windows, this refery to the size in bytes of the working
* set pages (the "Speicherauslastung" column in the task manager).
*/
static size_t GetProcessMemoryUsage();
/**
* Returns the total size of phyiscal memory in bytes
*/
static size_t GetTotalSizeOfPhysicalRam();
/**
* Allocates an array of a given number of elements. Each element
* has a size of sizeof(ElementType). The function returns NULL, if the array
* could not be allocated.
* @param numberOfElements the number of elements of the array
* @param noThrow if set to false, an exception is thrown if memory allocation
* fails. If set to true, a itk::MemoryAllocationError is thrown
* @returns a pointer to the allocated array. If noThrow == true, NULL is returned
* if memory allocation failed.
*/
template <typename ElementType>
static ElementType* AllocateElements(size_t numberOfElements, bool noThrow = false )
{
// Encapsulate all image memory allocation here to throw an
// exception when memory allocation fails even when the compiler
// does not do this by default.
ElementType* data = NULL;
try
{
data = new ElementType[numberOfElements];
}
catch(...)
{
data = NULL;
}
if( ( data == NULL ) && ( noThrow == false ) )
{
throw itk::MemoryAllocationError(__FILE__, __LINE__, "Failed to allocate memory.", ITK_LOCATION);
}
return data;
}
/**
* Deletes an array of elements previously allocated by AllocateElements.
* @param elements the array to delete. Not that NULL is an accepted value.
*/
template <typename ElementType>
static void DeleteElements(ElementType* elements)
{
if ( elements != NULL )
{
delete[] elements;
}
}
protected:
#ifndef _MSC_VER
static int ReadStatmFromProcFS( int* size, int* res, int* shared, int* text, int* sharedLibs, int* stack, int* dirtyPages );
#endif
};
} //end of namespace mitk
#endif
diff --git a/Core/Code/DataManagement/mitkModalityProperty.cpp b/Core/Code/DataManagement/mitkModalityProperty.cpp
index b5047d0027..32bfd3185a 100644
--- a/Core/Code/DataManagement/mitkModalityProperty.cpp
+++ b/Core/Code/DataManagement/mitkModalityProperty.cpp
@@ -1,80 +1,74 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkModalityProperty.h"
mitk::ModalityProperty::ModalityProperty()
{
AddEnumerationTypes();
}
mitk::ModalityProperty::ModalityProperty( const IdType& value )
{
AddEnumerationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value ) ;
}
else
{
SetValue( 0 );
}
}
mitk::ModalityProperty::ModalityProperty( const std::string& value )
{
AddEnumerationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetValue( "undefined" );
}
}
mitk::ModalityProperty::~ModalityProperty()
{
}
void mitk::ModalityProperty::AddEnumerationTypes()
{
IdType newId = static_cast<IdType>(EnumerationProperty::Size());
AddEnum( "undefined", newId++ );
AddEnum( "CR", newId++ ); // computer radiography
AddEnum( "CT", newId++ ); // computed tomography
AddEnum( "MR", newId++ ); // magnetic resonance
AddEnum( "NM", newId++ ); // nuclear medicine
AddEnum( "US", newId++ ); // ultrasound
AddEnum( "Color Doppler", newId++ ); // ultrasound
AddEnum( "Power Doppler", newId++ ); // ultrasound
}
-mitk::ModalityProperty::Pointer mitk::ModalityProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::ModalityProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkModalityProperty.h b/Core/Code/DataManagement/mitkModalityProperty.h
index df2d5f01b4..f2f624d153 100644
--- a/Core/Code/DataManagement/mitkModalityProperty.h
+++ b/Core/Code/DataManagement/mitkModalityProperty.h
@@ -1,74 +1,72 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkModalityProperty_h_Included
#define mitkModalityProperty_h_Included
#include <MitkExports.h>
#include "mitkEnumerationProperty.h"
#include <itkObjectFactory.h>
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
\brief Enumerates all known modalities
\ingroup DataManagement
*/
class MITK_CORE_EXPORT ModalityProperty : public EnumerationProperty
{
public:
mitkClassMacro(ModalityProperty, EnumerationProperty);
itkNewMacro(ModalityProperty);
mitkNewMacro1Param(ModalityProperty, const IdType&);
mitkNewMacro1Param(ModalityProperty, const std::string&);
- Pointer Clone() const;
-
using BaseProperty::operator=;
protected:
ModalityProperty();
ModalityProperty( const IdType& value );
ModalityProperty( const std::string& value );
virtual ~ModalityProperty();
virtual void AddEnumerationTypes();
private:
// purposely not implemented
const ModalityProperty& operator=(const ModalityProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace
#endif
diff --git a/Core/Code/DataManagement/mitkPlaneGeometry.cpp b/Core/Code/DataManagement/mitkPlaneGeometry.cpp
index 03375c052a..d6d98c3f8b 100644
--- a/Core/Code/DataManagement/mitkPlaneGeometry.cpp
+++ b/Core/Code/DataManagement/mitkPlaneGeometry.cpp
@@ -1,777 +1,777 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlaneGeometry.h"
#include "mitkPlaneOperation.h"
#include "mitkInteractionConst.h"
#include "mitkLine.h"
#include <vtkTransform.h>
#include <vnl/vnl_cross.h>
namespace mitk
{
mitk::PlaneGeometry::PlaneGeometry()
{
Initialize();
}
mitk::PlaneGeometry::~PlaneGeometry()
{
}
void
PlaneGeometry::Initialize()
{
Superclass::Initialize();
}
void
PlaneGeometry::EnsurePerpendicularNormal(mitk::AffineTransform3D *transform)
{
//ensure row(2) of transform to be perpendicular to plane, keep length.
VnlVector normal = vnl_cross_3d(
transform->GetMatrix().GetVnlMatrix().get_column(0),
transform->GetMatrix().GetVnlMatrix().get_column(1) );
normal.normalize();
ScalarType len = transform->GetMatrix()
.GetVnlMatrix().get_column(2).two_norm();
if (len==0) len = 1;
normal*=len;
Matrix3D matrix = transform->GetMatrix();
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
}
void
PlaneGeometry::SetIndexToWorldTransform(mitk::AffineTransform3D *transform)
{
EnsurePerpendicularNormal(transform);
Superclass::SetIndexToWorldTransform(transform);
}
void
PlaneGeometry::SetBounds(const BoundingBox::BoundsArrayType &bounds)
{
//currently the unit rectangle must be starting at the origin [0,0]
assert(bounds[0]==0);
assert(bounds[2]==0);
//the unit rectangle must be two-dimensional
assert(bounds[1]>0);
assert(bounds[3]>0);
Superclass::SetBounds(bounds);
}
void
PlaneGeometry::IndexToWorld( const Point2D &pt_units, Point2D &pt_mm ) const
{
pt_mm[0]=m_ScaleFactorMMPerUnitX*pt_units[0];
pt_mm[1]=m_ScaleFactorMMPerUnitY*pt_units[1];
}
void PlaneGeometry::WorldToIndex( const Point2D &pt_mm, Point2D &pt_units ) const
{
pt_units[0]=pt_mm[0]*(1.0/m_ScaleFactorMMPerUnitX);
pt_units[1]=pt_mm[1]*(1.0/m_ScaleFactorMMPerUnitY);
}
void PlaneGeometry::IndexToWorld( const Point2D & /*atPt2d_units*/,
const Vector2D &vec_units, Vector2D &vec_mm) const
{
MITK_WARN<<"Warning! Call of the deprecated function PlaneGeometry::IndexToWorld(point, vec, vec). Use PlaneGeometry::IndexToWorld(vec, vec) instead!";
this->IndexToWorld(vec_units, vec_mm);
}
void PlaneGeometry::IndexToWorld(const Vector2D &vec_units, Vector2D &vec_mm) const
{
vec_mm[0] = m_ScaleFactorMMPerUnitX * vec_units[0];
vec_mm[1] = m_ScaleFactorMMPerUnitY * vec_units[1];
}
void
PlaneGeometry::WorldToIndex( const Point2D & /*atPt2d_mm*/,
const Vector2D &vec_mm, Vector2D &vec_units) const
{
MITK_WARN<<"Warning! Call of the deprecated function PlaneGeometry::WorldToIndex(point, vec, vec). Use PlaneGeometry::WorldToIndex(vec, vec) instead!";
this->WorldToIndex(vec_mm, vec_units);
}
void
PlaneGeometry::WorldToIndex( const Vector2D &vec_mm, Vector2D &vec_units) const
{
vec_units[0] = vec_mm[0] * ( 1.0 / m_ScaleFactorMMPerUnitX );
vec_units[1] = vec_mm[1] * ( 1.0 / m_ScaleFactorMMPerUnitY );
}
void
PlaneGeometry::InitializeStandardPlane( mitk::ScalarType width,
ScalarType height, const Vector3D & spacing,
PlaneGeometry::PlaneOrientation planeorientation,
ScalarType zPosition, bool frontside, bool rotated )
{
AffineTransform3D::Pointer transform;
transform = AffineTransform3D::New();
AffineTransform3D::MatrixType matrix;
AffineTransform3D::MatrixType::InternalMatrixType &vnlmatrix =
matrix.GetVnlMatrix();
vnlmatrix.set_identity();
vnlmatrix(0,0) = spacing[0];
vnlmatrix(1,1) = spacing[1];
vnlmatrix(2,2) = spacing[2];
transform->SetIdentity();
transform->SetMatrix(matrix);
InitializeStandardPlane(width, height, transform.GetPointer(),
planeorientation, zPosition, frontside, rotated);
}
void
PlaneGeometry::InitializeStandardPlane( mitk::ScalarType width,
ScalarType height, const AffineTransform3D* transform,
PlaneGeometry::PlaneOrientation planeorientation, ScalarType zPosition,
bool frontside, bool rotated )
{
Superclass::Initialize();
//construct standard view
Point3D origin;
VnlVector rightDV(3), bottomDV(3);
origin.Fill(0);
int normalDirection;
switch(planeorientation)
{
case Axial:
if(frontside)
{
if(rotated==false)
{
FillVector3D(origin, 0, 0, zPosition);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 1, 0);
}
else
{
FillVector3D(origin, width, height, zPosition);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, -1, 0);
}
}
else
{
if(rotated==false)
{
FillVector3D(origin, width, 0, zPosition);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 1, 0);
}
else
{
FillVector3D(origin, 0, height, zPosition);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, -1, 0);
}
}
normalDirection = 2;
break;
case Frontal:
if(frontside)
{
if(rotated==false)
{
FillVector3D(origin, 0, zPosition, 0);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else
{
FillVector3D(origin, width, zPosition, height);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
else
{
if(rotated==false)
{
FillVector3D(origin, width, zPosition, 0);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else
{
FillVector3D(origin, 0, zPosition, height);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
normalDirection = 1;
break;
case Sagittal:
if(frontside)
{
if(rotated==false)
{
FillVector3D(origin, zPosition, 0, 0);
FillVector3D(rightDV, 0, 1, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else
{
FillVector3D(origin, zPosition, width, height);
FillVector3D(rightDV, 0, -1, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
else
{
if(rotated==false)
{
FillVector3D(origin, zPosition, width, 0);
FillVector3D(rightDV, 0, -1, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else
{
FillVector3D(origin, zPosition, 0, height);
FillVector3D(rightDV, 0, 1, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
normalDirection = 0;
break;
default:
itkExceptionMacro("unknown PlaneOrientation");
}
if ( transform != NULL )
{
origin = transform->TransformPoint( origin );
rightDV = transform->TransformVector( rightDV );
bottomDV = transform->TransformVector( bottomDV );
}
ScalarType bounds[6]= { 0, width, 0, height, 0, 1 };
this->SetBounds( bounds );
if ( transform == NULL )
{
this->SetMatrixByVectors( rightDV, bottomDV );
}
else
{
this->SetMatrixByVectors(
rightDV, bottomDV,
transform->GetMatrix().GetVnlMatrix()
.get_column(normalDirection).magnitude()
);
}
this->SetOrigin(origin);
}
void
PlaneGeometry::InitializeStandardPlane( const Geometry3D *geometry3D,
PlaneOrientation planeorientation, ScalarType zPosition,
bool frontside, bool rotated )
{
this->SetReferenceGeometry( const_cast< Geometry3D * >( geometry3D ) );
ScalarType width, height;
const BoundingBox::BoundsArrayType& boundsarray =
geometry3D->GetBoundingBox()->GetBounds();
Vector3D originVector;
FillVector3D(originVector, boundsarray[0], boundsarray[2], boundsarray[4]);
if(geometry3D->GetImageGeometry())
{
FillVector3D( originVector,
originVector[0] - 0.5,
originVector[1] - 0.5,
originVector[2] - 0.5 );
}
switch(planeorientation)
{
case Axial:
width = geometry3D->GetExtent(0);
height = geometry3D->GetExtent(1);
break;
case Frontal:
width = geometry3D->GetExtent(0);
height = geometry3D->GetExtent(2);
break;
case Sagittal:
width = geometry3D->GetExtent(1);
height = geometry3D->GetExtent(2);
break;
default:
itkExceptionMacro("unknown PlaneOrientation");
}
InitializeStandardPlane( width, height,
geometry3D->GetIndexToWorldTransform(),
planeorientation, zPosition, frontside, rotated );
ScalarType bounds[6]= { 0, width, 0, height, 0, 1 };
this->SetBounds( bounds );
Point3D origin;
originVector = geometry3D->GetIndexToWorldTransform()
->TransformVector( originVector );
origin = GetOrigin() + originVector;
SetOrigin(origin);
}
void
PlaneGeometry::InitializeStandardPlane( const Geometry3D *geometry3D,
bool top, PlaneOrientation planeorientation, bool frontside, bool rotated )
{
ScalarType zPosition;
switch(planeorientation)
{
case Axial:
zPosition = (top ? 0.5 : geometry3D->GetExtent(2)-1+0.5);
break;
case Frontal:
zPosition = (top ? 0.5 : geometry3D->GetExtent(1)-1+0.5);
break;
case Sagittal:
zPosition = (top ? 0.5 : geometry3D->GetExtent(0)-1+0.5);
break;
default:
itkExceptionMacro("unknown PlaneOrientation");
}
InitializeStandardPlane( geometry3D, planeorientation,
zPosition, frontside, rotated );
}
void
PlaneGeometry::InitializeStandardPlane( const Vector3D &rightVector,
const Vector3D &downVector, const Vector3D *spacing )
{
- InitializeStandardPlane( rightVector.Get_vnl_vector(),
- downVector.Get_vnl_vector(), spacing );
+ InitializeStandardPlane( rightVector.GetVnlVector(),
+ downVector.GetVnlVector(), spacing );
}
void
PlaneGeometry::InitializeStandardPlane( const VnlVector& rightVector,
const VnlVector &downVector, const Vector3D *spacing )
{
ScalarType width = rightVector.magnitude();
ScalarType height = downVector.magnitude();
InitializeStandardPlane( width, height, rightVector, downVector, spacing );
}
void
PlaneGeometry::InitializeStandardPlane( mitk::ScalarType width,
ScalarType height, const Vector3D &rightVector, const Vector3D &downVector,
const Vector3D *spacing )
{
InitializeStandardPlane(
width, height,
- rightVector.Get_vnl_vector(), downVector.Get_vnl_vector(),
+ rightVector.GetVnlVector(), downVector.GetVnlVector(),
spacing );
}
void
PlaneGeometry::InitializeStandardPlane(
mitk::ScalarType width, ScalarType height,
const VnlVector &rightVector, const VnlVector &downVector,
const Vector3D *spacing )
{
assert(width > 0);
assert(height > 0);
VnlVector rightDV = rightVector; rightDV.normalize();
VnlVector downDV = downVector; downDV.normalize();
VnlVector normal = vnl_cross_3d(rightVector, downVector);
normal.normalize();
if(spacing!=NULL)
{
rightDV *= (*spacing)[0];
downDV *= (*spacing)[1];
normal *= (*spacing)[2];
}
AffineTransform3D::Pointer transform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightDV);
matrix.GetVnlMatrix().set_column(1, downDV);
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
transform->SetOffset(m_IndexToWorldTransform->GetOffset());
ScalarType bounds[6] = { 0, width, 0, height, 0, 1 };
this->SetBounds( bounds );
this->SetIndexToWorldTransform( transform );
}
void
PlaneGeometry::InitializePlane( const Point3D &origin,
const Vector3D &normal )
{
VnlVector rightVectorVnl(3), downVectorVnl;
if( Equal( normal[1], 0.0f ) == false )
{
FillVector3D( rightVectorVnl, 1.0f, -normal[0]/normal[1], 0.0f );
rightVectorVnl.normalize();
}
else
{
FillVector3D( rightVectorVnl, 0.0f, 1.0f, 0.0f );
}
- downVectorVnl = vnl_cross_3d( normal.Get_vnl_vector(), rightVectorVnl );
+ downVectorVnl = vnl_cross_3d( normal.GetVnlVector(), rightVectorVnl );
downVectorVnl.normalize();
InitializeStandardPlane( rightVectorVnl, downVectorVnl );
SetOrigin(origin);
}
void
PlaneGeometry::SetMatrixByVectors( const VnlVector &rightVector,
const VnlVector &downVector, ScalarType thickness )
{
VnlVector normal = vnl_cross_3d(rightVector, downVector);
normal.normalize();
normal *= thickness;
AffineTransform3D::Pointer transform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightVector);
matrix.GetVnlMatrix().set_column(1, downVector);
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
transform->SetOffset(m_IndexToWorldTransform->GetOffset());
SetIndexToWorldTransform(transform);
}
Vector3D
PlaneGeometry::GetNormal() const
{
Vector3D frontToBack;
- frontToBack.Set_vnl_vector( m_IndexToWorldTransform
+ frontToBack.SetVnlVector( m_IndexToWorldTransform
->GetMatrix().GetVnlMatrix().get_column(2) );
return frontToBack;
}
VnlVector
PlaneGeometry::GetNormalVnl() const
{
return m_IndexToWorldTransform
->GetMatrix().GetVnlMatrix().get_column(2);
}
ScalarType
PlaneGeometry::DistanceFromPlane( const Point3D &pt3d_mm ) const
{
return fabs(SignedDistance( pt3d_mm ));
}
ScalarType
PlaneGeometry::SignedDistance( const Point3D &pt3d_mm ) const
{
return SignedDistanceFromPlane(pt3d_mm);
}
bool
PlaneGeometry::IsAbove( const Point3D &pt3d_mm ) const
{
return SignedDistanceFromPlane(pt3d_mm) > 0;
}
bool
PlaneGeometry::IntersectionLine(
const PlaneGeometry* plane, Line3D& crossline ) const
{
Vector3D normal = this->GetNormal();
normal.Normalize();
Vector3D planeNormal = plane->GetNormal();
planeNormal.Normalize();
Vector3D direction = itk::CrossProduct( normal, planeNormal );
if ( direction.GetSquaredNorm() < eps )
return false;
crossline.SetDirection( direction );
double N1dN2 = normal * planeNormal;
double determinant = 1.0 - N1dN2 * N1dN2;
Vector3D origin = this->GetOrigin().GetVectorFromOrigin();
Vector3D planeOrigin = plane->GetOrigin().GetVectorFromOrigin();
double d1 = normal * origin;
double d2 = planeNormal * planeOrigin;
double c1 = ( d1 - d2 * N1dN2 ) / determinant;
double c2 = ( d2 - d1 * N1dN2 ) / determinant;
Vector3D p = normal * c1 + planeNormal * c2;
- crossline.GetPoint().Get_vnl_vector() = p.Get_vnl_vector();
+ crossline.GetPoint().GetVnlVector() = p.GetVnlVector();
return true;
}
unsigned int
PlaneGeometry::IntersectWithPlane2D(
const PlaneGeometry* plane, Point2D& lineFrom, Point2D &lineTo ) const
{
Line3D crossline;
if ( this->IntersectionLine( plane, crossline ) == false )
return 0;
Point2D point2;
Vector2D direction2;
this->Map( crossline.GetPoint(), point2 );
this->Map( crossline.GetPoint(), crossline.GetDirection(), direction2 );
return
Line3D::RectangleLineIntersection(
0, 0, GetExtentInMM(0), GetExtentInMM(1),
point2, direction2, lineFrom, lineTo );
}
double PlaneGeometry::Angle( const PlaneGeometry *plane ) const
{
return angle(plane->GetMatrixColumn(2), GetMatrixColumn(2));
}
double PlaneGeometry::Angle( const Line3D &line ) const
{
return vnl_math::pi_over_2
- - angle( line.GetDirection().Get_vnl_vector(), GetMatrixColumn(2) );
+ - angle( line.GetDirection().GetVnlVector(), GetMatrixColumn(2) );
}
bool PlaneGeometry::IntersectionPoint(
const Line3D &line, Point3D &intersectionPoint ) const
{
Vector3D planeNormal = this->GetNormal();
planeNormal.Normalize();
Vector3D lineDirection = line.GetDirection();
lineDirection.Normalize();
double t = planeNormal * lineDirection;
if ( fabs( t ) < eps )
{
return false;
}
Vector3D diff;
diff = this->GetOrigin() - line.GetPoint();
t = ( planeNormal * diff ) / t;
intersectionPoint = line.GetPoint() + lineDirection * t;
return true;
}
bool
PlaneGeometry::IntersectionPointParam( const Line3D &line, double &t ) const
{
Vector3D planeNormal = this->GetNormal();
Vector3D lineDirection = line.GetDirection();
t = planeNormal * lineDirection;
if ( fabs( t ) < eps )
{
return false;
}
Vector3D diff;
diff = this->GetOrigin() - line.GetPoint();
t = ( planeNormal * diff ) / t;
return true;
}
bool
PlaneGeometry::IsParallel( const PlaneGeometry *plane ) const
{
return ( (Angle(plane) < 10.0 * mitk::sqrteps ) || ( Angle(plane) > ( vnl_math::pi - 10.0 * sqrteps ) ) ) ;
}
bool
PlaneGeometry::IsOnPlane( const Point3D &point ) const
{
return Distance(point) < eps;
}
bool
PlaneGeometry::IsOnPlane( const Line3D &line ) const
{
return ( (Distance( line.GetPoint() ) < eps)
&& (Distance( line.GetPoint2() ) < eps) );
}
bool
PlaneGeometry::IsOnPlane( const PlaneGeometry *plane ) const
{
return ( IsParallel( plane ) && (Distance( plane->GetOrigin() ) < eps) );
}
Point3D
PlaneGeometry::ProjectPointOntoPlane( const Point3D& pt ) const
{
ScalarType len = this->GetNormalVnl().two_norm();
return pt - this->GetNormal() * this->SignedDistanceFromPlane( pt ) / len;
}
-AffineGeometryFrame3D::Pointer
-PlaneGeometry::Clone() const
+itk::LightObject::Pointer
+PlaneGeometry::InternalClone() const
{
Self::Pointer newGeometry = new PlaneGeometry(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
void
PlaneGeometry::ExecuteOperation( Operation *operation )
{
vtkTransform *transform = vtkTransform::New();
transform->SetMatrix( m_VtkMatrix );
switch ( operation->GetOperationType() )
{
case OpORIENT:
{
mitk::PlaneOperation *planeOp = dynamic_cast< mitk::PlaneOperation * >( operation );
if ( planeOp == NULL )
{
return;
}
Point3D center = planeOp->GetPoint();
Vector3D orientationVector = planeOp->GetNormal();
Vector3D defaultVector;
FillVector3D( defaultVector, 0.0, 0.0, 1.0 );
Vector3D rotationAxis = itk::CrossProduct( orientationVector, defaultVector );
//vtkFloatingPointType rotationAngle = acos( orientationVector[2] / orientationVector.GetNorm() );
vtkFloatingPointType rotationAngle = atan2( (double) rotationAxis.GetNorm(), (double) (orientationVector * defaultVector) );
rotationAngle *= 180.0 / vnl_math::pi;
transform->PostMultiply();
transform->Identity();
transform->Translate( center[0], center[1], center[2] );
transform->RotateWXYZ( rotationAngle, rotationAxis[0], rotationAxis[1], rotationAxis[2] );
transform->Translate( -center[0], -center[1], -center[2] );
break;
}
case OpRESTOREPLANEPOSITION:
{
RestorePlanePositionOperation *op = dynamic_cast< mitk::RestorePlanePositionOperation* >(operation);
if(op == NULL)
{
return;
}
AffineTransform3D::Pointer transform2 = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, op->GetTransform()->GetMatrix().GetVnlMatrix().get_column(0));
matrix.GetVnlMatrix().set_column(1, op->GetTransform()->GetMatrix().GetVnlMatrix().get_column(1));
matrix.GetVnlMatrix().set_column(2, op->GetTransform()->GetMatrix().GetVnlMatrix().get_column(2));
transform2->SetMatrix(matrix);
Vector3D offset = op->GetTransform()->GetOffset();
transform2->SetOffset(offset);
this->SetIndexToWorldTransform(transform2);
ScalarType bounds[6] = {0, op->GetWidth(), 0, op->GetHeight(), 0 ,1 };
this->SetBounds(bounds);
TransferItkToVtkTransform();
this->Modified();
transform->Delete();
return;
}
default:
Superclass::ExecuteOperation( operation );
transform->Delete();
return;
}
m_VtkMatrix->DeepCopy(transform->GetMatrix());
this->TransferVtkToItkTransform();
this->Modified();
transform->Delete();
}
void PlaneGeometry::PrintSelf( std::ostream& os, itk::Indent indent ) const
{
Superclass::PrintSelf(os,indent);
os << indent << " Normal: " << GetNormal() << std::endl;
}
} // namespace
diff --git a/Core/Code/DataManagement/mitkPlaneGeometry.h b/Core/Code/DataManagement/mitkPlaneGeometry.h
index 51b3a13829..82fd504f1b 100644
--- a/Core/Code/DataManagement/mitkPlaneGeometry.h
+++ b/Core/Code/DataManagement/mitkPlaneGeometry.h
@@ -1,434 +1,434 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#include <MitkExports.h>
#include "mitkGeometry2D.h"
#include "mitkRestorePlanePositionOperation.h"
#include <vnl/vnl_cross.h>
namespace mitk {
template < class TCoordRep, unsigned int NPointDimension > class Line;
typedef Line<ScalarType, 3> Line3D;
/**
* \brief Describes a two-dimensional, rectangular plane
*
* \ingroup Geometry
*/
class MITK_CORE_EXPORT PlaneGeometry : public Geometry2D
{
public:
mitkClassMacro(PlaneGeometry,Geometry2D);
/** Method for creation through the object factory. */
itkNewMacro(Self);
enum PlaneOrientation
{
#ifdef _MSC_VER
Transversal, // deprecated
#endif
Axial = 0,
Sagittal,
Frontal
};
#ifdef __GNUC__
__attribute__ ((deprecated)) static const PlaneOrientation Transversal = PlaneOrientation(Axial);
#endif
virtual void IndexToWorld(const Point2D &pt_units, Point2D &pt_mm) const;
virtual void WorldToIndex(const Point2D &pt_mm, Point2D &pt_units) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## @deprecated First parameter (Point2D) is not used. If possible, please use void IndexToWorld(const mitk::Vector2D& vec_units, mitk::Vector2D& vec_mm) const.
//## For further information about coordinates types, please see the Geometry documentation
virtual void IndexToWorld(const mitk::Point2D &atPt2d_untis, const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## For further information about coordinates types, please see the Geometry documentation
virtual void IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## @deprecated First parameter (Point2D) is not used. If possible, please use void WorldToIndex(const mitk::Vector2D& vec_mm, mitk::Vector2D& vec_units) const.
//## For further information about coordinates types, please see the Geometry documentation
virtual void WorldToIndex(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## For further information about coordinates types, please see the Geometry documentation
virtual void WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
virtual void Initialize();
/**
* \brief Initialize a plane with orientation \a planeorientation
* (default: axial) with respect to \a geometry3D (default: identity).
* Spacing also taken from \a geometry3D.
*
* \warning A former version of this method created a geometry with unit
* spacing. For unit spacing use
*
* \code
* // for in-plane unit spacing:
* thisgeometry->SetSizeInUnits(thisgeometry->GetExtentInMM(0),
* thisgeometry->GetExtentInMM(1));
* // additionally, for unit spacing in normal direction (former version
* // did not do this):
* thisgeometry->SetExtentInMM(2, 1.0);
* \endcode
*/
virtual void InitializeStandardPlane( const Geometry3D* geometry3D,
PlaneOrientation planeorientation = Axial, ScalarType zPosition = 0,
bool frontside=true, bool rotated=false );
/**
* \brief Initialize a plane with orientation \a planeorientation
* (default: axial) with respect to \a geometry3D (default: identity).
* Spacing also taken from \a geometry3D.
*
* \param top if \a true, create plane at top, otherwise at bottom
* (for PlaneOrientation Axial, for other plane locations respectively)
*/
virtual void InitializeStandardPlane( const Geometry3D* geometry3D, bool top,
PlaneOrientation planeorientation = Axial,
bool frontside=true, bool rotated=false );
/**
* \brief Initialize a plane with orientation \a planeorientation
* (default: axial) with respect to \a transform (default: identity)
* given width and height in units.
*
*/
virtual void InitializeStandardPlane( ScalarType width, ScalarType height,
const AffineTransform3D* transform = NULL,
PlaneOrientation planeorientation = Axial,
ScalarType zPosition = 0, bool frontside=true, bool rotated=false );
/**
* \brief Initialize plane with orientation \a planeorientation
* (default: axial) given width, height and spacing.
*
*/
virtual void InitializeStandardPlane( ScalarType width, ScalarType height,
const Vector3D & spacing, PlaneOrientation planeorientation = Axial,
ScalarType zPosition = 0, bool frontside = true, bool rotated = false );
/**
* \brief Initialize plane by width and height in pixels, right-/down-vector
* (itk) to describe orientation in world-space (vectors will be normalized)
* and spacing (default: 1.0 mm in all directions).
*
* The vectors are normalized and multiplied by the respective spacing before
* they are set in the matrix.
*/
virtual void InitializeStandardPlane( ScalarType width, ScalarType height,
const Vector3D& rightVector, const Vector3D& downVector,
const Vector3D *spacing = NULL );
/**
* \brief Initialize plane by width and height in pixels,
* right-/down-vector (vnl) to describe orientation in world-space (vectors
* will be normalized) and spacing (default: 1.0 mm in all directions).
*
* The vectors are normalized and multiplied by the respective spacing
* before they are set in the matrix.
*/
virtual void InitializeStandardPlane( ScalarType width, ScalarType height,
const VnlVector& rightVector, const VnlVector& downVector,
const Vector3D * spacing = NULL );
/**
* \brief Initialize plane by right-/down-vector (itk) and spacing
* (default: 1.0 mm in all directions).
*
* The length of the right-/-down-vector is used as width/height in units,
* respectively. Then, the vectors are normalized and multiplied by the
* respective spacing before they are set in the matrix.
*/
virtual void InitializeStandardPlane( const Vector3D& rightVector,
const Vector3D& downVector, const Vector3D * spacing = NULL );
/**
* \brief Initialize plane by right-/down-vector (vnl) and spacing
* (default: 1.0 mm in all directions).
*
* The length of the right-/-down-vector is used as width/height in units,
* respectively. Then, the vectors are normalized and multiplied by the
* respective spacing before they are set in the matrix.
*/
virtual void InitializeStandardPlane( const VnlVector& rightVector,
const VnlVector& downVector, const Vector3D * spacing = NULL );
/**
* \brief Initialize plane by origin and normal (size is 1.0 mm in
* all directions, direction of right-/down-vector valid but
* undefined).
*
*/
virtual void InitializePlane( const Point3D& origin, const Vector3D& normal);
/**
* \brief Initialize plane by right-/down-vector.
*
* \warning The vectors are set into the matrix as they are,
* \em without normalization!
*/
void SetMatrixByVectors( const VnlVector& rightVector,
const VnlVector& downVector, ScalarType thickness=1.0 );
/**
* \brief Change \a transform so that the third column of the
* transform-martix is perpendicular to the first two columns
*
*/
static void EnsurePerpendicularNormal( AffineTransform3D* transform );
/**
* \brief Normal of the plane
*
*/
Vector3D GetNormal() const;
/**
* \brief Normal of the plane as VnlVector
*
*/
VnlVector GetNormalVnl() const;
virtual ScalarType SignedDistance( const Point3D& pt3d_mm ) const;
virtual bool IsAbove( const Point3D& pt3d_mm ) const;
/**
* \brief Distance of the point from the plane
* (bounding-box \em not considered)
*
*/
ScalarType DistanceFromPlane( const Point3D& pt3d_mm ) const ;
/**
* \brief Signed distance of the point from the plane
* (bounding-box \em not considered)
*
* > 0 : point is in the direction of the direction vector.
*/
inline ScalarType SignedDistanceFromPlane( const Point3D& pt3d_mm ) const
{
ScalarType len = GetNormalVnl().two_norm();
if( len == 0 )
return 0;
return (pt3d_mm-GetOrigin())*GetNormal() / len;
}
/**
* \brief Distance of the plane from another plane
* (bounding-box \em not considered)
*
* Result is 0 if planes are not parallel.
*/
ScalarType DistanceFromPlane(const PlaneGeometry* plane) const
{
return fabs(SignedDistanceFromPlane(plane));
}
/**
* \brief Signed distance of the plane from another plane
* (bounding-box \em not considered)
*
* Result is 0 if planes are not parallel.
*/
inline ScalarType SignedDistanceFromPlane( const PlaneGeometry *plane ) const
{
if(IsParallel(plane))
{
return SignedDistance(plane->GetOrigin());
}
return 0;
}
/**
* \brief Calculate the intersecting line of two planes
*
* \return \a true planes are intersecting
* \return \a false planes do not intersect
*/
bool IntersectionLine( const PlaneGeometry *plane, Line3D &crossline ) const;
/**
* \brief Calculate two points where another plane intersects the border of this plane
*
* \return number of intersection points (0..2). First interection point (if existing)
* is returned in \a lineFrom, second in \a lineTo.
*/
unsigned int IntersectWithPlane2D(const PlaneGeometry *plane,
Point2D &lineFrom, Point2D &lineTo ) const ;
/**
* \brief Calculate the angle between two planes
*
* \return angle in radiants
*/
double Angle( const PlaneGeometry *plane ) const;
/**
* \brief Calculate the angle between the plane and a line
*
* \return angle in radiants
*/
double Angle( const Line3D &line ) const;
/**
* \brief Calculate intersection point between the plane and a line
*
* \param intersectionPoint intersection point
* \return \a true if \em unique intersection exists, i.e., if line
* is \em not on or parallel to the plane
*/
bool IntersectionPoint( const Line3D &line,
Point3D &intersectionPoint ) const;
/**
* \brief Calculate line parameter of intersection point between the
* plane and a line
*
* \param t parameter of line: intersection point is
* line.GetPoint()+t*line.GetDirection()
* \return \a true if \em unique intersection exists, i.e., if line
* is \em not on or parallel to the plane
*/
bool IntersectionPointParam( const Line3D &line, double &t ) const;
/**
* \brief Returns whether the plane is parallel to another plane
*
* @return true iff the normal vectors both point to the same or exactly oposit direction
*/
bool IsParallel( const PlaneGeometry *plane ) const;
/**
* \brief Returns whether the point is on the plane
* (bounding-box \em not considered)
*/
bool IsOnPlane( const Point3D &point ) const;
/**
* \brief Returns whether the line is on the plane
* (bounding-box \em not considered)
*/
bool IsOnPlane( const Line3D &line ) const;
/**
* \brief Returns whether the plane is on the plane
* (bounding-box \em not considered)
*
* @return true iff the normal vector of the planes point to the same or the exactly oposit direction and
* the distance of the planes is < eps
*
*/
bool IsOnPlane( const PlaneGeometry *plane ) const;
/**
* \brief Returns the lot from the point to the plane
*/
Point3D ProjectPointOntoPlane( const Point3D &pt ) const;
virtual void SetIndexToWorldTransform( AffineTransform3D *transform);
virtual void SetBounds( const BoundingBox::BoundsArrayType &bounds );
- AffineGeometryFrame3D::Pointer Clone() const;
+ virtual itk::LightObject::Pointer InternalClone() const;
/** Implements operation to re-orient the plane */
virtual void ExecuteOperation( Operation *operation );
protected:
PlaneGeometry();
virtual ~PlaneGeometry();
virtual void PrintSelf( std::ostream &os, itk::Indent indent ) const;
private:
/**
* \brief Compares plane with another plane: \a true if IsOnPlane
* (bounding-box \em not considered)
*/
virtual bool operator==( const PlaneGeometry * ) const { return false; };
/**
* \brief Compares plane with another plane: \a false if IsOnPlane
* (bounding-box \em not considered)
*/
virtual bool operator!=( const PlaneGeometry * ) const { return false; };
};
} // namespace mitk
#endif /* PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Core/Code/DataManagement/mitkPlaneOrientationProperty.cpp b/Core/Code/DataManagement/mitkPlaneOrientationProperty.cpp
index 80f39ecec6..c45f1970aa 100644
--- a/Core/Code/DataManagement/mitkPlaneOrientationProperty.cpp
+++ b/Core/Code/DataManagement/mitkPlaneOrientationProperty.cpp
@@ -1,107 +1,101 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlaneOrientationProperty.h"
namespace mitk
{
PlaneOrientationProperty::PlaneOrientationProperty( )
{
this->AddDecorationTypes();
this->SetValue( static_cast<IdType>( PLANE_DECORATION_NONE ) );
}
PlaneOrientationProperty::PlaneOrientationProperty( const IdType& value )
{
this->AddDecorationTypes();
if ( this->IsValidEnumerationValue( value ) )
{
this->SetValue( value ) ;
}
else
{
this->SetValue( static_cast<IdType>( PLANE_DECORATION_NONE ) );
}
}
PlaneOrientationProperty::PlaneOrientationProperty( const std::string& value )
{
this->AddDecorationTypes();
if ( this->IsValidEnumerationValue( value ) )
{
this->SetValue( value );
}
else
{
this->SetValue( static_cast<IdType>( PLANE_DECORATION_NONE ) );
}
}
int PlaneOrientationProperty::GetPlaneDecoration()
{
return static_cast<int>( this->GetValueAsId() );
}
void PlaneOrientationProperty::SetPlaneDecorationToNone()
{
this->SetValue( static_cast<IdType>( PLANE_DECORATION_NONE ) );
}
void PlaneOrientationProperty::SetPlaneDecorationToPositiveOrientation()
{
this->SetValue( static_cast<IdType>( PLANE_DECORATION_POSITIVE_ORIENTATION ) );
}
void PlaneOrientationProperty::SetPlaneDecorationToNegativeOrientation()
{
this->SetValue( static_cast<IdType>( PLANE_DECORATION_NEGATIVE_ORIENTATION ) );
}
void PlaneOrientationProperty::AddDecorationTypes()
{
this->AddEnum( "No plane decoration", static_cast<IdType>( PLANE_DECORATION_NONE ) );
this->AddEnum( "Arrows in positive direction", static_cast<IdType>( PLANE_DECORATION_POSITIVE_ORIENTATION ) );
this->AddEnum( "Arrows in negative direction", static_cast<IdType>( PLANE_DECORATION_NEGATIVE_ORIENTATION ) );
}
bool PlaneOrientationProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
-PlaneOrientationProperty::Pointer PlaneOrientationProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer PlaneOrientationProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
} // namespace
diff --git a/Core/Code/DataManagement/mitkPlaneOrientationProperty.h b/Core/Code/DataManagement/mitkPlaneOrientationProperty.h
index 3c13cc4782..c9b099d012 100644
--- a/Core/Code/DataManagement/mitkPlaneOrientationProperty.h
+++ b/Core/Code/DataManagement/mitkPlaneOrientationProperty.h
@@ -1,132 +1,130 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITK_PLANE_DECORATION_PROPERTY__H
#define MITK_PLANE_DECORATION_PROPERTY__H
#include "mitkEnumerationProperty.h"
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* Property which controls whether 2D line representation of a PlaneGeometry
* should have small arrows at both ends to indicate the orientation of
* the plane, and whether the arrows should be oriented in the direction of
* the plane's normal or against it.
*
* Valid values of the enumeration property are
* - PLANE_DECORATION_NONE (no arrows)
* - PLANE_DECORATION_POSITIVE_ORIENTATION (arrows pointing upwards)
* - PLANE_DECORATION_NEGATIVE_ORIENTATION (arrows pointing downwards)
*
* See also mitk::Geometry2DDataMapper2D::DrawOrientationArrow()
*/
class MITK_CORE_EXPORT PlaneOrientationProperty : public EnumerationProperty
{
public:
mitkClassMacro( PlaneOrientationProperty, EnumerationProperty );
itkNewMacro(PlaneOrientationProperty);
mitkNewMacro1Param(PlaneOrientationProperty, const IdType&);
mitkNewMacro1Param(PlaneOrientationProperty, const std::string&);
- Pointer Clone() const;
-
enum
{
PLANE_DECORATION_NONE,
PLANE_DECORATION_POSITIVE_ORIENTATION,
PLANE_DECORATION_NEGATIVE_ORIENTATION
};
/**
* Returns the state of plane decoration.
*/
virtual int GetPlaneDecoration();
/**
* Sets the decoration type to no decoration.
*/
virtual void SetPlaneDecorationToNone();
/**
* Sets the decoration type to arrows in positive plane direction.
*/
virtual void SetPlaneDecorationToPositiveOrientation();
/**
* Sets the decoration type to arrows in negative plane direction.
*/
virtual void SetPlaneDecorationToNegativeOrientation();
using BaseProperty::operator=;
protected:
/**
* Constructor. Sets the decoration type to none.
*/
PlaneOrientationProperty( );
/**
* Constructor. Sets the decoration type to the given value. If it is not
* valid, the interpolation is set to none
*/
PlaneOrientationProperty( const IdType &value );
/**
* Constructor. Sets the decoration type to the given value. If it is not
* valid, the representation is set to none
*/
PlaneOrientationProperty( const std::string &value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid types.
*/
virtual bool AddEnum( const std::string &name, const IdType &id );
/**
* Adds the standard enumeration types with corresponding strings.
*/
virtual void AddDecorationTypes();
private:
// purposely not implemented
PlaneOrientationProperty& operator=(const PlaneOrientationProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // end of namespace mitk
#endif
diff --git a/Core/Code/DataManagement/mitkPointSet.cpp b/Core/Code/DataManagement/mitkPointSet.cpp
index c580873a1b..a8b350ef41 100755
--- a/Core/Code/DataManagement/mitkPointSet.cpp
+++ b/Core/Code/DataManagement/mitkPointSet.cpp
@@ -1,797 +1,797 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSet.h"
#include "mitkPointOperation.h"
#include "mitkInteractionConst.h"
mitk::PointSet::PointSet()
{
this->InitializeEmpty();
}
mitk::PointSet::PointSet(const PointSet &other): BaseData(other)
{
// Copy overall geometry information
this->SetGeometry(other.GetGeometry());
// Copy geometry information of every single timestep
for (unsigned int t=0; t < other.GetTimeSteps(); t++)
{
this->SetClonedGeometry( other.GetGeometry(t) );
}
// Expand to desired amount of timesteps
this->Expand(other.GetTimeSteps());
// Copy points
for (unsigned int t=0; t < other.GetTimeSteps(); t++)
{
for (int i=0; i< other.GetSize(t); i++)
{
this->InsertPoint(i, other.GetPoint(i,t), t);
}
}
}
mitk::PointSet::~PointSet()
{
this->ClearData();
}
void mitk::PointSet::ClearData()
{
m_PointSetSeries.clear();
Superclass::ClearData();
}
void mitk::PointSet::InitializeEmpty()
{
m_PointSetSeries.resize( 1 );
m_PointSetSeries[0] = DataType::New();
PointDataContainer::Pointer pointData = PointDataContainer::New();
m_PointSetSeries[0]->SetPointData( pointData );
m_CalculateBoundingBox = false;
Superclass::InitializeTimeSlicedGeometry(1);
m_Initialized = true;
}
bool mitk::PointSet::IsEmptyTimeStep(unsigned int t) const
{
return IsInitialized() && (GetSize(t) == 0);
}
void mitk::PointSet::Expand( unsigned int timeSteps )
{
// Check if the vector is long enough to contain the new element
// at the given position. If not, expand it with sufficient pre-initialized
// elements.
//
// NOTE: This method will never REDUCE the vector size; it should only
// be used to make sure that the vector has enough elements to include the
// specified time step.
unsigned int oldSize = m_PointSetSeries.size();
if ( timeSteps > oldSize )
{
Superclass::Expand( timeSteps );
m_PointSetSeries.resize( timeSteps );
for ( unsigned int i = oldSize; i < timeSteps; ++i )
{
m_PointSetSeries[i] = DataType::New();
PointDataContainer::Pointer pointData = PointDataContainer::New();
m_PointSetSeries[i]->SetPointData( pointData );
}
//if the size changes, then compute the bounding box
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetExtendTimeRangeEvent() );
}
}
unsigned int mitk::PointSet::GetPointSetSeriesSize() const
{
return m_PointSetSeries.size();
}
int mitk::PointSet::GetSize( unsigned int t ) const
{
if ( t < m_PointSetSeries.size() )
{
return m_PointSetSeries[t]->GetNumberOfPoints();
}
else
{
return 0;
}
}
mitk::PointSet::DataType::Pointer mitk::PointSet::GetPointSet( int t ) const
{
if ( t < (int)m_PointSetSeries.size() )
{
return m_PointSetSeries[t];
}
else
{
return NULL;
}
}
int mitk::PointSet::SearchPoint( Point3D point, float distance, int t ) const
{
if ( t >= (int)m_PointSetSeries.size() )
{
return -1;
}
// Out is the point which is checked to be the searched point
PointType out;
out.Fill( 0 );
PointType indexPoint;
this->GetGeometry( t )->WorldToIndex(point, indexPoint);
// Searching the first point in the Set, that is +- distance far away fro
// the given point
unsigned int i;
PointsContainer::Iterator it, end;
end = m_PointSetSeries[t]->GetPoints()->End();
int bestIndex = -1;
distance = distance * distance;
// To correct errors from converting index to world and world to index
if (distance == 0.0)
{
distance = 0.000001;
}
ScalarType bestDist = distance;
ScalarType dist, tmp;
for ( it = m_PointSetSeries[t]->GetPoints()->Begin(), i = 0;
it != end;
++it, ++i )
{
bool ok = m_PointSetSeries[t]->GetPoints()
->GetElementIfIndexExists( it->Index(), &out );
if ( !ok )
{
return -1;
}
else if ( indexPoint == out ) //if totally equal
{
return it->Index();
}
//distance calculation
tmp = out[0] - indexPoint[0]; dist = tmp * tmp;
tmp = out[1] - indexPoint[1]; dist += tmp * tmp;
tmp = out[2] - indexPoint[2]; dist += tmp * tmp;
if ( dist < bestDist )
{
bestIndex = it->Index();
bestDist = dist;
}
}
return bestIndex;
}
mitk::PointSet::PointType
mitk::PointSet::GetPoint( PointIdentifier id, int t ) const
{
PointType out;
out.Fill(0);
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return out;
}
if ( m_PointSetSeries[t]->GetPoints()->IndexExists(id) )
{
m_PointSetSeries[t]->GetPoint( id, &out );
this->GetGeometry(t)->IndexToWorld( out, out );
return out;
}
else
{
return out;
}
}
bool
mitk::PointSet
::GetPointIfExists( PointIdentifier id, PointType* point, int t ) const
{
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return false;
}
if ( m_PointSetSeries[t]->GetPoints()->GetElementIfIndexExists(id, point) )
{
this->GetGeometry( t )->IndexToWorld( *point, *point );
return true;
}
else
{
return false;
}
}
void mitk::PointSet::SetPoint( PointIdentifier id, PointType point, int t )
{
// Adapt the size of the data vector if necessary
this->Expand( t+1 );
mitk::Point3D indexPoint;
this->GetGeometry( t )->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->SetPoint( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = mitk::PTUNDEFINED;
m_PointSetSeries[t]->SetPointData( id, defaultPointData );
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
void mitk::PointSet::SetPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t )
{
// Adapt the size of the data vector if necessary
this->Expand( t+1 );
mitk::Point3D indexPoint;
this->GetGeometry( t )->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->SetPoint( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = spec;
m_PointSetSeries[t]->SetPointData( id, defaultPointData );
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
void mitk::PointSet::InsertPoint( PointIdentifier id, PointType point, int t )
{
if ( (unsigned int) t < m_PointSetSeries.size() )
{
mitk::Point3D indexPoint;
mitk::Geometry3D* tempGeometry = this->GetGeometry( t );
if (tempGeometry == NULL)
{
MITK_INFO<< __FILE__ << ", l." << __LINE__ << ": GetGeometry of "<< t <<" returned NULL!" << std::endl;
return;
}
tempGeometry->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->GetPoints()->InsertElement( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = mitk::PTUNDEFINED;
m_PointSetSeries[t]->GetPointData()->InsertElement(id, defaultPointData);
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
}
void mitk::PointSet::InsertPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t )
{
if ( (unsigned int) t < m_PointSetSeries.size() )
{
mitk::Point3D indexPoint;
mitk::Geometry3D* tempGeometry = this->GetGeometry( t );
if (tempGeometry == NULL)
{
MITK_INFO<< __FILE__ << ", l." << __LINE__ << ": GetGeometry of "<< t <<" returned NULL!" << std::endl;
return;
}
tempGeometry->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->GetPoints()->InsertElement( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = spec;
m_PointSetSeries[t]->GetPointData()->InsertElement(id, defaultPointData);
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
}
bool mitk::PointSet::SwapPointPosition( PointIdentifier id, bool moveUpwards, int t )
{
if(IndexExists(id, t) )
{
PointType point = GetPoint(id,t);
if(moveUpwards)
{//up
if(IndexExists(id-1,t))
{
InsertPoint(id, GetPoint(id - 1, t), t);
InsertPoint(id-1,point,t);
this->Modified();
return true;
}
}
else
{//down
if(IndexExists(id+1,t))
{
InsertPoint(id, GetPoint(id + 1, t), t);
InsertPoint(id+1,point,t);
this->Modified();
return true;
}
}
}
return false;
}
bool mitk::PointSet::IndexExists( int position, int t ) const
{
if ( (unsigned int) t < m_PointSetSeries.size() )
{
return m_PointSetSeries[t]->GetPoints()->IndexExists( position );
}
else
{
return false;
}
}
bool mitk::PointSet::GetSelectInfo( int position, int t ) const
{
if ( this->IndexExists( position, t ) )
{
PointDataType pointData = { 0, false, PTUNDEFINED };
m_PointSetSeries[t]->GetPointData( position, &pointData );
return pointData.selected;
}
else
{
return false;
}
}
void mitk::PointSet::SetSelectInfo( int position, bool selected, int t )
{
if ( this->IndexExists( position, t ) )
{
// timeStep to ms
ScalarType timeInMS = this->GetTimeSlicedGeometry()->TimeStepToMS( t );
// point
Point3D point = this->GetPoint( position, t );
std::auto_ptr<PointOperation> op;
if (selected)
{
op.reset(new mitk::PointOperation(OpSELECTPOINT, timeInMS, point, position ));
}
else
{
op.reset(new mitk::PointOperation(OpDESELECTPOINT, timeInMS, point, position ));
}
this->ExecuteOperation( op.get() );
}
}
mitk::PointSpecificationType mitk::PointSet::GetSpecificationTypeInfo( int position, int t ) const
{
if ( this->IndexExists( position, t ) )
{
PointDataType pointData = { 0, false, PTUNDEFINED };
m_PointSetSeries[t]->GetPointData( position, &pointData );
return pointData.pointSpec;
}
else
{
return PTUNDEFINED;
}
}
int mitk::PointSet::GetNumberOfSelected( int t ) const
{
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return 0;
}
int numberOfSelected = 0;
PointDataIterator it;
for ( it = m_PointSetSeries[t]->GetPointData()->Begin();
it != m_PointSetSeries[t]->GetPointData()->End();
it++ )
{
if (it->Value().selected == true)
{
++numberOfSelected;
}
}
return numberOfSelected;
}
int mitk::PointSet::SearchSelectedPoint( int t ) const
{
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return -1;
}
PointDataIterator it;
for ( it = m_PointSetSeries[t]->GetPointData()->Begin();
it != m_PointSetSeries[t]->GetPointData()->End();
it++ )
{
if ( it->Value().selected == true )
{
return it->Index();
}
}
return -1;
}
void mitk::PointSet::ExecuteOperation( Operation* operation )
{
int timeStep = -1;
mitkCheckOperationTypeMacro(PointOperation, operation, pointOp);
if ( pointOp )
{
timeStep = this->GetTimeSlicedGeometry()
->MSToTimeStep( pointOp->GetTimeInMS() );
}
if ( timeStep < 0 )
{
MITK_ERROR << "Time step (" << timeStep << ") outside of PointSet time bounds" << std::endl;
return;
}
switch (operation->GetOperationType())
{
case OpNOTHING:
break;
case OpINSERT://inserts the point at the given position and selects it.
{
int position = pointOp->GetIndex();
PointType pt;
pt.CastFrom(pointOp->GetPoint());
//transfer from world to index coordinates
mitk::Geometry3D* geometry = this->GetGeometry( timeStep );
if (geometry == NULL)
{
MITK_INFO<<"GetGeometry returned NULL!\n";
return;
}
geometry->WorldToIndex(pt, pt);
m_PointSetSeries[timeStep]->GetPoints()->InsertElement(position, pt);
PointDataType pointData =
{
static_cast<unsigned int>(pointOp->GetIndex()),
pointOp->GetSelected(),
pointOp->GetPointType()
};
m_PointSetSeries[timeStep]->GetPointData()
->InsertElement(position, pointData);
this->Modified();
//boundingbox has to be computed
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetAddEvent() );
this->OnPointSetChange();
}
break;
case OpMOVE://moves the point given by index
{
PointType pt;
pt.CastFrom(pointOp->GetPoint());
//transfer from world to index coordinates
this->GetGeometry( timeStep )->WorldToIndex(pt, pt);
// Copy new point into container
m_PointSetSeries[timeStep]->SetPoint(pointOp->GetIndex(), pt);
// Insert a default point data object to keep the containers in sync
// (if no point data object exists yet)
PointDataType pointData;
if ( !m_PointSetSeries[timeStep]->GetPointData( pointOp->GetIndex(), &pointData ) )
{
m_PointSetSeries[timeStep]->SetPointData( pointOp->GetIndex(), pointData );
}
this->OnPointSetChange();
this->Modified();
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetMoveEvent() );
}
break;
case OpREMOVE://removes the point at given by position
{
m_PointSetSeries[timeStep]->GetPoints()->DeleteIndex((unsigned)pointOp->GetIndex());
m_PointSetSeries[timeStep]->GetPointData()->DeleteIndex((unsigned)pointOp->GetIndex());
this->OnPointSetChange();
this->Modified();
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetRemoveEvent() );
}
break;
case OpSELECTPOINT://select the given point
{
PointDataType pointData = {0, false, PTUNDEFINED};
m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
pointData.selected = true;
m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
this->Modified();
}
break;
case OpDESELECTPOINT://unselect the given point
{
PointDataType pointData = {0, false, PTUNDEFINED};
m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
pointData.selected = false;
m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
this->Modified();
}
break;
case OpSETPOINTTYPE:
{
PointDataType pointData = {0, false, PTUNDEFINED};
m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
pointData.pointSpec = pointOp->GetPointType();
m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
this->Modified();
}
break;
case OpMOVEPOINTUP: // swap content of point with ID pointOp->GetIndex() with the point preceding it in the container // move point position within the pointset
{
PointIdentifier currentID = pointOp->GetIndex();
/* search for point with this id and point that precedes this one in the data container */
PointsContainer::STLContainerType points = m_PointSetSeries[timeStep]->GetPoints()->CastToSTLContainer();
PointsContainer::STLContainerType::iterator it = points.find(currentID);
if (it == points.end()) // ID not found
break;
if (it == points.begin()) // we are at the first element, there is no previous element
break;
/* get and cache current point & pointdata and previous point & pointdata */
--it;
PointIdentifier prevID = it->first;
if (this->SwapPointContents(prevID, currentID, timeStep) == true)
this->Modified();
}
break;
case OpMOVEPOINTDOWN: // move point position within the pointset
{
PointIdentifier currentID = pointOp->GetIndex();
/* search for point with this id and point that succeeds this one in the data container */
PointsContainer::STLContainerType points = m_PointSetSeries[timeStep]->GetPoints()->CastToSTLContainer();
PointsContainer::STLContainerType::iterator it = points.find(currentID);
if (it == points.end()) // ID not found
break;
++it;
if (it == points.end()) // ID is already the last element, there is no succeeding element
break;
/* get and cache current point & pointdata and previous point & pointdata */
PointIdentifier nextID = it->first;
if (this->SwapPointContents(nextID, currentID, timeStep) == true)
this->Modified();
}
break;
default:
itkWarningMacro("mitkPointSet could not understrand the operation. Please check!");
break;
}
//to tell the mappers, that the data is modified and has to be updated
//only call modified if anything is done, so call in cases
//this->Modified();
mitk::OperationEndEvent endevent(operation);
((const itk::Object*)this)->InvokeEvent(endevent);
//*todo has to be done here, cause of update-pipeline not working yet
// As discussed lately, don't mess with the rendering from inside data structures
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PointSet::UpdateOutputInformation()
{
if ( this->GetSource( ) )
{
this->GetSource( )->UpdateOutputInformation( );
}
//
// first make sure, that the associated time sliced geometry has
// the same number of geometry 3d's as PointSets are present
//
mitk::TimeSlicedGeometry* timeGeometry = GetTimeSlicedGeometry();
if ( timeGeometry->GetTimeSteps() != m_PointSetSeries.size() )
{
itkExceptionMacro(<<"timeGeometry->GetTimeSteps() != m_PointSetSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
}
// This is needed to detect zero objects
mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
BoundingBox::BoundsArrayType itkBoundsNull(nullpoint);
//
// Iterate over the PointSets and update the Geometry
// information of each of the items.
//
if (m_CalculateBoundingBox)
{
for ( unsigned int i = 0 ; i < m_PointSetSeries.size() ; ++i )
{
const DataType::BoundingBoxType *bb = m_PointSetSeries[i]->GetBoundingBox();
BoundingBox::BoundsArrayType itkBounds = bb->GetBounds();
if ( m_PointSetSeries[i].IsNull() || (m_PointSetSeries[i]->GetNumberOfPoints() == 0)
|| (itkBounds == itkBoundsNull) )
{
itkBounds = itkBoundsNull;
continue;
}
// Ensure minimal bounds of 1.0 in each dimension
for ( unsigned int j = 0; j < 3; ++j )
{
if ( itkBounds[j*2+1] - itkBounds[j*2] < 1.0 )
{
BoundingBox::CoordRepType center =
(itkBounds[j*2] + itkBounds[j*2+1]) / 2.0;
itkBounds[j*2] = center - 0.5;
itkBounds[j*2+1] = center + 0.5;
}
}
this->GetGeometry(i)->SetBounds(itkBounds);
}
m_CalculateBoundingBox = false;
}
this->GetTimeSlicedGeometry()->UpdateInformation();
}
void mitk::PointSet::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::PointSet::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::PointSet::VerifyRequestedRegion()
{
return true;
}
-void mitk::PointSet::SetRequestedRegion( itk::DataObject * )
+void mitk::PointSet::SetRequestedRegion(const DataObject * )
{
}
void mitk::PointSet::PrintSelf( std::ostream& os, itk::Indent indent ) const
{
Superclass::PrintSelf(os, indent);
os << indent << "Number timesteps: " << m_PointSetSeries.size() << "\n";
unsigned int i = 0;
for (PointSetSeries::const_iterator it = m_PointSetSeries.begin(); it != m_PointSetSeries.end(); ++it)
{
os << indent << "Timestep " << i++ << ": \n";
MeshType::Pointer ps = *it;
itk::Indent nextIndent = indent.GetNextIndent();
ps->Print(os, nextIndent);
MeshType::PointsContainer* points = ps->GetPoints();
MeshType::PointDataContainer* datas = ps->GetPointData();
MeshType::PointDataContainer::Iterator dataIterator = datas->Begin();
for (MeshType::PointsContainer::Iterator pointIterator = points->Begin();
pointIterator != points->End();
++pointIterator, ++dataIterator)
{
os << nextIndent << "Point " << pointIterator->Index() << ": [";
os << pointIterator->Value().GetElement(0);
for (unsigned int i = 1; i < PointType::GetPointDimension(); ++i)
{
os << ", " << pointIterator->Value().GetElement(i);
}
os << "]";
os << ", selected: " << dataIterator->Value().selected << ", point spec: " << dataIterator->Value().pointSpec << "\n";
}
}
}
bool mitk::PointSet::SwapPointContents(PointIdentifier id1, PointIdentifier id2, int timeStep)
{
/* search and cache contents */
PointType p1;
if (m_PointSetSeries[timeStep]->GetPoint(id1, &p1) == false)
return false;
PointDataType data1;
if (m_PointSetSeries[timeStep]->GetPointData(id1, &data1) == false)
return false;
PointType p2;
if (m_PointSetSeries[timeStep]->GetPoint(id2, &p2) == false)
return false;
PointDataType data2;
if (m_PointSetSeries[timeStep]->GetPointData(id2, &data2) == false)
return false;
/* now swap contents */
m_PointSetSeries[timeStep]->SetPoint(id1, p2);
m_PointSetSeries[timeStep]->SetPointData(id1, data2);
m_PointSetSeries[timeStep]->SetPoint(id2, p1);
m_PointSetSeries[timeStep]->SetPointData(id2, data1);
return true;
}
diff --git a/Core/Code/DataManagement/mitkPointSet.h b/Core/Code/DataManagement/mitkPointSet.h
index 0b484b6711..ae13c84964 100755
--- a/Core/Code/DataManagement/mitkPointSet.h
+++ b/Core/Code/DataManagement/mitkPointSet.h
@@ -1,274 +1,274 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKPointSet_H_HEADER_INCLUDED
#define MITKPointSet_H_HEADER_INCLUDED
#include "mitkBaseData.h"
#include <itkMesh.h>
#include <itkDefaultDynamicMeshTraits.h>
namespace mitk {
/**
* \brief Data structure which stores a set of points. Superclass of
* mitk::Mesh.
*
* 3D points are grouped within a point set; for time resolved usage, one point
* set is created and maintained per time step. A point entry consists of the
* point coordinates and point data.
*
* The point data includes a point ID (unique identifier to address this point
* within the point set), the selection state of the point and the type of
* the point.
*
* For further information about different point types see
* mitk::PointSpecificationType in mitkVector.h.
*
* Inserting a point is accompanied by an event, containing an index. The new
* point is inserted into the list at the specified position. At the same time
* an internal ID is generated and stored for the point. Points at specific time
* steps are accessed by specifying the time step number (which defaults to 0).
*
* The points of itk::PointSet stores the points in a pointContainer
* (MapContainer). The points are best accessed by using a ConstIterator (as
* defined in MapContainer); avoid access via index.
*
* The class internally uses an itk::Mesh for each time step, because
* mitk::Mesh is derived from mitk::PointSet and needs the itk::Mesh structure
* which is also derived from itk::PointSet. Thus several typedefs which seem
* to be in wrong place, are declared here (for example SelectedLinesType).
*
* \section mitkPointSetDisplayOptions
*
* The default mappers for this data structure are mitk::PointSetGLMapper2D and
* mitk::PointSetVtkMapper3D. See these classes for display options which can
* can be set via properties.
*
* \section Events
*
* PointSet issues the following events, for which observers can register
* (the below events are grouped into a class hierarchy as indicated by
* identation level; e.g. PointSetSizeChangeEvent comprises PointSetAddEvent
* and PointSetRemoveEvent):
*
* <tt>
* PointSetEvent <i>subsumes all PointSet events</i>
* PointSetMoveEvent <i>issued when a point of the PointSet is moved</i>
* PointSetSizeChangeEvent <i>subsumes add and remove events</i>
* PointSetAddEvent <i>issued when a point is added to the PointSet</i>
* PointSetRemoveEvent <i>issued when a point is removed from the PointSet</i>
* </tt>
* \ingroup PSIO
* \ingroup Data
*/
class MITK_CORE_EXPORT PointSet : public BaseData
{
public:
mitkClassMacro(PointSet, BaseData);
itkNewMacro(Self);
mitkCloneMacro(PointSet);
typedef mitk::ScalarType CoordinateType;
typedef mitk::ScalarType InterpolationWeightType;
static const unsigned int PointDimension = 3;
static const unsigned int MaxTopologicalDimension = 3;
/**
* \brief struct for data of a point
*/
struct PointDataType
{
unsigned int id; //to give the point a special ID
bool selected; //information about if the point is selected
mitk::PointSpecificationType pointSpec; //specifies the type of the point
};
/**
* \brief cellDataType, that stores all indexes of the lines, that are
* selected e.g.: points A,B and C.Between A and B there is a line with
* index 0. If vector of cellData contains 1 and 2, then the lines between
* B and C and C and A is selected.
*/
typedef std::vector<unsigned int> SelectedLinesType;
typedef SelectedLinesType::iterator SelectedLinesIter;
struct CellDataType
{
//used to set the whole cell on selected
bool selected;
//indexes of selected lines. 0 is between pointId 0 and 1
SelectedLinesType selectedLines;
//is the polygon already finished and closed
bool closed;
};
typedef itk::DefaultDynamicMeshTraits<
PointDataType, PointDimension, MaxTopologicalDimension,
CoordinateType, InterpolationWeightType, CellDataType > MeshTraits;
typedef itk::Mesh<PointDataType, PointDimension, MeshTraits> MeshType;
typedef MeshType DataType;
typedef DataType::PointType PointType;
typedef DataType::PointIdentifier PointIdentifier;
typedef DataType::PointsContainer PointsContainer;
typedef DataType::PointsContainerIterator PointsIterator;
typedef DataType::PointsContainer::ConstIterator PointsConstIterator;
typedef DataType::PointDataContainer PointDataContainer;
typedef DataType::PointDataContainerIterator PointDataIterator;
virtual void Expand( unsigned int timeSteps );
/** \brief executes the given Operation */
virtual void ExecuteOperation(Operation* operation);
/** \brief returns the current size of the point-list */
virtual int GetSize( unsigned int t = 0 ) const;
virtual unsigned int GetPointSetSeriesSize() const;
/** \brief returns the pointset */
virtual DataType::Pointer GetPointSet( int t = 0 ) const;
/**
* \brief Get the point with ID id in world coordinates
*
* check if the ID exists. If it doesn't exist, then return 0,0,0
*/
PointType GetPoint( PointIdentifier id, int t = 0 ) const;
/**
* \brief Get the point with ID id in world coordinates
*
* If a point exists for the ID id, the point is returned in the parameter point
* and the method returns true. If the ID does not exist, the method returns false
*/
bool GetPointIfExists( PointIdentifier id, PointType* point, int t = 0 ) const;
/**
* \brief Set the given point in world coordinate system into the itkPointSet.
*/
void SetPoint( PointIdentifier id, PointType point, int t = 0 );
/**
* \brief Set the given point in world coordinate system with the given PointSpecificationType
*/
void SetPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t = 0 );
/**
* \brief Set the given point in world coordinate system into the itkPointSet.
*/
void InsertPoint( PointIdentifier id, PointType point, int t = 0 );
/**
* \brief Set the given point in world coordinate system with given PointSpecificationType
*/
void InsertPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t );
/**
* \brief Swap a point at the given position (id) with the upper point (moveUpwards=true) or with the lower point (moveUpwards=false).
* If upper or lower index does not exist false is returned, if swap was successful true.
*/
bool SwapPointPosition( PointIdentifier id, bool moveUpwards, int t = 0 );
/**
* \brief searches a selected point and returns the id of that point.
* If no point is found, then -1 is returned
*/
virtual int SearchSelectedPoint( int t = 0 ) const;
/** \brief returns true if a point exists at this position */
virtual bool IndexExists( int position, int t = 0 ) const;
/** \brief to get the state selected/unselected of the point on the
* position
*/
virtual bool GetSelectInfo( int position, int t = 0 ) const;
virtual void SetSelectInfo( int position, bool selected, int t = 0 );
/** \brief to get the type of the point at the position and the moment */
virtual PointSpecificationType GetSpecificationTypeInfo( int position, int t ) const;
/** \brief returns the number of selected points */
virtual int GetNumberOfSelected( int t = 0 ) const;
/**
* \brief searches a point in the list == point +/- distance
*
* \param point is in world coordinates.
* \param distance is in mm.
* returns -1 if no point is found
* or the position in the list of the first match
*/
int SearchPoint( Point3D point, float distance, int t = 0 ) const;
virtual bool IsEmptyTimeStep(unsigned int t) const;
//virtual methods, that need to be implemented
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion(const itk::DataObject *data);
//Method for subclasses
virtual void OnPointSetChange(){};
protected:
PointSet();
PointSet(const PointSet &other);
virtual ~PointSet();
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const; ///< print content of the object to os
virtual void ClearData();
virtual void InitializeEmpty();
/** \brief swaps point coordinates and point data of the points with identifiers id1 and id2 */
bool SwapPointContents(PointIdentifier id1, PointIdentifier id2, int t = 0 );
typedef std::vector< DataType::Pointer > PointSetSeries;
PointSetSeries m_PointSetSeries;
/**
* @brief flag to indicate the right time to call SetBounds
**/
bool m_CalculateBoundingBox;
};
#pragma GCC visibility push(default)
itkEventMacro( PointSetEvent, itk::AnyEvent );
itkEventMacro( PointSetMoveEvent, PointSetEvent );
itkEventMacro( PointSetSizeChangeEvent, PointSetEvent );
itkEventMacro( PointSetAddEvent, PointSetSizeChangeEvent );
itkEventMacro( PointSetRemoveEvent, PointSetSizeChangeEvent );
itkEventMacro( PointSetExtendTimeRangeEvent, PointSetEvent );
#pragma GCC visibility pop
} // namespace mitk
#endif /* MITKPointSet_H_HEADER_INCLUDED */
diff --git a/Core/Code/DataManagement/mitkPointSetShapeProperty.cpp b/Core/Code/DataManagement/mitkPointSetShapeProperty.cpp
new file mode 100644
index 0000000000..3807465638
--- /dev/null
+++ b/Core/Code/DataManagement/mitkPointSetShapeProperty.cpp
@@ -0,0 +1,78 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkPointSetShapeProperty.h"
+
+
+mitk::PointSetShapeProperty::PointSetShapeProperty( )
+{
+ this->AddPointSetShapes();
+ this->SetValue( CROSS );
+}
+
+mitk::PointSetShapeProperty::PointSetShapeProperty( const IdType& value )
+{
+ this->AddPointSetShapes();
+ if ( IsValidEnumerationValue( value ) )
+ {
+ this->SetValue( value ) ;
+ }
+ else
+ MITK_WARN << "Warning: invalid point set shape";
+}
+
+mitk::PointSetShapeProperty::PointSetShapeProperty( const std::string& value )
+{
+ this->AddPointSetShapes();
+ if ( IsValidEnumerationValue( value ) )
+ {
+ this->SetValue( value );
+ }
+ else
+ MITK_WARN << "Invalid point set shape";
+}
+
+int mitk::PointSetShapeProperty::GetPointSetShape()
+{
+ return static_cast<int>( this->GetValueAsId() );
+}
+
+void mitk::PointSetShapeProperty::AddPointSetShapes()
+{
+ AddEnum("None", NONE);
+ AddEnum("Vertex", VERTEX);
+ AddEnum("Dash", DASH);
+ AddEnum("Cross", CROSS);
+ AddEnum("ThickCross", THICK_CROSS);
+ AddEnum("Triangle", TRIANGLE);
+ AddEnum("Square", SQUARE);
+ AddEnum("Circle", CIRCLE);
+ AddEnum("Diamond", DIAMOND);
+ AddEnum("Arrow", ARROW);
+ AddEnum("ThickArrow", THICK_ARROW);
+ AddEnum("HookedArrow", HOOKED_ARROW);
+}
+
+bool mitk::PointSetShapeProperty::AddEnum( const std::string& name, const IdType& id )
+{
+ return Superclass::AddEnum( name, id );
+}
+
+itk::LightObject::Pointer mitk::PointSetShapeProperty::InternalClone() const
+{
+ itk::LightObject::Pointer result(new Self(*this));
+ return result;
+}
diff --git a/Core/Code/DataManagement/mitkPointSetShapeProperty.h b/Core/Code/DataManagement/mitkPointSetShapeProperty.h
new file mode 100644
index 0000000000..0834e2f1e5
--- /dev/null
+++ b/Core/Code/DataManagement/mitkPointSetShapeProperty.h
@@ -0,0 +1,126 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef _MITK_POINTSET_SHAPE_PROPERTY__H_
+#define _MITK_POINTSET_SHAPE_PROPERTY__H_
+
+#include "mitkEnumerationProperty.h"
+
+namespace mitk
+{
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable: 4522)
+#endif
+
+/**
+ * Encapsulates the enumeration for point set shapes. Valid values are:
+ * \li NONE
+ * \li VERTEX
+ * \li DASH
+ * \li CROSS (default)
+ * \li THICK_CROSS
+ * \li TRIANGLE
+ * \li SQUARE
+ * \li CIRCLE
+ * \li DIAMOND
+ * \li ARROW
+ * \li THICK_ARROW
+ * \li HOOKED_ARROW
+ *
+ * This class provides different shapes for the point set rendering (unselected points).
+ *
+ */
+
+class MITK_CORE_EXPORT PointSetShapeProperty : public EnumerationProperty
+{
+public:
+
+ mitkClassMacro( PointSetShapeProperty, EnumerationProperty );
+
+ itkNewMacro(PointSetShapeProperty);
+
+ mitkNewMacro1Param(PointSetShapeProperty, const IdType&);
+
+ mitkNewMacro1Param(PointSetShapeProperty, const std::string&);
+
+ enum PointSetShape
+ {
+ NONE = 0,
+ VERTEX = 1,
+ DASH = 2,
+ CROSS = 3,
+ THICK_CROSS = 4,
+ TRIANGLE = 5,
+ SQUARE = 6,
+ CIRCLE = 7,
+ DIAMOND = 8,
+ ARROW = 9,
+ THICK_ARROW = 10,
+ HOOKED_ARROW = 11
+ // Default = CROSS;
+ };
+
+ /**
+ * Returns the current shape
+ */
+ virtual int GetPointSetShape();
+
+ using BaseProperty::operator=;
+
+ protected:
+
+ /** Sets rendering type to default (VTK_RAY_CAST_COMPOSITE_FUNCTION).
+ */
+ PointSetShapeProperty( );
+
+ /**
+ * Constructor. Sets rendering type to the given value.
+ */
+ PointSetShapeProperty( const IdType& value );
+
+ /**
+ * Constructor. Sets rendering type to the given value.
+ */
+ PointSetShapeProperty( const std::string& value );
+
+ /**
+ * this function is overridden as protected, so that the user may not add
+ * additional invalid rendering types.
+ */
+ virtual bool AddEnum( const std::string& name, const IdType& id );
+
+ /**
+ * Adds the default enumeration types.
+ */
+ virtual void AddPointSetShapes();
+
+private:
+
+ // purposely not implemented
+ PointSetShapeProperty& operator=(const PointSetShapeProperty&);
+
+ virtual itk::LightObject::Pointer InternalClone() const;
+};
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+} // end of namespace mitk
+
+#endif
diff --git a/Core/Code/DataManagement/mitkPropertyList.cpp b/Core/Code/DataManagement/mitkPropertyList.cpp
index 0bad64951d..94278f7332 100644
--- a/Core/Code/DataManagement/mitkPropertyList.cpp
+++ b/Core/Code/DataManagement/mitkPropertyList.cpp
@@ -1,291 +1,284 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPropertyList.h"
#include "mitkProperties.h"
#include "mitkStringProperty.h"
#include "mitkVector.h"
mitk::BaseProperty* mitk::PropertyList::GetProperty(const std::string& propertyKey) const
{
PropertyMap::const_iterator it;
it=m_Properties.find( propertyKey );
if(it!=m_Properties.end())
return it->second;
else
return NULL;
}
void mitk::PropertyList::SetProperty(const std::string& propertyKey, BaseProperty* property)
{
if (!property) return;
//make sure that BaseProperty*, which may have just been created and never been
//assigned to a SmartPointer, is registered/unregistered properly. If we do not
//do that, it will a) not deleted in case it is identical to the old one or
//b) possibly deleted when temporarily added to a smartpointer somewhere below.
BaseProperty::Pointer tmpSmartPointerToProperty = property;
PropertyMap::iterator it( m_Properties.find( propertyKey ) );
// Is a property with key @a propertyKey contained in the list?
if( it != m_Properties.end() )
{
// yes
//is the property contained in the list identical to the new one?
if( it->second->operator==(*property) )
{
// yes? do nothing and return.
return;
}
if (it->second->AssignProperty(*property))
{
// The assignment was successfull
this->Modified();
}
else
{
MITK_ERROR << "In " __FILE__ ", l." << __LINE__
<< ": Trying to set existing property " << it->first << " of type " << it->second->GetNameOfClass()
<< " to a property with different type " << property->GetNameOfClass() << "."
<< " Use ReplaceProperty() instead."
<< std::endl;
}
return;
}
//no? add it.
PropertyMapElementType newProp;
newProp.first = propertyKey;
newProp.second = property;
m_Properties.insert ( newProp );
this->Modified();
}
void mitk::PropertyList::ReplaceProperty(const std::string& propertyKey, BaseProperty* property)
{
if (!property) return;
PropertyMap::iterator it( m_Properties.find( propertyKey ) );
// Is a property with key @a propertyKey contained in the list?
if( it != m_Properties.end() )
{
it->second=NULL;
m_Properties.erase(it);
}
//no? add/replace it.
PropertyMapElementType newProp;
newProp.first = propertyKey;
newProp.second = property;
m_Properties.insert ( newProp );
Modified();
}
mitk::PropertyList::PropertyList()
{
}
mitk::PropertyList::PropertyList(const mitk::PropertyList& other)
: itk::Object()
{
for (PropertyMap::const_iterator i = other.m_Properties.begin();
i != other.m_Properties.end(); ++i)
{
m_Properties.insert(std::make_pair(i->first, i->second->Clone()));
}
}
mitk::PropertyList::~PropertyList()
{
Clear();
}
/**
* Consider the list as changed when any of the properties has changed recently.
*/
unsigned long mitk::PropertyList::GetMTime() const
{
for ( PropertyMap::const_iterator it = m_Properties.begin() ;
it != m_Properties.end();
++it )
{
if( it->second.IsNull() )
{
itkWarningMacro(<< "Property '" << it->first <<"' contains nothing (NULL).");
continue;
}
if( Superclass::GetMTime() < it->second->GetMTime() )
{
Modified();
break;
}
}
return Superclass::GetMTime();
}
bool mitk::PropertyList::DeleteProperty(const std::string& propertyKey)
{
PropertyMap::iterator it;
it=m_Properties.find( propertyKey );
if(it!=m_Properties.end())
{
it->second=NULL;
m_Properties.erase(it);
Modified();
return true;
}
return false;
}
-mitk::PropertyList::Pointer mitk::PropertyList::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
-
void mitk::PropertyList::Clear()
{
PropertyMap::iterator it = m_Properties.begin(), end = m_Properties.end();
while(it!=end)
{
it->second = NULL;
++it;
}
m_Properties.clear();
}
itk::LightObject::Pointer mitk::PropertyList::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
void mitk::PropertyList::ConcatenatePropertyList(PropertyList *pList, bool replace)
{
if (pList)
{
const PropertyMap* propertyMap = pList->GetMap();
for ( PropertyMap::const_iterator iter = propertyMap->begin(); // m_PropertyList is created in the constructor, so we don't check it here
iter != propertyMap->end();
++iter )
{
const std::string key = iter->first;
BaseProperty* value = iter->second;
if (replace)
{
ReplaceProperty( key.c_str(), value );
}
else
{
SetProperty( key.c_str(), value );
}
}
}
}
bool mitk::PropertyList::GetBoolProperty(const char* propertyKey, bool& boolValue) const
{
BoolProperty *gp = dynamic_cast<BoolProperty*>( GetProperty(propertyKey) );
if ( gp != NULL )
{
boolValue = gp->GetValue();
return true;
}
return false;
// Templated Method does not work on Macs
//return GetPropertyValue<bool>(propertyKey, boolValue);
}
bool mitk::PropertyList::GetIntProperty(const char* propertyKey, int &intValue) const
{
IntProperty *gp = dynamic_cast<IntProperty*>( GetProperty(propertyKey) );
if ( gp != NULL )
{
intValue = gp->GetValue();
return true;
}
return false;
// Templated Method does not work on Macs
//return GetPropertyValue<int>(propertyKey, intValue);
}
bool mitk::PropertyList::GetFloatProperty(const char* propertyKey, float &floatValue) const
{
FloatProperty *gp = dynamic_cast<FloatProperty*>( GetProperty(propertyKey) );
if ( gp != NULL )
{
floatValue = gp->GetValue();
return true;
}
return false;
// Templated Method does not work on Macs
//return GetPropertyValue<float>(propertyKey, floatValue);
}
bool mitk::PropertyList::GetStringProperty(const char* propertyKey, std::string& stringValue) const
{
StringProperty* sp= dynamic_cast<StringProperty*>(GetProperty(propertyKey));
if ( sp != NULL )
{
stringValue = sp->GetValue();
return true;
}
return false;
}
void mitk::PropertyList::SetIntProperty(const char* propertyKey, int intValue)
{
SetProperty(propertyKey, mitk::IntProperty::New(intValue));
}
void mitk::PropertyList::SetBoolProperty( const char* propertyKey, bool boolValue)
{
SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
}
void mitk::PropertyList::SetFloatProperty( const char* propertyKey, float floatValue)
{
SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
}
void mitk::PropertyList::SetStringProperty( const char* propertyKey, const char* stringValue)
{
SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
}
diff --git a/Core/Code/DataManagement/mitkPropertyList.h b/Core/Code/DataManagement/mitkPropertyList.h
index 40a2a1029f..233fd52e79 100644
--- a/Core/Code/DataManagement/mitkPropertyList.h
+++ b/Core/Code/DataManagement/mitkPropertyList.h
@@ -1,212 +1,210 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef PROPERTYLIST_H_HEADER_INCLUDED_C1C77D8D
#define PROPERTYLIST_H_HEADER_INCLUDED_C1C77D8D
#include <MitkExports.h>
#include "mitkBaseProperty.h"
#include "mitkGenericProperty.h"
#include "mitkUIDGenerator.h"
#include <itkObjectFactory.h>
#include <string>
#include <map>
namespace mitk {
class XMLWriter;
/**
* @brief Key-value list holding instances of BaseProperty
*
* This list is meant to hold an arbitrary list of "properties",
* which should describe the object associated with this list.
*
* Usually you will use PropertyList as part of a DataNode
* object - in this context the properties describe the data object
* held by the DataNode (e.g. whether the object is rendered at
* all, which color is used for rendering, what name should be
* displayed for the object, etc.)
*
* The values in the list are not fixed, you may introduce any kind
* of property that seems useful - all you have to do is inherit
* from BaseProperty.
*
* The list is organized as a key-value pairs, i.e.
*
* \li "name" : pointer to a StringProperty
* \li "visible" : pointer to a BoolProperty
* \li "color" : pointer to a ColorProperty
* \li "volume" : pointer to a FloatProperty
*
* Please see the documentation of SetProperty and ReplaceProperty for two
* quite different semantics. Normally SetProperty is what you want - this
* method will try to change the value of an existing property and will
* not allow you to replace e.g. a ColorProperty with an IntProperty.
*
* @ingroup DataManagement
*/
class MITK_CORE_EXPORT PropertyList : public itk::Object
{
public:
mitkClassMacro(PropertyList, itk::Object)
/**
* Method for creation through the object factory.
*/
itkNewMacro(Self)
- Pointer Clone() const;
-
/**
* Map structure to hold the properties: the map key is a string,
* the value consists of the actual property object (BaseProperty).
*/
typedef std::map< std::string, BaseProperty::Pointer> PropertyMap;
typedef std::pair< std::string, BaseProperty::Pointer> PropertyMapElementType;
/**
* @brief Get a property by its name.
*/
mitk::BaseProperty* GetProperty(const std::string& propertyKey) const;
/**
* @brief Set a property in the list/map by value.
*
* The actual OBJECT holding the value of the property is not replaced, but its value
* is modified to match that of @a property. To really replace the object holding the
* property - which would make sense if you want to change the type (bool, string) of the property
* - call ReplaceProperty.
*/
void SetProperty(const std::string& propertyKey, BaseProperty* property);
/**
* @brief Set a property object in the list/map by reference.
*
* The actual OBJECT holding the value of the property is replaced by this function.
* This is useful if you want to change the type of the property, like from BoolProperty to StringProperty.
* Another use is to share one and the same property object among several ProperyList/DataNode objects, which
* makes them appear synchronized.
*/
void ReplaceProperty(const std::string& propertyKey, BaseProperty* property);
/**
* @brief Set a property object in the list/map by reference.
*/
void ConcatenatePropertyList(PropertyList *pList, bool replace = false);
//##Documentation
//## @brief Convenience access method for GenericProperty<T> properties
//## (T being the type of the second parameter)
//## @return @a true property was found
template <typename T>
bool GetPropertyValue(const char* propertyKey, T & value) const
{
GenericProperty<T>* gp= dynamic_cast<GenericProperty<T>*>(GetProperty(propertyKey));
if ( gp != NULL )
{
value = gp->GetValue();
return true;
}
return false;
}
/**
* @brief Convenience method to access the value of a BoolProperty
*/
bool GetBoolProperty(const char* propertyKey, bool& boolValue) const;
/**
* @brief Convenience method to set the value of a BoolProperty
*/
void SetBoolProperty( const char* propertyKey, bool boolValue);
/**
* @brief Convenience method to access the value of an IntProperty
*/
bool GetIntProperty(const char* propertyKey, int &intValue) const;
/**
* @brief Convenience method to set the value of an IntProperty
*/
void SetIntProperty(const char* propertyKey, int intValue);
/**
* @brief Convenience method to access the value of a FloatProperty
*/
bool GetFloatProperty(const char* propertyKey, float &floatValue) const;
/**
* @brief Convenience method to set the value of a FloatProperty
*/
void SetFloatProperty( const char* propertyKey, float floatValue);
/**
* @brief Convenience method to access the value of a StringProperty
*/
bool GetStringProperty(const char* propertyKey, std::string& stringValue) const;
/**
* @brief Convenience method to set the value of a StringProperty
*/
void SetStringProperty( const char* propertyKey, const char* stringValue);
/**
* @brief Get the timestamp of the last change of the map or the last change of one of
* the properties store in the list (whichever is later).
*/
virtual unsigned long GetMTime() const;
/**
* @brief Remove a property from the list/map.
*/
bool DeleteProperty(const std::string& propertyKey);
const PropertyMap* GetMap() const { return &m_Properties; }
bool IsEmpty() const { return m_Properties.empty(); }
virtual void Clear();
protected:
PropertyList();
PropertyList(const PropertyList& other);
virtual ~PropertyList();
/**
* @brief Map of properties.
*/
PropertyMap m_Properties;
private:
virtual itk::LightObject::Pointer InternalClone() const;
};
} // namespace mitk
#endif /* PROPERTYLIST_H_HEADER_INCLUDED_C1C77D8D */
diff --git a/Core/Code/DataManagement/mitkRenderingModeProperty.cpp b/Core/Code/DataManagement/mitkRenderingModeProperty.cpp
index 99377a60d0..c233ae638d 100644
--- a/Core/Code/DataManagement/mitkRenderingModeProperty.cpp
+++ b/Core/Code/DataManagement/mitkRenderingModeProperty.cpp
@@ -1,77 +1,71 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkRenderingModeProperty.h"
mitk::RenderingModeProperty::RenderingModeProperty( )
{
this->AddRenderingModes();
this->SetValue( LEVELWINDOW_COLOR );
}
mitk::RenderingModeProperty::RenderingModeProperty( const IdType& value )
{
this->AddRenderingModes();
if ( IsValidEnumerationValue( value ) )
{
this->SetValue( value ) ;
}
else
MITK_WARN << "Warning: invalid image rendering mode";
}
mitk::RenderingModeProperty::RenderingModeProperty( const std::string& value )
{
this->AddRenderingModes();
if ( IsValidEnumerationValue( value ) )
{
this->SetValue( value );
}
else
MITK_WARN << "Invalid image rendering mode";
}
int mitk::RenderingModeProperty::GetRenderingMode()
{
return static_cast<int>( this->GetValueAsId() );
}
void mitk::RenderingModeProperty::AddRenderingModes()
{
AddEnum( "LevelWindow_Color", LEVELWINDOW_COLOR );
AddEnum( "LookupTable_LevelWindow_Color", LOOKUPTABLE_LEVELWINDOW_COLOR );
AddEnum( "ColorTransferFunction_LevelWindow_Color", COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR );
AddEnum( "LookupTable_Color", LOOKUPTABLE_COLOR );
AddEnum( "ColorTransferFunction_Color", COLORTRANSFERFUNCTION_COLOR );
}
bool mitk::RenderingModeProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
-mitk::RenderingModeProperty::Pointer mitk::RenderingModeProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::RenderingModeProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkRenderingModeProperty.h b/Core/Code/DataManagement/mitkRenderingModeProperty.h
index 50f7dda154..fb550df067 100644
--- a/Core/Code/DataManagement/mitkRenderingModeProperty.h
+++ b/Core/Code/DataManagement/mitkRenderingModeProperty.h
@@ -1,117 +1,115 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_RENDERING_MODE_PROPERTY__H_
#define _MITK_RENDERING_MODE_PROPERTY__H_
#include "mitkEnumerationProperty.h"
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* Encapsulates the enumeration for rendering modes. Valid values are:
* \li LEVELWINDOW_COLOR: Level window and color will be applied to the image.
* \li LOOKUPTABLE_LEVELWINDOW_COLOR: A lookup table, level window and color will be applied to the image.
* \li COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR: A colortransferfunction, level window and color will be applied to the image.
* \li LOOKUPTABLE_COLOR: A lookup table and color will be applied to the image.
* \li COLORTRANSFERFUNCTION_COLOR: A colortransferfunction and color will be applied to the image.
*
* The order is given by the names (e.g. LOOKUPTABLE_COLOR applies first a lookup table and next a color).
* Currently, there is no GUI (in mitkWorkbench) support for controlling lookup tables or transfer functions.
* This has to be done by the programmer. Color and level window are controled by color widget and level window slider.
* Currently, the color is always applied. We do not set the color to white, if the user changes the mode. We assume
* that users who change the mode know that a previously set color will still be applied (on top of the mode).
*/
class MITK_CORE_EXPORT RenderingModeProperty : public EnumerationProperty
{
public:
mitkClassMacro( RenderingModeProperty, EnumerationProperty );
itkNewMacro(RenderingModeProperty);
mitkNewMacro1Param(RenderingModeProperty, const IdType&);
mitkNewMacro1Param(RenderingModeProperty, const std::string&);
- Pointer Clone() const;
-
enum ImageRenderingMode
{
LEVELWINDOW_COLOR = 0,
LOOKUPTABLE_LEVELWINDOW_COLOR = 1,
COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR = 2,
LOOKUPTABLE_COLOR = 3,
COLORTRANSFERFUNCTION_COLOR = 4
// Default = LEVELWINDOW_COLOR;
};
/**
* Returns the current rendering mode
*/
virtual int GetRenderingMode();
using BaseProperty::operator=;
protected:
/** Sets rendering type to default (VTK_RAY_CAST_COMPOSITE_FUNCTION).
*/
RenderingModeProperty( );
/**
* Constructor. Sets rendering type to the given value.
*/
RenderingModeProperty( const IdType& value );
/**
* Constructor. Sets rendering type to the given value.
*/
RenderingModeProperty( const std::string& value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid rendering types.
*/
virtual bool AddEnum( const std::string& name, const IdType& id );
/**
* Adds the default enumeration types.
*/
virtual void AddRenderingModes();
private:
// purposely not implemented
RenderingModeProperty& operator=(const RenderingModeProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // end of namespace mitk
#endif
diff --git a/Core/Code/DataManagement/mitkResliceMethodProperty.cpp b/Core/Code/DataManagement/mitkResliceMethodProperty.cpp
index 052683cce0..3713b72ece 100644
--- a/Core/Code/DataManagement/mitkResliceMethodProperty.cpp
+++ b/Core/Code/DataManagement/mitkResliceMethodProperty.cpp
@@ -1,57 +1,51 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkResliceMethodProperty.h"
mitk::ResliceMethodProperty::ResliceMethodProperty( )
{
AddThickSlicesTypes();
SetValue( (IdType)0 );
}
mitk::ResliceMethodProperty::ResliceMethodProperty( const IdType& value )
{
AddThickSlicesTypes();
if ( IsValidEnumerationValue( value ) )
SetValue( value );
}
mitk::ResliceMethodProperty::ResliceMethodProperty( const std::string& value )
{
AddThickSlicesTypes();
if ( IsValidEnumerationValue( value ) )
SetValue( value );
}
void mitk::ResliceMethodProperty::AddThickSlicesTypes()
{
AddEnum( "disabled", (IdType) 0 );
AddEnum( "mip", (IdType) 1 );
AddEnum( "sum", (IdType) 2 );
AddEnum( "weighted", (IdType) 3 );
}
-mitk::ResliceMethodProperty::Pointer mitk::ResliceMethodProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::ResliceMethodProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkResliceMethodProperty.h b/Core/Code/DataManagement/mitkResliceMethodProperty.h
index eb7ea26b78..fabe744dca 100644
--- a/Core/Code/DataManagement/mitkResliceMethodProperty.h
+++ b/Core/Code/DataManagement/mitkResliceMethodProperty.h
@@ -1,70 +1,68 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __MITKRESLICEMETHODENUMPROPERTY_H
#define __MITKRESLICEMETHODENUMPROPERTY_H
#include "mitkEnumerationProperty.h"
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* Encapsulates the thick slices method enumeration
*/
class MITK_CORE_EXPORT ResliceMethodProperty : public EnumerationProperty
{
public:
mitkClassMacro( ResliceMethodProperty, EnumerationProperty );
itkNewMacro(ResliceMethodProperty);
mitkNewMacro1Param(ResliceMethodProperty, const IdType&);
mitkNewMacro1Param(ResliceMethodProperty, const std::string&);
- Pointer Clone() const;
-
using BaseProperty::operator=;
protected:
ResliceMethodProperty( );
ResliceMethodProperty( const IdType& value );
ResliceMethodProperty( const std::string& value );
void AddThickSlicesTypes();
private:
// purposely not implemented
ResliceMethodProperty& operator=(const ResliceMethodProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // end of namespace mitk
#endif //_MITK_VTK_SCALARMODE_PROPERTY__H_
diff --git a/Core/Code/DataManagement/mitkShaderProperty.cpp b/Core/Code/DataManagement/mitkShaderProperty.cpp
index 6e042c910b..d61ce949e6 100644
--- a/Core/Code/DataManagement/mitkShaderProperty.cpp
+++ b/Core/Code/DataManagement/mitkShaderProperty.cpp
@@ -1,126 +1,120 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <vtkAbstractMapper.h>
#include "mitkShaderProperty.h"
#include "mitkCoreServices.h"
#include "mitkIShaderRepository.h"
#include <itkDirectory.h>
#include <itksys/SystemTools.hxx>
mitk::ShaderProperty::ShaderProperty( )
{
AddShaderTypes();
SetShader( (IdType)0 );
}
mitk::ShaderProperty::ShaderProperty(const ShaderProperty& other)
: mitk::EnumerationProperty(other)
, shaderList(other.shaderList)
{
}
mitk::ShaderProperty::ShaderProperty( const IdType& value )
{
AddShaderTypes();
SetShader(value);
}
mitk::ShaderProperty::ShaderProperty( const std::string& value )
{
AddShaderTypes();
SetShader(value);
}
void mitk::ShaderProperty::SetShader( const IdType& value )
{
if ( IsValidEnumerationValue( value ) )
SetValue( value );
else
SetValue( (IdType)0 );
}
void mitk::ShaderProperty::SetShader( const std::string& value )
{
if ( IsValidEnumerationValue( value ) )
SetValue( value );
else
SetValue( (IdType)0 );
}
mitk::EnumerationProperty::IdType mitk::ShaderProperty::GetShaderId()
{
return GetValueAsId();
}
std::string mitk::ShaderProperty::GetShaderName()
{
return GetValueAsString();
}
void mitk::ShaderProperty::AddShaderTypes()
{
AddEnum( "fixed" );
IShaderRepository* shaderRepo = CoreServices::GetShaderRepository();
if (shaderRepo == NULL) return;
std::list<mitk::IShaderRepository::Shader::Pointer> l = shaderRepo->GetShaders();
std::list<mitk::IShaderRepository::Shader::Pointer>::const_iterator i = l.begin();
while( i != l.end() )
{
AddEnum( (*i)->GetName() );
i++;
}
}
bool mitk::ShaderProperty::AddEnum( const std::string& name ,const IdType& /*id*/)
{
Element e;
e.name=name;
bool success=Superclass::AddEnum( e.name, (IdType)shaderList.size() );
shaderList.push_back(e);
return success;
}
bool mitk::ShaderProperty::Assign(const BaseProperty &property)
{
Superclass::Assign(property);
this->shaderList = static_cast<const Self&>(property).shaderList;
return true;
}
-mitk::ShaderProperty::Pointer mitk::ShaderProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::ShaderProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkShaderProperty.h b/Core/Code/DataManagement/mitkShaderProperty.h
index eadc0a6874..873dc1848f 100644
--- a/Core/Code/DataManagement/mitkShaderProperty.h
+++ b/Core/Code/DataManagement/mitkShaderProperty.h
@@ -1,120 +1,118 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __MITKSHADERENUMPROPERTY_H
#define __MITKSHADERENUMPROPERTY_H
#include "mitkEnumerationProperty.h"
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* Encapsulates the shader enumeration
*/
class MITK_CORE_EXPORT ShaderProperty : public EnumerationProperty
{
public:
class Element {
public:
std::string name;
};
mitkClassMacro( ShaderProperty, EnumerationProperty );
itkNewMacro(ShaderProperty);
mitkNewMacro1Param(ShaderProperty, const IdType&);
mitkNewMacro1Param(ShaderProperty, const std::string&);
- Pointer Clone() const;
-
/**
* Returns the current scalar mode value as defined by VTK constants.
* @returns the current scalar mode as VTK constant.
*/
IdType GetShaderId();
std::string GetShaderName();
void SetShader(const IdType& i);
void SetShader(const std::string& i);
using BaseProperty::operator=;
protected:
std::list<Element> shaderList;
/**
* Constructor. Sets the representation to a default value of surface(2)
*/
ShaderProperty( );
ShaderProperty(const ShaderProperty& other);
/**
* \brief Sets the scalar mode to the given value. If it is not
* valid, the scalar mode is set to default (0).
* @param value the integer representation of the scalar mode
*/
ShaderProperty( const IdType& value );
/**
* \brief Sets the scalar mode to the given value. If it is not
* valid, the representation is set to default (0).
* @param value the string representation of the scalar mode
*/
ShaderProperty( const std::string& value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid scalar mode types.
*/
bool AddEnum( const std::string& name, const IdType& id = 0);
/**
* Adds the enumeration types as defined by vtk to the list of known
* enumeration values.
*/
void AddShaderTypes();
private:
// purposely not implemented
ShaderProperty& operator=(const ShaderProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
virtual bool Assign(const BaseProperty &property);
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // end of namespace mitk
#endif //_MITK_VTK_SCALARMODE_PROPERTY__H_
diff --git a/Core/Code/DataManagement/mitkSlicedData.cpp b/Core/Code/DataManagement/mitkSlicedData.cpp
index 2ee20cc2c4..bfb5dcef8e 100644
--- a/Core/Code/DataManagement/mitkSlicedData.cpp
+++ b/Core/Code/DataManagement/mitkSlicedData.cpp
@@ -1,352 +1,350 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSlicedData.h"
#include "mitkBaseProcess.h"
mitk::SlicedData::SlicedData() : m_UseLargestPossibleRegion(false)
{
unsigned int i;
for(i=0;i<4;++i)
{
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize (i, 1);
}
}
mitk::SlicedData::SlicedData( const SlicedData &other ): BaseData(other),
m_LargestPossibleRegion(other.m_LargestPossibleRegion),
m_RequestedRegion(other.m_RequestedRegion),
m_BufferedRegion(other.m_BufferedRegion),
m_UseLargestPossibleRegion(other.m_UseLargestPossibleRegion)
{
}
mitk::SlicedData::~SlicedData()
{
}
void mitk::SlicedData::UpdateOutputInformation()
{
Superclass::UpdateOutputInformation();
if (this->GetSource().IsNull())
// If we don't have a source, then let's make our Image
// span our buffer
{
m_UseLargestPossibleRegion = true;
}
// Now we should know what our largest possible region is. If our
// requested region was not set yet, (or has been set to something
// invalid - with no data in it ) then set it to the largest possible
// region.
if ( ! m_RequestedRegionInitialized)
{
this->SetRequestedRegionToLargestPossibleRegion();
m_RequestedRegionInitialized = true;
}
m_LastRequestedRegionWasOutsideOfTheBufferedRegion = 0;
}
void mitk::SlicedData::PrepareForNewData()
{
if ( GetUpdateMTime() < GetPipelineMTime() || GetDataReleased() )
{
ReleaseData();
}
}
void mitk::SlicedData::SetRequestedRegionToLargestPossibleRegion()
{
m_UseLargestPossibleRegion = true;
if(GetGeometry()==NULL)
return;
unsigned int i;
const RegionType::IndexType & index = GetLargestPossibleRegion().GetIndex();
const RegionType::SizeType & size = GetLargestPossibleRegion().GetSize();
for(i=0;i<RegionDimension;++i)
{
m_RequestedRegion.SetIndex(i, index[i]);
m_RequestedRegion.SetSize(i, size[i]);
}
}
bool mitk::SlicedData::RequestedRegionIsOutsideOfTheBufferedRegion()
{
// Is the requested region within the currently buffered data?
// SlicedData and subclasses store entire volumes or slices. The
// methods IsVolumeSet() and IsSliceSet are provided to check,
// a volume or slice, respectively, is available. Thus, these
// methods used here.
const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
const SizeType& largestPossibleRegionSize
= GetLargestPossibleRegion().GetSize();
// are whole channels requested?
int c, cEnd;
c=requestedRegionIndex[4];
cEnd=c+static_cast<long>(requestedRegionSize[4]);
if(requestedRegionSize[3] == largestPossibleRegionSize[3])
{
for (; c< cEnd; ++c)
if(IsChannelSet(c)==false) return true;
return false;
}
// are whole volumes requested?
int t, tEnd;
t=requestedRegionIndex[3];
tEnd=t+static_cast<long>(requestedRegionSize[3]);
if(requestedRegionSize[2] == largestPossibleRegionSize[2])
{
for (; c< cEnd; ++c)
for (; t< tEnd; ++t)
if(IsVolumeSet(t, c)==false) return true;
return false;
}
// ok, only slices are requested. Check if they are available.
int s, sEnd;
s=requestedRegionIndex[2];
sEnd=s+static_cast<long>(requestedRegionSize[2]);
for (; c< cEnd; ++c)
for (; t< tEnd; ++t)
for (; s< sEnd; ++s)
if(IsSliceSet(s, t, c)==false) return true;
return false;
}
bool mitk::SlicedData::VerifyRequestedRegion()
{
if(GetTimeSlicedGeometry() == NULL) return false;
unsigned int i;
// Is the requested region within the LargestPossibleRegion?
// Note that the test is indeed against the largest possible region
// rather than the buffered region; see DataObject::VerifyRequestedRegion.
const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
const IndexType &largestPossibleRegionIndex
= GetLargestPossibleRegion().GetIndex();
const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
const SizeType& largestPossibleRegionSize
= GetLargestPossibleRegion().GetSize();
for (i=0; i< RegionDimension; ++i)
{
if ( (requestedRegionIndex[i] < largestPossibleRegionIndex[i]) ||
((requestedRegionIndex[i] + static_cast<long>(requestedRegionSize[i]))
> (largestPossibleRegionIndex[i]+static_cast<long>(largestPossibleRegionSize[i]))))
{
return false;
}
}
return true;
}
-void mitk::SlicedData::SetRequestedRegion(itk::DataObject *data)
+void mitk::SlicedData::SetRequestedRegion( const itk::DataObject *data)
{
m_UseLargestPossibleRegion=false;
- mitk::SlicedData *slicedData;
-
- slicedData = dynamic_cast<mitk::SlicedData*>(data);
+ const mitk::SlicedData *slicedData = dynamic_cast<const mitk::SlicedData*>(data);
if (slicedData)
{
m_RequestedRegion = slicedData->GetRequestedRegion();
m_RequestedRegionInitialized = true;
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(DataObject*) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
}
}
void mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType *region)
{
m_UseLargestPossibleRegion=false;
if(region!=NULL)
{
m_RequestedRegion = *region;
m_RequestedRegionInitialized = true;
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(SlicedData*).name() );
}
}
void mitk::SlicedData::CopyInformation(const itk::DataObject *data)
{
// Standard call to the superclass' method
Superclass::CopyInformation(data);
const mitk::SlicedData *slicedData;
slicedData = dynamic_cast<const mitk::SlicedData*>(data);
if (slicedData)
{
m_LargestPossibleRegion = slicedData->GetLargestPossibleRegion();
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::SlicedData::CopyInformation(const DataObject *data) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
}
}
//const mitk::Geometry2D* mitk::SlicedData::GetGeometry2D(int s, int t) const
//{
// const_cast<SlicedData*>(this)->SetRequestedRegionToLargestPossibleRegion();
//
// const_cast<SlicedData*>(this)->UpdateOutputInformation();
//
// return GetSlicedGeometry(t)->GetGeometry2D(s);
//}
//
mitk::SlicedGeometry3D* mitk::SlicedData::GetSlicedGeometry(unsigned int t) const
{
if(GetTimeSlicedGeometry() == NULL)
return NULL;
return dynamic_cast<SlicedGeometry3D*>(GetTimeSlicedGeometry()->GetGeometry3D(t));
}
const mitk::SlicedGeometry3D* mitk::SlicedData::GetUpdatedSlicedGeometry(unsigned int t)
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetSlicedGeometry(t);
}
void mitk::SlicedData::SetGeometry(Geometry3D* aGeometry3D)
{
if(aGeometry3D!=NULL)
{
TimeSlicedGeometry::Pointer timeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(aGeometry3D);
if(timeSlicedGeometry.IsNull())
{
SlicedGeometry3D::Pointer slicedGeometry = dynamic_cast<SlicedGeometry3D*>(aGeometry3D);
if(slicedGeometry.IsNull())
{
Geometry2D* geometry2d = dynamic_cast<Geometry2D*>(aGeometry3D);
if(geometry2d!=NULL)
{
if((GetSlicedGeometry()->GetGeometry2D(0)==geometry2d) && (GetSlicedGeometry()->GetSlices()==1))
return;
slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(geometry2d, 1);
}
else
{
slicedGeometry = SlicedGeometry3D::New();
PlaneGeometry::Pointer planeGeometry = PlaneGeometry::New();
planeGeometry->InitializeStandardPlane(aGeometry3D);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, (unsigned int)(aGeometry3D->GetExtent(2)));
}
}
assert(slicedGeometry.IsNotNull());
timeSlicedGeometry = TimeSlicedGeometry::New();
timeSlicedGeometry->InitializeEvenlyTimed(slicedGeometry, 1);
}
Superclass::SetGeometry(timeSlicedGeometry);
}
else
{
if(GetGeometry()==NULL)
return;
Superclass::SetGeometry(NULL);
}
}
void mitk::SlicedData::SetSpacing(const float aSpacing[3])
{
this->SetSpacing((mitk::Vector3D)aSpacing);
}
void mitk::SlicedData::SetOrigin(const mitk::Point3D& origin)
{
mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
assert(timeSlicedGeometry!=NULL);
mitk::SlicedGeometry3D* slicedGeometry;
unsigned int steps = timeSlicedGeometry->GetTimeSteps();
for(unsigned int timestep = 0; timestep < steps; ++timestep)
{
slicedGeometry = GetSlicedGeometry(timestep);
if(slicedGeometry != NULL)
{
slicedGeometry->SetOrigin(origin);
if(slicedGeometry->GetEvenlySpaced())
{
mitk::Geometry2D* geometry2D = slicedGeometry->GetGeometry2D(0);
geometry2D->SetOrigin(origin);
slicedGeometry->InitializeEvenlySpaced(geometry2D, slicedGeometry->GetSlices());
}
}
if(GetTimeSlicedGeometry()->GetEvenlyTimed())
{
GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, steps);
break;
}
}
}
void mitk::SlicedData::SetSpacing(mitk::Vector3D aSpacing)
{
mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
assert(timeSlicedGeometry!=NULL);
mitk::SlicedGeometry3D* slicedGeometry;
unsigned int steps = timeSlicedGeometry->GetTimeSteps();
for(unsigned int timestep = 0; timestep < steps; ++timestep)
{
slicedGeometry = GetSlicedGeometry(timestep);
if(slicedGeometry != NULL)
{
slicedGeometry->SetSpacing(aSpacing);
}
if(GetTimeSlicedGeometry()->GetEvenlyTimed())
{
GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, steps);
break;
}
}
}
diff --git a/Core/Code/DataManagement/mitkSlicedData.h b/Core/Code/DataManagement/mitkSlicedData.h
index ddc798c589..0c26d36471 100644
--- a/Core/Code/DataManagement/mitkSlicedData.h
+++ b/Core/Code/DataManagement/mitkSlicedData.h
@@ -1,222 +1,222 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef SLICEDDATA_H_HEADER_INCLUDED
#define SLICEDDATA_H_HEADER_INCLUDED
#include <MitkExports.h>
#include "mitkBaseData.h"
#include "mitkTimeSlicedGeometry.h"
#include "mitkSlicedGeometry3D.h"
#include "itkIndex.h"
#include "itkOffset.h"
#include "itkSize.h"
#include "itkImageRegion.h"
namespace mitk {
class SlicedGeometry3D;
//##Documentation
//## @brief Super class of data objects consisting of slices
//##
//## Super class of data objects consisting of slices, e.g., images or a stack
//## of contours. (GetGeometry will return a Geometry3D containing Geometry2D
//## objects).
//##
//## SlicedData-objects have geometries of type SlicedGeometry3D or sub-classes.
//## @ingroup Data
class MITK_CORE_EXPORT SlicedData : public BaseData
{
public:
mitkClassMacro(SlicedData, BaseData);
itkStaticConstMacro(RegionDimension, unsigned int, 5);
/** Region typedef support. A region is used to specify a subset of a @a SlicedData. */
typedef itk::ImageRegion<RegionDimension> RegionType;
/** Index typedef support. An index is used to access pixel values. */
typedef itk::Index<RegionDimension> IndexType;
typedef IndexType::IndexValueType IndexValueType;
/** Offset typedef support. An offset represent relative position
* between indices. */
typedef itk::Offset<RegionDimension> OffsetType;
typedef OffsetType::OffsetValueType OffsetValueType;
/** Size typedef support. A size is used to define region bounds. */
typedef itk::Size<RegionDimension> SizeType;
typedef SizeType::SizeValueType SizeValueType;
//##Documentation
//## Update the information for this DataObject so that it can be used as
//## an output of a ProcessObject. This method is used in the pipeline
//## mechanism to propagate information and initialize the meta data
//## associated with a itk::DataObject. Any implementation of this method
//## in a derived class of itk::DataObject is assumed to call its source's
//## ProcessObject::UpdateOutputInformation() which determines modified
//## times, LargestPossibleRegions, and any extra meta data like spacing,
//## origin, etc.
virtual void UpdateOutputInformation();
virtual void PrepareForNewData();
//##Documentation
//## Set the RequestedRegion to the LargestPossibleRegion. This forces a
//## filter to produce all of the output in one execution (i.e. not
//## streaming) on the next call to Update().
virtual void SetRequestedRegionToLargestPossibleRegion();
//##Documentation
//## Determine whether the RequestedRegion is outside of the
//## BufferedRegion. This method returns true if the RequestedRegion is
//## outside the BufferedRegion (true if at least one pixel is outside).
//## This is used by the pipeline mechanism to determine whether a filter
//## needs to re-execute in order to satisfy the current request. If the
//## current RequestedRegion is already inside the BufferedRegion from the
//## previous execution (and the current filter is up to date), then a
//## given filter does not need to re-execute
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
//##Documentation
//## @brief Verify that the RequestedRegion is within the
//## LargestPossibleRegion.
//##
//## Verify that the RequestedRegion is within the LargestPossibleRegion.
//## If the RequestedRegion is not within the LargestPossibleRegion,
//## then the filter cannot possibly satisfy the request. This method
//## returns true if the request can be satisfied (even if it will be
//## necessary to process the entire LargestPossibleRegion) and
//## returns false otherwise. This method is used by
//## PropagateRequestedRegion(). PropagateRequestedRegion() throws a
//## InvalidRequestedRegionError exception if the requested region is
//## not within the LargestPossibleRegion.
virtual bool VerifyRequestedRegion();
//##Documentation
//## Set the requested region from this data object to match the requested
//## region of the data object passed in as a parameter. This method is
//## implemented in the concrete subclasses of DataObject.
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion( const itk::DataObject *data);
//##Documentation
//## Set the requested region from this data object to match the requested
//## region of the data object passed in as a parameter. This method is
//## implemented in the concrete subclasses of DataObject.
virtual void SetRequestedRegion(SlicedData::RegionType *region);
const RegionType& GetLargestPossibleRegion() const
{
return m_LargestPossibleRegion;
}
//##Documentation
//## Get the region object that defines the size and starting index
//## for the region of the image requested (i.e., the region of the
//## image to be operated on by a filter).
virtual const RegionType& GetRequestedRegion() const
{
return m_RequestedRegion;
}
virtual bool IsSliceSet(int s = 0, int t = 0, int n = 0) const = 0;
virtual bool IsVolumeSet(int t = 0, int n = 0) const = 0;
virtual bool IsChannelSet(int n = 0) const = 0;
virtual void CopyInformation(const itk::DataObject *data);
//##Documentation
//## @brief Get the number of channels
unsigned int GetNumberOfChannels() const
{
return m_LargestPossibleRegion.GetSize(4);
}
////##Documentation
////## @brief Return the Geometry2D of the slice (@a s, @a t).
////##
////## The method does not simply call GetGeometry()->GetGeometry2D(). Before doing this, it
////## makes sure that the Geometry2D is up-to-date before returning it (by
////## setting the update extent appropriately and calling
////## UpdateOutputInformation).
////##
////## @warning GetGeometry2D not yet completely implemented.
////## @todo Appropriate setting of the update extent is missing.
//virtual const mitk::Geometry2D* GetGeometry2D(int s, int t=0) const;
//##Documentation
//## @brief Convenience access method for the geometry, which is of type SlicedGeometry3D (or a sub-class of it).
//##
//## @em No update will be called. Normally used in GenerateOutputInformation of
//## subclasses of BaseProcess.
SlicedGeometry3D* GetSlicedGeometry(unsigned int t=0) const;
//##Documentation
//## @brief Convenience access method for the geometry, which is of type SlicedGeometry3D (or a sub-class of it).
//##
//## The method does not simply return the value of the m_Geometry3D member.
//## Before doing this, it makes sure that the Geometry3D is up-to-date before
//## returning it (by setting the update extent appropriately and calling
//## UpdateOutputInformation).
//##
//## @warning GetGeometry not yet completely implemented.
//## @todo Appropriate setting of the update extent is missing.
const SlicedGeometry3D* GetUpdatedSlicedGeometry(unsigned int t=0);
//##Documentation
//## @brief Set the Geometry3D of the data, which will be referenced (not copied!). It
//## has to be a sub-class of SlicedGeometry3D.
//##
//## @warning This method will normally be called internally by the sub-class of SlicedData
//## during initialization.
virtual void SetGeometry(Geometry3D* aGeometry3D);
//##Documentation
//## @brief Convenience method for setting the origin of
//## the SlicedGeometry3D instances of all time steps
//##
//## In case the SlicedGeometry3D is evenly spaced,
//## the origin of the first slice is set to \a origin.
//## \sa mitk::BaseData::SetOrigin
virtual void SetOrigin(const Point3D& origin);
//##Documentation
//## @brief Convenience method for setting the spacing of
//## the SlicedGeometry3D instances of all time steps
virtual void SetSpacing(const float aSpacing[3]);
//##Documentation
//## @brief Convenience method for setting the spacing of
//## the SlicedGeometry3D instances of all time steps
virtual void SetSpacing(mitk::Vector3D aSpacing);
protected:
SlicedData();
SlicedData(const SlicedData &other);
virtual ~SlicedData();
RegionType m_LargestPossibleRegion;
RegionType m_RequestedRegion;
RegionType m_BufferedRegion;
bool m_UseLargestPossibleRegion;
};
} // namespace mitk
#endif /* SLICEDDATA_H_HEADER_INCLUDED */
diff --git a/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp b/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
index ae8fdd38a6..a75aa54fde 100644
--- a/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
+++ b/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
@@ -1,1026 +1,1025 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSlicedGeometry3D.h"
#include "mitkPlaneGeometry.h"
#include "mitkRotationOperation.h"
#include "mitkPlaneOperation.h"
#include "mitkRestorePlanePositionOperation.h"
#include "mitkInteractionConst.h"
#include "mitkSliceNavigationController.h"
const float PI = 3.14159265359;
mitk::SlicedGeometry3D::SlicedGeometry3D()
: m_EvenlySpaced( true ),
m_Slices( 0 ),
m_ReferenceGeometry( NULL ),
m_SliceNavigationController( NULL )
{
m_DirectionVector.Fill(0);
this->InitializeSlicedGeometry( m_Slices );
}
mitk::SlicedGeometry3D::SlicedGeometry3D(const SlicedGeometry3D& other)
: Superclass(other),
m_EvenlySpaced( other.m_EvenlySpaced ),
m_Slices( other.m_Slices ),
m_ReferenceGeometry( other.m_ReferenceGeometry ),
m_SliceNavigationController( other.m_SliceNavigationController )
{
m_DirectionVector.Fill(0);
SetSpacing( other.GetSpacing() );
SetDirectionVector( other.GetDirectionVector() );
if ( m_EvenlySpaced )
{
- AffineGeometryFrame3D::Pointer geometry = other.m_Geometry2Ds[0]->Clone();
+ Geometry2D::Pointer geometry = other.m_Geometry2Ds[0]->Clone();
Geometry2D* geometry2D = dynamic_cast<Geometry2D*>(geometry.GetPointer());
assert(geometry2D!=NULL);
SetGeometry2D(geometry2D, 0);
}
else
{
unsigned int s;
for ( s = 0; s < other.m_Slices; ++s )
{
if ( other.m_Geometry2Ds[s].IsNull() )
{
assert(other.m_EvenlySpaced);
m_Geometry2Ds[s] = NULL;
}
else
{
- AffineGeometryFrame3D::Pointer geometry = other.m_Geometry2Ds[s]->Clone();
- Geometry2D* geometry2D = dynamic_cast<Geometry2D*>(geometry.GetPointer());
+ Geometry2D* geometry2D = other.m_Geometry2Ds[0]->Clone();
assert(geometry2D!=NULL);
SetGeometry2D(geometry2D, s);
}
}
}
}
mitk::SlicedGeometry3D::~SlicedGeometry3D()
{
}
mitk::Geometry2D *
mitk::SlicedGeometry3D::GetGeometry2D( int s ) const
{
mitk::Geometry2D::Pointer geometry2D = NULL;
if ( this->IsValidSlice(s) )
{
geometry2D = m_Geometry2Ds[s];
// If (a) m_EvenlySpaced==true, (b) we don't have a Geometry2D stored
// for the requested slice, and (c) the first slice (s=0)
// is a PlaneGeometry instance, then we calculate the geometry of the
// requested as the plane of the first slice shifted by m_Spacing[2]*s
// in the direction of m_DirectionVector.
if ( (m_EvenlySpaced) && (geometry2D.IsNull()) )
{
PlaneGeometry *firstSlice = dynamic_cast< PlaneGeometry * > (
m_Geometry2Ds[0].GetPointer() );
if ( firstSlice != NULL )
{
if ( (m_DirectionVector[0] == 0.0)
&& (m_DirectionVector[1] == 0.0)
&& (m_DirectionVector[2] == 0.0) )
{
m_DirectionVector = firstSlice->GetNormal();
m_DirectionVector.Normalize();
}
Vector3D direction;
direction = m_DirectionVector * m_Spacing[2];
mitk::PlaneGeometry::Pointer requestedslice;
requestedslice = static_cast< mitk::PlaneGeometry * >(
firstSlice->Clone().GetPointer() );
requestedslice->SetOrigin(
requestedslice->GetOrigin() + direction * s );
geometry2D = requestedslice;
m_Geometry2Ds[s] = geometry2D;
}
}
return geometry2D;
}
else
{
return NULL;
}
}
const mitk::BoundingBox *
mitk::SlicedGeometry3D::GetBoundingBox() const
{
assert(m_BoundingBox.IsNotNull());
return m_BoundingBox.GetPointer();
}
bool
mitk::SlicedGeometry3D::SetGeometry2D( mitk::Geometry2D *geometry2D, int s )
{
if ( this->IsValidSlice(s) )
{
m_Geometry2Ds[s] = geometry2D;
m_Geometry2Ds[s]->SetReferenceGeometry( m_ReferenceGeometry );
return true;
}
return false;
}
void
mitk::SlicedGeometry3D::InitializeSlicedGeometry( unsigned int slices )
{
Superclass::Initialize();
m_Slices = slices;
Geometry2D::Pointer gnull = NULL;
m_Geometry2Ds.assign( m_Slices, gnull );
Vector3D spacing;
spacing.Fill( 1.0 );
this->SetSpacing( spacing );
m_DirectionVector.Fill( 0 );
}
void
mitk::SlicedGeometry3D::InitializeEvenlySpaced(
mitk::Geometry2D* geometry2D, unsigned int slices, bool flipped )
{
assert( geometry2D != NULL );
this->InitializeEvenlySpaced(
geometry2D, geometry2D->GetExtentInMM(2)/geometry2D->GetExtent(2),
slices, flipped );
}
void
mitk::SlicedGeometry3D::InitializeEvenlySpaced(
mitk::Geometry2D* geometry2D, mitk::ScalarType zSpacing,
unsigned int slices, bool flipped )
{
assert( geometry2D != NULL );
assert( geometry2D->GetExtent(0) > 0 );
assert( geometry2D->GetExtent(1) > 0 );
geometry2D->Register();
Superclass::Initialize();
m_Slices = slices;
BoundingBox::BoundsArrayType bounds = geometry2D->GetBounds();
bounds[4] = 0;
bounds[5] = slices;
// clear and reserve
Geometry2D::Pointer gnull = NULL;
m_Geometry2Ds.assign( m_Slices, gnull );
Vector3D directionVector = geometry2D->GetAxisVector(2);
directionVector.Normalize();
directionVector *= zSpacing;
if ( flipped == false )
{
// Normally we should use the following four lines to create a copy of
// the transform contrained in geometry2D, because it may not be changed
// by us. But we know that SetSpacing creates a new transform without
// changing the old (coming from geometry2D), so we can use the fifth
// line instead. We check this at (**).
//
// AffineTransform3D::Pointer transform = AffineTransform3D::New();
// transform->SetMatrix(geometry2D->GetIndexToWorldTransform()->GetMatrix());
// transform->SetOffset(geometry2D->GetIndexToWorldTransform()->GetOffset());
// SetIndexToWorldTransform(transform);
m_IndexToWorldTransform = const_cast< AffineTransform3D * >(
geometry2D->GetIndexToWorldTransform() );
}
else
{
directionVector *= -1.0;
m_IndexToWorldTransform = AffineTransform3D::New();
m_IndexToWorldTransform->SetMatrix(
geometry2D->GetIndexToWorldTransform()->GetMatrix() );
AffineTransform3D::OutputVectorType scaleVector;
FillVector3D(scaleVector, 1.0, 1.0, -1.0);
m_IndexToWorldTransform->Scale(scaleVector, true);
m_IndexToWorldTransform->SetOffset(
geometry2D->GetIndexToWorldTransform()->GetOffset() );
}
mitk::Vector3D spacing;
FillVector3D( spacing,
geometry2D->GetExtentInMM(0) / bounds[1],
geometry2D->GetExtentInMM(1) / bounds[3],
zSpacing );
// Ensure that spacing differs from m_Spacing to make SetSpacing change the
// matrix.
m_Spacing[2] = zSpacing - 1;
this->SetDirectionVector( directionVector );
this->SetBounds( bounds );
this->SetGeometry2D( geometry2D, 0 );
this->SetSpacing( spacing );
this->SetEvenlySpaced();
this->SetTimeBounds( geometry2D->GetTimeBounds() );
assert(m_IndexToWorldTransform.GetPointer()
!= geometry2D->GetIndexToWorldTransform()); // (**) see above.
this->SetFrameOfReferenceID( geometry2D->GetFrameOfReferenceID() );
this->SetImageGeometry( geometry2D->GetImageGeometry() );
geometry2D->UnRegister();
}
void
mitk::SlicedGeometry3D::InitializePlanes(
const mitk::Geometry3D *geometry3D,
mitk::PlaneGeometry::PlaneOrientation planeorientation,
bool top, bool frontside, bool rotated )
{
m_ReferenceGeometry = const_cast< Geometry3D * >( geometry3D );
PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
planeGeometry->InitializeStandardPlane(
geometry3D, top, planeorientation, frontside, rotated );
ScalarType viewSpacing = 1;
unsigned int slices = 1;
switch ( planeorientation )
{
case PlaneGeometry::Axial:
viewSpacing = geometry3D->GetSpacing()[2];
slices = (unsigned int) geometry3D->GetExtent( 2 );
break;
case PlaneGeometry::Frontal:
viewSpacing = geometry3D->GetSpacing()[1];
slices = (unsigned int) geometry3D->GetExtent( 1 );
break;
case PlaneGeometry::Sagittal:
viewSpacing = geometry3D->GetSpacing()[0];
slices = (unsigned int) geometry3D->GetExtent( 0 );
break;
default:
itkExceptionMacro("unknown PlaneOrientation");
}
mitk::Vector3D normal = this->AdjustNormal( planeGeometry->GetNormal() );
ScalarType directedExtent =
std::abs( m_ReferenceGeometry->GetExtentInMM( 0 ) * normal[0] )
+ std::abs( m_ReferenceGeometry->GetExtentInMM( 1 ) * normal[1] )
+ std::abs( m_ReferenceGeometry->GetExtentInMM( 2 ) * normal[2] );
if ( directedExtent >= viewSpacing )
{
slices = static_cast< int >(directedExtent / viewSpacing + 0.5);
}
else
{
slices = 1;
}
bool flipped = (top == false);
if ( frontside == false )
{
flipped = !flipped;
}
if ( planeorientation == PlaneGeometry::Frontal )
{
flipped = !flipped;
}
this->InitializeEvenlySpaced( planeGeometry, viewSpacing, slices, flipped );
}
void
mitk::SlicedGeometry3D
::ReinitializePlanes( const Point3D &center, const Point3D &referencePoint )
{
// Need a reference frame to align the rotated planes
if ( !m_ReferenceGeometry )
{
return;
}
// Get first plane of plane stack
PlaneGeometry *firstPlane =
dynamic_cast< PlaneGeometry * >( m_Geometry2Ds[0].GetPointer() );
// If plane stack is empty, exit
if ( firstPlane == NULL )
{
return;
}
// Calculate the "directed" spacing when taking the plane (defined by its axes
// vectors and normal) as the reference coordinate frame.
//
// This is done by calculating the radius of the ellipsoid defined by the
// original volume spacing axes, in the direction of the respective axis of the
// reference frame.
mitk::Vector3D axis0 = firstPlane->GetAxisVector(0);
mitk::Vector3D axis1 = firstPlane->GetAxisVector(1);
mitk::Vector3D normal = firstPlane->GetNormal();
normal.Normalize();
Vector3D spacing;
spacing[0] = this->CalculateSpacing( axis0 );
spacing[1] = this->CalculateSpacing( axis1 );
spacing[2] = this->CalculateSpacing( normal );
Superclass::SetSpacing( spacing );
// Now we need to calculate the number of slices in the plane's normal
// direction, so that the entire volume is covered. This is done by first
// calculating the dot product between the volume diagonal (the maximum
// distance inside the volume) and the normal, and dividing this value by
// the directed spacing calculated above.
ScalarType directedExtent =
std::abs( m_ReferenceGeometry->GetExtentInMM( 0 ) * normal[0] )
+ std::abs( m_ReferenceGeometry->GetExtentInMM( 1 ) * normal[1] )
+ std::abs( m_ReferenceGeometry->GetExtentInMM( 2 ) * normal[2] );
if ( directedExtent >= spacing[2] )
{
m_Slices = static_cast< unsigned int >(directedExtent / spacing[2] + 0.5);
}
else
{
m_Slices = 1;
}
// The origin of our "first plane" needs to be adapted to this new extent.
// To achieve this, we first calculate the current distance to the volume's
// center, and then shift the origin in the direction of the normal by the
// difference between this distance and half of the new extent.
double centerOfRotationDistance =
firstPlane->SignedDistanceFromPlane( center );
if ( centerOfRotationDistance > 0 )
{
firstPlane->SetOrigin( firstPlane->GetOrigin()
+ normal * (centerOfRotationDistance - directedExtent / 2.0)
);
m_DirectionVector = normal;
}
else
{
firstPlane->SetOrigin( firstPlane->GetOrigin()
+ normal * (directedExtent / 2.0 + centerOfRotationDistance)
);
m_DirectionVector = -normal;
}
// Now we adjust this distance according with respect to the given reference
// point: we need to make sure that the point is touched by one slice of the
// new slice stack.
double referencePointDistance =
firstPlane->SignedDistanceFromPlane( referencePoint );
int referencePointSlice = static_cast< int >(
referencePointDistance / spacing[2]);
double alignmentValue =
referencePointDistance / spacing[2] - referencePointSlice;
firstPlane->SetOrigin(
firstPlane->GetOrigin() + normal * alignmentValue * spacing[2] );
// Finally, we can clear the previous geometry stack and initialize it with
// our re-initialized "first plane".
m_Geometry2Ds.assign( m_Slices, Geometry2D::Pointer( NULL ) );
if ( m_Slices > 0 )
{
m_Geometry2Ds[0] = firstPlane;
}
// Reinitialize SNC with new number of slices
m_SliceNavigationController->GetSlice()->SetSteps( m_Slices );
this->Modified();
}
double
mitk::SlicedGeometry3D::CalculateSpacing( const mitk::Vector3D &d ) const
{
// Need the spacing of the underlying dataset / geometry
if ( !m_ReferenceGeometry )
{
return 1.0;
}
const mitk::Vector3D &spacing = m_ReferenceGeometry->GetSpacing();
return SlicedGeometry3D::CalculateSpacing( spacing, d );
}
double mitk::SlicedGeometry3D::CalculateSpacing( const mitk::Vector3D spacing, const mitk::Vector3D &d )
{
// The following can be derived from the ellipsoid equation
//
// 1 = x^2/a^2 + y^2/b^2 + z^2/c^2
//
// where (a,b,c) = spacing of original volume (ellipsoid radii)
// and (x,y,z) = scaled coordinates of vector d (according to ellipsoid)
//
double scaling = d[0]*d[0] / (spacing[0] * spacing[0])
+ d[1]*d[1] / (spacing[1] * spacing[1])
+ d[2]*d[2] / (spacing[2] * spacing[2]);
scaling = sqrt( scaling );
return ( sqrt( d[0]*d[0] + d[1]*d[1] + d[2]*d[2] ) / scaling );
}
mitk::Vector3D
mitk::SlicedGeometry3D::AdjustNormal( const mitk::Vector3D &normal ) const
{
Geometry3D::TransformType::Pointer inverse = Geometry3D::TransformType::New();
m_ReferenceGeometry->GetIndexToWorldTransform()->GetInverse( inverse );
Vector3D transformedNormal = inverse->TransformVector( normal );
transformedNormal.Normalize();
return transformedNormal;
}
void
mitk::SlicedGeometry3D::SetImageGeometry( const bool isAnImageGeometry )
{
Superclass::SetImageGeometry( isAnImageGeometry );
mitk::Geometry3D* geometry;
unsigned int s;
for ( s = 0; s < m_Slices; ++s )
{
geometry = m_Geometry2Ds[s];
if ( geometry!=NULL )
{
geometry->SetImageGeometry( isAnImageGeometry );
}
}
}
void
mitk::SlicedGeometry3D::ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry )
{
mitk::Geometry3D* geometry;
unsigned int s;
for ( s = 0; s < m_Slices; ++s )
{
geometry = m_Geometry2Ds[s];
if ( geometry!=NULL )
{
geometry->ChangeImageGeometryConsideringOriginOffset( isAnImageGeometry );
}
}
Superclass::ChangeImageGeometryConsideringOriginOffset( isAnImageGeometry );
}
bool
mitk::SlicedGeometry3D::IsValidSlice( int s ) const
{
return ((s >= 0) && (s < (int)m_Slices));
}
void
mitk::SlicedGeometry3D::SetReferenceGeometry( Geometry3D *referenceGeometry )
{
m_ReferenceGeometry = referenceGeometry;
std::vector<Geometry2D::Pointer>::iterator it;
for ( it = m_Geometry2Ds.begin(); it != m_Geometry2Ds.end(); ++it )
{
(*it)->SetReferenceGeometry( referenceGeometry );
}
}
void
mitk::SlicedGeometry3D::SetSpacing( const mitk::Vector3D &aSpacing )
{
bool hasEvenlySpacedPlaneGeometry = false;
mitk::Point3D origin;
mitk::Vector3D rightDV, bottomDV;
BoundingBox::BoundsArrayType bounds;
assert(aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0);
// In case of evenly-spaced data: re-initialize instances of Geometry2D,
// since the spacing influences them
if ((m_EvenlySpaced) && (m_Geometry2Ds.size() > 0))
{
mitk::Geometry2D::ConstPointer firstGeometry =
m_Geometry2Ds[0].GetPointer();
const PlaneGeometry *planeGeometry =
dynamic_cast< const PlaneGeometry * >( firstGeometry.GetPointer() );
if (planeGeometry != NULL )
{
this->WorldToIndex( planeGeometry->GetOrigin(), origin );
this->WorldToIndex( planeGeometry->GetAxisVector(0), rightDV );
this->WorldToIndex( planeGeometry->GetAxisVector(1), bottomDV );
bounds = planeGeometry->GetBounds();
hasEvenlySpacedPlaneGeometry = true;
}
}
Superclass::SetSpacing(aSpacing);
mitk::Geometry2D::Pointer firstGeometry;
// In case of evenly-spaced data: re-initialize instances of Geometry2D,
// since the spacing influences them
if ( hasEvenlySpacedPlaneGeometry )
{
//create planeGeometry according to new spacing
this->IndexToWorld( origin, origin );
this->IndexToWorld( rightDV, rightDV );
this->IndexToWorld( bottomDV, bottomDV );
mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
planeGeometry->SetImageGeometry( this->GetImageGeometry() );
planeGeometry->SetReferenceGeometry( m_ReferenceGeometry );
planeGeometry->InitializeStandardPlane(
- rightDV.Get_vnl_vector(), bottomDV.Get_vnl_vector(), &m_Spacing );
+ rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &m_Spacing );
planeGeometry->SetOrigin(origin);
planeGeometry->SetBounds(bounds);
firstGeometry = planeGeometry;
}
else if ( (m_EvenlySpaced) && (m_Geometry2Ds.size() > 0) )
{
firstGeometry = m_Geometry2Ds[0].GetPointer();
}
//clear and reserve
Geometry2D::Pointer gnull=NULL;
m_Geometry2Ds.assign(m_Slices, gnull);
if ( m_Slices > 0 )
{
m_Geometry2Ds[0] = firstGeometry;
}
this->Modified();
}
void
mitk::SlicedGeometry3D
::SetSliceNavigationController( SliceNavigationController *snc )
{
m_SliceNavigationController = snc;
}
mitk::SliceNavigationController *
mitk::SlicedGeometry3D::GetSliceNavigationController()
{
return m_SliceNavigationController;
}
void
mitk::SlicedGeometry3D::SetEvenlySpaced(bool on)
{
if(m_EvenlySpaced!=on)
{
m_EvenlySpaced=on;
this->Modified();
}
}
void
mitk::SlicedGeometry3D
::SetDirectionVector( const mitk::Vector3D& directionVector )
{
Vector3D newDir = directionVector;
newDir.Normalize();
if ( newDir != m_DirectionVector )
{
m_DirectionVector = newDir;
this->Modified();
}
}
void
mitk::SlicedGeometry3D::SetTimeBounds( const mitk::TimeBounds& timebounds )
{
Superclass::SetTimeBounds( timebounds );
unsigned int s;
for ( s = 0; s < m_Slices; ++s )
{
if(m_Geometry2Ds[s].IsNotNull())
{
m_Geometry2Ds[s]->SetTimeBounds( timebounds );
}
}
m_TimeBounds = timebounds;
}
-mitk::AffineGeometryFrame3D::Pointer
-mitk::SlicedGeometry3D::Clone() const
+itk::LightObject::Pointer
+mitk::SlicedGeometry3D::InternalClone() const
{
Self::Pointer newGeometry = new SlicedGeometry3D(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
void
mitk::SlicedGeometry3D::PrintSelf( std::ostream& os, itk::Indent indent ) const
{
Superclass::PrintSelf(os,indent);
os << indent << " EvenlySpaced: " << m_EvenlySpaced << std::endl;
if ( m_EvenlySpaced )
{
os << indent << " DirectionVector: " << m_DirectionVector << std::endl;
}
os << indent << " Slices: " << m_Slices << std::endl;
os << std::endl;
os << indent << " GetGeometry2D(0): ";
if ( this->GetGeometry2D(0) == NULL )
{
os << "NULL" << std::endl;
}
else
{
this->GetGeometry2D(0)->Print(os, indent);
}
}
void
mitk::SlicedGeometry3D::ExecuteOperation(Operation* operation)
{
switch ( operation->GetOperationType() )
{
case OpNOTHING:
break;
case OpROTATE:
if ( m_EvenlySpaced )
{
// Need a reference frame to align the rotation
if ( m_ReferenceGeometry )
{
// Clear all generated geometries and then rotate only the first slice.
// The other slices will be re-generated on demand
// Save first slice
Geometry2D::Pointer geometry2D = m_Geometry2Ds[0];
RotationOperation *rotOp = dynamic_cast< RotationOperation * >( operation );
// Generate a RotationOperation using the dataset center instead of
// the supplied rotation center. This is necessary so that the rotated
// zero-plane does not shift away. The supplied center is instead used
// to adjust the slice stack afterwards.
Point3D center = m_ReferenceGeometry->GetCenter();
RotationOperation centeredRotation(
rotOp->GetOperationType(),
center,
rotOp->GetVectorOfRotation(),
rotOp->GetAngleOfRotation()
);
// Rotate first slice
geometry2D->ExecuteOperation( &centeredRotation );
// Clear the slice stack and adjust it according to the center of
// the dataset and the supplied rotation center (see documentation of
// ReinitializePlanes)
this->ReinitializePlanes( center, rotOp->GetCenterOfRotation() );
geometry2D->SetSpacing(this->GetSpacing());
if ( m_SliceNavigationController )
{
m_SliceNavigationController->SelectSliceByPoint(
rotOp->GetCenterOfRotation() );
m_SliceNavigationController->AdjustSliceStepperRange();
}
Geometry3D::ExecuteOperation( &centeredRotation );
}
else
{
// we also have to consider the case, that there is no reference geometry available.
if ( m_Geometry2Ds.size() > 0 )
{
// Reach through to all slices in my container
for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
iter != m_Geometry2Ds.end();
++iter)
{
(*iter)->ExecuteOperation(operation);
}
// rotate overall geometry
RotationOperation *rotOp = dynamic_cast< RotationOperation * >( operation );
Geometry3D::ExecuteOperation( rotOp);
}
}
}
else
{
// Reach through to all slices
for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
iter != m_Geometry2Ds.end();
++iter)
{
(*iter)->ExecuteOperation(operation);
}
}
break;
case OpORIENT:
if ( m_EvenlySpaced )
{
// get operation data
PlaneOperation *planeOp = dynamic_cast< PlaneOperation * >( operation );
// Get first slice
Geometry2D::Pointer geometry2D = m_Geometry2Ds[0];
PlaneGeometry *planeGeometry = dynamic_cast< PlaneGeometry * >(
geometry2D.GetPointer() );
// Need a PlaneGeometry, a PlaneOperation and a reference frame to
// carry out the re-orientation. If not all avaialble, stop here
if ( !m_ReferenceGeometry || !planeGeometry || !planeOp )
{
break;
}
// General Behavior:
// Clear all generated geometries and then rotate only the first slice.
// The other slices will be re-generated on demand
//
// 1st Step: Reorient Normal Vector of first plane
//
Point3D center = planeOp->GetPoint(); //m_ReferenceGeometry->GetCenter();
mitk::Vector3D currentNormal = planeGeometry->GetNormal();
mitk::Vector3D newNormal;
if (planeOp->AreAxisDefined())
{
// If planeOp was defined by one centerpoint and two axis vectors
newNormal = CrossProduct(planeOp->GetAxisVec0(), planeOp->GetAxisVec1());
}
else
{
// If planeOp was defined by one centerpoint and one normal vector
newNormal = planeOp->GetNormal();
}
// Get Rotation axis und angle
currentNormal.Normalize();
newNormal.Normalize();
- float rotationAngle = angle(currentNormal.Get_vnl_vector(),newNormal.Get_vnl_vector());
+ float rotationAngle = angle(currentNormal.GetVnlVector(),newNormal.GetVnlVector());
rotationAngle *= 180.0 / vnl_math::pi; // from rad to deg
Vector3D rotationAxis = itk::CrossProduct( currentNormal, newNormal );
if (std::abs(rotationAngle-180) < mitk::eps )
{
// current Normal and desired normal are not linear independent!!(e.g 1,0,0 and -1,0,0).
// Rotation Axis should be ANY vector that is 90° to current Normal
mitk::Vector3D helpNormal;
helpNormal = currentNormal;
helpNormal[0] += 1;
helpNormal[1] -= 1;
helpNormal[2] += 1;
helpNormal.Normalize();
rotationAxis = itk::CrossProduct( helpNormal, currentNormal );
}
RotationOperation centeredRotation(
mitk::OpROTATE,
center,
rotationAxis,
rotationAngle
);
// Rotate first slice
geometry2D->ExecuteOperation( &centeredRotation );
// Reinitialize planes and select slice, if my rotations are all done.
if (!planeOp->AreAxisDefined())
{
// Clear the slice stack and adjust it according to the center of
// rotation and plane position (see documentation of ReinitializePlanes)
this->ReinitializePlanes( center, planeOp->GetPoint() );
if ( m_SliceNavigationController )
{
m_SliceNavigationController->SelectSliceByPoint( planeOp->GetPoint() );
m_SliceNavigationController->AdjustSliceStepperRange();
}
}
// Also apply rotation on the slicedGeometry - Geometry3D (Bounding geometry)
Geometry3D::ExecuteOperation( &centeredRotation );
//
// 2nd step. If axis vectors were defined, rotate the plane around its normal to fit these
//
if (planeOp->AreAxisDefined())
{
mitk::Vector3D vecAxixNew = planeOp->GetAxisVec0();
vecAxixNew.Normalize();
mitk::Vector3D VecAxisCurr = geometry2D->GetAxisVector(0);
VecAxisCurr.Normalize();
- float rotationAngle = angle(VecAxisCurr.Get_vnl_vector(),vecAxixNew.Get_vnl_vector());
+ float rotationAngle = angle(VecAxisCurr.GetVnlVector(),vecAxixNew.GetVnlVector());
rotationAngle = rotationAngle * 180 / PI; // Rad to Deg
// we rotate around the normal of the plane, but we do not know, if we need to rotate clockwise
// or anti-clockwise. So we rotate around the crossproduct of old and new Axisvector.
// Since both axis vectors lie in the plane, the crossproduct is the planes normal or the negative planes normal
rotationAxis = itk::CrossProduct( VecAxisCurr, vecAxixNew );
if (std::abs(rotationAngle-180) < mitk::eps )
{
// current axisVec and desired axisVec are not linear independent!!(e.g 1,0,0 and -1,0,0).
// Rotation Axis can be just plane Normal. (have to rotate by 180°)
rotationAxis = newNormal;
}
// Perfom Rotation
mitk::RotationOperation op(mitk::OpROTATE, center, rotationAxis, rotationAngle);
geometry2D->ExecuteOperation( &op );
// Apply changes on first slice to whole slice stack
this->ReinitializePlanes( center, planeOp->GetPoint() );
if ( m_SliceNavigationController )
{
m_SliceNavigationController->SelectSliceByPoint( planeOp->GetPoint() );
m_SliceNavigationController->AdjustSliceStepperRange();
}
// Also apply rotation on the slicedGeometry - Geometry3D (Bounding geometry)
Geometry3D::ExecuteOperation( &op );
}
}
else
{
// Reach through to all slices
for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
iter != m_Geometry2Ds.end();
++iter)
{
(*iter)->ExecuteOperation(operation);
}
}
break;
case OpRESTOREPLANEPOSITION:
if ( m_EvenlySpaced )
{
// Save first slice
Geometry2D::Pointer geometry2D = m_Geometry2Ds[0];
PlaneGeometry* planeGeometry = dynamic_cast< PlaneGeometry * >(
geometry2D.GetPointer() );
RestorePlanePositionOperation *restorePlaneOp = dynamic_cast< RestorePlanePositionOperation* >( operation );
// Need a PlaneGeometry, a PlaneOperation and a reference frame to
// carry out the re-orientation
if ( m_ReferenceGeometry && planeGeometry && restorePlaneOp )
{
// Clear all generated geometries and then rotate only the first slice.
// The other slices will be re-generated on demand
// Rotate first slice
geometry2D->ExecuteOperation( restorePlaneOp );
m_DirectionVector = restorePlaneOp->GetDirectionVector();
double centerOfRotationDistance =
planeGeometry->SignedDistanceFromPlane( m_ReferenceGeometry->GetCenter() );
if ( centerOfRotationDistance > 0 )
{
m_DirectionVector = m_DirectionVector;
}
else
{
m_DirectionVector = -m_DirectionVector;
}
Vector3D spacing = restorePlaneOp->GetSpacing();
Superclass::SetSpacing( spacing );
// /*Now we need to calculate the number of slices in the plane's normal
// direction, so that the entire volume is covered. This is done by first
// calculating the dot product between the volume diagonal (the maximum
// distance inside the volume) and the normal, and dividing this value by
// the directed spacing calculated above.*/
ScalarType directedExtent =
std::abs( m_ReferenceGeometry->GetExtentInMM( 0 ) * m_DirectionVector[0] )
+ std::abs( m_ReferenceGeometry->GetExtentInMM( 1 ) * m_DirectionVector[1] )
+ std::abs( m_ReferenceGeometry->GetExtentInMM( 2 ) * m_DirectionVector[2] );
if ( directedExtent >= spacing[2] )
{
m_Slices = static_cast< unsigned int >(directedExtent / spacing[2] + 0.5);
}
else
{
m_Slices = 1;
}
m_Geometry2Ds.assign( m_Slices, Geometry2D::Pointer( NULL ) );
if ( m_Slices > 0 )
{
m_Geometry2Ds[0] = geometry2D;
}
m_SliceNavigationController->GetSlice()->SetSteps( m_Slices );
this->Modified();
//End Reinitialization
if ( m_SliceNavigationController )
{
m_SliceNavigationController->GetSlice()->SetPos( restorePlaneOp->GetPos() );
m_SliceNavigationController->AdjustSliceStepperRange();
}
Geometry3D::ExecuteOperation(restorePlaneOp);
}
}
else
{
// Reach through to all slices
for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
iter != m_Geometry2Ds.end();
++iter)
{
(*iter)->ExecuteOperation(operation);
}
}
break;
}
this->Modified();
}
diff --git a/Core/Code/DataManagement/mitkSlicedGeometry3D.h b/Core/Code/DataManagement/mitkSlicedGeometry3D.h
index 4db57bb247..80fdc978cf 100644
--- a/Core/Code/DataManagement/mitkSlicedGeometry3D.h
+++ b/Core/Code/DataManagement/mitkSlicedGeometry3D.h
@@ -1,324 +1,324 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKSLICEDGEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
#define MITKSLICEDGEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
#include "mitkGeometry3D.h"
#include "mitkPlaneGeometry.h"
namespace mitk {
class SliceNavigationController;
class NavigationController;
/** \brief Describes the geometry of a data object consisting of slices.
*
* A Geometry2D can be requested for each slice. In the case of
* \em evenly-spaced, \em plane geometries (m_EvenlySpaced==true),
* only the 2D-geometry of the first slice has to be set (to an instance of
* PlaneGeometry). The 2D geometries of the other slices are calculated
* by shifting the first slice in the direction m_DirectionVector by
* m_Spacing.z * sliceNumber. The m_Spacing member (which is only
* relevant in the case m_EvenlySpaced==true) descibes the size of a voxel
* (in mm), i.e., m_Spacing.x is the voxel width in the x-direction of the
* plane. It is derived from the reference geometry of this SlicedGeometry3D,
* which usually would be the global geometry describing how datasets are to
* be resliced.
*
* By default, slices are oriented in the direction of one of the main axes
* (x, y, z). However, by means of rotation, it is possible to realign the
* slices in any possible direction. In case of an inclined plane, the spacing
* is derived as a product of the (regular) geometry spacing and the direction
* vector of the plane.
*
* SlicedGeometry3D and the associated Geometry2Ds have to be initialized in
* the method GenerateOutputInformation() of BaseProcess (or CopyInformation /
* UpdateOutputInformation of BaseData, if possible, e.g., by analyzing pic
* tags in Image) subclasses. See also
*
* \sa itk::ProcessObject::GenerateOutputInformation(),
* \sa itk::DataObject::CopyInformation() and
* \a itk::DataObject::UpdateOutputInformation().
*
* Rule: everything is in mm (or ms for temporal information) if not
* stated otherwise.
*
* \warning The hull (i.e., transform, bounding-box and
* time-bounds) is only guaranteed to be up-to-date after calling
* UpdateInformation().
*
* \ingroup Geometry
*/
class MITK_CORE_EXPORT SlicedGeometry3D : public mitk::Geometry3D
{
public:
mitkClassMacro(SlicedGeometry3D, Geometry3D);
/** Method for creation through the object factory. */
itkNewMacro(Self);
/**
* \brief Returns the Geometry2D of the slice (\a s).
*
* If (a) m_EvenlySpaced==true, (b) we don't have a Geometry2D stored
* for the requested slice, and (c) the first slice (s=0)
* is a PlaneGeometry instance, then we calculate the geometry of the
* requested as the plane of the first slice shifted by m_Spacing[3]*s
* in the direction of m_DirectionVector.
*
* \warning The Geometry2Ds are not necessarily up-to-date and not even
* initialized.
*
* The Geometry2Ds have to be initialized in the method
* GenerateOutputInformation() of BaseProcess (or CopyInformation /
* UpdateOutputInformation of BaseData, if possible, e.g., by analyzing
* pic tags in Image) subclasses. See also
*
* \sa itk::ProcessObject::GenerateOutputInformation(),
* \sa itk::DataObject::CopyInformation() and
* \sa itk::DataObject::UpdateOutputInformation().
*/
virtual mitk::Geometry2D* GetGeometry2D( int s ) const;
/**
* \brief Set Geometry2D of slice \a s.
*/
virtual bool SetGeometry2D( mitk::Geometry2D *geometry2D, int s );
//##Documentation
//## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
virtual void SetTimeBounds( const mitk::TimeBounds& timebounds );
virtual const mitk::BoundingBox* GetBoundingBox() const;
/**
* \brief Get the number of slices
*/
itkGetConstMacro( Slices, unsigned int );
/**
* \brief Check whether a slice exists
*/
virtual bool IsValidSlice( int s = 0 ) const;
virtual void SetReferenceGeometry( Geometry3D *referenceGeometry );
/**
* \brief Set the spacing (m_Spacing), in direction of the plane normal.
*
* INTERNAL METHOD.
*/
virtual void SetSpacing( const mitk::Vector3D &aSpacing );
/**
* \brief Set the SliceNavigationController corresponding to this sliced
* geometry.
*
* The SNC needs to be informed when the number of slices in the geometry
* changes, which can occur whenthe slices are re-oriented by rotation.
*/
virtual void SetSliceNavigationController(
mitk::SliceNavigationController *snc );
mitk::SliceNavigationController *GetSliceNavigationController();
/**
* \brief Set/Get whether the SlicedGeometry3D is evenly-spaced
* (m_EvenlySpaced)
*
* If (a) m_EvenlySpaced==true, (b) we don't have a Geometry2D stored for
* the requested slice, and (c) the first slice (s=0) is a PlaneGeometry
* instance, then we calculate the geometry of the requested as the plane
* of the first slice shifted by m_Spacing.z * s in the direction of
* m_DirectionVector.
*
* \sa GetGeometry2D
*/
itkGetConstMacro(EvenlySpaced, bool);
virtual void SetEvenlySpaced(bool on = true);
/**
* \brief Set/Get the vector between slices for the evenly-spaced case
* (m_EvenlySpaced==true).
*
* If the direction-vector is (0,0,0) (the default) and the first
* 2D geometry is a PlaneGeometry, then the direction-vector will be
* calculated from the plane normal.
*
* \sa m_DirectionVector
*/
virtual void SetDirectionVector(const mitk::Vector3D& directionVector);
itkGetConstMacro(DirectionVector, const mitk::Vector3D&);
- virtual AffineGeometryFrame3D::Pointer Clone() const;
+ virtual itk::LightObject::Pointer InternalClone() const;
static const std::string SLICES;
const static std::string DIRECTION_VECTOR;
const static std::string EVENLY_SPACED;
/**
* \brief Tell this instance how many Geometry2Ds it shall manage. Bounding
* box and the Geometry2Ds must be set additionally by calling the respective
* methods!
*
* \warning Bounding box and the 2D-geometries must be set additionally: use
* SetBounds(), SetGeometry().
*/
virtual void InitializeSlicedGeometry( unsigned int slices );
/**
* \brief Completely initialize this instance as evenly-spaced with slices
* parallel to the provided Geometry2D that is used as the first slice and
* for spacing calculation.
*
* Initializes the bounding box according to the width/height of the
* Geometry2D and \a slices. The spacing is calculated from the Geometry2D.
*/
virtual void InitializeEvenlySpaced( mitk::Geometry2D *geometry2D,
unsigned int slices, bool flipped=false );
/**
* \brief Completely initialize this instance as evenly-spaced with slices
* parallel to the provided Geometry2D that is used as the first slice and
* for spacing calculation (except z-spacing).
*
* Initializes the bounding box according to the width/height of the
* Geometry2D and \a slices. The x-/y-spacing is calculated from the
* Geometry2D.
*/
virtual void InitializeEvenlySpaced( mitk::Geometry2D *geometry2D,
mitk::ScalarType zSpacing, unsigned int slices, bool flipped=false );
/**
* \brief Completely initialize this instance as evenly-spaced plane slices
* parallel to a side of the provided Geometry3D and using its spacing
* information.
*
* Initializes the bounding box according to the width/height of the
* Geometry3D and the number of slices according to
* Geometry3D::GetExtent(2).
*
* \param planeorientation side parallel to which the slices will be oriented
* \param top if \a true, create plane at top, otherwise at bottom
* (for PlaneOrientation Axial, for other plane locations respectively)
* \param frontside defines the side of the plane (the definition of
* front/back is somewhat arbitrary)
*
* \param rotate rotates the plane by 180 degree around its normal (the
* definition of rotated vs not rotated is somewhat arbitrary)
*/
virtual void InitializePlanes( const mitk::Geometry3D *geometry3D,
mitk::PlaneGeometry::PlaneOrientation planeorientation, bool top=true,
bool frontside=true, bool rotated=false );
virtual void SetImageGeometry(const bool isAnImageGeometry);
virtual void ExecuteOperation(Operation* operation);
static double CalculateSpacing( const mitk::Vector3D spacing, const mitk::Vector3D &d );
protected:
SlicedGeometry3D();
SlicedGeometry3D(const SlicedGeometry3D& other);
virtual ~SlicedGeometry3D();
/**
* Reinitialize plane stack after rotation. More precisely, the first plane
* of the stack needs to spatially aligned, in two respects:
*
* 1. Re-alignment with respect to the dataset center; this is necessary
* since the distance from the first plane to the center could otherwise
* continuously decrease or increase.
* 2. Re-alignment with respect to a given reference point; the reference
* point is a location which the user wants to be exactly touched by one
* plane of the plane stack. The first plane is minimally shifted to
* ensure this touching. Usually, the reference point would be the
* point around which the geometry is rotated.
*/
virtual void ReinitializePlanes( const Point3D &center,
const Point3D &referencePoint );
ScalarType GetLargestExtent( const Geometry3D *geometry );
void PrintSelf(std::ostream& os, itk::Indent indent) const;
/** Calculate "directed spacing", i.e. the spacing in directions
* non-orthogonal to the coordinate axes. This is done via the
* ellipsoid equation.
*/
double CalculateSpacing( const mitk::Vector3D &direction ) const;
/** The extent of the slice stack, i.e. the number of slices, depends on the
* plane normal. For rotated geometries, the geometry's transform needs to
* be accounted in this calculation.
*/
mitk::Vector3D AdjustNormal( const mitk::Vector3D &normal ) const;
/**
* Container for the 2D-geometries contained within this SliceGeometry3D.
*/
mutable std::vector<Geometry2D::Pointer> m_Geometry2Ds;
/**
* If (a) m_EvenlySpaced==true, (b) we don't have a Geometry2D stored
* for the requested slice, and (c) the first slice (s=0)
* is a PlaneGeometry instance, then we calculate the geometry of the
* requested as the plane of the first slice shifted by m_Spacing.z*s
* in the direction of m_DirectionVector.
*
* \sa GetGeometry2D
*/
bool m_EvenlySpaced;
/**
* Vector between slices for the evenly-spaced case (m_EvenlySpaced==true).
* If the direction-vector is (0,0,0) (the default) and the first
* 2D geometry is a PlaneGeometry, then the direction-vector will be
* calculated from the plane normal.
*/
mutable mitk::Vector3D m_DirectionVector;
/** Number of slices this SliceGeometry3D is descibing. */
unsigned int m_Slices;
/** Underlying Geometry3D for this SlicedGeometry */
mitk::Geometry3D *m_ReferenceGeometry;
/** SNC correcsponding to this geometry; used to reflect changes in the
* number of slices due to rotation. */
//mitk::NavigationController *m_NavigationController;
mitk::SliceNavigationController *m_SliceNavigationController;
};
} // namespace mitk
#endif /* MITKSLICEDGEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkSmartPointerProperty.cpp b/Core/Code/DataManagement/mitkSmartPointerProperty.cpp
index d666cb4667..483f04a8c3 100644
--- a/Core/Code/DataManagement/mitkSmartPointerProperty.cpp
+++ b/Core/Code/DataManagement/mitkSmartPointerProperty.cpp
@@ -1,148 +1,142 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSmartPointerProperty.h"
mitk::SmartPointerProperty::ReferenceCountMapType mitk::SmartPointerProperty::m_ReferenceCount;
mitk::SmartPointerProperty::ReferencesUIDMapType mitk::SmartPointerProperty::m_ReferencesUID;
mitk::SmartPointerProperty::ReadInSmartPointersMapType mitk::SmartPointerProperty::m_ReadInInstances;
mitk::SmartPointerProperty::ReadInTargetsMapType mitk::SmartPointerProperty::m_ReadInTargets;
mitk::UIDGenerator mitk::SmartPointerProperty::m_UIDGenerator("POINTER_");
void mitk::SmartPointerProperty::PostProcessXMLReading()
{
for (ReadInSmartPointersMapType::iterator iter = m_ReadInInstances.begin();
iter != m_ReadInInstances.end();
++iter)
{
if ( m_ReadInTargets.find(iter->second) != m_ReadInTargets.end() )
{
iter->first->SetSmartPointer( m_ReadInTargets[ iter->second ] );
}
}
m_ReadInInstances.clear();
}
/// \return The number of SmartPointerProperties that point to @param object
unsigned int mitk::SmartPointerProperty::GetReferenceCountFor(itk::Object* object)
{
if ( m_ReferenceCount.find(object) != m_ReferenceCount.end() )
{
return m_ReferenceCount[object];
}
else
{
return 0;
}
}
void mitk::SmartPointerProperty::RegisterPointerTarget(itk::Object* object, const std::string uid)
{
m_ReadInTargets[uid] = object;
}
std::string mitk::SmartPointerProperty::GetReferenceUIDFor(itk::Object* object)
{
if ( m_ReferencesUID.find(object) != m_ReferencesUID.end() )
{
return m_ReferencesUID[object];
}
else
{
return std::string("invalid");
}
}
bool mitk::SmartPointerProperty::IsEqual(const BaseProperty& property) const
{
return this->m_SmartPointer == static_cast<const Self&>(property).m_SmartPointer;
}
bool mitk::SmartPointerProperty::Assign(const BaseProperty& property)
{
this->m_SmartPointer = static_cast<const Self&>(property).m_SmartPointer;
return true;
}
mitk::SmartPointerProperty::SmartPointerProperty(itk::Object* pointer)
{
SetSmartPointer( pointer );
}
mitk::SmartPointerProperty::SmartPointerProperty(const SmartPointerProperty& other)
: BaseProperty(other)
, m_SmartPointer(other.m_SmartPointer)
{
}
itk::Object::Pointer mitk::SmartPointerProperty::GetSmartPointer() const
{
return m_SmartPointer;
}
itk::Object::Pointer mitk::SmartPointerProperty::GetValue() const
{
return this->GetSmartPointer();
}
void mitk::SmartPointerProperty::SetSmartPointer(itk::Object* pointer)
{
if(m_SmartPointer.GetPointer() != pointer)
{
// keep track of referenced objects
if ( m_SmartPointer.GetPointer() && --m_ReferenceCount[m_SmartPointer.GetPointer()] == 0 ) // if there is no reference left, delete entry
{
m_ReferenceCount.erase( m_SmartPointer.GetPointer() );
m_ReferencesUID.erase( m_SmartPointer.GetPointer() );
}
if ( pointer && ++m_ReferenceCount[pointer] == 1 ) // first reference --> generate UID
{
m_ReferencesUID[pointer] = m_UIDGenerator.GetUID();
}
// change pointer
m_SmartPointer = pointer;
Modified();
}
}
void mitk::SmartPointerProperty::SetValue(const ValueType & value)
{
this->SetSmartPointer(value.GetPointer());
}
std::string mitk::SmartPointerProperty::GetValueAsString() const
{
if ( m_SmartPointer.IsNotNull() )
return m_ReferencesUID[ m_SmartPointer.GetPointer() ];
else
return std::string("NULL");
}
-mitk::SmartPointerProperty::Pointer mitk::SmartPointerProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::SmartPointerProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkSmartPointerProperty.h b/Core/Code/DataManagement/mitkSmartPointerProperty.h
index 20ac955bd7..75db26a07c 100644
--- a/Core/Code/DataManagement/mitkSmartPointerProperty.h
+++ b/Core/Code/DataManagement/mitkSmartPointerProperty.h
@@ -1,109 +1,107 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKSMARTPOINTERPROPERTY_H_HEADER_INCLUDED_C126B791
#define MITKSMARTPOINTERPROPERTY_H_HEADER_INCLUDED_C126B791
#include <MitkExports.h>
#include "mitkBaseProperty.h"
#include "mitkUIDGenerator.h"
#include<map>
#include<list>
#include<string>
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
//##Documentation
//## @brief Property containing a smart-pointer
//## @ingroup DataManagement
class MITK_CORE_EXPORT SmartPointerProperty : public BaseProperty
{
public:
mitkClassMacro(SmartPointerProperty, BaseProperty);
itkNewMacro(SmartPointerProperty);
mitkNewMacro1Param(SmartPointerProperty, itk::Object*);
typedef itk::Object::Pointer ValueType;
- Pointer Clone() const;
-
itk::Object::Pointer GetSmartPointer() const;
ValueType GetValue() const;
void SetSmartPointer(itk::Object*);
void SetValue(const ValueType&);
/// mainly for XML output
virtual std::string GetValueAsString() const;
static void PostProcessXMLReading();
/// Return the number of SmartPointerProperties that reference the object given as parameter
static unsigned int GetReferenceCountFor(itk::Object*);
static std::string GetReferenceUIDFor(itk::Object*);
static void RegisterPointerTarget(itk::Object*, const std::string uid);
using BaseProperty::operator=;
protected:
SmartPointerProperty(itk::Object* = NULL);
SmartPointerProperty(const SmartPointerProperty&);
itk::Object::Pointer m_SmartPointer;
private:
// purposely not implemented
SmartPointerProperty& operator=(const SmartPointerProperty&);
itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty&) const;
virtual bool Assign(const BaseProperty&);
typedef std::map<itk::Object*, unsigned int> ReferenceCountMapType;
typedef std::map<itk::Object*, std::string> ReferencesUIDMapType;
typedef std::map<SmartPointerProperty*, std::string> ReadInSmartPointersMapType;
typedef std::map<std::string, itk::Object*> ReadInTargetsMapType;
/// for each itk::Object* count how many SmartPointerProperties point to it
static ReferenceCountMapType m_ReferenceCount;
static ReferencesUIDMapType m_ReferencesUID;
static ReadInSmartPointersMapType m_ReadInInstances;
static ReadInTargetsMapType m_ReadInTargets;
/// to generate unique IDs for the objects pointed at (during XML writing)
static UIDGenerator m_UIDGenerator;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif /* MITKSMARTPOINTERPROPERTY_H_HEADER_INCLUDED_C126B791 */
diff --git a/Core/Code/DataManagement/mitkStringProperty.cpp b/Core/Code/DataManagement/mitkStringProperty.cpp
index d1fea19b12..98e5f08738 100644
--- a/Core/Code/DataManagement/mitkStringProperty.cpp
+++ b/Core/Code/DataManagement/mitkStringProperty.cpp
@@ -1,65 +1,59 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkStringProperty.h"
const char* mitk::StringProperty::PATH = "path";
mitk::StringProperty::StringProperty( const char* string )
: m_Value()
{
if ( string )
m_Value = string;
}
mitk::StringProperty::StringProperty( const std::string& s )
: m_Value( s )
{
}
mitk::StringProperty::StringProperty(const StringProperty& other)
: BaseProperty(other)
, m_Value(other.m_Value)
{
}
bool mitk::StringProperty::IsEqual(const BaseProperty& property ) const
{
return this->m_Value == static_cast<const Self&>(property).m_Value;
}
bool mitk::StringProperty::Assign(const BaseProperty& property )
{
this->m_Value = static_cast<const Self&>(property).m_Value;
return true;
}
std::string mitk::StringProperty::GetValueAsString() const
{
return m_Value;
}
-mitk::StringProperty::Pointer mitk::StringProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::StringProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkStringProperty.h b/Core/Code/DataManagement/mitkStringProperty.h
index 13586216c1..960839265e 100644
--- a/Core/Code/DataManagement/mitkStringProperty.h
+++ b/Core/Code/DataManagement/mitkStringProperty.h
@@ -1,85 +1,83 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKSTRINGPROPERTY_H_HEADER_INCLUDED_C1C02491
#define MITKSTRINGPROPERTY_H_HEADER_INCLUDED_C1C02491
#include <itkConfigure.h>
#include <MitkExports.h>
#include "mitkBaseProperty.h"
#include <string>
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* @brief Property for strings
* @ingroup DataManagement
*/
class MITK_CORE_EXPORT StringProperty : public BaseProperty
{
protected:
std::string m_Value;
StringProperty( const char* string = 0 );
StringProperty( const std::string& s );
StringProperty(const StringProperty&);
public:
mitkClassMacro(StringProperty, BaseProperty);
typedef std::string ValueType;
itkNewMacro(StringProperty);
mitkNewMacro1Param(StringProperty, const char*);
mitkNewMacro1Param(StringProperty, const std::string&)
- Pointer Clone() const;
-
itkGetStringMacro(Value);
itkSetStringMacro(Value);
virtual std::string GetValueAsString() const;
static const char* PATH;
using BaseProperty::operator=;
private:
// purposely not implemented
StringProperty& operator=(const StringProperty&);
itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty& property ) const;
virtual bool Assign(const BaseProperty& property );
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif
diff --git a/Core/Code/DataManagement/mitkSurface.cpp b/Core/Code/DataManagement/mitkSurface.cpp
index 24428d0980..81dfb66e43 100644
--- a/Core/Code/DataManagement/mitkSurface.cpp
+++ b/Core/Code/DataManagement/mitkSurface.cpp
@@ -1,386 +1,386 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSurface.h"
#include "mitkInteractionConst.h"
#include "mitkSurfaceOperation.h"
#include <algorithm>
#include <vtkPolyData.h>
static vtkPolyData* DeepCopy(vtkPolyData* other)
{
if (other == NULL)
return NULL;
vtkPolyData* copy = vtkPolyData::New();
copy->DeepCopy(other);
return copy;
}
static void Delete(vtkPolyData* polyData)
{
if (polyData != NULL)
polyData->Delete();
}
static void Update(vtkPolyData* polyData)
{
if (polyData != NULL)
polyData->Update();
}
mitk::Surface::Surface()
: m_CalculateBoundingBox(false)
{
this->InitializeEmpty();
}
mitk::Surface::Surface(const mitk::Surface& other)
: BaseData(other),
m_LargestPossibleRegion(other.m_LargestPossibleRegion),
m_RequestedRegion(other.m_RequestedRegion),
m_CalculateBoundingBox(other.m_CalculateBoundingBox)
{
if(!other.m_PolyDatas.empty())
{
m_PolyDatas.resize(other.m_PolyDatas.size());
std::transform(other.m_PolyDatas.begin(), other.m_PolyDatas.end(), m_PolyDatas.begin(), DeepCopy);
}
else
{
this->InitializeEmpty();
}
}
void mitk::Surface::Swap(mitk::Surface& other)
{
std::swap(m_PolyDatas, other.m_PolyDatas);
std::swap(m_LargestPossibleRegion, other.m_LargestPossibleRegion);
std::swap(m_RequestedRegion, other.m_RequestedRegion);
std::swap(m_CalculateBoundingBox, other.m_CalculateBoundingBox);
}
mitk::Surface& mitk::Surface::operator=(Surface other)
{
this->Swap(other);
return *this;
}
mitk::Surface::~Surface()
{
this->ClearData();
}
void mitk::Surface::ClearData()
{
using ::Delete;
std::for_each(m_PolyDatas.begin(), m_PolyDatas.end(), Delete);
m_PolyDatas.clear();
Superclass::ClearData();
}
const mitk::Surface::RegionType& mitk::Surface::GetLargestPossibleRegion() const
{
m_LargestPossibleRegion.SetIndex(3, 0);
m_LargestPossibleRegion.SetSize(3, GetTimeSlicedGeometry()->GetTimeSteps());
return m_LargestPossibleRegion;
}
const mitk::Surface::RegionType& mitk::Surface::GetRequestedRegion() const
{
return m_RequestedRegion;
}
void mitk::Surface::InitializeEmpty()
{
if (!m_PolyDatas.empty())
this->ClearData();
Superclass::InitializeTimeSlicedGeometry();
m_PolyDatas.push_back(NULL);
m_Initialized = true;
}
void mitk::Surface::SetVtkPolyData(vtkPolyData* polyData, unsigned int t)
{
this->Expand(t + 1);
if (m_PolyDatas[t] != NULL)
{
if (m_PolyDatas[t] == polyData)
return;
m_PolyDatas[t]->Delete();
}
m_PolyDatas[t] = polyData;
if(polyData != NULL)
polyData->Register(NULL);
m_CalculateBoundingBox = true;
this->Modified();
this->UpdateOutputInformation();
}
bool mitk::Surface::IsEmptyTimeStep(unsigned int t) const
{
if(!IsInitialized())
return false;
vtkPolyData* polyData = const_cast<Surface*>(this)->GetVtkPolyData(t);
return polyData == NULL || (
polyData->GetNumberOfLines() == 0 &&
polyData->GetNumberOfPolys() == 0 &&
polyData->GetNumberOfStrips() == 0 &&
polyData->GetNumberOfVerts() == 0
);
}
vtkPolyData* mitk::Surface::GetVtkPolyData(unsigned int t)
{
if (t < m_PolyDatas.size())
{
if(m_PolyDatas[t] == NULL && this->GetSource().IsNotNull())
{
RegionType requestedRegion;
requestedRegion.SetIndex(3, t);
requestedRegion.SetSize(3, 1);
this->SetRequestedRegion(&requestedRegion);
this->GetSource()->Update();
}
return m_PolyDatas[t];
}
return NULL;
}
void mitk::Surface::UpdateOutputInformation()
{
if (this->GetSource().IsNotNull())
this->GetSource()->UpdateOutputInformation();
if (m_CalculateBoundingBox == true && !m_PolyDatas.empty())
this->CalculateBoundingBox();
else
this->GetTimeSlicedGeometry()->UpdateInformation();
}
void mitk::Surface::CalculateBoundingBox()
{
mitk::TimeSlicedGeometry* timeSlicedGeometry = this->GetTimeSlicedGeometry();
if (timeSlicedGeometry->GetTimeSteps() != m_PolyDatas.size())
mitkThrow() << "Number of geometry time steps is inconsistent with number of poly data pointers.";
for (unsigned int i = 0; i < m_PolyDatas.size(); ++i)
{
vtkPolyData* polyData = m_PolyDatas[i];
vtkFloatingPointType bounds[6] = {0};
if (polyData != NULL && polyData->GetNumberOfPoints() > 0)
{
polyData->Update();
polyData->ComputeBounds();
polyData->GetBounds(bounds);
}
mitk::Geometry3D::Pointer geometry = timeSlicedGeometry->GetGeometry3D(i);
if (geometry.IsNull())
mitkThrow() << "Time-sliced geometry is invalid (equals NULL).";
geometry->SetFloatBounds(bounds);
}
timeSlicedGeometry->UpdateInformation();
m_CalculateBoundingBox = false;
}
void mitk::Surface::SetRequestedRegionToLargestPossibleRegion()
{
m_RequestedRegion = GetLargestPossibleRegion();
}
bool mitk::Surface::RequestedRegionIsOutsideOfTheBufferedRegion()
{
RegionType::IndexValueType end = m_RequestedRegion.GetIndex(3) + m_RequestedRegion.GetSize(3);
if(static_cast<RegionType::IndexValueType>(m_PolyDatas.size()) < end)
return true;
for(RegionType::IndexValueType t = m_RequestedRegion.GetIndex(3); t < end; ++t)
{
if(m_PolyDatas[t] == NULL)
return true;
}
return false;
}
bool mitk::Surface::VerifyRequestedRegion()
{
if(m_RequestedRegion.GetIndex(3) >= 0 && m_RequestedRegion.GetIndex(3) + m_RequestedRegion.GetSize(3) <= m_PolyDatas.size())
return true;
return false;
}
-void mitk::Surface::SetRequestedRegion(itk::DataObject* data)
+void mitk::Surface::SetRequestedRegion(const itk::DataObject* data )
{
- mitk::Surface* surface = dynamic_cast<mitk::Surface*>(data);
+ const mitk::Surface *surface = dynamic_cast<const mitk::Surface*>(data);
if (surface != NULL)
m_RequestedRegion = surface->GetRequestedRegion();
else
mitkThrow() << "Data object used to get requested region is not a mitk::Surface.";
}
void mitk::Surface::SetRequestedRegion(Surface::RegionType* region)
{
if (region == NULL)
mitkThrow() << "Requested region is invalid (equals NULL)";
m_RequestedRegion = *region;
}
void mitk::Surface::CopyInformation(const itk::DataObject* data)
{
Superclass::CopyInformation(data);
const mitk::Surface* surface = dynamic_cast<const mitk::Surface*>(data);
if (surface == NULL)
mitkThrow() << "Data object used to get largest possible region is not a mitk::Surface.";
m_LargestPossibleRegion = surface->GetLargestPossibleRegion();
}
void mitk::Surface::Update()
{
using ::Update;
if (this->GetSource().IsNull())
std::for_each(m_PolyDatas.begin(), m_PolyDatas.end(), Update);
Superclass::Update();
}
void mitk::Surface::Expand(unsigned int timeSteps)
{
if (timeSteps > m_PolyDatas.size())
{
Superclass::Expand(timeSteps);
m_PolyDatas.resize(timeSteps);
m_CalculateBoundingBox = true;
}
}
void mitk::Surface::ExecuteOperation(Operation* operation)
{
switch (operation->GetOperationType())
{
case OpSURFACECHANGED:
{
mitk::SurfaceOperation* surfaceOperation = dynamic_cast<mitk::SurfaceOperation*>(operation);
if(surfaceOperation == NULL)
break;
unsigned int timeStep = surfaceOperation->GetTimeStep();
if(m_PolyDatas[timeStep] != NULL)
{
vtkPolyData* updatedPolyData = surfaceOperation->GetVtkPolyData();
if(updatedPolyData != NULL)
{
this->SetVtkPolyData(updatedPolyData, timeStep);
this->CalculateBoundingBox();
this->Modified();
}
}
break;
}
default:
return;
}
}
unsigned int mitk::Surface::GetSizeOfPolyDataSeries() const
{
return m_PolyDatas.size();
}
void mitk::Surface::Graft(const DataObject* data)
{
const Surface* surface = dynamic_cast<const Surface*>(data);
if(surface == NULL)
mitkThrow() << "Data object used to graft surface is not a mitk::Surface.";
this->CopyInformation(data);
m_PolyDatas.clear();
for (unsigned int i = 0; i < surface->GetSizeOfPolyDataSeries(); ++i)
{
m_PolyDatas.push_back(vtkPolyData::New());
m_PolyDatas.back()->DeepCopy(const_cast<mitk::Surface*>(surface)->GetVtkPolyData(i));
}
}
void mitk::Surface::PrintSelf(std::ostream& os, itk::Indent indent) const
{
Superclass::PrintSelf(os, indent);
os << indent << "\nNumber PolyDatas: " << m_PolyDatas.size() << "\n";
unsigned int count = 0;
for (std::vector<vtkPolyData*>::const_iterator it = m_PolyDatas.begin(); it != m_PolyDatas.end(); ++it)
{
os << "\n";
if(*it != NULL)
{
os << indent << "PolyData at time step " << count << ":\n";
os << indent << "Number of cells: " << (*it)->GetNumberOfCells() << "\n";
os << indent << "Number of points: " << (*it)->GetNumberOfPoints() << "\n\n";
os << indent << "VTKPolyData:\n";
(*it)->Print(os);
}
else
{
os << indent << "Empty PolyData at time step " << count << "\n";
}
++count;
}
}
diff --git a/Core/Code/DataManagement/mitkSurface.h b/Core/Code/DataManagement/mitkSurface.h
index 00553d52f2..8c406d34e6 100644
--- a/Core/Code/DataManagement/mitkSurface.h
+++ b/Core/Code/DataManagement/mitkSurface.h
@@ -1,79 +1,79 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkSurface_h
#define mitkSurface_h
#include "mitkBaseData.h"
#include "itkImageRegion.h"
class vtkPolyData;
namespace mitk
{
/**
* \brief Class for storing surfaces (vtkPolyData).
* \ingroup Data
*/
class MITK_CORE_EXPORT Surface : public BaseData
{
public:
typedef itk::ImageRegion<5> RegionType;
mitkClassMacro(Surface, BaseData);
itkNewMacro(Self);
mitkCloneMacro(Surface);
void CalculateBoundingBox();
virtual void CopyInformation(const itk::DataObject *data);
virtual void ExecuteOperation(Operation *operation);
virtual void Expand( unsigned int timeSteps = 1 );
const RegionType& GetLargestPossibleRegion() const;
virtual const RegionType& GetRequestedRegion() const;
unsigned int GetSizeOfPolyDataSeries() const;
virtual vtkPolyData* GetVtkPolyData(unsigned int t = 0);
virtual void Graft( const DataObject* data );
virtual bool IsEmptyTimeStep(unsigned int t) const;
virtual void PrintSelf( std::ostream& os, itk::Indent indent ) const;
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion(const itk::DataObject *data);
virtual void SetRequestedRegion(Surface::RegionType *region);
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual void SetVtkPolyData(vtkPolyData* polydata, unsigned int t = 0);
virtual void Swap(Surface& other);
virtual void Update();
virtual void UpdateOutputInformation();
virtual bool VerifyRequestedRegion();
protected:
Surface();
virtual ~Surface();
Surface(const Surface& other);
Surface& operator=(Surface other);
virtual void ClearData();
virtual void InitializeEmpty();
private:
std::vector<vtkPolyData*> m_PolyDatas;
mutable RegionType m_LargestPossibleRegion;
RegionType m_RequestedRegion;
bool m_CalculateBoundingBox;
};
}
#endif
diff --git a/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.cpp b/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
index 2bdb79f18c..a411ad1054 100644
--- a/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
+++ b/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
@@ -1,102 +1,102 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkThinPlateSplineCurvedGeometry.h"
#include <vtkThinPlateSplineTransform.h>
#include <vtkPoints.h>
mitk::ThinPlateSplineCurvedGeometry::ThinPlateSplineCurvedGeometry()
{
m_InterpolatingAbstractTransform = m_ThinPlateSplineTransform = vtkThinPlateSplineTransform::New();
m_VtkTargetLandmarks = vtkPoints::New();
m_VtkProjectedLandmarks = vtkPoints::New();
m_ThinPlateSplineTransform->SetInverseIterations(5000);
}
mitk::ThinPlateSplineCurvedGeometry::ThinPlateSplineCurvedGeometry(const ThinPlateSplineCurvedGeometry& other ) : Superclass(other)
{
this->SetSigma(other.GetSigma());
}
mitk::ThinPlateSplineCurvedGeometry::~ThinPlateSplineCurvedGeometry()
{
// don't need to delete m_ThinPlateSplineTransform, because it is
// the same as m_InterpolatingAbstractTransform, which will be deleted
// by the superclass.
if(m_VtkTargetLandmarks!=NULL)
m_VtkTargetLandmarks->Delete();
if(m_VtkProjectedLandmarks!=NULL)
m_VtkProjectedLandmarks->Delete();
}
bool mitk::ThinPlateSplineCurvedGeometry::IsValid() const
{
return m_TargetLandmarks.IsNotNull() && (m_TargetLandmarks->Size() >= 3) && m_LandmarkProjector.IsNotNull();
}
void mitk::ThinPlateSplineCurvedGeometry::SetSigma(float sigma)
{
m_ThinPlateSplineTransform->SetSigma(sigma);
}
float mitk::ThinPlateSplineCurvedGeometry::GetSigma() const
{
return m_ThinPlateSplineTransform->GetSigma();
}
void mitk::ThinPlateSplineCurvedGeometry::ComputeGeometry()
{
Superclass::ComputeGeometry();
const mitk::PointSet::DataType::PointsContainer *finalTargetLandmarks, *projectedTargetLandmarks;
finalTargetLandmarks = m_LandmarkProjector->GetFinalTargetLandmarks();
projectedTargetLandmarks = m_LandmarkProjector->GetProjectedLandmarks();
mitk::PointSet::DataType::PointsContainer::ConstIterator targetIt, projectedIt;
targetIt = finalTargetLandmarks->Begin();
projectedIt = projectedTargetLandmarks->Begin();
//initialize Thin-Plate-Spline
m_VtkTargetLandmarks->Reset();
m_VtkProjectedLandmarks->Reset();
vtkIdType id;
int size=finalTargetLandmarks->Size();
for(id=0; id < size; ++id, ++targetIt, ++projectedIt)
{
const mitk::PointSet::PointType& target = targetIt->Value();
m_VtkTargetLandmarks->InsertPoint(id, target[0], target[1], target[2]);
const mitk::PointSet::PointType& projected = projectedIt->Value();
m_VtkProjectedLandmarks->InsertPoint(id, projected[0], projected[1], projected[2]);
}
m_VtkTargetLandmarks->Modified();
m_VtkProjectedLandmarks->Modified();
m_ThinPlateSplineTransform->SetSourceLandmarks(m_VtkProjectedLandmarks);
m_ThinPlateSplineTransform->SetTargetLandmarks(m_VtkTargetLandmarks);
}
-mitk::AffineGeometryFrame3D::Pointer mitk::ThinPlateSplineCurvedGeometry::Clone() const
+itk::LightObject::Pointer mitk::ThinPlateSplineCurvedGeometry::InternalClone() const
{
mitk::AffineGeometryFrame3D::Pointer newGeometry = new Self(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
diff --git a/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.h b/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.h
index d899fcd87f..c2ea557605 100644
--- a/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.h
+++ b/Core/Code/DataManagement/mitkThinPlateSplineCurvedGeometry.h
@@ -1,68 +1,68 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKTHINPLATESPLINECURVEDGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define MITKTHINPLATESPLINECURVEDGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#include "mitkLandmarkProjectorBasedCurvedGeometry.h"
class vtkPoints;
class vtkThinPlateSplineTransform;
namespace mitk {
//##Documentation
//## @brief Thin-plate-spline-based landmark-based curved geometry
//##
//## @ingroup Geometry
class MITK_CORE_EXPORT ThinPlateSplineCurvedGeometry : public LandmarkProjectorBasedCurvedGeometry
{
public:
mitkClassMacro(ThinPlateSplineCurvedGeometry, LandmarkProjectorBasedCurvedGeometry);
itkNewMacro(Self);
virtual void ComputeGeometry();
- virtual AffineGeometryFrame3D::Pointer Clone() const;
+ virtual itk::LightObject::Pointer InternalClone() const;
vtkThinPlateSplineTransform* GetThinPlateSplineTransform() const
{
return m_ThinPlateSplineTransform;
}
virtual void SetSigma(float sigma);
virtual float GetSigma() const;
virtual bool IsValid() const;
protected:
ThinPlateSplineCurvedGeometry();
ThinPlateSplineCurvedGeometry(const ThinPlateSplineCurvedGeometry& other );
virtual ~ThinPlateSplineCurvedGeometry();
vtkThinPlateSplineTransform* m_ThinPlateSplineTransform;
vtkPoints* m_VtkTargetLandmarks;
vtkPoints* m_VtkProjectedLandmarks;
};
} // namespace mitk
#endif /* MITKTHINPLATESPLINECURVEDGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp b/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp
index 6a628ac6e2..2b29716886 100644
--- a/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp
+++ b/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp
@@ -1,422 +1,422 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTimeSlicedGeometry.h"
void mitk::TimeSlicedGeometry::UpdateInformation()
{
if(m_TimeSteps==0) return;
unsigned long maxModifiedTime = 0, curModifiedTime;
mitk::ScalarType stmin, stmax;
stmin= ScalarTypeNumericTraits::NonpositiveMin();
stmax= ScalarTypeNumericTraits::max();
TimeBounds timeBounds;
timeBounds[0]=stmax; timeBounds[1]=stmin;
mitk::BoundingBox::Pointer boundingBox=mitk::BoundingBox::New();
mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
unsigned int t;
mitk::Geometry3D* geometry3d;
mitk::BoundingBox::ConstPointer nextBoundingBox;
mitk::BoundingBox::PointIdentifier pointid=0;
// Need to check for zero bounding boxes
mitk::ScalarType zeropoint[]={0,0,0,0,0,0};
BoundingBox::BoundsArrayType itkBoundsZero(zeropoint);
for(t=0; t < m_TimeSteps; ++t)
{
geometry3d = GetGeometry3D(t);
assert(geometry3d!=NULL);
curModifiedTime = geometry3d->GetMTime();
if(maxModifiedTime < curModifiedTime)
maxModifiedTime = curModifiedTime;
const TimeBounds & curTimeBounds = geometry3d->GetTimeBounds();
if((curTimeBounds[0] > stmin) && (curTimeBounds[0] < timeBounds[0]))
timeBounds[0] = curTimeBounds[0];
if((curTimeBounds[1] < stmax) && (curTimeBounds[1] > timeBounds[1]))
timeBounds[1] = curTimeBounds[1];
nextBoundingBox = geometry3d->GetBoundingBox();
assert(nextBoundingBox.IsNotNull());
// Only respect non-zero BBes
if (nextBoundingBox->GetBounds() == itkBoundsZero)
{
continue;
}
const mitk::BoundingBox::PointsContainer * nextPoints = nextBoundingBox->GetPoints();
if(nextPoints!=NULL)
{
mitk::BoundingBox::PointsContainer::ConstIterator pointsIt = nextPoints->Begin();
while (pointsIt != nextPoints->End() )
{
pointscontainer->InsertElement( pointid++, pointsIt->Value());
++pointsIt;
}
}
}
if(!(timeBounds[0] < stmax))
{
timeBounds[0] = stmin;
timeBounds[1] = stmax;
}
m_TimeBounds = timeBounds;
assert(timeBounds[0]<=timeBounds[1]);
boundingBox->SetPoints(pointscontainer);
boundingBox->ComputeBoundingBox();
m_BoundingBox = boundingBox;
SetIndexToWorldTransform(GetGeometry3D(0)->GetIndexToWorldTransform());
if(this->GetMTime() < maxModifiedTime)
Modified();
}
mitk::Geometry3D* mitk::TimeSlicedGeometry::GetGeometry3D(int t) const
{
mitk::Geometry3D::Pointer geometry3d = NULL;
if(IsValidTime(t))
{
geometry3d = m_Geometry3Ds[t];
//if (a) we don't have a Geometry3D stored for the requested time,
//(b) m_EvenlyTimed is activated and (c) the first geometry (t=0)
//is set, then we clone the geometry and set the m_TimeBounds accordingly.
if((m_EvenlyTimed) && (geometry3d.IsNull()))
{
const Geometry3D* firstgeometry=m_Geometry3Ds[0].GetPointer();
assert(firstgeometry != NULL);
mitk::Geometry3D::Pointer requestedgeometry;
requestedgeometry = dynamic_cast<Geometry3D*>(firstgeometry->Clone().GetPointer());
if ( requestedgeometry.IsNull() ) itkExceptionMacro("Geometry is NULL!");
TimeBounds timebounds = requestedgeometry->GetTimeBounds();
if(timebounds[1]<ScalarTypeNumericTraits::max())
{
mitk::ScalarType later = (timebounds[1]-timebounds[0])*t;
timebounds[0]+=later; timebounds[1]+=later;
requestedgeometry->SetTimeBounds(timebounds);
}
geometry3d = requestedgeometry;
m_Geometry3Ds[t] = geometry3d;
}
}
else
return NULL;
return geometry3d;
}
bool mitk::TimeSlicedGeometry::SetGeometry3D(mitk::Geometry3D* geometry3D, int t)
{
if(IsValidTime(t))
{
m_Geometry3Ds[t]=geometry3D;
return true;
}
return false;
}
int mitk::TimeSlicedGeometry::MSToTimeStep(mitk::ScalarType time_in_ms) const
{
if(time_in_ms < m_TimeBounds[0])
return -1;
if(time_in_ms >= m_TimeBounds[1])
return m_TimeSteps;
if(m_EvenlyTimed)
{
if(m_TimeBounds[0] == m_TimeBounds[1])
return 0;
if((m_TimeBounds[0]>ScalarTypeNumericTraits::NonpositiveMin()) && (m_TimeBounds[1]<ScalarTypeNumericTraits::max()))
{
return (int) ceil(((time_in_ms - m_TimeBounds[0])/(m_TimeBounds[1]-m_TimeBounds[0])*m_TimeSteps)-0.5);
}
return 0;
}
else
{
unsigned int t;
for ( t = 0; t < m_TimeSteps; ++t )
{
const TimeBounds& timeBounds = GetGeometry3D( t )->GetTimeBounds();
if( (timeBounds[0] <= time_in_ms) && (time_in_ms <= timeBounds[1]) )
{
return t;
}
}
}
return 0;
}
mitk::ScalarType mitk::TimeSlicedGeometry::TimeStepToMS(int timestep) const
{
if(IsValidTime(timestep)==false)
return ScalarTypeNumericTraits::max();
if(m_EvenlyTimed)
{
if ( timestep == 0 )
return m_TimeBounds[0];
else
{
assert( ! (m_TimeBounds[0] == ScalarTypeNumericTraits::NonpositiveMin() && m_TimeBounds[1] == ScalarTypeNumericTraits::max() ) );
return ((mitk::ScalarType)timestep)/m_TimeSteps*(m_TimeBounds[1]-m_TimeBounds[0])+m_TimeBounds[0];
}
}
else
{
return GetGeometry3D(timestep)->GetTimeBounds()[0];
}
}
int mitk::TimeSlicedGeometry::TimeStepToTimeStep(
const mitk::TimeSlicedGeometry *referenceGeometry, int t) const
{
int timeStep;
if ( referenceGeometry->GetTimeSteps() > 1 )
{
// referenceGeometry is nD+t
timeStep = this->MSToTimeStep( referenceGeometry->TimeStepToMS( t ) );
}
else
{
// referenceGEometry is nD (only one time step)
timeStep = 0;
}
return timeStep;
}
void mitk::TimeSlicedGeometry::InitializeEvenlyTimed(unsigned int timeSteps)
{
Geometry3D::Pointer geometry3D = Geometry3D::New();
geometry3D->Initialize();
InitializeEvenlyTimed(geometry3D, timeSteps);
}
void mitk::TimeSlicedGeometry::InitializeEvenlyTimed(mitk::Geometry3D* geometry3D, unsigned int timeSteps)
{
assert(geometry3D!=NULL);
geometry3D->Register();
InitializeEmpty(timeSteps);
AffineTransform3D::Pointer transform = AffineTransform3D::New();
transform->SetMatrix(geometry3D->GetIndexToWorldTransform()->GetMatrix());
transform->SetOffset(geometry3D->GetIndexToWorldTransform()->GetOffset());
SetIndexToWorldTransform(transform);
SetBounds(geometry3D->GetBounds());
SetGeometry3D(geometry3D, 0);
SetEvenlyTimed();
UpdateInformation();
SetFrameOfReferenceID(geometry3D->GetFrameOfReferenceID());
SetImageGeometry(geometry3D->GetImageGeometry());
geometry3D->UnRegister();
}
void mitk::TimeSlicedGeometry::InitializeEmpty(unsigned int timeSteps)
{
m_IndexToWorldTransform = NULL;
Superclass::Initialize();
m_TimeSteps = timeSteps;
// initialize with empty geometries
Geometry3D::Pointer gnull=NULL;
m_Geometry3Ds.assign(m_TimeSteps, gnull);
}
void mitk::TimeSlicedGeometry::ExpandToNumberOfTimeSteps( unsigned int timeSteps )
{
if( timeSteps <= m_TimeSteps ) return;
if(m_TimeSteps == 1)
{
Geometry3D* g3d = m_Geometry3Ds[0];
const TimeBounds & timeBounds = g3d->GetTimeBounds();
if( (timeBounds[0] == ScalarTypeNumericTraits::NonpositiveMin()) ||
(timeBounds[1]==ScalarTypeNumericTraits::max())
)
{
mitk::ScalarType timeBounds[] = {0.0, 1.0};
m_Geometry3Ds[0]->SetTimeBounds( timeBounds );
}
}
// Expand to Number of time steps; initialize with empty geometries
Geometry3D::Pointer gnull=NULL;
m_Geometry3Ds.resize(timeSteps, gnull);
m_TimeSteps = timeSteps;
UpdateInformation();
}
mitk::TimeSlicedGeometry::TimeSlicedGeometry() : m_TimeSteps(0), m_EvenlyTimed(false)
{
}
mitk::TimeSlicedGeometry::TimeSlicedGeometry(const TimeSlicedGeometry& other) : Geometry3D(other), m_TimeSteps(other.m_TimeSteps), m_EvenlyTimed(other.m_EvenlyTimed)
{
m_Geometry3Ds.resize(m_TimeSteps);
unsigned int t;
for(t=0; t<m_TimeSteps; ++t)
{
if(other.m_Geometry3Ds[t].IsNull())
{
assert(other.m_EvenlyTimed);
SetGeometry3D(NULL,t);
}
else
{
SetGeometry3D(dynamic_cast<Geometry3D*>(other.m_Geometry3Ds[t]->Clone().GetPointer()), t);
}
}
}
mitk::TimeSlicedGeometry::~TimeSlicedGeometry()
{
}
void mitk::TimeSlicedGeometry::SetImageGeometry(const bool isAnImageGeometry)
{
Superclass::SetImageGeometry(isAnImageGeometry);
mitk::Geometry3D* geometry3d;
unsigned int t;
for(t=0; t<m_TimeSteps; ++t)
{
geometry3d = m_Geometry3Ds[t];
if(geometry3d!=NULL)
geometry3d->SetImageGeometry(isAnImageGeometry);
}
}
void mitk::TimeSlicedGeometry::ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry)
{
mitk::Geometry3D* geometry3d;
unsigned int t;
for(t=0; t<m_TimeSteps; ++t)
{
geometry3d = m_Geometry3Ds[t];
if(geometry3d!=NULL)
geometry3d->ChangeImageGeometryConsideringOriginOffset(isAnImageGeometry);
}
Superclass::ChangeImageGeometryConsideringOriginOffset(isAnImageGeometry);
}
void mitk::TimeSlicedGeometry::SetEvenlyTimed(bool on)
{
m_EvenlyTimed = on;
Modified();
}
bool mitk::TimeSlicedGeometry::IsValidTime(int t) const
{
return (t>=0) && (t< (int)m_TimeSteps);
}
bool mitk::TimeSlicedGeometry::IsValid() const
{
return Superclass::IsValid() && (m_TimeSteps > 0);
}
void mitk::TimeSlicedGeometry::CopyTimes(const mitk::TimeSlicedGeometry* timeslicedgeometry, unsigned int t, unsigned int endtimeindex)
{
if(endtimeindex >= timeslicedgeometry->GetTimeSteps())
endtimeindex = timeslicedgeometry->GetTimeSteps()-1;
if(endtimeindex >= this->GetTimeSteps())
endtimeindex = this->GetTimeSteps()-1;
for(; t <= endtimeindex; ++t)
{
mitk::Geometry3D* geometry3d = GetGeometry3D(t);
mitk::Geometry3D* othergeometry3d = timeslicedgeometry->GetGeometry3D(t);
assert((geometry3d!=NULL) && (othergeometry3d!=NULL));
geometry3d->SetTimeBounds(othergeometry3d->GetTimeBounds());
}
UpdateInformation();
}
-mitk::AffineGeometryFrame3D::Pointer mitk::TimeSlicedGeometry::Clone() const
+itk::LightObject::Pointer mitk::TimeSlicedGeometry::InternalClone() const
{
Self::Pointer newGeometry = new TimeSlicedGeometry(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
void mitk::TimeSlicedGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
{
//Superclass::PrintSelf(os,indent);
os << indent << " EvenlyTimed: " << m_EvenlyTimed << std::endl;
os << indent << " TimeSteps: " << m_TimeSteps << std::endl;
os << std::endl;
os << indent << " GetGeometry3D(0): ";
if(GetGeometry3D(0)==NULL)
os << "NULL" << std::endl;
else
GetGeometry3D(0)->Print(os, indent);
}
void mitk::TimeSlicedGeometry::ExecuteOperation(Operation* operation)
{
// reach through to all time steps
for (std::vector<Geometry3D::Pointer>::iterator iter = m_Geometry3Ds.begin();
iter != m_Geometry3Ds.end();
++iter)
{
(*iter)->ExecuteOperation(operation);
}
Geometry3D::ExecuteOperation(operation);
this->Modified();
}
diff --git a/Core/Code/DataManagement/mitkTimeSlicedGeometry.h b/Core/Code/DataManagement/mitkTimeSlicedGeometry.h
index 1de4988cf4..04ab86f89b 100644
--- a/Core/Code/DataManagement/mitkTimeSlicedGeometry.h
+++ b/Core/Code/DataManagement/mitkTimeSlicedGeometry.h
@@ -1,182 +1,182 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef TIMESLICEDGEOMETRY_H_HEADER_INCLUDED_C1EBD0AD
#define TIMESLICEDGEOMETRY_H_HEADER_INCLUDED_C1EBD0AD
#include "mitkGeometry3D.h"
namespace mitk {
//##Documentation
//## @brief Describes a geometry consisting of several geometries which
//## exist at different times.
//##
//## The geometry contains m_TimeSteps geometries, which can be accessed
//## using GetGeometry3D(int t). To convert between world-time in
//## milliseconds and the integer timestep-number use MSToTimeStep.
//## The hull (in space and time) of the TimeSlicedGeometry contains all
//## contained geometries.
//## @warning The hull (i.e., transform, bounding-box and
//## time-bounds) is only guaranteed to be up-to-date after calling
//## UpdateInformation().
//##
//## TimeSlicedGeometry and the associated Geometry3Ds have to be
//## initialized in the method GenerateOutputInformation() of BaseProcess (or
//## CopyInformation/ UpdateOutputInformation of BaseData, if possible, e.g.,
//## by analyzing pic tags in Image) subclasses. See also
//## itk::ProcessObject::GenerateOutputInformation(),
//## itk::DataObject::CopyInformation() and
//## itk::DataObject::UpdateOutputInformation().
//##
//## @ingroup Geometry
class MITK_CORE_EXPORT TimeSlicedGeometry : public Geometry3D
{
public:
mitkClassMacro(TimeSlicedGeometry, Geometry3D);
itkNewMacro(Self);
//##Documentation
//## @brief Re-calculate the hull of the contained geometries.
//##
//## The transforms, bounding-box and time-bounds of this
//## geometry (stored in members of the super-class Geometry3D)
//## are re-calculated from the contained geometries.
void UpdateInformation();
//##Documentation
//## @brief Get the number of time-steps
itkGetConstMacro(TimeSteps, unsigned int);
//##Documentation
//## @brief Set/Get whether the TimeSlicedGeometry is evenly-timed (m_EvenlyTimed)
//##
//## If (a) we don't have a Geometry3D stored for the requested time,
//## (b) m_EvenlyTimed is activated and (c) the first geometry (t=0)
//## is set, then we clone the geometry and set the m_TimeBounds accordingly.
//## \sa GetGeometry3D
itkGetConstMacro(EvenlyTimed, bool);
virtual void SetEvenlyTimed(bool on = true);
//##Documentation
//## @brief Set the Geometry3D for time @a t
virtual bool SetGeometry3D(mitk::Geometry3D* geometry3D, int t);
//##Documentation
//## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
//##Documentation
//## @brief Get the Geometry3D at time @a t
virtual mitk::Geometry3D* GetGeometry3D(int t) const;
//##Documentation
//## @brief Test whether @a t is a valid time step
virtual bool IsValidTime(int t) const;
//##Documentation
//## @brief Returns true if TimeSliceGeometry is valid
virtual bool IsValid() const;
//##Documentation
//## @brief Convert time in ms to a time step
virtual int MSToTimeStep(mitk::ScalarType time_in_ms) const;
//##Documentation
//## @brief Convert time step to time in ms
virtual mitk::ScalarType TimeStepToMS(int timestep) const;
//##Documentation
//## @brief Convert time step in the reference TimeSlicedGeometry to time step
//## in this TimeSlicedGeometry.
virtual int TimeStepToTimeStep(const mitk::TimeSlicedGeometry *referenceGeometry, int t) const;
//##Documentation
//## @brief Completely initialize this instance as evenly-timed with
//## \a timeSteps geometries of type Geometry3D, each initialized by
//## Geometry3D::Initialize().
virtual void InitializeEvenlyTimed(unsigned int timeSteps);
//##Documentation
//## @brief Completely initialize this instance as evenly-timed with
//## \a timeSteps geometries identical to the provided Geometry3D
//## except for the time bounds
virtual void InitializeEvenlyTimed(mitk::Geometry3D* geometry3D, unsigned int timeSteps);
//##Documentation
//## @brief Initialize this instance to contain \a timeSteps
//## geometries, but without setting them yet
virtual void InitializeEmpty(unsigned int timeSteps);
//##Documentation
//## @brief Expand the number of time steps contained
//## to \a timeSteps.
//##
//## New, additional time steps will be initialized empty.
//## Only enlargement of the time steps vector is intended and possible.
virtual void ExpandToNumberOfTimeSteps( unsigned int timeSteps );
virtual void SetImageGeometry(const bool isAnImageGeometry);
//##Documentation
//## @brief Copy the m_TimeBounds of the geometries contained
//## in timeslicedgeometry into the geometries contained in this
//## TimeSlicedGeometry object.
//##
//## Useful for initialization of the TimeSlicedGeometry of the
//## output in GenerateOutputInformation() methods of process objects,
//## see for example BoundingObjectCutter::GenerateOutputInformation().
//## @param t start time index
//## @param endtimeindex (endtimeindex) is the time index of
//## the last geometry whose time-bounds are copied. If
//## timeslicedgeometry or this TimeSlicedGeometry object does
//## not contain enough geometries, endtimeindex is reduced
//## appropriately.
void CopyTimes(const mitk::TimeSlicedGeometry* timeslicedgeometry, unsigned int t=0, unsigned int endtimeindex = itk::NumericTraits<unsigned int>::max());
//##Documentation
//## @brief duplicates the geometry
- virtual AffineGeometryFrame3D::Pointer Clone() const;
+ virtual itk::LightObject::Pointer InternalClone() const;
// muellerm, 18.1.13, method not implemented
//TimeSlicedGeometry::Pointer CloneCopy() const;
virtual void ExecuteOperation(Operation* operation);
protected:
TimeSlicedGeometry();
TimeSlicedGeometry(const TimeSlicedGeometry& other);
virtual ~TimeSlicedGeometry();
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
mutable std::vector<Geometry3D::Pointer> m_Geometry3Ds;
//##Documentation
//## @brief Number of time steps
unsigned int m_TimeSteps;
//##Documentation
//## @brief \a true in case the time steps have equal length
bool m_EvenlyTimed;
static const std::string EVENLY_TIMED;
static const std::string TIME_STEPS;
};
} // namespace mitk
#endif /* TIMESLICEDGEOMETRY_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkTransferFunction.cpp b/Core/Code/DataManagement/mitkTransferFunction.cpp
index c0d5324523..9c0ae8f9a9 100644
--- a/Core/Code/DataManagement/mitkTransferFunction.cpp
+++ b/Core/Code/DataManagement/mitkTransferFunction.cpp
@@ -1,338 +1,332 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTransferFunction.h"
#include "mitkImageToItk.h"
#include "mitkHistogramGenerator.h"
#include <itkRGBPixel.h>
#include <vector>
namespace mitk
{
TransferFunction::TransferFunction()
{
m_ScalarOpacityFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
m_ColorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
m_GradientOpacityFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
m_ScalarOpacityFunction->Initialize();
m_ScalarOpacityFunction->AddPoint(0,1);
m_GradientOpacityFunction->Initialize();
m_GradientOpacityFunction->AddPoint(0,1);
m_ColorTransferFunction->RemoveAllPoints();
m_ColorTransferFunction->SetColorSpaceToHSV();
m_ColorTransferFunction->AddRGBPoint(0,1,1,1);
}
TransferFunction::TransferFunction(const TransferFunction& other)
: itk::Object()
, m_ScalarOpacityFunction(other.m_ScalarOpacityFunction.New())
, m_GradientOpacityFunction(other.m_GradientOpacityFunction.New())
, m_ColorTransferFunction(other.m_ColorTransferFunction.New())
, m_Min(other.m_Min)
, m_Max(other.m_Max)
, m_Histogram(other.m_Histogram)
, m_ScalarOpacityPoints(other.m_ScalarOpacityPoints)
, m_GradientOpacityPoints(other.m_GradientOpacityPoints)
, m_RGBPoints(other.m_RGBPoints)
{
m_ScalarOpacityFunction->DeepCopy(other.m_ScalarOpacityFunction);
m_GradientOpacityFunction->DeepCopy(other.m_GradientOpacityFunction);
m_ColorTransferFunction->DeepCopy(other.m_ColorTransferFunction);
}
TransferFunction::~TransferFunction()
{
}
bool TransferFunction::operator==(Self& other)
{
if ((m_Min != other.m_Min) || (m_Max != other.m_Max))
return false;
bool sizes = (m_ScalarOpacityFunction->GetSize() == other.m_ScalarOpacityFunction->GetSize())
&& (m_GradientOpacityFunction->GetSize() == other.m_GradientOpacityFunction->GetSize())
&& (m_ColorTransferFunction->GetSize() == other.m_ColorTransferFunction->GetSize());
if (sizes == false)
return false;
for (int i = 0; i < m_ScalarOpacityFunction->GetSize(); i++ )
{
double myVal[4];
double otherVal[4];
m_ScalarOpacityFunction->GetNodeValue(i, myVal);
other.m_ScalarOpacityFunction->GetNodeValue(i, otherVal);
bool equal = (myVal[0] == otherVal[0])
&& (myVal[1] == otherVal[1])
&& (myVal[2] == otherVal[2])
&& (myVal[3] == otherVal[3]);
if (equal == false)
return false;
}
for (int i = 0; i < m_GradientOpacityFunction->GetSize(); i++ )
{
double myVal[4];
double otherVal[4];
m_GradientOpacityFunction->GetNodeValue(i, myVal);
other.m_GradientOpacityFunction->GetNodeValue(i, otherVal);
bool equal = (myVal[0] == otherVal[0])
&& (myVal[1] == otherVal[1])
&& (myVal[2] == otherVal[2])
&& (myVal[3] == otherVal[3]);
if (equal == false)
return false;
}
for (int i = 0; i < m_ColorTransferFunction->GetSize(); i++ )
{
double myVal[6];
double otherVal[6];
m_ColorTransferFunction->GetNodeValue(i, myVal);
other.m_ColorTransferFunction->GetNodeValue(i, otherVal);
bool equal = (myVal[0] == otherVal[0]) // X
&& (myVal[1] == otherVal[1]) // R
&& (myVal[2] == otherVal[2]) // G
&& (myVal[3] == otherVal[3]) // B
&& (myVal[4] == otherVal[4]) // midpoint
&& (myVal[5] == otherVal[5]); // sharpness
if (equal == false)
return false;
}
return true;
}
void TransferFunction::SetScalarOpacityPoints(TransferFunction::ControlPoints points)
{
m_ScalarOpacityFunction->RemoveAllPoints();
for(unsigned int i=0; i<=points.size()-1;i++)
{
this->AddScalarOpacityPoint(points[i].first, points[i].second);
}
}
void TransferFunction::SetGradientOpacityPoints(TransferFunction::ControlPoints points)
{
m_GradientOpacityFunction->RemoveAllPoints();
for(unsigned int i=0; i<=points.size()-1;i++)
{
this->AddGradientOpacityPoint(points[i].first, points[i].second);
}
}
void TransferFunction::SetRGBPoints(TransferFunction::RGBControlPoints rgbpoints)
{
m_ColorTransferFunction->RemoveAllPoints();
for(unsigned int i=0; i<=rgbpoints.size()-1;i++)
{
this->AddRGBPoint(rgbpoints[i].first, rgbpoints[i].second[0],
rgbpoints[i].second[1], rgbpoints[i].second[2]);
}
}
void TransferFunction::AddScalarOpacityPoint(double x, double value)
{
m_ScalarOpacityFunction->AddPoint(x, value);
}
void TransferFunction::AddGradientOpacityPoint(double x, double value)
{
m_GradientOpacityFunction->AddPoint(x, value);
}
void TransferFunction::AddRGBPoint(double x, double r, double g, double b)
{
m_ColorTransferFunction->AddRGBPoint(x, r, g, b);
}
TransferFunction::ControlPoints &TransferFunction::GetScalarOpacityPoints()
{
// Retrieve data points from VTK transfer function and store them in a vector
m_ScalarOpacityPoints.clear();
vtkFloatingPointType *data = m_ScalarOpacityFunction->GetDataPointer();
for ( int i = 0; i < m_ScalarOpacityFunction->GetSize(); ++i )
{
m_ScalarOpacityPoints.push_back( std::make_pair( data[i*2], data[i*2+1] ));
}
return m_ScalarOpacityPoints;
}
TransferFunction::ControlPoints &TransferFunction::GetGradientOpacityPoints()
{
// Retrieve data points from VTK transfer function and store them in a vector
m_GradientOpacityPoints.clear();
vtkFloatingPointType *data = m_GradientOpacityFunction->GetDataPointer();
for ( int i = 0; i < m_GradientOpacityFunction->GetSize(); ++i )
{
m_GradientOpacityPoints.push_back( std::make_pair( data[i*2], data[i*2+1] ));
}
return m_GradientOpacityPoints;
}
TransferFunction::RGBControlPoints &TransferFunction::GetRGBPoints()
{
// Retrieve data points from VTK transfer function and store them in a vector
m_RGBPoints.clear();
vtkFloatingPointType *data = m_ColorTransferFunction->GetDataPointer();
for ( int i = 0; i < m_ColorTransferFunction->GetSize(); ++i )
{
double rgb[] = { data[i*4+1], data[i*4+2], data[i*4+3] };
m_RGBPoints.push_back( std::make_pair( data[i*4], rgb ));
}
return m_RGBPoints;
}
int TransferFunction::RemoveScalarOpacityPoint(double x)
{
return m_ScalarOpacityFunction->RemovePoint(x);
}
int TransferFunction::RemoveGradientOpacityPoint(double x)
{
return m_GradientOpacityFunction->RemovePoint(x);
}
int TransferFunction::RemoveRGBPoint(double x)
{
return m_ColorTransferFunction->RemovePoint(x);
}
void TransferFunction::ClearScalarOpacityPoints()
{
m_ScalarOpacityFunction->RemoveAllPoints();
}
void TransferFunction::ClearGradientOpacityPoints()
{
m_GradientOpacityFunction->RemoveAllPoints();
}
void TransferFunction::ClearRGBPoints()
{
m_ColorTransferFunction->RemoveAllPoints();
}
void TransferFunction::InitializeByItkHistogram(
const itk::Statistics::Histogram<double>* histogram)
{
m_Histogram = histogram;
m_Min = (int)GetHistogram()->GetBinMin(0,0);
m_Max = (int)GetHistogram()->GetBinMax(0, GetHistogram()->Size()-1);
/*
m_ScalarOpacityFunction->Initialize();
m_ScalarOpacityFunction->AddPoint(m_Min,0.0);
m_ScalarOpacityFunction->AddPoint(0.0,0.0);
m_ScalarOpacityFunction->AddPoint(m_Max,1.0);
m_GradientOpacityFunction->Initialize();
m_GradientOpacityFunction->AddPoint(m_Min,0.0);
m_GradientOpacityFunction->AddPoint(0.0,1.0);
m_GradientOpacityFunction->AddPoint((m_Max*0.125),1.0);
m_GradientOpacityFunction->AddPoint((m_Max*0.2),1.0);
m_GradientOpacityFunction->AddPoint((m_Max*0.25),1.0);
m_GradientOpacityFunction->AddPoint(m_Max,1.0);
m_ColorTransferFunction->RemoveAllPoints();
m_ColorTransferFunction->AddRGBPoint(m_Min,1,0,0);
m_ColorTransferFunction->AddRGBPoint(m_Max,1,1,0);
m_ColorTransferFunction->SetColorSpaceToHSV();
MITK_INFO << "min/max in tf-c'tor:" << m_Min << "/" << m_Max << std::endl;
*/
}
void TransferFunction::InitializeByMitkImage( const Image * image )
{
HistogramGenerator::Pointer histGen= HistogramGenerator::New();
histGen->SetImage(image);
histGen->SetSize(256);
histGen->ComputeHistogram();
m_Histogram = histGen->GetHistogram();
m_Min = (int)GetHistogram()->GetBinMin(0,0);
m_Max = (int)GetHistogram()->GetBinMax(0, GetHistogram()->Size()-1);
m_ScalarOpacityFunction->Initialize();
m_ScalarOpacityFunction->AddPoint(m_Min,0.0);
m_ScalarOpacityFunction->AddPoint(0.0,0.0);
m_ScalarOpacityFunction->AddPoint(m_Max,1.0);
m_GradientOpacityFunction->Initialize();
m_GradientOpacityFunction->AddPoint(m_Min,0.0);
m_GradientOpacityFunction->AddPoint(0.0,1.0);
m_GradientOpacityFunction->AddPoint((m_Max*0.125),1.0);
m_GradientOpacityFunction->AddPoint((m_Max*0.2),1.0);
m_GradientOpacityFunction->AddPoint((m_Max*0.25),1.0);
m_GradientOpacityFunction->AddPoint(m_Max,1.0);
m_ColorTransferFunction->RemoveAllPoints();
m_ColorTransferFunction->AddRGBPoint(m_Min,1,0,0);
m_ColorTransferFunction->AddRGBPoint(m_Max,1,1,0);
m_ColorTransferFunction->SetColorSpaceToHSV();
//MITK_INFO << "min/max in tf-c'tor:" << m_Min << "/" << m_Max << std::endl;
}
void TransferFunction::InitializeHistogram( const Image * image )
{
HistogramGenerator::Pointer histGen= HistogramGenerator::New();
histGen->SetImage(image);
histGen->SetSize(256);
histGen->ComputeHistogram();
m_Histogram = histGen->GetHistogram();
m_Min = (int)GetHistogram()->GetBinMin(0,0);
m_Max = (int)GetHistogram()->GetBinMax(0, GetHistogram()->Size()-1);
}
void TransferFunction::PrintSelf(std::ostream &os, itk::Indent indent) const
{
os << indent << "ScalarOpacity: ";
m_ScalarOpacityFunction->PrintHeader(os, vtkIndent());
os << indent << "GradientOpacity: ";
m_GradientOpacityFunction->PrintHeader(os, vtkIndent());
os << indent << "ColorTransfer: ";
m_ColorTransferFunction->PrintHeader(os, vtkIndent());
os << indent << "Min: " << m_Min << ", Max: " << m_Max << std::endl;
}
-mitk::TransferFunction::Pointer mitk::TransferFunction::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::TransferFunction::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
}// namespace
diff --git a/Core/Code/DataManagement/mitkTransferFunction.h b/Core/Code/DataManagement/mitkTransferFunction.h
index 37b1682809..282affc91e 100644
--- a/Core/Code/DataManagement/mitkTransferFunction.h
+++ b/Core/Code/DataManagement/mitkTransferFunction.h
@@ -1,201 +1,198 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITK_TRANSFER_FUNCTION_H_HEADER_INCLUDED
#define MITK_TRANSFER_FUNCTION_H_HEADER_INCLUDED
#include "mitkHistogramGenerator.h"
#include <MitkExports.h>
#include "mitkImage.h"
#include <itkObject.h>
#include <itkRGBPixel.h>
#include <itkHistogram.h>
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
#include <vtkSmartPointer.h>
#include <vector>
#include <algorithm>
#include <set>
namespace mitk {
/**
* \brief Wrapper class for VTK scalar opacity, gradient opacity, and color
* transfer functions.
*
* Holds a copy of each of the three standard VTK transfer functions (scalar
* opacity, gradient opacity, color) and provides an interface for manipulating
* their control points. Each original function can be retrieved by a Get()
* method.
*
* NOTE: Currently, transfer function initialization based on histograms or
* computed-tomography-presets is also provided by this class, but will likely
* be separated into a specific initializer class.
*/
class MITK_CORE_EXPORT TransferFunction : public itk::Object
{
public:
typedef std::vector<std::pair<double, double> > ControlPoints;
typedef std::vector<std::pair<double, itk::RGBPixel<double> > > RGBControlPoints;
mitkClassMacro(TransferFunction, itk::DataObject);
itkNewMacro(Self);
- Pointer Clone() const;
-
-
/** \brief Get/Set min/max of transfer function range for initialization. */
itkSetMacro(Min,int);
/** \brief Get/Set min/max of transfer function range for initialization. */
itkSetMacro(Max,int);
/** \brief Get/Set min/max of transfer function range for initialization. */
itkGetMacro(Min,int);
/** \brief Get/Set min/max of transfer function range for initialization. */
itkGetMacro(Max,int);
/** \brief Get/Set wrapped vtk transfer function. */
itkGetMacro(ScalarOpacityFunction,vtkPiecewiseFunction*);
/** \brief Get/Set wrapped vtk transfer function. */
itkGetMacro(GradientOpacityFunction,vtkPiecewiseFunction*);
/** \brief Get/Set wrapped vtk transfer function. */
itkGetMacro(ColorTransferFunction,vtkColorTransferFunction*);
itkSetMacro(ColorTransferFunction,vtkSmartPointer<vtkColorTransferFunction>);
/** \brief Get histogram used for transfer function initialization. */
itkGetConstObjectMacro(Histogram,HistogramGenerator::HistogramType);
/** \brief Initialize transfer function based on the histogram of an mitk::Image. */
void InitializeByMitkImage(const mitk::Image* image);
/** \brief Initialize transfer function based on the specified histogram. */
void InitializeByItkHistogram(const itk::Statistics::Histogram<double>* histogram);
/** \brief Initialize the internal histogram and min/max range based on the
* specified mitk::Image. */
void InitializeHistogram( const mitk::Image* image );
/** \brief Insert control points and values into the scalar opacity transfer
* function. */
void SetScalarOpacityPoints(TransferFunction::ControlPoints points);
/** \brief Insert control points and values into the gradient opacity transfer
* function. */
void SetGradientOpacityPoints(TransferFunction::ControlPoints points);
/** \brief Insert control points and RGB values into the color transfer
* function. */
void SetRGBPoints(TransferFunction::RGBControlPoints rgbpoints);
/** \brief Add a single control point to the scalar opacity transfer function. */
void AddScalarOpacityPoint(double x, double value);
/** \brief Add a single control point to the gradient opacity transfer function. */
void AddGradientOpacityPoint(double x, double value);
/** \brief Add a single control point to the color opacity transfer function. */
void AddRGBPoint(double x, double r, double g, double b);
/** \brief Get a copy of the scalar opacity transfer function control-points. */
TransferFunction::ControlPoints &GetScalarOpacityPoints();
/** \brief Get a copy of the gradient opacity transfer function control-points. */
TransferFunction::ControlPoints &GetGradientOpacityPoints();
/** \brief Get a copy of the color transfer function control-points. */
TransferFunction::RGBControlPoints &GetRGBPoints();
/** \brief Remove the specified control point from the scalar opacity transfer
* function. */
int RemoveScalarOpacityPoint(double x);
/** \brief Remove the specified control point from the gradient opacity transfer
* function. */
int RemoveGradientOpacityPoint(double x);
/** \brief Remove the specified control point from the color transfer function. */
int RemoveRGBPoint(double x);
/** \brief Removes all control points from the scalar opacity transfer function. */
void ClearScalarOpacityPoints();
/** \brief Removes all control points from the gradient opacity transfer
* function. */
void ClearGradientOpacityPoints();
/** \brief Removes all control points from the color transfer function. */
void ClearRGBPoints();
bool operator==(Self& other);
protected:
TransferFunction();
virtual ~TransferFunction();
TransferFunction(const TransferFunction& other);
virtual itk::LightObject::Pointer InternalClone() const;
void PrintSelf(std::ostream &os, itk::Indent indent) const;
/** Wrapped VTK scalar opacity transfer function */
vtkSmartPointer<vtkPiecewiseFunction> m_ScalarOpacityFunction;
/** Wrapped VTK gradient opacity transfer function */
vtkSmartPointer<vtkPiecewiseFunction> m_GradientOpacityFunction;
/** Wrapped VTK color transfer function */
vtkSmartPointer<vtkColorTransferFunction> m_ColorTransferFunction;
/** Current range of transfer function (used for initialization) */
int m_Min;
/** Current range of transfer function (used for initialization) */
int m_Max;
/** Specified or calculated histogram (used for initialization) */
mitk::HistogramGenerator::HistogramType::ConstPointer m_Histogram;
private:
/** Temporary STL style copy of VTK internal control points */
TransferFunction::ControlPoints m_ScalarOpacityPoints;
/** Temporary STL style copy of VTK internal control points */
TransferFunction::ControlPoints m_GradientOpacityPoints;
/** Temporary STL style copy of VTK internal control points */
TransferFunction::RGBControlPoints m_RGBPoints;
};
}
#endif /* MITK_TRANSFER_FUNCTION_H_HEADER_INCLUDED */
diff --git a/Core/Code/DataManagement/mitkTransferFunctionProperty.cpp b/Core/Code/DataManagement/mitkTransferFunctionProperty.cpp
index f600f319f5..b5215c36d7 100644
--- a/Core/Code/DataManagement/mitkTransferFunctionProperty.cpp
+++ b/Core/Code/DataManagement/mitkTransferFunctionProperty.cpp
@@ -1,67 +1,61 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTransferFunctionProperty.h"
namespace mitk {
bool TransferFunctionProperty::IsEqual(const BaseProperty& property) const
{
return *(this->m_Value) == *(static_cast<const Self&>(property).m_Value);
}
bool TransferFunctionProperty::Assign(const BaseProperty& property)
{
this->m_Value = static_cast<const Self&>(property).m_Value;
return true;
}
std::string TransferFunctionProperty::GetValueAsString() const
{
std::stringstream myStr;
myStr << GetValue();
return myStr.str();
}
TransferFunctionProperty::TransferFunctionProperty()
: BaseProperty()
{}
TransferFunctionProperty::TransferFunctionProperty(const TransferFunctionProperty& other)
: BaseProperty(other)
, m_Value(other.m_Value->Clone())
{
}
TransferFunctionProperty::TransferFunctionProperty( mitk::TransferFunction::Pointer value )
: BaseProperty(), m_Value( value )
{}
-TransferFunctionProperty::Pointer TransferFunctionProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer TransferFunctionProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
} // namespace mitk
diff --git a/Core/Code/DataManagement/mitkTransferFunctionProperty.h b/Core/Code/DataManagement/mitkTransferFunctionProperty.h
index 982ee6cf63..fcf57840c8 100644
--- a/Core/Code/DataManagement/mitkTransferFunctionProperty.h
+++ b/Core/Code/DataManagement/mitkTransferFunctionProperty.h
@@ -1,77 +1,75 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKTRANFERFUNCTIONPROPERTY_H_HEADER_INCLUDED
#define MITKTRANFERFUNCTIONPROPERTY_H_HEADER_INCLUDED
#include "mitkBaseProperty.h"
#include "mitkTransferFunction.h"
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
class MITK_CORE_EXPORT TransferFunctionProperty : public BaseProperty
{
public:
typedef mitk::TransferFunction::Pointer ValueType;
mitkClassMacro(TransferFunctionProperty, BaseProperty);
itkNewMacro(TransferFunctionProperty);
mitkNewMacro1Param(TransferFunctionProperty, mitk::TransferFunction::Pointer);
- Pointer Clone() const;
-
itkSetMacro(Value, mitk::TransferFunction::Pointer );
itkGetConstMacro(Value, mitk::TransferFunction::Pointer );
std::string GetValueAsString() const;
using BaseProperty::operator=;
protected:
mitk::TransferFunction::Pointer m_Value;
TransferFunctionProperty();
TransferFunctionProperty(const TransferFunctionProperty& other);
TransferFunctionProperty( mitk::TransferFunction::Pointer value );
private:
// purposely not implemented
TransferFunctionProperty& operator=(const TransferFunctionProperty&);
itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty& property) const;
virtual bool Assign(const BaseProperty& property);
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif /* MITKTRANFERFUNCTIONPROPERTY_H_HEADER_INCLUDED */
diff --git a/Core/Code/DataManagement/mitkVector.h b/Core/Code/DataManagement/mitkVector.h
index 598c2a5411..29883739ee 100644
--- a/Core/Code/DataManagement/mitkVector.h
+++ b/Core/Code/DataManagement/mitkVector.h
@@ -1,448 +1,457 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD
#define MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD
// this is needed for memcopy in ITK
// can be removed when fixed in ITK
#include <cstring>
#include <itkPoint.h>
#include <float.h>
#include <itkIndex.h>
#include <itkContinuousIndex.h>
#include <itkVector.h>
#include <itkMatrix.h>
#include <itkTransform.h>
#include <vnl/vnl_quaternion.h>
#include <MitkExports.h>
#ifndef DOXYGEN_SKIP
namespace mitk {
typedef float ScalarType;
typedef itk::Matrix<ScalarType, 3, 3> Matrix3D;
typedef itk::Matrix<ScalarType,4,4> Matrix4D;
typedef vnl_matrix_fixed<ScalarType, 3, 3> VnlMatrix3D;
typedef itk::Transform<ScalarType, 3, 3> Transform3D;
typedef vnl_vector<ScalarType> VnlVector;
typedef vnl_vector_ref<ScalarType> VnlVectorRef;
typedef itk::Point<ScalarType,2> Point2D;
typedef itk::Point<ScalarType,3> Point3D;
typedef itk::Point<ScalarType,4> Point4D;
typedef itk::Point<int,2> Point2I;
typedef itk::Point<int,3> Point3I;
typedef itk::Point<int,4> Point4I;
typedef itk::Vector<ScalarType,2> Vector2D;
typedef itk::Vector<ScalarType,3> Vector3D;
typedef itk::Index<3> Index3D;
typedef itk::ContinuousIndex<ScalarType, 3> ContinuousIndex3D;
typedef vnl_quaternion<ScalarType> Quaternion;
//##Documentation
//##@brief enumeration of the type a point can be
enum PointSpecificationType
{
PTUNDEFINED = 0,
PTSTART,
PTCORNER,
PTEDGE,
PTEND
};
typedef itk::NumericTraits<mitk::ScalarType> ScalarTypeNumericTraits;
MITK_CORE_EXPORT extern const ScalarType eps;
MITK_CORE_EXPORT extern const ScalarType sqrteps;
MITK_CORE_EXPORT extern const double large;
template <class T> class VectorTraits {
public:
typedef T ValueType;
};
template <> class VectorTraits<VnlVector> {
public:
typedef ScalarType ValueType;
};
template<> class VectorTraits<double[4]> {
public:
typedef double ValueType;
};
template<> class VectorTraits< itk::Index<5> > {
public:
typedef itk::Index<5>::IndexValueType ValueType;
};
template<> class VectorTraits< itk::Index<3> > {
public:
typedef itk::Index<3>::IndexValueType ValueType;
};
template<> class VectorTraits< long int [3]> {
public:
typedef long int ValueType;
};
template<> class VectorTraits< float [3]> {
public:
typedef float ValueType;
};
template<> class VectorTraits< double [3]> {
public:
typedef double ValueType;
};
template<> class VectorTraits< vnl_vector_fixed<ScalarType, 3> > {
public:
typedef ScalarType ValueType;
};
template<> class VectorTraits< long unsigned int[3]> {
public:
typedef long unsigned int ValueType;
};
template<> class VectorTraits< unsigned int *> {
public:
typedef unsigned int ValueType;
};
template<> class VectorTraits< ScalarType[4] > {
public:
typedef ScalarType ValueType;
};
template<> class VectorTraits< itk::Vector<float,3> > {
public:
typedef float ValueType;
};
template<> class VectorTraits< itk::Point<float,3> > {
public:
typedef float ValueType;
};
template<> class VectorTraits< itk::Point<float,4> > {
public:
typedef float ValueType;
};
template<> class VectorTraits< itk::Vector<double,3> > {
public:
typedef double ValueType;
};
template<> class VectorTraits< itk::Point<double,3> > {
public:
typedef double ValueType;
};
template<> class VectorTraits< itk::Vector<int,3> > {
public:
typedef int ValueType;
};
template<> class VectorTraits< itk::Point<int,3> > {
public:
typedef int ValueType;
};
template <class Tin, class Tout>
inline void itk2vtk(const Tin& in, Tout& out)
{
out[0]=(typename VectorTraits<Tout>::ValueType)(in[0]);
out[1]=(typename VectorTraits<Tout>::ValueType)(in[1]);
out[2]=(typename VectorTraits<Tout>::ValueType)(in[2]);
}
template <class Tin, class Tout>
inline void vtk2itk(const Tin& in, Tout& out)
{
out[0]=(typename VectorTraits<Tout>::ValueType)(in[0]);
out[1]=(typename VectorTraits<Tout>::ValueType)(in[1]);
out[2]=(typename VectorTraits<Tout>::ValueType)(in[2]);
}
template <class Tout>
inline void FillVector3D(Tout& out, ScalarType x, ScalarType y, ScalarType z)
{
out[0] = (typename VectorTraits<Tout>::ValueType)x;
out[1] = (typename VectorTraits<Tout>::ValueType)y;
out[2] = (typename VectorTraits<Tout>::ValueType)z;
}
template <class Tout>
inline void FillVector4D(Tout& out, ScalarType x, ScalarType y, ScalarType z, ScalarType t)
{
out[0] = (typename VectorTraits<Tout>::ValueType)x;
out[1] = (typename VectorTraits<Tout>::ValueType)y;
out[2] = (typename VectorTraits<Tout>::ValueType)z;
out[3] = (typename VectorTraits<Tout>::ValueType)t;
}
template <class Tin, class Tout>
inline void vnl2vtk(const vnl_vector<Tin>& in, Tout *out)
{
unsigned int i;
for(i=0; i<in.size();++i)
out[i]=(Tout) (in[i]);
}
template <class Tin, class Tout>
inline void vtk2vnl(const Tin *in, vnl_vector<Tout>& out)
{
unsigned int i;
for(i=0; i<out.size();++i)
out[i]=(Tout) (in[i]);
}
template <class Tin, class Tout>
inline void vtk2vnlref(const Tin *in, vnl_vector_ref<Tout>& out)
{
unsigned int i;
for(i=0; i<out.size();++i)
out[i]=(Tout) (in[i]);
}
template <class Tin, class Tout, unsigned int n>
inline void vnl2vtk(const vnl_vector_fixed<Tin, n>& in, Tout *out)
{
unsigned int i;
for(i=0; i<in.size();++i)
out[i]=(Tout) (in[i]);
}
template <class Tin, class Tout, unsigned int n>
inline void vtk2vnl(const Tin *in, vnl_vector_fixed<Tout, n>& out)
{
unsigned int i;
for(i=0; i<out.size();++i)
out[i]=(Tout) (in[i]);
}
template <class T, unsigned int NVectorDimension>
itk::Vector<T, NVectorDimension> operator+(const itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
{
itk::Vector<T, NVectorDimension> sub;
for( unsigned int i=0; i<NVectorDimension; i++)
{
sub[i] = vector[i]+point[i];
}
return sub;
}
template <class T, unsigned int NVectorDimension>
inline itk::Vector<T, NVectorDimension>& operator+=(itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
{
for( unsigned int i=0; i<NVectorDimension; i++)
{
vector[i] += point[i];
}
return vector;
}
template <class T, unsigned int NVectorDimension>
itk::Vector<T, NVectorDimension> operator-(const itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
{
itk::Vector<T, NVectorDimension> sub;
for( unsigned int i=0; i<NVectorDimension; i++)
{
sub[i] = vector[i]-point[i];
}
return sub;
}
template <class T, unsigned int NVectorDimension>
inline itk::Vector<T, NVectorDimension>& operator-=(itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
{
for( unsigned int i=0; i<NVectorDimension; i++)
{
vector[i] -= point[i];
}
return vector;
}
/*!
\brief Check for matrix equality with a user defined accuracy. As an equality metric the root mean squared error (RMS) of all elements is calculated.
\param matrix1 first vnl matrix
\param matrix2 second vnl matrix
\epsilon user defined accuracy bounds
*/
template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
inline bool MatrixEqualRMS(const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix1,const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
{
if ( (matrix1.rows() == matrix2.rows()) && (matrix1.cols() == matrix2.cols()) )
{
vnl_matrix_fixed<TCoordRep,NRows,NCols> differenceMatrix = matrix1-matrix2;
if (differenceMatrix.rms()<epsilon)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
/*!
\brief Check for matrix equality with a user defined accuracy. As an equality metric the root mean squared error (RMS) of all elements is calculated.
\param matrix1 first itk matrix
\param matrix2 second itk matrix
\epsilon user defined accuracy bounds
*/
template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
inline bool MatrixEqualRMS(const itk::Matrix<TCoordRep, NRows, NCols>& matrix1,const itk::Matrix<TCoordRep, NRows, NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
{
return mitk::MatrixEqualRMS(matrix1.GetVnlMatrix(),matrix2.GetVnlMatrix(),epsilon);
}
/*!
\brief Check for element-wise matrix equality with a user defined accuracy.
\param matrix1 first vnl matrix
\param matrix2 second vnl matrix
\epsilon user defined accuracy bounds
*/
template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
inline bool MatrixEqualElementWise(const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix1,const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
{
if ( (matrix1.rows() == matrix2.rows()) && (matrix1.cols() == matrix2.cols()) )
{
for( unsigned int r=0; r<NRows; r++)
{
for( unsigned int c=0; c<NCols; c++ )
{
TCoordRep difference = fabs(matrix1(r,c)-matrix2(r,c));
if (difference>epsilon)
{
return false;
}
}
}
return true;
}
else
{
return false;
}
}
/*!
\brief Check for element-wise matrix equality with a user defined accuracy.
\param matrix1 first itk matrix
\param matrix2 second itk matrix
\epsilon user defined accuracy bounds
*/
template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
inline bool MatrixEqualElementWise(const itk::Matrix<TCoordRep, NRows, NCols>& matrix1,const itk::Matrix<TCoordRep, NRows, NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
{
return mitk::MatrixEqualElementWise(matrix1.GetVnlMatrix(),matrix2.GetVnlMatrix(),epsilon);
}
template <typename TCoordRep, unsigned int NPointDimension>
inline bool Equal(const itk::Vector<TCoordRep, NPointDimension>& vector1, const itk::Vector<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps)
{
typename itk::Vector<TCoordRep, NPointDimension>::VectorType diff = vector1-vector2;
for (unsigned int i=0; i<NPointDimension; i++)
if (diff[i]>eps || diff[i]<-eps)
return false;
return true;
}
template <typename TCoordRep, unsigned int NPointDimension>
inline bool Equal(const itk::Point<TCoordRep, NPointDimension>& vector1, const itk::Point<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps)
{
typename itk::Point<TCoordRep, NPointDimension>::VectorType diff = vector1-vector2;
for (unsigned int i=0; i<NPointDimension; i++)
if (diff[i]>eps || diff[i]<-eps)
return false;
return true;
}
inline bool Equal(const mitk::VnlVector& vector1, const mitk::VnlVector& vector2, ScalarType eps=mitk::eps)
{
mitk::VnlVector diff = vector1-vector2;
for (unsigned int i=0; i<diff.size(); i++)
if (diff[i]>eps || diff[i]<-eps)
return false;
return true;
}
inline bool Equal(double scalar1, double scalar2, ScalarType eps=mitk::eps)
{
return fabs(scalar1-scalar2) < eps;
}
template <typename TCoordRep, unsigned int NPointDimension>
inline bool Equal(const vnl_vector_fixed<TCoordRep, NPointDimension> & vector1, const vnl_vector_fixed<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps)
{
vnl_vector_fixed<TCoordRep, NPointDimension> diff = vector1-vector2;
- return diff.squared_magnitude() < mitk::eps;
+ bool returnValue = true;
+ for( unsigned int i=0; i<diff.size(); i++)
+ {
+ if(diff[i]>eps || diff[i]<-eps)
+ {
+ returnValue = false;
+ }
+ }
+
+ return returnValue;
}
template <typename U, typename V, unsigned int NRows, unsigned int NColumns>
inline void TransferMatrix(const itk::Matrix<U, NRows, NColumns>& in, itk::Matrix<V, NRows, NColumns>& out)
{
for (unsigned int i = 0; i < in.RowDimensions; ++i)
for (unsigned int j = 0; j < in.ColumnDimensions; ++j)
out[i][j] = in[i][j];
}
} // namespace mitk
#endif //DOXYGEN_SKIP
/*
* This part of the code has been shifted here to avoid compiler clashes
* caused by including <itkAffineGeometryFrame.h> before the declaration of
* the Equal() methods above. This problem occurs when using MSVC and is
* probably related to a compiler bug.
*/
#include <itkAffineGeometryFrame.h>
namespace mitk
{
typedef itk::AffineGeometryFrame<ScalarType, 3>::TransformType AffineTransform3D;
}
#define mitkSetConstReferenceMacro(name,type) \
virtual void Set##name (const type & _arg) \
{ \
itkDebugMacro("setting " << #name " to " << _arg ); \
if (this->m_##name != _arg) \
{ \
this->m_##name = _arg; \
this->Modified(); \
} \
}
#define mitkSetVectorMacro(name,type) \
mitkSetConstReferenceMacro(name,type)
#define mitkGetVectorMacro(name,type) \
itkGetConstReferenceMacro(name,type)
#endif /* MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkVtkInterpolationProperty.cpp b/Core/Code/DataManagement/mitkVtkInterpolationProperty.cpp
index 660a054b6a..556df231b8 100644
--- a/Core/Code/DataManagement/mitkVtkInterpolationProperty.cpp
+++ b/Core/Code/DataManagement/mitkVtkInterpolationProperty.cpp
@@ -1,103 +1,97 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <vtkProperty.h>
#include "mitkVtkInterpolationProperty.h"
mitk::VtkInterpolationProperty::VtkInterpolationProperty( )
{
AddInterpolationTypes();
SetValue( static_cast<IdType>( VTK_GOURAUD ) );
}
mitk::VtkInterpolationProperty::VtkInterpolationProperty( const IdType& value )
{
AddInterpolationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value ) ;
}
else
{
SetValue( static_cast<IdType>( VTK_GOURAUD ) );
}
}
mitk::VtkInterpolationProperty::VtkInterpolationProperty( const std::string& value )
{
AddInterpolationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetValue( static_cast<IdType>( VTK_GOURAUD ) );
}
}
int mitk::VtkInterpolationProperty::GetVtkInterpolation()
{
return static_cast<int>( GetValueAsId() );
}
void mitk::VtkInterpolationProperty::SetInterpolationToFlat()
{
SetValue( static_cast<IdType>( VTK_FLAT ) );
}
void mitk::VtkInterpolationProperty::SetInterpolationToGouraud()
{
SetValue( static_cast<IdType>( VTK_GOURAUD ) );
}
void mitk::VtkInterpolationProperty::SetInterpolationToPhong()
{
SetValue( static_cast<IdType>( VTK_PHONG ) );
}
void mitk::VtkInterpolationProperty::AddInterpolationTypes()
{
AddEnum( "Flat", static_cast<IdType>( VTK_FLAT ) );
AddEnum( "Gouraud", static_cast<IdType>( VTK_GOURAUD ) );
AddEnum( "Phong", static_cast<IdType>( VTK_PHONG ) );
}
bool mitk::VtkInterpolationProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
-mitk::VtkInterpolationProperty::Pointer mitk::VtkInterpolationProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::VtkInterpolationProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkVtkInterpolationProperty.h b/Core/Code/DataManagement/mitkVtkInterpolationProperty.h
index acd1d0db44..74be94f80a 100644
--- a/Core/Code/DataManagement/mitkVtkInterpolationProperty.h
+++ b/Core/Code/DataManagement/mitkVtkInterpolationProperty.h
@@ -1,122 +1,120 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_VTK_INTERPOLATION_PROPERTY__H_
#define _MITK_VTK_INTERPOLATION_PROPERTY__H_
#include "mitkEnumerationProperty.h"
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* Encapsulates the enumeration vtkInterpolation. Valid values are
* (VTK constant/Id/string representation):
* VTK_FLAT/0/Flat, VTK_GOURAUD/1/Gouraud, VTK_PHONG/2/Phong
* Default is the Gouraud interpolation
*/
class MITK_CORE_EXPORT VtkInterpolationProperty : public EnumerationProperty
{
public:
mitkClassMacro( VtkInterpolationProperty, EnumerationProperty );
itkNewMacro(VtkInterpolationProperty);
mitkNewMacro1Param(VtkInterpolationProperty, const IdType&);
mitkNewMacro1Param(VtkInterpolationProperty, const std::string&);
- Pointer Clone() const;
-
/**
* Returns the current interpolation value as defined by VTK constants.
* @returns the current interpolation as VTK constant.
*/
virtual int GetVtkInterpolation();
/**
* Sets the interpolation type to VTK_FLAT.
*/
virtual void SetInterpolationToFlat();
/**
* Sets the interpolation type to VTK_WIREFRAME.
*/
virtual void SetInterpolationToGouraud();
/**
* Sets the interpolation type to VTK_SURFACE.
*/
virtual void SetInterpolationToPhong();
using BaseProperty::operator=;
protected:
/**
* Constructor. Sets the representation to a default value of surface(2)
*/
VtkInterpolationProperty( );
/**
* Constructor. Sets the interpolation to the given value. If it is not
* valid, the interpolation is set to gouraud(1)
* @param value the integer representation of the interpolation
*/
VtkInterpolationProperty( const IdType& value );
/**
* Constructor. Sets the interpolation to the given value. If it is not
* valid, the representation is set to gouraud(1)
* @param value the string representation of the interpolation
*/
VtkInterpolationProperty( const std::string& value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid interpolation types.
*/
virtual bool AddEnum( const std::string& name, const IdType& id );
/**
* Adds the enumeration types as defined by vtk to the list of known
* enumeration values.
*/
virtual void AddInterpolationTypes();
private:
// purposely not implemented
VtkInterpolationProperty& operator=(const VtkInterpolationProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // end of namespace mitk
#endif
diff --git a/Core/Code/DataManagement/mitkVtkRepresentationProperty.cpp b/Core/Code/DataManagement/mitkVtkRepresentationProperty.cpp
index 637a5d00c3..f0c2828743 100644
--- a/Core/Code/DataManagement/mitkVtkRepresentationProperty.cpp
+++ b/Core/Code/DataManagement/mitkVtkRepresentationProperty.cpp
@@ -1,102 +1,96 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <vtkProperty.h>
#include "mitkVtkRepresentationProperty.h"
mitk::VtkRepresentationProperty::VtkRepresentationProperty( )
{
AddRepresentationTypes();
SetValue( static_cast<IdType>( VTK_SURFACE ) );
}
mitk::VtkRepresentationProperty::VtkRepresentationProperty( const IdType& value )
{
AddRepresentationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetValue( static_cast<IdType>( VTK_SURFACE ) );
}
}
mitk::VtkRepresentationProperty::VtkRepresentationProperty( const std::string& value )
{
AddRepresentationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetValue( static_cast<IdType>( VTK_SURFACE ) );
}
}
int mitk::VtkRepresentationProperty::GetVtkRepresentation()
{
return static_cast<int>( GetValueAsId() );
}
void mitk::VtkRepresentationProperty::SetRepresentationToPoints()
{
SetValue( static_cast<IdType>( VTK_POINTS ) );
}
void mitk::VtkRepresentationProperty::SetRepresentationToWireframe()
{
SetValue( static_cast<IdType>( VTK_WIREFRAME ) );
}
void mitk::VtkRepresentationProperty::SetRepresentationToSurface()
{
SetValue( static_cast<IdType>( VTK_SURFACE ) );
}
void mitk::VtkRepresentationProperty::AddRepresentationTypes()
{
AddEnum( "Points", static_cast<IdType>( VTK_POINTS ) );
AddEnum( "Wireframe", static_cast<IdType>( VTK_WIREFRAME ) );
AddEnum( "Surface", static_cast<IdType>( VTK_SURFACE ) );
}
bool mitk::VtkRepresentationProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
-mitk::VtkRepresentationProperty::Pointer mitk::VtkRepresentationProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::VtkRepresentationProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkVtkRepresentationProperty.h b/Core/Code/DataManagement/mitkVtkRepresentationProperty.h
index 9b5ef1fda6..cffa76c8a3 100644
--- a/Core/Code/DataManagement/mitkVtkRepresentationProperty.h
+++ b/Core/Code/DataManagement/mitkVtkRepresentationProperty.h
@@ -1,121 +1,119 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_VTK_REPRESENTATION_PROPERTY__H_
#define _MITK_VTK_REPRESENTATION_PROPERTY__H_
#include "mitkEnumerationProperty.h"
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* Encapsulates the enumeration vtkRepresentation. Valid values are
* (VTK constant/Id/string representation):
* VTK_POINTS/0/Points, VTK_WIREFRAME/1/Wireframe, VTK_SURFACE/2/Surface
* Default is the Surface representation
*/
class MITK_CORE_EXPORT VtkRepresentationProperty : public EnumerationProperty
{
public:
mitkClassMacro( VtkRepresentationProperty, EnumerationProperty );
itkNewMacro(VtkRepresentationProperty);
mitkNewMacro1Param(VtkRepresentationProperty, const IdType&);
mitkNewMacro1Param(VtkRepresentationProperty, const std::string&);
- Pointer Clone() const;
-
/**
* Returns the current representation value as defined by VTK constants.
* @returns the current representation as VTK constant.
*/
virtual int GetVtkRepresentation();
/**
* Sets the representation type to VTK_POINTS.
*/
virtual void SetRepresentationToPoints();
/**
* Sets the representation type to VTK_WIREFRAME.
*/
virtual void SetRepresentationToWireframe();
/**
* Sets the representation type to VTK_SURFACE.
*/
virtual void SetRepresentationToSurface();
using BaseProperty::operator=;
protected:
/**
* Constructor. Sets the representation to a default value of Surface(2)
*/
VtkRepresentationProperty( );
/**
* Constructor. Sets the representation to the given value. If it is not
* valid, the representation is set to Surface(2)
* @param value the integer representation of the representation
*/
VtkRepresentationProperty( const IdType& value );
/**
* Constructor. Sets the representation to the given value. If it is not
* valid, the representation is set to Surface(2)
* @param value the string representation of the representation
*/
VtkRepresentationProperty( const std::string& value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid representation types.
*/
virtual bool AddEnum( const std::string& name, const IdType& id );
/**
* Adds the enumeration types as defined by vtk to the list of known
* enumeration values.
*/
virtual void AddRepresentationTypes();
private:
// purposely not implemented
VtkRepresentationProperty& operator=(const VtkRepresentationProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // end of namespace mitk
#endif
diff --git a/Core/Code/DataManagement/mitkVtkResliceInterpolationProperty.cpp b/Core/Code/DataManagement/mitkVtkResliceInterpolationProperty.cpp
index d13b914500..702eedbad2 100644
--- a/Core/Code/DataManagement/mitkVtkResliceInterpolationProperty.cpp
+++ b/Core/Code/DataManagement/mitkVtkResliceInterpolationProperty.cpp
@@ -1,103 +1,97 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <vtkProperty.h>
#include "mitkVtkResliceInterpolationProperty.h"
mitk::VtkResliceInterpolationProperty::VtkResliceInterpolationProperty( )
{
this->AddInterpolationTypes();
this->SetValue( static_cast<IdType>( VTK_RESLICE_NEAREST ) );
}
mitk::VtkResliceInterpolationProperty::VtkResliceInterpolationProperty( const IdType& value )
{
this->AddInterpolationTypes();
if ( IsValidEnumerationValue( value ) )
{
this->SetValue( value ) ;
}
else
{
this->SetValue( static_cast<IdType>( VTK_RESLICE_NEAREST ) );
}
}
mitk::VtkResliceInterpolationProperty::VtkResliceInterpolationProperty( const std::string& value )
{
this->AddInterpolationTypes();
if ( IsValidEnumerationValue( value ) )
{
this->SetValue( value );
}
else
{
this->SetValue( static_cast<IdType>( VTK_RESLICE_NEAREST ) );
}
}
int mitk::VtkResliceInterpolationProperty::GetInterpolation()
{
return static_cast<int>( this->GetValueAsId() );
}
void mitk::VtkResliceInterpolationProperty::SetInterpolationToNearest()
{
this->SetValue( static_cast<IdType>( VTK_RESLICE_NEAREST ) );
}
void mitk::VtkResliceInterpolationProperty::SetInterpolationToLinear()
{
this->SetValue( static_cast<IdType>( VTK_RESLICE_LINEAR ) );
}
void mitk::VtkResliceInterpolationProperty::SetInterpolationToCubic()
{
this->SetValue( static_cast<IdType>( VTK_RESLICE_CUBIC ) );
}
void mitk::VtkResliceInterpolationProperty::AddInterpolationTypes()
{
AddEnum( "Nearest", static_cast<IdType>( VTK_RESLICE_NEAREST ) );
AddEnum( "Linear", static_cast<IdType>( VTK_RESLICE_LINEAR ) );
AddEnum( "Cubic", static_cast<IdType>( VTK_RESLICE_CUBIC ) );
}
bool mitk::VtkResliceInterpolationProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
-mitk::VtkResliceInterpolationProperty::Pointer mitk::VtkResliceInterpolationProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::VtkResliceInterpolationProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkVtkResliceInterpolationProperty.h b/Core/Code/DataManagement/mitkVtkResliceInterpolationProperty.h
index 7f6b678653..e9f2e3d09d 100644
--- a/Core/Code/DataManagement/mitkVtkResliceInterpolationProperty.h
+++ b/Core/Code/DataManagement/mitkVtkResliceInterpolationProperty.h
@@ -1,118 +1,116 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_VTK_RESLICE_INTERPOLATION_PROPERTY__H_
#define _MITK_VTK_RESLICE_INTERPOLATION_PROPERTY__H_
#include "mitkEnumerationProperty.h"
#include <vtkImageReslice.h>
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* Encapsulates the enumeration for reslice interpolation. Valid values are
* (VTK constant/Id/string representation):
* VTK_RESLICE_NEAREST, VTK_RESLICE_LINEAR, VTK_RESLICE_CUBIC
* Default is VTK_RESLICE_NEAREST
*/
class MITK_CORE_EXPORT VtkResliceInterpolationProperty : public EnumerationProperty
{
public:
mitkClassMacro( VtkResliceInterpolationProperty, EnumerationProperty );
itkNewMacro(VtkResliceInterpolationProperty);
mitkNewMacro1Param(VtkResliceInterpolationProperty, const IdType&);
mitkNewMacro1Param(VtkResliceInterpolationProperty, const std::string&);
- Pointer Clone() const;
-
/**
* Returns the current interpolation value as defined by VTK constants.
*/
virtual int GetInterpolation();
/**
* Sets the interpolation type to VTK_RESLICE_NEAREST.
*/
virtual void SetInterpolationToNearest();
/**
* Sets the interpolation type to VTK_RESLICE_LINEAR.
*/
virtual void SetInterpolationToLinear();
/**
* Sets the interpolation type to VTK_RESLICE_CUBIC.
*/
virtual void SetInterpolationToCubic();
using BaseProperty::operator=;
protected:
/** Sets reslice interpolation mode to default (VTK_RESLICE_NEAREST).
*/
VtkResliceInterpolationProperty( );
/**
* Constructor. Sets reslice interpolation to the given value.
*/
VtkResliceInterpolationProperty( const IdType& value );
/**
* Constructor. Sets reslice interpolation to the given value.
*/
VtkResliceInterpolationProperty( const std::string& value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid interpolation types.
*/
virtual bool AddEnum( const std::string& name, const IdType& id );
/**
* Adds the enumeration types as defined by vtk to the list of known
* enumeration values.
*/
virtual void AddInterpolationTypes();
private:
// purposely not implemented
VtkResliceInterpolationProperty& operator=(const VtkResliceInterpolationProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // end of namespace mitk
#endif
diff --git a/Core/Code/DataManagement/mitkVtkScalarModeProperty.cpp b/Core/Code/DataManagement/mitkVtkScalarModeProperty.cpp
index 8fe199efc5..867536b3a7 100644
--- a/Core/Code/DataManagement/mitkVtkScalarModeProperty.cpp
+++ b/Core/Code/DataManagement/mitkVtkScalarModeProperty.cpp
@@ -1,106 +1,100 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <vtkAbstractMapper.h>
#include "mitkVtkScalarModeProperty.h"
mitk::VtkScalarModeProperty::VtkScalarModeProperty( )
{
AddInterpolationTypes();
SetScalarModeToDefault();
}
mitk::VtkScalarModeProperty::VtkScalarModeProperty( const IdType& value )
{
AddInterpolationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value ) ;
}
else
{
SetScalarModeToDefault();
}
}
mitk::VtkScalarModeProperty::VtkScalarModeProperty( const std::string& value )
{
AddInterpolationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetScalarModeToDefault();
}
}
int mitk::VtkScalarModeProperty::GetVtkScalarMode()
{
return static_cast<int>( GetValueAsId() );
}
void mitk::VtkScalarModeProperty::SetScalarModeToDefault()
{
SetValue( static_cast<IdType>( VTK_SCALAR_MODE_DEFAULT ) );
}
void mitk::VtkScalarModeProperty::SetScalarModeToPointData()
{
SetValue( static_cast<IdType>( VTK_SCALAR_MODE_USE_POINT_DATA ) );
}
void mitk::VtkScalarModeProperty::SetScalarModeToCellData()
{
SetValue( static_cast<IdType>( VTK_SCALAR_MODE_USE_CELL_DATA ) );
}
void mitk::VtkScalarModeProperty::SetScalarModeToPointFieldData()
{
SetValue( static_cast<IdType>( VTK_SCALAR_MODE_USE_POINT_FIELD_DATA ) );
}
void mitk::VtkScalarModeProperty::SetScalarModeToCellFieldData()
{
SetValue( static_cast<IdType>( VTK_SCALAR_MODE_USE_CELL_FIELD_DATA ) );
}
void mitk::VtkScalarModeProperty::AddInterpolationTypes()
{
AddEnum( "Default", static_cast<IdType>( VTK_SCALAR_MODE_DEFAULT ) );
AddEnum( "PointData", static_cast<IdType>( VTK_SCALAR_MODE_USE_POINT_DATA ) );
AddEnum( "CellData", static_cast<IdType>( VTK_SCALAR_MODE_USE_CELL_DATA ) );
AddEnum( "PointFieldData", static_cast<IdType>( VTK_SCALAR_MODE_USE_POINT_FIELD_DATA ) );
AddEnum( "CellFieldData", static_cast<IdType>( VTK_SCALAR_MODE_USE_CELL_FIELD_DATA ) );
}
bool mitk::VtkScalarModeProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
-mitk::VtkScalarModeProperty::Pointer mitk::VtkScalarModeProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::VtkScalarModeProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkVtkScalarModeProperty.h b/Core/Code/DataManagement/mitkVtkScalarModeProperty.h
index 983eda1082..66fa93729c 100644
--- a/Core/Code/DataManagement/mitkVtkScalarModeProperty.h
+++ b/Core/Code/DataManagement/mitkVtkScalarModeProperty.h
@@ -1,120 +1,118 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_VTK_SCALARMODE_PROPERTY__H_
#define _MITK_VTK_SCALARMODE_PROPERTY__H_
#include "mitkEnumerationProperty.h"
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* Encapsulates the enumeration vtkInterpolation. Valid values are
* (VTK constant/Id/string representation):
* \li VTK_SCALAR_MODE_DEFAULT/0/Default,
* \li VTK_SCALAR_MODE_USE_POINT_DATA/1/PointData,
* \li VTK_SCALAR_MODE_USE_CELL_DATA/2/CellData
* \li VTK_SCALAR_MODE_USE_POINT_FIELD_DATA/3/PointFieldData
* \li VTK_SCALAR_MODE_USE_CELL_FIELD_DATA/4/CellFieldData
*/
class MITK_CORE_EXPORT VtkScalarModeProperty : public EnumerationProperty
{
public:
mitkClassMacro( VtkScalarModeProperty, EnumerationProperty );
itkNewMacro(VtkScalarModeProperty);
mitkNewMacro1Param(VtkScalarModeProperty, const IdType&);
mitkNewMacro1Param(VtkScalarModeProperty, const std::string&);
- Pointer Clone() const;
-
/**
* Returns the current scalar mode value as defined by VTK constants.
* @returns the current scalar mode as VTK constant.
*/
virtual int GetVtkScalarMode();
virtual void SetScalarModeToDefault();
virtual void SetScalarModeToPointData();
virtual void SetScalarModeToCellData();
virtual void SetScalarModeToPointFieldData();
virtual void SetScalarModeToCellFieldData();
using BaseProperty::operator=;
protected:
/**
* Constructor. Sets the representation to a default value of surface(2)
*/
VtkScalarModeProperty( );
/**
* \brief Sets the scalar mode to the given value. If it is not
* valid, the scalar mode is set to default (0).
* @param value the integer representation of the scalar mode
*/
VtkScalarModeProperty( const IdType& value );
/**
* \brief Sets the scalar mode to the given value. If it is not
* valid, the representation is set to default (0).
* @param value the string representation of the scalar mode
*/
VtkScalarModeProperty( const std::string& value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid scalar mode types.
*/
virtual bool AddEnum( const std::string& name, const IdType& id );
/**
* Adds the enumeration types as defined by vtk to the list of known
* enumeration values.
*/
virtual void AddInterpolationTypes();
private:
// purposely not implemented
VtkScalarModeProperty& operator=(const VtkScalarModeProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // end of namespace mitk
#endif //_MITK_VTK_SCALARMODE_PROPERTY__H_
diff --git a/Core/Code/DataManagement/mitkVtkVolumeRenderingProperty.cpp b/Core/Code/DataManagement/mitkVtkVolumeRenderingProperty.cpp
index 2abfcf8d6b..f732ce33fa 100644
--- a/Core/Code/DataManagement/mitkVtkVolumeRenderingProperty.cpp
+++ b/Core/Code/DataManagement/mitkVtkVolumeRenderingProperty.cpp
@@ -1,90 +1,84 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <vtkProperty.h>
#include "mitkVtkVolumeRenderingProperty.h"
mitk::VtkVolumeRenderingProperty::VtkVolumeRenderingProperty( )
{
this->AddRenderingTypes();
this->SetValue( static_cast<IdType>( VTK_RAY_CAST_COMPOSITE_FUNCTION ) );
}
mitk::VtkVolumeRenderingProperty::VtkVolumeRenderingProperty( const IdType& value )
{
this->AddRenderingTypes();
if ( IsValidEnumerationValue( value ) )
{
this->SetValue( value ) ;
}
else
MITK_INFO << "Warning: invalid rendering configuration" << std::endl;
}
mitk::VtkVolumeRenderingProperty::VtkVolumeRenderingProperty( const std::string& value )
{
this->AddRenderingTypes();
if ( IsValidEnumerationValue( value ) )
{
this->SetValue( value );
}
else
MITK_INFO << "Warning: invalid rendering configuration" << std::endl;
}
int mitk::VtkVolumeRenderingProperty::GetRenderingType()
{
return static_cast<int>( this->GetValueAsId() );
}
void mitk::VtkVolumeRenderingProperty::SetRenderingTypeToMIP()
{
this->SetValue( static_cast<IdType>( VTK_VOLUME_RAY_CAST_MIP_FUNCTION ) );
}
void mitk::VtkVolumeRenderingProperty::SetRenderingTypeToComposite()
{
this->SetValue( static_cast<IdType>( VTK_RAY_CAST_COMPOSITE_FUNCTION ) );
}
void mitk::VtkVolumeRenderingProperty::AddRenderingTypes()
{
AddEnum( "MIP", static_cast<IdType>( VTK_VOLUME_RAY_CAST_MIP_FUNCTION ) );
AddEnum( "COMPOSITE", static_cast<IdType> (VTK_RAY_CAST_COMPOSITE_FUNCTION));
}
bool mitk::VtkVolumeRenderingProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
-mitk::VtkVolumeRenderingProperty::Pointer mitk::VtkVolumeRenderingProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::VtkVolumeRenderingProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkVtkVolumeRenderingProperty.h b/Core/Code/DataManagement/mitkVtkVolumeRenderingProperty.h
index debf2787d6..445ffa9fd1 100644
--- a/Core/Code/DataManagement/mitkVtkVolumeRenderingProperty.h
+++ b/Core/Code/DataManagement/mitkVtkVolumeRenderingProperty.h
@@ -1,114 +1,112 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_VTK_VOLUME_RENDERING_PROPERTY__H_
#define _MITK_VTK_VOLUME_RENDERING_PROPERTY__H_
#include "mitkEnumerationProperty.h"
#define VTK_RAY_CAST_COMPOSITE_FUNCTION 1
#define VTK_VOLUME_RAY_CAST_MIP_FUNCTION 2
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
* Encapsulates the enumeration for volume rendering. Valid values are
* (VTK constant/Id/string representation):
* VTK_VOLUME_RAY_CAST_MIP_FUNCTION
* VTK_RAY_CAST_COMPOSITE_FUNCTION
* Default is NULL
*/
class MITK_CORE_EXPORT VtkVolumeRenderingProperty : public EnumerationProperty
{
public:
mitkClassMacro( VtkVolumeRenderingProperty, EnumerationProperty );
itkNewMacro(VtkVolumeRenderingProperty);
mitkNewMacro1Param(VtkVolumeRenderingProperty, const IdType&);
mitkNewMacro1Param(VtkVolumeRenderingProperty, const std::string&);
- Pointer Clone() const;
-
/**
* Returns the current volume rendering type
*/
virtual int GetRenderingType();
/**
* Sets the rendering type to VTK_VOLUME_RAY_CAST_MIP_FUNCTION
*/
virtual void SetRenderingTypeToMIP();
/**
* Sets the rendering type to VTK_RAY_CAST_COMPOSITE_FUNCTION
*/
virtual void SetRenderingTypeToComposite();
using BaseProperty::operator=;
protected:
/** Sets rendering type to default (VTK_RAY_CAST_COMPOSITE_FUNCTION).
*/
VtkVolumeRenderingProperty( );
/**
* Constructor. Sets rendering type to the given value.
*/
VtkVolumeRenderingProperty( const IdType& value );
/**
* Constructor. Sets rendering type to the given value.
*/
VtkVolumeRenderingProperty( const std::string& value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid rendering types.
*/
virtual bool AddEnum( const std::string& name, const IdType& id );
/**
* Adds the enumeration types as defined by vtk to the list of known
* enumeration values.
*/
virtual void AddRenderingTypes();
private:
// purposely not implemented
VtkVolumeRenderingProperty& operator=(const VtkVolumeRenderingProperty&);
itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // end of namespace mitk
#endif
diff --git a/Core/Code/DataManagement/mitkWeakPointerProperty.cpp b/Core/Code/DataManagement/mitkWeakPointerProperty.cpp
index d505bb129e..b9d4d95fa0 100644
--- a/Core/Code/DataManagement/mitkWeakPointerProperty.cpp
+++ b/Core/Code/DataManagement/mitkWeakPointerProperty.cpp
@@ -1,86 +1,80 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkWeakPointerProperty.h"
bool mitk::WeakPointerProperty::IsEqual(const BaseProperty& property) const
{
return this->m_WeakPointer == static_cast<const Self&>(property).m_WeakPointer;
}
bool mitk::WeakPointerProperty::Assign(const BaseProperty& property)
{
this->m_WeakPointer = static_cast<const Self&>(property).m_WeakPointer;
return true;
}
mitk::WeakPointerProperty::WeakPointerProperty(itk::Object* pointer) : m_WeakPointer(pointer)
{
}
mitk::WeakPointerProperty::WeakPointerProperty(const WeakPointerProperty& other)
: mitk::BaseProperty(other)
, m_WeakPointer(other.m_WeakPointer)
{
}
mitk::WeakPointerProperty::~WeakPointerProperty()
{
}
std::string mitk::WeakPointerProperty::GetValueAsString() const
{
std::stringstream ss;
ss << m_WeakPointer.GetPointer();
return ss.str();
}
mitk::WeakPointerProperty::ValueType mitk::WeakPointerProperty::GetWeakPointer() const
{
return m_WeakPointer.GetPointer();
}
mitk::WeakPointerProperty::ValueType mitk::WeakPointerProperty::GetValue() const
{
return GetWeakPointer();
}
void mitk::WeakPointerProperty::SetWeakPointer(itk::Object* pointer)
{
if(m_WeakPointer.GetPointer() != pointer)
{
m_WeakPointer = pointer;
Modified();
}
}
void mitk::WeakPointerProperty::SetValue(const ValueType &value)
{
SetWeakPointer(value.GetPointer());
}
-mitk::WeakPointerProperty::Pointer mitk::WeakPointerProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::WeakPointerProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/DataManagement/mitkWeakPointerProperty.h b/Core/Code/DataManagement/mitkWeakPointerProperty.h
index 1b5e222800..f164185caf 100644
--- a/Core/Code/DataManagement/mitkWeakPointerProperty.h
+++ b/Core/Code/DataManagement/mitkWeakPointerProperty.h
@@ -1,85 +1,83 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKWEAKPOINTERPROPERTY_H_HEADER_INCLUDED_C126B791
#define MITKWEAKPOINTERPROPERTY_H_HEADER_INCLUDED_C126B791
#include <MitkExports.h>
#include "mitkBaseProperty.h"
#include "itkWeakPointer.h"
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
//##Documentation
//## @brief Property containing a smart-pointer
//##
//## @ingroup DataManagement
class MITK_CORE_EXPORT WeakPointerProperty : public BaseProperty
{
public:
mitkClassMacro(WeakPointerProperty, BaseProperty);
itkNewMacro(WeakPointerProperty);
mitkNewMacro1Param(WeakPointerProperty, itk::Object*);
- Pointer Clone() const;
-
virtual ~WeakPointerProperty();
typedef itk::WeakPointer<itk::Object> ValueType;
ValueType GetWeakPointer() const;
ValueType GetValue() const;
void SetWeakPointer(itk::Object* pointer);
void SetValue(const ValueType& value);
virtual std::string GetValueAsString() const;
using BaseProperty::operator=;
protected:
itk::WeakPointer<itk::Object> m_WeakPointer;
WeakPointerProperty(const WeakPointerProperty&);
WeakPointerProperty(itk::Object* pointer = 0);
private:
// purposely not implemented
WeakPointerProperty& operator=(const WeakPointerProperty&);
itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty& property) const;
virtual bool Assign(const BaseProperty& property);
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif /* MITKWEAKPOINTERPROPERTY_H_HEADER_INCLUDED_C126B791 */
diff --git a/Core/Code/IO/mitkFileWriter.h b/Core/Code/IO/mitkFileWriter.h
index 6285c25b6e..d07733769d 100644
--- a/Core/Code/IO/mitkFileWriter.h
+++ b/Core/Code/IO/mitkFileWriter.h
@@ -1,165 +1,166 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef FILEWRITER_H_HEADER_INCLUDED
#define FILEWRITER_H_HEADER_INCLUDED
#include <MitkExports.h>
#include <itkProcessObject.h>
#include <mitkDataNode.h>
namespace mitk {
//##Documentation
//## @brief Interface class of writers that write data to files
//## @ingroup Process
class MITK_CORE_EXPORT FileWriter : public itk::ProcessObject
{
public:
mitkClassMacro(FileWriter,itk::ProcessObject);
//##Documentation
//## @brief Get the specified the file to write
//##
//## Either the FileName or FilePrefix plus FilePattern are used to write.
virtual const char* GetFileName() const = 0;
//##Documentation
//## @brief Specify the file to write.
//##
//## Either the FileName or FilePrefix plus FilePattern are used to write.
virtual void SetFileName(const char* aFileName) = 0;
//##Documentation
//## @brief Get the specified file prefix for the file(s) to write.
//##
//## You should specify either a FileName or FilePrefix. Use FilePrefix if
//## the data is stored in multiple files.
virtual const char* GetFilePrefix() const = 0;
//##Documentation
//## @brief Specify file prefix for the file(s) to write.
//##
//## You should specify either a FileName or FilePrefix. Use FilePrefix if
//## the data is stored in multiple files.
virtual void SetFilePrefix(const char* aFilePrefix) = 0;
//##Documentation
//## @brief Get the specified file pattern for the file(s) to write. The
//## sprintf format used to build filename from FilePrefix and number.
//##
//## You should specify either a FileName or FilePrefix. Use FilePrefix if
//## the data is stored in multiple files.
virtual const char* GetFilePattern() const = 0;
//##Documentation
//## @brief Specified file pattern for the file(s) to write. The sprintf
//## format used to build filename from FilePrefix and number.
//##
//## You should specify either a FileName or FilePrefix. Use FilePrefix if
//## the data is stored in multiple files.
virtual void SetFilePattern(const char* aFilePattern) = 0;
//##Documentation
//## @brief Return the extension to be added to the filename.
virtual std::string GetFileExtension();
//##Documentation
//## @brief Checks if given extension is valid for file writer
bool IsExtensionValid(std::string extension);
//##Documentation
//## @brief Return the possible file extensions for the data type associated with the writer
virtual std::vector<std::string> GetPossibleFileExtensions() = 0;
//##Documentation
//## @brief possible file extensions for the data type associated with the writer as string
virtual std::string GetPossibleFileExtensionsAsString();
//##Documentation
//## @brief Check if the Writer can write this type of data of the
//## DataTreenode.
virtual bool CanWriteDataType( DataNode* );
//##Documentation
//## @brief Return the MimeType of the saved File.
virtual std::string GetWritenMIMEType();
//##Documentation
//## @brief Set the DataTreenode as Input. Important: The Writer
//## always have a SetInput-Function.
+ using itk::ProcessObject::SetInput;
virtual void SetInput( DataNode* );
virtual void Write() = 0;
/**
@brief Specifies, whether the file writer also can
write a file to a memory buffer */
virtual bool CanWriteToMemory( );
/**
@brief Set/Get functions to advise the file writer to
use tis internal memory array as file writing destination*/
virtual void SetWriteToMemory( bool write );
virtual bool GetWriteToMemory( );
/**
@brief To be used along with a call of SetWriteToMemory(true). This returns
the memory buffer where the file was written.*/
virtual const char* GetMemoryPointer();
/**
@brief To be used along with a call of SetWriteToMemory(true). This returns
the size of the memory buffer where the file was written.*/
virtual unsigned int GetMemorySize();
/**
@brief CAUTION: It's up to the user to call this function to release the
memory buffer after use in case the file writer has written to its memory array.*/
virtual void ReleaseMemory();
protected:
FileWriter();
virtual ~FileWriter();
bool m_CanWriteToMemory;
bool m_WriteToMemory;
char * m_MemoryBuffer;
unsigned int m_MemoryBufferSize;
};
#define mitkWriterMacro \
virtual void Write() \
{ \
if ( this->GetInput() == NULL ) \
{ \
itkExceptionMacro(<<"Write:Please specify an input!"); \
return; \
} \
/* Fill in image information.*/ \
this->UpdateOutputInformation(); \
(*(this->GetInputs().begin()))->SetRequestedRegionToLargestPossibleRegion();\
this->PropagateRequestedRegion(NULL); \
this->UpdateOutputData(NULL); \
} \
\
virtual void Update() \
{ \
Write(); \
}
} // namespace mitk
#endif /* FILEWRITER_H_HEADER_INCLUDED */
diff --git a/Core/Code/IO/mitkIOAdapter.h b/Core/Code/IO/mitkIOAdapter.h
index 8d3e1a1457..3f38cbede2 100644
--- a/Core/Code/IO/mitkIOAdapter.h
+++ b/Core/Code/IO/mitkIOAdapter.h
@@ -1,93 +1,93 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkIOAdapter_h
#define __mitkIOAdapter_h
#include "mitkBaseProcess.h"
#include "itkObject.h"
namespace mitk
{
//##Documentation
//## @brief IOAdapterBase class is an abstract adapter class for IO process objects.
//##
//## @ingroup IO
class MITK_CORE_EXPORT IOAdapterBase: public itk::Object
{
public:
/** Standard typedefs. */
typedef IOAdapterBase Self;
typedef itk::Object Superclass;
typedef itk::SmartPointer<Self>Pointer;
typedef itk::SmartPointer<const Self>ConstPointer;
/// Create an object and return a pointer to it as a mitk::BaseProcess.
- virtual itk::SmartPointer<BaseProcess> CreateIOProcessObject(const std::string filename, const std::string filePrefix, const std::string filePattern) = 0;
+ virtual itk::SmartPointer<BaseDataSource> CreateIOProcessObject(const std::string filename, const std::string filePrefix, const std::string filePattern) = 0;
virtual bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern) = 0;
protected:
IOAdapterBase() {}
~IOAdapterBase() {}
private:
IOAdapterBase(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
//##Documentation
//## @brief IOAdapter class is an adapter class for instantiation of IO process objects.
//## Additional this interface defines the function CanReadFile().
//## This interface allows the target (object) the access to the adaptee (IO process object).
//## @ingroup IO
template <class T>
class IOAdapter : public IOAdapterBase
{
public:
/** Standard class typedefs. */
typedef IOAdapter Self;
typedef itk::SmartPointer<Self> Pointer;
/** Methods from mitk::BaseProcess. */
itkFactorylessNewMacro(Self);
mitk::BaseProcess::Pointer CreateIOProcessObject(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
typename T::Pointer ioProcessObject = T::New();
ioProcessObject->SetFileName(filename.c_str());
ioProcessObject->SetFilePrefix(filePrefix.c_str());
ioProcessObject->SetFilePattern(filePattern.c_str());
return ioProcessObject.GetPointer();
}
virtual bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
return T::CanReadFile(filename, filePrefix, filePattern);
}
protected:
IOAdapter() {}
~IOAdapter() {}
private:
IOAdapter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
} // end namespace mitk
#endif
diff --git a/Core/Code/IO/mitkIOUtil.cpp b/Core/Code/IO/mitkIOUtil.cpp
index 37dc199f77..d671110b0a 100644
--- a/Core/Code/IO/mitkIOUtil.cpp
+++ b/Core/Code/IO/mitkIOUtil.cpp
@@ -1,317 +1,317 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkIOUtil.h"
#include "mitkDataNodeFactory.h"
#include "mitkImageWriter.h"
#include "mitkPointSetWriter.h"
#include "mitkSurfaceVtkWriter.h"
#include <mitkGetModuleContext.h>
#include <mitkModuleContext.h>
#include <mitkStandaloneDataStorage.h>
#include <mitkIDataNodeReader.h>
#include <mitkProgressBar.h>
//ITK
#include <itksys/SystemTools.hxx>
//VTK
#include <vtkPolyData.h>
#include <vtkTriangleFilter.h>
#include <vtkSmartPointer.h>
namespace mitk {
const std::string IOUtil::DEFAULTIMAGEEXTENSION = ".nrrd";
const std::string IOUtil::DEFAULTSURFACEEXTENSION = ".stl";
const std::string IOUtil::DEFAULTPOINTSETEXTENSION = ".mps";
int IOUtil::LoadFiles(const std::vector<std::string> &fileNames, DataStorage &ds)
{
// Get the set of registered mitk::IDataNodeReader services
ModuleContext* context = mitk::GetModuleContext();
const std::list<ServiceReference> refs = context->GetServiceReferences<IDataNodeReader>();
std::vector<IDataNodeReader*> services;
services.reserve(refs.size());
for (std::list<ServiceReference>::const_iterator i = refs.begin();
i != refs.end(); ++i)
{
IDataNodeReader* s = context->GetService<IDataNodeReader>(*i);
if (s != 0)
{
services.push_back(s);
}
}
mitk::ProgressBar::GetInstance()->AddStepsToDo(2*fileNames.size());
// Iterate over all file names and use the IDataNodeReader services
// to load them.
int nodesRead = 0;
for (std::vector<std::string>::const_iterator i = fileNames.begin();
i != fileNames.end(); ++i)
{
for (std::vector<IDataNodeReader*>::const_iterator readerIt = services.begin();
readerIt != services.end(); ++readerIt)
{
try
{
int n = (*readerIt)->Read(*i, ds);
nodesRead += n;
if (n > 0) break;
}
catch (const std::exception& e)
{
MITK_WARN << e.what();
}
}
mitk::ProgressBar::GetInstance()->Progress(2);
}
for (std::list<ServiceReference>::const_iterator i = refs.begin();
i != refs.end(); ++i)
{
context->UngetService(*i);
}
return nodesRead;
}
DataStorage::Pointer IOUtil::LoadFiles(const std::vector<std::string>& fileNames)
{
mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
LoadFiles(fileNames, *ds);
return ds.GetPointer();
}
DataNode::Pointer IOUtil::LoadDataNode(const std::string path)
{
mitk::DataNodeFactory::Pointer reader = mitk::DataNodeFactory::New();
try
{
reader->SetFileName( path );
reader->Update();
if((reader->GetNumberOfOutputs()<1))
{
MITK_ERROR << "Could not find data '" << path << "'";
mitkThrow() << "An exception occured during loading the file " << path << ". Exception says could not find data.";
}
- mitk::DataNode::Pointer node = reader->GetOutput(0);
+ mitk::DataNode::Pointer node = reader->GetOutput();
if(node.IsNull())
{
MITK_ERROR << "Could not find path: '" << path << "'" << " datanode is NULL" ;
mitkThrow() << "An exception occured during loading the file " << path << ". Exception says datanode is NULL.";
}
return reader->GetOutput( 0 );
}
catch ( itk::ExceptionObject & e )
{
MITK_ERROR << "Exception occured during load data of '" << path << "': Exception: " << e.what();
mitkThrow() << "An exception occured during loading the file " << path << ". Exception says: " << e.what();
}
}
Image::Pointer IOUtil::LoadImage(const std::string path)
{
mitk::DataNode::Pointer node = LoadDataNode(path);
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
if(image.IsNull())
{
MITK_ERROR << "Image is NULL '" << path << "'";
mitkThrow() << "An exception occured during loading the image " << path << ". Exception says: Image is NULL.";
}
return image;
}
Surface::Pointer IOUtil::LoadSurface(const std::string path)
{
mitk::DataNode::Pointer node = LoadDataNode(path);
mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(node->GetData());
if(surface.IsNull())
{
MITK_ERROR << "Surface is NULL '" << path << "'";
mitkThrow() << "An exception occured during loading the file " << path << ". Exception says: Surface is NULL.";
}
return surface;
}
PointSet::Pointer IOUtil::LoadPointSet(const std::string path)
{
mitk::DataNode::Pointer node = LoadDataNode(path);
mitk::PointSet::Pointer pointset = dynamic_cast<mitk::PointSet*>(node->GetData());
if(pointset.IsNull())
{
MITK_ERROR << "PointSet is NULL '" << path << "'";
mitkThrow() << "An exception occured during loading the file " << path << ". Exception says: Pointset is NULL.";
}
return pointset;
}
bool IOUtil::SaveImage(mitk::Image::Pointer image, const std::string path)
{
std::string dir = itksys::SystemTools::GetFilenamePath( path );
std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
std::string finalFileName = dir + "/" + baseFilename;
mitk::ImageWriter::Pointer imageWriter = mitk::ImageWriter::New();
//check if an extension is given, else use the defaul extension
if( extension == "" )
{
MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
<< DEFAULTIMAGEEXTENSION;
extension = DEFAULTIMAGEEXTENSION;
}
// check if extension is suitable for writing image data
if (!imageWriter->IsExtensionValid(extension))
{
MITK_WARN << extension << " extension is unknown. Extension set to default: " << finalFileName
<< DEFAULTIMAGEEXTENSION;
extension = DEFAULTIMAGEEXTENSION;
}
try
{
//write the data
imageWriter->SetInput(image);
imageWriter->SetFileName(finalFileName.c_str());
imageWriter->SetExtension(extension.c_str());
imageWriter->Write();
}
catch ( std::exception& e )
{
MITK_ERROR << " during attempt to write '" << finalFileName + extension << "' Exception says:";
MITK_ERROR << e.what();
mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
}
return true;
}
bool IOUtil::SaveSurface(Surface::Pointer surface, const std::string path)
{
std::string dir = itksys::SystemTools::GetFilenamePath( path );
std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
std::string finalFileName = dir + "/" + baseFilename;
if (extension == "") // if no extension has been set we use the default extension
{
MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
<< DEFAULTSURFACEEXTENSION;
extension = DEFAULTSURFACEEXTENSION;
}
try
{
finalFileName += extension;
if(extension == ".stl" )
{
mitk::SurfaceVtkWriter<vtkSTLWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkSTLWriter>::New();
// check if surface actually consists of triangles; if not, the writer will not do anything; so, convert to triangles...
vtkPolyData* polys = surface->GetVtkPolyData();
if( polys->GetNumberOfStrips() > 0 )
{
vtkSmartPointer<vtkTriangleFilter> triangleFilter = vtkSmartPointer<vtkTriangleFilter>::New();
triangleFilter->SetInput(polys);
triangleFilter->Update();
polys = triangleFilter->GetOutput();
polys->Register(NULL);
surface->SetVtkPolyData(polys);
}
surfaceWriter->SetInput( surface );
surfaceWriter->SetFileName( finalFileName.c_str() );
surfaceWriter->GetVtkWriter()->SetFileTypeToBinary();
surfaceWriter->Write();
}
else if(extension == ".vtp")
{
mitk::SurfaceVtkWriter<vtkXMLPolyDataWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkXMLPolyDataWriter>::New();
surfaceWriter->SetInput( surface );
surfaceWriter->SetFileName( finalFileName.c_str() );
surfaceWriter->GetVtkWriter()->SetDataModeToBinary();
surfaceWriter->Write();
}
else if(extension == ".vtk")
{
mitk::SurfaceVtkWriter<vtkPolyDataWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkPolyDataWriter>::New();
surfaceWriter->SetInput( surface );
surfaceWriter->SetFileName( finalFileName.c_str() );
surfaceWriter->Write();
}
else
{
// file extension not suitable for writing specified data type
MITK_ERROR << "File extension is not suitable for writing'" << finalFileName;
mitkThrow() << "An exception occured during writing the file " << finalFileName <<
". File extension " << extension << " is not suitable for writing.";
}
}
catch(std::exception& e)
{
MITK_ERROR << " during attempt to write '" << finalFileName << "' Exception says:";
MITK_ERROR << e.what();
mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
}
return true;
}
bool IOUtil::SavePointSet(PointSet::Pointer pointset, const std::string path)
{
mitk::PointSetWriter::Pointer pointSetWriter = mitk::PointSetWriter::New();
std::string dir = itksys::SystemTools::GetFilenamePath( path );
std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
std::string finalFileName = dir + "/" + baseFilename;
if (extension == "") // if no extension has been entered manually into the filename
{
MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
<< DEFAULTPOINTSETEXTENSION;
extension = DEFAULTPOINTSETEXTENSION;
}
// check if extension is valid
if (!pointSetWriter->IsExtensionValid(extension))
{
MITK_WARN << extension << " extension is unknown. Extension set to default: " << finalFileName
<< DEFAULTPOINTSETEXTENSION;
extension = DEFAULTPOINTSETEXTENSION;
}
try
{
pointSetWriter->SetInput( pointset );
finalFileName += extension;
pointSetWriter->SetFileName( finalFileName.c_str() );
pointSetWriter->Update();
}
catch( std::exception& e )
{
MITK_ERROR << " during attempt to write '" << finalFileName << "' Exception says:";
MITK_ERROR << e.what();
mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
}
return true;
}
}
diff --git a/Core/Code/IO/mitkImageGenerator.h b/Core/Code/IO/mitkImageGenerator.h
index 32afe9a0d9..8047c0818c 100644
--- a/Core/Code/IO/mitkImageGenerator.h
+++ b/Core/Code/IO/mitkImageGenerator.h
@@ -1,178 +1,183 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef ImageGenerator_H_HEADER_INCLUDED
#define ImageGenerator_H_HEADER_INCLUDED
#include <MitkExports.h>
#include <mitkImage.h>
#include <itkMersenneTwisterRandomVariateGenerator.h>
#include <itkImageRegionIterator.h>
namespace mitk {
//##Documentation
//## @brief generator for synthetic MITK images
//## This is a helper class to generate synthetic MITK images (random or gradient).
//## @ingroup IO
class MITK_CORE_EXPORT ImageGenerator
{
public:
/*!
\brief Generates gradient image with the defined size and spacing
*/
template <typename TPixelType>
static mitk::Image::Pointer GenerateGradientImage(unsigned int dimX,
unsigned int dimY,
unsigned int dimZ,
float spacingX = 1,
float spacingY = 1,
float spacingZ = 1)
{
- itk::ImageRegion<3> imageRegion;
+ typedef itk::Image< TPixelType, 3 > ImageType;
+ typename ImageType::RegionType imageRegion;
imageRegion.SetSize(0, dimX);
imageRegion.SetSize(1, dimY);
imageRegion.SetSize(2, dimZ);
- mitk::Vector3D spacing;
+ typename ImageType::SpacingType spacing;
spacing[0] = spacingX;
spacing[1] = spacingY;
spacing[2] = spacingZ;
mitk::Point3D origin; origin.Fill(0.0);
itk::Matrix<double, 3, 3> directionMatrix; directionMatrix.SetIdentity();
- typedef itk::Image< TPixelType, 3 > ImageType;
typename ImageType::Pointer image = ImageType::New();
image->SetSpacing( spacing );
image->SetOrigin( origin );
image->SetDirection( directionMatrix );
image->SetLargestPossibleRegion( imageRegion );
image->SetBufferedRegion( imageRegion );
image->SetRequestedRegion( imageRegion );
image->Allocate();
image->FillBuffer(0.0);
typedef itk::ImageRegionIterator<ImageType> IteratorOutputType;
IteratorOutputType it(image, imageRegion);
it.GoToBegin();
TPixelType val = 0;
while(!it.IsAtEnd())
{
it.Set(val);
val++;
++it;
}
mitk::Image::Pointer mitkImage = mitk::Image::New();
mitkImage->InitializeByItk( image.GetPointer() );
mitkImage->SetVolume( image->GetBufferPointer() );
return mitkImage;
}
/*!
\brief Generates random image with the defined size and spacing
*/
template <typename TPixelType>
static mitk::Image::Pointer GenerateRandomImage(unsigned int dimX,
unsigned int dimY,
unsigned int dimZ = 1,
unsigned int dimT = 1,
float spacingX = 1,
float spacingY = 1,
float spacingZ = 1,
const double randomMax = 1000.0f, const double randMin = 0.0f)
{
//set the data type according to the template
mitk::PixelType type = MakeScalarPixelType<TPixelType>();
//type.Initialize(typeid(TPixelType));
//initialize the MITK image with given dimenion and data type
mitk::Image::Pointer output = mitk::Image::New();
unsigned int* dimensions = new unsigned int[4];
unsigned int numberOfDimensions = 0;
unsigned int bufferSize = 0;
//check which dimension is needed
if(dimT <= 1)
{
if(dimZ <= 1)
{ //2D
numberOfDimensions = 2;
dimensions[0] = dimX;
dimensions[1] = dimY;
bufferSize = dimX*dimY;
}
else
{ //3D
numberOfDimensions = 3;
dimensions[0] = dimX;
dimensions[1] = dimY;
dimensions[2] = dimZ;
bufferSize = dimX*dimY*dimZ;
}
}
else
{ //4D
numberOfDimensions = 4;
dimensions[0] = dimX;
dimensions[1] = dimY;
dimensions[2] = dimZ;
dimensions[3] = dimT;
bufferSize = dimX*dimY*dimZ*dimT;
}
output->Initialize(type, numberOfDimensions, dimensions);
mitk::Vector3D spacing;
spacing[0] = spacingX;
spacing[1] = spacingY;
spacing[2] = spacingZ;
output->SetSpacing(spacing);
//get a pointer to the image buffer to write into
TPixelType* imageBuffer = (TPixelType*)output->GetData();
//initialize the random generator
itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
randomGenerator->Initialize();
//fill the buffer for each pixel/voxel
for(unsigned int i = 0; i < bufferSize; i++)
{
// the comparison of the component type is sufficient enough since the mitk::PixelType type object is
// created as SCALAR and hence does not need the comparison against type.GetPixelTypeId() == itk::ImageIOBase::SCALAR
- if(type.GetTypeId() == typeid(int)) //call integer function
+ if(type.GetComponentType() == itk::ImageIOBase::INT) //call integer function
{
imageBuffer[i] = (TPixelType)randomGenerator->GetIntegerVariate((int)randomMax);
//TODO random generator does not support integer values in a given range (e.g. from 5-10)
//range is always [0, (int)randomMax]
- }else if((type.GetTypeId() == typeid(double)) || (type.GetTypeId() == typeid(float))) //call integer function
+ }
+ else if((type.GetComponentType() == itk::ImageIOBase::DOUBLE) ||
+ (type.GetComponentType() == itk::ImageIOBase::FLOAT)) //call floating point function
{
imageBuffer[i] = (TPixelType)randomGenerator->GetUniformVariate(randMin,randomMax);
- }else if(type.GetTypeId() == typeid(unsigned char))
+ }
+ else if(type.GetComponentType() == itk::ImageIOBase::UCHAR)
{
//use the integer randomGenerator with mod 256 to generate unsigned char values
imageBuffer[i] = (unsigned char) ((int)randomGenerator->GetIntegerVariate((int)randomMax)) % 256;
- }else{
+ }
+ else
+ {
MITK_ERROR << "Datatype not supported yet.";
//TODO call different methods for other datatypes
}
}
return output;
}
};
} // namespace mitk
#endif /* ImageGenerator_H_HEADER_INCLUDED */
diff --git a/Core/Code/IO/mitkImageWriter.cpp b/Core/Code/IO/mitkImageWriter.cpp
index 2a66eec545..b915f30859 100644
--- a/Core/Code/IO/mitkImageWriter.cpp
+++ b/Core/Code/IO/mitkImageWriter.cpp
@@ -1,379 +1,377 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImageWriter.h"
#include "mitkItkPictureWrite.h"
#include "mitkImage.h"
#include "mitkImageTimeSelector.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageReadAccessor.h"
#include <itkImageIOBase.h>
#include <itkImageIOFactory.h>
mitk::ImageWriter::ImageWriter()
{
this->SetNumberOfRequiredInputs( 1 );
m_MimeType = "";
SetDefaultExtension();
}
mitk::ImageWriter::~ImageWriter()
{
}
void mitk::ImageWriter::SetDefaultExtension()
{
m_Extension = ".mhd";
}
#include <vtkConfigure.h>
#include <vtkImageData.h>
#include <vtkXMLImageDataWriter.h>
static void writeVti(const char * filename, mitk::Image* image, int t=0)
{
vtkXMLImageDataWriter * vtkwriter = vtkXMLImageDataWriter::New();
vtkwriter->SetFileName( filename );
vtkwriter->SetInput(image->GetVtkImageData(t));
vtkwriter->Write();
vtkwriter->Delete();
}
#include <itkRGBAPixel.h>
void mitk::ImageWriter::WriteByITK(mitk::Image* image, const std::string& fileName)
{
// Pictures and picture series like .png are written via a different mechanism then volume images.
// So, they are still multiplexed and thus not support vector images.
if (fileName.find(".png") != std::string::npos || fileName.find(".tif") != std::string::npos || fileName.find(".jpg") != std::string::npos)
{
try
{
// switch processing of single/multi-component images
if( image->GetPixelType(0).GetNumberOfComponents() == 1)
{
AccessByItk_1( image, _mitkItkPictureWrite, fileName );
}
else
{
AccessFixedPixelTypeByItk_1( image, _mitkItkPictureWriteComposite, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ , fileName);
}
}
catch(itk::ExceptionObject &e)
{
std::cerr << "Caught " << e.what() << std::endl;
}
catch(std::exception &e)
{
std::cerr << "Caught std::exception " << e.what() << std::endl;
}
return;
}
// Implementation of writer using itkImageIO directly. This skips the use
// of templated itkImageFileWriter, which saves the multiplexing on MITK side.
unsigned int dimension = image->GetDimension();
unsigned int* dimensions = image->GetDimensions();
mitk::PixelType pixelType = image->GetPixelType();
mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
mitk::Point3D origin = image->GetGeometry()->GetOrigin();
itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( fileName.c_str(),
itk::ImageIOFactory::WriteMode );
if(imageIO.IsNull())
{
itkExceptionMacro(<< "Error: Could not create itkImageIO via factory for file " << fileName);
}
// Set the necessary information for imageIO
imageIO->SetNumberOfDimensions(dimension);
- imageIO->SetPixelTypeInfo( pixelType.GetTypeId() );
- // Set also the PixelTypeIO information since it is available after
- // the changes in PixelType for Bug #12838
- imageIO->SetPixelType( pixelType.GetPixelTypeId() );
-
- if(pixelType.GetNumberOfComponents() > 1)
- imageIO->SetNumberOfComponents( pixelType.GetNumberOfComponents() );
+ imageIO->SetPixelType( pixelType.GetPixelType() );
+ imageIO->SetComponentType( pixelType.GetComponentType() < PixelComponentUserType ?
+ static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
+ itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
+ imageIO->SetNumberOfComponents( pixelType.GetNumberOfComponents() );
itk::ImageIORegion ioRegion( dimension );
for(unsigned int i=0; i<dimension; i++)
{
imageIO->SetDimensions(i,dimensions[i]);
imageIO->SetSpacing(i,spacing[i]);
imageIO->SetOrigin(i,origin[i]);
mitk::Vector3D direction;
- direction.Set_vnl_vector(image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
+ direction.SetVnlVector(image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
vnl_vector< double > axisDirection(dimension);
for(unsigned int j=0; j<dimension; j++)
{
axisDirection[j] = direction[j]/spacing[i];
}
imageIO->SetDirection( i, axisDirection );
ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i) );
ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i) );
}
//use compression if available
imageIO->UseCompressionOn();
imageIO->SetIORegion(ioRegion);
imageIO->SetFileName(fileName);
ImageReadAccessor imageAccess(image);
imageIO->Write(imageAccess.GetData());
}
void mitk::ImageWriter::GenerateData()
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
if ( m_FileName == "" )
{
itkWarningMacro( << "Sorry, filename has not been set!" );
return ;
}
FILE* tempFile = fopen(m_FileName.c_str(),"w");
if (tempFile==NULL)
{
itkExceptionMacro(<<"File location not writeable");
return;
}
fclose(tempFile);
remove(m_FileName.c_str());
// Creating clone of input image, since i might change the geometry
mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput())->Clone();
// Check if geometry information will be lost
if (input->GetDimension() == 2)
{
if (!input->GetGeometry()->Is2DConvertable())
{
MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might consider using Convert2Dto3DImageFilter before saving.";
// set matrix to identity
mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
affTrans->SetIdentity();
mitk::Vector3D spacing = input->GetGeometry()->GetSpacing();
mitk::Point3D origin = input->GetGeometry()->GetOrigin();
input->GetGeometry()->SetIndexToWorldTransform(affTrans);
input->GetGeometry()->SetSpacing(spacing);
input->GetGeometry()->SetOrigin(origin);
}
}
bool vti = (m_Extension.find(".vti") != std::string::npos);
// If the extension is NOT .pic and NOT .nrrd and NOT .nii and NOT .nii.gz the following block is entered
if ( m_Extension.find(".pic") == std::string::npos
&& m_Extension.find(".nrrd") == std::string::npos
&& m_Extension.find(".nii") == std::string::npos
&& m_Extension.find(".nii.gz") == std::string::npos
)
{
if(input->GetDimension() > 3)
{
int t, timesteps;
timesteps = input->GetDimension(3);
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput(input);
mitk::Image::Pointer image = timeSelector->GetOutput();
for(t = 0; t < timesteps; ++t)
{
- ::itk::OStringStream filename;
+ std::ostringstream filename;
timeSelector->SetTimeNr(t);
timeSelector->Update();
if(input->GetTimeSlicedGeometry()->IsValidTime(t))
{
const mitk::TimeBounds& timebounds = input->GetTimeSlicedGeometry()->GetGeometry3D(t)->GetTimeBounds();
filename << m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
}
else
{
itkWarningMacro(<<"Error on write: TimeSlicedGeometry invalid of image " << filename << ".");
filename << m_FileName.c_str() << "_T" << t << m_Extension;
}
if ( vti )
{
writeVti(filename.str().c_str(), input, t);
}
else
{
WriteByITK(image, filename.str());
}
}
}
else if ( vti )
{
- ::itk::OStringStream filename;
+ std::ostringstream filename;
filename << m_FileName.c_str() << m_Extension;
writeVti(filename.str().c_str(), input);
}
else
{
- ::itk::OStringStream filename;
+ std::ostringstream filename;
filename << m_FileName.c_str() << m_Extension;
WriteByITK(input, filename.str());
}
}
else
{
// use the PicFileWriter for the .pic data type
if( m_Extension.find(".pic") != std::string::npos )
{
/* PicFileWriter::Pointer picWriter = PicFileWriter::New();
size_t found;
found = m_FileName.find( m_Extension ); // !!! HAS to be at the very end of the filename (not somewhere in the middle)
if( m_FileName.length() > 3 && found != m_FileName.length() - 4 )
{
//if Extension not in Filename
- ::itk::OStringStream filename;
+ std::ostringstream filename;
filename << m_FileName.c_str() << m_Extension;
picWriter->SetFileName( filename.str().c_str() );
}
else
{
picWriter->SetFileName( m_FileName.c_str() );
}
picWriter->SetInputImage( input );
picWriter->Write();
*/ }
// use the ITK .nrrd Image writer
if( m_Extension.find(".nrrd") != std::string::npos
|| m_Extension.find(".nii") != std::string::npos
|| m_Extension.find(".nii.gz") != std::string::npos
)
{
- ::itk::OStringStream filename;
+ std::ostringstream filename;
filename << this->m_FileName.c_str() << this->m_Extension;
WriteByITK(input, filename.str());
}
}
m_MimeType = "application/MITK.Pic";
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
bool mitk::ImageWriter::CanWriteDataType( DataNode* input )
{
if ( input )
{
mitk::BaseData* data = input->GetData();
if ( data )
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( data );
if( image.IsNotNull() )
{
//"SetDefaultExtension()" set m_Extension to ".mhd" ?????
m_Extension = ".pic";
return true;
}
}
}
return false;
}
void mitk::ImageWriter::SetInput( DataNode* input )
{
if( input && CanWriteDataType( input ) )
this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::Image*>( input->GetData() ) );
}
std::string mitk::ImageWriter::GetWritenMIMEType()
{
return m_MimeType;
}
std::vector<std::string> mitk::ImageWriter::GetPossibleFileExtensions()
{
std::vector<std::string> possibleFileExtensions;
possibleFileExtensions.push_back(".pic");
possibleFileExtensions.push_back(".bmp");
possibleFileExtensions.push_back(".dcm");
possibleFileExtensions.push_back(".DCM");
possibleFileExtensions.push_back(".dicom");
possibleFileExtensions.push_back(".DICOM");
possibleFileExtensions.push_back(".gipl");
possibleFileExtensions.push_back(".gipl.gz");
possibleFileExtensions.push_back(".mha");
possibleFileExtensions.push_back(".nii");
possibleFileExtensions.push_back(".nrrd");
possibleFileExtensions.push_back(".nhdr");
possibleFileExtensions.push_back(".png");
possibleFileExtensions.push_back(".PNG");
possibleFileExtensions.push_back(".spr");
possibleFileExtensions.push_back(".mhd");
possibleFileExtensions.push_back(".vtk");
possibleFileExtensions.push_back(".vti");
possibleFileExtensions.push_back(".hdr");
possibleFileExtensions.push_back(".png");
possibleFileExtensions.push_back(".tif");
possibleFileExtensions.push_back(".jpg");
return possibleFileExtensions;
}
std::string mitk::ImageWriter::GetFileExtension()
{
return m_Extension;
}
void mitk::ImageWriter::SetInput( mitk::Image* image )
{
this->ProcessObject::SetNthInput( 0, image );
}
const mitk::Image* mitk::ImageWriter::GetInput()
{
if ( this->GetNumberOfInputs() < 1 )
{
return NULL;
}
else
{
return static_cast< const mitk::Image * >( this->ProcessObject::GetInput( 0 ) );
}
}
diff --git a/Core/Code/IO/mitkImageWriter.h b/Core/Code/IO/mitkImageWriter.h
index 107179ae9a..1b5c5a82f8 100644
--- a/Core/Code/IO/mitkImageWriter.h
+++ b/Core/Code/IO/mitkImageWriter.h
@@ -1,158 +1,159 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_IMAGE_WRITER__H_
#define _MITK_IMAGE_WRITER__H_
#include <mitkFileWriter.h>
namespace mitk
{
class Image;
/**
* @brief Writer for mitk::Image
*
* Uses the given extension (SetExtension) to decide the format to write
* (.mhd is default, .pic, .tif, .png, .jpg supported yet).
* @ingroup IO
*/
class MITK_CORE_EXPORT ImageWriter : public mitk::FileWriter
{
public:
mitkClassMacro( ImageWriter, mitk::FileWriter );
itkNewMacro( Self );
mitkWriterMacro;
/**
* Sets the filename of the file to write.
* @param _arg the name of the file to write.
*/
itkSetStringMacro( FileName );
/**
* @returns the name of the file to be written to disk.
*/
itkGetStringMacro( FileName );
/**
* \brief Explicitly set the extension to be added to the filename.
* @param _arg to be added to the filename, including a "."
* (e.g., ".mhd").
*/
itkSetStringMacro( Extension );
/**
* \brief Get the extension to be added to the filename.
* @returns the extension to be added to the filename (e.g.,
* ".mhd").
*/
itkGetStringMacro( Extension );
/**
* \brief Set the extension to be added to the filename to the default
*/
void SetDefaultExtension();
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePrefix );
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePrefix );
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePattern );
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePattern );
/**
* Sets the 0'th input object for the filter.
* @param input the first input for the filter.
*/
void SetInput( mitk::Image* input );
//##Documentation
//## @brief Return the possible file extensions for the data type associated with the writer
virtual std::vector<std::string> GetPossibleFileExtensions();
/**
* @brief Return the extension to be added to the filename.
*/
virtual std::string GetFileExtension();
/**
* @brief Check if the Writer can write the Content of the
*/
virtual bool CanWriteDataType( DataNode* );
/**
* @brief Return the MimeType of the saved File.
*/
virtual std::string GetWritenMIMEType();
+ using Superclass::SetInput;
/**
* @brief Set the DataTreenode as Input. Important: The Writer always have a SetInput-Function.
*/
virtual void SetInput( DataNode* );
/**
* @returns the 0'th input object of the filter.
*/
const mitk::Image* GetInput();
protected:
/**
* Constructor.
*/
ImageWriter();
/**
* Virtual destructor.
*/
virtual ~ImageWriter();
virtual void GenerateData();
virtual void WriteByITK(mitk::Image* image, const std::string& fileName);
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
std::string m_Extension;
std::string m_MimeType;
};
}
#endif //_MITK_IMAGE_WRITER__H_
diff --git a/Core/Code/IO/mitkItkImageFileReader.cpp b/Core/Code/IO/mitkItkImageFileReader.cpp
index 6d09f51ac9..64844dd321 100644
--- a/Core/Code/IO/mitkItkImageFileReader.cpp
+++ b/Core/Code/IO/mitkItkImageFileReader.cpp
@@ -1,209 +1,205 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkItkImageFileReader.h"
#include "mitkConfig.h"
#include "mitkException.h"
#include <itkImageFileReader.h>
#include <itksys/SystemTools.hxx>
#include <itksys/Directory.hxx>
#include <itkImage.h>
//#include <itkImageSeriesReader.h>
#include <itkImageFileReader.h>
#include <itkImageIOFactory.h>
#include <itkImageIORegion.h>
//#include <itkImageSeriesReader.h>
//#include <itkDICOMImageIO2.h>
//#include <itkDICOMSeriesFileNames.h>
//#include <itkGDCMImageIO.h>
//#include <itkGDCMSeriesFileNames.h>
//#include <itkNumericSeriesFileNames.h>
void mitk::ItkImageFileReader::GenerateData()
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
mitk::Image::Pointer image = this->GetOutput();
const unsigned int MINDIM = 2;
const unsigned int MAXDIM = 4;
MITK_INFO << "loading " << m_FileName << " via itk::ImageIOFactory... " << std::endl;
// Check to see if we can read the file given the name or prefix
if ( m_FileName == "" )
{
mitkThrow() << "Empty filename in mitk::ItkImageFileReader ";
return ;
}
itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( m_FileName.c_str(), itk::ImageIOFactory::ReadMode );
if ( imageIO.IsNull() )
{
//itkWarningMacro( << "File Type not supported!" );
mitkThrow() << "Could not create itk::ImageIOBase object for filename " << m_FileName;
return ;
}
// Got to allocate space for the image. Determine the characteristics of
// the image.
imageIO->SetFileName( m_FileName.c_str() );
imageIO->ReadImageInformation();
unsigned int ndim = imageIO->GetNumberOfDimensions();
if ( ndim < MINDIM || ndim > MAXDIM )
{
itkWarningMacro( << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim << " dimensions! Reading as 4D." );
ndim = MAXDIM;
}
itk::ImageIORegion ioRegion( ndim );
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
unsigned int dimensions[ MAXDIM ];
dimensions[ 0 ] = 0;
dimensions[ 1 ] = 0;
dimensions[ 2 ] = 0;
dimensions[ 3 ] = 0;
float spacing[ MAXDIM ];
spacing[ 0 ] = 1.0f;
spacing[ 1 ] = 1.0f;
spacing[ 2 ] = 1.0f;
spacing[ 3 ] = 1.0f;
Point3D origin;
origin.Fill(0);
unsigned int i;
for ( i = 0; i < ndim ; ++i )
{
ioStart[ i ] = 0;
ioSize[ i ] = imageIO->GetDimensions( i );
if(i<MAXDIM)
{
dimensions[ i ] = imageIO->GetDimensions( i );
spacing[ i ] = imageIO->GetSpacing( i );
if(spacing[ i ] <= 0)
spacing[ i ] = 1.0f;
}
if(i<3)
{
origin[ i ] = imageIO->GetOrigin( i );
}
}
ioRegion.SetSize( ioSize );
ioRegion.SetIndex( ioStart );
MITK_INFO << "ioRegion: " << ioRegion << std::endl;
imageIO->SetIORegion( ioRegion );
void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
imageIO->Read( buffer );
- mitk::PixelType pixelType = mitk::PixelType(imageIO->GetComponentTypeInfo(), imageIO->GetPixelType(),
- imageIO->GetComponentSize(), imageIO->GetNumberOfComponents(),
- imageIO->GetComponentTypeAsString( imageIO->GetComponentType() ).c_str(),
- imageIO->GetPixelTypeAsString( imageIO->GetPixelType() ).c_str() );
- image->Initialize( pixelType, ndim, dimensions );
+ image->Initialize( MakePixelType(imageIO), ndim, dimensions );
image->SetImportChannel( buffer, 0, Image::ManageMemory );
// access direction of itk::Image and include spacing
mitk::Matrix3D matrix;
matrix.SetIdentity();
unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
for ( i=0; i < itkDimMax3; ++i)
for( j=0; j < itkDimMax3; ++j )
matrix[i][j] = imageIO->GetDirection(j)[i];
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(image->GetSlicedGeometry(0)->GetGeometry2D(0));
planeGeometry->SetOrigin(origin);
planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
// re-initialize SlicedGeometry3D
SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
slicedGeometry->SetSpacing(spacing);
// re-initialize TimeSlicedGeometry
image->GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, image->GetDimension(3));
buffer = NULL;
MITK_INFO << "number of image components: "<< image->GetPixelType().GetNumberOfComponents() << std::endl;
// mitk::DataNode::Pointer node = this->GetOutput();
// node->SetData( image );
// add level-window property
//if ( image->GetPixelType().GetNumberOfComponents() == 1 )
//{
// SetDefaultImageProperties( node );
//}
MITK_INFO << "...finished!" << std::endl;
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
bool mitk::ItkImageFileReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
// First check the extension
if( filename == "" )
return false;
// check if image is serie
if( filePattern != "" && filePrefix != "" )
return false;
itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( filename.c_str(), itk::ImageIOFactory::ReadMode );
if ( imageIO.IsNull() )
return false;
return true;
}
mitk::ItkImageFileReader::ItkImageFileReader()
: m_FileName(""), m_FilePrefix(""), m_FilePattern("")
{
}
mitk::ItkImageFileReader::~ItkImageFileReader()
{
}
diff --git a/Core/Code/IO/mitkLookupTableProperty.cpp b/Core/Code/IO/mitkLookupTableProperty.cpp
index e3dbd846c8..7a3b011581 100755
--- a/Core/Code/IO/mitkLookupTableProperty.cpp
+++ b/Core/Code/IO/mitkLookupTableProperty.cpp
@@ -1,86 +1,80 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLookupTableProperty.h"
mitk::LookupTableProperty::LookupTableProperty()
{
}
mitk::LookupTableProperty::LookupTableProperty(const LookupTableProperty& other)
: mitk::BaseProperty(other)
, m_LookupTable(other.m_LookupTable)
{
}
mitk::LookupTableProperty::LookupTableProperty(const mitk::LookupTable::Pointer lut)
{
this->SetLookupTable(lut);
}
bool mitk::LookupTableProperty::IsEqual(const BaseProperty& property) const
{
return *(this->m_LookupTable) == *(static_cast<const Self&>(property).m_LookupTable);
}
bool mitk::LookupTableProperty::Assign(const BaseProperty& property)
{
this->m_LookupTable = static_cast<const Self&>(property).m_LookupTable;
return true;
}
std::string mitk::LookupTableProperty::GetValueAsString() const
{
std::stringstream ss;
ss << m_LookupTable;
return ss.str();
}
mitk::LookupTableProperty::ValueType mitk::LookupTableProperty::GetValue() const
{
return m_LookupTable;
}
void mitk::LookupTableProperty::SetLookupTable(const mitk::LookupTable::Pointer aLookupTable)
{
// MITK_INFO << "setting LUT property ... " << std::endl;
if((m_LookupTable != aLookupTable) || (*m_LookupTable != *aLookupTable))
{
m_LookupTable = aLookupTable;
Modified();
}
// MITK_INFO << "setting LUT property OK! " << std::endl;
}
void mitk::LookupTableProperty::SetValue(const ValueType & value)
{
SetLookupTable(value);
}
-mitk::LookupTableProperty::Pointer mitk::LookupTableProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::LookupTableProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Core/Code/IO/mitkLookupTableProperty.h b/Core/Code/IO/mitkLookupTableProperty.h
index 73ed35ac0f..8ff875177e 100755
--- a/Core/Code/IO/mitkLookupTableProperty.h
+++ b/Core/Code/IO/mitkLookupTableProperty.h
@@ -1,89 +1,87 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKLookupTablePROPERTY_H_HEADER_INCLUDED_C10EEAA8
#define MITKLookupTablePROPERTY_H_HEADER_INCLUDED_C10EEAA8
#include <MitkExports.h>
#include "mitkBaseProperty.h"
#include "mitkLookupTable.h"
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
//##Documentation
//## @brief Property for LookupTable data
//##
//## @ingroup DataManagement
class MITK_CORE_EXPORT LookupTableProperty : public BaseProperty
{
protected:
LookupTable::Pointer m_LookupTable;
LookupTableProperty();
LookupTableProperty(const LookupTableProperty&);
LookupTableProperty(const mitk::LookupTable::Pointer lut);
public:
typedef LookupTable::Pointer ValueType;
mitkClassMacro(LookupTableProperty, BaseProperty);
itkNewMacro(LookupTableProperty);
mitkNewMacro1Param(LookupTableProperty, const mitk::LookupTable::Pointer);
- Pointer Clone() const;
-
itkGetObjectMacro(LookupTable, LookupTable );
ValueType GetValue() const;
void SetLookupTable(const mitk::LookupTable::Pointer aLookupTable);
void SetValue(const ValueType&);
virtual std::string GetValueAsString() const;
using BaseProperty::operator=;
private:
// purposely not implemented
LookupTableProperty& operator=(const LookupTableProperty&);
itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty& property) const;
virtual bool Assign(const BaseProperty& property);
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif /* MITKLookupTablePROPERTY_H_HEADER_INCLUDED_C10EEAA8 */
diff --git a/Core/Code/IO/mitkPixelType.cpp b/Core/Code/IO/mitkPixelType.cpp
index 1a66e3f766..463f5d5737 100644
--- a/Core/Code/IO/mitkPixelType.cpp
+++ b/Core/Code/IO/mitkPixelType.cpp
@@ -1,204 +1,121 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPixelType.h"
#include <mitkLogMacros.h>
-#include <itkVector.h>
-#include <itkRGBPixel.h>
-#include <itkRGBAPixel.h>
-#include <itkCovariantVector.h>
-#include "itkDiffusionTensor3D.h"
-
-#define HUNDRED_VECS(HUN) \
- TEN_VECS(HUN) \
- TEN_VECS(HUN+10) \
- TEN_VECS(HUN+20) \
- TEN_VECS(HUN+30) \
- TEN_VECS(HUN+40) \
- TEN_VECS(HUN+50) \
- TEN_VECS(HUN+60) \
- TEN_VECS(HUN+70) \
- TEN_VECS(HUN+80) \
- TEN_VECS(HUN+90) \
-
-#define TEN_VECS(TEN) \
- if(false){} \
- N_VEC(TEN+ 1) \
- N_VEC(TEN+ 2) \
- N_VEC(TEN+ 3) \
- N_VEC(TEN+ 4) \
- N_VEC(TEN+ 5) \
- N_VEC(TEN+ 6) \
- N_VEC(TEN+ 7) \
- N_VEC(TEN+ 8) \
- N_VEC(TEN+ 9) \
- N_VEC(TEN+10) \
-
-#define N_VEC(N_DIRS) \
- _N_VEC(N_DIRS,double) \
- _N_VEC(N_DIRS,float) \
- _N_VEC(N_DIRS,short) \
-
-#define _N_VEC(N_DIRS,PIXTYPE) \
- else if ( *m_TypeId == typeid( itk::Vector<PIXTYPE,N_DIRS> )) \
- { \
- found = true; \
- m_TypeId = & typeid( PIXTYPE ); \
- m_NumberOfComponents *= N_DIRS; \
- m_Type = mitkIpPicFloat; \
- m_Bpe = sizeof(PIXTYPE) * 8 * m_NumberOfComponents; \
- m_ItkTypeId = &typeid( itk::Vector<PIXTYPE,N_DIRS> ); \
- } \
-
-
-
-const std::type_info &mitk::GetPixelTypeFromITKImageIO(const itk::ImageIOBase::Pointer imageIO)
-{
- // return the component type for scalar types
- if( imageIO->GetNumberOfComponents() == 1)
- {
- return imageIO->GetComponentTypeInfo();
- }
- else
- {
- itk::ImageIOBase::IOPixelType ptype = imageIO->GetPixelType();
-
- switch(ptype)
- {
- case itk::ImageIOBase::RGBA:
- return typeid( itk::RGBAPixel< unsigned char> );
- break;
- case itk::ImageIOBase::RGB:
- return typeid( itk::RGBPixel< unsigned char>);
- break;
- default:
- return imageIO->GetComponentTypeInfo();
- }
- }
-}
+
mitk::PixelType::PixelType( const mitk::PixelType& other )
: m_ComponentType( other.m_ComponentType ),
m_PixelType( other.m_PixelType),
m_ComponentTypeName( other.m_ComponentTypeName ),
m_PixelTypeName( other.m_PixelTypeName ),
m_NumberOfComponents( other.m_NumberOfComponents ),
m_BytesPerComponent( other.m_BytesPerComponent )
{
+}
+
+itk::ImageIOBase::IOPixelType mitk::PixelType::GetPixelType() const
+{
+ return m_PixelType;
+}
+
+int mitk::PixelType::GetComponentType() const
+{
+ return m_ComponentType;
+}
+
+std::string mitk::PixelType::GetPixelTypeAsString() const
+{
+ return m_PixelTypeName;
+}
+
+std::string mitk::PixelType::GetComponentTypeAsString() const
+{
+ return m_ComponentTypeName;
+}
+
+std::string mitk::PixelType::GetTypeAsString() const
+{
+ return m_PixelTypeName + " (" + m_ComponentTypeName + ")";
+}
+
+size_t mitk::PixelType::GetSize() const
+{
+ return (m_NumberOfComponents * m_BytesPerComponent);
+}
+
+size_t mitk::PixelType::GetBpe() const
+{
+ return this->GetSize() * 8;
+}
+size_t mitk::PixelType::GetNumberOfComponents() const
+{
+ return m_NumberOfComponents;
+}
+
+size_t mitk::PixelType::GetBitsPerComponent() const
+{
+ return m_BytesPerComponent * 8;
+}
+
+mitk::PixelType::~PixelType()
+{}
+
+mitk::PixelType::PixelType( const int componentType,
+ const ItkIOPixelType pixelType,
+ std::size_t bytesPerComponent,
+ std::size_t numberOfComponents,
+ const std::string& componentTypeName,
+ const std::string& pixelTypeName)
+ : m_ComponentType( componentType ),
+ m_PixelType( pixelType ),
+ m_ComponentTypeName(componentTypeName),
+ m_PixelTypeName(pixelTypeName),
+ m_NumberOfComponents( numberOfComponents ),
+ m_BytesPerComponent( bytesPerComponent )
+{
}
bool mitk::PixelType::operator==(const mitk::PixelType& rhs) const
{
MITK_DEBUG << "operator==" << std::endl;
MITK_DEBUG << "m_NumberOfComponents = " << m_NumberOfComponents << " " << rhs.m_NumberOfComponents << std::endl;
MITK_DEBUG << "m_BytesPerComponent = " << m_BytesPerComponent << " " << rhs.m_BytesPerComponent << std::endl;
MITK_DEBUG << "m_PixelTypeName = " << m_PixelTypeName << " " << rhs.m_PixelTypeName << std::endl;
MITK_DEBUG << "m_PixelType = " << m_PixelType << " " << rhs.m_PixelType << std::endl;
bool returnValue = ( this->m_PixelType == rhs.m_PixelType
&& this->m_ComponentType == rhs.m_ComponentType
&& this->m_NumberOfComponents == rhs.m_NumberOfComponents
&& this->m_BytesPerComponent == rhs.m_BytesPerComponent
);
if(returnValue)
MITK_DEBUG << " [TRUE] ";
else
MITK_DEBUG << " [FALSE] ";
return returnValue;
}
bool mitk::PixelType::operator!=(const mitk::PixelType& rhs) const
{
return !(this->operator==(rhs));
}
-
-std::string mitk::PixelType::PixelNameFromItkIOType(ItkIOPixelType ptype)
-{
- std::string s;
- switch(ptype)
- {
- case itk::ImageIOBase::SCALAR:
- return (s = "scalar");
- case itk::ImageIOBase::VECTOR:
- return (s = "vector");
- case itk::ImageIOBase::COVARIANTVECTOR:
- return (s = "covariant_vector");
- case itk::ImageIOBase::POINT:
- return (s = "point");
- case itk::ImageIOBase::OFFSET:
- return (s = "offset");
- case itk::ImageIOBase::RGB:
- return (s = "rgb");
- case itk::ImageIOBase::RGBA:
- return (s = "rgba");
- case itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR:
- return (s = "symmetric_second_rank_tensor");
- case itk::ImageIOBase::DIFFUSIONTENSOR3D:
- return (s = "diffusion_tensor_3D");
- case itk::ImageIOBase::COMPLEX:
- return (s = "complex");
- case itk::ImageIOBase::UNKNOWNPIXELTYPE:
- break;
- default:
- mitkThrow() << "Unknown pixel type "<< ptype;
- }
- return (s="unknown");
-}
-
-#define SET_ITK_TYPE_ID(anItkIoPixelType_test, numberOfComponents_test, ITK_TYPE) \
- if ( (itk::ImageIOBase::anItkIoPixelType_test == anItkIoPixelType ) && \
- (numberOfComponents_test == m_NumberOfComponents) \
- ) \
- { * \
- m_ItkTypeId = &typeid(ITK_TYPE); \
- }
-
-#define SET_TYPE(TYPE, IPPIC_TYPE) \
- if ( *m_TypeId == typeid( TYPE ) ) \
- { \
- m_Type = IPPIC_TYPE; \
- m_Bpe = sizeof(TYPE) * 8 * m_NumberOfComponents; \
- \
- typedef itk::Vector<TYPE, 3> Vector3Type; \
- typedef itk::CovariantVector<TYPE, 3> CovariantVector3Type; \
- typedef itk::Point<TYPE, 3> Point3Type; \
- typedef itk::Vector<TYPE, 2> Vector2Type; \
- typedef itk::CovariantVector<TYPE, 2> CovariantVector2Type; \
- typedef itk::Point<TYPE, 2> Point2Type; \
- \
- SET_ITK_TYPE_ID(UNKNOWNPIXELTYPE, 1, TYPE ) else \
- SET_ITK_TYPE_ID(SCALAR, 1, TYPE ) else \
- \
- SET_ITK_TYPE_ID(VECTOR, 2, Vector2Type ) else \
- SET_ITK_TYPE_ID(COVARIANTVECTOR, 2, CovariantVector2Type ) else \
- SET_ITK_TYPE_ID(POINT, 2, Point2Type ) else \
- \
- SET_ITK_TYPE_ID(RGB, 3, itk::RGBPixel<TYPE> ) else \
- /*SET_ITK_TYPE_ID(DIFFUSIONTENSOR3D, 6, itk::DiffusionTensor3D<TYPE> ) else */ \
- SET_ITK_TYPE_ID(VECTOR, 3, Vector3Type ) else \
- SET_ITK_TYPE_ID(COVARIANTVECTOR, 3, CovariantVector3Type ) else \
- SET_ITK_TYPE_ID(POINT, 3, Point3Type ) else \
- \
- SET_ITK_TYPE_ID(RGBA, 4, itk::RGBAPixel<TYPE> ) else \
- { \
- } \
- } \
- else
diff --git a/Core/Code/IO/mitkPixelType.h b/Core/Code/IO/mitkPixelType.h
index e9ea5fc76c..fb50a3feb8 100644
--- a/Core/Code/IO/mitkPixelType.h
+++ b/Core/Code/IO/mitkPixelType.h
@@ -1,279 +1,233 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef PIXELTYPE_H_HEADER_INCLUDED_C1EBF565
#define PIXELTYPE_H_HEADER_INCLUDED_C1EBF565
#include <MitkExports.h>
#include "mitkCommon.h"
#include "mitkPixelTypeTraits.h"
#include <typeinfo>
#include <string>
#include <itkImageIOBase.h>
#include <itkImage.h>
namespace mitk {
-template< typename ComponentT>
-const char* ComponentTypeToString()
+template<typename T>
+std::string PixelComponentTypeToString()
{
- return typeid(ComponentT).name();
+ return itk::ImageIOBase::GetComponentTypeAsString(itk::ImageIOBase::MapPixelType<T>::CType);
}
template<typename PixelT>
-const char* PixelTypeToString()
+std::string PixelTypeToString()
{
- return typeid(PixelT).name();
+ return std::string();
}
//##Documentation
//## @brief Class for defining the data type of pixels
//##
//## To obtain additional type information not provided by this class
//## itk::ImageIOBase can be used by passing the return value of
//## PixelType::GetItkTypeId() to itk::ImageIOBase::SetPixelTypeInfo
//## and using the itk::ImageIOBase methods GetComponentType,
//## GetComponentTypeAsString, GetPixelType, GetPixelTypeAsString.
//## @ingroup Data
class MITK_CORE_EXPORT PixelType
{
public:
typedef itk::ImageIOBase::IOPixelType ItkIOPixelType;
+ typedef itk::ImageIOBase::IOComponentType ItkIOComponentType;
PixelType(const mitk::PixelType & aPixelType);
- /** \brief Get the \a type_info of the scalar (!) type. Each element
- * may contain m_NumberOfComponents (more than one) of these scalars.
- *
- */
- inline const std::type_info& GetTypeId() const
- {
- return m_ComponentType;
- }
-
- /** \brief Get the \a type_info of the whole pixel type.
- *
- * If you want the type information for the component of a compound type use the
- * GetTypeId() method
- */
- /*inline const std::type_info& GetPixelTypeId() const
- {
- return m_PixelType;
- }
-*/
- inline itk::ImageIOBase::IOPixelType GetPixelTypeId() const
- {
- return m_PixelType;
- }
-
- /** \brief Returns a string containing the ItkTypeName,
- *
- * The string provides the same information as GetPixelTypeId.name()
- */
- std::string GetItkTypeAsString() const
- {
- return m_PixelTypeName;
- }
-
- /** \brief Returns a string containing the type name of the component,
- *
- * The string provides the same information as GetTypeId.name()
- */
- std::string GetComponentTypeAsString() const
- {
- return m_ComponentTypeName;
- }
-
- /** \brief Get size of the PixelType in bytes
- *
- * A RGBA PixelType of floats will return 4 * sizeof(float)
- */
- size_t GetSize() const
- {
- return (m_NumberOfComponents * m_BytesPerComponent);
- }
-
- /** \brief Get the number of bits per element (of an
- * element)
- *
- * A vector of double with three components will return
- * 8*sizeof(double)*3.
- * \sa GetBitsPerComponent
- * \sa GetItkTypeId
- * \sa GetTypeId
- */
- size_t GetBpe() const
- {
- return this->GetSize() * 8;
- }
-
- /** \brief Get the number of components of which each element consists
- *
- * Each pixel can consist of multiple components, e.g. RGB.
- */
- inline size_t GetNumberOfComponents() const
- {
- return m_NumberOfComponents;
- }
-
- /** \brief Get the number of bits per components
- * \sa GetBitsPerComponent
- */
- inline size_t GetBitsPerComponent() const
- {
- return m_BytesPerComponent * 8;
- }
+ itk::ImageIOBase::IOPixelType GetPixelType() const;
+
+ /**
+ * \brief Get the \a component type (the scalar (!) type). Each element
+ * may contain m_NumberOfComponents (more than one) of these scalars.
+ *
+ */
+ int GetComponentType() const;
+
+ /**
+ * \brief Returns a string containing the ITK pixel type name.
+ */
+ std::string GetPixelTypeAsString() const;
+
+ /**
+ * \brief Returns a string containing the name of the component.
+ */
+ std::string GetComponentTypeAsString() const;
+
+ /**
+ * \brief Returns a string representing the pixel type and pixel components.
+ */
+ std::string GetTypeAsString() const;
+
+ /**
+ * \brief Get size of the PixelType in bytes
+ *
+ * A RGBA PixelType of floats will return 4 * sizeof(float)
+ */
+ size_t GetSize() const;
+
+ /**
+ * \brief Get the number of bits per element (of an
+ * element)
+ *
+ * A vector of double with three components will return
+ * 8*sizeof(double)*3.
+ * \sa GetBitsPerComponent
+ * \sa GetItkTypeId
+ * \sa GetTypeId
+ */
+ size_t GetBpe() const;
+
+ /**
+ * \brief Get the number of components of which each element consists
+ *
+ * Each pixel can consist of multiple components, e.g. RGB.
+ */
+ size_t GetNumberOfComponents() const;
+
+ /**
+ * \brief Get the number of bits per components
+ * \sa GetBitsPerComponent
+ */
+ size_t GetBitsPerComponent() const;
bool operator==(const PixelType& rhs) const;
bool operator!=(const PixelType& rhs) const;
- ~PixelType() {}
+ ~PixelType();
private:
- friend class ItkImageFileReader;
-
- friend class NrrdTbssImageReader;
- friend class NrrdTbssRoiImageReader;
+ friend PixelType MakePixelType(const itk::ImageIOBase* imageIO);
template< typename ComponentT, typename PixelT, std::size_t numberOfComponents >
friend PixelType MakePixelType();
template< typename ItkImageType >
friend PixelType MakePixelType();
- PixelType( const std::type_info& componentType,
- //const std::type_info& pixelType,
+ PixelType( const int componentType,
const ItkIOPixelType pixelType,
std::size_t bytesPerComponent,
std::size_t numberOfComponents,
- const char* componentTypeName = 0,
- const char* pixelTypeName = 0 )
- : m_ComponentType( componentType ),
- m_PixelType( pixelType ),
- m_NumberOfComponents( numberOfComponents ),
- m_BytesPerComponent( bytesPerComponent )
- {
- if(componentTypeName) m_ComponentTypeName = componentTypeName;
- else m_ComponentTypeName = componentType.name();
-
- if(pixelTypeName) m_PixelTypeName = pixelTypeName;
- //else m_PixelTypeName = pixelType.name();
- else m_PixelTypeName = this->PixelNameFromItkIOType( pixelType );
- }
-
- std::string PixelNameFromItkIOType( ItkIOPixelType ptype);
+ const std::string& componentTypeName,
+ const std::string& pixelTypeName);
// default constructor is disabled on purpose
PixelType(void);
// assignment operator declared private on purpose
PixelType& operator=(const PixelType& other);
/** \brief the \a type_info of the scalar (!) component type. Each element
may contain m_NumberOfComponents (more than one) of these scalars.
*/
- const std::type_info& m_ComponentType;
+ const int m_ComponentType;
const ItkIOPixelType m_PixelType;
- std::string m_ComponentTypeName;
+ const std::string m_ComponentTypeName;
- std::string m_PixelTypeName;
+ const std::string m_PixelTypeName;
std::size_t m_NumberOfComponents;
std::size_t m_BytesPerComponent;
};
/** \brief A template method for creating a pixel type.
*/
template< typename ComponentT, typename PixelT, std::size_t numOfComponents >
PixelType MakePixelType()
{
typedef itk::Image< PixelT, numOfComponents> ItkImageType;
- return PixelType( typeid(ComponentT), //typeid(ItkImageType),
- MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOType,
+ return PixelType( MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOComponentType,
+ MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOPixelType,
sizeof(ComponentT), numOfComponents,
- ComponentTypeToString<ComponentT>(),
- 0//PixelTypeToString<ItkImageType>()
+ PixelComponentTypeToString<ComponentT>(),
+ PixelTypeToString<PixelT>()
);
}
/** \brief A template method for creating a pixel type from an ItkImageType
*
* For fixed size vector images ( i.e. images of type itk::FixedArray<3,float> ) also the number of components
* is propagated to the constructor
*/
template< typename ItkImageType >
PixelType MakePixelType()
{
// define new type, since the ::PixelType is used to distinguish between simple and compound types
typedef typename ItkImageType::PixelType ImportPixelType;
// get the component type ( is either directly ImportPixelType or ImportPixelType::ValueType for compound types )
typedef typename GetComponentType<ImportPixelType>::ComponentType ComponentT;
// The PixelType is the same as the ComponentT for simple types
typedef typename ItkImageType::PixelType PixelT;
// Get the length of compound type ( initialized to 1 for simple types and variable-length vector images)
size_t numComp = ComponentsTrait<
(isPrimitiveType<PixelT>::value || isVectorImage<PixelT, ComponentT>::value), ItkImageType >::Size;
// call the constructor
return PixelType(
- typeid(ComponentT),
- MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOType,
- //MapCompositePixelType< PixelT >::IOType,
+ MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOComponentType,
+ MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOPixelType,
sizeof(ComponentT), numComp,
- ComponentTypeToString<ComponentT>(),
- 0
+ PixelComponentTypeToString<ComponentT>(),
+ PixelTypeToString<PixelT>()
);
}
+inline PixelType MakePixelType(const itk::ImageIOBase* imageIO)
+{
+ return mitk::PixelType(imageIO->GetComponentType(), imageIO->GetPixelType(),
+ imageIO->GetComponentSize(), imageIO->GetNumberOfComponents(),
+ imageIO->GetComponentTypeAsString(imageIO->GetComponentType()),
+ imageIO->GetPixelTypeAsString(imageIO->GetPixelType()));
+}
+
/** \brief An interface to the MakePixelType method for creating scalar pixel types.
*
* Usage: for example MakeScalarPixelType<short>() for a scalar short image
*/
template< typename T>
PixelType MakeScalarPixelType()
{
return MakePixelType<T,T,1>();
}
-/**
- * @brief Translate the itk::ImageIOBase::IOType to a std::type_info
- *
- * The functionality is similar to the itk::ImageIOBase::GetComponentTypeInfo but this one can also handle composite pixel types.
- *
- * @param imageIO the ImageIO associated with an image to be read-in
- * @return the typeid() of the given type for composite types, calls internal GetComponentTypeInfo for simple types
- */
-const std::type_info& GetPixelTypeFromITKImageIO( const itk::ImageIOBase::Pointer imageIO);
-
} // namespace mitk
#endif /* PIXELTYPE_H_HEADER_INCLUDED_C1EBF565 */
diff --git a/Core/Code/IO/mitkPixelTypeMultiplex.h b/Core/Code/IO/mitkPixelTypeMultiplex.h
index d97512b30e..71431b9ed6 100644
--- a/Core/Code/IO/mitkPixelTypeMultiplex.h
+++ b/Core/Code/IO/mitkPixelTypeMultiplex.h
@@ -1,141 +1,141 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKPIXELTYPEMULTIPLEX_H
#define MITKPIXELTYPEMULTIPLEX_H
#define mitkPixelTypeMultiplex0( function, ptype ) \
{ \
- if ( ptype.GetTypeId() == typeid(char) )\
+ if ( ptype.GetComponentType() == itk::ImageIOBase::CHAR )\
function<char>( ptype, );\
- else if ( ptype.GetTypeId() == typeid(unsigned char))\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UCHAR)\
function<unsigned char>( ptype, );\
- else if ( ptype.GetTypeId() == typeid(short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::SHORT )\
function<short>( ptype, ); \
- else if ( ptype.GetTypeId() == typeid(unsigned short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::USHORT )\
function<unsigned short>( ptype, );\
- else if ( ptype.GetTypeId() == typeid(int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::INT )\
function<int>( ptype, );\
- else if ( ptype.GetTypeId() == typeid(unsigned int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UINT )\
function<unsigned int>( ptype, );\
- else if ( ptype.GetTypeId() == typeid(long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::LONG )\
function<long int>( ptype, );\
- else if ( ptype.GetTypeId() == typeid(unsigned long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::ULONG )\
function<unsigned long int>( ptype, );\
- else if ( ptype.GetTypeId() == typeid(float) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::FLOAT )\
function<float>( ptype, );\
- else if ( ptype.GetTypeId() == typeid(double) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::DOUBLE )\
function<double>( ptype, );\
}\
#define mitkPixelTypeMultiplex1( function, ptype, param1 ) \
{ \
- if ( ptype.GetTypeId() == typeid(char) )\
+ if ( ptype.GetComponentType() == itk::ImageIOBase::CHAR )\
function<char>( ptype, param1 );\
- else if ( ptype.GetTypeId() == typeid(unsigned char))\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UCHAR)\
function<unsigned char>( ptype, param1 );\
- else if ( ptype.GetTypeId() == typeid(short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::SHORT )\
function<short>( ptype, param1 ); \
- else if ( ptype.GetTypeId() == typeid(unsigned short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::USHORT )\
function<unsigned short>( ptype, param1 );\
- else if ( ptype.GetTypeId() == typeid(int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::INT )\
function<int>( ptype, param1 );\
- else if ( ptype.GetTypeId() == typeid(unsigned int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UINT )\
function<unsigned int>( ptype, param1 );\
- else if ( ptype.GetTypeId() == typeid(long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::LONG )\
function<long int>( ptype, param1 );\
- else if ( ptype.GetTypeId() == typeid(unsigned long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::ULONG )\
function<unsigned long int>( ptype, param1 );\
- else if ( ptype.GetTypeId() == typeid(float) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::FLOAT )\
function<float>( ptype, param1 );\
- else if ( ptype.GetTypeId() == typeid(double) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::DOUBLE )\
function<double>( ptype, param1 );\
}\
#define mitkPixelTypeMultiplex2( function, ptype, param1, param2 ) \
{ \
- if ( ptype.GetTypeId() == typeid(char) )\
+ if ( ptype.GetComponentType() == itk::ImageIOBase::CHAR )\
function<char>( ptype, param1, param2 );\
- else if ( ptype.GetTypeId() == typeid(unsigned char))\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UCHAR)\
function<unsigned char>( ptype, param1, param2 );\
- else if ( ptype.GetTypeId() == typeid(short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::SHORT )\
function<short>( ptype, param1, param2 ); \
- else if ( ptype.GetTypeId() == typeid(unsigned short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::USHORT )\
function<unsigned short>( ptype, param1, param2 );\
- else if ( ptype.GetTypeId() == typeid(int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::INT )\
function<int>( ptype, param1, param2 );\
- else if ( ptype.GetTypeId() == typeid(unsigned int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UINT )\
function<unsigned int>( ptype, param1, param2 );\
- else if ( ptype.GetTypeId() == typeid(long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::LONG )\
function<long int>( ptype, param1, param2 );\
- else if ( ptype.GetTypeId() == typeid(unsigned long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::ULONG )\
function<unsigned long int>( ptype, param1, param2 );\
- else if ( ptype.GetTypeId() == typeid(float) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::FLOAT )\
function<float>( ptype, param1, param2 );\
- else if ( ptype.GetTypeId() == typeid(double) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::DOUBLE )\
function<double>( ptype, param1, param2 );\
}\
#define mitkPixelTypeMultiplex3( function, ptype, param1, param2, param3 ) \
{ \
- if ( ptype.GetTypeId() == typeid(char) )\
+ if ( ptype.GetComponentType() == itk::ImageIOBase::CHAR )\
function<char>( ptype, param1, param2, param3 );\
- else if ( ptype.GetTypeId() == typeid(unsigned char))\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UCHAR)\
function<unsigned char>( ptype, param1, param2, param3 );\
- else if ( ptype.GetTypeId() == typeid(short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::SHORT )\
function<short>( ptype, param1, param2, param3 ); \
- else if ( ptype.GetTypeId() == typeid(unsigned short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::USHORT )\
function<unsigned short>( ptype, param1, param2, param3 );\
- else if ( ptype.GetTypeId() == typeid(int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::INT )\
function<int>( ptype, param1, param2, param3 );\
- else if ( ptype.GetTypeId() == typeid(unsigned int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UINT )\
function<unsigned int>( ptype, param1, param2, param3 );\
- else if ( ptype.GetTypeId() == typeid(long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::LONG )\
function<long int>( ptype, param1, param2, param3 );\
- else if ( ptype.GetTypeId() == typeid(unsigned long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::ULONG )\
function<unsigned long int>( ptype, param1, param2, param3 );\
- else if ( ptype.GetTypeId() == typeid(float) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::FLOAT )\
function<float>( ptype, param1, param2, param3 );\
- else if ( ptype.GetTypeId() == typeid(double) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::DOUBLE )\
function<double>( ptype, param1, param2, param3 );\
}\
#define mitkPixelTypeMultiplex4( function, ptype, param1, param2, param3, param4 ) \
{ \
- if ( ptype.GetTypeId() == typeid(char) )\
+ if ( ptype.GetComponentType() == itk::ImageIOBase::CHAR )\
function<char>( ptype, param1, param2, param3, param4 );\
- else if ( ptype.GetTypeId() == typeid(unsigned char))\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UCHAR)\
function<unsigned char>( ptype, param1, param2, param3, param4 );\
- else if ( ptype.GetTypeId() == typeid(short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::SHORT )\
function<short>( ptype, param1, param2, param3, param4 ); \
- else if ( ptype.GetTypeId() == typeid(unsigned short) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::USHORT )\
function<unsigned short>( ptype, param1, param2, param3, param4 );\
- else if ( ptype.GetTypeId() == typeid(int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::INT )\
function<int>( ptype, param1, param2, param3, param4 );\
- else if ( ptype.GetTypeId() == typeid(unsigned int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::UINT )\
function<unsigned int>( ptype, param1, param2, param3, param4 );\
- else if ( ptype.GetTypeId() == typeid(long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::LONG )\
function<long int>( ptype, param1, param2, param3, param4 );\
- else if ( ptype.GetTypeId() == typeid(unsigned long int) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::ULONG )\
function<unsigned long int>( ptype, param1, param2, param3, param4 );\
- else if ( ptype.GetTypeId() == typeid(float) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::FLOAT )\
function<float>( ptype, param1, param2, param3, param4 );\
- else if ( ptype.GetTypeId() == typeid(double) )\
+ else if ( ptype.GetComponentType() == itk::ImageIOBase::DOUBLE )\
function<double>( ptype, param1, param2, param3, param4 );\
}\
#endif // MITKPIXELTYPEMULTIPLEX_H
diff --git a/Core/Code/IO/mitkPixelTypeTraits.h b/Core/Code/IO/mitkPixelTypeTraits.h
index a3f7c6e243..9c20eaebca 100644
--- a/Core/Code/IO/mitkPixelTypeTraits.h
+++ b/Core/Code/IO/mitkPixelTypeTraits.h
@@ -1,215 +1,245 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef PIXELTYPETRAITS_H
#define PIXELTYPETRAITS_H
#include <itkImageIOBase.h>
#include <itkRGBPixel.h>
#include <itkRGBAPixel.h>
#include <itkDiffusionTensor3D.h>
/** \file mitkPixelTypeTraits.h
*
* The pixel type traits are in general used for compile time resolution of the component type and
* the number of components for compound types like the ones in ItkImageType.
* The default values are used to define the corresponding variable also for scalar types
*/
namespace itk
{
/** Forward declaration of the Variable Length Vector class from ITK */
template < typename TValueType > class VariableLengthVector;
}
+#define MITK_PIXEL_COMPONENT_TYPE(type,ctype,name) \
+ template <> struct mitk::MapPixelComponentType<type> \
+ { \
+ static const int value = ctype; \
+ } \
+ template <> std::string mitk::PixelComponentTypeToString() \
+ { \
+ return name; \
+ }
+
+namespace mitk {
+
+static const int PixelUserType = itk::ImageIOBase::MATRIX + 1;
+static const int PixelComponentUserType = itk::ImageIOBase::DOUBLE + 1;
+
+/**
+ * Maps pixel component types (primitive types like int, short, double, etc. and custom
+ * types) to and integer constant. Specialize this template for custom types by using the
+ * #MITK_PIXEL_COMPONENT_TYPE macro.
+ */
+template<typename T>
+struct MapPixelComponentType
+{
+ static const int value = itk::ImageIOBase::MapPixelType<T>::CType;
+};
+
/**
\brief This is an implementation of a type trait to provide a compile-time check for PixelType used in
the instantiation of an itk::Image
*/
template< typename T>
struct isPrimitiveType
{
static const bool value = false;
};
/** \def DEFINE_TYPE_PRIMITIVE macro which provides a partial specialization for the \sa isPrimitiveType
object */
#define DEFINE_TYPE_PRIMITIVE(_TYPEIN) \
template<> struct isPrimitiveType<_TYPEIN>{ static const bool value = true; }
/** \brief Partial specialization (unsigned char) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(unsigned char);
/** \brief Partial specialization (char) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(char);
/** \brief Partial specialization (signed char) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(signed char);
/** \brief Partial specialization (unsigned short) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(unsigned short);
/** \brief Partial specialization (short) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(short);
/** \brief Partial specialization (unsigned int) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(unsigned int);
/** \brief Partial specialization (int) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(int);
/** \brief Partial specialization (long int) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(long int);
/** \brief Partial specialization (long unsigned int) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(long unsigned int);
/** \brief Partial specialization (float) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(float);
/** \brief Partial specialization (double) for the isPrimitiveType object */
DEFINE_TYPE_PRIMITIVE(double);
/** \brief Type trait to provide compile-time check for T ?= itk::VectorImage */
template< class T, typename TValueType >
struct isVectorImage
{
static const bool value = false;
};
/** \brief Partial specification for the isVectorImage trait. */
template< typename TValueType >
struct isVectorImage< itk::VariableLengthVector<TValueType>, TValueType>
{
static const bool value = true;
};
/** \brief Compile-time trait for resolving the ValueType from an ItkImageType */
template<bool flag,typename T>
struct PixelTypeTrait
{
typedef T ValueType;
};
/** \brief Partial specialization for the PixelTypeTrait
*
* Specialization for the false value. Used to define the value type for non-primitive pixel types
*/
template<typename T>
struct PixelTypeTrait<false, T>
{
typedef typename T::ValueType ValueType;
};
/** \brief Compile time resolving of the type of a component */
template<typename T>
struct GetComponentType
{
typedef typename PixelTypeTrait<isPrimitiveType<T>::value, T>::ValueType ComponentType;
};
/** \brief Object for compile-time resolving of the number of components for given type.
*
* Default value for the component number is 1
*/
template<bool V, typename T>
struct ComponentsTrait
{
static const size_t Size = 1;
};
/** \brief Partial specialization for the ComponentsTraits in case of compound types */
template<typename T>
struct ComponentsTrait<false, T>
{
static const size_t Size = T::ValueType::Length;
};
typedef itk::ImageIOBase::IOPixelType itkIOPixelType;
/** \brief Object for compile-time translation of a composite pixel type into an itk::ImageIOBase::IOPixelType information
*
* The default value of the IOCompositeType is the UNKNOWNPIXELTYPE, the default value will be used for all but the
* types below with own partial specialization. The values of the IOCompositeType member in the specializations correspond
* to the values of the itk::ImageIOBase::IOPixelType enum values.
*/
template< class T>
struct MapCompositePixelType
{
static const itkIOPixelType IOCompositeType = itk::ImageIOBase::UNKNOWNPIXELTYPE;
};
//------------------------
// Partial template specialization for fixed-length types
//------------------------
template< class C>
struct MapCompositePixelType< itk::RGBPixel<C> >
{
static const itkIOPixelType IOCompositeType = itk::ImageIOBase::RGB;
};
template< class C>
struct MapCompositePixelType< itk::RGBAPixel<C> >
{
static const itkIOPixelType IOCompositeType = itk::ImageIOBase::RGBA;
};
template< class C>
struct MapCompositePixelType< itk::DiffusionTensor3D<C> >
{
static const itkIOPixelType IOCompositeType = itk::ImageIOBase::DIFFUSIONTENSOR3D;
};
//------------------------
// Partial template specialization for variable-length types
//------------------------
template< class C, unsigned int N>
struct MapCompositePixelType< itk::Vector< C,N > >
{
static const itkIOPixelType IOCompositeType = itk::ImageIOBase::VECTOR;
};
template< class C, unsigned int N>
struct MapCompositePixelType< itk::FixedArray< C,N > >
{
static const itkIOPixelType IOCompositeType = itk::ImageIOBase::COVARIANTVECTOR;
};
template< class C, unsigned int N>
struct MapCompositePixelType< itk::CovariantVector< C,N > >
{
static const itkIOPixelType IOCompositeType = itk::ImageIOBase::COVARIANTVECTOR;
};
template< class C, unsigned int N>
struct MapCompositePixelType< itk::Matrix< C,N > >
{
static const itkIOPixelType IOCompositeType = itk::ImageIOBase::MATRIX;
};
/** \brief Object for compile-time translation of a pixel type into an itk::ImageIOBase::IOPixelType information
*
* The first template parameter is the pixel type to be translated, the second parameter determines the processing
* way. For non-primitive types the first template parameter is passed to the MapCompositePixelType object to be resolved there
* for primitive types the value is set to SCALAR.
*
* To initalize the flag correctly in compile-time use the \sa isPrimitiveType<T> trait.
*/
template< class T, bool Primitive>
struct MapPixelType
{
- static const itkIOPixelType IOType = MapCompositePixelType<T>::IOCompositeType;
+ static const itkIOPixelType IOPixelType = MapCompositePixelType<T>::IOCompositeType;
+ static const int IOComponentType = MapPixelComponentType<typename GetComponentType<T>::ComponentType>::value;
};
/** \brief Partial specialization for setting the IOPixelType for primitive types to SCALAR */
template<class T>
struct MapPixelType< T, true>
{
- static const itkIOPixelType IOType = itk::ImageIOBase::SCALAR;
+ static const itkIOPixelType IOPixelType = itk::ImageIOBase::SCALAR;
+ static const int IOComponentType = MapPixelComponentType<T>::value;
};
+} // end namespace mitk
+
#endif // PIXELTYPETRAITS_H
diff --git a/Core/Code/IO/mitkPointSetReader.cpp b/Core/Code/IO/mitkPointSetReader.cpp
index 587cf24e85..efeb37719c 100644
--- a/Core/Code/IO/mitkPointSetReader.cpp
+++ b/Core/Code/IO/mitkPointSetReader.cpp
@@ -1,194 +1,194 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetReader.h"
#include <iostream>
#include <fstream>
#include <locale>
mitk::PointSetReader::PointSetReader()
{
m_Success = false;
}
mitk::PointSetReader::~PointSetReader()
{}
void mitk::PointSetReader::GenerateData()
{
std::locale::global(std::locale("C"));
m_Success = false;
if ( m_FileName == "" )
{
itkWarningMacro( << "Sorry, filename has not been set!" );
return ;
}
if ( ! this->CanReadFile( m_FileName.c_str() ) )
{
itkWarningMacro( << "Sorry, can't read file " << m_FileName << "!" );
return ;
}
try{
TiXmlDocument doc(m_FileName.c_str());
bool loadOkay = doc.LoadFile();
if (loadOkay)
{
TiXmlHandle docHandle( &doc );
unsigned int pointSetCounter(0);
for( TiXmlElement* currentPointSetElement = docHandle.FirstChildElement("point_set_file").FirstChildElement("point_set").ToElement();
currentPointSetElement != NULL; currentPointSetElement = currentPointSetElement->NextSiblingElement())
{
mitk::PointSet::Pointer newPointSet = mitk::PointSet::New();
if(currentPointSetElement->FirstChildElement("time_series") != NULL)
{
for( TiXmlElement* currentTimeSeries = currentPointSetElement->FirstChildElement("time_series")->ToElement();
currentTimeSeries != NULL; currentTimeSeries = currentTimeSeries->NextSiblingElement())
{
unsigned int currentTimeStep(0);
TiXmlElement* currentTimeSeriesID = currentTimeSeries->FirstChildElement("time_series_id");
currentTimeStep = atoi(currentTimeSeriesID->GetText());
newPointSet = this->ReadPoint(newPointSet, currentTimeSeries, currentTimeStep);
}
}
else
{
newPointSet = this->ReadPoint(newPointSet, currentPointSetElement, 0);
}
this->SetNthOutput( pointSetCounter, newPointSet );
pointSetCounter++;
}
}
else
{
MITK_WARN << "XML parser error!";
}
}catch(...)
{
MITK_ERROR << "Cannot read point set.";
m_Success = false;
}
m_Success = true;
}
mitk::PointSet::Pointer mitk::PointSetReader::ReadPoint(mitk::PointSet::Pointer newPointSet,
TiXmlElement* currentTimeSeries, unsigned int currentTimeStep)
{
if(currentTimeSeries->FirstChildElement("point") != NULL)
{
for( TiXmlElement* currentPoint = currentTimeSeries->FirstChildElement("point")->ToElement();
currentPoint != NULL; currentPoint = currentPoint->NextSiblingElement())
{
unsigned int id(0);
mitk::PointSpecificationType spec((mitk::PointSpecificationType) 0);
double x(0.0);
double y(0.0);
double z(0.0);
id = atoi(currentPoint->FirstChildElement("id")->GetText());
if(currentPoint->FirstChildElement("specification") != NULL)
{
spec = (mitk::PointSpecificationType) atoi(currentPoint->FirstChildElement("specification")->GetText());
}
x = atof(currentPoint->FirstChildElement("x")->GetText());
y = atof(currentPoint->FirstChildElement("y")->GetText());
z = atof(currentPoint->FirstChildElement("z")->GetText());
mitk::Point3D point;
mitk::FillVector3D(point, x, y, z);
newPointSet->SetPoint(id, point, spec, currentTimeStep);
}
}
else
{
if(currentTimeStep != newPointSet->GetTimeSteps()+1)
{
newPointSet->Expand(currentTimeStep+1); // expand time step series with empty time step
}
}
return newPointSet;
}
void mitk::PointSetReader::GenerateOutputInformation()
{
}
int mitk::PointSetReader::CanReadFile ( const char *name )
{
std::ifstream in( name );
bool isGood = in.good();
in.close();
return isGood;
}
bool mitk::PointSetReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
// First check the extension
if( filename == "" )
{
//MITK_INFO<<"No filename specified."<<std::endl;
return false;
}
// check if image is serie
if( filePattern != "" && filePrefix != "" )
return false;
bool extensionFound = false;
std::string::size_type MPSPos = filename.rfind(".mps");
if ((MPSPos != std::string::npos)
&& (MPSPos == filename.length() - 4))
{
extensionFound = true;
}
MPSPos = filename.rfind(".MPS");
if ((MPSPos != std::string::npos)
&& (MPSPos == filename.length() - 4))
{
extensionFound = true;
}
if( !extensionFound )
{
//MITK_INFO<<"The filename extension is not recognized."<<std::endl;
return false;
}
return true;
}
void mitk::PointSetReader::ResizeOutputs( const unsigned int& num )
{
unsigned int prevNum = this->GetNumberOfOutputs();
- this->SetNumberOfOutputs( num );
+ this->SetNumberOfIndexedOutputs( num );
for ( unsigned int i = prevNum; i < num; ++i )
{
this->SetNthOutput( i, this->MakeOutput( i ).GetPointer() );
}
}
bool mitk::PointSetReader::GetSuccess() const
{
return m_Success;
}
diff --git a/Core/Code/IO/mitkPointSetWriter.cpp b/Core/Code/IO/mitkPointSetWriter.cpp
index 9bc9979a35..ba4c069c84 100644
--- a/Core/Code/IO/mitkPointSetWriter.cpp
+++ b/Core/Code/IO/mitkPointSetWriter.cpp
@@ -1,382 +1,382 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetWriter.h"
#include <iostream>
#include <fstream>
#include <locale>
//
// Initialization of the xml tags.
//
const char* mitk::PointSetWriter::XML_POINT_SET_FILE = "point_set_file" ;
const char* mitk::PointSetWriter::XML_FILE_VERSION = "file_version" ;
const char* mitk::PointSetWriter::XML_POINT_SET = "point_set" ;
const char* mitk::PointSetWriter::XML_TIME_SERIES = "time_series";
const char* mitk::PointSetWriter::XML_TIME_SERIES_ID = "time_series_id";
const char* mitk::PointSetWriter::XML_POINT = "point" ;
const char* mitk::PointSetWriter::XML_ID = "id" ;
const char* mitk::PointSetWriter::XML_SPEC = "specification" ;
const char* mitk::PointSetWriter::XML_X = "x" ;
const char* mitk::PointSetWriter::XML_Y = "y" ;
const char* mitk::PointSetWriter::XML_Z = "z" ;
const char* mitk::PointSetWriter::VERSION_STRING = "0.1" ;
mitk::PointSetWriter::PointSetWriter()
: m_FileName(""), m_FilePrefix(""), m_FilePattern("")
{
this->SetNumberOfRequiredInputs( 1 );
- this->SetNumberOfOutputs( 1 );
+ this->SetNumberOfIndexedOutputs( 1 );
this->SetNthOutput( 0, mitk::PointSet::New().GetPointer() );
m_Indent = 2;
m_IndentDepth = 0;
m_Success = false;
}
mitk::PointSetWriter::~PointSetWriter()
{}
void mitk::PointSetWriter::GenerateData()
{
m_Success = false;
m_IndentDepth = 0;
//
// Opening the file to write to
//
if ( m_FileName == "" )
{
itkWarningMacro( << "Sorry, filename has not been set!" );
return ;
}
std::ofstream out( m_FileName.c_str() );
if ( !out.good() )
{
itkExceptionMacro(<< "File " << m_FileName << " could not be opened!");
itkWarningMacro( << "Sorry, file " << m_FileName << " could not be opened!" );
out.close();
return ;
}
std::locale previousLocale(out.getloc());
std::locale I("C");
out.imbue(I);
//
// Here the actual xml writing begins
//
WriteXMLHeader( out );
WriteStartElement( XML_POINT_SET_FILE, out );
WriteStartElement( XML_FILE_VERSION, out );
WriteCharacterData( VERSION_STRING, out );
WriteEndElement( XML_FILE_VERSION, out, false );
//
// for each input object write its xml representation to
// the stream
//
for ( unsigned int i = 0 ; i < this->GetNumberOfInputs(); ++i )
{
InputType::Pointer pointSet = this->GetInput( i );
assert( pointSet.IsNotNull() );
WriteXML( pointSet.GetPointer(), out );
}
WriteEndElement( XML_POINT_SET_FILE, out );
out.imbue(previousLocale);
if ( !out.good() ) // some error during output
{
out.close();
throw std::ios_base::failure("Some error during point set writing.");
}
out.close();
m_Success = true;
m_MimeType = "application/MITK.PointSet";
}
void mitk::PointSetWriter::WriteXML( mitk::PointSet* pointSet, std::ofstream& out )
{
WriteStartElement( XML_POINT_SET, out );
unsigned int timecount = pointSet->GetTimeSteps();
for(unsigned int i=0; i< timecount; i++)
{
WriteStartElement( XML_TIME_SERIES, out );
WriteStartElement( XML_TIME_SERIES_ID, out );
WriteCharacterData( ConvertToString( i ).c_str() , out );
WriteEndElement( XML_TIME_SERIES_ID, out, false );
mitk::PointSet::PointsContainer* pointsContainer = pointSet->GetPointSet(i)->GetPoints();
mitk::PointSet::PointsContainer::Iterator it;
for ( it = pointsContainer->Begin(); it != pointsContainer->End(); ++it )
{
WriteStartElement( XML_POINT, out );
WriteStartElement( XML_ID, out );
WriteCharacterData( ConvertToString( it->Index() ).c_str() , out );
WriteEndElement( XML_ID, out, false );
mitk::PointSet::PointType point = it->Value();
WriteStartElement( XML_SPEC, out );
WriteCharacterData( ConvertToString( pointSet->GetSpecificationTypeInfo(it->Index(), i) ).c_str() , out );
WriteEndElement( XML_SPEC, out, false );
WriteStartElement( XML_X, out );
WriteCharacterData( ConvertToString( point[ 0 ] ).c_str(), out );
WriteEndElement( XML_X, out, false );
WriteStartElement( XML_Y, out );
WriteCharacterData( ConvertToString( point[ 1 ] ).c_str(), out );
WriteEndElement( XML_Y, out, false );
WriteStartElement( XML_Z, out );
WriteCharacterData( ConvertToString( point[ 2 ] ).c_str(), out );
WriteEndElement( XML_Z, out, false );
WriteEndElement( XML_POINT, out );
}
WriteEndElement( XML_TIME_SERIES, out );
}
WriteEndElement( XML_POINT_SET, out );
}
void mitk::PointSetWriter::ResizeInputs( const unsigned int& num )
{
unsigned int prevNum = this->GetNumberOfInputs();
- this->SetNumberOfInputs( num );
+ this->SetNumberOfIndexedInputs( num );
for ( unsigned int i = prevNum; i < num; ++i )
{
this->SetNthInput( i, mitk::PointSet::New().GetPointer() );
}
}
void mitk::PointSetWriter::SetInput( InputType* pointSet )
{
this->ProcessObject::SetNthInput( 0, pointSet );
}
void mitk::PointSetWriter::SetInput( const unsigned int& id, InputType* pointSet )
{
if ( id >= this->GetNumberOfInputs() )
this->ResizeInputs( id + 1 );
this->ProcessObject::SetNthInput( id, pointSet );
}
mitk::PointSet* mitk::PointSetWriter::GetInput()
{
if ( this->GetNumberOfInputs() < 1 )
{
return 0;
}
else
{
return dynamic_cast<InputType*> ( this->GetInput( 0 ) );
}
}
mitk::PointSet* mitk::PointSetWriter::GetInput( const unsigned int& num )
{
return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( num ) );
}
template < typename T>
std::string mitk::PointSetWriter::ConvertToString( T value )
{
std::ostringstream o;
std::locale I("C");
o.imbue(I);
if ( o << value )
{
return o.str();
}
else
return "conversion error";
}
void mitk::PointSetWriter::WriteXMLHeader( std::ofstream &file )
{
file << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>";
}
void mitk::PointSetWriter::WriteStartElement( const char *const tag, std::ofstream &file )
{
file << std::endl;
WriteIndent( file );
file << '<' << tag << '>';
m_IndentDepth++;
}
void mitk::PointSetWriter::WriteEndElement( const char *const tag, std::ofstream &file, const bool& indent )
{
m_IndentDepth--;
if ( indent )
{
file << std::endl;
WriteIndent( file );
}
file << '<' << '/' << tag << '>';
}
void mitk::PointSetWriter::WriteCharacterData( const char *const data, std::ofstream &file )
{
file << data;
}
void mitk::PointSetWriter::WriteStartElement( std::string &tag, std::ofstream &file )
{
WriteStartElement( tag.c_str(), file );
}
void mitk::PointSetWriter::WriteEndElement( std::string &tag, std::ofstream &file, const bool& indent )
{
WriteEndElement( tag.c_str(), file, indent );
}
void mitk::PointSetWriter::WriteCharacterData( std::string &data, std::ofstream &file )
{
WriteCharacterData( data.c_str(), file );
}
void mitk::PointSetWriter::WriteIndent( std::ofstream& file )
{
std::string spaces( m_IndentDepth * m_Indent, ' ' );
file << spaces.c_str();
}
bool mitk::PointSetWriter::GetSuccess() const
{
return m_Success;
}
bool mitk::PointSetWriter::CanWriteDataType( DataNode* input )
{
if ( input )
{
mitk::BaseData* data = input->GetData();
if ( data )
{
mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>( data );
if( pointSet.IsNotNull() )
{
//this writer has no "SetDefaultExtension()" - function
m_Extension = ".mps";
return true;
}
}
}
return false;
}
void mitk::PointSetWriter::SetInput( DataNode* input )
{
if( input && CanWriteDataType( input ) )
this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::PointSet*>( input->GetData() ) );
}
std::string mitk::PointSetWriter::GetWritenMIMEType()
{
return m_MimeType;
}
std::vector<std::string> mitk::PointSetWriter::GetPossibleFileExtensions()
{
std::vector<std::string> possibleFileExtensions;
possibleFileExtensions.push_back(".mps");
return possibleFileExtensions;
}
std::string mitk::PointSetWriter::GetFileExtension()
{
return m_Extension;
}
diff --git a/Core/Code/IO/mitkPointSetWriter.h b/Core/Code/IO/mitkPointSetWriter.h
index 81ff3da725..9ba6a7e216 100644
--- a/Core/Code/IO/mitkPointSetWriter.h
+++ b/Core/Code/IO/mitkPointSetWriter.h
@@ -1,265 +1,266 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_POINT_SET_WRITER__H_
#define _MITK_POINT_SET_WRITER__H_
#include <itkProcessObject.h>
#include <mitkFileWriter.h>
#include <mitkPointSet.h>
namespace mitk
{
/**
* @brief XML-based writer for mitk::PointSets
*
* XML-based writer for mitk::PointSets. Multiple PointSets can be written in
* a single XML file by simply setting multiple inputs to the filter.
* Writing of multiple XML files according to a given filename pattern is not
* yet supported.
* @ingroup PSIO
* @ingroup Process
*/
class MITK_CORE_EXPORT PointSetWriter : public mitk::FileWriter
{
public:
mitkClassMacro( PointSetWriter, mitk::FileWriter );
mitkWriterMacro;
itkNewMacro( Self );
typedef mitk::PointSet InputType;
typedef InputType::Pointer InputTypePointer;
/**
* Sets the filename of the file to write.
* @param FileName the name of the file to write.
*/
itkSetStringMacro( FileName );
/**
* @returns the name of the file to be written to disk.
*/
itkGetStringMacro( FileName );
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePrefix );
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePrefix );
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePattern );
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePattern );
/**
* Sets the 0'th input object for the filter.
* @param input the first input for the filter.
*/
void SetInput( InputType* input );
/**
* Sets the n'th input object for the filter. If num is
* larger than GetNumberOfInputs() the number of inputs is
* resized appropriately.
* @param input the n'th input for the filter.
*/
void SetInput( const unsigned int& num, InputType* input);
/**
* @returns the 0'th input object of the filter.
*/
PointSet* GetInput();
/**
* @param num the index of the desired output object.
* @returns the n'th input object of the filter.
*/
PointSet* GetInput( const unsigned int& num );
/**
* @brief Return the possible file extensions for the data type associated with the writer
*/
virtual std::vector<std::string> GetPossibleFileExtensions();
/**
* @brief Return the extension to be added to the filename.
*/
virtual std::string GetFileExtension();
/**
* @brief Check if the Writer can write the Content of the
*/
virtual bool CanWriteDataType( DataNode* );
/**
* @brief Return the MimeType of the saved File.
*/
virtual std::string GetWritenMIMEType();
+ using mitk::FileWriter::SetInput;
/**
* @brief Set the DataTreenode as Input. Important: The Writer always have a SetInput-Function.
*/
virtual void SetInput( DataNode* );
/**
* @returns whether the last write attempt was successful or not.
*/
bool GetSuccess() const;
protected:
/**
* Constructor.
*/
PointSetWriter();
/**
* Virtual destructor.
*/
virtual ~PointSetWriter();
/**
* Writes the XML file
*/
virtual void GenerateData();
/**
* Resizes the number of inputs of the writer.
* The inputs are initialized by empty PointSets
* @param num the new number of inputs
*/
virtual void ResizeInputs( const unsigned int& num );
/**
* Converts an arbitrary type to a string. The type has to
* support the << operator. This works fine at least for integral
* data types as float, int, long etc.
* @param value the value to convert
* @returns the string representation of value
*/
template < typename T>
std::string ConvertToString( T value );
/**
* Writes an XML representation of the given point set to
* an outstream. The XML-Header an root node is not included!
* @param pointSet the point set to be converted to xml
* @param out the stream to write to.
*/
void WriteXML( mitk::PointSet* pointSet, std::ofstream& out );
/**
* Writes an standard xml header to the given stream.
* @param file the stream in which the header is written.
*/
void WriteXMLHeader( std::ofstream &file );
/** Write a start element tag */
void WriteStartElement( const char *const tag, std::ofstream &file );
/**
* Write an end element tag
* End-Elements following character data should pass indent = false.
*/
void WriteEndElement( const char *const tag, std::ofstream &file, const bool& indent = true );
/** Write character data inside a tag. */
void WriteCharacterData( const char *const data, std::ofstream &file );
/** Write a start element tag */
void WriteStartElement( std::string &tag, std::ofstream &file );
/** Write an end element tag */
void WriteEndElement( std::string &tag, std::ofstream &file, const bool& indent = true );
/** Write character data inside a tag. */
void WriteCharacterData( std::string &data, std::ofstream &file );
/** Writes empty spaces to the stream according to m_IndentDepth and m_Indent */
void WriteIndent( std::ofstream& file );
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
std::string m_Extension;
std::string m_MimeType;
unsigned int m_IndentDepth;
unsigned int m_Indent;
bool m_Success;
public:
static const char* XML_POINT_SET;
static const char* XML_TIME_SERIES;
static const char* XML_TIME_SERIES_ID;
static const char* XML_POINT_SET_FILE;
static const char* XML_FILE_VERSION;
static const char* XML_POINT;
static const char* XML_SPEC;
static const char* XML_ID;
static const char* XML_X;
static const char* XML_Y;
static const char* XML_Z;
static const char* VERSION_STRING;
};
}
#endif
diff --git a/Core/Code/IO/mitkSurfaceVtkWriter.h b/Core/Code/IO/mitkSurfaceVtkWriter.h
index 99825d8b2e..5761555988 100644
--- a/Core/Code/IO/mitkSurfaceVtkWriter.h
+++ b/Core/Code/IO/mitkSurfaceVtkWriter.h
@@ -1,202 +1,203 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_SURFACE_VTK_WRITER__H_
#define _MITK_SURFACE_VTK_WRITER__H_
#include <iomanip>
#include <vtkSTLWriter.h>
#include <vtkPolyDataWriter.h>
#include <vtkXMLPolyDataWriter.h>
#include <itkProcessObject.h>
#include <mitkFileWriter.h>
#include <mitkPointSet.h>
#include <mitkSurface.h>
#include <vtkSmartPointer.h>
class vtkTransformPolyDataFilter;
namespace mitk
{
/**
* @brief VTK-based writer for mitk::Surface
*
* The mitk::Surface is written using the VTK-writer-type provided as the
* template argument. If the mitk::Surface contains multiple points of
* time, multiple files are written. The life-span (time-bounds) of each
* each point of time is included in the filename according to the
* following scheme:
* &lt;filename&gt;_S&lt;timebounds[0]&gt;E&lt;timebounds[1]&gt;_T&lt;framenumber&gt;
* (S=start, E=end, T=time).
* Writing of multiple files according to a given filename pattern is not
* yet supported.
* @ingroup Process
*/
template <class VTKWRITER>
class MITK_CORE_EXPORT SurfaceVtkWriter : public mitk::FileWriter
{
public:
mitkClassMacro( SurfaceVtkWriter, mitk::FileWriter );
itkNewMacro( Self );
mitkWriterMacro;
typedef VTKWRITER VtkWriterType;
/**
* Sets the filename of the file to write.
* @param _arg the name of the file to write.
*/
itkSetStringMacro( FileName );
/**
* @returns the name of the file to be written to disk.
*/
itkGetStringMacro( FileName );
/**
* \brief Explicitly set the extension to be added to the filename.
* @param _arg to be added to the filename, including a "."
* (e.g., ".vtk").
*
* Partial template specialization is used for some vtk-writer types
* to set a default extension.
*/
itkSetStringMacro( Extension );
/**
* \brief Get the extension to be added to the filename.
* @returns the extension to be added to the filename (e.g.,
* ".vtk").
*/
itkGetStringMacro( Extension );
/**
* \brief Set the extension to be added to the filename to the default
*
* Partial template specialization is used for some vtk-writer types
* to define the default extension.
*/
void SetDefaultExtension();
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePrefix );
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePrefix );
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePattern );
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePattern );
/**
* Sets the 0'th input object for the filter.
* @param input the first input for the filter.
*/
void SetInput( mitk::Surface* input );
/**
* @returns the 0'th input object of the filter.
*/
const mitk::Surface* GetInput();
/**
* @brief Return the extension to be added to the filename.
*/
virtual std::string GetFileExtension();
/**
* @brief Check if the Writer can write the Content of the DataTreenode.
*/
virtual bool CanWriteDataType( DataNode* );
/**
* @brief Return the MimeType of the saved File.
*/
virtual std::string GetWritenMIMEType();
+ using Superclass::SetInput;
/**
* @brief Set the DataTreenode as Input. Important: The Writer always have a SetInput-Function.
*/
virtual void SetInput( DataNode* );
VtkWriterType* GetVtkWriter()
{
return m_VtkWriter;
}
/**
* @brief Return the possible file extensions for the data type associated with the writer
*/
virtual std::vector<std::string> GetPossibleFileExtensions();
protected:
/**
* Constructor.
*/
SurfaceVtkWriter();
/**
* Virtual destructor.
*/
virtual ~SurfaceVtkWriter();
virtual void GenerateData();
void ExecuteWrite( VtkWriterType* vtkWriter );
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
std::string m_Extension;
std::string m_MimeType;
vtkSmartPointer<VtkWriterType> m_VtkWriter;
bool m_WriterWriteHasReturnValue;
};
#ifndef Mitk_EXPORTS
extern template class SurfaceVtkWriter<vtkSTLWriter>;
extern template class SurfaceVtkWriter<vtkPolyDataWriter>;
extern template class SurfaceVtkWriter<vtkXMLPolyDataWriter>;
#endif
}
#endif //_MITK_SURFACE_VTK_WRITER__H_
diff --git a/Core/Code/IO/mitkSurfaceVtkWriter.txx b/Core/Code/IO/mitkSurfaceVtkWriter.txx
index df39fc20fb..172076c43d 100644
--- a/Core/Code/IO/mitkSurfaceVtkWriter.txx
+++ b/Core/Code/IO/mitkSurfaceVtkWriter.txx
@@ -1,174 +1,174 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSurfaceVtkWriter.h"
#include <vtkConfigure.h>
#include <vtkPolyData.h>
#include <vtkLinearTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkErrorCode.h>
#include <sstream>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
template <class VTKWRITER>
mitk::SurfaceVtkWriter<VTKWRITER>::SurfaceVtkWriter()
: m_WriterWriteHasReturnValue( false )
{
this->SetNumberOfRequiredInputs( 1 );
m_VtkWriter = vtkSmartPointer<VtkWriterType>::New();
//enable to write ascii-formatted-file
//m_VtkWriter->SetFileTypeToASCII();
SetDefaultExtension(); // and information about the Writer's Write() method
}
template <class VTKWRITER>
mitk::SurfaceVtkWriter<VTKWRITER>::~SurfaceVtkWriter()
{
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::SetDefaultExtension()
{
m_Extension = ".vtk";
}
template<class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::ExecuteWrite( VtkWriterType* vtkWriter )
{
if ( vtkWriter->Write() == 0 || vtkWriter->GetErrorCode() != 0 )
{
itkExceptionMacro(<<"Error during surface writing: " << vtkErrorCode::GetStringFromErrorCode(vtkWriter->GetErrorCode()) );
}
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::GenerateData()
{
if ( m_FileName == "" )
{
itkWarningMacro( << "Sorry, filename has not been set!" );
return ;
}
mitk::Surface::Pointer input = const_cast<mitk::Surface*>(this->GetInput());
vtkSmartPointer<vtkTransformPolyDataFilter> transformPolyData = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
vtkPolyData * polyData;
Geometry3D* geometry;
unsigned int t, timesteps = input->GetTimeSlicedGeometry()->GetTimeSteps();
for(t = 0; t < timesteps; ++t)
{
// surfaces do not have to exist in all timeteps; therefor, only write valid surfaces
if( input->GetVtkPolyData(t) == NULL ) continue;
- ::itk::OStringStream filename;
+ std::ostringstream filename;
filename.imbue(::std::locale::classic());
geometry = input->GetGeometry(t);
if ( timesteps > 1 )
{
if(input->GetTimeSlicedGeometry()->IsValidTime(t))
{
const TimeBounds& timebounds = geometry->GetTimeBounds();
filename << m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
}
else
{
itkWarningMacro(<<"Error on write: TimeSlicedGeometry invalid of surface " << filename << ".");
filename << m_FileName.c_str() << "_T" << t << m_Extension;
}
m_VtkWriter->SetFileName(filename.str().c_str());
}
else
m_VtkWriter->SetFileName(m_FileName.c_str());
geometry->TransferItkToVtkTransform();
transformPolyData->SetInput(input->GetVtkPolyData(t));
transformPolyData->SetTransform(geometry->GetVtkTransform());
transformPolyData->UpdateWholeExtent();
polyData = transformPolyData->GetOutput();
m_VtkWriter->SetInput(polyData);
ExecuteWrite( m_VtkWriter );
}
m_MimeType = "application/MITK.Surface";
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( mitk::Surface* surface )
{
this->ProcessObject::SetNthInput( 0, surface );
}
template <class VTKWRITER>
const mitk::Surface* mitk::SurfaceVtkWriter<VTKWRITER>::GetInput()
{
if ( this->GetNumberOfInputs() < 1 )
{
return NULL;
}
else
{
return static_cast< const Surface * >( this->ProcessObject::GetInput( 0 ) );
}
}
template <class VTKWRITER>
bool mitk::SurfaceVtkWriter<VTKWRITER>::CanWriteDataType( DataNode* input )
{
if ( input )
{
BaseData* data = input->GetData();
if ( data )
{
Surface::Pointer surface = dynamic_cast<Surface*>( data );
if( surface.IsNotNull() )
{
SetDefaultExtension();
return true;
}
}
}
return false;
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( DataNode* input )
{
if( input && CanWriteDataType( input ) )
SetInput( dynamic_cast<Surface*>( input->GetData() ) );
}
template <class VTKWRITER>
std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetWritenMIMEType()
{
return m_MimeType;
}
template <class VTKWRITER>
std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetFileExtension()
{
return m_Extension;
}
diff --git a/Core/Code/Interactions/mitkDisplayInteractor.h b/Core/Code/Interactions/mitkDisplayInteractor.h
index 4658a9127e..2e3dfbf169 100644
--- a/Core/Code/Interactions/mitkDisplayInteractor.h
+++ b/Core/Code/Interactions/mitkDisplayInteractor.h
@@ -1,163 +1,163 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkDisplayInteractor_h
#define mitkDisplayInteractor_h
#include <MitkExports.h>
#include "mitkInteractionEventObserver.h"
namespace mitk
{
/**
*\class DisplayInteractor
*@brief Observer that manages the interaction with the display.
*
* This includes the interaction of Zooming, Panning, Scrolling and adjusting the LevelWindow.
*
* @ingroup Interaction
**/
/**
* Inherits from mitk::InteractionEventObserver since it doesn't alter any data (only their representation),
* and its actions cannot be associated with a DataNode. Also inherits from EventStateMachine
*/
class MITK_CORE_EXPORT DisplayInteractor: public EventStateMachine, public InteractionEventObserver
{
public:
mitkClassMacro(DisplayInteractor, EventStateMachine)
itkNewMacro(Self)
/**
- * By this function the Observer gets notifier about new events.
+ * By this function the Observer gets notified about new events.
* Here it is adapted to pass the events to the state machine in order to use
* its infrastructure.
- * It also checks if event is to be accepted when i already has been processed by a DataInteractor.
+ * It also checks if event is to be accepted when it already has been processed by a DataInteractor.
*/
virtual void Notify(InteractionEvent* interactionEvent, bool isHandled);
protected:
DisplayInteractor();
virtual ~DisplayInteractor();
/**
* Derived function.
* Connects the action names used in the state machine pattern with functions implemented within
* this InteractionEventObserver. This is only necessary here because the events are processed by the state machine.
*/
void ConnectActionsAndFunctions();
/**
* Derived function.
* Is executed when config object is set / changed.
* Here it is used to read out the parameters set in the configuration file,
* and set the member variables accordingly.
*/
virtual void ConfigurationChanged();
/**
* Derived function.
* Is executed when config object is set / changed.
* Here it is used to read out the parameters set in the configuration file,
* and set the member variables accordingly.
*/
virtual bool FilterEvents(InteractionEvent* interactionEvent, DataNode* dataNode);
/**
* \brief Initializes an interaction, saves the pointers start position for further reference.
*/
virtual bool Init(StateMachineAction*, InteractionEvent*);
/**
* \brief Performs panning of the data set in the render window.
*/
virtual bool Move(StateMachineAction*, InteractionEvent*);
/**
* \brief Performs zooming relative to mouse/pointer movement.
*
* Behavior is determined by \see m_ZoomDirection and \see m_ZoomFactor.
*
*/
virtual bool Zoom(StateMachineAction*, InteractionEvent*);
/**
* \brief Performs scrolling relative to mouse/pointer movement.
*
* Behavior is determined by \see m_ScrollDirection and \see m_AutoRepeat.
*
*/
virtual bool Scroll(StateMachineAction*, InteractionEvent*);
/**
* \brief Scrolls one layer up
*/
virtual bool ScrollOneDown(StateMachineAction*, InteractionEvent*);
/**
* \brief Scrolls one layer down
*/
virtual bool ScrollOneUp(StateMachineAction*, InteractionEvent*);
/**
* \brief Adjusts the level windows relative to mouse/pointer movement.
*/
virtual bool AdjustLevelWindow(StateMachineAction*, InteractionEvent*);
private:
/**
* \brief Coordinate of the pointer at begin of an interaction
*/
mitk::Point2D m_StartDisplayCoordinate;
/**
* \brief Coordinate of the pointer at begin of an interaction translated to mm unit
*/
mitk::Point2D m_StartCoordinateInMM;
/**
* \brief Coordinate of the pointer in the last step within an interaction.
*/
mitk::Point2D m_LastDisplayCoordinate;
/**
* \brief Current coordinates of the pointer.
*/
mitk::Point2D m_CurrentDisplayCoordinate;
/**
* \brief Modifier that defines how many slices are scrolled per pixel that the mouse has moved
*
* This modifier defines how many slices the scene is scrolled per pixel that the mouse cursor has moved.
* By default the modifier is 4. This means that when the user moves the cursor by 4 pixels in Y-direction
* the scene is scrolled by one slice. If the user has moved the the cursor by 20 pixels, the scene is
* scrolled by 5 slices.
*
* If the cursor has moved less than m_IndexToSliceModifier pixels the scene is scrolled by one slice.
*/
int m_IndexToSliceModifier;
/** Defines behavior at end of data set.
* If set to true it will restart at end of data set from the beginning.
*/
bool m_AutoRepeat;
/**
* Defines scroll behavior.
* Default is up/down movement of pointer performs scrolling
*/
std::string m_ScrollDirection;
/**
* Defines scroll behavior.
* Default is up/down movement of pointer performs zooming
*/
std::string m_ZoomDirection;
/**
* Determines if the Observer reacts to events that already have been processed by a DataInteractor.
* The default value is false.
*/
bool m_AlwaysReact;
/**
* Factor to adjust zooming speed.
*/
float m_ZoomFactor;
};
}
#endif
diff --git a/Core/Code/Interactions/mitkEventConfig.cpp b/Core/Code/Interactions/mitkEventConfig.cpp
index aeaaa7fd6e..ad0c4fa87e 100755
--- a/Core/Code/Interactions/mitkEventConfig.cpp
+++ b/Core/Code/Interactions/mitkEventConfig.cpp
@@ -1,393 +1,393 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkEventConfig.h"
#include "mitkEventFactory.h"
#include "mitkInteractionEvent.h"
#include "mitkInternalEvent.h"
#include "mitkInteractionKeyEvent.h"
#include "mitkInteractionEventConst.h"
// VTK
#include <vtkXMLParser.h>
#include <vtkXMLDataElement.h>
// us
#include "mitkGetModuleContext.h"
#include "mitkModule.h"
#include "mitkModuleResource.h"
#include "mitkModuleResourceStream.h"
namespace mitk {
class EventConfigXMLParser : public vtkXMLParser
{
public:
EventConfigXMLParser(EventConfigPrivate* d);
protected:
/**
* @brief Derived from XMLReader
**/
void StartElement(const char* elementName, const char **atts);
/**
* @brief Derived from XMLReader
**/
void EndElement(const char* elementName);
std::string ReadXMLStringAttribute(const std::string& name, const char** atts);
bool ReadXMLBooleanAttribute(const std::string& name, const char** atts);
private:
EventConfigPrivate* const d;
};
struct EventConfigPrivate : public SharedData
{
EventConfigPrivate();
EventConfigPrivate(const EventConfigPrivate& other);
struct EventMapping
{
std::string variantName;
InteractionEvent::ConstPointer interactionEvent;
};
/**
* Checks if mapping with the same parameters already exists, if so, it is replaced,
* else the new mapping added
*/
void InsertMapping(const EventMapping& mapping);
/**
* @brief List of all global properties of the config object.
*/
PropertyList::Pointer m_PropertyList;
/**
* @brief Temporal list of all prMousePressEventoperties of a Event. Used to parse an Input-Event and collect all parameters between the two <input>
* and </event_variant> tags.
*/
PropertyList::Pointer m_EventPropertyList;
EventMapping m_CurrEventMapping;
typedef std::list<EventMapping> EventListType;
/**
* Stores InteractionEvents and their corresponding VariantName
*/
EventListType m_EventList;
bool m_Errors; // use member, because of inheritance from vtkXMLParser we can't return a success value for parsing the file.
EventConfigXMLParser m_XmlParser;
};
}
mitk::EventConfigPrivate::EventConfigPrivate()
: m_PropertyList(PropertyList::New())
, m_Errors(false)
, m_XmlParser(this)
{
// Avoid VTK warning: Trying to delete object with non-zero reference count.
m_XmlParser.SetReferenceCount(0);
}
mitk::EventConfigPrivate::EventConfigPrivate(const EventConfigPrivate& other)
: SharedData(other)
, m_PropertyList(other.m_PropertyList->Clone())
, m_EventPropertyList(other.m_EventPropertyList->Clone())
, m_CurrEventMapping(other.m_CurrEventMapping)
, m_EventList(other.m_EventList)
, m_Errors(other.m_Errors)
, m_XmlParser(this)
{
// Avoid VTK warning: Trying to delete object with non-zero reference count.
m_XmlParser.SetReferenceCount(0);
}
void mitk::EventConfigPrivate::InsertMapping(const EventMapping& mapping)
{
for (EventListType::iterator it = m_EventList.begin(); it != m_EventList.end(); ++it)
{
if (*(it->interactionEvent) == *mapping.interactionEvent)
{
//MITK_INFO<< "Configuration overwritten:" << (*it).variantName;
m_EventList.erase(it);
break;
}
}
m_EventList.push_back(mapping);
}
mitk::EventConfigXMLParser::EventConfigXMLParser(EventConfigPrivate *d)
: d(d)
{
}
void mitk::EventConfigXMLParser::StartElement(const char* elementName, const char **atts)
{
std::string name(elementName);
- if (name == InteractionEventConst::xmlTagConfigRoot)
+ if (name == InteractionEventConst::xmlTagConfigRoot())
{
//
}
- else if (name == InteractionEventConst::xmlTagParam)
+ else if (name == InteractionEventConst::xmlTagParam())
{
- std::string name = ReadXMLStringAttribute(InteractionEventConst::xmlParameterName, atts);
- std::string value = ReadXMLStringAttribute(InteractionEventConst::xmlParameterValue, atts);
+ std::string name = ReadXMLStringAttribute(InteractionEventConst::xmlParameterName(), atts);
+ std::string value = ReadXMLStringAttribute(InteractionEventConst::xmlParameterValue(), atts);
d->m_PropertyList->SetStringProperty(name.c_str(), value.c_str());
}
- else if (name == InteractionEventConst::xmlTagEventVariant)
+ else if (name == InteractionEventConst::xmlTagEventVariant())
{
- std::string eventClass = ReadXMLStringAttribute(InteractionEventConst::xmlParameterEventClass, atts);
- std::string eventVariant = ReadXMLStringAttribute(InteractionEventConst::xmlParameterName, atts);
+ std::string eventClass = ReadXMLStringAttribute(InteractionEventConst::xmlParameterEventClass(), atts);
+ std::string eventVariant = ReadXMLStringAttribute(InteractionEventConst::xmlParameterName(), atts);
// New list in which all parameters are stored that are given within the <input/> tag
d->m_EventPropertyList = PropertyList::New();
- d->m_EventPropertyList->SetStringProperty(InteractionEventConst::xmlParameterEventClass.c_str(), eventClass.c_str());
- d->m_EventPropertyList->SetStringProperty(InteractionEventConst::xmlParameterEventVariant.c_str(), eventVariant.c_str());
+ d->m_EventPropertyList->SetStringProperty(InteractionEventConst::xmlParameterEventClass().c_str(), eventClass.c_str());
+ d->m_EventPropertyList->SetStringProperty(InteractionEventConst::xmlParameterEventVariant().c_str(), eventVariant.c_str());
d->m_CurrEventMapping.variantName = eventVariant;
}
- else if (name == InteractionEventConst::xmlTagAttribute)
+ else if (name == InteractionEventConst::xmlTagAttribute())
{
// Attributes that describe an Input Event, such as which MouseButton triggered the event,or which modifier keys are pressed
- std::string name = ReadXMLStringAttribute(InteractionEventConst::xmlParameterName, atts);
- std::string value = ReadXMLStringAttribute(InteractionEventConst::xmlParameterValue, atts);
+ std::string name = ReadXMLStringAttribute(InteractionEventConst::xmlParameterName(), atts);
+ std::string value = ReadXMLStringAttribute(InteractionEventConst::xmlParameterValue(), atts);
d->m_EventPropertyList->SetStringProperty(name.c_str(), value.c_str());
}
}
void mitk::EventConfigXMLParser::EndElement(const char* elementName)
{
std::string name(elementName);
// At end of input section, all necessary infos are collected to created an interaction event.
- if (name == InteractionEventConst::xmlTagEventVariant)
+ if (name == InteractionEventConst::xmlTagEventVariant())
{
InteractionEvent::Pointer event = EventFactory::CreateEvent(d->m_EventPropertyList);
if (event.IsNotNull())
{
d->m_CurrEventMapping.interactionEvent = event;
d->InsertMapping(d->m_CurrEventMapping);
}
else
{
MITK_WARN<< "EventConfig: Unknown Event-Type in config. Entry skipped: " << name;
}
}
}
std::string mitk::EventConfigXMLParser::ReadXMLStringAttribute(const std::string& name, const char** atts)
{
if (atts)
{
const char** attsIter = atts;
while (*attsIter)
{
if (name == *attsIter)
{
attsIter++;
return *attsIter;
}
attsIter += 2;
}
}
return std::string();
}
bool mitk::EventConfigXMLParser::ReadXMLBooleanAttribute(const std::string& name, const char** atts)
{
std::string s = ReadXMLStringAttribute(name, atts);
std::transform(s.begin(), s.end(), s.begin(), ::toupper);
return s == "TRUE";
}
mitk::EventConfig::EventConfig()
: d(new EventConfigPrivate)
{
}
mitk::EventConfig::EventConfig(const EventConfig &other)
: d(other.d)
{
}
mitk::EventConfig::EventConfig(const std::string& filename, const Module* module)
: d(new EventConfigPrivate)
{
if (module == NULL)
{
module = GetModuleContext()->GetModule();
}
mitk::ModuleResource resource = module->GetResource("Interactions/" + filename);
if (!resource.IsValid())
{
MITK_ERROR << "Resource not valid. State machine pattern in module " << module->GetName()
<< " not found: /Interactions/" << filename;
return;
}
EventConfig newConfig;
mitk::ModuleResourceStream stream(resource);
newConfig.d->m_XmlParser.SetStream(&stream);
bool success = newConfig.d->m_XmlParser.Parse() && !newConfig.d->m_Errors;
if (success)
{
*this = newConfig;
}
}
mitk::EventConfig::EventConfig(std::istream &inputStream)
: d(new EventConfigPrivate)
{
EventConfig newConfig;
newConfig.d->m_XmlParser.SetStream(&inputStream);
bool success = newConfig.d->m_XmlParser.Parse() && !newConfig.d->m_Errors;
if (success)
{
*this = newConfig;
}
}
mitk::EventConfig::EventConfig(const std::vector<PropertyList::Pointer> &configDescription)
: d(new EventConfigPrivate)
{
std::vector<PropertyList::Pointer>::const_iterator it_end = configDescription.end();
for (std::vector<PropertyList::Pointer>::const_iterator it = configDescription.begin(); it != it_end; ++it) {
InteractionEvent::Pointer event = EventFactory::CreateEvent(*it);
if (event.IsNotNull())
{
d->m_CurrEventMapping.interactionEvent = event;
std::string eventVariant;
- (*it)->GetStringProperty(InteractionEventConst::xmlTagEventVariant.c_str(), eventVariant);
+ (*it)->GetStringProperty(InteractionEventConst::xmlTagEventVariant().c_str(), eventVariant);
d->m_CurrEventMapping.variantName = eventVariant;
d->InsertMapping(d->m_CurrEventMapping);
}
else
{
MITK_WARN<< "EventConfig: Unknown Event-Type in config. When constructing from PropertyList.";
}
}
}
mitk::EventConfig& mitk::EventConfig::operator =(const mitk::EventConfig& other)
{
d = other.d;
return *this;
}
mitk::EventConfig::~EventConfig()
{
}
bool mitk::EventConfig::IsValid() const
{
return !d->m_EventList.empty();
}
bool mitk::EventConfig::AddConfig(const std::string& fileName, const Module* module)
{
if (module == NULL)
{
module = GetModuleContext()->GetModule();
}
mitk::ModuleResource resource = module->GetResource("Interactions/" + fileName);
if (!resource.IsValid())
{
MITK_ERROR << "Resource not valid. State machine pattern in module " << module->GetName()
<< " not found: /Interactions/" << fileName;
return false;
}
EventConfig newConfig(*this);
mitk::ModuleResourceStream stream(resource);
newConfig.d->m_XmlParser.SetStream(&stream);
bool success = newConfig.d->m_XmlParser.Parse() && !newConfig.d->m_Errors;
if (success)
{
*this = newConfig;
}
return success;
}
bool mitk::EventConfig::AddConfig(const EventConfig& config)
{
if (!config.IsValid()) return false;
d->m_PropertyList->ConcatenatePropertyList(config.d->m_PropertyList->Clone(), true);
d->m_EventPropertyList = config.d->m_EventPropertyList->Clone();
d->m_CurrEventMapping = config.d->m_CurrEventMapping;
d->InsertMapping(config.d->m_CurrEventMapping);
return true;
}
mitk::PropertyList::Pointer mitk::EventConfig::GetAttributes() const
{
return d->m_PropertyList;
}
std::string mitk::EventConfig::GetMappedEvent(const EventType& interactionEvent) const
{
// internal events are excluded from mapping
if (std::strcmp(interactionEvent->GetNameOfClass(), "InternalEvent") == 0)
{
InternalEvent* internalEvent = dynamic_cast<InternalEvent*>(interactionEvent.GetPointer());
return internalEvent->GetSignalName();
}
for (EventConfigPrivate::EventListType::const_iterator it = d->m_EventList.begin();
it != d->m_EventList.end(); ++it)
{
if (*(it->interactionEvent) == *interactionEvent)
{
return (*it).variantName;
}
}
// if this part is reached, no mapping has been found,
// so here we handle key events and map a key event to the string "Std" + letter/code
// so "A" will be returned as "StdA"
if (std::strcmp(interactionEvent->GetNameOfClass(), "InteractionKeyEvent") == 0)
{
InteractionKeyEvent* keyEvent = dynamic_cast<InteractionKeyEvent*>(interactionEvent.GetPointer());
return ("Std" + keyEvent->GetKey());
}
return "";
}
void mitk::EventConfig::ClearConfig()
{
d->m_PropertyList->Clear();
d->m_EventPropertyList->Clear();
d->m_CurrEventMapping.variantName.clear();
d->m_CurrEventMapping.interactionEvent = NULL;
d->m_EventList.clear();
d->m_Errors = false;
}
diff --git a/Core/Code/Interactions/mitkEventFactory.cpp b/Core/Code/Interactions/mitkEventFactory.cpp
index ad26f7e4dc..31a2e08c7a 100755
--- a/Core/Code/Interactions/mitkEventFactory.cpp
+++ b/Core/Code/Interactions/mitkEventFactory.cpp
@@ -1,224 +1,224 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkEventFactory.h"
#include <algorithm>
#include <sstream>
#include <string>
#include <mitkMousePressEvent.h>
#include <mitkMouseMoveEvent.h>
#include <mitkMouseReleaseEvent.h>
#include <mitkMouseWheelEvent.h>
#include <mitkInteractionKeyEvent.h>
#include <mitkInteractionEventConst.h>
#include <mitkInteractionPositionEvent.h>
#include <mitkInternalEvent.h>
namespace
{
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
{
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim))
{
elems.push_back(item);
}
return elems;
}
std::vector<std::string> split(const std::string &s, char delim)
{
std::vector < std::string > elems;
return split(s, delim, elems);
}
}
mitk::InteractionEvent::Pointer mitk::EventFactory::CreateEvent(PropertyList::Pointer list)
{
//
std::string eventClass, eventVariant;
- list->GetStringProperty(InteractionEventConst::xmlParameterEventClass.c_str(), eventClass);
- list->GetStringProperty(InteractionEventConst::xmlParameterEventVariant.c_str(), eventVariant);
+ list->GetStringProperty(InteractionEventConst::xmlParameterEventClass().c_str(), eventClass);
+ list->GetStringProperty(InteractionEventConst::xmlParameterEventVariant().c_str(), eventVariant);
// Query all possible attributes, if they are not present, set their default values.
// Position Events & Key Events
std::string strModifiers;
InteractionEvent::ModifierKeys modifiers = InteractionEvent::NoKey;
std::string strEventButton;
InteractionEvent::MouseButtons eventButton = InteractionEvent::NoButton;
std::string strButtonState;
InteractionEvent::MouseButtons buttonState = InteractionEvent::NoButton;
std::string strKey;
std::string key;
std::string strWheelDelta;
int wheelDelta;
std::string strSignalName = "";
Point2D pos;
pos.Fill(0);
// Parse modifier information
- if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyModifier.c_str(), strModifiers))
+ if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyModifier().c_str(), strModifiers))
{
std::vector<std::string> mods = split(strModifiers, ',');
for (std::vector<std::string>::iterator it = mods.begin(); it != mods.end(); ++it)
{
std::transform((*it).begin(), (*it).end(), (*it).begin(), ::toupper);
if (*it == "CTRL")
{
modifiers = modifiers | InteractionEvent::ControlKey;
}
else if (*it == "ALT")
{
modifiers = modifiers | InteractionEvent::AltKey;
}
else if (*it == "SHIFT")
{
modifiers = modifiers | InteractionEvent::ShiftKey;
}
else
{
MITK_WARN<< "mitkEventFactory: Invalid event modifier in config file :" << (*it);
}
}
}
// Set EventButton
- if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyEventButton.c_str(), strEventButton))
+ if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyEventButton().c_str(), strEventButton))
{
std::transform(strEventButton.begin(), strEventButton.end(), strEventButton.begin(), ::toupper);
if (strEventButton == "MIDDLEMOUSEBUTTON")
{
eventButton = InteractionEvent::MiddleMouseButton;
}
else if (strEventButton == "LEFTMOUSEBUTTON")
{
eventButton = InteractionEvent::LeftMouseButton;
}
else if (strEventButton == "RIGHTMOUSEBUTTON")
{
eventButton = InteractionEvent::RightMouseButton;
}
else
{
MITK_WARN<< "mitkEventFactory: Invalid event button in config file: " << strEventButton;
}
}
// Parse ButtonStates
- if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyButtonState.c_str(), strButtonState))
+ if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyButtonState().c_str(), strButtonState))
{
std::vector<std::string> mods = split(strButtonState, ',');
for (std::vector<std::string>::iterator it = mods.begin(); it != mods.end(); ++it)
{
std::transform((*it).begin(), (*it).end(), (*it).begin(), ::toupper);
if (*it == "MIDDLEMOUSEBUTTON")
{
buttonState = buttonState | InteractionEvent::MiddleMouseButton;
}
else if (*it == "LEFTMOUSEBUTTON")
{
buttonState = buttonState | InteractionEvent::LeftMouseButton;
}
else if (*it == "RIGHTMOUSEBUTTON")
{
buttonState = buttonState | InteractionEvent::RightMouseButton;
}
else
{
MITK_WARN<< "mitkEventFactory: Invalid event buttonstate in config file:" << (*it);
}
}
}
// Key
- if (!list->GetStringProperty(InteractionEventConst::xmlEventPropertyKey.c_str(), strKey))
+ if (!list->GetStringProperty(InteractionEventConst::xmlEventPropertyKey().c_str(), strKey))
{
key = "";
}
else
{
key = strKey;
}
// WheelDelta
- if (!list->GetStringProperty(InteractionEventConst::xmlEventPropertyScrollDirection.c_str(), strWheelDelta))
+ if (!list->GetStringProperty(InteractionEventConst::xmlEventPropertyScrollDirection().c_str(), strWheelDelta))
{
wheelDelta = 0;
}
else
{
std::transform(strWheelDelta.begin(), strWheelDelta.end(), strWheelDelta.begin(), ::toupper);
if (strWheelDelta == "DOWN")
{
wheelDelta = -1;
}
else
{
wheelDelta = 1;
}
}
// Internal Signals Name
- list->GetStringProperty(InteractionEventConst::xmlEventPropertySignalName.c_str(), strSignalName);
+ list->GetStringProperty(InteractionEventConst::xmlEventPropertySignalName().c_str(), strSignalName);
/*
* Here the objects are created
*/
mitk::InteractionEvent::Pointer event;
std::transform(eventClass.begin(), eventClass.end(), eventClass.begin(), ::toupper);
if (eventClass == "MOUSEPRESSEVENT")
{
// buttonstates incorporate the event button (as in Qt)
buttonState = buttonState | eventButton;
event = MousePressEvent::New(NULL, pos, buttonState, modifiers, eventButton);
}
else if (eventClass == "MOUSEMOVEEVENT")
{
event = MouseMoveEvent::New(NULL, pos, buttonState, modifiers);
}
else if (eventClass == "MOUSERELEASEEVENT")
{
event = MouseReleaseEvent::New(NULL, pos, buttonState, modifiers, eventButton);
}
else if (eventClass == "INTERACTIONKEYEVENT")
{
event = InteractionKeyEvent::New(NULL, key, modifiers);
}
else if (eventClass == "MOUSEWHEELEVENT")
{
event = MouseWheelEvent::New(NULL, pos, buttonState, modifiers, wheelDelta);
}
else if (eventClass == "INTERACTIONPOSITIONEVENT")
{
event = InteractionPositionEvent::New(NULL, pos);
}
else if (eventClass == "INTERNALEVENT")
{
event = InternalEvent::New(NULL, NULL, strSignalName);
}
else if (eventClass == "INTERACTIONEVENT")
{
event = InteractionEvent::New(NULL);
}
if (event.IsNull())
{
MITK_WARN<< "Event couldn't be constructed. Please check your StateMachine patterns and config files\n for the following event class, which is not valid: " << eventClass;
return NULL;
}
return event;
}
diff --git a/Core/Code/Interactions/mitkInteractionEventConst.cpp b/Core/Code/Interactions/mitkInteractionEventConst.cpp
index 35fb858ed3..810d1377af 100644
--- a/Core/Code/Interactions/mitkInteractionEventConst.cpp
+++ b/Core/Code/Interactions/mitkInteractionEventConst.cpp
@@ -1,41 +1,107 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkInteractionEventConst.h"
namespace mitk {
-// XML Tags
-const std::string InteractionEventConst::xmlTagConfigRoot = "config";
-const std::string InteractionEventConst::xmlTagParam = "param";
-const std::string InteractionEventConst::xmlTagEventVariant = "event_variant";
-const std::string InteractionEventConst::xmlTagAttribute = "attribute";
-
-// XML Param
-const std::string InteractionEventConst::xmlParameterName = "name";
-const std::string InteractionEventConst::xmlParameterValue = "value";
-const std::string InteractionEventConst::xmlParameterEventVariant = "event_variant";
-const std::string InteractionEventConst::xmlParameterEventClass = "class";
-
-// Event Description
-const std::string InteractionEventConst::xmlEventPropertyModifier = "Modifiers";
-const std::string InteractionEventConst::xmlEventPropertyEventButton = "EventButton";
-const std::string InteractionEventConst::xmlEventPropertyButtonState = "ButtonState";
-const std::string InteractionEventConst::xmlEventPropertyKey = "Key";
-const std::string InteractionEventConst::xmlEventPropertyScrollDirection = "ScrollDirection";
-const std::string InteractionEventConst::xmlEventPropertySignalName = "SignalName";
+const std::string InteractionEventConst::xmlTagConfigRoot()
+{
+ static const std::string xmlTagConfigRoot = "config";
+ return xmlTagConfigRoot;
+}
+
+const std::string InteractionEventConst::xmlTagParam()
+{
+ static const std::string xmlTagParam = "param";
+ return xmlTagParam;
+
+}
+
+const std::string InteractionEventConst::xmlTagEventVariant()
+{
+ static const std::string xmlTagEventVariant = "event_variant";
+ return xmlTagEventVariant;
+}
+
+const std::string InteractionEventConst::xmlTagAttribute()
+{
+ static const std::string xmlTagAttribute = "attribute";
+ return xmlTagAttribute;
+}
+
+const std::string InteractionEventConst::xmlParameterName()
+{
+ static const std::string xmlParameterName = "name";
+ return xmlParameterName;
+}
+
+const std::string InteractionEventConst::xmlParameterValue()
+{
+ static const std::string xmlParameterValue = "value";
+ return xmlParameterValue;
+}
+
+const std::string InteractionEventConst::xmlParameterEventVariant()
+{
+ static const std::string xmlParameterEventVariant = "event_variant";
+ return xmlParameterEventVariant;
+}
+
+const std::string InteractionEventConst::xmlParameterEventClass()
+{
+ static const std::string xmlParameterEventClass = "class";
+ return xmlParameterEventClass;
+}
+
+const std::string InteractionEventConst::xmlEventPropertyModifier()
+{
+ static const std::string xmlEventPropertyModifier = "Modifiers";
+ return xmlEventPropertyModifier;
+}
+
+const std::string InteractionEventConst::xmlEventPropertyEventButton()
+{
+ static const std::string xmlEventPropertyEventButton = "EventButton";
+ return xmlEventPropertyEventButton;
+}
+
+const std::string InteractionEventConst::xmlEventPropertyButtonState()
+{
+ static const std::string xmlEventPropertyButtonState = "ButtonState";
+ return xmlEventPropertyButtonState;
+}
+
+const std::string InteractionEventConst::xmlEventPropertyKey()
+{
+ static const std::string xmlEventPropertyKey = "Key";
+ return xmlEventPropertyKey;
+}
+
+const std::string InteractionEventConst::xmlEventPropertyScrollDirection()
+{
+ static const std::string xmlEventPropertyScrollDirection = "ScrollDirection";
+ return xmlEventPropertyScrollDirection;
+}
+
+const std::string InteractionEventConst::xmlEventPropertySignalName()
+{
+ static const std::string xmlEventPropertySignalName = "SignalName";
+ return xmlEventPropertySignalName;
+}
+
}
diff --git a/Core/Code/Interactions/mitkInteractionEventConst.h b/Core/Code/Interactions/mitkInteractionEventConst.h
index 37ef831324..fea72b994c 100644
--- a/Core/Code/Interactions/mitkInteractionEventConst.h
+++ b/Core/Code/Interactions/mitkInteractionEventConst.h
@@ -1,54 +1,53 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKINTERACTEVENTCONST_H
#define MITKINTERACTEVENTCONST_H
#include <string>
#include <MitkExports.h>
namespace mitk
{
/**
* @brief Constants to describe Mouse Events and special Key Events.
*/
struct MITK_CORE_EXPORT InteractionEventConst
{
// XML Tags
- static const std::string xmlTagConfigRoot; // = "config";
- static const std::string xmlTagParam; // = "param";
- static const std::string xmlTagEventVariant; // = "event_variant";
- static const std::string xmlTagAttribute; // = "attribute";
+ static const std::string xmlTagConfigRoot(); // = "config";
+ static const std::string xmlTagParam(); // = "param";
+ static const std::string xmlTagEventVariant(); // = "event_variant";
+ static const std::string xmlTagAttribute(); // = "attribute";
// XML Param
- static const std::string xmlParameterName; // = "name";
- static const std::string xmlParameterValue; // = "value";
- static const std::string xmlParameterEventVariant; // = "event_variant";
- static const std::string xmlParameterEventClass; // = "class";
+ static const std::string xmlParameterName(); // = "name";
+ static const std::string xmlParameterValue(); // = "value";
+ static const std::string xmlParameterEventVariant(); // = "event_variant";
+ static const std::string xmlParameterEventClass(); // = "class";
// Event Description
- static const std::string xmlEventPropertyModifier; // = "Modifiers";
- static const std::string xmlEventPropertyEventButton; // = "EventButton";
- static const std::string xmlEventPropertyButtonState; // = "ButtonState";
- static const std::string xmlEventPropertyKey; // = "Key";
- static const std::string xmlEventPropertyScrollDirection; // = "ScrollDirection";
- static const std::string xmlEventPropertySignalName; // = "SignalName";
-
+ static const std::string xmlEventPropertyModifier(); // = "Modifiers";
+ static const std::string xmlEventPropertyEventButton(); // = "EventButton";
+ static const std::string xmlEventPropertyButtonState(); // = "ButtonState";
+ static const std::string xmlEventPropertyKey(); // = "Key";
+ static const std::string xmlEventPropertyScrollDirection(); // = "ScrollDirection";
+ static const std::string xmlEventPropertySignalName(); // = "SignalName";
};
} //namespace mitk
#endif //ifndef MITKINTERACTEVENTCONST_H
diff --git a/Core/Code/Interactions/mitkStateMachineTransition.cpp b/Core/Code/Interactions/mitkStateMachineTransition.cpp
index d5b629df0e..020d23e7ad 100755
--- a/Core/Code/Interactions/mitkStateMachineTransition.cpp
+++ b/Core/Code/Interactions/mitkStateMachineTransition.cpp
@@ -1,99 +1,99 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkStateMachineTransition.h"
#include "mitkStateMachineAction.h"
#include "mitkStateMachineState.h"
#include "mitkEventFactory.h"
#include "mitkInteractionEventConst.h"
mitk::StateMachineTransition::StateMachineTransition(const std::string& nextStateName, const std::string& eventClass,
const std::string& eventVariant)
: m_EventClass(eventClass)
, m_EventVariant(eventVariant)
, m_NextStateName(nextStateName)
{
PropertyList::Pointer propertyList = PropertyList::New();
- propertyList->SetStringProperty(InteractionEventConst::xmlParameterEventClass.c_str(), eventClass.c_str());
+ propertyList->SetStringProperty(InteractionEventConst::xmlParameterEventClass().c_str(), eventClass.c_str());
m_TransitionEvent = EventFactory::CreateEvent(propertyList);
}
bool mitk::StateMachineTransition::operator ==(const StateMachineTransition& transition) const
{
// Create event based on incoming event type,
// then try to cast it to the type of event that this transition holds,
// if this is possible, the variant is checked
// check for NULL since a corrupted state machine might cause an empty event
if (m_TransitionEvent.IsNull())
{
return false;
}
PropertyList::Pointer propertyList = PropertyList::New();
- propertyList->SetStringProperty(InteractionEventConst::xmlParameterEventClass.c_str(), transition.m_EventClass.c_str());
+ propertyList->SetStringProperty(InteractionEventConst::xmlParameterEventClass().c_str(), transition.m_EventClass.c_str());
InteractionEvent::Pointer tmpEvent = EventFactory::CreateEvent(propertyList);
if (tmpEvent.IsNull()) {
return false;
}
if (m_TransitionEvent->IsSuperClassOf(tmpEvent.GetPointer()))
{
return (this->m_EventVariant == transition.m_EventVariant);
}
else
{
// if event variants match, but super class condition is violated
// this means that the configuration file, implements a class that does not
// support the type in the state machine.
if (this->m_EventVariant == transition.m_EventVariant)
{
MITK_WARN<< "Event type in Statemachine " << m_EventClass << " is not compatible to configuration class " << transition.m_EventClass;
}
return false;
}
}
mitk::StateMachineTransition::~StateMachineTransition()
{
//needed for correct reference counting of mitkState//, for real???
m_NextState = NULL;
m_Actions.clear();
}
void mitk::StateMachineTransition::AddAction(const StateMachineAction::Pointer& action)
{
m_Actions.push_back(action);
}
mitk::StateMachineState::Pointer mitk::StateMachineTransition::GetNextState() const
{
return m_NextState;
}
std::string mitk::StateMachineTransition::GetNextStateName() const
{
return m_NextStateName;
}
std::vector<mitk::StateMachineAction::Pointer> mitk::StateMachineTransition::GetActions() const
{
return m_Actions;
}
void mitk::StateMachineTransition::SetNextState(const SpStateMachineState& nextState)
{
m_NextState = nextState;
}
diff --git a/Core/Code/Rendering/mitkGLMapper2D.h b/Core/Code/Rendering/mitkGLMapper2D.h
index d332e5ee60..cb4cc6fec3 100644
--- a/Core/Code/Rendering/mitkGLMapper2D.h
+++ b/Core/Code/Rendering/mitkGLMapper2D.h
@@ -1,35 +1,35 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKGLMAPPER2D_H_HEADER_INCLUDED_C197C872
#define MITKGLMAPPER2D_H_HEADER_INCLUDED_C197C872
#include "mitkGLMapper.h"
namespace mitk {
// typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use GLMapper instead
+ // \deprecatedSince{2013_03} Use GLMapper instead
DEPRECATED(typedef GLMapper GLMapper2D);
} // namespace mitk
#endif /* MITKGLMAPPER2D_H_HEADER_INCLUDED_C197C872 */
diff --git a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp b/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
index dbf0bd9e86..4d401f3466 100644
--- a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
+++ b/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
@@ -1,665 +1,672 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkGL.h"
#include "mitkGeometry2DDataMapper2D.h"
#include "mitkBaseRenderer.h"
#include "mitkPlaneGeometry.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkSmartPointerProperty.h"
#include "mitkPlaneOrientationProperty.h"
#include "mitkGeometry2DDataToSurfaceFilter.h"
#include "mitkSurfaceGLMapper2D.h"
#include "mitkLine.h"
#include "mitkNodePredicateDataType.h"
#include "mitkResliceMethodProperty.h"
mitk::Geometry2DDataMapper2D::Geometry2DDataMapper2D()
: m_SurfaceMapper( NULL ), m_DataStorage(NULL), m_ParentNode(NULL),
m_OtherGeometry2Ds(), m_RenderOrientationArrows( false ),
m_ArrowOrientationPositive( true )
{
}
mitk::Geometry2DDataMapper2D::~Geometry2DDataMapper2D()
{
}
const mitk::Geometry2DData* mitk::Geometry2DDataMapper2D::GetInput(void)
{
return static_cast<const Geometry2DData * > ( GetDataNode()->GetData() );
}
-void mitk::Geometry2DDataMapper2D::GenerateDataForRenderer(mitk::BaseRenderer* /* renderer */)
+void mitk::Geometry2DDataMapper2D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
{
+ BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+
+ if(!ls->IsGenerateDataRequired(renderer,this,GetDataNode()))
+ return;
+
+ ls->UpdateGenerateDataTime();
+
// collect all Geometry2DDatas accessible from the DataStorage
m_OtherGeometry2Ds.clear();
if (m_DataStorage.IsNull())
return;
mitk::NodePredicateDataType::Pointer p = mitk::NodePredicateDataType::New("Geometry2DData");
mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetDerivations(m_ParentNode, p, false);
for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
{
if(it->Value().IsNull())
continue;
BaseData* data = it->Value()->GetData();
if (data == NULL)
continue;
Geometry2DData* geometry2dData = dynamic_cast<Geometry2DData*>(data);
if(geometry2dData == NULL)
continue;
PlaneGeometry* planegeometry = dynamic_cast<PlaneGeometry*>(geometry2dData->GetGeometry2D());
if (planegeometry != NULL)
m_OtherGeometry2Ds.push_back(it->Value());
}
}
void mitk::Geometry2DDataMapper2D::Paint(BaseRenderer *renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if(!visible) return;
Geometry2DData::Pointer input = const_cast< Geometry2DData * >(this->GetInput());
// intersecting with ourself?
if ( input.IsNull() || (this->GetInput()->GetGeometry2D() ==
renderer->GetCurrentWorldGeometry2D()) )
{
return; // do nothing!
}
const PlaneGeometry *inputPlaneGeometry =
dynamic_cast< const PlaneGeometry * >( input->GetGeometry2D() );
const PlaneGeometry *worldPlaneGeometry =
dynamic_cast< const PlaneGeometry* >(
renderer->GetCurrentWorldGeometry2D() );
if ( worldPlaneGeometry && inputPlaneGeometry
&& inputPlaneGeometry->GetReferenceGeometry() )
{
DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
assert( displayGeometry );
const Geometry3D *referenceGeometry =
inputPlaneGeometry->GetReferenceGeometry();
// calculate intersection of the plane data with the border of the
// world geometry rectangle
Point2D lineFrom, lineTo;
typedef Geometry3D::TransformType TransformType;
const TransformType *transform = dynamic_cast< const TransformType * >(
referenceGeometry->GetIndexToWorldTransform() );
TransformType::Pointer inverseTransform = TransformType::New();
transform->GetInverse( inverseTransform );
Line3D crossLine, otherCrossLine;
// Calculate the intersection line of the input plane with the world plane
if ( worldPlaneGeometry->IntersectionLine(
inputPlaneGeometry, crossLine ) )
{
BoundingBox::PointType boundingBoxMin, boundingBoxMax;
boundingBoxMin = referenceGeometry->GetBoundingBox()->GetMinimum();
boundingBoxMax = referenceGeometry->GetBoundingBox()->GetMaximum();
if(referenceGeometry->GetImageGeometry())
{
for(unsigned int i = 0; i < 3; ++i)
{
boundingBoxMin[i]-=0.5;
boundingBoxMax[i]-=0.5;
}
}
crossLine.Transform( *inverseTransform );
Point3D point1, point2;
// Then, clip this line with the (transformed) bounding box of the
// reference geometry.
if ( crossLine.BoxLineIntersection(
boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2],
boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2],
crossLine.GetPoint(), crossLine.GetDirection(),
point1, point2 ) == 2 )
{
// Transform the resulting line start and end points into display
// coordinates.
worldPlaneGeometry->Map(
transform->TransformPoint( point1 ), lineFrom );
worldPlaneGeometry->Map(
transform->TransformPoint( point2 ), lineTo );
Line< ScalarType, 2 > mainLine, otherLine;
Line< ScalarType, 2 > primaryHelperLine, secondaryHelperLine;
mainLine.SetPoints( lineFrom, lineTo );
primaryHelperLine.SetPoints( lineFrom, lineTo );
secondaryHelperLine.SetPoints( lineFrom, lineTo );
displayGeometry->WorldToDisplay( lineFrom, lineFrom );
displayGeometry->WorldToDisplay( lineTo, lineTo );
ScalarType lengthInDisplayUnits = (lineTo - lineFrom).GetNorm();
Vector2D mainLineDirectionOrthogonal;
mainLineDirectionOrthogonal[0] = -mainLine.GetDirection()[1];
mainLineDirectionOrthogonal[1] = mainLine.GetDirection()[0];
// lineParams stores the individual segments of the line, which are
// separated by a gap each (to mark the intersection with another
// displayed line)
std::vector< ScalarType > mainLineParams;
std::vector< ScalarType > primaryHelperLineParams;
std::vector< ScalarType > secondaryHelperLineParams;
mainLineParams.reserve( m_OtherGeometry2Ds.size() + 2 );
mainLineParams.push_back( 0.0 );
mainLineParams.push_back( 1.0 );
primaryHelperLineParams.reserve( m_OtherGeometry2Ds.size() + 2 );
primaryHelperLineParams.push_back( 0.0 );
primaryHelperLineParams.push_back( 1.0 );
secondaryHelperLineParams.reserve( m_OtherGeometry2Ds.size() + 2 );
secondaryHelperLineParams.push_back( 0.0 );
secondaryHelperLineParams.push_back( 1.0 );
// Now iterate through all other lines displayed in this window and
// calculate the positions of intersection with the line to be
// rendered; these positions will be stored in lineParams to form a
// gap afterwards.
NodesVectorType::iterator otherPlanesIt = m_OtherGeometry2Ds.begin();
NodesVectorType::iterator otherPlanesEnd = m_OtherGeometry2Ds.end();
//int mainLineThickSlicesMode = 0;
int mainLineThickSlicesNum = 1;
DataNode* dataNodeOfInputPlaneGeometry = NULL;
// Now we have to find the DataNode that contains the inputPlaneGeometry
// in order to determine the state of the thick-slice rendering
while ( otherPlanesIt != otherPlanesEnd )
{
PlaneGeometry *otherPlane = static_cast< PlaneGeometry * >(
static_cast< Geometry2DData * >(
(*otherPlanesIt)->GetData() )->GetGeometry2D() );
// if we have found the correct node
if ( (otherPlane == inputPlaneGeometry)
&& worldPlaneGeometry->IntersectionLine(
otherPlane, otherCrossLine ) )
{
dataNodeOfInputPlaneGeometry = (*otherPlanesIt);
// if( dataNodeOfInputPlaneGeometry )
// {
// mainLineThickSlicesMode = this->DetermineThickSliceMode(dataNodeOfInputPlaneGeometry, mainLineThickSlicesNum);
// }
break;
}
otherPlanesIt++;
}
// if we did not find a dataNode for the inputPlaneGeometry there is nothing we can do from here
if ( dataNodeOfInputPlaneGeometry == NULL )
return;
// Determine if we should draw the area covered by the thick slicing, default is false.
// This will also show the area of slices that do not have thick slice mode enabled
bool showAreaOfThickSlicing = false;
dataNodeOfInputPlaneGeometry->GetBoolProperty( "reslice.thickslices.showarea", showAreaOfThickSlicing );
// get the normal of the inputPlaneGeometry
Vector3D normal = inputPlaneGeometry->GetNormal();
// determine the pixelSpacing in that direction
double thickSliceDistance = SlicedGeometry3D::CalculateSpacing( referenceGeometry->GetSpacing(), normal );
// As the inputPlaneGeometry cuts through the center of the slice in the middle
// we have to add 0.5 pixel in order to compensate.
thickSliceDistance *= mainLineThickSlicesNum+0.5;
// not the nicest place to do it, but we have the width of the visible bloc in MM here
// so we store it in this fancy property
dataNodeOfInputPlaneGeometry->SetFloatProperty( "reslice.thickslices.sizeinmm", thickSliceDistance*2 );
if ( showAreaOfThickSlicing )
{
// vectorToHelperLine defines how to reach the helperLine from the mainLine
Vector2D vectorToHelperLine;
vectorToHelperLine = mainLineDirectionOrthogonal;
vectorToHelperLine.Normalize();
// got the right direction, so we multiply the width
vectorToHelperLine *= thickSliceDistance;
// and create the corresponding points
primaryHelperLine.SetPoints( primaryHelperLine.GetPoint1() - vectorToHelperLine,
primaryHelperLine.GetPoint2() - vectorToHelperLine );
secondaryHelperLine.SetPoints( secondaryHelperLine.GetPoint1() + vectorToHelperLine,
secondaryHelperLine.GetPoint2() + vectorToHelperLine );
}
//int otherLineThickSlicesMode = 0;
int otherLineThickSlicesNum = 1;
// by default, there is no gap for the helper lines
ScalarType gapSize = 0.0;
otherPlanesIt = m_OtherGeometry2Ds.begin();
while ( otherPlanesIt != otherPlanesEnd )
{
PlaneGeometry *otherPlane = static_cast< PlaneGeometry * >(
static_cast< Geometry2DData * >(
(*otherPlanesIt)->GetData() )->GetGeometry2D() );
// Just as with the original line, calculate the intersection with
// the world geometry...
if ( (otherPlane != inputPlaneGeometry)
&& worldPlaneGeometry->IntersectionLine(
otherPlane, otherCrossLine ) )
{
//otherLineThickSlicesMode = this->DetermineThickSliceMode((*otherPlanesIt), otherLineThickSlicesNum);
Vector3D normal = otherPlane->GetNormal();
double otherLineThickSliceDistance = SlicedGeometry3D::CalculateSpacing( referenceGeometry->GetSpacing(), normal );
otherLineThickSliceDistance *= (otherLineThickSlicesNum+0.5)*2;
Point2D otherLineFrom, otherLineTo;
// ... and clip the resulting line segment with the reference
// geometry bounding box.
otherCrossLine.Transform( *inverseTransform );
if ( otherCrossLine.BoxLineIntersection(
boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2],
boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2],
otherCrossLine.GetPoint(), otherCrossLine.GetDirection(),
point1, point2 ) == 2 )
{
worldPlaneGeometry->Map(
transform->TransformPoint( point1 ), otherLineFrom );
worldPlaneGeometry->Map(
transform->TransformPoint( point2 ), otherLineTo );
otherLine.SetPoints( otherLineFrom, otherLineTo );
// then we have to determine the gap position of the main line
// by finding the position at which the two lines cross
this->DetermineParametricCrossPositions( mainLine, otherLine, mainLineParams );
// if the other line is also in thick slice mode, we have to determine the
// gapsize considering the width of that other line and the spacing in its direction
if ( showAreaOfThickSlicing )
{
Vector2D otherLineDirection = otherLine.GetDirection();
otherLineDirection.Normalize();
mainLineDirectionOrthogonal.Normalize();
// determine the gapsize
gapSize = fabs( otherLineThickSliceDistance / ( otherLineDirection*mainLineDirectionOrthogonal ) );
gapSize = gapSize / displayGeometry->GetScaleFactorMMPerDisplayUnit();
// determine the gap positions for the helper lines as well
this->DetermineParametricCrossPositions( primaryHelperLine, otherLine, primaryHelperLineParams );
this->DetermineParametricCrossPositions( secondaryHelperLine, otherLine, secondaryHelperLineParams );
}
}
}
++otherPlanesIt;
}
// If we have to draw the helperlines, the mainline will be drawn as a dashed line
// with a fixed gapsize of 10 pixels
this->DrawLine(renderer,
lengthInDisplayUnits,
mainLine,
mainLineParams,
inputPlaneGeometry,
showAreaOfThickSlicing,
10.0
);
// If drawn, the helperlines are drawn as a solid line. The gapsize depends on the
// width of the crossed line.
if ( showAreaOfThickSlicing )
{
this->DrawLine(renderer,
lengthInDisplayUnits,
primaryHelperLine,
primaryHelperLineParams,
inputPlaneGeometry,
false,
gapSize
);
this->DrawLine(renderer,
lengthInDisplayUnits,
secondaryHelperLine,
secondaryHelperLineParams,
inputPlaneGeometry,
false,
gapSize
);
}
}
}
}
else
{
Geometry2DDataToSurfaceFilter::Pointer surfaceCreator;
SmartPointerProperty::Pointer surfacecreatorprop;
surfacecreatorprop = dynamic_cast< SmartPointerProperty * >(
GetDataNode()->GetProperty(
"surfacegeometry", renderer));
if( (surfacecreatorprop.IsNull()) ||
(surfacecreatorprop->GetSmartPointer().IsNull()) ||
((surfaceCreator = dynamic_cast< Geometry2DDataToSurfaceFilter * >(
surfacecreatorprop->GetSmartPointer().GetPointer())).IsNull())
)
{
surfaceCreator = Geometry2DDataToSurfaceFilter::New();
surfacecreatorprop = SmartPointerProperty::New(surfaceCreator);
surfaceCreator->PlaceByGeometryOn();
GetDataNode()->SetProperty( "surfacegeometry", surfacecreatorprop );
}
surfaceCreator->SetInput( input );
// Clip the Geometry2D with the reference geometry bounds (if available)
if ( input->GetGeometry2D()->HasReferenceGeometry() )
{
surfaceCreator->SetBoundingBox(
input->GetGeometry2D()->GetReferenceGeometry()->GetBoundingBox()
);
}
int res;
bool usegeometryparametricbounds = true;
if ( GetDataNode()->GetIntProperty("xresolution", res, renderer))
{
surfaceCreator->SetXResolution(res);
usegeometryparametricbounds=false;
}
if (GetDataNode()->GetIntProperty("yresolution", res, renderer))
{
surfaceCreator->SetYResolution(res);
usegeometryparametricbounds=false;
}
surfaceCreator->SetUseGeometryParametricBounds(usegeometryparametricbounds);
// Calculate the surface of the Geometry2D
surfaceCreator->Update();
if (m_SurfaceMapper.IsNull())
{
m_SurfaceMapper=SurfaceGLMapper2D::New();
}
m_SurfaceMapper->SetSurface(surfaceCreator->GetOutput());
m_SurfaceMapper->SetDataNode(GetDataNode());
m_SurfaceMapper->Paint(renderer);
}
}
void mitk::Geometry2DDataMapper2D::DrawOrientationArrow( mitk::Point2D &outerPoint, mitk::Point2D &innerPoint,
const mitk::PlaneGeometry *planeGeometry,
const mitk::PlaneGeometry *rendererPlaneGeometry,
const mitk::DisplayGeometry *displayGeometry,
bool positiveOrientation )
{
// Draw arrows to indicate plane orientation
// Vector along line
Vector2D v1 = innerPoint - outerPoint;
v1.Normalize();
v1 *= 7.0;
// Orthogonal vector
Vector2D v2;
v2[0] = v1[1];
v2[1] = -v1[0];
// Calculate triangle tip for one side and project it back into world
// coordinates to determine whether it is above or below the plane
Point2D worldPoint2D;
Point3D worldPoint;
displayGeometry->DisplayToWorld( outerPoint + v1 + v2, worldPoint2D );
rendererPlaneGeometry->Map( worldPoint2D, worldPoint );
// Initialize remaining triangle coordinates accordingly
// (above/below state is XOR'ed with orientation flag)
Point2D p1 = outerPoint + v1 * 2.0;
Point2D p2 = outerPoint + v1
+ ((positiveOrientation ^ planeGeometry->IsAbove( worldPoint ))
? v2 : -v2);
// Draw the arrow (triangle)
glBegin( GL_TRIANGLES );
glVertex2f( outerPoint[0], outerPoint[1] );
glVertex2f( p1[0], p1[1] );
glVertex2f( p2[0], p2[1] );
glEnd();
}
void mitk::Geometry2DDataMapper2D::ApplyAllProperties( BaseRenderer *renderer )
{
Superclass::ApplyColorAndOpacityProperties(renderer);
PlaneOrientationProperty* decorationProperty;
this->GetDataNode()->GetProperty( decorationProperty, "decoration", renderer );
if ( decorationProperty != NULL )
{
if ( decorationProperty->GetPlaneDecoration() ==
PlaneOrientationProperty::PLANE_DECORATION_POSITIVE_ORIENTATION )
{
m_RenderOrientationArrows = true;
m_ArrowOrientationPositive = true;
}
else if ( decorationProperty->GetPlaneDecoration() ==
PlaneOrientationProperty::PLANE_DECORATION_NEGATIVE_ORIENTATION )
{
m_RenderOrientationArrows = true;
m_ArrowOrientationPositive = false;
}
else
{
m_RenderOrientationArrows = false;
}
}
}
void mitk::Geometry2DDataMapper2D::SetDatastorageAndGeometryBaseNode( mitk::DataStorage::Pointer ds, mitk::DataNode::Pointer parent )
{
if (ds.IsNotNull())
{
m_DataStorage = ds;
}
if (parent.IsNotNull())
{
m_ParentNode = parent;
}
}
void mitk::Geometry2DDataMapper2D::DrawLine( BaseRenderer* renderer,
ScalarType lengthInDisplayUnits,
Line<ScalarType,2> &line,
std::vector<ScalarType> &gapPositions,
const PlaneGeometry* inputPlaneGeometry,
bool drawDashed,
ScalarType gapSizeInPixel
)
{
DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
const PlaneGeometry *worldPlaneGeometry =
dynamic_cast< const PlaneGeometry* >( renderer->GetCurrentWorldGeometry2D() );
// Apply color and opacity read from the PropertyList.
this->ApplyAllProperties( renderer );
ScalarType gapSizeInParamUnits =
1.0 / lengthInDisplayUnits * gapSizeInPixel;
std::sort( gapPositions.begin(), gapPositions.end() );
Point2D p1, p2;
ScalarType p1Param, p2Param;
p1Param = gapPositions[0];
p1 = line.GetPoint( p1Param );
displayGeometry->WorldToDisplay( p1, p1 );
//Workaround to show the crosshair always on top of a 2D render window
//The image is usually located at depth = 0 or negative depth values, and thus,
//the crosshair with depth = 1 is always on top.
float depthPosition = 1.0f;
if ( drawDashed )
{
glEnable(GL_LINE_STIPPLE);
glLineStipple(1, 0xF0F0);
}
glEnable(GL_DEPTH_TEST);
// Iterate over all line segments and display each, with a gap
// in between.
unsigned int i, preLastLineParam = gapPositions.size() - 1;
for ( i = 1; i < preLastLineParam; ++i )
{
p2Param = gapPositions[i] - gapSizeInParamUnits * 0.5;
p2 = line.GetPoint( p2Param );
if ( p2Param > p1Param )
{
// Convert intersection points (until now mm) to display
// coordinates (units).
displayGeometry->WorldToDisplay( p2, p2 );
// draw
glBegin (GL_LINES);
glVertex3f(p1[0],p1[1], depthPosition);
glVertex3f(p2[0],p2[1], depthPosition);
glEnd ();
if ( (i == 1) && (m_RenderOrientationArrows) )
{
// Draw orientation arrow for first line segment
this->DrawOrientationArrow( p1, p2,
inputPlaneGeometry, worldPlaneGeometry, displayGeometry,
m_ArrowOrientationPositive );
}
}
p1Param = p2Param + gapSizeInParamUnits;
p1 = line.GetPoint( p1Param );
displayGeometry->WorldToDisplay( p1, p1 );
}
// Draw last line segment
p2Param = gapPositions[i];
p2 = line.GetPoint( p2Param );
displayGeometry->WorldToDisplay( p2, p2 );
glBegin( GL_LINES );
glVertex3f( p1[0], p1[1], depthPosition);
glVertex3f( p2[0], p2[1], depthPosition);
glEnd();
if ( drawDashed )
{
glDisable(GL_LINE_STIPPLE);
}
// Draw orientation arrows
if ( m_RenderOrientationArrows )
{
this->DrawOrientationArrow( p2, p1,
inputPlaneGeometry, worldPlaneGeometry, displayGeometry,
m_ArrowOrientationPositive );
if ( preLastLineParam < 2 )
{
// If we only have one line segment, draw other arrow, too
this->DrawOrientationArrow( p1, p2,
inputPlaneGeometry, worldPlaneGeometry, displayGeometry,
m_ArrowOrientationPositive );
}
}
}
int mitk::Geometry2DDataMapper2D::DetermineThickSliceMode( DataNode * dn, int &thickSlicesNum )
{
int thickSlicesMode = 0;
// determine the state and the extend of the thick-slice mode
mitk::ResliceMethodProperty *resliceMethodEnumProperty=0;
if( dn->GetProperty( resliceMethodEnumProperty, "reslice.thickslices" ) && resliceMethodEnumProperty )
thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
IntProperty *intProperty=0;
if( dn->GetProperty( intProperty, "reslice.thickslices.num" ) && intProperty )
{
thickSlicesNum = intProperty->GetValue();
if(thickSlicesNum < 1) thickSlicesNum=0;
if(thickSlicesNum > 10) thickSlicesNum=10;
}
if ( thickSlicesMode == 0 )
thickSlicesNum = 0;
return thickSlicesMode;
}
void mitk::Geometry2DDataMapper2D::DetermineParametricCrossPositions( Line< mitk::ScalarType, 2 > &mainLine,
Line< mitk::ScalarType, 2 > &otherLine,
std::vector< mitk::ScalarType > &crossPositions )
{
Vector2D direction, dOrth;
// By means of the dot product, calculate the gap position as
// parametric value in the range [0, 1]
direction = otherLine.GetDirection();
dOrth[0] = -direction[1]; dOrth[1] = direction[0];
ScalarType gapPosition = ( otherLine.GetPoint1() - mainLine.GetPoint1() ) * dOrth;
ScalarType norm = mainLine.GetDirection() * dOrth;
if ( fabs( norm ) > eps )
{
gapPosition /= norm;
if ( (gapPosition > 0.0) && (gapPosition < 1.0) )
{
crossPositions.push_back(gapPosition);
}
}
}
diff --git a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.h b/Core/Code/Rendering/mitkGeometry2DDataMapper2D.h
index ff6e8a26ec..df8164324c 100644
--- a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.h
+++ b/Core/Code/Rendering/mitkGeometry2DDataMapper2D.h
@@ -1,121 +1,122 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKGEOMETRY2DDATAMAPPER2D_H_HEADER_INCLUDED_C19C0BFB
#define MITKGEOMETRY2DDATAMAPPER2D_H_HEADER_INCLUDED_C19C0BFB
#include <MitkExports.h>
#include "mitkGLMapper.h"
#include "mitkSurfaceGLMapper2D.h"
#include "mitkDataStorage.h"
#include "mitkDataNode.h"
#include "mitkWeakPointer.h"
namespace mitk {
class BaseRenderer;
/**
* \brief OpenGL-based mapper to display a Geometry2D in a 2D window
*
* Currently implemented for mapping on PlaneGeometry.
* The result is normally a line. An important usage of this class is to show
* the orientation of the slices displayed in other 2D windows.
*
*
* Properties that can be set and influence the Geometry2DDataMapper2D are:
*
* - \b "PlaneOrientationProperty": (PlaneOrientationProperty)
* \todo implement for AbstractTransformGeometry.
* \ingroup Mapper
*/
class MITK_CORE_EXPORT Geometry2DDataMapper2D : public GLMapper
{
public:
mitkClassMacro(Geometry2DDataMapper2D, GLMapper);
itkNewMacro(Self);
/**
* \brief Get the Geometry2DData to map
*/
const Geometry2DData *GetInput();
virtual void Paint( BaseRenderer *renderer );
virtual void SetDatastorageAndGeometryBaseNode(mitk::DataStorage::Pointer ds, mitk::DataNode::Pointer parent);
/** Applies properties specific to this mapper */
virtual void ApplyAllProperties( BaseRenderer *renderer );
+ LocalStorageHandler<BaseLocalStorage> m_LSH;
protected:
Geometry2DDataMapper2D();
virtual ~Geometry2DDataMapper2D();
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
/**
* \brief Returns the thick slice mode for the given datanode.
*
* This method returns the value of the 'reslice.thickslices' property for
* the given datanode.
* '0': thick slice mode disabled
* '1': thick slice mode enabled
*
* The variable 'thickSlicesNum' contains the value of the 'reslice.thickslices.num'
* property that defines how many slices are shown at once.
*/
int DetermineThickSliceMode( DataNode * dn, int &thickSlicesNum );
/**
* \brief Determines the cross position of two lines and stores them as parametric coordinates
*
* This method determines the parametric position at which a line 'otherLine' crosses another line
* 'mainLine'. The result is stored in 'crossPositions'.
*/
void DetermineParametricCrossPositions( Line<ScalarType,2> &mainLine, Line<ScalarType,2> &otherLine, std::vector<ScalarType> &crossPositions );
void DrawLine( BaseRenderer * renderer, ScalarType lengthInDisplayUnits,
Line< ScalarType, 2 > &line, std::vector< ScalarType > &gapPositions,
const PlaneGeometry * inputPlaneGeometry, bool drawDashed,
ScalarType gapSizeInPixel
);
void DrawOrientationArrow( Point2D &outerPoint, Point2D &innerPoint,
const PlaneGeometry *planeGeometry,
const PlaneGeometry *rendererPlaneGeometry,
const DisplayGeometry *displayGeometry,
bool positiveOrientation = true );
SurfaceGLMapper2D::Pointer m_SurfaceMapper;
mitk::WeakPointer<mitk::DataStorage> m_DataStorage; ///< DataStorage that will be searched for sub nodes
DataNode::Pointer m_ParentNode; ///< parent node that will be used to search for sub nodes
typedef std::vector<DataNode*> NodesVectorType;
NodesVectorType m_OtherGeometry2Ds;
bool m_RenderOrientationArrows;
bool m_ArrowOrientationPositive;
};
} // namespace mitk
#endif /* MITKGEOMETRY2DDATAMAPPER2D_H_HEADER_INCLUDED_C19C0BFB */
diff --git a/Core/Code/Rendering/mitkGradientBackground.cpp b/Core/Code/Rendering/mitkGradientBackground.cpp
index e7cc375679..833349dbb1 100644
--- a/Core/Code/Rendering/mitkGradientBackground.cpp
+++ b/Core/Code/Rendering/mitkGradientBackground.cpp
@@ -1,239 +1,239 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkGradientBackground.h"
#include "mitkVtkLayerController.h"
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkMapper.h>
#include <vtkActor.h>
#include <vtkPolyDataMapper.h>
#include <vtkPolyData.h>
#include <vtkCamera.h>
#include <vtkLookupTable.h>
#include <vtkCellArray.h>
#include <vtkUnsignedIntArray.h>
#include <vtkPoints.h>
#include <vtkPointData.h>
#include <vtkObjectFactory.h>
#include <vtkRendererCollection.h>
mitk::GradientBackground::GradientBackground()
{
m_RenderWindow = NULL;
m_Renderer = vtkRenderer::New();
m_Actor = vtkActor::New();
m_Mapper = vtkPolyDataMapper::New();
m_Lut = vtkLookupTable::New();
m_Plane = vtkPolyData::New();
vtkPoints* points = vtkPoints::New( );
points->InsertPoint(0,-10,0,0);
points->InsertPoint(1,-10,1,0);
points->InsertPoint(2,10,1,0);
points->InsertPoint(3,10,0,0);
vtkCellArray* cellArray = vtkCellArray::New();
cellArray->InsertNextCell(4);
cellArray->InsertCellPoint(0);
cellArray->InsertCellPoint(1);
cellArray->InsertCellPoint(2);
cellArray->InsertCellPoint(3);
vtkUnsignedIntArray* data = vtkUnsignedIntArray::New();
data->InsertTuple1(0,1);
data->InsertTuple1(1,0);
data->InsertTuple1(2,0);
data->InsertTuple1(3,1);
m_Plane->SetPoints( points );
m_Plane->SetPolys( cellArray );
m_Plane->GetPointData()->SetScalars( data );
points->Delete();
cellArray->Delete();
data->Delete();
m_Lut->SetNumberOfColors( 2 );
m_Lut->Build();
m_Lut->SetTableValue( m_Lut->GetIndex(0), 1, 1, 1 );
m_Lut->SetTableValue( m_Lut->GetIndex(1), 0, 0, 0 );
m_Mapper->SetInput( m_Plane );
m_Mapper->SetLookupTable( m_Lut );
//m_Mapper->ImmediateModeRenderingOn();
m_Actor->SetMapper( m_Mapper );
m_Renderer->AddActor( m_Actor );
m_Renderer->InteractiveOff();
m_Renderer->GetActiveCamera()->ParallelProjectionOn();
m_Renderer->ResetCamera();
m_Renderer->GetActiveCamera()->SetParallelScale(0.5);
}
mitk::GradientBackground::~GradientBackground()
{
if ( m_RenderWindow != NULL )
if ( this->IsEnabled() )
this->Disable();
if ( m_Plane != NULL )
m_Plane->Delete();
if( m_Lut != NULL )
m_Lut->Delete();
if ( m_Mapper != NULL )
m_Mapper->Delete();
if ( m_Actor!=NULL )
m_Actor->Delete();
if ( m_Renderer != NULL )
m_Renderer->Delete();
}
/**
* Sets the renderwindow, in which the gradient background
* will be shown. Make sure, you have called this function
* before calling Enable()
*/
void mitk::GradientBackground::SetRenderWindow( vtkRenderWindow * renderWindow )
{
m_RenderWindow = renderWindow;
}
/**
* Returns the vtkRenderWindow, which is used
* for displaying the gradient background
*/
vtkRenderWindow* mitk::GradientBackground::GetRenderWindow()
{
return m_RenderWindow;
}
/**
* Returns the renderer responsible for
* rendering the color gradient into the
* vtkRenderWindow
*/
vtkRenderer* mitk::GradientBackground::GetVtkRenderer()
{
return m_Renderer;
}
/**
* Returns the actor associated with the color gradient
*/
vtkActor* mitk::GradientBackground::GetActor()
{
return m_Actor;
}
/**
* Returns the mapper associated with the color
* gradient.
*/
vtkPolyDataMapper* mitk::GradientBackground::GetMapper()
{
return m_Mapper;
}
/**
* Sets the gradient colors. The gradient
* will smoothly fade from color1 to color2
*/
void mitk::GradientBackground::SetGradientColors( double r1, double g1, double b1, double r2, double g2, double b2 )
{
m_Lut->SetTableValue( m_Lut->GetIndex(0), r1, g1, b1 );
m_Lut->SetTableValue( m_Lut->GetIndex(1), r2, g2, b2 );
}
void mitk::GradientBackground::SetUpperColor(double r, double g, double b )
{
m_Lut->SetTableValue( m_Lut->GetIndex(0), r, g, b );
}
void mitk::GradientBackground::SetLowerColor(double r, double g, double b )
{
m_Lut->SetTableValue( m_Lut->GetIndex(1), r, g, b );
}
/**
* Enables drawing of the color gradient background.
* If you want to disable it, call the Disable() function.
*/
void mitk::GradientBackground::Enable()
{
mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertBackgroundRenderer(m_Renderer,true);
}
/**
* Disables drawing of the color gradient background.
* If you want to enable it, call the Enable() function.
*/
void mitk::GradientBackground::Disable()
{
if ( this->IsEnabled() )
{
mitk::VtkLayerController::GetInstance(m_RenderWindow)->RemoveRenderer(m_Renderer);
}
}
/**
* Checks, if the gradient background is currently
* enabled (visible)
*/
bool mitk::GradientBackground::IsEnabled()
{
if ( m_RenderWindow == NULL )
return false;
else
return ( mitk::VtkLayerController::GetInstance(m_RenderWindow)->IsRendererInserted(m_Renderer));
}
void mitk::GradientBackground::SetRequestedRegionToLargestPossibleRegion()
{
//nothing to do
}
bool mitk::GradientBackground::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::GradientBackground::VerifyRequestedRegion()
{
return true;
}
-void mitk::GradientBackground::SetRequestedRegion(itk::DataObject*)
+void mitk::GradientBackground::SetRequestedRegion( const itk::DataObject*)
{
//nothing to do
}
diff --git a/Core/Code/Rendering/mitkGradientBackground.h b/Core/Code/Rendering/mitkGradientBackground.h
index a6559a7cdf..2721b95de9 100644
--- a/Core/Code/Rendering/mitkGradientBackground.h
+++ b/Core/Code/Rendering/mitkGradientBackground.h
@@ -1,159 +1,159 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _vtk_Gradient_Background_h_
#define _vtk_Gradient_Background_h_
#include <mitkBaseData.h>
class vtkRenderer;
class vtkMapper;
class vtkActor;
class vtkPolyDataMapper;
class vtkLookupTable;
class vtkPolyData;
class vtkRenderWindow;
namespace mitk {
class RenderWindow;
/**
* Displays a color gradient in the background
* of a vtkRenderWindow.
* The gradient ist faked by displaying a non-interactable
* smoothly shaded plane in a separate layer behind the
* scene. After setting the renderwindow, the gradient may be
* activated by calling Enable()
*/
class MITK_CORE_EXPORT GradientBackground : public BaseData
{
public:
mitkClassMacro( GradientBackground, BaseData );
itkNewMacro( Self );
/**
* Sets the renderwindow, in which the gradient background
* will be shown. Make sure, you have called this function
* before calling Enable()
*/
virtual void SetRenderWindow( vtkRenderWindow* renderWindow );
/**
* Returns the vtkRenderWindow, which is used
* for displaying the gradient background
*/
virtual vtkRenderWindow* GetRenderWindow();
/**
* Returns the renderer responsible for
* rendering the color gradient into the
* vtkRenderWindow
*/
virtual vtkRenderer* GetVtkRenderer();
/**
* Returns the actor associated with the color gradient
*/
virtual vtkActor* GetActor();
/**
* Returns the mapper associated with the color
* gradient.
*/
virtual vtkPolyDataMapper* GetMapper();
/**
* Sets the gradient colors. The gradient
* will smoothly fade from color1 to color2
*/
virtual void SetGradientColors( double r1, double g1, double b1, double r2, double g2, double b2);
virtual void SetUpperColor(double r, double g, double b );
virtual void SetLowerColor(double r, double g, double b );
/**
* Enables drawing of the color gradient background.
* If you want to disable it, call the Disable() function.
*/
virtual void Enable();
/**
* Disables drawing of the color gradient background.
* If you want to enable it, call the Enable() function.
*/
virtual void Disable();
/**
* Checks, if the gradient background is currently
* enabled (visible)
*/
virtual bool IsEnabled();
/**
* Empty implementation, since the GradientBackground doesn't
* support the requested region concept
*/
virtual void SetRequestedRegionToLargestPossibleRegion();
/**
* Empty implementation, since the GradientBackground doesn't
* support the requested region concept
*/
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
/**
* Empty implementation, since the GradientBackground doesn't
* support the requested region concept
*/
virtual bool VerifyRequestedRegion();
/**
* Empty implementation, since the GradientBackground doesn't
* support the requested region concept
*/
- virtual void SetRequestedRegion(itk::DataObject*);
+ virtual void SetRequestedRegion( const itk::DataObject*);
protected:
/**
* Constructor
*/
GradientBackground();
/**
* Destructor
*/
~GradientBackground();
vtkRenderWindow* m_RenderWindow;
vtkRenderer* m_Renderer;
vtkActor* m_Actor;
vtkPolyDataMapper* m_Mapper;
vtkLookupTable* m_Lut;
vtkPolyData* m_Plane;
};
} //end of namespace mitk
#endif
diff --git a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
index ef50187136..7d6a88dfef 100644
--- a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
+++ b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
@@ -1,1077 +1,1077 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include <mitkAbstractTransformGeometry.h>
#include <mitkDataNode.h>
#include <mitkDataNodeFactory.h>
#include <mitkImageSliceSelector.h>
#include <mitkLevelWindowProperty.h>
#include <mitkLookupTableProperty.h>
#include <mitkPlaneGeometry.h>
#include <mitkProperties.h>
#include <mitkResliceMethodProperty.h>
#include <mitkTimeSlicedGeometry.h>
#include <mitkVtkResliceInterpolationProperty.h>
#include <mitkPixelType.h>
//#include <mitkTransferFunction.h>
#include <mitkTransferFunctionProperty.h>
#include "mitkImageStatisticsHolder.h"
#include "mitkPlaneClipping.h"
//MITK Rendering
#include "mitkImageVtkMapper2D.h"
#include "vtkMitkThickSlicesFilter.h"
#include "vtkMitkLevelWindowFilter.h"
#include "vtkNeverTranslucentTexture.h"
//VTK
#include <vtkProperty.h>
#include <vtkTransform.h>
#include <vtkMatrix4x4.h>
#include <vtkLookupTable.h>
#include <vtkImageData.h>
#include <vtkPoints.h>
#include <vtkGeneralTransform.h>
#include <vtkImageReslice.h>
#include <vtkImageChangeInformation.h>
#include <vtkPlaneSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkCellArray.h>
#include <vtkCamera.h>
#include <vtkColorTransferFunction.h>
//ITK
#include <itkRGBAPixel.h>
#include <mitkRenderingModeProperty.h>
mitk::ImageVtkMapper2D::ImageVtkMapper2D()
{
}
mitk::ImageVtkMapper2D::~ImageVtkMapper2D()
{
//The 3D RW Mapper (Geometry2DDataVtkMapper3D) is listening to this event,
//in order to delete the images from the 3D RW.
this->InvokeEvent( itk::DeleteEvent() );
}
//set the two points defining the textured plane according to the dimension and spacing
void mitk::ImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer* renderer, vtkFloatingPointType planeBounds[6])
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
float depth = this->CalculateLayerDepth(renderer);
//Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
//plane size in crosshair rotation and swivel mode.
localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
//These two points define the axes of the plane in combination with the origin.
//Point 1 is the x-axis and point 2 the y-axis.
//Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
localStorage->m_Plane->SetPoint1(planeBounds[1] , planeBounds[2], depth); //P1: (xMax, yMin, depth)
localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); //P2: (xMin, yMax, depth)
}
float mitk::ImageVtkMapper2D::CalculateLayerDepth(mitk::BaseRenderer* renderer)
{
//get the clipping range to check how deep into z direction we can render images
double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
//Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
float depth = -maxRange*0.01; // divide by 100
int layer = 0;
GetDataNode()->GetIntProperty( "layer", layer, renderer);
//add the layer property for each image to render images with a higher layer on top of the others
depth += layer*10; //*10: keep some room for each image (e.g. for QBalls in between)
if(depth > 0.0f) {
depth = 0.0f;
MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
}
return depth;
}
const mitk::Image* mitk::ImageVtkMapper2D::GetInput( void )
{
return static_cast< const mitk::Image * >( GetDataNode()->GetData() );
}
vtkProp* mitk::ImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
{
//return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Actors;
}
void mitk::ImageVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
mitk::DataNode* datanode = this->GetDataNode();
if ( input == NULL || input->IsInitialized() == false )
{
return;
}
//check if there is a valid worldGeometry
const Geometry2D *worldGeometry = renderer->GetCurrentWorldGeometry2D();
if( ( worldGeometry == NULL ) || ( !worldGeometry->IsValid() ) || ( !worldGeometry->HasReferenceGeometry() ))
{
return;
}
input->Update();
// early out if there is no intersection of the current rendering geometry
// and the geometry of the image that is to be rendered.
if ( !RenderingGeometryIntersectsImage( worldGeometry, input->GetSlicedGeometry() ) )
{
// set image to NULL, to clear the texture in 3D, because
// the latest image is used there if the plane is out of the geometry
// see bug-13275
localStorage->m_ReslicedImage = NULL;
localStorage->m_Mapper->SetInput( localStorage->m_EmptyPolyData );
return;
}
//set main input for ExtractSliceFilter
localStorage->m_Reslicer->SetInput(input);
localStorage->m_Reslicer->SetWorldGeometry(worldGeometry);
localStorage->m_Reslicer->SetTimeStep( this->GetTimestep() );
//set the transformation of the image to adapt reslice axis
localStorage->m_Reslicer->SetResliceTransformByGeometry( input->GetTimeSlicedGeometry()->GetGeometry3D( this->GetTimestep() ) );
//is the geometry of the slice based on the input image or the worldgeometry?
bool inPlaneResampleExtentByGeometry = false;
datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
// Initialize the interpolation mode for resampling; switch to nearest
// neighbor if the input image is too small.
if ( (input->GetDimension() >= 3) && (input->GetDimension(2) > 1) )
{
VtkResliceInterpolationProperty *resliceInterpolationProperty;
datanode->GetProperty(
resliceInterpolationProperty, "reslice interpolation" );
int interpolationMode = VTK_RESLICE_NEAREST;
if ( resliceInterpolationProperty != NULL )
{
interpolationMode = resliceInterpolationProperty->GetInterpolation();
}
switch ( interpolationMode )
{
case VTK_RESLICE_NEAREST:
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
break;
case VTK_RESLICE_LINEAR:
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);
break;
case VTK_RESLICE_CUBIC:
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);
break;
}
}
else
{
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
}
//set the vtk output property to true, makes sure that no unneeded mitk image convertion
//is done.
localStorage->m_Reslicer->SetVtkOutputRequest(true);
//Thickslicing
int thickSlicesMode = 0;
int thickSlicesNum = 1;
// Thick slices parameters
if( input->GetPixelType().GetNumberOfComponents() == 1 ) // for now only single component are allowed
{
DataNode *dn=renderer->GetCurrentWorldGeometry2DNode();
if(dn)
{
ResliceMethodProperty *resliceMethodEnumProperty=0;
if( dn->GetProperty( resliceMethodEnumProperty, "reslice.thickslices" ) && resliceMethodEnumProperty )
thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
IntProperty *intProperty=0;
if( dn->GetProperty( intProperty, "reslice.thickslices.num" ) && intProperty )
{
thickSlicesNum = intProperty->GetValue();
if(thickSlicesNum < 1) thickSlicesNum=1;
if(thickSlicesNum > 10) thickSlicesNum=10;
}
}
else
{
MITK_WARN << "no associated widget plane data tree node found";
}
}
const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( worldGeometry );
if(thickSlicesMode > 0)
{
double dataZSpacing = 1.0;
Vector3D normInIndex, normal;
if ( planeGeometry != NULL ){
normal = planeGeometry->GetNormal();
}else{
const mitk::AbstractTransformGeometry* abstractGeometry = dynamic_cast< const AbstractTransformGeometry * >(worldGeometry);
if(abstractGeometry != NULL)
normal = abstractGeometry->GetPlane()->GetNormal();
else
return; //no fitting geometry set
}
normal.Normalize();
input->GetTimeSlicedGeometry()->GetGeometry3D( this->GetTimestep() )->WorldToIndex( normal, normInIndex );
dataZSpacing = 1.0 / normInIndex.GetNorm();
localStorage->m_Reslicer->SetOutputDimensionality( 3 );
localStorage->m_Reslicer->SetOutputSpacingZDirection(dataZSpacing);
localStorage->m_Reslicer->SetOutputExtentZDirection( -thickSlicesNum, 0+thickSlicesNum );
// Do the reslicing. Modified() is called to make sure that the reslicer is
// executed even though the input geometry information did not change; this
// is necessary when the input /em data, but not the /em geometry changes.
localStorage->m_TSFilter->SetThickSliceMode( thickSlicesMode-1 );
localStorage->m_TSFilter->SetInput( localStorage->m_Reslicer->GetVtkOutput() );
//vtkFilter=>mitkFilter=>vtkFilter update mechanism will fail without calling manually
localStorage->m_Reslicer->Modified();
localStorage->m_Reslicer->Update();
localStorage->m_TSFilter->Modified();
localStorage->m_TSFilter->Update();
localStorage->m_ReslicedImage = localStorage->m_TSFilter->GetOutput();
}
else
{
//this is needed when thick mode was enable bevore. These variable have to be reset to default values
localStorage->m_Reslicer->SetOutputDimensionality( 2 );
localStorage->m_Reslicer->SetOutputSpacingZDirection(1.0);
localStorage->m_Reslicer->SetOutputExtentZDirection( 0, 0 );
localStorage->m_Reslicer->Modified();
//start the pipeline with updating the largest possible, needed if the geometry of the input has changed
localStorage->m_Reslicer->UpdateLargestPossibleRegion();
localStorage->m_ReslicedImage = localStorage->m_Reslicer->GetVtkOutput();
}
// Bounds information for reslicing (only reuqired if reference geometry
// is present)
//this used for generating a vtkPLaneSource with the right size
vtkFloatingPointType sliceBounds[6];
for ( int i = 0; i < 6; ++i )
{
sliceBounds[i] = 0.0;
}
localStorage->m_Reslicer->GetClippedPlaneBounds(sliceBounds);
//get the spacing of the slice
localStorage->m_mmPerPixel = localStorage->m_Reslicer->GetOutputSpacing();
// calculate minimum bounding rect of IMAGE in texture
{
vtkFloatingPointType textureClippingBounds[6];
for ( int i = 0; i < 6; ++i )
{
textureClippingBounds[i] = 0.0;
}
// Calculate the actual bounds of the transformed plane clipped by the
// dataset bounding box; this is required for drawing the texture at the
// correct position during 3D mapping.
mitk::PlaneClipping::CalculateClippedPlaneBounds( input->GetGeometry(), planeGeometry, textureClippingBounds );
textureClippingBounds[0] = static_cast< int >( textureClippingBounds[0] / localStorage->m_mmPerPixel[0] + 0.5 );
textureClippingBounds[1] = static_cast< int >( textureClippingBounds[1] / localStorage->m_mmPerPixel[0] + 0.5 );
textureClippingBounds[2] = static_cast< int >( textureClippingBounds[2] / localStorage->m_mmPerPixel[1] + 0.5 );
textureClippingBounds[3] = static_cast< int >( textureClippingBounds[3] / localStorage->m_mmPerPixel[1] + 0.5 );
//clipping bounds for cutting the image
localStorage->m_LevelWindowFilter->SetClippingBounds(textureClippingBounds);
}
//get the number of scalar components to distinguish between different image types
int numberOfComponents = localStorage->m_ReslicedImage->GetNumberOfScalarComponents();
//get the binary property
bool binary = false;
bool binaryOutline = false;
datanode->GetBoolProperty( "binary", binary, renderer );
if(binary) //binary image
{
datanode->GetBoolProperty( "outline binary", binaryOutline, renderer );
if(binaryOutline) //contour rendering
{
if ( input->GetPixelType().GetBpe() <= 8 )
{
//generate contours/outlines
localStorage->m_OutlinePolyData = CreateOutlinePolyData(renderer);
float binaryOutlineWidth(1.0);
if ( datanode->GetFloatProperty( "outline width", binaryOutlineWidth, renderer ) )
{
if ( localStorage->m_Actors->GetNumberOfPaths() > 1 )
{
float binaryOutlineShadowWidth(1.5);
datanode->GetFloatProperty( "outline shadow width", binaryOutlineShadowWidth, renderer );
dynamic_cast<vtkActor*>(localStorage->m_Actors->GetParts()->GetItemAsObject(0))
->GetProperty()->SetLineWidth( binaryOutlineWidth * binaryOutlineShadowWidth );
}
localStorage->m_Actor->GetProperty()->SetLineWidth( binaryOutlineWidth );
}
}
else
{
binaryOutline = false;
this->ApplyLookuptable(renderer);
MITK_WARN << "Type of all binary images should be (un)signed char. Outline does not work on other pixel types!";
}
}
else //standard binary image
{
if(numberOfComponents != 1)
{
MITK_ERROR << "Rendering Error: Binary Images with more then 1 component are not supported!";
}
}
}
if (!(numberOfComponents == 1 || numberOfComponents == 3 || numberOfComponents == 4))
{
MITK_WARN << "Unknown number of components!";
}
this->ApplyOpacity( renderer );
this->ApplyRenderingMode(renderer);
// do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
localStorage->m_Texture->MapColorScalarsThroughLookupTableOff();
//connect the input with the levelwindow filter
localStorage->m_LevelWindowFilter->SetInput(localStorage->m_ReslicedImage);
//connect the texture with the output of the levelwindow filter
// check for texture interpolation property
bool textureInterpolation = false;
GetDataNode()->GetBoolProperty( "texture interpolation", textureInterpolation, renderer );
//set the interpolation modus according to the property
localStorage->m_Texture->SetInterpolate(textureInterpolation);
localStorage->m_Texture->SetInputConnection(localStorage->m_LevelWindowFilter->GetOutputPort());
this->TransformActor( renderer );
vtkActor* contourShadowActor = dynamic_cast<vtkActor*> (localStorage->m_Actors->GetParts()->GetItemAsObject(0));
if(binary && binaryOutline) //connect the mapper with the polyData which contains the lines
{
//We need the contour for the binary outline property as actor
localStorage->m_Mapper->SetInput(localStorage->m_OutlinePolyData);
localStorage->m_Actor->SetTexture(NULL); //no texture for contours
bool binaryOutlineShadow( false );
datanode->GetBoolProperty( "outline binary shadow", binaryOutlineShadow, renderer );
if ( binaryOutlineShadow )
contourShadowActor->SetVisibility( true );
else
contourShadowActor->SetVisibility( false );
}
else
{ //Connect the mapper with the input texture. This is the standard case.
//setup the textured plane
this->GeneratePlane( renderer, sliceBounds );
//set the plane as input for the mapper
localStorage->m_Mapper->SetInputConnection(localStorage->m_Plane->GetOutputPort());
//set the texture for the actor
localStorage->m_Actor->SetTexture(localStorage->m_Texture);
contourShadowActor->SetVisibility( false );
}
// We have been modified => save this for next Update()
localStorage->m_LastUpdateTime.Modified();
}
void mitk::ImageVtkMapper2D::ApplyLevelWindow(mitk::BaseRenderer *renderer)
{
LocalStorage *localStorage = this->GetLocalStorage( renderer );
LevelWindow levelWindow;
this->GetDataNode()->GetLevelWindow( levelWindow, renderer, "levelwindow" );
localStorage->m_LevelWindowFilter->GetLookupTable()->SetRange( levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound() );
mitk::LevelWindow opacLevelWindow;
if( this->GetDataNode()->GetLevelWindow( opacLevelWindow, renderer, "opaclevelwindow" ) )
{
//pass the opaque level window to the filter
localStorage->m_LevelWindowFilter->SetMinOpacity(opacLevelWindow.GetLowerWindowBound());
localStorage->m_LevelWindowFilter->SetMaxOpacity(opacLevelWindow.GetUpperWindowBound());
}
else
{
//no opaque level window
localStorage->m_LevelWindowFilter->SetMinOpacity(0.0);
localStorage->m_LevelWindowFilter->SetMaxOpacity(255.0);
}
}
void mitk::ImageVtkMapper2D::ApplyColor( mitk::BaseRenderer* renderer )
{
LocalStorage *localStorage = this->GetLocalStorage( renderer );
float rgb[3]= { 1.0f, 1.0f, 1.0f };
// check for color prop and use it for rendering if it exists
// binary image hovering & binary image selection
bool hover = false;
bool selected = false;
GetDataNode()->GetBoolProperty("binaryimage.ishovering", hover, renderer);
GetDataNode()->GetBoolProperty("selected", selected, renderer);
if(hover && !selected)
{
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
("binaryimage.hoveringcolor", renderer));
if(colorprop.IsNotNull())
{
memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
}
else
{
GetDataNode()->GetColor( rgb, renderer, "color" );
}
}
if(selected)
{
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
("binaryimage.selectedcolor", renderer));
if(colorprop.IsNotNull()) {
memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
}
else
{
GetDataNode()->GetColor(rgb, renderer, "color");
}
}
if(!hover && !selected)
{
GetDataNode()->GetColor( rgb, renderer, "color" );
}
double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; //conversion to double for VTK
dynamic_cast<vtkActor*> (localStorage->m_Actors->GetParts()->GetItemAsObject(0))->GetProperty()->SetColor(rgbConv);
localStorage->m_Actor->GetProperty()->SetColor(rgbConv);
if ( localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1 )
{
float rgb[3]= { 1.0f, 1.0f, 1.0f };
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
("outline binary shadow color", renderer));
if(colorprop.IsNotNull())
{
memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
}
double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; //conversion to double for VTK
dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) )->GetProperty()->SetColor(rgbConv);
}
}
void mitk::ImageVtkMapper2D::ApplyOpacity( mitk::BaseRenderer* renderer )
{
LocalStorage* localStorage = this->GetLocalStorage( renderer );
float opacity = 1.0f;
// check for opacity prop and use it for rendering if it exists
GetDataNode()->GetOpacity( opacity, renderer, "opacity" );
//set the opacity according to the properties
localStorage->m_Actor->GetProperty()->SetOpacity(opacity);
if ( localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1 )
{
dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) )->GetProperty()->SetOpacity(opacity);
}
}
void mitk::ImageVtkMapper2D::ApplyRenderingMode( mitk::BaseRenderer* renderer )
{
LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
bool binary = false;
this->GetDataNode()->GetBoolProperty( "binary", binary, renderer );
if(binary) // is it a binary image?
{
//for binary images, we always use our default LuT and map every value to (0,1)
//the opacity of 0 will always be 0.0. We never a apply a LuT/TfF nor a level window.
localStorage->m_LevelWindowFilter->SetLookupTable(localStorage->m_BinaryLookupTable);
}
else
{
//all other image types can make use of the rendering mode
int renderingMode = mitk::RenderingModeProperty::LEVELWINDOW_COLOR;
mitk::RenderingModeProperty::Pointer mode = dynamic_cast<mitk::RenderingModeProperty*>(this->GetDataNode()->GetProperty( "Image Rendering.Mode", renderer ));
if(mode.IsNotNull())
{
renderingMode = mode->GetRenderingMode();
}
switch(renderingMode)
{
case mitk::RenderingModeProperty::LEVELWINDOW_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_Color";
localStorage->m_LevelWindowFilter->SetLookupTable( localStorage->m_DefaultLookupTable );
this->ApplyLevelWindow( renderer );
break;
case mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_LookupTable_Color";
this->ApplyLookuptable( renderer );
this->ApplyLevelWindow( renderer );
break;
case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_ColorTransferFunction_Color";
this->ApplyColorTransferFunction( renderer );
this->ApplyLevelWindow( renderer );
break;
case mitk::RenderingModeProperty::LOOKUPTABLE_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = LookupTable_Color";
this->ApplyLookuptable( renderer );
break;
case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = ColorTransferFunction_Color";
this->ApplyColorTransferFunction( renderer );
break;
default:
MITK_ERROR << "No valid 'Image Rendering.Mode' set";
break;
}
}
//we apply color for all images (including binaries).
this->ApplyColor( renderer );
}
void mitk::ImageVtkMapper2D::ApplyLookuptable( mitk::BaseRenderer* renderer )
{
LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
vtkLookupTable* usedLookupTable = localStorage->m_ColorLookupTable;
// If lookup table or transferfunction use is requested...
mitk::LookupTableProperty::Pointer lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(this->GetDataNode()->GetProperty("LookupTable"));
if( lookupTableProp.IsNotNull() ) // is a lookuptable set?
{
usedLookupTable = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
}
else
{
MITK_WARN << "Image Rendering.Mode was set to use a lookup table but there is no property 'LookupTable'. A default (rainbow) lookup table will be used.";
}
localStorage->m_LevelWindowFilter->SetLookupTable(usedLookupTable);
}
void mitk::ImageVtkMapper2D::ApplyColorTransferFunction(mitk::BaseRenderer *renderer)
{
mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("Image Rendering.Transfer Function",renderer ));
if( transferFunctionProp.IsNull() )
{
MITK_ERROR << "'Image Rendering.Mode'' was set to use a color transfer function but there is no property 'Image Rendering.Transfer Function'. Nothing will be done.";
return;
}
LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
//pass the transfer function to our level window filter
localStorage->m_LevelWindowFilter->SetLookupTable(transferFunctionProp->GetValue()->GetColorTransferFunction());
}
void mitk::ImageVtkMapper2D::Update(mitk::BaseRenderer* renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible )
{
return;
}
mitk::Image* data = const_cast<mitk::Image *>( this->GetInput() );
if ( data == NULL )
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep( renderer );
// Check if time step is valid
const TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
if ( ( dataTimeGeometry == NULL )
|| ( dataTimeGeometry->GetTimeSteps() == 0 )
|| ( !dataTimeGeometry->IsValidTime( this->GetTimestep() ) ) )
{
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
//check if something important has changed and we need to rerender
if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
|| (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2DUpdateTime()) //was the geometry modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2D()->GetMTime())
|| (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
|| (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
{
this->GenerateDataForRenderer( renderer );
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
void mitk::ImageVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
// Properties common for both images and segmentations
node->AddProperty( "depthOffset", mitk::FloatProperty::New( 0.0 ), renderer, overwrite );
node->AddProperty( "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "outline width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
node->AddProperty( "outline binary shadow", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "outline binary shadow color", ColorProperty::New(0.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "outline shadow width", mitk::FloatProperty::New( 1.5 ), renderer, overwrite );
if(image->IsRotated()) node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC) );
else node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
node->AddProperty( "texture interpolation", mitk::BoolProperty::New( mitk::DataNodeFactory::m_TextureInterpolationActive ) ); // set to user configurable default value (see global options)
node->AddProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
node->AddProperty( "bounding box", mitk::BoolProperty::New( false ) );
mitk::RenderingModeProperty::Pointer renderingModeProperty = mitk::RenderingModeProperty::New();
node->AddProperty( "Image Rendering.Mode", renderingModeProperty);
std::string photometricInterpretation; // DICOM tag telling us how pixel values should be displayed
if ( node->GetStringProperty( "dicom.pixel.PhotometricInterpretation", photometricInterpretation ) )
{
// modality provided by DICOM or other reader
if ( photometricInterpretation.find("MONOCHROME1") != std::string::npos ) // meaning: display MINIMUM pixels as WHITE
{
// generate LUT (white to black)
mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
vtkLookupTable* bwLut = mitkLut->GetVtkLookupTable();
bwLut->SetTableRange (0, 1);
bwLut->SetSaturationRange (0, 0);
bwLut->SetHueRange (0, 0);
bwLut->SetValueRange (1, 0);
bwLut->SetAlphaRange (1, 1);
bwLut->SetRampToLinear();
bwLut->Build();
mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
mitkLutProp->SetLookupTable(mitkLut);
node->SetProperty( "LookupTable", mitkLutProp );
}
else
if ( photometricInterpretation.find("MONOCHROME2") != std::string::npos ) // meaning: display MINIMUM pixels as BLACK
{
// apply default LUT (black to white)
node->SetProperty( "color", mitk::ColorProperty::New( 1,1,1 ), renderer );
}
// PALETTE interpretation should be handled ok by RGB loading
}
bool isBinaryImage(false);
if ( ! node->GetBoolProperty("binary", isBinaryImage) )
{
// ok, property is not set, use heuristic to determine if this
// is a binary image
mitk::Image::Pointer centralSliceImage;
ScalarType minValue = 0.0;
ScalarType maxValue = 0.0;
ScalarType min2ndValue = 0.0;
ScalarType max2ndValue = 0.0;
mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
sliceSelector->SetInput(image);
sliceSelector->SetSliceNr(image->GetDimension(2)/2);
sliceSelector->SetTimeNr(image->GetDimension(3)/2);
sliceSelector->SetChannelNr(image->GetDimension(4)/2);
sliceSelector->Update();
centralSliceImage = sliceSelector->GetOutput();
if ( centralSliceImage.IsNotNull() && centralSliceImage->IsInitialized() )
{
minValue = centralSliceImage->GetStatistics()->GetScalarValueMin();
maxValue = centralSliceImage->GetStatistics()->GetScalarValueMax();
min2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMin();
max2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMax();
}
if ((maxValue == min2ndValue && minValue == max2ndValue) || minValue == maxValue)
{
// centralSlice is strange, lets look at all data
minValue = image->GetStatistics()->GetScalarValueMin();
maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute();
min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
}
isBinaryImage = ( maxValue == min2ndValue && minValue == max2ndValue );
}
// some more properties specific for a binary...
if (isBinaryImage)
{
node->AddProperty( "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite );
node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.selectedcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.selectedannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.hoveringcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.hoveringannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binary", mitk::BoolProperty::New( true ), renderer, overwrite );
node->AddProperty("layer", mitk::IntProperty::New(10), renderer, overwrite);
}
else //...or image type object
{
node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
node->AddProperty( "color", ColorProperty::New(1.0,1.0,1.0), renderer, overwrite );
node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
}
if(image.IsNotNull() && image->IsInitialized())
{
if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
{
/* initialize level/window from DICOM tags */
std::string sLevel;
std::string sWindow;
if ( image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowCenter", sLevel )
&& image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowWidth", sWindow ) )
{
float level = atof( sLevel.c_str() );
float window = atof( sWindow.c_str() );
mitk::LevelWindow contrast;
std::string sSmallestPixelValueInSeries;
std::string sLargestPixelValueInSeries;
if ( image->GetPropertyList()->GetStringProperty( "dicom.series.SmallestPixelValueInSeries", sSmallestPixelValueInSeries )
&& image->GetPropertyList()->GetStringProperty( "dicom.series.LargestPixelValueInSeries", sLargestPixelValueInSeries ) )
{
float smallestPixelValueInSeries = atof( sSmallestPixelValueInSeries.c_str() );
float largestPixelValueInSeries = atof( sLargestPixelValueInSeries.c_str() );
contrast.SetRangeMinMax( smallestPixelValueInSeries-1, largestPixelValueInSeries+1 ); // why not a little buffer?
// might remedy some l/w widget challenges
}
else
{
contrast.SetAuto( static_cast<mitk::Image*>(node->GetData()), false, true ); // we need this as a fallback
}
contrast.SetLevelWindow( level, window, true );
node->SetProperty( "levelwindow", LevelWindowProperty::New( contrast ), renderer );
}
}
if(((overwrite) || (node->GetProperty("opaclevelwindow", renderer)==NULL))
- && (image->GetPixelType().GetPixelTypeId() == itk::ImageIOBase::RGBA)
- && (image->GetPixelType().GetTypeId() == typeid( unsigned char)) )
+ && (image->GetPixelType().GetPixelType() == itk::ImageIOBase::RGBA)
+ && (image->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR) )
{
mitk::LevelWindow opaclevwin;
opaclevwin.SetRangeMinMax(0,255);
opaclevwin.SetWindowBounds(0,255);
mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
node->SetProperty( "opaclevelwindow", prop, renderer );
}
}
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
mitk::ImageVtkMapper2D::LocalStorage* mitk::ImageVtkMapper2D::GetLocalStorage(mitk::BaseRenderer* renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
vtkSmartPointer<vtkPolyData> mitk::ImageVtkMapper2D::CreateOutlinePolyData(mitk::BaseRenderer* renderer ){
LocalStorage* localStorage = this->GetLocalStorage(renderer);
//get the min and max index values of each direction
int* extent = localStorage->m_ReslicedImage->GetExtent();
int xMin = extent[0];
int xMax = extent[1];
int yMin = extent[2];
int yMax = extent[3];
int* dims = localStorage->m_ReslicedImage->GetDimensions(); //dimensions of the image
int line = dims[0]; //how many pixels per line?
int x = xMin; //pixel index x
int y = yMin; //pixel index y
char* currentPixel;
//get the depth for each contour
float depth = CalculateLayerDepth(renderer);
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New(); //the points to draw
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); //the lines to connect the points
// We take the pointer to the first pixel of the image
currentPixel = static_cast<char*>(localStorage->m_ReslicedImage->GetScalarPointer() );
while (y <= yMax)
{
//if the current pixel value is set to something
if ((currentPixel) && (*currentPixel != 0))
{
//check in which direction a line is necessary
//a line is added if the neighbor of the current pixel has the value 0
//and if the pixel is located at the edge of the image
//if vvvvv not the first line vvvvv
if (y > yMin && *(currentPixel-line) == 0)
{ //x direction - bottom edge of the pixel
//add the 2 points
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
//add the line between both points
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv not the last line vvvvv
if (y < yMax && *(currentPixel+line) == 0)
{ //x direction - top edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv not the first pixel vvvvv
if ( (x > xMin || y > yMin) && *(currentPixel-1) == 0)
{ //y direction - left edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv not the last pixel vvvvv
if ( (y < yMax || (x < xMax) ) && *(currentPixel+1) == 0)
{ //y direction - right edge of the pixel
vtkIdType p1 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
/* now consider pixels at the edge of the image */
//if vvvvv left edge of image vvvvv
if (x == xMin)
{ //draw left edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv right edge of image vvvvv
if (x == xMax)
{ //draw right edge of the pixel
vtkIdType p1 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv bottom edge of image vvvvv
if (y == yMin)
{ //draw bottom edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv top edge of image vvvvv
if (y == yMax)
{ //draw top edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
}//end if currentpixel is set
x++;
if (x > xMax)
{ //reached end of line
x = xMin;
y++;
}
// Increase the pointer-position to the next pixel.
// This is safe, as the while-loop and the x-reset logic above makes
// sure we do not exceed the bounds of the image
currentPixel++;
}//end of while
// Create a polydata to store everything in
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
// Add the points to the dataset
polyData->SetPoints(points);
// Add the lines to the dataset
polyData->SetLines(lines);
return polyData;
}
void mitk::ImageVtkMapper2D::TransformActor(mitk::BaseRenderer* renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
//get the transformation matrix of the reslicer in order to render the slice as axial, coronal or saggital
vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_Reslicer->GetResliceAxes();
trans->SetMatrix(matrix);
//transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or saggital)
localStorage->m_Actor->SetUserTransform(trans);
//transform the origin to center based coordinates, because MITK is center based.
localStorage->m_Actor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
if ( localStorage->m_Actors->GetNumberOfPaths() > 1 )
{
vtkActor* secondaryActor = dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) );
secondaryActor->SetUserTransform(trans);
secondaryActor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
}
}
bool mitk::ImageVtkMapper2D::RenderingGeometryIntersectsImage( const Geometry2D* renderingGeometry, SlicedGeometry3D* imageGeometry )
{
// if either one of the two geometries is NULL we return true
// for safety reasons
if ( renderingGeometry == NULL || imageGeometry == NULL )
return true;
// get the distance for the first cornerpoint
ScalarType initialDistance = renderingGeometry->SignedDistance( imageGeometry->GetCornerPoint( 0 ) );
for( int i=1; i<8; i++ )
{
mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint( i );
// get the distance to the other cornerpoints
ScalarType distance = renderingGeometry->SignedDistance( cornerPoint );
// if it has not the same signing as the distance of the first point
if ( initialDistance * distance < 0 )
{
// we have an intersection and return true
return true;
}
}
// all distances have the same sign, no intersection and we return false
return false;
}
mitk::ImageVtkMapper2D::LocalStorage::~LocalStorage()
{
}
mitk::ImageVtkMapper2D::LocalStorage::LocalStorage()
{
m_LevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
//Do as much actions as possible in here to avoid double executions.
m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
m_Texture = vtkSmartPointer<vtkNeverTranslucentTexture>::New().GetPointer();
m_DefaultLookupTable = vtkSmartPointer<vtkLookupTable>::New();
m_BinaryLookupTable = vtkSmartPointer<vtkLookupTable>::New();
m_ColorLookupTable = vtkSmartPointer<vtkLookupTable>::New();
m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_Actor = vtkSmartPointer<vtkActor>::New();
m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
m_Reslicer = mitk::ExtractSliceFilter::New();
m_TSFilter = vtkSmartPointer<vtkMitkThickSlicesFilter>::New();
m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
m_ReslicedImage = vtkSmartPointer<vtkImageData>::New();
m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
//the following actions are always the same and thus can be performed
//in the constructor for each image (i.e. the image-corresponding local storage)
m_TSFilter->ReleaseDataFlagOn();
//built a default lookuptable
m_DefaultLookupTable->SetRampToLinear();
m_DefaultLookupTable->SetSaturationRange( 0.0, 0.0 );
m_DefaultLookupTable->SetHueRange( 0.0, 0.0 );
m_DefaultLookupTable->SetValueRange( 0.0, 1.0 );
m_DefaultLookupTable->Build();
m_BinaryLookupTable->SetRampToLinear();
m_BinaryLookupTable->SetSaturationRange( 0.0, 0.0 );
m_BinaryLookupTable->SetHueRange( 0.0, 0.0 );
m_BinaryLookupTable->SetValueRange( 0.0, 1.0 );
m_BinaryLookupTable->SetRange(0.0, 1.0);
m_BinaryLookupTable->Build();
// add a default rainbow lookup table for color mapping
m_ColorLookupTable->SetRampToLinear();
m_ColorLookupTable->SetHueRange(0.6667, 0.0);
m_ColorLookupTable->SetTableRange(0.0, 20.0);
m_ColorLookupTable->Build();
// make first value transparent
{
double rgba[4];
m_BinaryLookupTable->GetTableValue(0, rgba);
m_BinaryLookupTable->SetTableValue(0, rgba[0], rgba[1], rgba[2], 0.0); // background to 0
}
//do not repeat the texture (the image)
m_Texture->RepeatOff();
//set the mapper for the actor
m_Actor->SetMapper( m_Mapper );
vtkSmartPointer<vtkActor> outlineShadowActor = vtkSmartPointer<vtkActor>::New();
outlineShadowActor->SetMapper( m_Mapper );
m_Actors->AddPart( outlineShadowActor );
m_Actors->AddPart( m_Actor );
}
diff --git a/Core/Code/Rendering/mitkImageVtkMapper2D.h b/Core/Code/Rendering/mitkImageVtkMapper2D.h
index 7fae62aa09..2f5c60d258 100644
--- a/Core/Code/Rendering/mitkImageVtkMapper2D.h
+++ b/Core/Code/Rendering/mitkImageVtkMapper2D.h
@@ -1,304 +1,304 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKIMAGEVTKMAPPER2D_H_HEADER_INCLUDED_C10E906E
#define MITKIMAGEVTKMAPPER2D_H_HEADER_INCLUDED_C10E906E
//MITK
#include <mitkCommon.h>
//MITK Rendering
#include "mitkBaseRenderer.h"
#include "mitkVtkMapper.h"
#include "mitkExtractSliceFilter.h"
//VTK
#include <vtkSmartPointer.h>
#include <vtkPropAssembly.h>
class vtkActor;
class vtkPolyDataMapper;
class vtkPlaneSource;
class vtkImageData;
class vtkLookupTable;
class vtkImageReslice;
class vtkImageChangeInformation;
class vtkPoints;
class vtkMitkThickSlicesFilter;
class vtkPolyData;
class vtkMitkApplyLevelWindowToRGBFilter;
class vtkMitkLevelWindowFilter;
namespace mitk {
/** \brief Mapper to resample and display 2D slices of a 3D image.
*
* The following image gives a brief overview of the mapping and the involved parts.
*
* \image html imageVtkMapper2Darchitecture.png
*
* First, the image is resliced by means of vtkImageReslice. The volume image
* serves as input to the mapper in addition to spatial placement of the slice and a few other
* properties such as thick slices. This code was already present in the old version
* (mitkImageMapperGL2D).
*
* Next, the obtained slice (m_ReslicedImage) is put into a vtkMitkLevelWindowFilter
* and the scalar levelwindow, opacity levelwindow and optional clipping to
* local image bounds are applied
*
* Next, the output of the vtkMitkLevelWindowFilter is used to create a texture
* (m_Texture) and a plane onto which the texture is rendered (m_Plane). For
* mapping purposes, a vtkPolyDataMapper (m_Mapper) is utilized. Orthographic
* projection is applied to create the effect of a 2D image. The mapper and the
* texture are assigned to the actor (m_Actor) which is passed to the VTK rendering
* pipeline via the method GetVtkProp().
*
* In order to transform the textured plane to the correct position in space, the
* same transformation as used for reslicing is applied to both the camera and the
* vtkActor. All important steps are explained in more detail below. The resulting
* 2D image (by reslicing the underlying 3D input image appropriately) can either
* be directly rendered in a 2D view or just be calculated to be used later by another
* rendering entity, e.g. in texture mapping in a 3D view.
*
* Properties that can be set for images and influence the imageMapper2D are:
*
* - \b "opacity": (FloatProperty) Opacity of the image
* - \b "color": (ColorProperty) Color of the image
* - \b "LookupTable": (mitkLookupTableProperty) If this property is set,
* the default lookuptable will be ignored and the "LookupTable" value
* will be used instead.
* - \b "Image Rendering.Mode": This property decides which mode is used to render images. (E.g. if a lookup table or a transferfunction is applied). Detailed documentation about the modes can be found here: \link mitk::RenderingerModeProperty \endlink
* - \b "Image Rendering.Transfer Function": (mitkTransferFunctionProperty) If this
* property is set, a color transferfunction will be used to color the image.
* - \b "binary": (BoolProperty) is the image a binary image or not
* - \b "outline binary": (BoolProperty) show outline of the image or not
* - \b "texture interpolation": (BoolProperty) texture interpolation of the image
* - \b "reslice interpolation": (VtkResliceInterpolationProperty) reslice interpolation of the image
* - \b "in plane resample extent by geometry": (BoolProperty) Do it or not
* - \b "bounding box": (BoolProperty) Is the Bounding Box of the image shown or not
* - \b "layer": (IntProperty) Layer of the image
* - \b "volume annotation color": (ColorProperty) color of the volume annotation, TODO has to be reimplemented
* - \b "volume annotation unit": (StringProperty) annotation unit as string (does not implicit convert the unit!)
unit is ml or cm3, TODO has to be reimplemented
* The default properties are:
* - \b "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite )
* - \b "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite )
* - \b "binary", mitk::BoolProperty::New( true ), renderer, overwrite )
* - \b "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite )
* - \b "texture interpolation", mitk::BoolProperty::New( mitk::DataNodeFactory::m_TextureInterpolationActive ) )
* - \b "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() )
* - \b "in plane resample extent by geometry", mitk::BoolProperty::New( false ) )
* - \b "bounding box", mitk::BoolProperty::New( false ) )
* - \b "layer", mitk::IntProperty::New(10), renderer, overwrite)
* - \b "Image Rendering.Transfer Function": Default color transfer function for CTs
* - \b "LookupTable": Rainbow color.
* If the modality-property is set for an image, the mapper uses modality-specific default properties,
* e.g. color maps, if they are defined.
* \ingroup Mapper
*/
class MITK_CORE_EXPORT ImageVtkMapper2D : public VtkMapper
{
public:
/** Standard class typedefs. */
mitkClassMacro( ImageVtkMapper2D,VtkMapper );
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \brief Get the Image to map */
const mitk::Image *GetInput(void);
/** \brief Checks whether this mapper needs to update itself and generate
* data. */
virtual void Update(mitk::BaseRenderer * renderer);
//### methods of MITK-VTK rendering pipeline
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
//### end of methods of MITK-VTK rendering pipeline
/** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
/**
* To render transveral, coronal, and sagittal, the mapper is called three times.
* For performance reasons, the corresponding data for each view is saved in the
* internal helper class LocalStorage. This allows rendering n views with just
* 1 mitkMapper using n vtkMapper.
* */
class MITK_CORE_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
/** \brief Actor of a 2D render window. */
vtkSmartPointer<vtkActor> m_Actor;
vtkSmartPointer<vtkPropAssembly> m_Actors;
/** \brief Mapper of a 2D render window. */
vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
/** \brief Current slice of a 2D render window.*/
vtkSmartPointer<vtkImageData> m_ReslicedImage;
/** \brief Empty vtkPolyData that is set when rendering geometry does not
* intersect the image geometry.
* \warning This member variable is set to NULL,
* if no image geometry is inside the plane geometry
* of the respective render window. Any user of this
* slice has to check whether it is set to NULL!
*/
vtkSmartPointer<vtkPolyData> m_EmptyPolyData;
/** \brief Plane on which the slice is rendered as texture. */
vtkSmartPointer<vtkPlaneSource> m_Plane;
/** \brief The texture which is used to render the current slice. */
vtkSmartPointer<vtkTexture> m_Texture;
/** \brief The lookuptables for colors and level window */
vtkSmartPointer<vtkLookupTable> m_DefaultLookupTable;
vtkSmartPointer<vtkLookupTable> m_BinaryLookupTable;
vtkSmartPointer<vtkLookupTable> m_ColorLookupTable;
/** \brief The actual reslicer (one per renderer) */
mitk::ExtractSliceFilter::Pointer m_Reslicer;
/** \brief Filter for thick slices */
vtkSmartPointer<vtkMitkThickSlicesFilter> m_TSFilter;
/** \brief PolyData object containg all lines/points needed for outlining the contour.
This container is used to save a computed contour for the next rendering execution.
For instance, if you zoom or pann, there is no need to recompute the contour. */
vtkSmartPointer<vtkPolyData> m_OutlinePolyData;
/** \brief Timestamp of last update of stored data. */
itk::TimeStamp m_LastUpdateTime;
/** \brief mmPerPixel relation between pixel and mm. (World spacing).*/
mitk::ScalarType* m_mmPerPixel;
/** \brief This filter is used to apply the level window to Grayvalue and RBG(A) images. */
vtkSmartPointer<vtkMitkLevelWindowFilter> m_LevelWindowFilter;
/** \brief Default constructor of the local storage. */
LocalStorage();
/** \brief Default deconstructor of the local storage. */
~LocalStorage();
};
/** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
- mitk::Mapper::LocalStorageHandler<LocalStorage> m_LSH;
+ mitk::LocalStorageHandler<LocalStorage> m_LSH;
/** \brief Get the LocalStorage corresponding to the current renderer. */
LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);
/** \brief Set the default properties for general image rendering. */
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
/** \brief This method switches between different rendering modes (e.g. use a lookup table or a transfer function).
* Detailed documentation about the modes can be found here: \link mitk::RenderingerModeProperty \endlink
*/
void ApplyRenderingMode(mitk::BaseRenderer *renderer);
protected:
/** \brief Transforms the actor to the actual position in 3D.
* \param renderer The current renderer corresponding to the render window.
*/
void TransformActor(mitk::BaseRenderer* renderer);
/** \brief Generates a plane according to the size of the resliced image in milimeters.
*
* \image html texturedPlane.png
*
* In VTK a vtkPlaneSource is defined through three points. The origin and two
* points defining the axes of the plane (see VTK documentation). The origin is
* set to (xMin; yMin; Z), where xMin and yMin are the minimal bounds of the
* resliced image in space. Z is relevant for blending and the layer property.
* The center of the plane (C) is also the center of the view plane (cf. the image above).
*
* \note For the standard MITK view with three 2D render windows showing three
* different slices, three such planes are generated. All these planes are generated
* in the XY-plane (even if they depict a YZ-slice of the volume).
*
*/
void GeneratePlane(mitk::BaseRenderer* renderer, vtkFloatingPointType planeBounds[6]);
/** \brief Generates a vtkPolyData object containing the outline of a given binary slice.
\param renderer: Pointer to the renderer containing the needed information
\note This code is based on code from the iil library.
*/
vtkSmartPointer<vtkPolyData> CreateOutlinePolyData(mitk::BaseRenderer* renderer);
/** Default constructor */
ImageVtkMapper2D();
/** Default deconstructor */
virtual ~ImageVtkMapper2D();
/** \brief Does the actual resampling, without rendering the image yet.
* All the data is generated inside this method. The vtkProp (or Actor)
* is filled with content (i.e. the resliced image).
*
* After generation, a 4x4 transformation matrix(t) of the current slice is obtained
* from the vtkResliceImage object via GetReslicesAxis(). This matrix is
* applied to each textured plane (actor->SetUserTransform(t)) to transform everything
* to the actual 3D position (cf. the following image).
*
* \image html cameraPositioning3D.png
*
*/
virtual void GenerateDataForRenderer(mitk::BaseRenderer *renderer);
/** \brief This method uses the vtkCamera clipping range and the layer property
* to calcualte the depth of the object (e.g. image or contour). The depth is used
* to keep the correct order for the final VTK rendering.*/
float CalculateLayerDepth(mitk::BaseRenderer* renderer);
/** \brief This method applies (or modifies) the lookuptable for all types of images.
* \warning To use the lookup table, the property 'Lookup Table' must be set and a 'Image Rendering.Mode'
* which uses the lookup table must be set.
*/
void ApplyLookuptable(mitk::BaseRenderer* renderer);
/** \brief This method applies a color transfer function.
* Internally, a vtkColorTransferFunction is used. This is usefull for coloring continous
* images (e.g. float)
* \warning To use the color transfer function, the property 'Image Rendering.Transfer Function' must be set and a 'Image Rendering.Mode' which uses the color transfer function must be set.
*/
void ApplyColorTransferFunction(mitk::BaseRenderer* renderer);
/**
* @brief ApplyLevelWindow Apply the level window for the given renderer.
* \warning To use the level window, the property 'LevelWindow' must be set and a 'Image Rendering.Mode' which uses the level window must be set.
* @param renderer Level window for which renderer?
*/
void ApplyLevelWindow(mitk::BaseRenderer* renderer);
/** \brief Set the color of the image/polydata */
void ApplyColor( mitk::BaseRenderer* renderer );
/** \brief Set the opacity of the actor. */
void ApplyOpacity( mitk::BaseRenderer* renderer );
/**
* \brief Calculates whether the given rendering geometry intersects the
* given SlicedGeometry3D.
*
* This method checks if the given Geometry2D intersects the given
* SlicedGeometry3D. It calculates the distance of the Geometry2D to all
* 8 cornerpoints of the SlicedGeometry3D. If all distances have the same
* sign (all positive or all negative) there is no intersection.
* If the distances have different sign, there is an intersection.
**/
bool RenderingGeometryIntersectsImage( const Geometry2D* renderingGeometry, SlicedGeometry3D* imageGeometry );
};
} // namespace mitk
#endif /* MITKIMAGEVTKMAPPER2D_H_HEADER_INCLUDED_C10E906E */
diff --git a/Core/Code/Rendering/mitkLocalStorageHandler.h b/Core/Code/Rendering/mitkLocalStorageHandler.h
new file mode 100644
index 0000000000..515b3a017b
--- /dev/null
+++ b/Core/Code/Rendering/mitkLocalStorageHandler.h
@@ -0,0 +1,115 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+
+#ifndef LOCALSTORAGEHANDLER_H_HEADER_INCLUDED_C1E6EA08
+#define LOCALSTORAGEHANDLER_H_HEADER_INCLUDED_C1E6EA08
+
+#include <MitkExports.h>
+#include "mitkBaseRenderer.h"
+#include "mitkVtkPropRenderer.h"
+#include "mitkLevelWindow.h"
+#include "mitkCommon.h"
+
+#include <itkObject.h>
+#include <itkWeakPointer.h>
+
+//Just included to get VTK version
+#include <vtkConfigure.h>
+
+class vtkWindow;
+class vtkProp;
+
+namespace mitk {
+
+
+ /** \brief Interface for accessing (templated) LocalStorageHandler instances.
+ */
+ class BaseLocalStorageHandler
+ {
+ public:
+ virtual ~BaseLocalStorageHandler() {}
+ virtual void ClearLocalStorage(mitk::BaseRenderer *renderer,bool unregisterFromBaseRenderer=true )=0;
+ };
+
+
+ /** \brief Templated class for management of LocalStorage implementations in Mappers.
+ *
+ * The LocalStorageHandler is responsible for providing a LocalStorage to a
+ * concrete mitk::Mapper subclass. Each RenderWindow / mitk::BaseRenderer is
+ * assigned its own LocalStorage instance so that all contained ressources
+ * (actors, shaders, textures, ...) are provided individually per window.
+ *
+ */
+ template<class L> class LocalStorageHandler : public mitk::BaseLocalStorageHandler
+ {
+ protected:
+
+ std::map<mitk::BaseRenderer *,L*> m_BaseRenderer2LS;
+
+ public:
+
+
+ /** \brief deallocates a local storage for a specifc BaseRenderer (if the
+ * BaseRenderer is itself deallocating it in its destructor, it has to set
+ * unregisterFromBaseRenderer=false)
+ */
+ virtual void ClearLocalStorage(mitk::BaseRenderer *renderer,bool unregisterFromBaseRenderer=true )
+ {
+ //MITK_INFO << "deleting a localstorage on a mapper request";
+ if(unregisterFromBaseRenderer)
+ renderer->UnregisterLocalStorageHandler( this );
+ L *l = m_BaseRenderer2LS[renderer];
+ m_BaseRenderer2LS.erase( renderer );
+ delete l;
+ }
+
+ /** \brief Retrieves a LocalStorage for a specific BaseRenderer.
+ *
+ * Should be used by mappers in GenerateDataForRenderer()
+ */
+ L *GetLocalStorage(mitk::BaseRenderer *forRenderer)
+ {
+ L *l = m_BaseRenderer2LS[ forRenderer ];
+ if(!l)
+ {
+ //MITK_INFO << "creating new localstorage";
+ l = new L;
+ m_BaseRenderer2LS[ forRenderer ] = l;
+ forRenderer->RegisterLocalStorageHandler( this );
+ }
+ return l;
+ }
+
+ ~LocalStorageHandler()
+ {
+ typename std::map<mitk::BaseRenderer *,L*>::iterator it;
+
+ for ( it=m_BaseRenderer2LS.begin() ; it != m_BaseRenderer2LS.end(); it++ )
+ {
+ (*it).first->UnregisterLocalStorageHandler(this);
+ delete (*it).second;
+ }
+
+ m_BaseRenderer2LS.clear();
+ }
+
+ };
+
+
+} // namespace mitk
+
+#endif /* LOCALSTORAGEHANDLER_H_HEADER_INCLUDED_C1E6EA08 */
diff --git a/Core/Code/Rendering/mitkManufacturerLogo.cpp b/Core/Code/Rendering/mitkManufacturerLogo.cpp
index 50d2830aa0..6cc9163583 100644
--- a/Core/Code/Rendering/mitkManufacturerLogo.cpp
+++ b/Core/Code/Rendering/mitkManufacturerLogo.cpp
@@ -1,380 +1,380 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkManufacturerLogo.h"
#include "mitkVtkLayerController.h"
#include <mitkStandardFileLocations.h>
#include <mitkConfig.h>
#include <itkObject.h>
#include <itkMacro.h>
#include <itksys/SystemTools.hxx>
#include <vtkImageImport.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkMapper.h>
#include <vtkImageActor.h>
#include <vtkImageMapper.h>
#include <vtkPolyData.h>
#include <vtkCamera.h>
#include <vtkObjectFactory.h>
#include <vtkRendererCollection.h>
#include <vtkPNGReader.h>
#include <vtkImageData.h>
#include <vtkConfigure.h>
#include <vtkImageFlip.h>
#include <mbilogo.h>
#include <algorithm>
mitk::ManufacturerLogo::ManufacturerLogo()
:m_ImageData(NULL)
{
m_RenderWindow = NULL;
m_Renderer = vtkRenderer::New();
m_Actor = vtkImageActor::New();
m_Mapper = vtkImageMapper::New();
m_PngReader = vtkPNGReader::New();
m_VtkImageImport = vtkImageImport::New();
m_LogoPosition = mitk::ManufacturerLogo::LowerRight;
m_IsEnabled = false;
m_ForceShowMBIDepartmentLogo = false;
m_ZoomFactor = 1.15;
m_Opacity = 0.5;
m_FileName = "";
m_PngReader->SetFileName(m_FileName.c_str());
}
mitk::ManufacturerLogo::~ManufacturerLogo()
{
if ( m_RenderWindow != NULL )
if ( this->IsEnabled() )
this->Disable();
if ( m_Mapper != NULL )
m_Mapper->Delete();
if ( m_Actor!=NULL )
m_Actor->Delete();
if ( m_Renderer != NULL )
m_Renderer->Delete();
if ( m_PngReader != NULL )
m_PngReader->Delete();
if ( m_VtkImageImport != NULL )
m_VtkImageImport->Delete();
if ( m_ImageData != NULL)
delete[] m_ImageData;
}
/**
* Sets the renderwindow, in which the logo
* will be shown. Make sure, you have called this function
* before calling Enable()
*/
void mitk::ManufacturerLogo::SetRenderWindow( vtkRenderWindow* renderWindow )
{
m_RenderWindow = renderWindow;
}
/**
* Returns the vtkRenderWindow, which is used
* for displaying the logo
*/
vtkRenderWindow* mitk::ManufacturerLogo::GetRenderWindow()
{
return m_RenderWindow;
}
/**
* Returns the renderer responsible for
* rendering the logo into the
* vtkRenderWindow
*/
vtkRenderer* mitk::ManufacturerLogo::GetVtkRenderer()
{
return m_Renderer;
}
/**
* Returns the actor associated with the logo
*/
vtkImageActor* mitk::ManufacturerLogo::GetActor()
{
return m_Actor;
}
/**
* Returns the mapper associated with the
* logo.
*/
vtkImageMapper* mitk::ManufacturerLogo::GetMapper()
{
return m_Mapper;
}
void mitk::ManufacturerLogo::SetLogoSource(const char* filename)
{
std::string file = filename;
if(file.length() != 0)
{
m_FileName = filename;
m_PngReader->SetFileName(m_FileName.c_str());
}
}
/**
* Enables drawing of the logo.
* If you want to disable it, call the Disable() function.
*/
void mitk::ManufacturerLogo::Enable()
{
if(m_IsEnabled)
return;
if(m_RenderWindow != NULL)
{
if(itksys::SystemTools::FileExists(m_FileName.c_str()) && !m_ForceShowMBIDepartmentLogo)
{
m_PngReader->Update();
m_Actor->SetInput(m_PngReader->GetOutput());
}
else // either logo file not found or logo renderer is forced to show the MBI logo
{
m_VtkImageImport->SetDataScalarTypeToUnsignedChar();
m_VtkImageImport->SetNumberOfScalarComponents(mbiLogo_NumberOfScalars);
m_VtkImageImport->SetWholeExtent(0,mbiLogo_Width-1,0,mbiLogo_Height-1,0,1-1);
m_VtkImageImport->SetDataExtentToWholeExtent();
// flip mbi logo around y axis and change color order
m_ImageData = new char[mbiLogo_Height*mbiLogo_Width*mbiLogo_NumberOfScalars];
unsigned int column, row;
char * dest = m_ImageData;
char * source = (char*) &mbiLogo_Data[0];;
char r, g, b, a;
for (column = 0; column < mbiLogo_Height; column++)
for (row = 0; row < mbiLogo_Width; row++)
{ //change r with b
b = *source++;
g = *source++;
r = *source++;
a = *source++;
*dest++ = r;
*dest++ = g;
*dest++ = b;
*dest++ = a;
}
m_VtkImageImport->SetImportVoidPointer(m_ImageData);
m_VtkImageImport->Modified();
m_VtkImageImport->Update();
m_Actor->SetInput(m_VtkImageImport->GetOutput());
}
m_Actor->SetOpacity(m_Opacity);
m_Renderer->AddActor( m_Actor );
m_Renderer->InteractiveOff();
SetupCamera();
SetupPosition();
mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertForegroundRenderer(m_Renderer,false);
m_IsEnabled = true;
}
}
void mitk::ManufacturerLogo::SetupCamera()
{
// set the vtk camera in way that stretches the logo all over the renderwindow
vtkImageData * image = m_Actor->GetInput();
m_Camera = m_Renderer->GetActiveCamera();
m_Camera->SetClippingRange(1,100000);
if ( !image )
return;
double spacing[3];
double origin[3];
int dimensions[3];
image->GetSpacing(spacing);
image->GetOrigin(origin);
image->GetDimensions(dimensions);
double focalPoint[3];
double position[3];
for ( unsigned int cc = 0; cc < 3; cc++)
{
focalPoint[cc] = origin[cc] + ( spacing[cc] * dimensions[cc] ) / 2.0;
position[cc] = focalPoint[cc];
}
m_Camera->SetViewUp (0,1,0);
int idx = 2;
const double distanceToFocalPoint = 1000;
position[idx] = distanceToFocalPoint;
m_Camera->ParallelProjectionOn();
m_Camera->SetPosition (position);
m_Camera->SetFocalPoint (focalPoint);
int d1 = (idx + 1) % 3;
int d2 = (idx + 2) % 3;
double max = std::max(dimensions[d1],dimensions[d2]);
m_Camera->SetParallelScale( max / 2 );
}
void mitk::ManufacturerLogo::SetupPosition()
{ // Position and Scale of the logo
double newPos[4];
int dimensions[3];
vtkImageData * image = m_Actor->GetInput();
image->GetDimensions(dimensions);
// normalize image dimensions
double max = std::max(dimensions[0],dimensions[1]);
double normX = dimensions[0] / max;
double normY = dimensions[1] / max;
double buffer = 0; // buffer to the boarder of the renderwindow
switch(m_LogoPosition)
{
case mitk::ManufacturerLogo::LowerLeft:
{
newPos[0] = (0 + buffer);
newPos[1] = (0 + buffer);
newPos[2] = 0.2 * normX * m_ZoomFactor;
newPos[3] = 0.2 * normY * m_ZoomFactor;
break;
}
case mitk::ManufacturerLogo::LowerRight:
{
newPos[0] = (1 - buffer) - 0.2 * normX * m_ZoomFactor;
newPos[1] = 0.0;
newPos[2] = (1 - buffer);
newPos[3] = 0.2 * normY * m_ZoomFactor;
break;
}
case mitk::ManufacturerLogo::UpperLeft:
{
newPos[0] = (0 + buffer);
newPos[1] = (1 - buffer) - 0.2 * normY * m_ZoomFactor;
newPos[2] = 0.2 * normX * m_ZoomFactor;
newPos[3] = (1 - buffer);
break;
}
case mitk::ManufacturerLogo::UpperRight:
{
newPos[0] = (1 - buffer) - 0.2 * normX * m_ZoomFactor;
newPos[1] = (1 - buffer) - 0.2 * normY * m_ZoomFactor;
newPos[2] = (1 - buffer);
newPos[3] = (1 - buffer);
break;
}
case mitk::ManufacturerLogo::Middle:
default:
{
newPos[0] = 0.5 - 0.2 * normX * m_ZoomFactor;
newPos[1] = 0.5 + 0.2 * normY * m_ZoomFactor;
newPos[2] = 0.5 - 0.2 * normX * m_ZoomFactor;
newPos[3] = 0.5 + 0.2 * normY * m_ZoomFactor;
break;
}
}
m_Renderer->SetViewport(newPos);
}
void mitk::ManufacturerLogo::ForceMBILogoVisible(bool visible)
{
m_ForceShowMBIDepartmentLogo = visible;
}
void mitk::ManufacturerLogo::SetZoomFactor( double factor )
{
m_ZoomFactor = factor;
}
void mitk::ManufacturerLogo::SetOpacity(double opacity)
{
m_Opacity = opacity;
}
/**
* Disables drawing of the logo.
* If you want to enable it, call the Enable() function.
*/
void mitk::ManufacturerLogo::Disable()
{
if ( this->IsEnabled() && !m_ForceShowMBIDepartmentLogo )
{
mitk::VtkLayerController::GetInstance(m_RenderWindow)->RemoveRenderer(m_Renderer);
m_IsEnabled = false;
}
}
/**
* Checks, if the logo is currently
* enabled (visible)
*/
bool mitk::ManufacturerLogo::IsEnabled()
{
return m_IsEnabled;
}
void mitk::ManufacturerLogo::SetRequestedRegionToLargestPossibleRegion()
{
//nothing to do
}
bool mitk::ManufacturerLogo::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::ManufacturerLogo::VerifyRequestedRegion()
{
return true;
}
-void mitk::ManufacturerLogo::SetRequestedRegion(itk::DataObject*)
+void mitk::ManufacturerLogo::SetRequestedRegion( const itk::DataObject*)
{
//nothing to do
}
diff --git a/Core/Code/Rendering/mitkManufacturerLogo.h b/Core/Code/Rendering/mitkManufacturerLogo.h
index 0553653bec..0dd9faa86b 100644
--- a/Core/Code/Rendering/mitkManufacturerLogo.h
+++ b/Core/Code/Rendering/mitkManufacturerLogo.h
@@ -1,182 +1,182 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _vtk_Logo_Rendering_h_
#define _vtk_Logo_Rendering_h_
#include <mitkBaseData.h>
class vtkRenderer;
class vtkRenderWindow;
class vtkMapper;
class vtkCamera;
class vtkImageActor;
class vtkImageMapper;
class vtkLookupTable;
class vtkPolyData;
class vtkPNGReader;
class vtkImageImport;
namespace mitk {
class RenderWindow;
/**
* Renders a company logo in the foreground
* of a vtkRenderWindow.
*/
class MITK_CORE_EXPORT ManufacturerLogo : public BaseData
{
public:
mitkClassMacro( ManufacturerLogo, BaseData );
itkNewMacro( Self );
enum LogoPosition{ UpperLeft, UpperRight, LowerLeft, LowerRight, Middle };
/**
* Sets the renderwindow, in which the logo
* will be shown. Make sure, you have called this function
* before calling Enable()
*/
virtual void SetRenderWindow( vtkRenderWindow* renderWindow );
/**
* Sets the source file for the logo.
*/
virtual void SetLogoSource(const char* filename);
/**
* Sets the opacity level of the logo.
*/
virtual void SetOpacity(double opacity);
/**
* Specifies the logo size, values from 0...10,
* where 1 is a nice little logo
*/
virtual void SetZoomFactor( double factor );
/**
* Enables drawing of the logo.
* If you want to disable it, call the Disable() function.
*/
virtual void Enable();
/**
* Disables drawing of the logo.
* If you want to enable it, call the Enable() function.
*/
virtual void Disable();
/**
* Checks, if the logo is currently
* enabled (visible)
*/
virtual bool IsEnabled();
/**
* Empty implementation, since the ManufacturerLogo doesn't
* support the requested region concept
*/
virtual void SetRequestedRegionToLargestPossibleRegion();
/**
* Empty implementation, since the ManufacturerLogo doesn't
* support the requested region concept
*/
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
/**
* Empty implementation, since the ManufacturerLogo doesn't
* support the requested region concept
*/
virtual bool VerifyRequestedRegion();
/**
* Empty implementation, since the ManufacturerLogo doesn't
* support the requested region concept
*/
- virtual void SetRequestedRegion(itk::DataObject*);
+ virtual void SetRequestedRegion( const itk::DataObject*);
/**
* Returns the vtkRenderWindow, which is used
* for displaying the logo
*/
virtual vtkRenderWindow* GetRenderWindow();
/**
* Returns the renderer responsible for
* rendering the logo into the
* vtkRenderWindow
*/
virtual vtkRenderer* GetVtkRenderer();
/**
* Returns the actor associated with the logo
*/
virtual vtkImageActor* GetActor();
/**
* Returns the mapper associated with the logo
*/
virtual vtkImageMapper* GetMapper();
/**
* If set true, this method forces the logo rendering mechanism that it always
* renders the MBI department logo, independent from mainapp option settings.
*/
virtual void ForceMBILogoVisible(bool visible);
protected:
void SetupCamera();
void SetupPosition();
/**
* Constructor
*/
ManufacturerLogo();
/**
* Destructor
*/
~ManufacturerLogo();
vtkRenderWindow* m_RenderWindow;
vtkRenderer* m_Renderer;
vtkImageActor* m_Actor;
vtkImageMapper* m_Mapper;
vtkPNGReader* m_PngReader;
vtkCamera* m_Camera;
vtkImageImport* m_VtkImageImport;
std::string m_FileName;
bool m_IsEnabled;
bool m_ForceShowMBIDepartmentLogo;
LogoPosition m_LogoPosition;
double m_ZoomFactor;
double m_Opacity;
char * m_ImageData;
};
} //end of namespace mitk
#endif
diff --git a/Core/Code/Rendering/mitkMapper.cpp b/Core/Code/Rendering/mitkMapper.cpp
index 8a8e2ebe88..6310f2875a 100644
--- a/Core/Code/Rendering/mitkMapper.cpp
+++ b/Core/Code/Rendering/mitkMapper.cpp
@@ -1,150 +1,164 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkMapper.h"
#include "mitkDataNode.h"
#include "mitkBaseRenderer.h"
#include "mitkProperties.h"
+
mitk::Mapper::Mapper()
:m_TimeStep( 0 )
{
}
mitk::Mapper::~Mapper()
{
}
mitk::BaseData* mitk::Mapper::GetData() const
{
return m_DataNode->GetData();
}
mitk::DataNode* mitk::Mapper::GetDataNode() const
{
return this->m_DataNode.GetPointer();
}
bool mitk::Mapper::GetColor(float rgb[3], mitk::BaseRenderer* renderer, const char* name) const
{
const mitk::DataNode* node=GetDataNode();
if(node==NULL)
return false;
return node->GetColor(rgb, renderer, name);
}
bool mitk::Mapper::GetVisibility(bool &visible, mitk::BaseRenderer* renderer, const char* name) const
{
const mitk::DataNode* node=GetDataNode();
if(node==NULL)
return false;
return node->GetVisibility(visible, renderer, name);
}
bool mitk::Mapper::GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const char* name) const
{
const mitk::DataNode* node=GetDataNode();
if(node==NULL)
return false;
return node->GetOpacity(opacity, renderer, name);
}
bool mitk::Mapper::GetLevelWindow(mitk::LevelWindow& levelWindow, mitk::BaseRenderer* renderer, const char* name) const
{
const mitk::DataNode* node=GetDataNode();
if(node==NULL)
return false;
return node->GetLevelWindow(levelWindow, renderer, name);
}
bool mitk::Mapper::IsVisible(mitk::BaseRenderer* renderer, const char* name) const
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, name);
return visible;
}
void mitk::Mapper::CalculateTimeStep( mitk::BaseRenderer *renderer )
{
if ( ( renderer != NULL ) && ( m_DataNode.GetPointer() != NULL ) )
{
m_TimeStep = renderer->GetTimeStep(m_DataNode->GetData());
}
else
{
m_TimeStep = 0;
}
}
void mitk::Mapper::Update(mitk::BaseRenderer *renderer)
{
const DataNode* node = GetDataNode();
+
assert(node!=NULL);
- //safety cause there are datatreenodes that have no defined data (video-nodes and root)
- unsigned int dataMTime = 0;
- mitk::BaseData::Pointer data = static_cast<mitk::BaseData *>(node->GetData());
+ mitk::BaseData * data = static_cast<mitk::BaseData *>(node->GetData());
- if (data.IsNotNull())
- {
- dataMTime = data->GetMTime();
- }
+ if (!data)
+ return;
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep( renderer );
// Check if time step is valid
const TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
if ( ( dataTimeGeometry == NULL )
|| ( dataTimeGeometry->GetTimeSteps() == 0 )
|| ( !dataTimeGeometry->IsValidTime( m_TimeStep ) ) )
{
// TimeSlicedGeometry or time step is not valid for this data:
// reset mapper so that nothing is displayed
this->ResetMapper( renderer );
return;
}
- if(
- (m_LastUpdateTime < GetMTime()) ||
- (m_LastUpdateTime < node->GetDataReferenceChangedTime()) ||
- (m_LastUpdateTime < dataMTime) ||
- (renderer && (m_LastUpdateTime < renderer->GetTimeStepUpdateTime()))
- )
+ this->GenerateDataForRenderer(renderer);
+}
+
+
+bool mitk::Mapper::BaseLocalStorage::IsGenerateDataRequired(
+ mitk::BaseRenderer *renderer,
+ mitk::Mapper *mapper,
+ mitk::DataNode *dataNode)
+{
+ if( mapper && m_LastGenerateDataTime < mapper -> GetMTime () )
+ return true;
+
+ if( dataNode )
{
- m_LastUpdateTime.Modified();
+ if( m_LastGenerateDataTime < dataNode -> GetDataReferenceChangedTime () )
+ return true;
+
+ mitk::BaseData * data = dataNode -> GetData ( ) ;
+
+ if( data && m_LastGenerateDataTime < data -> GetMTime ( ) )
+ return true;
}
- this->GenerateDataForRenderer(renderer);
+ if( renderer && m_LastGenerateDataTime < renderer -> GetTimeStepUpdateTime ( ) )
+ return true;
+
+ return false;
}
void mitk::Mapper::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
node->AddProperty( "layer", mitk::IntProperty::New(0), renderer, overwrite);
node->AddProperty( "name", mitk::StringProperty::New("No Name!"), renderer, overwrite );
}
diff --git a/Core/Code/Rendering/mitkMapper.h b/Core/Code/Rendering/mitkMapper.h
index 6bab8fae42..22d98f25c4 100644
--- a/Core/Code/Rendering/mitkMapper.h
+++ b/Core/Code/Rendering/mitkMapper.h
@@ -1,298 +1,241 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MAPPER_H_HEADER_INCLUDED_C1E6EA08
#define MAPPER_H_HEADER_INCLUDED_C1E6EA08
#include <MitkExports.h>
#include "mitkBaseRenderer.h"
#include "mitkVtkPropRenderer.h"
#include "mitkLevelWindow.h"
#include "mitkCommon.h"
+#include "mitkLocalStorageHandler.h"
#include <itkObject.h>
#include <itkWeakPointer.h>
//Just included to get VTK version
#include <vtkConfigure.h>
class vtkWindow;
class vtkProp;
namespace mitk {
class BaseRenderer;
class BaseData;
class DataNode;
- /** \brief Interface for accessing (templated) LocalStorageHandler instances.
- */
- class BaseLocalStorageHandler
- {
- public:
- virtual ~BaseLocalStorageHandler() {}
- virtual void ClearLocalStorage(mitk::BaseRenderer *renderer,bool unregisterFromBaseRenderer=true )=0;
- };
-
-
/** \brief Base class of all mappers, Vtk as well as OpenGL mappers
*
* By the help of mappers, the input data is transformed to tangible primitives,
* such as surfaces, points, lines, etc.
* This is the base class of all mappers, Vtk as well as OpenGL mappers.
* Subclasses of mitk::Mapper control the creation of rendering primitives
* that interface to the graphics library (e.g., OpenGL, vtk).
*
* \todo Should Mapper be a subclass of ImageSource?
* \ingroup Mapper
*/
class MITK_CORE_EXPORT Mapper : public itk::Object
{
public:
mitkClassMacro(Mapper, itk::Object);
/** \brief Set the DataNode containing the data to map */
itkSetObjectMacro(DataNode, DataNode);
/** \brief Get the DataNode containing the data to map */
virtual DataNode* GetDataNode() const;
/**\brief Get the data to map
*
* Returns the mitk::BaseData object associated with this mapper.
* \return the mitk::BaseData associated with this mapper.
* \deprecatedSince{2013_03} Use GetDataNode()->GetData() instead to access the data
*/
DEPRECATED(BaseData* GetData() const);
/** \brief Convenience access method for color properties (instances of
* ColorProperty)
* \return \a true property was found
* \deprecatedSince{2013_03} Use GetDataNode()->GetColor(...) instead to get the color
*/
DEPRECATED(virtual bool GetColor(float rgb[3], BaseRenderer* renderer, const char* name = "color") const);
/** \brief Convenience access method for visibility properties (instances
* of BoolProperty)
* \return \a true property was found
* \sa IsVisible
* \deprecatedSince{2013_03} Use GetDataNode()->GetVisibility(...) instead to get the visibility
*/
DEPRECATED(virtual bool GetVisibility(bool &visible, BaseRenderer* renderer, const char* name = "visible") const);
/** \brief Convenience access method for opacity properties (instances of
* FloatProperty)
* \return \a true property was found
* \deprecatedSince{2013_03} Use GetDataNode()->GetOpacity(...) instead to get the opacity
*/
DEPRECATED(virtual bool GetOpacity(float &opacity, BaseRenderer* renderer, const char* name = "opacity") const);
/** \brief Convenience access method for color properties (instances of
* LevelWindoProperty)
* \return \a true property was found
* \deprecatedSince{2013_03} Use GetDataNode->GetLevelWindow(...) instead to get the levelwindow
*/
DEPRECATED(virtual bool GetLevelWindow(LevelWindow &levelWindow, BaseRenderer* renderer, const char* name = "levelwindow") const);
/** \brief Convenience access method for visibility properties (instances
* of BoolProperty). Return value is the visibility. Default is
* visible==true, i.e., true is returned even if the property (\a
* propertyKey) is not found.
*
* Thus, the return value has a different meaning than in the
* GetVisibility method!
* \sa GetVisibility
* \deprecatedSince{2013_03} Use GetDataNode()->GetVisibility(...) instead
*/
DEPRECATED(virtual bool IsVisible(BaseRenderer* renderer, const char* name = "visible") const);
/** \brief Returns whether this is an vtk-based mapper
* \deprecatedSince{2013_03} All mappers of superclass VTKMapper are vtk based, use a dynamic_cast instead
*/
virtual bool IsVtkBased() const = 0;
/** \brief Calls the time step of the input data for the specified renderer and checks
* whether the time step is valid and calls method GenerateDataForRenderer()
*/
virtual void Update(BaseRenderer* renderer);
/** \brief Responsible for calling the appropriate render functions.
* To be implemented in sub-classes.
*/
virtual void MitkRender(mitk::BaseRenderer* renderer, mitk::VtkPropRenderer::RenderType type) = 0;
/**
* \brief Apply specific color and opacity properties read from the PropertyList.
* Reimplemented in GLmapper (does not use the actor) and the VtkMapper class.
* The function is called by the individual mapper (mostly in the ApplyProperties() or ApplyAllProperties()
* method).
*/
virtual void ApplyColorAndOpacityProperties(mitk::BaseRenderer* renderer, vtkActor* actor = NULL) = 0;
/** \brief Set default values of properties used by this mapper
* to \a node
*
* \param node The node for which the properties are set
* \param overwrite overwrite existing properties (default: \a false)
* \param renderer defines which property list of node is used
* (default: \a NULL, i.e. default property list)
*/
static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false);
/** \brief Returns the current time step as calculated from the renderer */
int GetTimestep() const { return m_TimeStep; }
/** Returns true if this Mapper currently allows for Level-of-Detail rendering.
* This reflects whether this Mapper currently invokes StartEvent, EndEvent, and
* ProgressEvent on BaseRenderer. */
virtual bool IsLODEnabled( BaseRenderer * /*renderer*/ ) const { return false; }
protected:
/** \brief explicit constructor which disallows implicit conversions */
explicit Mapper();
/** \brief virtual destructor in order to derive from this class */
virtual ~Mapper();
/** \brief Generate the data needed for rendering (independent of a specific renderer)
* \deprecatedSince{2013_03} Use GenerateDataForRenderer(BaseRenderer* renderer) instead.
*/
DEPRECATED( virtual void GenerateData() ) { }
/** \brief Generate the data needed for rendering into \a renderer */
virtual void GenerateDataForRenderer(BaseRenderer* /* renderer */) { }
/** \brief Updates the time step, which is sometimes needed in subclasses */
virtual void CalculateTimeStep( BaseRenderer* renderer );
/** \brief Reset the mapper (i.e., make sure that nothing is displayed) if no
* valid data is present. In most cases the reimplemented function
* disables the according actors (toggling visibility off)
*
* To be implemented in sub-classes.
*/
virtual void ResetMapper( BaseRenderer* /*renderer*/ ) { }
//\brief not thread-safe
itk::WeakPointer<DataNode> m_DataNode;
- /** \brief timestamp of last update of stored data */
- itk::TimeStamp m_LastUpdateTime;
private:
/** \brief The current time step of the dataset to be rendered,
* for use in subclasses.
* The current timestep can be accessed via the GetTimestep() method.
*/
int m_TimeStep;
/** \brief copy constructor */
Mapper( const Mapper &);
/** \brief assignment operator */
Mapper &operator=(const Mapper &);
public:
/** \brief Base class for mapper specific rendering ressources.
*/
- class BaseLocalStorage
+ class MITK_CORE_EXPORT BaseLocalStorage
{
- };
+ public:
- /** \brief Templated class for management of LocalStorage implementations in Mappers.
- *
- * The LocalStorageHandler is responsible for providing a LocalStorage to a
- * concrete mitk::Mapper subclass. Each RenderWindow / mitk::BaseRenderer is
- * assigned its own LocalStorage instance so that all contained ressources
- * (actors, shaders, textures, ...) are provided individually per window.
- *
- */
- template<class L> class LocalStorageHandler : public mitk::BaseLocalStorageHandler
- {
- protected:
+ bool IsGenerateDataRequired(mitk::BaseRenderer *renderer,mitk::Mapper *mapper,mitk::DataNode *dataNode);
- std::map<mitk::BaseRenderer *,L*> m_BaseRenderer2LS;
+ inline void UpdateGenerateDataTime()
+ {
+ m_LastGenerateDataTime.Modified();
+ }
- public:
+ inline itk::TimeStamp & GetLastGenerateDataTime() { return m_LastGenerateDataTime; }
+
+ protected:
- /** \brief deallocates a local storage for a specifc BaseRenderer (if the
- * BaseRenderer is itself deallocating it in its destructor, it has to set
- * unregisterFromBaseRenderer=false)
- */
- virtual void ClearLocalStorage(mitk::BaseRenderer *renderer,bool unregisterFromBaseRenderer=true )
- {
- //MITK_INFO << "deleting a localstorage on a mapper request";
- if(unregisterFromBaseRenderer)
- renderer->UnregisterLocalStorageHandler( this );
- L *l = m_BaseRenderer2LS[renderer];
- m_BaseRenderer2LS.erase( renderer );
- delete l;
- }
-
- /** \brief Retrieves a LocalStorage for a specific BaseRenderer.
- *
- * Should be used by mappers in GenerateDataForRenderer()
- */
- L *GetLocalStorage(mitk::BaseRenderer *forRenderer)
- {
- L *l = m_BaseRenderer2LS[ forRenderer ];
- if(!l)
- {
- //MITK_INFO << "creating new localstorage";
- l = new L;
- m_BaseRenderer2LS[ forRenderer ] = l;
- forRenderer->RegisterLocalStorageHandler( this );
- }
- return l;
- }
-
- ~LocalStorageHandler()
- {
- typename std::map<mitk::BaseRenderer *,L*>::iterator it;
-
- for ( it=m_BaseRenderer2LS.begin() ; it != m_BaseRenderer2LS.end(); it++ )
- {
- (*it).first->UnregisterLocalStorageHandler(this);
- delete (*it).second;
- }
-
- m_BaseRenderer2LS.clear();
- }
+ /** \brief timestamp of last update of stored data */
+ itk::TimeStamp m_LastGenerateDataTime;
};
};
} // namespace mitk
#endif /* MAPPER_H_HEADER_INCLUDED_C1E6EA08 */
diff --git a/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp b/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
index 3fe64931e5..e3664c35e8 100644
--- a/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
@@ -1,523 +1,524 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetGLMapper2D.h"
#include "mitkPointSet.h"
#include "mitkPlaneGeometry.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "vtkLinearTransform.h"
#include "mitkStringProperty.h"
#include "mitkPointSet.h"
#include "mitkVtkPropRenderer.h"
#include "mitkGL.h"
//const float selectedColor[]={1.0,0.0,0.6}; //for selected!
mitk::PointSetGLMapper2D::PointSetGLMapper2D()
: m_Polygon(false),
m_ShowPoints(true),
m_ShowDistances(false),
m_DistancesDecimalDigits(1),
m_ShowAngles(false),
m_ShowDistantLines(true),
m_LineWidth(1)
{
}
mitk::PointSetGLMapper2D::~PointSetGLMapper2D()
{
}
const mitk::PointSet *mitk::PointSetGLMapper2D::GetInput(void)
{
return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
}
+
void mitk::PointSetGLMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
{
GLMapper::ApplyColorAndOpacityProperties( renderer );
const mitk::DataNode* node=GetDataNode();
if( node == NULL )
return;
node->GetBoolProperty("show contour", m_Polygon);
node->GetBoolProperty("close contour", m_PolygonClosed);
node->GetBoolProperty("show points", m_ShowPoints);
node->GetBoolProperty("show distances", m_ShowDistances);
node->GetIntProperty("distance decimal digits", m_DistancesDecimalDigits);
node->GetBoolProperty("show angles", m_ShowAngles);
node->GetBoolProperty("show distant lines", m_ShowDistantLines);
node->GetIntProperty("line width", m_LineWidth);
node->GetIntProperty("point line width", m_PointLineWidth);
node->GetIntProperty("point 2D size", m_Point2DSize);
}
static bool makePerpendicularVector2D(const mitk::Vector2D& in, mitk::Vector2D& out)
{
if((fabs(in[0])>0) && ( (fabs(in[0])>fabs(in[1])) || (in[1] == 0) ) )
{
out[0]=-in[1]/in[0];
out[1]=1;
out.Normalize();
return true;
}
else
if(fabs(in[1])>0)
{
out[0]=1;
out[1]=-in[0]/in[1];
out.Normalize();
return true;
}
else
return false;
}
void mitk::PointSetGLMapper2D::Paint( mitk::BaseRenderer *renderer )
{
const mitk::DataNode* node=GetDataNode();
if( node == NULL )
return;
const int text2dDistance = 10;
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible) return;
// @FIXME: Logik fuer update
bool updateNeccesary=true;
if (updateNeccesary)
{
// ok, das ist aus GenerateData kopiert
mitk::PointSet::Pointer input = const_cast<mitk::PointSet*>(this->GetInput());
// Get the TimeSlicedGeometry of the input object
const TimeSlicedGeometry* inputTimeGeometry = input->GetTimeSlicedGeometry();
if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) )
{
return;
}
//
// get the world time
//
const Geometry2D* worldGeometry = renderer->GetCurrentWorldGeometry2D();
assert( worldGeometry != NULL );
ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
//
// convert the world time in time steps of the input object
//
int timeStep=0;
if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
timeStep = inputTimeGeometry->MSToTimeStep( time );
if ( inputTimeGeometry->IsValidTime( timeStep ) == false )
{
return;
}
mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timeStep );
if ( itkPointSet.GetPointer() == NULL)
{
return;
}
mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
assert(displayGeometry.IsNotNull());
//apply color and opacity read from the PropertyList
this->ApplyAllProperties(renderer);
vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
//List of the Points
PointSet::DataType::PointsContainerConstIterator it, end;
it = itkPointSet->GetPoints()->Begin();
end = itkPointSet->GetPoints()->End();
//iterator on the additional data of each point
PointSet::DataType::PointDataContainerIterator selIt, selEnd;
bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
selIt = itkPointSet->GetPointData()->Begin();
selEnd = itkPointSet->GetPointData()->End();
int counter = 0;
//for writing text
int j = 0;
//for switching back to old color after using selected color
float recallColor[4];
glGetFloatv(GL_CURRENT_COLOR,recallColor);
//get the properties for coloring the points
float unselectedColor[4] = {1.0, 1.0, 0.0, 1.0};//yellow
//check if there is an unselected property
if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("unselectedcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor"))->GetValue();
unselectedColor[0] = tmpColor[0];
unselectedColor[1] = tmpColor[1];
unselectedColor[2] = tmpColor[2];
unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
}
else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("unselectedcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor"))->GetValue();
unselectedColor[0] = tmpColor[0];
unselectedColor[1] = tmpColor[1];
unselectedColor[2] = tmpColor[2];
unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
}
else
{
//get the color from the dataNode
node->GetColor(unselectedColor, NULL);
}
//get selected property
float selectedColor[4] = {1.0, 0.0, 0.6, 1.0};
if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
selectedColor[0] = tmpColor[0];
selectedColor[1] = tmpColor[1];
selectedColor[2] = tmpColor[2];
selectedColor[3] = 1.0f;
}
else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
selectedColor[0] = tmpColor[0];
selectedColor[1] = tmpColor[1];
selectedColor[2] = tmpColor[2];
selectedColor[3] = 1.0f;
}
//check if there is an pointLineWidth property
if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(renderer)->GetProperty("point line width")) != NULL)
{
m_PointLineWidth = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("point line width"))->GetValue();
}
else if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(NULL)->GetProperty("point line width")) != NULL)
{
m_PointLineWidth = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("point line width"))->GetValue();
}
//check if there is an point 2D size property
if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(renderer)->GetProperty("point 2D size")) != NULL)
{
m_Point2DSize = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("point 2D size"))->GetValue();
}
else if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(NULL)->GetProperty("point 2D size")) != NULL)
{
m_Point2DSize = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("point 2D size"))->GetValue();
}
Point3D p; // currently visited point
Point3D lastP; // last visited point
Vector3D vec; // p - lastP
Vector3D lastVec; // lastP - point before lastP
vec.Fill(0);
mitk::Point3D projected_p; // p projected on viewplane
Point2D pt2d; // projected_p in display coordinates
Point2D lastPt2d; // last projected_p in display coordinates
Point2D preLastPt2d;// projected_p in display coordinates before lastPt2d
Point2D lastPt2DInPointSet; // The last point in the pointset in display coordinates
mitk::PointSet::DataType::PointType plob;
plob.Fill(0);
itkPointSet->GetPoint( itkPointSet->GetNumberOfPoints()-1, &plob);
//map lastPt2DInPointSet to display coordinates
float vtkp[3];
itk2vtk(plob, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, lastPt2DInPointSet);
displayGeometry->WorldToDisplay(lastPt2DInPointSet, lastPt2DInPointSet);
while(it!=end) // iterate over all points
{
lastP = p; // valid only for counter > 0
lastVec = vec; // valid only for counter > 1
preLastPt2d = lastPt2d; // valid only for counter > 1
lastPt2d = pt2d; // valid only for counter > 0
itk2vtk(it->Value(), vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
vec = p-lastP; // valid only for counter > 0
displayGeometry->Project(p, projected_p);
Vector3D diff=p-projected_p;
ScalarType scalardiff = diff.GetSquaredNorm();
//MouseOrientation
bool isInputDevice=false;
bool isRendererSlice = scalardiff < 0.00001; //cause roundoff error
if(this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice && !isRendererSlice )
{
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
//Point size depending of distance to slice
/*float p_size = (1/scalardiff)*10*m_Point2DSize;
if(p_size < m_Point2DSize * 0.6 )
p_size = m_Point2DSize * 0.6 ;
else if ( p_size > m_Point2DSize )
p_size = m_Point2DSize;*/
float p_size = (1/scalardiff)*100.0;
if(p_size < 6.0 )
p_size = 6.0 ;
else if ( p_size > 10.0 )
p_size = 10.0;
//draw Point
float opacity = (p_size<8)?0.3:1.0;//don't get the opacity from the node? Feature not a bug! Otehrwise the 2D cross is hardly seen.
glColor4f(unselectedColor[0],unselectedColor[1],unselectedColor[2],opacity);
glPointSize(p_size);
//glShadeModel(GL_FLAT);
glBegin (GL_POINTS);
glVertex2fv(&pt2d[0]);
glEnd ();
}
//for point set
if(!isInputDevice && ( (scalardiff<4.0) || (m_Polygon)))
{
Point2D tmp;
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
Vector2D horz,vert;
horz[0]=(float)m_Point2DSize-scalardiff*2; horz[1]=0;
vert[0]=0; vert[1]=(float)m_Point2DSize-scalardiff*2;
// now paint text if available
if (dynamic_cast<mitk::StringProperty *>(this->GetDataNode()
->GetProperty("label")) != NULL)
{
const char * pointLabel = dynamic_cast<mitk::StringProperty *>(
this->GetDataNode()->GetProperty("label"))->GetValue();
std::string l = pointLabel;
if (input->GetSize()>1)
{
// char buffer[20];
// sprintf(buffer,"%d",it->Index());
std::stringstream ss;
ss << it->Index();
l.append(ss.str());
}
if (unselectedColor != NULL)
{
mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
float rgb[3];//yellow
rgb[0] = unselectedColor[0]; rgb[1] = unselectedColor[1]; rgb[2] = unselectedColor[2];
OpenGLrenderer->WriteSimpleText(l, pt2d[0] + text2dDistance, pt2d[1] + text2dDistance,rgb[0], rgb[1],rgb[2]);
}
else
{
mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
OpenGLrenderer->WriteSimpleText(l, pt2d[0] + text2dDistance, pt2d[1] + text2dDistance,0.0,1.0,0.0);
}
}
if((m_ShowPoints) && (scalardiff<4.0))
{
//check if the point is to be marked as selected
if(selIt != selEnd || pointDataBroken)
{
bool addAsSelected = false;
if (pointDataBroken)
addAsSelected = false;
else if (selIt->Value().selected)
addAsSelected = true;
else
addAsSelected = false;
if (addAsSelected)
{
horz[0]=(float)m_Point2DSize;
vert[1]=(float)m_Point2DSize;
glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);
glLineWidth(m_PointLineWidth);
//a diamond around the point with the selected color
glBegin (GL_LINE_LOOP);
tmp=pt2d-horz; glVertex2fv(&tmp[0]);
tmp=pt2d+vert; glVertex2fv(&tmp[0]);
tmp=pt2d+horz; glVertex2fv(&tmp[0]);
tmp=pt2d-vert; glVertex2fv(&tmp[0]);
glEnd ();
glLineWidth(1);
//the actual point in the specified color to see the usual color of the point
glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
glPointSize(1);
glBegin (GL_POINTS);
tmp=pt2d; glVertex2fv(&tmp[0]);
glEnd ();
}
else //if not selected
{
glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
glLineWidth(m_PointLineWidth);
//drawing crosses
glBegin (GL_LINES);
tmp=pt2d-horz; glVertex2fv(&tmp[0]);
tmp=pt2d+horz; glVertex2fv(&tmp[0]);
tmp=pt2d-vert; glVertex2fv(&tmp[0]);
tmp=pt2d+vert; glVertex2fv(&tmp[0]);
glEnd ();
glLineWidth(1);
}
}
}
bool drawLinesEtc = true;
if (!m_ShowDistantLines && counter > 0) // check, whether this line should be drawn
{
ScalarType currentDistance = displayGeometry->GetWorldGeometry()->SignedDistance(p);
ScalarType lastDistance = displayGeometry->GetWorldGeometry()->SignedDistance(lastP);
if ( currentDistance * lastDistance > 0.5 ) // points on same side of plane
drawLinesEtc = false;
}
// draw a line
if ((m_Polygon && counter>0 && drawLinesEtc) ||
(m_Polygon && m_PolygonClosed && drawLinesEtc))
{
if ((counter == 0) && ( m_PolygonClosed))
{
lastPt2d = lastPt2DInPointSet;
}
//get contour color property
float contourColor[4] = {unselectedColor[0], unselectedColor[1], unselectedColor[2], unselectedColor[3]};//so if no property set, then use unselected color
if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
contourColor[0] = tmpColor[0];
contourColor[1] = tmpColor[1];
contourColor[2] = tmpColor[2];
contourColor[3] = 1.0f;
}
else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
contourColor[0] = tmpColor[0];
contourColor[1] = tmpColor[1];
contourColor[2] = tmpColor[2];
contourColor[3] = 1.0f;
}
//set this color
glColor3f(contourColor[0],contourColor[1],contourColor[2]);
glLineWidth( m_LineWidth );
glBegin (GL_LINES);
glVertex2fv(&pt2d[0]);
glVertex2fv(&lastPt2d[0]);
glEnd ();
glLineWidth(1.0);
if(m_ShowDistances) // calculate and print a distance
{
std::stringstream buffer;
float distance = vec.GetNorm();
buffer<<std::fixed <<std::setprecision(m_DistancesDecimalDigits)<<distance<<" mm";
Vector2D vec2d = pt2d-lastPt2d;
makePerpendicularVector2D(vec2d, vec2d);
Vector2D pos2d = (lastPt2d.GetVectorFromOrigin()+pt2d)*0.5+vec2d*text2dDistance;
mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
OpenGLrenderer->WriteSimpleText(buffer.str(), pos2d[0], pos2d[1]);
//this->WriteTextXY(pos2d[0], pos2d[1], buffer.str(),renderer);
}
if(m_ShowAngles && counter > 1 ) // calculate and print the angle btw. two lines
{
std::stringstream buffer;
//buffer << angle(vec.Get_vnl_vector(), -lastVec.Get_vnl_vector())*180/vnl_math::pi << "�";
- buffer << angle(vec.Get_vnl_vector(), -lastVec.Get_vnl_vector())*180/vnl_math::pi << (char)176;
+ buffer << angle(vec.GetVnlVector(), -lastVec.GetVnlVector())*180/vnl_math::pi << (char)176;
Vector2D vec2d = pt2d-lastPt2d;
vec2d.Normalize();
Vector2D lastVec2d = lastPt2d-preLastPt2d;
lastVec2d.Normalize();
vec2d=vec2d-lastVec2d;
vec2d.Normalize();
Vector2D pos2d = lastPt2d.GetVectorFromOrigin()+vec2d*text2dDistance*text2dDistance;
mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
OpenGLrenderer->WriteSimpleText(buffer.str(), pos2d[0], pos2d[1]);
//this->WriteTextXY(pos2d[0], pos2d[1], buffer.str(),renderer);
}
}
counter++;
}
++it;
if(selIt != selEnd && !pointDataBroken)
++selIt;
j++;
}
//recall the color to the same color before this drawing
glColor3f(recallColor[0],recallColor[1],recallColor[2]);
}
}
void mitk::PointSetGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite ); // width of the line from one point to another
node->AddProperty( "point line width", mitk::IntProperty::New(1), renderer, overwrite ); //width of the cross marking a point
node->AddProperty( "point 2D size", mitk::IntProperty::New(8), renderer, overwrite ); // length of the cross marking a point // length of an edge of the box marking a point
node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite ); // contour of the line between points
node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite ); //show or hide points
node->AddProperty( "show distances", mitk::BoolProperty::New(false), renderer, overwrite ); //show or hide distance measure (not always available)
node->AddProperty( "distance decimal digits", mitk::IntProperty::New(2), renderer, overwrite ); //set the number of decimal digits to be shown
node->AddProperty( "show angles", mitk::BoolProperty::New(false), renderer, overwrite ); //show or hide angle measurement (not always available)
node->AddProperty( "show distant lines", mitk::BoolProperty::New(false), renderer, overwrite ); //show the line between to points from a distant view (equals "always on top" option)
node->AddProperty( "layer", mitk::IntProperty::New(1), renderer, overwrite ); // default to draw pointset above images (they have a default layer of 0)
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Core/Code/Rendering/mitkPointSetGLMapper2D.h b/Core/Code/Rendering/mitkPointSetGLMapper2D.h
index bf192147af..1079923989 100644
--- a/Core/Code/Rendering/mitkPointSetGLMapper2D.h
+++ b/Core/Code/Rendering/mitkPointSetGLMapper2D.h
@@ -1,94 +1,98 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKPointSetMAPPER2D_H_HEADER_INCLUDED
#define MITKPointSetMAPPER2D_H_HEADER_INCLUDED
#include <MitkExports.h>
#include "mitkGLMapper.h"
namespace mitk {
class BaseRenderer;
class PointSet;
/**
* @brief OpenGL-based mapper to display a mitk::PointSet in a 2D window.
*
* This mapper can actually more than just draw a number of points of a
* mitk::PointSet. If you set the right properties of the mitk::DataNode,
* which contains the point set, then this mapper will also draw lines
* connecting the points, and calculate and display distances and angles
* between adjacent points. Here is a complete list of boolean properties,
* which might be of interest:
*
* - \b "show contour": Draw not only the points but also the connections between
* them (default false)
* - \b "line width": IntProperty which gives the width of the contour lines
* - \b "show points": Wheter or not to draw the actual points (default true)
* - \b "show distances": Wheter or not to calculate and print the distance
* between adjacent points (default false)
* - \b "show angles": Wheter or not to calculate and print the angle between
* adjacent points (default false)
* - \b "show distant lines": When true, the mapper will also draw contour
* lines that are far away form the current slice (default true)
* - \b "label": StringProperty with a label for this point set
*
* BUG 1321 - possible new features:
* point-2d-size (length of lines in cross/diamond)
* point-linewidth
*
* @ingroup Mapper
*/
+
+/** \deprecatedSince{2013_06} This mapper is replaced by PointSetVtkMapper2D. The child classes of this class are deprecated.
+ * To further ensure their functionality PointSetGLMapper2D cannot be removed and is set deprecated too.
+ */
class MITK_CORE_EXPORT PointSetGLMapper2D : public GLMapper
{
public:
mitkClassMacro(PointSetGLMapper2D, GLMapper);
itkNewMacro(Self);
/** @brief Get the PointDataList to map */
virtual const mitk::PointSet * GetInput(void);
virtual void Paint(mitk::BaseRenderer * renderer);
virtual void ApplyAllProperties(mitk::BaseRenderer* renderer);
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
protected:
PointSetGLMapper2D();
virtual ~PointSetGLMapper2D();
bool m_Polygon;
bool m_PolygonClosed;
bool m_ShowPoints;
bool m_ShowDistances;
int m_DistancesDecimalDigits;
bool m_ShowAngles;
bool m_ShowDistantLines;
int m_LineWidth;
int m_PointLineWidth;
int m_Point2DSize;
};
} // namespace mitk
#endif /* MITKPointSetMapper2D_H_HEADER_INCLUDED */
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp b/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp
new file mode 100644
index 0000000000..62e8bc14e1
--- /dev/null
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp
@@ -0,0 +1,751 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+
+#include "mitkPointSetVtkMapper2D.h"
+#include "mitkDataNode.h"
+#include "mitkProperties.h"
+#include "mitkColorProperty.h"
+#include "mitkEnumerationProperty.h"
+#include "mitkVtkPropRenderer.h"
+#include "mitkPointSet.h"
+
+#include <vtkActor.h>
+#include <vtkAppendPolyData.h>
+#include <vtkPropAssembly.h>
+#include <vtkTubeFilter.h>
+#include <vtkRenderer.h>
+#include <vtkSphereSource.h>
+#include <vtkCubeSource.h>
+#include <vtkConeSource.h>
+#include <vtkDiskSource.h>
+#include <vtkCylinderSource.h>
+#include <vtkProperty.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkVectorText.h>
+#include <vtkTransform.h>
+#include <vtkTransformPolyDataFilter.h>
+#include <vtkPolyDataAlgorithm.h>
+#include <vtkTransform.h>
+#include <vtkGlyph3D.h>
+#include <vtkTransformFilter.h>
+#include <vtkLinearTransform.h>
+#include <vtkLine.h>
+#include <vtkSource.h>
+#include <vtkGlyphSource2D.h>
+#include <vtkFloatArray.h>
+#include <vtkPointData.h>
+#include <vtkPolyLine.h>
+#include <vtkTextActor.h>
+#include <vtkTextProperty.h>
+
+#include <stdlib.h>
+
+// constructor LocalStorage
+mitk::PointSetVtkMapper2D::LocalStorage::LocalStorage()
+{
+
+ // points
+ m_UnselectedPoints = vtkSmartPointer<vtkPoints>::New();
+ m_SelectedPoints = vtkSmartPointer<vtkPoints>::New();
+ m_ContourPoints = vtkSmartPointer<vtkPoints>::New();
+
+ // scales
+ m_UnselectedScales = vtkSmartPointer<vtkFloatArray>::New();
+ m_SelectedScales = vtkSmartPointer<vtkFloatArray>::New();
+
+ // distances
+ m_DistancesBetweenPoints = vtkSmartPointer<vtkFloatArray>::New();
+
+ // lines
+ m_ContourLines = vtkSmartPointer<vtkCellArray>::New();
+
+ // glyph source (provides the different shapes)
+ m_UnselectedGlyphSource2D = vtkSmartPointer<vtkGlyphSource2D>::New();
+ m_SelectedGlyphSource2D = vtkSmartPointer<vtkGlyphSource2D>::New();
+
+ // glyphs
+ m_UnselectedGlyph3D = vtkSmartPointer<vtkGlyph3D>::New();
+ m_SelectedGlyph3D = vtkSmartPointer<vtkGlyph3D>::New();
+
+ // polydata
+ m_VtkUnselectedPointListPolyData = vtkSmartPointer<vtkPolyData>::New();
+ m_VtkSelectedPointListPolyData = vtkSmartPointer <vtkPolyData>::New();
+ m_VtkContourPolyData = vtkSmartPointer<vtkPolyData>::New();
+
+ // actors
+ m_UnselectedActor = vtkSmartPointer <vtkActor>::New();
+ m_SelectedActor = vtkSmartPointer <vtkActor>::New();
+ m_ContourActor = vtkSmartPointer <vtkActor>::New();
+
+ // mappers
+ m_VtkUnselectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+ m_VtkSelectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+ m_VtkContourPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+
+ // propassembly
+ m_PropAssembly = vtkSmartPointer <vtkPropAssembly>::New();
+
+}
+// destructor LocalStorage
+mitk::PointSetVtkMapper2D::LocalStorage::~LocalStorage()
+{
+}
+
+// input for this mapper ( = point set)
+const mitk::PointSet* mitk::PointSetVtkMapper2D::GetInput()
+{
+ return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
+}
+
+// constructor PointSetVtkMapper2D
+mitk::PointSetVtkMapper2D::PointSetVtkMapper2D()
+: m_Polygon(false),
+m_PolygonClosed(false),
+m_ShowPoints(true),
+m_ShowDistances(false),
+m_DistancesDecimalDigits(1),
+m_ShowAngles(false),
+m_ShowDistantLines(false),
+m_LineWidth(1),
+m_PointLineWidth(1),
+m_Point2DSize(6),
+m_IdGlyph(mitk::PointSetShapeProperty::CROSS),
+m_FillGlyphs(false)
+{
+}
+
+// destructor
+mitk::PointSetVtkMapper2D::~PointSetVtkMapper2D()
+{
+}
+
+// toggles visiblity of the prop assembly
+void mitk::PointSetVtkMapper2D::ResetMapper( BaseRenderer* renderer )
+{
+ LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+ ls->m_PropAssembly->VisibilityOff();
+}
+
+// returns propassembly
+vtkProp* mitk::PointSetVtkMapper2D::GetVtkProp(mitk::BaseRenderer * renderer)
+{
+ LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+ return ls->m_PropAssembly;
+}
+
+static bool makePerpendicularVector2D(const mitk::Vector2D& in, mitk::Vector2D& out)
+{
+ if((fabs(in[0])>0) && ( (fabs(in[0])>fabs(in[1])) || (in[1] == 0) ) )
+ {
+ out[0]=-in[1]/in[0];
+ out[1]=1;
+ out.Normalize();
+ return true;
+ }
+ else
+ if(fabs(in[1])>0)
+ {
+ out[0]=1;
+ out[1]=-in[0]/in[1];
+ out.Normalize();
+ return true;
+ }
+ else
+ return false;
+}
+
+
+void mitk::PointSetVtkMapper2D::CreateVTKRenderObjects(mitk::BaseRenderer* renderer)
+{
+
+ LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+
+ if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_UnselectedActor))
+ ls->m_PropAssembly->RemovePart(ls->m_UnselectedActor);
+ if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_SelectedActor))
+ ls->m_PropAssembly->RemovePart(ls->m_SelectedActor);
+ if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_ContourActor))
+ ls->m_PropAssembly->RemovePart(ls->m_ContourActor);
+ if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextActor))
+ ls->m_PropAssembly->RemovePart(ls->m_VtkTextActor);
+
+ unsigned i = 0;
+ for(i=0; i< ls->m_VtkTextLabelActors.size(); i++)
+ {
+ if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextLabelActors.at(i)))
+ ls->m_PropAssembly->RemovePart(ls->m_VtkTextLabelActors.at(i));
+ }
+
+ for(i=0; i< ls->m_VtkTextDistanceActors.size(); i++)
+ {
+ if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextDistanceActors.at(i)))
+ ls->m_PropAssembly->RemovePart(ls->m_VtkTextDistanceActors.at(i));
+ }
+
+ for(i=0; i< ls->m_VtkTextAngleActors.size(); i++)
+ {
+ if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextAngleActors.at(i)))
+ ls->m_PropAssembly->RemovePart(ls->m_VtkTextAngleActors.at(i));
+ }
+
+ // polydata
+ ls->m_VtkUnselectedPointListPolyData = vtkSmartPointer<vtkPolyData>::New();
+ ls->m_VtkSelectedPointListPolyData = vtkSmartPointer <vtkPolyData>::New();
+ ls->m_VtkContourPolyData = vtkSmartPointer<vtkPolyData>::New();
+
+
+ // exceptional displaying for PositionTracker -> MouseOrientationTool
+ int mapperID;
+ bool isInputDevice=false;
+ if( this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice )
+ {
+ if( this->GetDataNode()->GetIntProperty("BaseRendererMapperID",mapperID) && mapperID == 2)
+ return; //The event for the PositionTracker came from the 3d widget and not needs to be displayed
+ }
+
+ // get input point set and update the PointSet
+ mitk::PointSet::Pointer input = const_cast<mitk::PointSet*>(this->GetInput());
+
+ /* only update the input data, if the property tells us to */
+ bool update = true;
+ this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);
+ if (update == true)
+ input->Update();
+
+ //TODO: insert last changes on timestamps
+ int timestep = this->GetTimestep();
+
+ mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
+
+ if ( itkPointSet.GetPointer() == NULL)
+ {
+ ls->m_PropAssembly->VisibilityOff();
+ return;
+ }
+
+ //iterator for point set
+ mitk::PointSet::PointsContainer::Iterator pointsIter = itkPointSet->GetPoints()->Begin();
+
+ // PointDataContainer has additional information to each point, e.g. whether
+ // it is selected or not
+ mitk::PointSet::PointDataContainer::Iterator pointDataIter;
+ pointDataIter = itkPointSet->GetPointData()->Begin();
+
+ //check if the list for the PointDataContainer is the same size as the PointsContainer.
+ //If not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)
+ bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
+
+ if(itkPointSet->GetPointData()->size() == 0 || pointDataBroken)
+ {
+ return;
+ }
+
+ // empty point sets, cellarrays, scalars
+ ls->m_UnselectedPoints->Reset();
+ ls->m_SelectedPoints->Reset();
+
+ ls->m_ContourPoints->Reset();
+ ls->m_ContourLines->Reset();
+
+ ls->m_UnselectedScales->Reset();
+ ls->m_SelectedScales->Reset();
+
+ ls->m_DistancesBetweenPoints->Reset();
+
+ ls->m_VtkTextLabelActors.clear();
+ ls->m_VtkTextDistanceActors.clear();
+ ls->m_VtkTextAngleActors.clear();
+
+ ls->m_UnselectedScales->SetNumberOfComponents(3);
+ ls->m_SelectedScales->SetNumberOfComponents(3);
+
+ int NumberContourPoints = 0;
+ bool pointsOnSameSideOfPlane = false;
+
+ const int text2dDistance = 10;
+
+ // initialize points with a random start value
+
+ // current point in point set
+ itk::Point<float> point = pointsIter->Value();
+
+ mitk::Point3D p = point; // currently visited point
+ mitk::Point3D lastP = point; // last visited point
+ mitk::Vector3D vec; // p - lastP
+ mitk::Vector3D lastVec; // lastP - point before lastP
+ vec.Fill(0);
+ lastVec.Fill(0);
+
+ mitk::Point3D projected_p = point; // p projected on viewplane
+
+ mitk::Point2D pt2d;
+ pt2d[0] = point[0]; // projected_p in display coordinates
+ pt2d[1] = point[1];
+ mitk::Point2D lastPt2d = pt2d; // last projected_p in display coordinates
+ mitk::Point2D preLastPt2d = pt2d ; // projected_p in display coordinates before lastPt2
+
+ // get display geometry
+ mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
+
+ // get plane geometry
+ mitk::PlaneGeometry::ConstPointer planeGeometry = renderer->GetSliceNavigationController()->GetCurrentPlaneGeometry();
+
+ int count = 0;
+
+ for (pointsIter=itkPointSet->GetPoints()->Begin();
+ pointsIter!=itkPointSet->GetPoints()->End();
+ pointsIter++)
+ {
+
+ lastP = p; // valid for number of points count > 0
+ preLastPt2d = lastPt2d; // valid only for count > 1
+ lastPt2d = pt2d; // valid for number of points count > 0
+
+ lastVec = vec; // valid only for counter > 1
+
+ // get current point in point set
+ point = pointsIter->Value();
+
+ p[0] = point[0];
+ p[1] = point[1];
+ p[2] = point[2];
+
+ displayGeometry->Project(p, projected_p);
+ displayGeometry->Map(projected_p, pt2d);
+ displayGeometry->WorldToDisplay(pt2d, pt2d);
+
+ vec = p-lastP; // valid only for counter > 0
+
+ // compute distance to current plane
+ float diff = planeGeometry->DistanceFromPlane(point);
+ diff = diff * diff;
+
+ //MouseOrientation
+ bool isInputDevice=false;
+ this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice);
+
+ // if point is close to current plane ( distance < 4) it will be displayed
+ if(!isInputDevice && (diff < 4.0))
+ {
+
+ // is point selected or not?
+ if (pointDataIter->Value().selected)
+ {
+ ls->m_SelectedPoints->InsertNextPoint(point[0],point[1],point[2]);
+ // point is scaled according to its distance to the plane
+ ls->m_SelectedScales->InsertNextTuple3(m_Point2DSize - (2*diff),0,0);
+ }
+ else
+ {
+ ls->m_UnselectedPoints->InsertNextPoint(point[0],point[1],point[2]);
+ // point is scaled according to its distance to the plane
+ ls->m_UnselectedScales->InsertNextTuple3(m_Point2DSize - (2*diff),0,0);
+ }
+
+
+ //---- LABEL -----//
+
+ // paint label for each point if available
+ if (dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetProperty("label")) != NULL)
+ {
+ const char * pointLabel = dynamic_cast<mitk::StringProperty *>(
+ this->GetDataNode()->GetProperty("label"))->GetValue();
+ std::string l = pointLabel;
+ if (input->GetSize()>1)
+ {
+ std::stringstream ss;
+ ss << pointsIter->Index();
+ l.append(ss.str());
+ }
+
+ ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
+
+ ls->m_VtkTextActor->SetPosition(pt2d[0] + text2dDistance, pt2d[1] + text2dDistance);
+ ls->m_VtkTextActor->SetInput(l.c_str());
+ ls->m_VtkTextActor->GetTextProperty()->SetOpacity( 100 );
+
+ float unselectedColor[4];
+
+ //check if there is a color property
+ GetDataNode()->GetColor(unselectedColor);
+
+ if (unselectedColor != NULL)
+ ls->m_VtkTextActor->GetTextProperty()->SetColor(unselectedColor[0], unselectedColor[1], unselectedColor[2]);
+ else
+ ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0f, 1.0f, 0.0f);
+
+ ls->m_VtkTextLabelActors.push_back(ls->m_VtkTextActor);
+
+ }
+ }
+
+ // draw contour, distance text and angle text in render window
+
+ // lines between points, which intersect the current plane, are drawn
+ if( m_Polygon && count > 0 )
+ {
+ ScalarType distance = displayGeometry->GetWorldGeometry()->SignedDistance(point);
+ ScalarType lastDistance = displayGeometry->GetWorldGeometry()->SignedDistance(lastP);
+
+ pointsOnSameSideOfPlane = (distance * lastDistance) > 0.5;
+
+ // Points must be on different side of plane in order to draw a contour.
+ // If "show distant lines" is enabled this condition is disregarded.
+ if ( !pointsOnSameSideOfPlane || m_ShowDistantLines)
+ {
+ vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
+
+ ls->m_ContourPoints->InsertNextPoint(lastP[0],lastP[1],lastP[2]);
+ line->GetPointIds()->SetId(0, NumberContourPoints);
+ NumberContourPoints++;
+
+ ls->m_ContourPoints->InsertNextPoint(point[0], point[1], point[2]);
+ line->GetPointIds()->SetId(1, NumberContourPoints);
+ NumberContourPoints++;
+
+ ls->m_ContourLines->InsertNextCell(line);
+
+
+ if(m_ShowDistances) // calculate and print distance between adjacent points
+ {
+ float distancePoints = point.EuclideanDistanceTo(lastP);
+
+ std::stringstream buffer;
+ buffer<<std::fixed <<std::setprecision(m_DistancesDecimalDigits)<<distancePoints<<" mm";
+
+ // compute desired display position of text
+ Vector2D vec2d = pt2d-lastPt2d;
+ makePerpendicularVector2D(vec2d, vec2d); // text is rendered within text2dDistance perpendicular to current line
+ Vector2D pos2d = (lastPt2d.GetVectorFromOrigin() + pt2d ) * 0.5 + vec2d * text2dDistance;
+
+ ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
+
+ ls->m_VtkTextActor->SetPosition(pos2d[0],pos2d[1]);
+ ls->m_VtkTextActor->SetInput(buffer.str().c_str());
+ ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0, 1.0, 0.0);
+
+ ls->m_VtkTextDistanceActors.push_back(ls->m_VtkTextActor);
+
+ }
+
+ if(m_ShowAngles && count > 1) // calculate and print angle between connected lines
+ {
+ std::stringstream buffer;
+ //(char) 176 is the degree sign
+ buffer << angle(vec.GetVnlVector(), -lastVec.GetVnlVector())*180/vnl_math::pi << (char)176;
+
+ //compute desired display position of text
+ Vector2D vec2d = pt2d-lastPt2d; // first arm enclosing the angle
+ vec2d.Normalize();
+ Vector2D lastVec2d = lastPt2d-preLastPt2d; // second arm enclosing the angle
+ lastVec2d.Normalize();
+ vec2d=vec2d-lastVec2d; // vector connecting both arms
+ vec2d.Normalize();
+
+ // middle between two vectors that enclose the angle
+ Vector2D pos2d = lastPt2d.GetVectorFromOrigin() + vec2d * text2dDistance * text2dDistance;
+
+ ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
+
+ ls->m_VtkTextActor->SetPosition(pos2d[0],pos2d[1]);
+ ls->m_VtkTextActor->SetInput(buffer.str().c_str());
+ ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0, 1.0, 0.0);
+
+ ls->m_VtkTextAngleActors.push_back(ls->m_VtkTextActor);
+ }
+ }
+ }
+
+ if(pointDataIter != itkPointSet->GetPointData()->End())
+ {
+ pointDataIter++;
+ count++;
+ }
+ }
+
+ // add each single text actor to the assembly
+ for(i=0; i< ls->m_VtkTextLabelActors.size(); i++)
+ {
+ ls->m_PropAssembly->AddPart(ls->m_VtkTextLabelActors.at(i));
+ }
+
+ for(i=0; i< ls->m_VtkTextDistanceActors.size(); i++)
+ {
+ ls->m_PropAssembly->AddPart(ls->m_VtkTextDistanceActors.at(i));
+ }
+
+ for(i=0; i< ls->m_VtkTextAngleActors.size(); i++)
+ {
+ ls->m_PropAssembly->AddPart(ls->m_VtkTextAngleActors.at(i));
+ }
+
+ //---- CONTOUR -----//
+
+
+ //create lines between the points which intersect the plane
+ if (m_Polygon)
+ {
+ // draw line between first and last point which is rendered
+ if(m_PolygonClosed && NumberContourPoints > 1){
+
+ vtkSmartPointer<vtkLine> closingLine = vtkSmartPointer<vtkLine>::New();
+ closingLine->GetPointIds()->SetId(0, 0); // index of first point
+ closingLine->GetPointIds()->SetId(1, NumberContourPoints-1); // index of last point
+ ls->m_ContourLines->InsertNextCell(closingLine);
+ }
+
+ ls->m_VtkContourPolyData->SetPoints(ls->m_ContourPoints);
+ ls->m_VtkContourPolyData->SetLines(ls->m_ContourLines);
+
+ ls->m_VtkContourPolyDataMapper->SetInput(ls->m_VtkContourPolyData);
+ ls->m_ContourActor->SetMapper(ls->m_VtkContourPolyDataMapper);
+ ls->m_ContourActor->GetProperty()->SetLineWidth(m_LineWidth);
+
+ ls->m_PropAssembly->AddPart(ls->m_ContourActor);
+
+ }
+
+ // the point set must be transformed in order to obtain the appropriate glyph orientation
+ // according to the current view
+ vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
+ vtkSmartPointer<vtkMatrix4x4> a,b = vtkSmartPointer<vtkMatrix4x4>::New();
+
+ a = planeGeometry->GetVtkTransform()->GetMatrix();
+ b->DeepCopy( a );
+
+ // delete transformation from matrix, only take orientation
+ b->SetElement(3,3,1);
+ b->SetElement(2,3,0);
+ b->SetElement(1,3,0);
+ b->SetElement(0,3,0);
+ b->SetElement(3,2,0);
+ b->SetElement(3,1,0);
+ b->SetElement(3,0,0);
+
+ transform->SetMatrix( b );
+
+ //---- UNSELECTED POINTS -----//
+
+ // apply properties to glyph
+ ls->m_UnselectedGlyphSource2D->SetGlyphType(m_IdGlyph);
+
+ if(m_FillGlyphs)
+ ls->m_UnselectedGlyphSource2D->FilledOn();
+ else
+ ls->m_UnselectedGlyphSource2D->FilledOff();
+
+ // apply transform
+ vtkSmartPointer<vtkTransformFilter> transformFilterU = vtkSmartPointer<vtkTransformFilter>::New();
+ transformFilterU->SetInputConnection(ls->m_UnselectedGlyphSource2D->GetOutputPort());
+ transformFilterU->SetTransform(transform);
+
+ ls->m_VtkUnselectedPointListPolyData->SetPoints(ls->m_UnselectedPoints);
+ ls->m_VtkUnselectedPointListPolyData->GetPointData()->SetVectors(ls->m_UnselectedScales);
+
+ // apply transform of current plane to glyphs
+ ls->m_UnselectedGlyph3D->SetSourceConnection(transformFilterU->GetOutputPort());
+ ls->m_UnselectedGlyph3D->SetInput(ls->m_VtkUnselectedPointListPolyData);
+ ls->m_UnselectedGlyph3D->SetScaleModeToScaleByVector();
+ ls->m_UnselectedGlyph3D->SetVectorModeToUseVector();
+
+ ls->m_VtkUnselectedPolyDataMapper->SetInput(ls->m_UnselectedGlyph3D->GetOutput());
+ ls->m_UnselectedActor->SetMapper(ls->m_VtkUnselectedPolyDataMapper);
+ ls->m_UnselectedActor->GetProperty()->SetLineWidth(m_PointLineWidth);
+
+ ls->m_PropAssembly->AddPart(ls->m_UnselectedActor);
+
+
+ //---- SELECTED POINTS -----//
+
+ ls->m_SelectedGlyphSource2D->SetGlyphTypeToDiamond();
+ ls->m_SelectedGlyphSource2D->CrossOn();
+ ls->m_SelectedGlyphSource2D->FilledOff();
+
+ // apply transform
+ vtkSmartPointer<vtkTransformFilter> transformFilterS = vtkSmartPointer<vtkTransformFilter>::New();
+ transformFilterS->SetInputConnection(ls->m_SelectedGlyphSource2D->GetOutputPort());
+ transformFilterS->SetTransform(transform);
+
+ ls->m_VtkSelectedPointListPolyData->SetPoints(ls->m_SelectedPoints);
+ ls->m_VtkSelectedPointListPolyData->GetPointData()->SetVectors(ls->m_SelectedScales);
+
+
+ // apply transform of current plane to glyphs
+ ls->m_SelectedGlyph3D->SetSourceConnection(transformFilterS->GetOutputPort());
+ ls->m_SelectedGlyph3D->SetInput(ls->m_VtkSelectedPointListPolyData);
+ ls->m_SelectedGlyph3D->SetScaleModeToScaleByVector();
+ ls->m_SelectedGlyph3D->SetVectorModeToUseVector();
+
+ ls->m_VtkSelectedPolyDataMapper->SetInput(ls->m_SelectedGlyph3D->GetOutput());
+ ls->m_SelectedActor->SetMapper(ls->m_VtkSelectedPolyDataMapper);
+ ls->m_SelectedActor->GetProperty()->SetLineWidth(m_PointLineWidth);
+
+ ls->m_PropAssembly->AddPart(ls->m_SelectedActor);
+
+}
+
+
+void mitk::PointSetVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
+{
+
+ const mitk::DataNode* node = GetDataNode();
+ if( node == NULL )
+ return;
+
+ LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+ bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
+
+ // toggle visibility
+ bool visible = true;
+ node->GetVisibility(visible, renderer, "visible");
+ if(!visible)
+ {
+ ls->m_UnselectedActor->VisibilityOff();
+ ls->m_SelectedActor->VisibilityOff();
+ ls->m_ContourActor->VisibilityOff();
+ ls->m_PropAssembly->VisibilityOff();
+ return;
+ }else{
+ ls->m_PropAssembly->VisibilityOn();
+ }
+
+ node->GetBoolProperty("show contour", m_Polygon, renderer);
+ node->GetBoolProperty("close contour", m_PolygonClosed, renderer);
+ node->GetBoolProperty("show points", m_ShowPoints, renderer);
+ node->GetBoolProperty("show distances", m_ShowDistances, renderer);
+ node->GetIntProperty("distance decimal digits", m_DistancesDecimalDigits, renderer);
+ node->GetBoolProperty("show angles", m_ShowAngles, renderer);
+ node->GetBoolProperty("show distant lines", m_ShowDistantLines, renderer);
+ node->GetIntProperty("line width", m_LineWidth, renderer);
+ node->GetIntProperty("point line width", m_PointLineWidth, renderer);
+ node->GetIntProperty("point 2D size", m_Point2DSize, renderer);
+ node->GetBoolProperty("Pointset.2D.fill shape", m_FillGlyphs, renderer);
+
+ mitk::PointSetShapeProperty::Pointer shape = dynamic_cast<mitk::PointSetShapeProperty*>(this->GetDataNode()->GetProperty( "Pointset.2D.shape", renderer ));
+ if(shape.IsNotNull())
+ {
+ m_IdGlyph = shape->GetPointSetShape();
+ }
+
+ //check for color props and use it for rendering of selected/unselected points and contour
+ //due to different params in VTK (double/float) we have to convert
+
+ float unselectedColor[4];
+ vtkFloatingPointType selectedColor[4]={1.0f,0.0f,0.0f,1.0f}; //red
+ vtkFloatingPointType contourColor[4]={1.0f,0.0f,0.0f,1.0f}; //red
+
+ float opacity = 1.0;
+
+ GetDataNode()->GetOpacity(opacity, renderer);
+
+ // apply color and opacity
+ if(m_ShowPoints)
+ {
+ ls->m_UnselectedActor->VisibilityOn();
+ ls->m_SelectedActor->VisibilityOn();
+
+ //check if there is a color property
+ GetDataNode()->GetColor(unselectedColor);
+
+ //get selected color property
+ if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
+ {
+ mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
+ selectedColor[0] = tmpColor[0];
+ selectedColor[1] = tmpColor[1];
+ selectedColor[2] = tmpColor[2];
+ selectedColor[3] = 1.0f; // alpha value
+ }
+ else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
+ {
+ mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
+ selectedColor[0] = tmpColor[0];
+ selectedColor[1] = tmpColor[1];
+ selectedColor[2] = tmpColor[2];
+ selectedColor[3] = 1.0f; // alpha value
+ }
+
+ ls->m_SelectedActor->GetProperty()->SetColor(selectedColor);
+ ls->m_SelectedActor->GetProperty()->SetOpacity(opacity);
+
+ ls->m_UnselectedActor->GetProperty()->SetColor(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
+ ls->m_UnselectedActor->GetProperty()->SetOpacity(opacity);
+
+ }
+ else
+ {
+ ls->m_UnselectedActor->VisibilityOff();
+ ls-> m_SelectedActor->VisibilityOff();
+ }
+
+ if (m_Polygon)
+ {
+ ls->m_ContourActor->VisibilityOn();
+
+ //get contour color property
+ if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
+ {
+ mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
+ contourColor[0] = tmpColor[0];
+ contourColor[1] = tmpColor[1];
+ contourColor[2] = tmpColor[2];
+ contourColor[3] = 1.0f;
+ }
+ else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
+ {
+ mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
+ contourColor[0] = tmpColor[0];
+ contourColor[1] = tmpColor[1];
+ contourColor[2] = tmpColor[2];
+ contourColor[3] = 1.0f;
+ }
+
+ ls->m_ContourActor->GetProperty()->SetColor(contourColor);
+ ls->m_ContourActor->GetProperty()->SetOpacity(opacity);
+ }
+ else
+ {
+ ls->m_ContourActor->VisibilityOff();
+ }
+
+ if(needGenerateData)
+ {
+ // create new vtk render objects (e.g. a circle for a point)
+ this->CreateVTKRenderObjects(renderer);
+ }
+}
+
+void mitk::PointSetVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
+{
+ node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite );
+ node->AddProperty( "point line width", mitk::IntProperty::New(1), renderer, overwrite );
+ node->AddProperty( "point 2D size", mitk::IntProperty::New(6), renderer, overwrite );
+ node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite );
+ node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
+ node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite );
+ node->AddProperty( "show distances", mitk::BoolProperty::New(false), renderer, overwrite );
+ node->AddProperty( "distance decimal digits", mitk::IntProperty::New(2), renderer, overwrite );
+ node->AddProperty( "show angles", mitk::BoolProperty::New(false), renderer, overwrite );
+ node->AddProperty( "show distant lines", mitk::BoolProperty::New(false), renderer, overwrite );
+ node->AddProperty( "layer", mitk::IntProperty::New(1), renderer, overwrite );
+ node->AddProperty( "Pointset.2D.fill shape", mitk::BoolProperty::New(false), renderer, overwrite); // fill or do not fill the glyph shape
+
+ mitk::PointSetShapeProperty::Pointer pointsetShapeProperty = mitk::PointSetShapeProperty::New();
+ node->AddProperty( "Pointset.2D.shape", pointsetShapeProperty, renderer, overwrite);
+
+ Superclass::SetDefaultProperties(node, renderer, overwrite);
+}
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper2D.h b/Core/Code/Rendering/mitkPointSetVtkMapper2D.h
new file mode 100644
index 0000000000..b3b68a3505
--- /dev/null
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper2D.h
@@ -0,0 +1,216 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+
+#ifndef MITKPointSetVtkMAPPER2D_H_HEADER_INCLUDED_C1902626
+#define MITKPointSetVtkMAPPER2D_H_HEADER_INCLUDED_C1902626
+
+#include <MitkExports.h>
+#include "mitkVtkMapper.h"
+#include "mitkBaseRenderer.h"
+#include "mitkLocalStorageHandler.h"
+#include "mitkPointSetShapeProperty.h"
+#include <vtkSmartPointer.h>
+#include <vtkAppendPolyData.h>
+#include <vtkGlyph3D.h>
+#include <vtkGlyphSource2D.h>
+#include <vtkFloatArray.h>
+#include <vtkCellArray.h>
+#include <vtkTextActor.h>
+
+class vtkActor;
+class vtkPropAssembly;
+class vtkAppendPolyData;
+class vtkPolyData;
+class vtkTubeFilter;
+class vtkPolyDataMapper;
+class vtkGlyphSource2D;
+class vtkSphereSource;
+class vtkGlyph3D;
+class vtkFloatArray;
+
+
+namespace mitk {
+
+ class PointSet;
+
+ /**
+ * @brief Vtk-based 2D mapper for PointSet
+ *
+ * Due to the need of different colors for selected
+ * and unselected points and the facts, that we also have a contour and
+ * labels for the points, the vtk structure is build up the following way:
+ *
+ * We have three PolyData, one selected, and one unselected and one
+ * for a contour between the points. Each one is connected to an own
+ * PolyDataMapper and an Actor. The different color for the unselected and
+ * selected state and for the contour is read from properties.
+ *
+ * This mapper has several additional functionalities, such as rendering
+ * a contour between points, calculating and displaying distances or angles
+ * between points.
+ *
+ * Then the three Actors are combined inside a vtkPropAssembly and this
+ * object is returned in GetProp() and so hooked up into the rendering
+ * pipeline.
+
+ * Properties that can be set for point sets and influence the PointSetVTKMapper2D are:
+ *
+ * - \b "line width": (IntProperty 2) // line width of the line from one point to another
+ * - \b "point line width": (IntProperty 1) // line width of the cross marking a point
+ * - \b "point 2D size": (IntProperty 6) // size of the glyph marking a point
+ * - \b "show contour": (BoolProperty false) // enable contour rendering between points (lines)
+ * - \b "close contour": (BoolProperty false) // if enabled, the open strip is closed (first point connected with last point)
+ * - \b "show points": (BoolProperty true) // show or hide points
+ * - \b "show distances": (BoolProperty false) // show or hide distance measure
+ * - \b "distance decimal digits": (IntProperty 2) // set the number of decimal digits to be shown when rendering the distance information
+ * - \b "show angles": (BoolProperty false) // show or hide angle measurement
+ * - \b "show distant lines": (BoolProperty false) // show the line between to points from a distant view (equals "always on top" option)
+ * - \b "layer": (IntProperty 1) // default is drawing pointset above images (they have a default layer of 0)
+ * - \b "PointSet.2D.shape" (EnumerationProperty Cross) // provides different shapes marking a point
+ * 0 = "None", 1 = "Vertex", 2 = "Dash", 3 = "Cross", 4 = "ThickCross", 5 = "Triangle", 6 = "Square", 7 = "Circle",
+ * 8 = "Diamond", 9 = "Arrow", 10 = "ThickArrow", 11 = "HookedArrow", 12 = "Cross"
+ * - \b "PointSet.2D.fill shape": (BoolProperty::New(false)) // fill or do not fill the glyph shape
+ *
+ *
+ * Other Properties used here but not defined in this class:
+ *
+ * - \b "selectedcolor": (ColorProperty (1.0f, 0.0f, 0.0f)) // default color of the selected pointset e.g. the current point is red
+ * - \b "contourcolor" : (ColorProperty (1.0f, 0.0f, 0.0f)) // default color for the contour is red
+ * - \b "color": (ColorProperty (1.0f, 1.0f, 0.0f)) // default color of the (unselected) pointset is yellow
+ * - \b "opacity": (FloatProperty 1.0) // opacity of point set, contours
+ * - \b "label": (StringProperty NULL) // a label can be defined for each point, which is rendered in proximity to the point
+ *
+ * @ingroup Mapper
+ */
+ class MITK_CORE_EXPORT PointSetVtkMapper2D : public VtkMapper
+ {
+ public:
+ mitkClassMacro(PointSetVtkMapper2D, VtkMapper);
+
+ itkNewMacro(Self);
+
+ virtual const mitk::PointSet* GetInput();
+
+ /** \brief returns the a prop assembly */
+ virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
+
+ /** \brief set the default properties for this mapper */
+ static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
+
+ /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
+ class LocalStorage : public mitk::Mapper::BaseLocalStorage
+ {
+
+ public:
+
+ /* constructor */
+ LocalStorage();
+
+ /* destructor */
+ ~LocalStorage();
+
+ // points
+ vtkSmartPointer<vtkPoints> m_UnselectedPoints;
+ vtkSmartPointer<vtkPoints> m_SelectedPoints;
+ vtkSmartPointer<vtkPoints> m_ContourPoints;
+
+ // scales
+ vtkSmartPointer<vtkFloatArray> m_UnselectedScales;
+ vtkSmartPointer<vtkFloatArray> m_SelectedScales;
+
+ // distances
+ vtkSmartPointer<vtkFloatArray> m_DistancesBetweenPoints;
+
+ // lines
+ vtkSmartPointer<vtkCellArray> m_ContourLines;
+
+ // glyph source (provides different shapes for the points)
+ vtkSmartPointer<vtkGlyphSource2D> m_UnselectedGlyphSource2D;
+ vtkSmartPointer<vtkGlyphSource2D> m_SelectedGlyphSource2D;
+
+ // glyph
+ vtkSmartPointer<vtkGlyph3D> m_UnselectedGlyph3D;
+ vtkSmartPointer<vtkGlyph3D> m_SelectedGlyph3D;
+
+ // polydata
+ vtkSmartPointer<vtkPolyData> m_VtkUnselectedPointListPolyData;
+ vtkSmartPointer<vtkPolyData> m_VtkSelectedPointListPolyData;
+ vtkSmartPointer<vtkPolyData> m_VtkContourPolyData;
+
+ // actor
+ vtkSmartPointer<vtkActor> m_UnselectedActor;
+ vtkSmartPointer<vtkActor> m_SelectedActor;
+ vtkSmartPointer<vtkActor> m_ContourActor;
+ vtkSmartPointer<vtkTextActor> m_VtkTextActor;
+
+ std::vector < vtkSmartPointer<vtkTextActor> > m_VtkTextLabelActors;
+ std::vector < vtkSmartPointer<vtkTextActor> > m_VtkTextDistanceActors;
+ std::vector < vtkSmartPointer<vtkTextActor> > m_VtkTextAngleActors;
+
+ // mappers
+ vtkSmartPointer<vtkPolyDataMapper> m_VtkUnselectedPolyDataMapper;
+ vtkSmartPointer<vtkPolyDataMapper> m_VtkSelectedPolyDataMapper;
+ vtkSmartPointer<vtkPolyDataMapper> m_VtkContourPolyDataMapper;
+
+ // propassembly
+ vtkSmartPointer<vtkPropAssembly> m_PropAssembly;
+
+ };
+
+ /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
+ mitk::LocalStorageHandler<LocalStorage> m_LSH;
+
+
+ protected:
+
+ /* constructor */
+ PointSetVtkMapper2D();
+
+ /* destructor */
+ virtual ~PointSetVtkMapper2D();
+
+ /* \brief Applies the color and opacity properties and calls CreateVTKRenderObjects */
+ virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
+ /* \brief Toggles visiblity of the propassembly */
+ virtual void ResetMapper( BaseRenderer* renderer );
+ /* \brief Fills the vtk objects, thus it is only called when the point set has been changed.
+ * This function iterates over the input point set and uses a specific shape defined in vtk glyph source
+ * to mark each point. The glyphs need to be rotated in the 2D- render windows
+ * in order to be ortogonal to the view vector. Therefore, the rotation of the current PlaneGeometry is
+ * used to determine the appropriate orienation of the glyphs. */
+ virtual void CreateVTKRenderObjects(mitk::BaseRenderer* renderer);
+
+ // properties
+ bool m_Polygon;
+ bool m_PolygonClosed;
+ bool m_ShowPoints;
+ bool m_ShowDistances;
+ int m_DistancesDecimalDigits;
+ bool m_ShowAngles;
+ bool m_ShowDistantLines;
+ int m_LineWidth;
+ int m_PointLineWidth;
+ int m_Point2DSize;
+ int m_IdGlyph;
+ bool m_FillGlyphs;
+
+ };
+
+
+} // namespace mitk
+
+#endif /* MITKPointSetVtkMAPPER2D_H_HEADER_INCLUDED_C1902626 */
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp b/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
index 4e8f3b8c3d..0f0931456f 100644
--- a/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
@@ -1,624 +1,633 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetVtkMapper3D.h"
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include "mitkColorProperty.h"
#include "mitkVtkPropRenderer.h"
#include "mitkPointSet.h"
#include <vtkActor.h>
#include <vtkAppendPolyData.h>
#include <vtkPropAssembly.h>
#include <vtkTubeFilter.h>
#include <vtkRenderer.h>
#include <vtkSphereSource.h>
#include <vtkCubeSource.h>
#include <vtkConeSource.h>
#include <vtkCylinderSource.h>
#include <vtkProperty.h>
#include <vtkPolyDataMapper.h>
#include <vtkCellArray.h>
#include <vtkVectorText.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkPolyDataAlgorithm.h>
#include <stdlib.h>
const mitk::PointSet* mitk::PointSetVtkMapper3D::GetInput()
{
return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
}
mitk::PointSetVtkMapper3D::PointSetVtkMapper3D()
: m_vtkSelectedPointList(NULL),
m_vtkUnselectedPointList(NULL),
m_VtkSelectedPolyDataMapper(NULL),
m_VtkUnselectedPolyDataMapper(NULL),
m_vtkTextList(NULL),
m_NumberOfSelectedAdded(0),
m_NumberOfUnselectedAdded(0),
m_PointSize(1.0),
m_ContourRadius(0.5)
{
//propassembly
m_PointsAssembly = vtkSmartPointer<vtkPropAssembly>::New();
//creating actors to be able to set transform
m_SelectedActor = vtkSmartPointer<vtkActor>::New();
m_UnselectedActor = vtkSmartPointer<vtkActor>::New();
m_ContourActor = vtkSmartPointer<vtkActor>::New();
}
mitk::PointSetVtkMapper3D::~PointSetVtkMapper3D()
{
}
void mitk::PointSetVtkMapper3D::ReleaseGraphicsResources(vtkWindow *renWin)
{
m_PointsAssembly->ReleaseGraphicsResources(renWin);
m_SelectedActor->ReleaseGraphicsResources(renWin);
m_UnselectedActor->ReleaseGraphicsResources(renWin);
m_ContourActor->ReleaseGraphicsResources(renWin);
}
void mitk::PointSetVtkMapper3D::CreateVTKRenderObjects()
{
m_vtkSelectedPointList = vtkSmartPointer<vtkAppendPolyData>::New();
m_vtkUnselectedPointList = vtkSmartPointer<vtkAppendPolyData>::New();
m_PointsAssembly->VisibilityOn();
if(m_PointsAssembly->GetParts()->IsItemPresent(m_SelectedActor))
m_PointsAssembly->RemovePart(m_SelectedActor);
if(m_PointsAssembly->GetParts()->IsItemPresent(m_UnselectedActor))
m_PointsAssembly->RemovePart(m_UnselectedActor);
if(m_PointsAssembly->GetParts()->IsItemPresent(m_ContourActor))
m_PointsAssembly->RemovePart(m_ContourActor);
// exceptional displaying for PositionTracker -> MouseOrientationTool
int mapperID;
bool isInputDevice=false;
if( this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice )
{
if( this->GetDataNode()->GetIntProperty("BaseRendererMapperID",mapperID) && mapperID == 2)
return; //The event for the PositionTracker came from the 3d widget and not needs to be displayed
}
// get and update the PointSet
mitk::PointSet::Pointer input = const_cast<mitk::PointSet*>(this->GetInput());
/* only update the input data, if the property tells us to */
bool update = true;
this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);
if (update == true)
input->Update();
int timestep = this->GetTimestep();
mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
if ( itkPointSet.GetPointer() == NULL)
{
m_PointsAssembly->VisibilityOff();
return;
}
mitk::PointSet::PointsContainer::Iterator pointsIter;
mitk::PointSet::PointDataContainer::Iterator pointDataIter;
int j;
m_NumberOfSelectedAdded = 0;
m_NumberOfUnselectedAdded = 0;
//create contour
bool makeContour = false;
this->GetDataNode()->GetBoolProperty("show contour", makeContour);
if (makeContour)
{
this->CreateContour();
}
//now fill selected and unselected pointList
//get size of Points in Property
m_PointSize = 2;
mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
if ( pointSizeProp.IsNotNull() )
m_PointSize = pointSizeProp->GetValue();
//get the property for creating a label onto every point only once
bool showLabel = true;
this->GetDataNode()->GetBoolProperty("show label", showLabel);
const char * pointLabel=NULL;
if(showLabel)
{
if(dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label")) != NULL)
pointLabel =dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label"))->GetValue();
else
showLabel = false;
}
//check if the list for the PointDataContainer is the same size as the PointsContainer. Is not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)
bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
//now add an object for each point in data
pointDataIter = itkPointSet->GetPointData()->Begin();
for (j=0, pointsIter=itkPointSet->GetPoints()->Begin();
pointsIter!=itkPointSet->GetPoints()->End();
pointsIter++, j++)
{
//check for the pointtype in data and decide which geom-object to take and then add to the selected or unselected list
int pointType;
if(itkPointSet->GetPointData()->size() == 0 || pointDataBroken)
pointType = mitk::PTUNDEFINED;
else
pointType = pointDataIter.Value().pointSpec;
vtkSmartPointer<vtkPolyDataAlgorithm> source;
switch (pointType)
{
case mitk::PTUNDEFINED:
{
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetRadius(m_PointSize);
itk::Point<float> point1 = pointsIter->Value();
sphere->SetCenter(point1[0],point1[1],point1[2]);
//sphere->SetCenter(pointsIter.Value()[0],pointsIter.Value()[1],pointsIter.Value()[2]);
//MouseOrientation Tool (PositionTracker)
if(isInputDevice)
{
sphere->SetThetaResolution(10);
sphere->SetPhiResolution(10);
}
else
{
sphere->SetThetaResolution(20);
sphere->SetPhiResolution(20);
}
source = sphere;
}
break;
case mitk::PTSTART:
{
vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
cube->SetXLength(m_PointSize/2);
cube->SetYLength(m_PointSize/2);
cube->SetZLength(m_PointSize/2);
itk::Point<float> point1 = pointsIter->Value();
cube->SetCenter(point1[0],point1[1],point1[2]);
source = cube;
}
break;
case mitk::PTCORNER:
{
vtkSmartPointer<vtkConeSource> cone = vtkSmartPointer<vtkConeSource>::New();
cone->SetRadius(m_PointSize);
itk::Point<float> point1 = pointsIter->Value();
cone->SetCenter(point1[0],point1[1],point1[2]);
cone->SetResolution(20);
source = cone;
}
break;
case mitk::PTEDGE:
{
vtkSmartPointer<vtkCylinderSource> cylinder = vtkSmartPointer<vtkCylinderSource>::New();
cylinder->SetRadius(m_PointSize);
itk::Point<float> point1 = pointsIter->Value();
cylinder->SetCenter(point1[0],point1[1],point1[2]);
cylinder->SetResolution(20);
source = cylinder;
}
break;
case mitk::PTEND:
{
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetRadius(m_PointSize);
//itk::Point<float> point1 = pointsIter->Value();
sphere->SetThetaResolution(20);
sphere->SetPhiResolution(20);
source = sphere;
}
break;
default:
{
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetRadius(m_PointSize);
itk::Point<float> point1 = pointsIter->Value();
sphere->SetCenter(point1[0],point1[1],point1[2]);
sphere->SetThetaResolution(20);
sphere->SetPhiResolution(20);
source = sphere;
}
break;
}
if (!pointDataBroken)
{
if (pointDataIter.Value().selected)
{
m_vtkSelectedPointList->AddInput(source->GetOutput());
++m_NumberOfSelectedAdded;
}
else
{
m_vtkUnselectedPointList->AddInput(source->GetOutput());
++m_NumberOfUnselectedAdded;
}
}
else
{
m_vtkUnselectedPointList->AddInput(source->GetOutput());
++m_NumberOfUnselectedAdded;
}
if (showLabel)
{
char buffer[20];
std::string l = pointLabel;
if ( input->GetSize()>1 )
{
sprintf(buffer,"%d",j+1);
l.append(buffer);
}
// Define the text for the label
vtkSmartPointer<vtkVectorText> label = vtkSmartPointer<vtkVectorText>::New();
label->SetText(l.c_str());
//# Set up a transform to move the label to a new position.
vtkSmartPointer<vtkTransform> aLabelTransform = vtkSmartPointer<vtkTransform>::New();
aLabelTransform->Identity();
itk::Point<float> point1 = pointsIter->Value();
aLabelTransform->Translate(point1[0]+2,point1[1]+2,point1[2]);
aLabelTransform->Scale(5.7,5.7,5.7);
//# Move the label to a new position.
vtkSmartPointer<vtkTransformPolyDataFilter> labelTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
labelTransform->SetTransform(aLabelTransform);
labelTransform->SetInput(label->GetOutput());
//add it to the wright PointList
if (pointType)
{
m_vtkSelectedPointList->AddInput(labelTransform->GetOutput());
++m_NumberOfSelectedAdded;
}
else
{
m_vtkUnselectedPointList->AddInput(labelTransform->GetOutput());
++m_NumberOfUnselectedAdded;
}
}
if(pointDataIter != itkPointSet->GetPointData()->End())
pointDataIter++;
} // end FOR
//now according to number of elements added to selected or unselected, build up the rendering pipeline
if (m_NumberOfSelectedAdded > 0)
{
m_VtkSelectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_VtkSelectedPolyDataMapper->SetInput(m_vtkSelectedPointList->GetOutput());
//create a new instance of the actor
m_SelectedActor = vtkSmartPointer<vtkActor>::New();
m_SelectedActor->SetMapper(m_VtkSelectedPolyDataMapper);
m_PointsAssembly->AddPart(m_SelectedActor);
}
if (m_NumberOfUnselectedAdded > 0)
{
m_VtkUnselectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_VtkUnselectedPolyDataMapper->SetInput(m_vtkUnselectedPointList->GetOutput());
//create a new instance of the actor
m_UnselectedActor = vtkSmartPointer<vtkActor>::New();
m_UnselectedActor->SetMapper(m_VtkUnselectedPolyDataMapper);
m_PointsAssembly->AddPart(m_UnselectedActor);
}
}
void mitk::PointSetVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
+ bool visible = true;
+ GetDataNode()->GetVisibility(visible, renderer, "visible");
+ if(!visible)
+ {
+ m_UnselectedActor->VisibilityOff();
+ m_SelectedActor->VisibilityOff();
+ m_ContourActor->VisibilityOff();
+ return;
+ }
+
// create new vtk render objects (e.g. sphere for a point)
- this->CreateVTKRenderObjects();
SetVtkMapperImmediateModeRendering(m_VtkSelectedPolyDataMapper);
SetVtkMapperImmediateModeRendering(m_VtkUnselectedPolyDataMapper);
- mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
- mitk::FloatProperty::Pointer contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize"));
- // only create new vtk render objects if property values were changed
- if ( pointSizeProp.IsNotNull() && contourSizeProp.IsNotNull() )
+ BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+ bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
+
+ if(!needGenerateData)
{
- if (m_PointSize!=pointSizeProp->GetValue() || m_ContourRadius!= contourSizeProp->GetValue())
- {
- this->CreateVTKRenderObjects();
- }
+ mitk::FloatProperty * pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
+ mitk::FloatProperty * contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize"));
+
+ // only create new vtk render objects if property values were changed
+ if(pointSizeProp && m_PointSize!=pointSizeProp->GetValue() )
+ needGenerateData = true;
+ if(contourSizeProp && m_ContourRadius!=contourSizeProp->GetValue() )
+ needGenerateData = true;
}
- this->ApplyAllProperties(renderer, m_ContourActor);
-
- bool visible = true;
- GetDataNode()->GetVisibility(visible, renderer, "visible");
- if(!visible)
+ if(needGenerateData)
{
- m_UnselectedActor->VisibilityOff();
- m_SelectedActor->VisibilityOff();
- m_ContourActor->VisibilityOff();
- return;
+ this->CreateVTKRenderObjects();
+ ls->UpdateGenerateDataTime();
}
+ this->ApplyAllProperties(renderer, m_ContourActor);
+
bool showPoints = true;
this->GetDataNode()->GetBoolProperty("show points", showPoints);
if(showPoints)
{
m_UnselectedActor->VisibilityOn();
m_SelectedActor->VisibilityOn();
}
else
{
m_UnselectedActor->VisibilityOff();
m_SelectedActor->VisibilityOff();
}
if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity")) != NULL)
{
mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity"));
float opacity = pointOpacity->GetValue();
m_ContourActor->GetProperty()->SetOpacity(opacity);
m_UnselectedActor->GetProperty()->SetOpacity(opacity);
m_SelectedActor->GetProperty()->SetOpacity(opacity);
}
bool makeContour = false;
this->GetDataNode()->GetBoolProperty("show contour", makeContour);
if (makeContour)
{
m_ContourActor->VisibilityOn();
}
else
{
m_ContourActor->VisibilityOff();
}
}
void mitk::PointSetVtkMapper3D::ResetMapper( BaseRenderer* /*renderer*/ )
{
m_PointsAssembly->VisibilityOff();
}
vtkProp* mitk::PointSetVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
{
return m_PointsAssembly;
}
void mitk::PointSetVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
{
vtkSmartPointer<vtkLinearTransform> vtktransform =
this->GetDataNode()->GetVtkTransform(this->GetTimestep());
m_SelectedActor->SetUserTransform(vtktransform);
m_UnselectedActor->SetUserTransform(vtktransform);
m_ContourActor->SetUserTransform(vtktransform);
}
void mitk::PointSetVtkMapper3D::ApplyAllProperties(mitk::BaseRenderer* renderer, vtkActor* actor)
{
Superclass::ApplyColorAndOpacityProperties(renderer, actor);
//check for color props and use it for rendering of selected/unselected points and contour
//due to different params in VTK (double/float) we have to convert!
//vars to convert to
vtkFloatingPointType unselectedColor[4]={1.0f,1.0f,0.0f,1.0f};//yellow
vtkFloatingPointType selectedColor[4]={1.0f,0.0f,0.0f,1.0f};//red
vtkFloatingPointType contourColor[4]={1.0f,0.0f,0.0f,1.0f};//red
//different types for color!!!
mitk::Color tmpColor;
double opacity = 1.0;
//check if there is an unselected property
if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor")) != NULL)
{
tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor"))->GetValue();
unselectedColor[0] = tmpColor[0];
unselectedColor[1] = tmpColor[1];
unselectedColor[2] = tmpColor[2];
unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
}
else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor")) != NULL)
{
tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor"))->GetValue();
unselectedColor[0] = tmpColor[0];
unselectedColor[1] = tmpColor[1];
unselectedColor[2] = tmpColor[2];
unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
}
else
{
//check if the node has a color
float unselectedColorTMP[4]={1.0f,1.0f,0.0f,1.0f};//yellow
m_DataNode->GetColor(unselectedColorTMP, NULL);
unselectedColor[0] = unselectedColorTMP[0];
unselectedColor[1] = unselectedColorTMP[1];
unselectedColor[2] = unselectedColorTMP[2];
//unselectedColor[3] stays 1.0f
}
//get selected property
if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
{
tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
selectedColor[0] = tmpColor[0];
selectedColor[1] = tmpColor[1];
selectedColor[2] = tmpColor[2];
selectedColor[3] = 1.0f;
}
else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
{
tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
selectedColor[0] = tmpColor[0];
selectedColor[1] = tmpColor[1];
selectedColor[2] = tmpColor[2];
selectedColor[3] = 1.0f;
}
//get contour property
if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
{
tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
contourColor[0] = tmpColor[0];
contourColor[1] = tmpColor[1];
contourColor[2] = tmpColor[2];
contourColor[3] = 1.0f;
}
else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
{
tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
contourColor[0] = tmpColor[0];
contourColor[1] = tmpColor[1];
contourColor[2] = tmpColor[2];
contourColor[3] = 1.0f;
}
if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity")) != NULL)
{
mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity"));
opacity = pointOpacity->GetValue();
}
else if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity")) != NULL)
{
mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity"));
opacity = pointOpacity->GetValue();
}
//finished color / opacity fishing!
//check if a contour shall be drawn
bool makeContour = false;
this->GetDataNode()->GetBoolProperty("show contour", makeContour, renderer);
if(makeContour && (m_ContourActor != NULL) )
{
this->CreateContour();
m_ContourActor->GetProperty()->SetColor(contourColor);
m_ContourActor->GetProperty()->SetOpacity(opacity);
}
m_SelectedActor->GetProperty()->SetColor(selectedColor);
m_SelectedActor->GetProperty()->SetOpacity(opacity);
m_UnselectedActor->GetProperty()->SetColor(unselectedColor);
m_UnselectedActor->GetProperty()->SetOpacity(opacity);
}
void mitk::PointSetVtkMapper3D::CreateContour()
{
vtkSmartPointer<vtkAppendPolyData> vtkContourPolyData = vtkSmartPointer<vtkAppendPolyData>::New();
vtkSmartPointer<vtkPolyDataMapper> vtkContourPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
mitk::PointSet::PointsContainer::Iterator pointsIter;
// mitk::PointSet::PointDataContainer::Iterator pointDataIter;
int j;
// get and update the PointSet
mitk::PointSet::Pointer input = const_cast<mitk::PointSet*>(this->GetInput());
int timestep = this->GetTimestep();
mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
if ( itkPointSet.GetPointer() == NULL)
{
return;
}
for (j=0, pointsIter=itkPointSet->GetPoints()->Begin(); pointsIter!=itkPointSet->GetPoints()->End() ; pointsIter++,j++)
{
vtkIdType cell[2] = {j-1,j};
itk::Point<float> point1 = pointsIter->Value();
points->InsertPoint(j,point1[0],point1[1],point1[2]);
if (j>0)
polys->InsertNextCell(2,cell);
}
bool close = false;
this->GetDataNode()->GetBoolProperty("close contour", close);
if (close)
{
vtkIdType cell[2] = {j-1,0};
polys->InsertNextCell(2,cell);
}
vtkSmartPointer<vtkPolyData> contour = vtkSmartPointer<vtkPolyData>::New();
contour->SetPoints(points);
contour->SetLines(polys);
contour->Update();
vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
tubeFilter->SetNumberOfSides( 12 );
tubeFilter->SetInput(contour);
//check for property contoursize.
m_ContourRadius = 0.5;
mitk::FloatProperty::Pointer contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize") );
if (contourSizeProp.IsNotNull())
m_ContourRadius = contourSizeProp->GetValue();
tubeFilter->SetRadius( m_ContourRadius );
tubeFilter->Update();
//add to pipeline
vtkContourPolyData->AddInput(tubeFilter->GetOutput());
vtkContourPolyDataMapper->SetInput(vtkContourPolyData->GetOutput());
m_ContourActor->SetMapper(vtkContourPolyDataMapper);
m_PointsAssembly->AddPart(m_ContourActor);
}
void mitk::PointSetVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite );
node->AddProperty( "pointsize", mitk::FloatProperty::New(1.0), renderer, overwrite);
node->AddProperty( "selectedcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite); //red
node->AddProperty( "color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite); //yellow
node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "contourcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);
node->AddProperty( "contoursize", mitk::FloatProperty::New(0.5), renderer, overwrite );
node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite );
node->AddProperty( "updateDataOnRender", mitk::BoolProperty::New(true), renderer, overwrite );
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper3D.h b/Core/Code/Rendering/mitkPointSetVtkMapper3D.h
index ffca0102c2..1ecdff32a8 100644
--- a/Core/Code/Rendering/mitkPointSetVtkMapper3D.h
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper3D.h
@@ -1,151 +1,153 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKPointSetVtkMAPPER3D_H_HEADER_INCLUDED_C1907273
#define MITKPointSetVtkMAPPER3D_H_HEADER_INCLUDED_C1907273
#include <MitkExports.h>
#include "mitkVtkMapper.h"
#include "mitkBaseRenderer.h"
#include <vtkSmartPointer.h>
class vtkActor;
class vtkPropAssembly;
class vtkAppendPolyData;
class vtkPolyData;
class vtkTubeFilter;
class vtkPolyDataMapper;
namespace mitk {
class PointSet;
/**
* @brief Vtk-based mapper for PointSet
*
* Due to the need of different colors for selected
* and unselected points and the facts, that we also have a contour and
* labels for the points, the vtk structure is build up the following way:
*
* We have two AppendPolyData, one selected, and one unselected and one
* for a contour between the points. Each one is connected to an own
* PolyDaraMapper and an Actor. The different color for the unselected and
* selected state and for the contour is read from properties.
*
* "unselectedcolor", "selectedcolor" and "contourcolor" are the strings,
* that are looked for. Pointlabels are added besides the selected or the
* deselected points.
*
* Then the three Actors are combined inside a vtkPropAssembly and this
* object is returned in GetProp() and so hooked up into the rendering
* pipeline.
* Properties that can be set for point sets and influence the PointSetVTKMapper3D are:
*
* - \b "color": (ColorProperty*) Color of the point set
* - \b "Opacity": (FloatProperty) Opacity of the point set
* - \b "show contour": (BoolProperty) If the contour of the points are visible
* - \b "contourSizeProp":(FloatProperty) Contour size of the points
The default properties are:
* - \b "line width": (IntProperty::New(2), renderer, overwrite )
* - \b "pointsize": (FloatProperty::New(1.0), renderer, overwrite)
* - \b "selectedcolor": (ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite) //red
* - \b "color": (ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite) //yellow
* - \b "show contour": (BoolProperty::New(false), renderer, overwrite )
* - \b "contourcolor": (ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite)
* - \b "contoursize": (FloatProperty::New(0.5), renderer, overwrite )
* - \b "close contour": (BoolProperty::New(false), renderer, overwrite )
* - \b "show points": (BoolProperty::New(true), renderer, overwrite )
* - \b "updateDataOnRender": (BoolProperty::New(true), renderer, overwrite )
*Other properties looked for are:
*
* - \b "show contour": if set to on, lines between the points are shown
* - \b "close contour": if set to on, the open strip is closed (first point
* connected with last point)
* - \b "pointsize": size of the points mapped
* - \b "label": text of the Points to show besides points
* - \b "contoursize": size of the contour drawn between the points
* (if not set, the pointsize is taken)
*
* @ingroup Mapper
*/
class MITK_CORE_EXPORT PointSetVtkMapper3D : public VtkMapper
{
public:
mitkClassMacro(PointSetVtkMapper3D, VtkMapper);
itkNewMacro(Self);
virtual const mitk::PointSet* GetInput();
//overwritten from VtkMapper3D to be able to return a
//m_PointsAssembly which is much faster than a vtkAssembly
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
virtual void UpdateVtkTransform(mitk::BaseRenderer* renderer);
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
void ReleaseGraphicsResources(vtkWindow *renWin);
+ LocalStorageHandler<BaseLocalStorage> m_LSH;
+
protected:
PointSetVtkMapper3D();
virtual ~PointSetVtkMapper3D();
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
virtual void ResetMapper( BaseRenderer* renderer );
virtual void ApplyAllProperties(mitk::BaseRenderer* renderer, vtkActor* actor);
virtual void CreateContour();
virtual void CreateVTKRenderObjects();
vtkSmartPointer<vtkAppendPolyData> m_vtkSelectedPointList;
vtkSmartPointer<vtkAppendPolyData> m_vtkUnselectedPointList;
vtkSmartPointer<vtkPolyDataMapper> m_VtkSelectedPolyDataMapper;
vtkSmartPointer<vtkPolyDataMapper> m_VtkUnselectedPolyDataMapper;
vtkSmartPointer<vtkActor> m_SelectedActor;
vtkSmartPointer<vtkActor> m_UnselectedActor;
vtkSmartPointer<vtkActor> m_ContourActor;
vtkSmartPointer<vtkPropAssembly> m_PointsAssembly;
//help for contour between points
vtkSmartPointer<vtkAppendPolyData> m_vtkTextList;
//variables to be able to log, how many inputs have been added to PolyDatas
unsigned int m_NumberOfSelectedAdded;
unsigned int m_NumberOfUnselectedAdded;
//variables to check if an update of the vtk objects is needed
ScalarType m_PointSize;
ScalarType m_ContourRadius;
};
} // namespace mitk
#endif /* MITKPointSetVtkMAPPER3D_H_HEADER_INCLUDED_C1907273 */
diff --git a/Core/Code/Rendering/mitkPolyDataGLMapper2D.cpp b/Core/Code/Rendering/mitkPolyDataGLMapper2D.cpp
index 920d51fec2..3f163d46c5 100644
--- a/Core/Code/Rendering/mitkPolyDataGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkPolyDataGLMapper2D.cpp
@@ -1,276 +1,276 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkGL.h>
#include "mitkPolyDataGLMapper2D.h"
#include "mitkBaseRenderer.h"
#include "mitkPlaneGeometry.h"
#include "mitkSurface.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkAbstractTransformGeometry.h"
#include "mitkVtkMapper3D.h"
#include <vtkPolyData.h>
#include <vtkPolyDataSource.h>
#include <vtkPlane.h>
#include <vtkCutter.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkLookupTable.h>
#include <vtkPointData.h>
#include <vtkCellData.h>
#include <vtkDataArray.h>
#include <vtkPolyData.h>
#include <vtkLinearTransform.h>
#include <vtkActor.h>
#include <vtkPolyDataMapper.h>
#include <vtkScalarsToColors.h>
#include <itkProcessObject.h>
void mitk::PolyDataGLMapper2D::Paint( mitk::BaseRenderer * renderer )
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible ) return;
// ok, das ist aus GenerateData kopiert
mitk::BaseData::Pointer input = const_cast<mitk::BaseData*>( GetDataNode()->GetData() );
assert( input );
input->Update();
vtkPolyData * vtkpolydata = this->GetVtkPolyData();
assert( vtkpolydata );
vtkLinearTransform * vtktransform = GetDataNode() ->GetVtkTransform();
if (vtktransform)
{
vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
if ( vtkpolydata != NULL )
{
Point3D point;
Vector3D normal;
if(worldPlaneGeometry.IsNotNull())
{
// set up vtkPlane according to worldGeometry
point=worldPlaneGeometry->GetOrigin();
normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
m_Plane->SetTransform((vtkAbstractTransform*)NULL);
}
else
{
//@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "plane plane" into a "curved plane"?
return;
AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldGeometry2D());
if(worldAbstractGeometry.IsNotNull())
{
// set up vtkPlane according to worldGeometry
point=const_cast<mitk::BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
FillVector3D(normal, 0, 0, 1);
m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
}
else
return;
}
vtkFloatingPointType vp[ 3 ], vnormal[ 3 ];
- vnl2vtk(point.Get_vnl_vector(), vp);
- vnl2vtk(normal.Get_vnl_vector(), vnormal);
+ vnl2vtk(point.GetVnlVector(), vp);
+ vnl2vtk(normal.GetVnlVector(), vnormal);
//normally, we would need to transform the surface and cut the transformed surface with the cutter.
//This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
//@todo It probably does not work for scaling operations yet:scaling operations have to be
//dealed with after the cut is performed by scaling the contour.
inversetransform->TransformPoint( vp, vp );
inversetransform->TransformNormalAtPoint( vp, vnormal, vnormal );
m_Plane->SetOrigin( vp );
m_Plane->SetNormal( vnormal );
// set data into cutter
m_Cutter->SetInput( vtkpolydata );
// m_Cutter->GenerateCutScalarsOff();
// m_Cutter->SetSortByToSortByCell();
// calculate the cut
m_Cutter->Update();
// fetch geometry
mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
assert( displayGeometry );
// float toGL=displayGeometry->GetSizeInDisplayUnits()[1];
//apply color and opacity read from the PropertyList
ApplyColorAndOpacityProperties( renderer );
// traverse the cut contour
vtkPolyData * contour = m_Cutter->GetOutput();
vtkPoints *vpoints = contour->GetPoints();
vtkCellArray *vpolys = contour->GetLines();
vtkPointData *vpointdata = contour->GetPointData();
vtkDataArray* vscalars = vpointdata->GetScalars();
vtkCellData *vcelldata = contour->GetCellData();
vtkDataArray* vcellscalars = vcelldata->GetScalars();
int i, numberOfCells = vpolys->GetNumberOfCells();
Point3D p;
Point2D p2d, last, first;
vpolys->InitTraversal();
vtkScalarsToColors* lut = GetVtkLUT();
assert ( lut != NULL );
for ( i = 0;i < numberOfCells;++i )
{
vtkIdType *cell(NULL);
vtkIdType cellSize(0);
vpolys->GetNextCell( cellSize, cell );
if ( m_ColorByCellData )
{ // color each cell according to cell data
vtkFloatingPointType* color = lut->GetColor( vcellscalars->GetComponent( i, 0 ) );
glColor3f( color[ 0 ], color[ 1 ], color[ 2 ] );
}
if ( m_ColorByPointData )
{
vtkFloatingPointType* color = lut->GetColor( vscalars->GetComponent( cell[0], 0 ) );
glColor3f( color[ 0 ], color[ 1 ], color[ 2 ] );
}
glBegin ( GL_LINE_LOOP );
for ( int j = 0;j < cellSize;++j )
{
vpoints->GetPoint( cell[ j ], vp );
//take transformation via vtktransform into account
vtktransform->TransformPoint( vp, vp );
vtk2itk( vp, p );
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map( p, p2d );
//convert point (until now mm and in worldcoordinates) to display coordinates (units )
displayGeometry->WorldToDisplay( p2d, p2d );
//convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
//p2d[1]=toGL-p2d[1];
//add the current vertex to the line
glVertex2f( p2d[0], p2d[1] );
}
glEnd ();
}
}
}
}
vtkPolyDataMapper* mitk::PolyDataGLMapper2D::GetVtkPolyDataMapper()
{
return NULL;
/*
mitk::DataNode::ConstPointer node = this->GetDataNode();
if ( node.IsNull() )
return NULL;
mitk::VtkMapper3D::Pointer mitkMapper = dynamic_cast< mitk::VtkMapper3D* > ( node->GetMapper( 2 ) );
if ( mitkMapper.IsNull() )
return NULL;
mitkMapper->Update(NULL);
vtkActor* actor = dynamic_cast<vtkActor*>( mitkMapper->GetVtkProp(0) );
if ( actor == NULL )
return NULL;
return dynamic_cast<vtkPolyDataMapper*>( actor->GetMapper() );
*/
}
vtkPolyData* mitk::PolyDataGLMapper2D::GetVtkPolyData( )
{
vtkPolyDataMapper * polyDataMapper = GetVtkPolyDataMapper();
if ( polyDataMapper == NULL )
return NULL;
else
return polyDataMapper->GetInput();
}
vtkScalarsToColors* mitk::PolyDataGLMapper2D::GetVtkLUT( )
{
vtkPolyDataMapper * polyDataMapper = GetVtkPolyDataMapper();
if ( polyDataMapper == NULL )
return NULL;
else
return polyDataMapper->GetLookupTable();
}
bool mitk::PolyDataGLMapper2D::IsConvertibleToVtkPolyData()
{
return ( GetVtkPolyDataMapper() != NULL );
}
mitk::PolyDataGLMapper2D::PolyDataGLMapper2D()
{
m_Plane = vtkPlane::New();
m_Cutter = vtkCutter::New();
m_Cutter->SetCutFunction( m_Plane );
m_Cutter->GenerateValues( 1, 0, 1 );
m_ColorByCellData = false;
m_ColorByPointData = false;
//m_LUT = vtkLookupTable::New();
//m_LUT->SetTableRange( 0, 255 );
//m_LUT->SetNumberOfColors( 255 );
//m_LUT->SetRampToLinear ();
//m_LUT->Build();
}
mitk::PolyDataGLMapper2D::~PolyDataGLMapper2D()
{}
diff --git a/Core/Code/Rendering/mitkRenderWindowFrame.cpp b/Core/Code/Rendering/mitkRenderWindowFrame.cpp
index 2450b0576f..cb483f70b8 100644
--- a/Core/Code/Rendering/mitkRenderWindowFrame.cpp
+++ b/Core/Code/Rendering/mitkRenderWindowFrame.cpp
@@ -1,150 +1,150 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkRenderWindowFrame.h"
#include "mitkVtkLayerController.h"
#include <mitkStandardFileLocations.h>
#include <mitkConfig.h>
#include <itkObject.h>
#include <itkMacro.h>
#include <itksys/SystemTools.hxx>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkObjectFactory.h>
#include <vtkConfigure.h>
#include <vtkMitkRectangleProp.h>
mitk::RenderWindowFrame::RenderWindowFrame()
{
m_RenderWindow = NULL;
m_RectangleRenderer = vtkRenderer::New();
m_IsEnabled = false;
}
mitk::RenderWindowFrame::~RenderWindowFrame()
{
if ( m_RenderWindow != NULL )
if ( this->IsEnabled() )
this->Disable();
if ( m_RectangleRenderer != NULL )
m_RectangleRenderer->Delete();
}
/**
* Sets the renderwindow, in which the text
* will be shown. Make sure, you have called this function
* before calling Enable()
*/
void mitk::RenderWindowFrame::SetRenderWindow( vtkRenderWindow* renderWindow )
{
m_RenderWindow = renderWindow;
}
/**
* Returns the vtkRenderWindow, which is used
* for displaying the text
*/
vtkRenderWindow* mitk::RenderWindowFrame::GetRenderWindow()
{
return m_RenderWindow;
}
/**
* Returns the renderer responsible for
* rendering the text into the
* vtkRenderWindow
*/
vtkRenderer* mitk::RenderWindowFrame::GetVtkRenderer()
{
return m_RectangleRenderer;
}
/**
* Disables drawing of the text label collection.
* If you want to enable it, call the Enable() function.
*/
void mitk::RenderWindowFrame::Disable()
{
if ( this->IsEnabled())
{
m_RectangleRenderer->EraseOn();
mitk::VtkLayerController::GetInstance(m_RenderWindow)->RemoveRenderer(m_RectangleRenderer);
m_IsEnabled = false;
}
}
/**
* Enables drawing of the text label collection.
* If you want to disable it, call the Disable() function.
*/
void mitk::RenderWindowFrame::Enable(float col1, float col2, float col3)
{
vtkMitkRectangleProp* rect = vtkMitkRectangleProp::New();
rect->SetRenderWindow(m_RenderWindow);
rect->SetColor(col1, col2, col3);
m_RectangleRenderer->AddViewProp(rect);
rect->Delete();
if(!mitk::VtkLayerController::GetInstance(m_RenderWindow)->IsRendererInserted( m_RectangleRenderer ))
{
m_RectangleRenderer->EraseOff();
m_RectangleRenderer->SetInteractive(0);
mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertForegroundRenderer(m_RectangleRenderer,true);
m_IsEnabled = true;
}
}
/**
* Checks, if the text is currently
* enabled (visible)
*/
bool mitk::RenderWindowFrame::IsEnabled()
{
return m_IsEnabled;
}
void mitk::RenderWindowFrame::SetRequestedRegionToLargestPossibleRegion()
{
//nothing to do
}
bool mitk::RenderWindowFrame::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::RenderWindowFrame::VerifyRequestedRegion()
{
return true;
}
-void mitk::RenderWindowFrame::SetRequestedRegion(itk::DataObject*)
+void mitk::RenderWindowFrame::SetRequestedRegion( const itk::DataObject*)
{
//nothing to do
}
diff --git a/Core/Code/Rendering/mitkRenderWindowFrame.h b/Core/Code/Rendering/mitkRenderWindowFrame.h
index dd2dfefd0b..b89d5448fa 100644
--- a/Core/Code/Rendering/mitkRenderWindowFrame.h
+++ b/Core/Code/Rendering/mitkRenderWindowFrame.h
@@ -1,132 +1,132 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _vtk_Colored_Rectangle_Rendering_h_
#define _vtk_Colored_Rectangle_Rendering_h_
#include <vtkSystemIncludes.h>
#include <mitkBaseData.h>
#include <vector>
#include <map>
class vtkRenderer;
class vtkRenderWindow;
class vtkCamera;
class vtkTextProperty;
class vtkTextActor;
namespace mitk {
/**
* This is a simple class for rendering colored rectangles
* at the boarders of vtkRenderWindows.
* The rectangle rendering itself is performed by means of a
* vtkProp (vtkMitkRectangleProp).
* This class instantiates the vtkProp and a corresponding vtkRenderer instance.
*/
class MITK_CORE_EXPORT RenderWindowFrame : public BaseData
{
public:
mitkClassMacro( RenderWindowFrame, BaseData );
itkNewMacro( Self );
/**
* Sets the renderwindow, in which colored rectangle boarders will be shown.
* Make sure, you have called this function
* before calling Enable()
*/
virtual void SetRenderWindow( vtkRenderWindow* renderWindow );
/**
* Enables drawing of the colored rectangle.
* If you want to disable it, call the Disable() function.
*/
virtual void Enable(float col1, float col2, float col3);
/**
* Disables drawing of the colored rectangle.
* If you want to enable it, call the Enable() function.
*/
virtual void Disable();
/**
* Checks, if the text is currently
* enabled (visible)
*/
virtual bool IsEnabled();
/**
* Empty implementation, since the rectangle rendering doesn't
* support the requested region concept
*/
virtual void SetRequestedRegionToLargestPossibleRegion();
/**
* Empty implementation, since the rectangle rendering doesn't
* support the requested region concept
*/
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
/**
* Empty implementation, since the rectangle rendering doesn't
* support the requested region concept
*/
virtual bool VerifyRequestedRegion();
/**
* Empty implementation, since the rectangle rendering doesn't
* support the requested region concept
*/
- virtual void SetRequestedRegion(itk::DataObject*);
+ virtual void SetRequestedRegion( const itk::DataObject*);
/**
* Returns the vtkRenderWindow, which is used
* for displaying the text
*/
virtual vtkRenderWindow* GetRenderWindow();
/**
* Returns the renderer responsible for
* rendering the text into the
* vtkRenderWindow
*/
virtual vtkRenderer* GetVtkRenderer();
protected:
/**
* Constructor
*/
RenderWindowFrame();
/**
* Destructor
*/
~RenderWindowFrame();
vtkRenderWindow* m_RenderWindow;
vtkRenderer* m_RectangleRenderer;
bool m_IsEnabled;
};
} //end of namespace mitk
#endif
diff --git a/Core/Code/Rendering/mitkRenderingTestHelper.cpp b/Core/Code/Rendering/mitkRenderingTestHelper.cpp
index cf646c1de3..66cf3f2f69 100644
--- a/Core/Code/Rendering/mitkRenderingTestHelper.cpp
+++ b/Core/Code/Rendering/mitkRenderingTestHelper.cpp
@@ -1,191 +1,237 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//VTK
#include <vtkRenderWindow.h>
#include <vtkPNGWriter.h>
#include <vtkRenderLargeImage.h>
#include <vtkRenderWindowInteractor.h>
//MITK
#include <mitkRenderingTestHelper.h>
#include <mitkStandaloneDataStorage.h>
#include <mitkRenderWindow.h>
#include <mitkGlobalInteraction.h>
#include <mitkSliceNavigationController.h>
#include <mitkNodePredicateDataType.h>
#include <mitkIOUtil.h>
// include gl to read out properties
#include <vtkOpenGL.h>
#include <vtkOpenGLExtensionManager.h>
-mitkRenderingTestHelper::mitkRenderingTestHelper(int width, int height, int argc, char* argv[])
+//VTK Testing to compare the rendered image pixel-wise against a reference screen shot
+#include "vtkTesting.h"
+
+mitk::RenderingTestHelper::RenderingTestHelper(int width, int height)
+ : m_AutomaticallyCloseRenderWindow(true)
{
- // Global interaction must(!) be initialized
- mitk::GlobalInteraction::GetInstance()->Initialize("global");
+ this->Initialize(width, height);
+}
- m_DataStorage = mitk::StandaloneDataStorage::New();
+mitk::RenderingTestHelper::RenderingTestHelper(int width, int height, int argc, char* argv[])
+ : m_AutomaticallyCloseRenderWindow(true)
+{
+ this->Initialize(width, height);
+ this->SetInputFileNames(argc, argv);
+}
- m_RenderWindow = mitk::RenderWindow::New();
- m_RenderWindow->GetRenderer()->SetDataStorage(m_DataStorage);
- m_RenderWindow->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
- this->GetVtkRenderWindow()->SetSize( width, height );
- m_RenderWindow->GetRenderer()->Resize( width, height);
+void mitk::RenderingTestHelper::Initialize(int width, int height)
+{
+ // Global interaction must(!) be initialized
+ mitk::GlobalInteraction::GetInstance()->Initialize("global");
- //this->GetVtkRenderWindow()->DoubleBufferOff( );
- this->SetInputFileNames(argc, argv);
- // prints the glinfo after creation of the vtkrenderwindow
- this->PrintGLInfo();
+ m_RenderWindow = mitk::RenderWindow::New();
+ m_DataStorage = mitk::StandaloneDataStorage::New();
+
+ m_RenderWindow->GetRenderer()->SetDataStorage(m_DataStorage);
+ this->SetMapperIDToRender2D();
+ this->GetVtkRenderWindow()->SetSize( width, height );
+ m_RenderWindow->GetRenderer()->Resize( width, height);
+
+ //Prints the glinfo after creation of the vtkrenderwindow, we always want to do this for debugging.
+ this->PrintGLInfo();
}
-mitkRenderingTestHelper::~mitkRenderingTestHelper()
+mitk::RenderingTestHelper::~RenderingTestHelper()
{
}
-void mitkRenderingTestHelper::PrintGLInfo()
+void mitk::RenderingTestHelper::PrintGLInfo()
{
- GLint maxTextureSize;
+ GLint maxTextureSize;
- glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);;
+ glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);;
- MITK_INFO << "OpenGL Render Context Information: \n"
- << "- GL_VENDOR: "<< glGetString(GL_VENDOR) << "\n"
- << "- GL_RENDERER: "<< glGetString(GL_RENDERER) << "\n"
- << "- GL_VERSION: "<< glGetString(GL_VERSION) << "\n"
- << "- GL_MAX_TEXTURE_SIZE: "<< maxTextureSize << "\n"
- << "- GL_EXTENSIONS: "<< glGetString(GL_EXTENSIONS);
+ MITK_INFO << "OpenGL Render Context Information: \n"
+ << "- GL_VENDOR: "<< glGetString(GL_VENDOR) << "\n"
+ << "- GL_RENDERER: "<< glGetString(GL_RENDERER) << "\n"
+ << "- GL_VERSION: "<< glGetString(GL_VERSION) << "\n"
+ << "- GL_MAX_TEXTURE_SIZE: "<< maxTextureSize << "\n"
+ << "- GL_EXTENSIONS: "<< glGetString(GL_EXTENSIONS);
}
-void mitkRenderingTestHelper::SetMapperID( mitk::BaseRenderer::StandardMapperSlot id)
+void mitk::RenderingTestHelper::SetMapperID( mitk::BaseRenderer::StandardMapperSlot id)
{
- m_RenderWindow->GetRenderer()->SetMapperID(id);
+ m_RenderWindow->GetRenderer()->SetMapperID(id);
}
-void mitkRenderingTestHelper::Render()
+void mitk::RenderingTestHelper::SetMapperIDToRender3D()
{
- //if the datastorage is initialized and at least 1 image is loaded render it
- if(m_DataStorage.IsNotNull() || m_DataStorage->GetAll()->Size() >= 1 )
- {
- //perform global reinit:
- m_RenderWindow->GetRenderer()->PrepareRender();
- // mitk::RenderingManager::GetInstance()->RequestUpdate(m_RenderWindow->GetVtkRenderWindow());
+ this->SetMapperID(mitk::BaseRenderer::Standard3D);
+}
- //use this to actually show the iamge in a renderwindow
- this->GetVtkRenderWindow()->Render();
-// this->GetVtkRenderWindow()->GetInteractor()->Start();
- }
- else
+void mitk::RenderingTestHelper::SetMapperIDToRender2D()
+{
+ this->SetMapperID(mitk::BaseRenderer::Standard2D);
+}
+
+void mitk::RenderingTestHelper::Render()
+{
+ //if the datastorage is initialized and at least 1 image is loaded render it
+ if(m_DataStorage.IsNotNull() || m_DataStorage->GetAll()->Size() >= 1 )
+ {
+ //Prepare the VTK camera before rendering.
+ m_RenderWindow->GetRenderer()->PrepareRender();
+
+ this->GetVtkRenderWindow()->Render();
+ if(m_AutomaticallyCloseRenderWindow == false)
{
- MITK_ERROR << "No images loaded in data storage!";
+ //Use interaction to stop the test
+ this->GetVtkRenderWindow()->GetInteractor()->Start();
}
+ }
+ else
+ {
+ MITK_ERROR << "No images loaded in data storage!";
+ }
}
-void mitkRenderingTestHelper::PrepareRender()
+mitk::DataStorage::Pointer mitk::RenderingTestHelper::GetDataStorage()
{
- //perform global reinit:
- m_RenderWindow->GetRenderer()->PrepareRender();
+ return m_DataStorage;
}
-mitk::DataStorage::Pointer mitkRenderingTestHelper::GetDataStorage()
+void mitk::RenderingTestHelper::SetInputFileNames(int argc, char* argv[])
{
- return m_DataStorage;
+ //i is set 1, because 0 is the testname as string
+ //parse parameters
+ for (int i = 1; i < argc; ++i)
+ {
+ //add everything to a list but -T and -V
+ std::string tmp = argv[i];
+ if((tmp.compare("-T")) && (tmp.compare("-V")))
+ {
+ this->AddToStorage(tmp);
+ }
+ else
+ {
+ break;
+ }
+ }
}
-void mitkRenderingTestHelper::SetInputFileNames(int argc, char* argv[])
+void mitk::RenderingTestHelper::SetViewDirection(mitk::SliceNavigationController::ViewDirection viewDirection)
{
- // parse parameters
- for (int i = 1; i < argc; ++i)
- {
- //add everything to a list but -T and -V
- std::string tmp = argv[i];
- if((tmp.compare("-T")) && (tmp.compare("-V")))
- {
- this->AddToStorage(tmp);
- }
- else
- {
- break;
- }
- }
+ mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow())->GetSliceNavigationController()->SetDefaultViewDirection(viewDirection);
+ mitk::RenderingManager::GetInstance()->InitializeViews( m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll()) );
}
-void mitkRenderingTestHelper::SetViewDirection(mitk::SliceNavigationController::ViewDirection viewDirection)
+void mitk::RenderingTestHelper::ReorientSlices(mitk::Point3D origin, mitk::Vector3D rotation)
{
- mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow())->GetSliceNavigationController()->SetDefaultViewDirection(viewDirection);
- mitk::RenderingManager::GetInstance()->InitializeViews( m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll()) );
+ mitk::SliceNavigationController::Pointer sliceNavigationController =
+ mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow())->GetSliceNavigationController();
+ sliceNavigationController->ReorientSlices(origin, rotation);
}
-void mitkRenderingTestHelper::ReorientSlices(mitk::Point3D origin, mitk::Vector3D rotation)
+vtkRenderer* mitk::RenderingTestHelper::GetVtkRenderer()
{
- mitk::SliceNavigationController::Pointer sliceNavigationController =
- mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow())->GetSliceNavigationController();
- sliceNavigationController->ReorientSlices(origin, rotation);
+ return m_RenderWindow->GetRenderer()->GetVtkRenderer();
}
-vtkRenderer* mitkRenderingTestHelper::GetVtkRenderer()
+void mitk::RenderingTestHelper::SetImageProperty(const char *propertyKey, mitk::BaseProperty* property )
{
- return m_RenderWindow->GetRenderer()->GetVtkRenderer();
+ this->m_DataStorage->GetNode(mitk::NodePredicateDataType::New("Image"))->SetProperty(propertyKey, property);
}
-void mitkRenderingTestHelper::SetImageProperty(const char *propertyKey, mitk::BaseProperty* property )
+vtkRenderWindow* mitk::RenderingTestHelper::GetVtkRenderWindow()
{
- this->m_DataStorage->GetNode(mitk::NodePredicateDataType::New("Image"))->SetProperty(propertyKey, property);
+ return m_RenderWindow->GetVtkRenderWindow();
}
-vtkRenderWindow* mitkRenderingTestHelper::GetVtkRenderWindow()
+bool mitk::RenderingTestHelper::CompareRenderWindowAgainstReference(int argc, char* argv[], double threshold)
{
- return m_RenderWindow->GetVtkRenderWindow();
+ this->Render();
+
+ //retVal meanings: (see VTK/Rendering/vtkTesting.h)
+ //0 = test failed
+ //1 = test passed
+ //2 = test not run
+ //3 = something with vtkInteraction
+ if(vtkTesting::Test(argc, argv, this->GetVtkRenderWindow(), threshold) == 1)
+ return true;
+ else
+ return false;
}
//method to save a screenshot of the renderwindow (e.g. create a reference screenshot)
-void mitkRenderingTestHelper::SaveAsPNG(std::string fileName)
+void mitk::RenderingTestHelper::SaveAsPNG(std::string fileName)
{
- vtkSmartPointer<vtkRenderer> renderer = this->GetVtkRenderer();
- bool doubleBuffering( renderer->GetRenderWindow()->GetDoubleBuffer() );
- renderer->GetRenderWindow()->DoubleBufferOff();
+ vtkSmartPointer<vtkRenderer> renderer = this->GetVtkRenderer();
+ bool doubleBuffering( renderer->GetRenderWindow()->GetDoubleBuffer() );
+ renderer->GetRenderWindow()->DoubleBufferOff();
- vtkSmartPointer<vtkRenderLargeImage> magnifier = vtkSmartPointer<vtkRenderLargeImage>::New();
- magnifier->SetInput(renderer);
- magnifier->SetMagnification(1);
+ vtkSmartPointer<vtkRenderLargeImage> magnifier = vtkSmartPointer<vtkRenderLargeImage>::New();
+ magnifier->SetInput(renderer);
+ magnifier->SetMagnification(1);
- vtkSmartPointer<vtkImageWriter> fileWriter = vtkSmartPointer<vtkPNGWriter>::New();
- fileWriter->SetInput(magnifier->GetOutput());
- fileWriter->SetFileName(fileName.c_str());
+ vtkSmartPointer<vtkImageWriter> fileWriter = vtkSmartPointer<vtkPNGWriter>::New();
+ fileWriter->SetInput(magnifier->GetOutput());
+ fileWriter->SetFileName(fileName.c_str());
- fileWriter->Write();
- renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering);
+ fileWriter->Write();
+ renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering);
}
-void mitkRenderingTestHelper::AddToStorage(const std::string &filename)
+void mitk::RenderingTestHelper::SetAutomaticallyCloseRenderWindow(bool automaticallyCloseRenderWindow)
{
- try
- {
- mitk::DataNode::Pointer node = mitk::IOUtil::LoadDataNode(filename);
- this->AddNodeToStorage(node);
- }
- catch ( itk::ExceptionObject & e )
- {
- MITK_ERROR << "Failed loading test data '" << filename << "': " << e.what();
- }
+ m_AutomaticallyCloseRenderWindow = automaticallyCloseRenderWindow;
+}
+
+void mitk::RenderingTestHelper::SaveReferenceScreenShot(std::string fileName)
+{
+ this->SaveAsPNG(fileName);
+}
+
+void mitk::RenderingTestHelper::AddToStorage(const std::string &filename)
+{
+ try
+ {
+ mitk::DataNode::Pointer node = mitk::IOUtil::LoadDataNode(filename);
+ this->AddNodeToStorage(node);
+ }
+ catch ( itk::ExceptionObject & e )
+ {
+ MITK_ERROR << "Failed loading test data '" << filename << "': " << e.what();
+ }
}
-void mitkRenderingTestHelper::AddNodeToStorage(mitk::DataNode::Pointer node)
+void mitk::RenderingTestHelper::AddNodeToStorage(mitk::DataNode::Pointer node)
{
- this->m_DataStorage->Add(node);
- mitk::RenderingManager::GetInstance()->InitializeViews( m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll()) );
+ this->m_DataStorage->Add(node);
+ mitk::RenderingManager::GetInstance()->InitializeViews( m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll()) );
}
diff --git a/Core/Code/Rendering/mitkRenderingTestHelper.h b/Core/Code/Rendering/mitkRenderingTestHelper.h
index 4b0ae508e1..22f0a69d50 100644
--- a/Core/Code/Rendering/mitkRenderingTestHelper.h
+++ b/Core/Code/Rendering/mitkRenderingTestHelper.h
@@ -1,114 +1,171 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkRenderingTestHelper_h
#define mitkRenderingTestHelper_h
#include <vtkSmartPointer.h>
#include <mitkRenderWindow.h>
#include <mitkDataNodeFactory.h>
#include <mitkDataStorage.h>
#include <MitkExports.h>
class vtkRenderWindow;
class vtkRenderer;
-class MITK_CORE_EXPORT mitkRenderingTestHelper
+namespace mitk
+{
+
+class MITK_CORE_EXPORT RenderingTestHelper
{
public:
- /** @brief Generate a rendering test helper object including a render window of the size width * height (in pixel).
- @param argc Number of parameters. (here: Images) "Usage: [filename1 filenam2 -V referenceScreenshot (optional -T /directory/to/save/differenceImage)]
- @param argv Given parameters.
+ /** @brief Generate a rendering test helper object including a render window of the size width * height (in pixel).
+ @param argc Number of parameters. (here: Images) "Usage: [filename1 filenam2 -V referenceScreenshot
+ (optional -T /directory/to/save/differenceImage)]
+ @param argv Given parameters. If no data is inserted via commandline, you can add data
+ later via AddNodeToDataStorage().
**/
- mitkRenderingTestHelper(int width, int height, int argc, char *argv[]);
+ RenderingTestHelper(int width, int height, int argc, char *argv[]);
+
+ /** @brief Generate a rendering test helper object including a render window of the size width * height (in pixel).*/
+ RenderingTestHelper(int width, int height);
- ~mitkRenderingTestHelper();
+ /** Default destructor */
+ ~RenderingTestHelper();
- /** @brief Getter for the vtkRenderer.
+ /** @brief Getter for the vtkRenderer.
**/
- vtkRenderer* GetVtkRenderer();
+ vtkRenderer* GetVtkRenderer();
- /** @brief Getter for the vtkRenderWindow which should be used to call vtkRegressionTestImage.
+ /** @brief Getter for the vtkRenderWindow which should be used to call vtkRegressionTestImage.
**/
- vtkRenderWindow* GetVtkRenderWindow();
+ vtkRenderWindow* GetVtkRenderWindow();
- /** @brief Method can be used to save a screenshot (e.g. reference screenshot as a .png file.
+ /** @brief Method can be used to save a screenshot (e.g. reference screenshot as a .png file.
@param fileName The filename of the new screenshot (including path).
**/
- void SaveAsPNG(std::string fileName);
-
- /** @brief This method set the property of the member datastorage
- @param property Set a property for each image in the datastorage m_DataStorage.
+ void SaveAsPNG(std::string fileName);
+
+ /**
+ * @brief SetStopRenderWindow Convenience method to make the renderwindow hold after rendering. Usefull for debugging.
+ * @param flag Flag indicating whether the renderwindow should automatically close (false, default) or stay open (true). Usefull for debugging.
+ */
+ void SetAutomaticallyCloseRenderWindow(bool automaticallyCloseRenderWindow);
+
+ /** @brief This method set the property of the member datastorage
+ @param property Set a property for each image in the datastorage m_DataStorage. If you want
+ to set the property for a single data node, use GetDataStorage() and set the property
+ yourself for the destinct node.
**/
- void SetImageProperty(const char *propertyKey, mitk::BaseProperty *property);
+ void SetImageProperty(const char *propertyKey, mitk::BaseProperty *property);
- /** @brief Set the view direction of the renderwindow (e.g. sagittal, coronal, axial)
+ /** @brief Set the view direction of the renderwindow (e.g. sagittal, coronal, axial)
**/
- void SetViewDirection(mitk::SliceNavigationController::ViewDirection viewDirection);
+ void SetViewDirection(mitk::SliceNavigationController::ViewDirection viewDirection);
- /** @brief Reorient the slice (e.g. rotation and translation like the swivel mode).
+ /** @brief Reorient the slice (e.g. rotation and translation like the swivel mode).
**/
- void ReorientSlices(mitk::Point3D origin, mitk::Vector3D rotation);
+ void ReorientSlices(mitk::Point3D origin, mitk::Vector3D rotation);
- /** @brief Render everything into an mitkRenderWindow. Call SetViewDirection() and SetProperty() before this method.
- **/
- void Render();
- /** @brief Calls PrepareRender function of mitkRenderWindow
+ /** @brief Render everything into an mitkRenderWindow. Call SetViewDirection() and SetProperty() before this method.
**/
- void PrepareRender();
+ void Render();
- /** @brief Returns the datastorage, in order to modify the data inside a rendering test.
+ /** @brief Returns the datastorage, in order to modify the data inside a rendering test.
**/
- mitk::DataStorage::Pointer GetDataStorage();
+ mitk::DataStorage::Pointer GetDataStorage();
- /**
+ /**
* @brief SetMapperID Change between Standard2D and 3D mappers.
* @param id Enum mitk::BaseRenderer::StandardMapperSlot which defines the mapper.
*/
- void SetMapperID(mitk::BaseRenderer::StandardMapperSlot id);
+ void SetMapperID(mitk::BaseRenderer::StandardMapperSlot id);
- /**
+ /**
* @brief AddNodeToStorage Add a node to the datastorage and perform a reinit which is necessary for rendering.
* @param node The data you want to add.
*/
- void AddNodeToStorage(mitk::DataNode::Pointer node);
+ void AddNodeToStorage(mitk::DataNode::Pointer node);
+
+ /**
+ * @brief SetMapperIDToRender3D Convenience method to render in a 3D renderwindow.
+ * @warning Does not add helper objects like the image planes to render images in 3D.
+ */
+ void SetMapperIDToRender3D();
+
+ /**
+ * @brief SetMapperIDToRender2D Convenience method to render in a 2D renderwindow.
+ */
+ void SetMapperIDToRender2D();
+
+ /**
+ * @brief SaveReferenceScreenShot Convenience method to save a reference screen shot.
+ * @param fileName Path/to/save/the/png/file.
+ */
+ void SaveReferenceScreenShot(std::string fileName);
+
+ /**
+ * @brief CompareRenderWindowAgainstReference Convenience method to compare the image rendered in the internal renderwindow against a reference screen shot.
+ *
+ Usage of vtkTesting::Test:
+ vtkTesting::Test( argc, argv, vtkRenderWindow, threshold )
+ Set a vtkRenderWindow containing the desired scene. This is automatically rendered.
+ vtkTesting::Test() automatically searches in argc and argv[]
+ for a path a valid image with -V. If the test failed with the
+ first image (foo.png) it checks if there are images of the form
+ foo_N.png (where N=1,2,3...) and compare against them. This allows for multiple
+ valid images.
+ * @param argc Number of arguments.
+ * @param argv Arguments must(!) contain the term "-V Path/To/Valid/Image.png"
+ * @param threshold Allowed difference between two images. Default = 10.0 and was taken from VTK.
+ * @return True if the images are equal regarding the threshold. False in all other cases.
+ */
+ bool CompareRenderWindowAgainstReference(int argc, char *argv[], double threshold = 10.0);
+
protected:
+ /**
+ * @brief Initialize Internal method to initialize the renderwindow and set the datastorage.
+ * @param width Height of renderwindow.
+ * @param height Width of renderwindow.
+ */
+ void Initialize(int width, int height);
- /** @brief Prints the opengl information, e.g. version, vendor and extensions,
+ /** @brief Prints the opengl information, e.g. version, vendor and extensions,
* This function can only be called after an opengl context is active.
* It only prints the context after the vtkRenderwindow is fully initialized.
**/
- void PrintGLInfo();
+ void PrintGLInfo();
- /** @brief This method tries to load the given file into a member datastorage, in order to render it.
+ /** @brief This method tries to load the given file into a member datastorage, in order to render it.
@param fileName The filename of the file to be loaded (including path).
**/
- void AddToStorage(const std::string& filename);
+ void AddToStorage(const std::string& filename);
- /** @brief This method tries to parse the given argv for files (e.g. images) and load them into a member datastorage, in order to render it.
+ /** @brief This method tries to parse the given argv for files (e.g. images) and load them into a member datastorage, in order to render it.
@param argc Number of parameters.
@param argv Given parameters.
**/
- void SetInputFileNames(int argc, char *argv[]);
+ void SetInputFileNames(int argc, char *argv[]);
- mitk::RenderWindow::Pointer m_RenderWindow; //<< Contains the mitkRenderWindow into which the test renders the data
- mitk::DataStorage::Pointer m_DataStorage; //<< Contains the mitkDataStorage which contains the data to be rendered
+ mitk::RenderWindow::Pointer m_RenderWindow; //<< Contains the mitkRenderWindow into which the test renders the data
+ mitk::DataStorage::Pointer m_DataStorage; //<< Contains the mitkDataStorage which contains the data to be rendered
+ bool m_AutomaticallyCloseRenderWindow; //<< Flag indicating whether the renderwindow should automatically close (true, default) or stay open (false). Usefull for debugging.
};
-
+}//namespace mitk
#endif
diff --git a/Core/Code/Rendering/mitkShaderRepository.cpp b/Core/Code/Rendering/mitkShaderRepository.cpp
index 249eef08ae..20e1fd81b3 100644
--- a/Core/Code/Rendering/mitkShaderRepository.cpp
+++ b/Core/Code/Rendering/mitkShaderRepository.cpp
@@ -1,519 +1,520 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#define SR_INFO MITK_INFO("shader.repository")
#define SR_WARN MITK_WARN("shader.repository")
#define SR_ERROR MITK_ERROR("shader.repository")
#include "mitkShaderRepository.h"
#include "mitkShaderProperty.h"
#include "mitkProperties.h"
#include "mitkDataNode.h"
#include <vtkActor.h>
#include <vtkProperty.h>
#include <vtkXMLMaterial.h>
#include <vtkXMLShader.h>
#include <vtkXMLDataElement.h>
#include <itkDirectory.h>
#include <itksys/SystemTools.hxx>
int mitk::ShaderRepository::shaderId = 0;
+const bool mitk::ShaderRepository::debug = false;
mitk::ShaderRepository::ShaderRepository()
{
LoadShaders();
}
mitk::ShaderRepository::~ShaderRepository()
{
}
mitk::ShaderRepository *mitk::ShaderRepository::GetGlobalShaderRepository()
{
static mitk::ShaderRepository::Pointer i;
if(i.IsNull())
{
i=mitk::ShaderRepository::New();
}
return i;
}
void mitk::ShaderRepository::LoadShaders()
{
itk::Directory::Pointer dir = itk::Directory::New();
std::string dirPath = "./vtk_shader";
if( dir->Load( dirPath.c_str() ) )
{
int n = dir->GetNumberOfFiles();
for(int r=0;r<n;r++)
{
const char *filename = dir->GetFile( r );
std::string extension = itksys::SystemTools::GetFilenameExtension(filename);
if(extension.compare(".xml")==0)
{
Shader::Pointer element=Shader::New();
element->SetName(itksys::SystemTools::GetFilenameWithoutExtension(filename));
std::string filePath = dirPath + std::string("/") + element->GetName() + std::string(".xml");
element->path = filePath;
SR_INFO << "found shader '" << element->GetName() << "'";
element->LoadProperties(filePath);
shaders.push_back(element);
}
}
}
}
mitk::ShaderRepository::Shader::Pointer mitk::ShaderRepository::GetShaderImpl(const std::string &name) const
{
std::list<Shader::Pointer>::const_iterator i = shaders.begin();
while( i != shaders.end() )
{
if( (*i)->GetName() == name)
return (*i);
i++;
}
return Shader::Pointer();
}
int mitk::ShaderRepository::LoadShader(const std::string& filename)
{
std::string extension = itksys::SystemTools::GetFilenameExtension(filename);
if (extension.compare(".xml")==0)
{
Shader::Pointer element=Shader::New();
element->SetName(itksys::SystemTools::GetFilenameWithoutExtension(filename));
element->name = element->GetName();
element->path = filename;
element->SetId(shaderId++);
element->LoadProperties(filename);
shaders.push_back(element);
- SR_INFO << "found shader '" << element->GetName() << "'";
+ SR_INFO(debug) << "found shader '" << element->GetName() << "'";
return element->GetId();
}
else
{
- SR_INFO << "Error: no xml shader file!";
+ SR_INFO(debug) << "Error: no xml shader file!";
return -1;
}
}
int mitk::ShaderRepository::LoadShader(std::istream& stream, const std::string& filename)
{
Shader::Pointer element=Shader::New();
element->SetName(filename);
element->name = filename;
element->SetId(shaderId++);
element->LoadProperties(stream);
shaders.push_back(element);
- SR_INFO << "found shader '" << element->GetName() << "'";
+ SR_INFO(debug) << "found shader '" << element->GetName() << "'";
return element->GetId();
}
bool mitk::ShaderRepository::UnloadShader(int id)
{
for (std::list<Shader::Pointer>::iterator i = shaders.begin();
i != shaders.end(); ++i)
{
if ((*i)->GetId() == id)
{
shaders.erase(i);
return true;
}
}
return false;
}
mitk::ShaderRepository::Shader::Shader()
{
}
mitk::ShaderRepository::Shader::~Shader()
{
}
void mitk::ShaderRepository::Shader::LoadPropertiesFromPath()
{
LoadProperties(path);
}
void mitk::ShaderRepository::Shader::LoadProperties(vtkProperty* p)
{
vtkXMLMaterial *m=p->GetMaterial();
if (m == NULL) return;
// Vertexshader uniforms
{
vtkXMLShader *s=m->GetVertexShader();
if (s)
{
vtkXMLDataElement *x=s->GetRootElement();
int n=x->GetNumberOfNestedElements();
for(int r=0;r<n;r++)
{
vtkXMLDataElement *y=x->GetNestedElement(r);
if(!strcmp(y->GetName(),"ApplicationUniform"))
{
Uniform::Pointer element=Uniform::New();
element->LoadFromXML(y);
uniforms.push_back(element);
}
}
}
}
// Fragmentshader uniforms
{
vtkXMLShader *s=m->GetFragmentShader();
if (s)
{
vtkXMLDataElement *x=s->GetRootElement();
int n=x->GetNumberOfNestedElements();
for(int r=0;r<n;r++)
{
vtkXMLDataElement *y=x->GetNestedElement(r);
if(!strcmp(y->GetName(),"ApplicationUniform"))
{
Uniform::Pointer element=Uniform::New();
element->LoadFromXML(y);
uniforms.push_back(element);
}
}
}
}
}
void mitk::ShaderRepository::Shader::LoadProperties(const std::string& path)
{
vtkProperty *p = vtkProperty::New();
p->LoadMaterial(path.c_str());
LoadProperties(p);
p->Delete();
}
void mitk::ShaderRepository::Shader::LoadProperties(std::istream& stream)
{
std::string content;
content.reserve(2048);
char buffer[2048];
while (stream.read(buffer, sizeof(buffer)))
{
content.append(buffer, sizeof(buffer));
}
content.append(buffer, static_cast<std::size_t>(stream.gcount()));
if (content.empty()) return;
this->SetMaterialXml(content);
vtkProperty *p = vtkProperty::New();
p->LoadMaterialFromString(content.c_str());
LoadProperties(p);
p->Delete();
}
mitk::ShaderRepository::Shader::Uniform::Uniform()
{
}
mitk::ShaderRepository::Shader::Uniform::~Uniform()
{
}
mitk::ShaderRepository::Shader *mitk::ShaderRepository::GetShader(const char *id) const
{
std::list<Shader::Pointer>::const_iterator i = shaders.begin();
while( i != shaders.end() )
{
if( (*i)->GetName() ==id)
return (*i);
i++;
}
return 0;
}
void mitk::ShaderRepository::Shader::Uniform::LoadFromXML(vtkXMLDataElement *y)
{
//MITK_INFO << "found uniform '" << y->GetAttribute("name") << "' type=" << y->GetAttribute("type");// << " default=" << y->GetAttribute("value");
name = y->GetAttribute("name");
const char *sType=y->GetAttribute("type");
if(!strcmp(sType,"float"))
type=glsl_float;
else if(!strcmp(sType,"vec2"))
type=glsl_vec2;
else if(!strcmp(sType,"vec3"))
type=glsl_vec3;
else if(!strcmp(sType,"vec4"))
type=glsl_vec4;
else if(!strcmp(sType,"int"))
type=glsl_int;
else if(!strcmp(sType,"ivec2"))
type=glsl_ivec2;
else if(!strcmp(sType,"ivec3"))
type=glsl_ivec3;
else if(!strcmp(sType,"ivec4"))
type=glsl_ivec4;
else
{
type=glsl_none;
SR_WARN << "unknown type for uniform '" << name << "'" ;
}
defaultFloat[0]=defaultFloat[1]=defaultFloat[2]=defaultFloat[3]=0;
/*
const char *sDefault=y->GetAttribute("value");
switch(type)
{
case glsl_float:
sscanf(sDefault,"%f",&defaultFloat[0]);
break;
case glsl_vec2:
sscanf(sDefault,"%f %f",&defaultFloat[0],&defaultFloat[1]);
break;
case glsl_vec3:
sscanf(sDefault,"%f %f %f",&defaultFloat[0],&defaultFloat[1],&defaultFloat[2]);
break;
case glsl_vec4:
sscanf(sDefault,"%f %f %f %f",&defaultFloat[0],&defaultFloat[1],&defaultFloat[2],&defaultFloat[3]);
break;
} */
}
void mitk::ShaderRepository::AddDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) const
{
node->AddProperty( "shader", mitk::ShaderProperty::New(), renderer, overwrite );
std::list<Shader::Pointer>::const_iterator i = shaders.begin();
while( i != shaders.end() )
{
std::list<Shader::Uniform::Pointer> *l = (*i)->GetUniforms();
std::string shaderName = (*i)->GetName();
std::list<Shader::Uniform::Pointer>::const_iterator j = l->begin();
while( j != l->end() )
{
std::string propertyName = "shader." + shaderName + "." + (*j)->name;
switch( (*j)->type )
{
case Shader::Uniform::glsl_float:
node->AddProperty( propertyName.c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[0] ), renderer, overwrite );
break;
case Shader::Uniform::glsl_vec2:
node->AddProperty( (propertyName+".x").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[0] ), renderer, overwrite );
node->AddProperty( (propertyName+".y").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[1] ), renderer, overwrite );
break;
case Shader::Uniform::glsl_vec3:
node->AddProperty( (propertyName+".x").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[0] ), renderer, overwrite );
node->AddProperty( (propertyName+".y").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[1] ), renderer, overwrite );
node->AddProperty( (propertyName+".z").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[2] ), renderer, overwrite );
break;
case Shader::Uniform::glsl_vec4:
node->AddProperty( (propertyName+".x").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[0] ), renderer, overwrite );
node->AddProperty( (propertyName+".y").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[1] ), renderer, overwrite );
node->AddProperty( (propertyName+".z").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[2] ), renderer, overwrite );
node->AddProperty( (propertyName+".w").c_str(), mitk::FloatProperty::New( (*j)->defaultFloat[3] ), renderer, overwrite );
break;
default:
break;
}
j++;
}
i++;
}
}
void mitk::ShaderRepository::ApplyProperties(mitk::DataNode* node, vtkActor *actor, mitk::BaseRenderer* renderer,itk::TimeStamp &MTime) const
{
bool setMTime = false;
vtkProperty* property = actor->GetProperty();
unsigned long ts = MTime.GetMTime();
mitk::ShaderProperty *sep= dynamic_cast<mitk::ShaderProperty*>(node->GetProperty("shader",renderer));
if(!sep)
{
property->ShadingOff();
return;
}
std::string shader=sep->GetValueAsString();
// Need update pipeline mode
if(sep->GetMTime() > ts)
{
if(shader.compare("fixed")==0)
{
//MITK_INFO << "disabling shader";
property->ShadingOff();
}
else
{
Shader::Pointer s=GetShaderImpl(shader);
if(s.IsNotNull())
{
//MITK_INFO << "enabling shader";
property->ShadingOn();
property->LoadMaterialFromString(s->GetMaterialXml().c_str());
}
}
setMTime = true;
}
if(shader.compare("fixed")!=0)
{
Shader::Pointer s=GetShaderImpl(shader);
if(s.IsNull())
return;
std::list<Shader::Uniform::Pointer>::const_iterator j = s->uniforms.begin();
while( j != s->uniforms.end() )
{
std::string propertyName = "shader." + s->GetName() + "." + (*j)->name;
// MITK_INFO << "querying property: " << propertyName;
// mitk::BaseProperty *p = node->GetProperty( propertyName.c_str(), renderer );
// if( p && p->GetMTime() > MTime.GetMTime() )
{
float fval[4];
// MITK_INFO << "copying property " << propertyName << " ->->- " << (*j)->name << " type=" << (*j)->type ;
switch( (*j)->type )
{
case Shader::Uniform::glsl_float:
node->GetFloatProperty( propertyName.c_str(), fval[0], renderer );
property->AddShaderVariable( (*j)->name.c_str(), 1 , fval );
break;
case Shader::Uniform::glsl_vec2:
node->GetFloatProperty( (propertyName+".x").c_str(), fval[0], renderer );
node->GetFloatProperty( (propertyName+".y").c_str(), fval[1], renderer );
property->AddShaderVariable( (*j)->name.c_str(), 2 , fval );
break;
case Shader::Uniform::glsl_vec3:
node->GetFloatProperty( (propertyName+".x").c_str(), fval[0], renderer );
node->GetFloatProperty( (propertyName+".y").c_str(), fval[1], renderer );
node->GetFloatProperty( (propertyName+".z").c_str(), fval[2], renderer );
property->AddShaderVariable( (*j)->name.c_str(), 3 , fval );
break;
case Shader::Uniform::glsl_vec4:
node->GetFloatProperty( (propertyName+".x").c_str(), fval[0], renderer );
node->GetFloatProperty( (propertyName+".y").c_str(), fval[1], renderer );
node->GetFloatProperty( (propertyName+".z").c_str(), fval[2], renderer );
node->GetFloatProperty( (propertyName+".w").c_str(), fval[3], renderer );
property->AddShaderVariable( (*j)->name.c_str(), 4 , fval );
break;
default:
break;
}
//setMTime=true;
}
j++;
}
}
if(setMTime)
MTime.Modified();
}
std::list<mitk::IShaderRepository::Shader::Pointer> mitk::ShaderRepository::GetShaders() const
{
std::list<mitk::IShaderRepository::Shader::Pointer> result;
for (std::list<Shader::Pointer>::const_iterator i = shaders.begin();
i != shaders.end(); ++i)
{
result.push_back(i->GetPointer());
}
return result;
}
mitk::IShaderRepository::Shader::Pointer mitk::ShaderRepository::GetShader(const std::string& name) const
{
for (std::list<Shader::Pointer>::const_iterator i = shaders.begin();
i != shaders.end(); ++i)
{
if ((*i)->GetName() == name) return i->GetPointer();
}
return IShaderRepository::Shader::Pointer();
}
mitk::IShaderRepository::Shader::Pointer mitk::ShaderRepository::GetShader(int id) const
{
for (std::list<Shader::Pointer>::const_iterator i = shaders.begin();
i != shaders.end(); ++i)
{
if ((*i)->GetId() == id) return i->GetPointer();
}
return IShaderRepository::Shader::Pointer();
}
diff --git a/Core/Code/Rendering/mitkShaderRepository.h b/Core/Code/Rendering/mitkShaderRepository.h
index f7c718065a..905352bf9c 100644
--- a/Core/Code/Rendering/mitkShaderRepository.h
+++ b/Core/Code/Rendering/mitkShaderRepository.h
@@ -1,196 +1,197 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITKSHADERREPOSITORY_H_
#define _MITKSHADERREPOSITORY_H_
#include <MitkExports.h>
#include "mitkIShaderRepository.h"
class vtkXMLDataElement;
class vtkProperty;
namespace mitk {
/**
* \brief Management class for vtkShader XML descriptions.
*
* Looks for all XML shader files in a given directory and adds default properties
* for each shader object (shader uniforms) to the specified mitk::DataNode.
*
* Additionally, it provides a utility function for applying properties for shaders
* in mappers.
*
* \deprecatedSince{2013_03} Use the micro service interface IShaderRepository instead.
*/
class MITK_CORE_EXPORT ShaderRepository : public itk::LightObject, public IShaderRepository
{
public:
mitkClassMacro( ShaderRepository, itk::LightObject )
itkFactorylessNewMacro( Self )
DEPRECATED(static ShaderRepository *GetGlobalShaderRepository());
/**
* \deprecatedSince{2013_03} Use IShaderRepository::Shader instead.
*/
class Shader : public IShaderRepository::Shader
{
public:
mitkClassMacro( Shader, itk::Object )
itkFactorylessNewMacro( Self )
class Uniform : public itk::Object
{
public:
mitkClassMacro( Uniform, itk::Object )
itkFactorylessNewMacro( Self )
enum Type
{
glsl_none,
glsl_float,
glsl_vec2,
glsl_vec3,
glsl_vec4,
glsl_int,
glsl_ivec2,
glsl_ivec3,
glsl_ivec4
};
/**
* Constructor
*/
Uniform();
/**
* Destructor
*/
~Uniform();
Type type;
std::string name;
int defaultInt[4];
float defaultFloat[4];
void LoadFromXML(vtkXMLDataElement *e);
};
std::list<Uniform::Pointer> uniforms;
/**
* Constructor
*/
Shader();
/**
* Destructor
*/
~Shader();
// DEPRECATED since 2013.03
std::string name;
// DEPRECATED since 2013.03
std::string path;
DEPRECATED(void LoadPropertiesFromPath());
Uniform *GetUniform(char * /*id*/) { return 0; }
std::list<Uniform::Pointer> *GetUniforms()
{
return &uniforms;
}
private:
friend class ShaderRepository;
void LoadProperties(vtkProperty* prop);
void LoadProperties(const std::string& path);
void LoadProperties(std::istream& stream);
};
protected:
std::list<Shader::Pointer> shaders;
void LoadShaders();
Shader::Pointer GetShaderImpl(const std::string& name) const;
/**
* Constructor
*/
ShaderRepository();
/**
* Destructor
*/
~ShaderRepository();
private:
static int shaderId;
+ static const bool debug;
public:
DEPRECATED(std::list<Shader::Pointer> *GetShaders())
{
return &shaders;
}
DEPRECATED(Shader *GetShader(const char *id) const);
std::list<IShaderRepository::Shader::Pointer> GetShaders() const;
IShaderRepository::Shader::Pointer GetShader(const std::string& name) const;
IShaderRepository::Shader::Pointer GetShader(int id) const;
/** \brief Adds all parsed shader uniforms to property list of the given DataNode;
* used by mappers.
*/
void AddDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) const;
/** \brief Applies shader and shader specific variables of the specified DataNode
* to the VTK object by updating the shader variables of its vtkProperty.
*/
void ApplyProperties(mitk::DataNode* node, vtkActor *actor, mitk::BaseRenderer* renderer,itk::TimeStamp &MTime) const;
/** \brief Loads a shader from a given file. Make sure that this file is in the XML shader format.
*/
DEPRECATED(int LoadShader(const std::string& filename));
int LoadShader(std::istream& stream, const std::string& name);
bool UnloadShader(int id);
};
} //end of namespace mitk
#endif
diff --git a/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp b/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
index 06cac2223f..28e61d3c84 100644
--- a/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
@@ -1,544 +1,544 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkGL.h>
#include "mitkSurfaceGLMapper2D.h"
#include "mitkBaseRenderer.h"
#include "mitkPlaneGeometry.h"
#include "mitkSurface.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkVtkScalarModeProperty.h"
#include "mitkAbstractTransformGeometry.h"
#include "mitkLookupTableProperty.h"
#include <vtkPolyData.h>
#include <vtkPlane.h>
#include <vtkCutter.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkLookupTable.h>
#include <vtkPointData.h>
#include <vtkCellData.h>
#include <vtkDataArray.h>
#include <vtkLinearTransform.h>
#include <vtkAbstractMapper.h>
#include <vtkPKdTree.h>
#include <vtkStripper.h>
mitk::SurfaceGLMapper2D::SurfaceGLMapper2D()
: m_Plane( vtkPlane::New() ),
m_Cutter( vtkCutter::New() ),
m_LUT( vtkLookupTable::New() ),
m_PointLocator( vtkPKdTree::New() ),
m_Stripper( vtkStripper::New() ),
m_DrawNormals(false),
m_FrontNormalLengthInPixels(10.0),
m_BackNormalLengthInPixels(10.0)
{
// default for normals on front side = green
m_FrontSideColor[0] = 0.0;
m_FrontSideColor[1] = 1.0;
m_FrontSideColor[2] = 0.0;
m_FrontSideColor[3] = 1.0;
// default for normals on back side = red
m_BackSideColor[0] = 1.0;
m_BackSideColor[1] = 0.0;
m_BackSideColor[2] = 0.0;
m_BackSideColor[3] = 1.0;
// default for line color = yellow
m_LineColor[0] = 1.0;
m_LineColor[1] = 1.0;
m_LineColor[2] = 0.0;
m_LineColor[3] = 1.0;
m_Cutter->SetCutFunction(m_Plane);
m_Cutter->GenerateValues(1,0,1);
m_LUT->SetTableRange(0,255);
m_LUT->SetNumberOfColors(255);
m_LUT->SetRampToLinear();
m_LUT->Build();
}
mitk::SurfaceGLMapper2D::~SurfaceGLMapper2D()
{
m_Plane->Delete();
m_Cutter->Delete();
m_LUT->Delete();
m_PointLocator->Delete();
m_Stripper->Delete();
}
const mitk::Surface *mitk::SurfaceGLMapper2D::GetInput(void)
{
if(m_Surface.IsNotNull())
return m_Surface;
return static_cast<const Surface * > ( GetDataNode()->GetData() );
}
void mitk::SurfaceGLMapper2D::SetDataNode( mitk::DataNode* node )
{
Superclass::SetDataNode( node );
bool useCellData;
if (dynamic_cast<BoolProperty *>(node->GetProperty("deprecated useCellDataForColouring")) == NULL)
useCellData = false;
else
useCellData = dynamic_cast<BoolProperty *>(node->GetProperty("deprecated useCellDataForColouring"))->GetValue();
if (!useCellData)
{
// search min/max point scalars over all time steps
vtkFloatingPointType dataRange[2] = {0,0};
vtkFloatingPointType range[2];
Surface::Pointer input = const_cast< Surface* >(dynamic_cast<const Surface*>( this->GetDataNode()->GetData() ));
if(input.IsNull()) return;
const TimeSlicedGeometry::Pointer inputTimeGeometry = input->GetTimeSlicedGeometry();
if(( inputTimeGeometry.IsNull() ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) ) return;
for (unsigned int timestep=0; timestep<inputTimeGeometry->GetTimeSteps(); timestep++)
{
vtkPolyData * vtkpolydata = input->GetVtkPolyData( timestep );
if((vtkpolydata==NULL) || (vtkpolydata->GetNumberOfPoints() < 1 )) continue;
vtkDataArray *vpointscalars = vtkpolydata->GetPointData()->GetScalars();
if (vpointscalars) {
vpointscalars->GetRange( range, 0 );
if (dataRange[0]==0 && dataRange[1]==0) {
dataRange[0] = range[0];
dataRange[1] = range[1];
}
else {
if (range[0] < dataRange[0]) dataRange[0] = range[0];
if (range[1] > dataRange[1]) dataRange[1] = range[1];
}
}
}
if (dataRange[1] - dataRange[0] > 0) {
m_LUT->SetTableRange( dataRange );
m_LUT->Build();
}
}
}
void mitk::SurfaceGLMapper2D::Paint(mitk::BaseRenderer * renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if(!visible) return;
Surface::Pointer input = const_cast<Surface*>(this->GetInput());
if(input.IsNull())
return;
//
// get the TimeSlicedGeometry of the input object
//
const TimeSlicedGeometry* inputTimeGeometry = input->GetTimeSlicedGeometry();
if(( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) )
return;
if (dynamic_cast<IntProperty *>(this->GetDataNode()->GetProperty("line width")) == NULL)
m_LineWidth = 1;
else
m_LineWidth = dynamic_cast<IntProperty *>(this->GetDataNode()->GetProperty("line width"))->GetValue();
//
// get the world time
//
Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
assert( worldGeometry.IsNotNull() );
ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
int timestep=0;
if( time > ScalarTypeNumericTraits::NonpositiveMin() )
timestep = inputTimeGeometry->MSToTimeStep( time );
// int timestep = this->GetTimestep();
if( inputTimeGeometry->IsValidTime( timestep ) == false )
return;
vtkPolyData * vtkpolydata = input->GetVtkPolyData( timestep );
if((vtkpolydata==NULL) || (vtkpolydata->GetNumberOfPoints() < 1 ))
return;
PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>(worldGeometry.GetPointer());
//apply color and opacity read from the PropertyList
this->ApplyAllProperties(renderer);
if (m_DrawNormals)
{
m_PointLocator->SetDataSet( vtkpolydata );
m_PointLocator->BuildLocatorFromPoints( vtkpolydata->GetPoints() );
}
if(vtkpolydata!=NULL)
{
Point3D point;
Vector3D normal;
//Check if Lookup-Table is already given, else use standard one.
vtkFloatingPointType* scalarLimits = m_LUT->GetTableRange();
vtkFloatingPointType scalarsMin = scalarLimits[0], scalarsMax = scalarLimits[1];
vtkLookupTable *lut;// = vtkLookupTable::New();
LookupTableProperty::Pointer lookupTableProp;
this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer);
if (lookupTableProp.IsNotNull() )
{
lut = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
if (dynamic_cast<FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
scalarsMin = dynamic_cast<FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();
if (dynamic_cast<FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
scalarsMax = dynamic_cast<FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();
// check if the scalar range has been changed, e.g. manually, for the data tree node, and rebuild the LUT if necessary.
double* oldRange = lut->GetTableRange();
if( oldRange[0] != scalarsMin || oldRange[1] != scalarsMax )
{
lut->SetTableRange(scalarsMin, scalarsMax);
lut->Build();
}
}
else
{
lut = m_LUT;
}
vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform(timestep);
if(worldPlaneGeometry.IsNotNull())
{
// set up vtkPlane according to worldGeometry
point=worldPlaneGeometry->GetOrigin();
normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
m_Plane->SetTransform((vtkAbstractTransform*)NULL);
}
else
{
AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldGeometry2D());
if(worldAbstractGeometry.IsNotNull())
{
AbstractTransformGeometry::ConstPointer surfaceAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(input->GetTimeSlicedGeometry()->GetGeometry3D(0));
if(surfaceAbstractGeometry.IsNotNull()) //@todo substitude by operator== after implementation, see bug id 28
{
PaintCells(renderer, vtkpolydata, worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut);
return;
}
else
{
//@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "flat plane" into a "curved plane"?
return;
// set up vtkPlane according to worldGeometry
point=const_cast<BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
FillVector3D(normal, 0, 0, 1);
m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
}
}
else
return;
}
vtkFloatingPointType vp[3], vnormal[3];
- vnl2vtk(point.Get_vnl_vector(), vp);
- vnl2vtk(normal.Get_vnl_vector(), vnormal);
+ vnl2vtk(point.GetVnlVector(), vp);
+ vnl2vtk(normal.GetVnlVector(), vnormal);
//normally, we would need to transform the surface and cut the transformed surface with the cutter.
//This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
//@todo It probably does not work for scaling operations yet:scaling operations have to be
//dealed with after the cut is performed by scaling the contour.
vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
inversetransform->TransformPoint(vp, vp);
inversetransform->TransformNormalAtPoint(vp, vnormal, vnormal);
m_Plane->SetOrigin(vp);
m_Plane->SetNormal(vnormal);
//set data into cutter
m_Cutter->SetInput(vtkpolydata);
m_Cutter->Update();
// m_Cutter->GenerateCutScalarsOff();
// m_Cutter->SetSortByToSortByCell();
if (m_DrawNormals)
{
m_Stripper->SetInput( m_Cutter->GetOutput() );
// calculate the cut
m_Stripper->Update();
PaintCells(renderer, m_Stripper->GetOutput(), worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut, vtkpolydata);
}
else
{
PaintCells(renderer, m_Cutter->GetOutput(), worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut, vtkpolydata);
}
}
}
void mitk::SurfaceGLMapper2D::PaintCells(mitk::BaseRenderer* renderer, vtkPolyData* contour,
const Geometry2D* worldGeometry,
const DisplayGeometry* displayGeometry,
vtkLinearTransform * vtktransform,
vtkLookupTable *lut,
vtkPolyData* original3DObject)
{
// deprecated settings
bool usePointData = false;
bool useCellData = false;
this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", useCellData);
bool scalarVisibility = false;
this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility);
if(scalarVisibility)
{
VtkScalarModeProperty* scalarMode;
if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
{
if( (scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA) ||
(scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT) )
{
usePointData = true;
}
if(scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA)
{
useCellData = true;
}
}
else
{
usePointData = true;
}
}
vtkPoints *vpoints = contour->GetPoints();
vtkDataArray *vpointscalars = contour->GetPointData()->GetScalars();
vtkCellArray *vlines = contour->GetLines();
vtkDataArray* vcellscalars = contour->GetCellData()->GetScalars();
Point3D p; Point2D p2d, last;
int i, j;
int numberOfLines = vlines->GetNumberOfCells();
glLineWidth( m_LineWidth );
glBegin (GL_LINES);
glColor4fv(m_LineColor);
double distanceSinceLastNormal(0.0);
vlines->InitTraversal();
for(i=0;i<numberOfLines;++i)
{
vtkIdType *cell(NULL);
vtkIdType cellSize(0);
vtkFloatingPointType vp[3];
vlines->GetNextCell(cellSize, cell);
vpoints->GetPoint(cell[0], vp);
//take transformation via vtktransform into account
vtktransform->TransformPoint(vp, vp);
vtk2itk(vp, p);
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map(p, p2d);
//convert point (until now mm and in world coordinates) to display coordinates (units )
displayGeometry->WorldToDisplay(p2d, p2d);
last=p2d;
for(j=1; j<cellSize; ++j)
{
vpoints->GetPoint(cell[j], vp);
Point3D originalPoint;
vtk2itk(vp, originalPoint);
//take transformation via vtktransform into account
vtktransform->TransformPoint(vp, vp);
vtk2itk(vp, p);
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map(p, p2d);
//convert point (until now mm and in world coordinates) to display coordinates (units )
displayGeometry->WorldToDisplay(p2d, p2d);
vtkFloatingPointType color[3];
if (useCellData && vcellscalars != NULL )
{
// color each cell according to cell data
lut->GetColor( vcellscalars->GetComponent(i,0),color);
glColor3f(color[0],color[1],color[2]);
glVertex2f(last[0], last[1]);
glVertex2f(p2d[0], p2d[1]);
}
else if (usePointData && vpointscalars != NULL )
{
lut->GetColor( vpointscalars->GetComponent(cell[j-1],0),color);
glColor3f(color[0],color[1],color[2]);
glVertex2f(last[0], last[1]);
lut->GetColor( vpointscalars->GetComponent(cell[j],0),color);
glColor3f(color[0],color[1],color[2]);
glVertex2f(p2d[0], p2d[1]);
}
else
{
glVertex2f(last[0], last[1]);
glVertex2f(p2d[0], p2d[1]);
// draw normals ?
if (m_DrawNormals && original3DObject)
{
distanceSinceLastNormal += sqrt((p2d[0]-last[0])*(p2d[0]-last[0]) + (p2d[1]-last[1])*(p2d[1]-last[1]));
if (distanceSinceLastNormal >= 5.0)
{
distanceSinceLastNormal = 0.0;
vtkPointData* pointData = original3DObject->GetPointData();
if (!pointData) break;
vtkDataArray* normalsArray = pointData->GetNormals();
if (!normalsArray) break;
// find 3D point closest to the currently drawn point
double distance(0.0);
vtkIdType closestPointId = m_PointLocator->FindClosestPoint(originalPoint[0], originalPoint[1], originalPoint[2], distance);
if (closestPointId >= 0)
{
// find normal of 3D object at this 3D point
double* normal = normalsArray->GetTuple3(closestPointId);
double transformedNormal[3];
vtktransform->TransformNormal(normal, transformedNormal);
Vector3D normalITK;
vtk2itk(transformedNormal, normalITK);
normalITK.Normalize();
// calculate a point (point from the cut 3D object) + (normal vector of closest point)
Point3D tip3D = p + normalITK;
// map this point into our 2D coordinate system
Point2D tip2D;
worldGeometry->Map(tip3D, tip2D);
displayGeometry->WorldToDisplay(tip2D, tip2D);
// calculate 2D vector from point to point+normal, normalize it to standard length
Vector2D tipVectorGLFront = tip2D - p2d;
tipVectorGLFront.Normalize();
tipVectorGLFront *= m_FrontNormalLengthInPixels;
Vector2D tipVectorGLBack = p2d - tip2D;
tipVectorGLBack.Normalize();
tipVectorGLBack *= m_BackNormalLengthInPixels;
Point2D tipPoint2D = p2d + tipVectorGLFront;
Point2D backTipPoint2D = p2d + tipVectorGLBack;
// draw normalized mapped normal vector
glColor4f(m_BackSideColor[0], m_BackSideColor[1], m_BackSideColor[2], m_BackSideColor[3]); // red backside
glVertex2f(p2d[0], p2d[1]);
glVertex2f(tipPoint2D[0], tipPoint2D[1]);
glColor4f(m_FrontSideColor[0], m_FrontSideColor[1], m_FrontSideColor[2], m_FrontSideColor[3]); // green backside
glVertex2f(p2d[0], p2d[1]);
glVertex2f(backTipPoint2D[0], backTipPoint2D[1]);
glColor4fv(m_LineColor); // back to line color
}
}
}
}
last=p2d;
}
}
glEnd();
glLineWidth(1.0);
}
void mitk::SurfaceGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "line width", IntProperty::New(2), renderer, overwrite );
node->AddProperty( "scalar mode", VtkScalarModeProperty::New(), renderer, overwrite );
node->AddProperty( "draw normals 2D", BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "invert normals", BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "front color", ColorProperty::New(0.0, 1.0, 0.0), renderer, overwrite );
node->AddProperty( "back color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite );
node->AddProperty( "front normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
node->AddProperty( "back normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
node->AddProperty( "layer", mitk::IntProperty::New(100), renderer, overwrite);
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
void mitk::SurfaceGLMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
{
ApplyColorAndOpacityProperties(renderer);
DataNode * node = GetDataNode();
if(node == NULL)
{
return;
}
node->GetBoolProperty("draw normals 2D", m_DrawNormals, renderer);
// check for color and opacity properties, use it for rendering if they exists
node->GetColor(m_LineColor, renderer, "color");
node->GetOpacity(m_LineColor[3], renderer, "opacity");
bool invertNormals(false);
node->GetBoolProperty("invert normals", invertNormals, renderer);
if (!invertNormals)
{
node->GetColor(m_FrontSideColor, renderer, "front color");
node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
node->GetColor(m_BackSideColor, renderer, "back color");
node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
node->GetFloatProperty( "front normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
node->GetFloatProperty( "back normal lenth (px)", m_BackNormalLengthInPixels, renderer );
}
else
{
node->GetColor(m_FrontSideColor, renderer, "back color");
node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
node->GetColor(m_BackSideColor, renderer, "front color");
node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
node->GetFloatProperty( "back normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
node->GetFloatProperty( "front normal lenth (px)", m_BackNormalLengthInPixels, renderer );
}
}
diff --git a/Core/Code/Rendering/mitkSurfaceVtkMapper3D.h b/Core/Code/Rendering/mitkSurfaceVtkMapper3D.h
index b460eae2f8..3e379a11be 100644
--- a/Core/Code/Rendering/mitkSurfaceVtkMapper3D.h
+++ b/Core/Code/Rendering/mitkSurfaceVtkMapper3D.h
@@ -1,162 +1,164 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKSURFACEDATAVTKMAPPER3D_H_HEADER_INCLUDED_C1907273
#define MITKSURFACEDATAVTKMAPPER3D_H_HEADER_INCLUDED_C1907273
#include <MitkExports.h>
#include "mitkVtkMapper.h"
#include "mitkSurface.h"
#include "mitkBaseRenderer.h"
+#include "mitkLocalStorageHandler.h"
#include <vtkActor.h>
#include <vtkOpenGLPolyDataMapper.h>
#include <vtkPainterPolyDataMapper.h>
#include <vtkPolyDataMapper.h>
#include <vtkPolyDataNormals.h>
#include <vtkPlaneCollection.h>
+
namespace mitk {
//##Documentation
//## @brief Vtk-based mapper for Surface
//##
//## @ingroup Mapper
/**
* @brief Vtk-based mapper for Surface
*
* Properties that can be set for surfaces and influence the surfaceVTKMapper3D are:
*
* - \b "Backface Culling": True enables backface culling, which means only front-facing polygons will be visualized. False/disabled by default.
* - \b "color": (ColorProperty) Diffuse color of the surface object (this property will be read when material.diffuseColor is not defined)
* - \b "Opacity": (FloatProperty) Opacity of the surface object
* - \b "material.ambientColor": (ColorProperty) Ambient color of the surface object
* - \b "material.ambientCoefficient": ( FloatProperty) Ambient coefficient of the surface object
* - \b "material.diffuseColor": ( ColorProperty) Diffuse color of the surface object
* - \b "material.diffuseCoefficient": (FloatProperty) Diffuse coefficient of the surface object
* - \b "material.specularColor": (ColorProperty) Specular Color of the surface object
* - \b "material.specularCoefficient": (FloatProperty) Specular coefficient of the surface object
* - \b "material.specularPower": (FloatProperty) Specular power of the surface object
* - \b "material.interpolation": (VtkInterpolationProperty) Interpolation
* - \b "material.representation": (VtkRepresentationProperty*) Representation
* - \b "material.wireframeLineWidth": (FloatProperty) Width in pixels of the lines drawn.
* - \b "scalar visibility": (BoolProperty) If the scarlars of the surface are visible
* Properties to look for are:
*
* - \b "scalar visibility": if set to on, scalars assigned to the data are shown
* Turn this on if using a lookup table.
* - \b "ScalarsRangeMinimum": Optional. Can be used to store the scalar min, e.g.
* for the level window settings.
* - \b "ScalarsRangeMaximum": Optional. See above.
*
* There might be still some other, deprecated properties. These will not be documented anymore.
* Please check the source if you really need them.
*
* @ingroup Mapper
*/
class MITK_CORE_EXPORT SurfaceVtkMapper3D : public VtkMapper
{
public:
mitkClassMacro(SurfaceVtkMapper3D, VtkMapper);
itkNewMacro(Self);
itkSetMacro(GenerateNormals, bool);
itkGetMacro(GenerateNormals, bool);
//enable ImmediateModeRendering for vtkMapping
//yet to solve bug 1398
void SetImmediateModeRenderingOn(int on = 1);
itkGetMacro(ImmediateModeRenderingOn, int);
virtual const mitk::Surface* GetInput();
virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer);
virtual void ApplyAllProperties(mitk::BaseRenderer* renderer, vtkActor* actor);
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
protected:
SurfaceVtkMapper3D();
virtual ~SurfaceVtkMapper3D();
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
virtual void ResetMapper( mitk::BaseRenderer* renderer );
/** Checks whether the specified property is a ClippingProperty and if yes,
* adds it to m_ClippingPlaneCollection (internal method). */
virtual void CheckForClippingProperty( mitk::BaseRenderer* renderer, mitk::BaseProperty *property );
bool m_GenerateNormals;
//enable ImmediateModeRendering for the vtkMapper
int m_ImmediateModeRenderingOn;
public:
class LocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
vtkActor* m_Actor;
vtkPolyDataMapper *m_VtkPolyDataMapper;
vtkPolyDataNormals *m_VtkPolyDataNormals;
vtkPlaneCollection *m_ClippingPlaneCollection;
itk::TimeStamp m_ShaderTimestampUpdate;
LocalStorage()
{
m_VtkPolyDataMapper = vtkOpenGLPolyDataMapper::New();
m_VtkPolyDataNormals = vtkPolyDataNormals::New();
m_Actor = vtkActor::New();
m_ClippingPlaneCollection = vtkPlaneCollection::New();
m_Actor->SetMapper(m_VtkPolyDataMapper);
}
~LocalStorage()
{
m_VtkPolyDataMapper->Delete();
m_VtkPolyDataNormals->Delete();
m_Actor->Delete();
m_ClippingPlaneCollection->Delete();
}
};
- mitk::Mapper::LocalStorageHandler<LocalStorage> m_LSH;
+ mitk::LocalStorageHandler<LocalStorage> m_LSH;
static void ApplyMitkPropertiesToVtkProperty(mitk::DataNode *node, vtkProperty* property, mitk::BaseRenderer* renderer);
static void SetDefaultPropertiesForVtkProperty(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite);
};
} // namespace mitk
#endif /* MITKSURFACEDATAVTKMAPPER3D_H_HEADER_INCLUDED_C1907273 */
diff --git a/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp b/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp
index a99ea97659..60530329ef 100644
--- a/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp
@@ -1,707 +1,707 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkVolumeDataVtkMapper3D.h"
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include "mitkLevelWindow.h"
#include "mitkColorProperty.h"
#include "mitkLevelWindowProperty.h"
#include "mitkLookupTableProperty.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkTransferFunctionInitializer.h"
#include "mitkColorProperty.h"
#include "mitkVtkPropRenderer.h"
#include "mitkRenderingManager.h"
#include <vtkActor.h>
#include <vtkProperty.h>
#include <vtkVolumeRayCastMapper.h>
#include <vtkVolumeTextureMapper2D.h>
#include <vtkVolume.h>
#include <vtkVolumeProperty.h>
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
#include <vtkVolumeRayCastCompositeFunction.h>
#include <vtkVolumeRayCastMIPFunction.h>
#include <vtkFiniteDifferenceGradientEstimator.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkImageShiftScale.h>
#include <vtkImageChangeInformation.h>
#include <vtkImageWriter.h>
#include <vtkImageData.h>
#include <vtkLODProp3D.h>
#include <vtkImageResample.h>
#include <vtkPlane.h>
#include <vtkImplicitPlaneWidget.h>
#include <vtkAssembly.h>
#include <vtkCubeSource.h>
#include <vtkPolyDataMapper.h>
#include "mitkVtkVolumeRenderingProperty.h"
#include <itkMultiThreader.h>
const mitk::Image* mitk::VolumeDataVtkMapper3D::GetInput()
{
return static_cast<const mitk::Image*> ( GetDataNode()->GetData() );
}
mitk::VolumeDataVtkMapper3D::VolumeDataVtkMapper3D()
: m_Mask( NULL )
{
m_PlaneSet = false;
m_ClippingPlane = vtkPlane::New();
m_PlaneWidget = vtkImplicitPlaneWidget::New();
/*
m_T2DMapper = vtkVolumeTextureMapper2D::New();
m_T2DMapper->SetMaximumNumberOfPlanes( 100 );
*/
m_HiResMapper = vtkVolumeRayCastMapper::New();
m_HiResMapper->SetSampleDistance(1.0); // 4 rays for every pixel
m_HiResMapper->IntermixIntersectingGeometryOn();
m_HiResMapper->SetNumberOfThreads( itk::MultiThreader::GetGlobalDefaultNumberOfThreads() );
/*
vtkVolumeRayCastCompositeFunction* compositeFunction = vtkVolumeRayCastCompositeFunction::New();
compositeFunction->SetCompositeMethodToClassifyFirst();
m_HiResMapper->SetVolumeRayCastFunction(compositeFunction);
compositeFunction->Delete();
vtkVolumeRayCastMIPFunction* mipFunction = vtkVolumeRayCastMIPFunction::New();
m_HiResMapper->SetVolumeRayCastFunction(mipFunction);
mipFunction->Delete();
*/
vtkFiniteDifferenceGradientEstimator* gradientEstimator =
vtkFiniteDifferenceGradientEstimator::New();
m_HiResMapper->SetGradientEstimator(gradientEstimator);
gradientEstimator->Delete();
m_VolumePropertyLow = vtkVolumeProperty::New();
m_VolumePropertyMed = vtkVolumeProperty::New();
m_VolumePropertyHigh = vtkVolumeProperty::New();
m_VolumeLOD = vtkLODProp3D::New();
m_VolumeLOD->VisibilityOff();
m_HiResID = m_VolumeLOD->AddLOD(m_HiResMapper,m_VolumePropertyHigh,0.0); // RayCast
// m_LowResID = m_VolumeLOD->AddLOD(m_T2DMapper,m_VolumePropertyLow,0.0); // TextureMapper2D
m_MedResID = m_VolumeLOD->AddLOD(m_HiResMapper,m_VolumePropertyMed,0.0); // RayCast
m_Resampler = vtkImageResample::New();
m_Resampler->SetAxisMagnificationFactor(0,0.25);
m_Resampler->SetAxisMagnificationFactor(1,0.25);
m_Resampler->SetAxisMagnificationFactor(2,0.25);
// For abort rendering mechanism
m_VolumeLOD->AutomaticLODSelectionOff();
m_BoundingBox = vtkCubeSource::New();
m_BoundingBox->SetXLength( 0.0 );
m_BoundingBox->SetYLength( 0.0 );
m_BoundingBox->SetZLength( 0.0 );
m_BoundingBoxMapper = vtkPolyDataMapper::New();
m_BoundingBoxMapper->SetInput( m_BoundingBox->GetOutput() );
m_BoundingBoxActor = vtkActor::New();
m_BoundingBoxActor->SetMapper( m_BoundingBoxMapper );
m_BoundingBoxActor->GetProperty()->SetColor( 1.0, 1.0, 1.0 );
m_BoundingBoxActor->GetProperty()->SetRepresentationToWireframe();
// BoundingBox rendering is not working due to problem with assembly
// transformation; see bug #454
// If commenting in the following, do not forget to comment in the
// m_Prop3DAssembly->Delete() line in the destructor.
//m_Prop3DAssembly = vtkAssembly::New();
//m_Prop3DAssembly->AddPart( m_VolumeLOD );
//m_Prop3DAssembly->AddPart( m_BoundingBoxActor );
//m_Prop3D = m_Prop3DAssembly;
m_ImageCast = vtkImageShiftScale::New();
m_ImageCast->SetOutputScalarTypeToUnsignedShort();
m_ImageCast->ClampOverflowOn();
m_UnitSpacingImageFilter = vtkImageChangeInformation::New();
m_UnitSpacingImageFilter->SetInput(m_ImageCast->GetOutput());
m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
m_ImageMaskFilter = vtkImageMask::New();
m_ImageMaskFilter->SetMaskedOutputValue(0xffff);
this->m_Resampler->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
this->m_HiResMapper->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
// m_T2DMapper->SetInput(m_Resampler->GetOutput());
this->CreateDefaultTransferFunctions();
}
vtkProp *mitk::VolumeDataVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
{
return m_VolumeLOD;
}
mitk::VolumeDataVtkMapper3D::~VolumeDataVtkMapper3D()
{
m_UnitSpacingImageFilter->Delete();
m_ImageCast->Delete();
// m_T2DMapper->Delete();
m_HiResMapper->Delete();
m_Resampler->Delete();
m_VolumePropertyLow->Delete();
m_VolumePropertyMed->Delete();
m_VolumePropertyHigh->Delete();
m_VolumeLOD->Delete();
m_ClippingPlane->Delete();
m_PlaneWidget->Delete();
// m_Prop3DAssembly->Delete();
m_BoundingBox->Delete();
m_BoundingBoxMapper->Delete();
m_BoundingBoxActor->Delete();
m_ImageMaskFilter->Delete();
m_DefaultColorTransferFunction->Delete();
m_DefaultOpacityTransferFunction->Delete();
m_DefaultGradientTransferFunction->Delete();
if (m_Mask)
{
m_Mask->Delete();
}
}
void mitk::VolumeDataVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
SetVtkMapperImmediateModeRendering(m_BoundingBoxMapper);
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
if ( !input || !input->IsInitialized() )
return;
vtkRenderWindow* renderWindow = renderer->GetRenderWindow();
bool volumeRenderingEnabled = true;
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible ||
this->GetDataNode() == NULL ||
dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))==NULL ||
dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))->GetValue() == false
)
{
volumeRenderingEnabled = false;
// Check if a bounding box should be displayed around the dataset
// (even if volume rendering is disabled)
bool hasBoundingBox = false;
this->GetDataNode()->GetBoolProperty( "bounding box", hasBoundingBox );
if ( !hasBoundingBox )
{
m_BoundingBoxActor->VisibilityOff();
}
else
{
m_BoundingBoxActor->VisibilityOn();
const BoundingBox::BoundsArrayType &bounds =
input->GetTimeSlicedGeometry()->GetBounds();
m_BoundingBox->SetBounds(
bounds[0], bounds[1],
bounds[2], bounds[3],
bounds[4], bounds[5] );
ColorProperty *colorProperty;
if ( this->GetDataNode()->GetProperty(
colorProperty, "color" ) )
{
const mitk::Color &color = colorProperty->GetColor();
m_BoundingBoxActor->GetProperty()->SetColor(
color[0], color[1], color[2] );
}
else
{
m_BoundingBoxActor->GetProperty()->SetColor(
1.0, 1.0, 1.0 );
}
}
}
// Don't do anything if VR is disabled
if ( !volumeRenderingEnabled )
{
m_VolumeLOD->VisibilityOff();
return;
}
else
{
mitk::VtkVolumeRenderingProperty* vrp=dynamic_cast<mitk::VtkVolumeRenderingProperty*>(GetDataNode()->GetProperty("volumerendering configuration",renderer));
if(vrp)
{
int renderingValue = vrp->GetValueAsId();
switch(renderingValue)
{
case VTK_VOLUME_RAY_CAST_MIP_FUNCTION:
{
vtkVolumeRayCastMIPFunction* mipFunction = vtkVolumeRayCastMIPFunction::New();
m_HiResMapper->SetVolumeRayCastFunction(mipFunction);
mipFunction->Delete();
MITK_INFO <<"in switch" <<std::endl;
break;
}
case VTK_RAY_CAST_COMPOSITE_FUNCTION:
{
vtkVolumeRayCastCompositeFunction* compositeFunction = vtkVolumeRayCastCompositeFunction::New();
compositeFunction->SetCompositeMethodToClassifyFirst();
m_HiResMapper->SetVolumeRayCastFunction(compositeFunction);
compositeFunction->Delete();
break;
}
default:
MITK_ERROR <<"Warning: invalid volume rendering option. " << std::endl;
}
}
m_VolumeLOD->VisibilityOn();
}
this->SetPreferences();
/*
switch ( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) )
{
case 0:
m_VolumeLOD->SetSelectedLODID(m_MedResID); m_LowResID );
break;
default:
case 1:
m_VolumeLOD->SetSelectedLODID( m_HiResID );
break;
}
*/
m_VolumeLOD->SetSelectedLODID( m_HiResID );
assert(input->GetTimeSlicedGeometry());
const Geometry3D* worldgeometry = renderer->GetCurrentWorldGeometry();
if(worldgeometry==NULL)
{
GetDataNode()->SetProperty("volumerendering",mitk::BoolProperty::New(false));
return;
}
vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
if(inputData==NULL)
return;
m_ImageCast->SetInput( inputData );
//If mask exists, process mask before resampling.
if (this->m_Mask)
{
this->m_ImageMaskFilter->SetImageInput(this->m_UnitSpacingImageFilter->GetOutput());
this->m_Resampler->SetInput(this->m_ImageMaskFilter->GetOutput());
this->m_HiResMapper->SetInput(this->m_ImageMaskFilter->GetOutput());
}
else
{
this->m_Resampler->SetInput(this->m_UnitSpacingImageFilter->GetOutput());
this->m_HiResMapper->SetInput(this->m_UnitSpacingImageFilter->GetOutput());
}
this->UpdateTransferFunctions( renderer );
vtkRenderWindowInteractor *interactor = renderWindow->GetInteractor();
float frameRate;
if( this->GetDataNode()->GetFloatProperty( "framerate", frameRate ) && frameRate > 0 && frameRate <= 60)
{
interactor->SetDesiredUpdateRate( frameRate );
interactor->SetStillUpdateRate( frameRate );
}
else if( frameRate > 60 )
{
this->GetDataNode()->SetProperty( "framerate",mitk::FloatProperty::New(60));
interactor->SetDesiredUpdateRate( 60 );
interactor->SetStillUpdateRate( 60 );
}
else
{
this->GetDataNode()->SetProperty( "framerate",mitk::FloatProperty::New(0.00001));
interactor->SetDesiredUpdateRate( 0.00001 );
interactor->SetStillUpdateRate( 0.00001 );
}
if ( m_RenderWindowInitialized.find( renderWindow ) == m_RenderWindowInitialized.end() )
{
m_RenderWindowInitialized.insert( renderWindow );
// mitk::RenderingManager::GetInstance()->SetNextLOD( 0, renderer );
mitk::RenderingManager::GetInstance()->SetShading( true, 0 );
mitk::RenderingManager::GetInstance()->SetShading( true, 1 );
//mitk::RenderingManager::GetInstance()->SetShading( true, 2 );
mitk::RenderingManager::GetInstance()->SetShadingValues(
m_VolumePropertyHigh->GetAmbient(),
m_VolumePropertyHigh->GetDiffuse(),
m_VolumePropertyHigh->GetSpecular(),
m_VolumePropertyHigh->GetSpecularPower());
mitk::RenderingManager::GetInstance()->SetClippingPlaneStatus(false);
}
this->SetClippingPlane( interactor );
}
void mitk::VolumeDataVtkMapper3D::CreateDefaultTransferFunctions()
{
m_DefaultOpacityTransferFunction = vtkPiecewiseFunction::New();
m_DefaultOpacityTransferFunction->AddPoint( 0.0, 0.0 );
m_DefaultOpacityTransferFunction->AddPoint( 255.0, 0.8 );
m_DefaultOpacityTransferFunction->ClampingOn();
m_DefaultGradientTransferFunction = vtkPiecewiseFunction::New();
m_DefaultGradientTransferFunction->AddPoint( 0.0, 0.0 );
m_DefaultGradientTransferFunction->AddPoint( 255.0, 0.8 );
m_DefaultGradientTransferFunction->ClampingOn();
m_DefaultColorTransferFunction = vtkColorTransferFunction::New();
m_DefaultColorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
m_DefaultColorTransferFunction->AddRGBPoint( 127.5, 1, 1, 0.0 );
m_DefaultColorTransferFunction->AddRGBPoint( 255.0, 0.8, 0.2, 0 );
m_DefaultColorTransferFunction->ClampingOn();
}
void mitk::VolumeDataVtkMapper3D::UpdateTransferFunctions( mitk::BaseRenderer *renderer )
{
vtkPiecewiseFunction *opacityTransferFunction = NULL;
vtkPiecewiseFunction *gradientTransferFunction = NULL;
vtkColorTransferFunction *colorTransferFunction = NULL;
mitk::LookupTableProperty::Pointer lookupTableProp;
lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(this->GetDataNode()->GetProperty("LookupTable"));
mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("TransferFunction"));
if ( transferFunctionProp.IsNotNull() ) {
opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
}
else if (lookupTableProp.IsNotNull() )
{
lookupTableProp->GetLookupTable()->CreateOpacityTransferFunction(opacityTransferFunction);
opacityTransferFunction->ClampingOn();
lookupTableProp->GetLookupTable()->CreateGradientTransferFunction(gradientTransferFunction);
gradientTransferFunction->ClampingOn();
lookupTableProp->GetLookupTable()->CreateColorTransferFunction(colorTransferFunction);
colorTransferFunction->ClampingOn();
}
else
{
opacityTransferFunction = m_DefaultOpacityTransferFunction;
gradientTransferFunction = m_DefaultGradientTransferFunction;
colorTransferFunction = m_DefaultColorTransferFunction;
float rgb[3]={1.0f,1.0f,1.0f};
// check for color prop and use it for rendering if it exists
if(GetDataNode()->GetColor(rgb, renderer, "color"))
{
colorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
colorTransferFunction->AddRGBPoint( 127.5, rgb[0], rgb[1], rgb[2] );
colorTransferFunction->AddRGBPoint( 255.0, rgb[0], rgb[1], rgb[2] );
}
}
if (this->m_Mask)
{
opacityTransferFunction->AddPoint(0xffff, 0.0);
}
m_VolumePropertyLow->SetColor( colorTransferFunction );
m_VolumePropertyLow->SetScalarOpacity( opacityTransferFunction );
m_VolumePropertyLow->SetGradientOpacity( gradientTransferFunction );
m_VolumePropertyLow->SetInterpolationTypeToNearest();
m_VolumePropertyMed->SetColor( colorTransferFunction );
m_VolumePropertyMed->SetScalarOpacity( opacityTransferFunction );
m_VolumePropertyMed->SetGradientOpacity( gradientTransferFunction );
m_VolumePropertyMed->SetInterpolationTypeToNearest();
m_VolumePropertyHigh->SetColor( colorTransferFunction );
m_VolumePropertyHigh->SetScalarOpacity( opacityTransferFunction );
m_VolumePropertyHigh->SetGradientOpacity( gradientTransferFunction );
m_VolumePropertyHigh->SetInterpolationTypeToLinear();
}
/* Shading enabled / disabled */
void mitk::VolumeDataVtkMapper3D::SetPreferences()
{
//LOD 0
/*if(mitk::RenderingManager::GetInstance()->GetShading(0))
{
m_VolumePropertyLow->ShadeOn();
m_VolumePropertyLow->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
m_VolumePropertyLow->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
m_VolumePropertyLow->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
m_VolumePropertyLow->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
}
else*/
{
m_VolumePropertyLow->ShadeOff();
}
//LOD 1
/*if(mitk::RenderingManager::GetInstance()->GetShading(1))
{
m_VolumePropertyMed->ShadeOn();
m_VolumePropertyMed->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
m_VolumePropertyMed->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
m_VolumePropertyMed->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
m_VolumePropertyMed->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
}
else*/
{
m_VolumePropertyMed->ShadeOff();
}
//LOD 2
/*
if(mitk::RenderingManager::GetInstance()->GetShading(2))
{
m_VolumePropertyHigh->ShadeOn();
//Shading Properties
m_VolumePropertyHigh->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
m_VolumePropertyHigh->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
m_VolumePropertyHigh->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
m_VolumePropertyHigh->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
}
else
{
m_VolumePropertyHigh->ShadeOff();
}
*/
}
/* Adds A Clipping Plane to the Mapper */
void mitk::VolumeDataVtkMapper3D::SetClippingPlane(vtkRenderWindowInteractor* interactor)
{
if(mitk::RenderingManager::GetInstance()->GetClippingPlaneStatus()) //if clipping plane is enabled
{
if(!m_PlaneSet)
{
m_PlaneWidget->SetInteractor(interactor);
m_PlaneWidget->SetPlaceFactor(1.0);
m_PlaneWidget->SetInput(m_UnitSpacingImageFilter->GetOutput());
m_PlaneWidget->OutlineTranslationOff(); //disables scaling of the bounding box
m_PlaneWidget->ScaleEnabledOff(); //disables scaling of the bounding box
m_PlaneWidget->DrawPlaneOff(); //clipping plane is transparent
mitk::Image* input = const_cast<mitk::Image *>(this->GetInput());
/*places the widget within the specified bounds*/
m_PlaneWidget->PlaceWidget(
input->GetGeometry()->GetOrigin()[0],(input->GetGeometry()->GetOrigin()[0])+(input->GetDimension(0))*(input->GetVtkImageData()->GetSpacing()[0]), input->GetGeometry()->GetOrigin()[1],(input->GetGeometry()->GetOrigin()[1])+(input->GetDimension(1))*(input->GetVtkImageData()->GetSpacing()[1]), input->GetGeometry()->GetOrigin()[2],(input->GetGeometry()->GetOrigin()[2])+(input->GetDimension(2))*(input->GetVtkImageData()->GetSpacing()[2]));
// m_T2DMapper->AddClippingPlane(m_ClippingPlane);
m_HiResMapper->AddClippingPlane(m_ClippingPlane);
}
m_PlaneWidget->GetPlane(m_ClippingPlane);
m_PlaneSet = true;
}
else //if clippingplane is disabled
{
if(m_PlaneSet) //if plane exists
{
DelClippingPlane();
}
}
}
/* Removes the clipping plane */
void mitk::VolumeDataVtkMapper3D::DelClippingPlane()
{
// m_T2DMapper->RemoveAllClippingPlanes();
m_HiResMapper->RemoveAllClippingPlanes();
m_PlaneSet = false;
}
void mitk::VolumeDataVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "volumerendering", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "volumerendering configuration", mitk::VtkVolumeRenderingProperty::New( 1 ), renderer, overwrite );
node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
if(image.IsNotNull() && image->IsInitialized())
{
if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
{
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelwindow;
levelwindow.SetAuto( image );
levWinProp->SetLevelWindow( levelwindow );
node->SetProperty( "levelwindow", levWinProp, renderer );
}
//This mapper used to set a default lut "LookupTable" for images. However, this will
//overwrite the default lut of the 2D image mapper. Thus, this property here is renamed.
/*
if((overwrite) || (node->GetProperty("Volume.LookupTable", renderer)==NULL))
{
// add a default rainbow lookup table for color mapping
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( "Volume.LookupTable", mitkLutProp );
}*/
if((overwrite) || (node->GetProperty("TransferFunction", renderer)==NULL))
{
// add a default transfer function
mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
tfInit->SetTransferFunctionMode(0);
node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
}
}
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
bool mitk::VolumeDataVtkMapper3D::IsLODEnabled( mitk::BaseRenderer * /*renderer*/ ) const
{
return false;
// Volume mapper is LOD enabled if volumerendering is enabled
/*
return
dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer)) != NULL &&
dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))->GetValue() == true;
*/
}
void mitk::VolumeDataVtkMapper3D::EnableMask()
{
if (!this->m_Mask)
{
const Image *orig_image = this->GetInput();
unsigned int *dimensions = orig_image->GetDimensions();
this->m_Mask = vtkImageData::New();
this->m_Mask->SetDimensions(dimensions[0], dimensions[1], dimensions[2]);
this->m_Mask->SetScalarTypeToUnsignedChar();
this->m_Mask->SetNumberOfScalarComponents(1);
this->m_Mask->AllocateScalars();
unsigned char *mask_data = static_cast<unsigned char*>(this->m_Mask->GetScalarPointer());
unsigned int size = dimensions[0] * dimensions[1] * dimensions[2];
for (unsigned int i = 0u; i < size; ++i)
{
*mask_data++ = 1u;
}
this->m_ImageMaskFilter->SetMaskInput(this->m_Mask);
this->m_ImageMaskFilter->Modified();
}
}
void mitk::VolumeDataVtkMapper3D::DisableMask()
{
if (this->m_Mask)
{
this->m_Mask->Delete();
this->m_Mask = 0;
}
}
mitk::Image::Pointer mitk::VolumeDataVtkMapper3D::GetMask()
{
if (this->m_Mask)
{
Image::Pointer mask = Image::New();
mask->Initialize(this->m_Mask);
mask->SetImportVolume(this->m_Mask->GetScalarPointer(), 0, 0, Image::ReferenceMemory);
mask->SetGeometry(this->GetInput()->GetGeometry());
return mask;
}
return 0;
}
void mitk::VolumeDataVtkMapper3D::UpdateMask()
{
if (this->m_Mask)
{
this->m_ImageMaskFilter->Modified();
}
}
bool mitk::VolumeDataVtkMapper3D::SetMask(const mitk::Image* mask)
{
if (this->m_Mask)
{
- if ( (mask->GetPixelType().GetTypeId() == typeid(unsigned char))
- &&(mask->GetPixelType().GetPixelTypeId() == itk::ImageIOBase::SCALAR ))
+ if ( (mask->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR)
+ &&(mask->GetPixelType().GetPixelType() == itk::ImageIOBase::SCALAR ))
{
Image *img = const_cast<Image*>(mask);
this->m_Mask->DeepCopy(img->GetVtkImageData());
this->m_ImageMaskFilter->Modified();
return true;
}
}
return false;
}
diff --git a/Core/Code/Rendering/mitkVtkMapper2D.h b/Core/Code/Rendering/mitkVtkMapper2D.h
index f9db3be352..1c18e0ef19 100644
--- a/Core/Code/Rendering/mitkVtkMapper2D.h
+++ b/Core/Code/Rendering/mitkVtkMapper2D.h
@@ -1,32 +1,32 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef BASEVTKMAPPER2D_H_HEADER_INCLUDED
#define BASEVTKMAPPER2D_H_HEADER_INCLUDED
#include "mitkVtkMapper.h"
namespace mitk {
// typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead.
+ // \deprecatedSince{2013_03} Use VtkMapper instead.
DEPRECATED(typedef VtkMapper VtkMapper2D);
} // namespace mitk
#endif /* BASEVTKMAPPER2D_H_HEADER_INCLUDED */
diff --git a/Core/Code/Rendering/mitkVtkMapper3D.h b/Core/Code/Rendering/mitkVtkMapper3D.h
index f31560ec0f..1958ac3614 100644
--- a/Core/Code/Rendering/mitkVtkMapper3D.h
+++ b/Core/Code/Rendering/mitkVtkMapper3D.h
@@ -1,31 +1,31 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef BASEVTKMAPPER3D_H_HEADER_INCLUDED
#define BASEVTKMAPPER3D_H_HEADER_INCLUDED
#include "mitkVtkMapper.h"
namespace mitk {
// typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead
+ // \deprecatedSince{2013_03} Use VtkMapper instead
DEPRECATED(typedef VtkMapper VtkMapper3D);
} // namespace mitk
#endif /* BASEVTKMAPPER3D_H_HEADER_INCLUDED */
diff --git a/Core/Code/Rendering/mitkVtkPropRenderer.cpp b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
index 22e1a83215..60a42fefbc 100644
--- a/Core/Code/Rendering/mitkVtkPropRenderer.cpp
+++ b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
@@ -1,927 +1,926 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkVtkPropRenderer.h"
// MAPPERS
#include "mitkMapper.h"
#include "mitkImageVtkMapper2D.h"
#include "mitkVtkMapper.h"
#include "mitkGLMapper.h"
#include "mitkGeometry2DDataVtkMapper3D.h"
-#include "mitkPointSetGLMapper2D.h"
#include "mitkImageSliceSelector.h"
#include "mitkRenderingManager.h"
#include "mitkGL.h"
#include "mitkGeometry3D.h"
#include "mitkDisplayGeometry.h"
#include "mitkLevelWindow.h"
#include "mitkCameraController.h"
#include "mitkVtkInteractorCameraController.h"
#include "mitkPlaneGeometry.h"
#include "mitkProperties.h"
#include "mitkSurface.h"
#include "mitkNodePredicateDataType.h"
#include "mitkVtkInteractorStyle.h"
// VTK
#include <vtkRenderer.h>
#include <vtkRendererCollection.h>
#include <vtkLight.h>
#include <vtkLightKit.h>
#include <vtkRenderWindow.h>
#include <vtkLinearTransform.h>
#include <vtkCamera.h>
#include <vtkWorldPointPicker.h>
#include <vtkPointPicker.h>
#include <vtkCellPicker.h>
#include <vtkTextActor.h>
#include <vtkTextProperty.h>
#include <vtkProp.h>
#include <vtkAssemblyPath.h>
#include <vtkAssemblyNode.h>
#include <vtkMapper.h>
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
#include <vtkInteractorStyleTrackballCamera.h>
mitk::VtkPropRenderer::VtkPropRenderer( const char* name, vtkRenderWindow * renWin, mitk::RenderingManager* rm )
: BaseRenderer(name,renWin, rm),
m_VtkMapperPresent(false),
m_CameraInitializedForMapperID(0)
{
didCount=false;
m_WorldPointPicker = vtkWorldPointPicker::New();
m_PointPicker = vtkPointPicker::New();
m_PointPicker->SetTolerance( 0.0025 );
m_CellPicker = vtkCellPicker::New();
m_CellPicker->SetTolerance( 0.0025 );
mitk::Geometry2DDataVtkMapper3D::Pointer geometryMapper = mitk::Geometry2DDataVtkMapper3D::New();
m_CurrentWorldGeometry2DMapper = geometryMapper;
m_CurrentWorldGeometry2DNode->SetMapper(2, geometryMapper);
m_LightKit = vtkLightKit::New();
m_LightKit->AddLightsToRenderer(m_VtkRenderer);
m_PickingMode = WorldPointPicking;
m_TextRenderer = vtkRenderer::New();
m_TextRenderer->SetRenderWindow(renWin);
m_TextRenderer->SetInteractive(0);
m_TextRenderer->SetErase(0);
}
/*!
\brief Destructs the VtkPropRenderer.
*/
mitk::VtkPropRenderer::~VtkPropRenderer()
{
// Workaround for GLDisplayList Bug
{
m_MapperID=0;
checkState();
}
if (m_LightKit != NULL)
m_LightKit->Delete();
if (m_VtkRenderer!=NULL)
{
m_CameraController = NULL;
m_VtkRenderer->Delete();
m_VtkRenderer = NULL;
}
else
m_CameraController = NULL;
if (m_WorldPointPicker != NULL)
m_WorldPointPicker->Delete();
if (m_PointPicker != NULL)
m_PointPicker->Delete();
if (m_CellPicker != NULL)
m_CellPicker->Delete();
if (m_TextRenderer != NULL)
m_TextRenderer->Delete();
}
void mitk::VtkPropRenderer::SetDataStorage( mitk::DataStorage* storage )
{
if ( storage == NULL )
return;
BaseRenderer::SetDataStorage(storage);
static_cast<mitk::Geometry2DDataVtkMapper3D*>(m_CurrentWorldGeometry2DMapper.GetPointer())->SetDataStorageForTexture( m_DataStorage.GetPointer() );
// Compute the geometry from the current data tree bounds and set it as world geometry
this->SetWorldGeometryToDataStorageBounds();
}
bool mitk::VtkPropRenderer::SetWorldGeometryToDataStorageBounds()
{
if ( m_DataStorage.IsNull() )
return false;
//initialize world geometry
mitk::TimeSlicedGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D( NULL, "includeInBoundingBox" );
if ( geometry.IsNull() )
return false;
this->SetWorldGeometry(geometry);
//this->GetDisplayGeometry()->SetSizeInDisplayUnits( this->m_TextRenderer->GetRenderWindow()->GetSize()[0], this->m_TextRenderer->GetRenderWindow()->GetSize()[1] );
this->GetDisplayGeometry()->Fit();
this->GetVtkRenderer()->ResetCamera();
this->Modified();
return true;
}
/*!
\brief
Called by the vtkMitkRenderProp in order to start MITK rendering process.
*/
int mitk::VtkPropRenderer::Render(mitk::VtkPropRenderer::RenderType type)
{
// Do we have objects to render?
if ( this->GetEmptyWorldGeometry())
return 0;
if ( m_DataStorage.IsNull())
return 0;
// Update mappers and prepare mapper queue
if (type == VtkPropRenderer::Opaque)
this->PrepareMapperQueue();
//go through the generated list and let the sorted mappers paint
bool lastVtkBased = true;
//bool sthVtkBased = false;
for(MappersMapType::iterator it = m_MappersMap.begin(); it != m_MappersMap.end(); it++)
{
Mapper * mapper = (*it).second;
VtkMapper* vtkmapper = dynamic_cast<VtkMapper*>(mapper);
if(vtkmapper)
{
//sthVtkBased = true;
if(!lastVtkBased)
{
Disable2DOpenGL();
lastVtkBased = true;
}
}
else
if(lastVtkBased)
{
Enable2DOpenGL();
lastVtkBased = false;
}
mapper->MitkRender(this, type);
}
if (lastVtkBased == false)
Disable2DOpenGL();
// Render text
if (type == VtkPropRenderer::Overlay)
{
if (m_TextCollection.size() > 0)
{
for (TextMapType::iterator it = m_TextCollection.begin(); it != m_TextCollection.end() ; it++)
m_TextRenderer->AddViewProp((*it).second);
m_TextRenderer->Render();
}
}
return 1;
}
/*!
\brief PrepareMapperQueue iterates the datatree
PrepareMapperQueue iterates the datatree in order to find mappers which shall be rendered. Also, it sortes the mappers wrt to their layer.
*/
void mitk::VtkPropRenderer::PrepareMapperQueue()
{
// variable for counting LOD-enabled mappers
m_NumberOfVisibleLODEnabledMappers = 0;
// Do we have to update the mappers ?
if ( m_LastUpdateTime < GetMTime() || m_LastUpdateTime < GetDisplayGeometry()->GetMTime() ) {
Update();
}
else if (m_MapperID>=1 && m_MapperID < 6)
Update();
// remove all text properties before mappers will add new ones
m_TextRenderer->RemoveAllViewProps();
for ( unsigned int i=0; i<m_TextCollection.size(); i++ )
{
m_TextCollection[i]->Delete();
}
m_TextCollection.clear();
// clear priority_queue
m_MappersMap.clear();
int mapperNo = 0;
//DataStorage
if( m_DataStorage.IsNull() )
return;
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin(); it != allObjects->End(); ++it)
{
DataNode::Pointer node = it->Value();
if ( node.IsNull() )
continue;
mitk::Mapper::Pointer mapper = node->GetMapper(m_MapperID);
if ( mapper.IsNull() )
continue;
bool visible = true;
node->GetVisibility(visible, this, "visible");
// The information about LOD-enabled mappers is required by RenderingManager
if ( mapper->IsLODEnabled( this ) && visible )
{
++m_NumberOfVisibleLODEnabledMappers;
}
// mapper without a layer property get layer number 1
int layer = 1;
node->GetIntProperty("layer", layer, this);
int nr = (layer<<16) + mapperNo;
m_MappersMap.insert( std::pair< int, Mapper * >( nr, mapper ) );
mapperNo++;
}
}
/*!
\brief
Enable2DOpenGL() and Disable2DOpenGL() are used to switch between 2D rendering (orthographic projection) and 3D rendering (perspective projection)
*/
void mitk::VtkPropRenderer::Enable2DOpenGL()
{
GLint iViewport[4];
// Get a copy of the viewport
glGetIntegerv( GL_VIEWPORT, iViewport );
// Save a copy of the projection matrix so that we can restore it
// when it's time to do 3D rendering again.
glMatrixMode( GL_PROJECTION );
glPushMatrix();
glLoadIdentity();
// Set up the orthographic projection
glOrtho(
iViewport[0], iViewport[0]+iViewport[2],
iViewport[1], iViewport[1]+iViewport[3],
-1.0, 1.0
);
glMatrixMode( GL_MODELVIEW );
glPushMatrix();
glLoadIdentity();
// Make sure depth testing and lighting are disabled for 2D rendering until
// we are finished rendering in 2D
glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_LIGHTING_BIT );
glDisable( GL_DEPTH_TEST );
glDisable( GL_LIGHTING );
// disable the texturing here so crosshair is painted in the correct colors
// vtk will reenable texturing every time it is needed
glDisable( GL_TEXTURE_1D );
glDisable( GL_TEXTURE_2D );
glLineWidth(1.0);
}
/*!
\brief Initialize the VtkPropRenderer
Enable2DOpenGL() and Disable2DOpenGL() are used to switch between 2D rendering (orthographic projection) and 3D rendering (perspective projection)
*/
void mitk::VtkPropRenderer::Disable2DOpenGL()
{
glPopAttrib();
glMatrixMode( GL_PROJECTION );
glPopMatrix();
glMatrixMode( GL_MODELVIEW );
glPopMatrix();
}
void mitk::VtkPropRenderer::Update(mitk::DataNode* datatreenode)
{
if(datatreenode!=NULL)
{
mitk::Mapper::Pointer mapper = datatreenode->GetMapper(m_MapperID);
if(mapper.IsNotNull())
{
GLMapper* glmapper=dynamic_cast<GLMapper*>(mapper.GetPointer());
if(GetDisplayGeometry()->IsValid())
{
if(glmapper != NULL)
{
glmapper->Update(this);
m_VtkMapperPresent=false;
}
else
{
VtkMapper* vtkmapper=dynamic_cast<VtkMapper*>(mapper.GetPointer());
if(vtkmapper != NULL)
{
vtkmapper->Update(this);
vtkmapper->UpdateVtkTransform(this);
m_VtkMapperPresent=true;
}
}
}
}
}
}
void mitk::VtkPropRenderer::Update()
{
if( m_DataStorage.IsNull() )
return;
m_VtkMapperPresent = false;
mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
Update(it->Value());
Modified();
m_LastUpdateTime = GetMTime();
}
/*!
\brief
This method is called from the two Constructors
*/
void mitk::VtkPropRenderer::InitRenderer(vtkRenderWindow* renderWindow)
{
BaseRenderer::InitRenderer(renderWindow);
if(renderWindow == NULL)
{
m_InitNeeded = false;
m_ResizeNeeded = false;
return;
}
m_InitNeeded = true;
m_ResizeNeeded = true;
m_LastUpdateTime = 0;
}
/*!
\brief Resize the OpenGL Window
*/
void mitk::VtkPropRenderer::Resize(int w, int h)
{
BaseRenderer::Resize(w, h);
m_RenderingManager->RequestUpdate(this->GetRenderWindow());
}
void mitk::VtkPropRenderer::InitSize(int w, int h)
{
m_RenderWindow->SetSize(w,h);
Superclass::InitSize(w, h);
Modified();
Update();
if(m_VtkRenderer!=NULL)
{
int w=vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
m_VtkRenderer->ResetCamera();
vtkObject::SetGlobalWarningDisplay(w);
}
}
void mitk::VtkPropRenderer::SetMapperID(const MapperSlotId mapperId)
{
if(m_MapperID != mapperId)
Superclass::SetMapperID(mapperId);
// Workaround for GL Displaylist Bug
checkState();
}
/*!
\brief Activates the current renderwindow.
*/
void mitk::VtkPropRenderer::MakeCurrent()
{
if(m_RenderWindow!=NULL)
m_RenderWindow->MakeCurrent();
}
void mitk::VtkPropRenderer::PickWorldPoint(const mitk::Point2D& displayPoint, mitk::Point3D& worldPoint) const
{
if(m_VtkMapperPresent)
{
//m_WorldPointPicker->SetTolerance (0.0001);
switch ( m_PickingMode )
{
case (WorldPointPicking) :
{
m_WorldPointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
vtk2itk(m_WorldPointPicker->GetPickPosition(), worldPoint);
break;
}
case (PointPicking) :
{
// create a new vtkRenderer
// give it all necessary information (camera position, etc.)
// get all surfaces from datastorage, get actors from them
// add all those actors to the new renderer
// give this new renderer to pointpicker
/*
vtkRenderer* pickingRenderer = vtkRenderer::New();
pickingRenderer->SetActiveCamera( );
DataStorage* dataStorage = m_DataStorage;
TNodePredicateDataType<Surface> isSurface;
DataStorage::SetOfObjects::ConstPointer allSurfaces = dataStorage->GetSubset( isSurface );
MITK_INFO << "in picking: got " << allSurfaces->size() << " surfaces." << std::endl;
for (DataStorage::SetOfObjects::const_iterator iter = allSurfaces->begin();
iter != allSurfaces->end();
++iter)
{
const DataNode* currentNode = *iter;
VtkMapper3D* baseVtkMapper3D = dynamic_cast<VtkMapper3D*>( currentNode->GetMapper( BaseRenderer::Standard3D ) );
if ( baseVtkMapper3D )
{
vtkActor* actor = dynamic_cast<vtkActor*>( baseVtkMapper3D->GetViewProp() );
if (actor)
{
MITK_INFO << "a" << std::flush;
pickingRenderer->AddActor( actor );
}
}
}
MITK_INFO << ";" << std::endl;
*/
m_PointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
vtk2itk(m_PointPicker->GetPickPosition(), worldPoint);
break;
}
}
}
else
{
Superclass::PickWorldPoint(displayPoint, worldPoint);
}
}
mitk::DataNode *
mitk::VtkPropRenderer::PickObject( const Point2D &displayPosition, Point3D &worldPosition ) const
{
if ( m_VtkMapperPresent )
{
m_CellPicker->InitializePickList();
// Iterate over all DataStorage objects to determine all vtkProps intended
// for picking
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
it != allObjects->End();
++it )
{
DataNode *node = it->Value();
if ( node == NULL )
continue;
bool pickable = false;
node->GetBoolProperty( "pickable", pickable );
if ( !pickable )
continue;
VtkMapper *mapper = dynamic_cast < VtkMapper * > ( node->GetMapper( m_MapperID ) );
if ( mapper == NULL )
continue;
vtkProp *prop = mapper->GetVtkProp( (mitk::BaseRenderer *)this );
if ( prop == NULL )
continue;
m_CellPicker->AddPickList( prop );
}
// Do the picking and retrieve the picked vtkProp (if any)
m_CellPicker->PickFromListOn();
m_CellPicker->Pick( displayPosition[0], displayPosition[1], 0.0, m_VtkRenderer );
m_CellPicker->PickFromListOff();
vtk2itk( m_CellPicker->GetPickPosition(), worldPosition );
vtkProp *prop = m_CellPicker->GetViewProp();
if ( prop == NULL )
{
return NULL;
}
// Iterate over all DataStorage objects to determine if the retrieved
// vtkProp is owned by any associated mapper.
for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
it != allObjects->End();
++it)
{
DataNode::Pointer node = it->Value();
if ( node.IsNull() )
continue;
mitk::Mapper * mapper = node->GetMapper( m_MapperID );
if ( mapper == NULL)
continue;
mitk::VtkMapper * vtkmapper = dynamic_cast< VtkMapper * >(mapper);
if(vtkmapper){
//if vtk-based, then ...
if ( vtkmapper->HasVtkProp( prop, const_cast< mitk::VtkPropRenderer * >( this ) ) )
{
return node;
}
}
}
return NULL;
}
else
{
return Superclass::PickObject( displayPosition, worldPosition );
}
};
/*!
\brief Writes some 2D text as overlay. Function returns an unique int Text_ID for each call, which can be used via the GetTextLabelProperty(int text_id) function
in order to get a vtkTextProperty. This property enables the setup of font, font size, etc.
*/
int mitk::VtkPropRenderer::WriteSimpleText(std::string text, double posX, double posY, double color1, double color2, double color3, float opacity)
{
if(text.size() > 0)
{
vtkTextActor* textActor = vtkTextActor::New();
textActor->SetPosition(posX,posY);
textActor->SetInput(text.c_str());
textActor->GetTextProperty()->SetColor(color1, color2, color3); //TODO: Read color from node property
textActor->GetTextProperty()->SetOpacity( opacity );
int text_id = m_TextCollection.size();
m_TextCollection.insert(TextMapType::value_type(text_id,textActor));
return text_id;
}
return -1;
}
/*!
\brief Can be used in order to get a vtkTextProperty for a specific text_id. This property enables the setup of font, font size, etc.
*/
vtkTextProperty* mitk::VtkPropRenderer::GetTextLabelProperty(int text_id)
{
return this->m_TextCollection[text_id]->GetTextProperty();
}
void mitk::VtkPropRenderer::InitPathTraversal()
{
if (m_DataStorage.IsNotNull())
{
m_PickingObjects = m_DataStorage->GetAll();
m_PickingObjectsIterator = m_PickingObjects->begin();
}
}
vtkAssemblyPath* mitk::VtkPropRenderer::GetNextPath()
{
if (m_DataStorage.IsNull() )
{
return NULL;
}
if ( m_PickingObjectsIterator == m_PickingObjects->end() )
{
return NULL;
}
vtkAssemblyPath* returnPath = vtkAssemblyPath::New();
//returnPath->Register(NULL);
bool success = false;
while (!success)
{
// loop until AddNode can be called successfully
const DataNode* node = *m_PickingObjectsIterator;
if (node)
{
Mapper* mapper = node->GetMapper( BaseRenderer::Standard3D );
if (mapper)
{
VtkMapper* vtkmapper = dynamic_cast<VtkMapper*>( mapper );
if (vtkmapper)
{
vtkProp* prop = vtkmapper->GetVtkProp(this);
if ( prop && prop->GetVisibility() )
{
// add to assembly path
returnPath->AddNode( prop, prop->GetMatrix() );
success = true;
}
}
}
}
++m_PickingObjectsIterator;
if ( m_PickingObjectsIterator == m_PickingObjects->end() ) break;
}
if ( success )
{
return returnPath;
}
else
{
return NULL;
}
}
void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow *renWin)
{
if( m_DataStorage.IsNull() )
return;
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::const_iterator iter = allObjects->begin(); iter != allObjects->end(); ++iter)
{
DataNode::Pointer node = *iter;
if ( node.IsNull() )
continue;
Mapper * mapper = node->GetMapper(m_MapperID);
if (mapper)
{
VtkMapper* vtkmapper = dynamic_cast<VtkMapper*>( mapper );
if(vtkmapper)
vtkmapper->ReleaseGraphicsResources(renWin);
}
}
}
const vtkWorldPointPicker *mitk::VtkPropRenderer::GetWorldPointPicker() const
{
return m_WorldPointPicker;
}
const vtkPointPicker *mitk::VtkPropRenderer::GetPointPicker() const
{
return m_PointPicker;
}
const vtkCellPicker *mitk::VtkPropRenderer::GetCellPicker() const
{
return m_CellPicker;
}
mitk::VtkPropRenderer::MappersMapType mitk::VtkPropRenderer::GetMappersMap() const
{
return m_MappersMap;
}
// Workaround for GL Displaylist bug
static int glWorkAroundGlobalCount = 0;
bool mitk::VtkPropRenderer::useImmediateModeRendering()
{
return glWorkAroundGlobalCount>1;
}
void mitk::VtkPropRenderer::checkState()
{
if (m_MapperID == Standard3D)
{
if (!didCount)
{
didCount = true;
glWorkAroundGlobalCount++;
if (glWorkAroundGlobalCount == 2)
{
MITK_INFO << "Multiple 3D Renderwindows active...: turning Immediate Rendering ON for legacy mappers";
// vtkMapper::GlobalImmediateModeRenderingOn();
}
//MITK_INFO << "GLOBAL 3D INCREASE " << glWorkAroundGlobalCount << "\n";
}
}
else
{
if(didCount)
{
didCount=false;
glWorkAroundGlobalCount--;
if(glWorkAroundGlobalCount==1)
{
MITK_INFO << "Single 3D Renderwindow active...: turning Immediate Rendering OFF for legacy mappers";
// vtkMapper::GlobalImmediateModeRenderingOff();
}
//MITK_INFO << "GLOBAL 3D DECREASE " << glWorkAroundGlobalCount << "\n";
}
}
}
//### Contains all methods which are neceassry before each VTK Render() call
void mitk::VtkPropRenderer::PrepareRender()
{
if ( this->GetMapperID() != m_CameraInitializedForMapperID )
{
Initialize2DvtkCamera(); //Set parallel projection etc.
}
AdjustCameraToScene(); //Prepare camera for 2D render windows
}
bool mitk::VtkPropRenderer::Initialize2DvtkCamera()
{
if ( this->GetMapperID() == Standard3D )
{
//activate parallel projection for 2D
this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(false);
this->GetRenderWindow()->GetInteractor()->SetInteractorStyle( vtkInteractorStyleTrackballCamera::New() );
m_CameraInitializedForMapperID = Standard3D;
}
else if( this->GetMapperID() == Standard2D)
{
//activate parallel projection for 2D
this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(true);
//turn the light out in the scene in order to render correct grey values.
//TODO Implement a property for light in the 2D render windows (in another method)
this->GetVtkRenderer()->RemoveAllLights();
this->GetRenderWindow()->GetInteractor()->SetInteractorStyle( mitkVtkInteractorStyle::New() );
m_CameraInitializedForMapperID = Standard2D;
}
return true;
}
void mitk::VtkPropRenderer::AdjustCameraToScene(){
if(this->GetMapperID() == Standard2D)
{
const mitk::DisplayGeometry* displayGeometry = this->GetDisplayGeometry();
double objectHeightInMM = this->GetCurrentWorldGeometry2D()->GetExtentInMM(1);//the height of the current object slice in mm
double displayHeightInMM = displayGeometry->GetSizeInMM()[1]; //the display height in mm (gets smaller when you zoom in)
double zoomFactor = objectHeightInMM/displayHeightInMM; //displayGeometry->GetScaleFactorMMPerDisplayUnit()
//determine how much of the object can be displayed
Vector2D displayGeometryOriginInMM = displayGeometry->GetOriginInMM(); //top left of the render window (Origin)
Vector2D displayGeometryCenterInMM = displayGeometryOriginInMM + displayGeometry->GetSizeInMM()*0.5; //center of the render window: (Origin + Size/2)
//Scale the rendered object:
//The image is scaled by a single factor, because in an orthographic projection sizes
//are preserved (so you cannot scale X and Y axis with different parameters). The
//parameter sets the size of the total display-volume. If you set this to the image
//height, the image plus a border with the size of the image will be rendered.
//Therefore, the size is imageHeightInMM / 2.
this->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(objectHeightInMM*0.5 );
//zooming with the factor calculated by dividing displayHeight through imegeHeight. The factor is inverse, because the VTK zoom method is working inversely.
this->GetVtkRenderer()->GetActiveCamera()->Zoom(zoomFactor);
//the center of the view-plane
double viewPlaneCenter[3];
viewPlaneCenter[0] = displayGeometryCenterInMM[0];
viewPlaneCenter[1] = displayGeometryCenterInMM[1];
viewPlaneCenter[2] = 0.0; //the view-plane is located in the XY-plane with Z=0.0
//define which direction is "up" for the ciamera (like default for vtk (0.0, 1.0, 0.0)
double cameraUp[3];
cameraUp[0] = 0.0;
cameraUp[1] = 1.0;
cameraUp[2] = 0.0;
//the position of the camera (center[0], center[1], 900000)
double cameraPosition[3];
cameraPosition[0] = viewPlaneCenter[0];
cameraPosition[1] = viewPlaneCenter[1];
cameraPosition[2] = 900000.0; //Reason for 900000: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
//set the camera corresponding to the textured plane
vtkSmartPointer<vtkCamera> camera = this->GetVtkRenderer()->GetActiveCamera();
if (camera)
{
camera->SetPosition( cameraPosition ); //set the camera position on the textured plane normal (in our case this is the view plane normal)
camera->SetFocalPoint( viewPlaneCenter ); //set the focal point to the center of the textured plane
camera->SetViewUp( cameraUp ); //set the view-up for the camera
// double distance = sqrt((cameraPosition[2]-viewPlaneCenter[2])*(cameraPosition[2]-viewPlaneCenter[2]));
// camera->SetClippingRange(distance-50, distance+50); //Reason for huge range: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
camera->SetClippingRange(0.1, 1000000); //Reason for huge range: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
}
const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( this->GetCurrentWorldGeometry2D() );
if ( planeGeometry != NULL )
{
//Transform the camera to the current position (transveral, coronal and saggital plane).
//This is necessary, because the SetUserTransform() method does not manipulate the vtkCamera.
//(Without not all three planes would be visible).
vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
vtkSmartPointer<vtkMatrix4x4> matrix = vtkSmartPointer<vtkMatrix4x4>::New();
Point3D origin;
Vector3D right, bottom, normal;
origin = planeGeometry->GetOrigin();
right = planeGeometry->GetAxisVector( 0 ); // right = Extent of Image in mm (worldspace)
bottom = planeGeometry->GetAxisVector( 1 );
normal = planeGeometry->GetNormal();
right.Normalize();
bottom.Normalize();
normal.Normalize();
matrix->SetElement(0, 0, right[0]);
matrix->SetElement(1, 0, right[1]);
matrix->SetElement(2, 0, right[2]);
matrix->SetElement(0, 1, bottom[0]);
matrix->SetElement(1, 1, bottom[1]);
matrix->SetElement(2, 1, bottom[2]);
matrix->SetElement(0, 2, normal[0]);
matrix->SetElement(1, 2, normal[1]);
matrix->SetElement(2, 2, normal[2]);
matrix->SetElement(0, 3, origin[0]);
matrix->SetElement(1, 3, origin[1]);
matrix->SetElement(2, 3, origin[2]);
matrix->SetElement(3, 0, 0.0);
matrix->SetElement(3, 1, 0.0);
matrix->SetElement(3, 2, 0.0);
matrix->SetElement(3, 3, 1.0);
trans->SetMatrix(matrix);
//Transform the camera to the current position (transveral, coronal and saggital plane).
this->GetVtkRenderer()->GetActiveCamera()->ApplyTransform(trans);
}
}
}
diff --git a/Core/Code/Rendering/mitkVtkWidgetRendering.cpp b/Core/Code/Rendering/mitkVtkWidgetRendering.cpp
index 2e08b4a583..6bbd4f8bb9 100644
--- a/Core/Code/Rendering/mitkVtkWidgetRendering.cpp
+++ b/Core/Code/Rendering/mitkVtkWidgetRendering.cpp
@@ -1,173 +1,173 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkVtkWidgetRendering.h"
#include "mitkVtkLayerController.h"
#include <mitkConfig.h>
#include <itkObject.h>
#include <itkMacro.h>
#include <itksys/SystemTools.hxx>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkObjectFactory.h>
#include <vtkRendererCollection.h>
#include <vtkInteractorObserver.h>
#include <algorithm>
mitk::VtkWidgetRendering::VtkWidgetRendering()
: m_RenderWindow( NULL ),
m_VtkWidget( NULL ),
m_IsEnabled( false )
{
m_Renderer = vtkRenderer::New();
}
mitk::VtkWidgetRendering::~VtkWidgetRendering()
{
if ( m_RenderWindow != NULL )
if ( this->IsEnabled() )
this->Disable();
if ( m_Renderer != NULL )
m_Renderer->Delete();
}
/**
* Sets the renderwindow, in which the widget
* will be shown. Make sure, you have called this function
* before calling Enable()
*/
void mitk::VtkWidgetRendering::SetRenderWindow( vtkRenderWindow* renderWindow )
{
m_RenderWindow = renderWindow;
}
/**
* Returns the vtkRenderWindow, which is used
* for displaying the widget
*/
vtkRenderWindow* mitk::VtkWidgetRendering::GetRenderWindow()
{
return m_RenderWindow;
}
/**
* Returns the renderer responsible for
* rendering the widget into the
* vtkRenderWindow
*/
vtkRenderer* mitk::VtkWidgetRendering::GetVtkRenderer()
{
return m_Renderer;
}
/**
* Enables drawing of the widget.
* If you want to disable it, call the Disable() function.
*/
void mitk::VtkWidgetRendering::Enable()
{
if(m_IsEnabled)
return;
if(m_RenderWindow != NULL)
{
vtkRenderWindowInteractor *interactor = m_RenderWindow->GetInteractor();
if ( m_VtkWidget != NULL )
{
m_VtkWidget->SetInteractor( interactor );
mitk::VtkLayerController *layerController =
mitk::VtkLayerController::GetInstance(m_RenderWindow);
if ( layerController )
{
layerController->InsertForegroundRenderer(m_Renderer,false);
}
m_IsEnabled = true;
}
}
}
/**
* Disables drawing of the widget.
* If you want to enable it, call the Enable() function.
*/
void mitk::VtkWidgetRendering::Disable()
{
if ( this->IsEnabled() )
{
mitk::VtkLayerController *layerController =
mitk::VtkLayerController::GetInstance(m_RenderWindow);
if ( layerController )
{
layerController->RemoveRenderer(m_Renderer);
}
m_IsEnabled = false;
}
}
/**
* Checks, if the widget is currently
* enabled (visible)
*/
bool mitk::VtkWidgetRendering::IsEnabled()
{
return m_IsEnabled;
}
void mitk::VtkWidgetRendering::SetRequestedRegionToLargestPossibleRegion()
{
//nothing to do
}
bool mitk::VtkWidgetRendering::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::VtkWidgetRendering::VerifyRequestedRegion()
{
return true;
}
-void mitk::VtkWidgetRendering::SetRequestedRegion(itk::DataObject*)
+void mitk::VtkWidgetRendering::SetRequestedRegion( const itk::DataObject*)
{
//nothing to do
}
void mitk::VtkWidgetRendering::SetVtkWidget( vtkInteractorObserver *widget )
{
m_VtkWidget = widget;
}
vtkInteractorObserver *mitk::VtkWidgetRendering::GetVtkWidget() const
{
return m_VtkWidget;
}
diff --git a/Core/Code/Rendering/mitkVtkWidgetRendering.h b/Core/Code/Rendering/mitkVtkWidgetRendering.h
index ad6ad045d5..7108e7bb70 100644
--- a/Core/Code/Rendering/mitkVtkWidgetRendering.h
+++ b/Core/Code/Rendering/mitkVtkWidgetRendering.h
@@ -1,142 +1,142 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _vtk_Widget_Rendering_h_
#define _vtk_Widget_Rendering_h_
#include <mitkBaseData.h>
class vtkRenderer;
class vtkRenderWindow;
class vtkInteractorObserver;
namespace mitk {
class RenderWindow;
/**
* \brief Mechanism for rendering a vtkWidget in the foreground of a RenderWindow.
*
* To use this class, specify the vtkRenderWindow of the window into which the
* vtkWidget shall be placed, and set the vtkWidget using SetVtkWidget().
* After enabling the vtkWidget and calling Enable() of this class, the widget
* should be rendered.
*
* Note: this class only provides a basic mechanism for adding widget; all widget
* configuration such as placement, size, and en-/disabling of interaction
* mechanisms need to be done in the vtkWidget object.
*/
class MITK_CORE_EXPORT VtkWidgetRendering : public BaseData
{
public:
mitkClassMacro( VtkWidgetRendering, BaseData );
itkNewMacro( Self );
/**
* Sets the renderwindow, in which the widget
* will be shown. Make sure, you have called this function
* before calling Enable()
*/
virtual void SetRenderWindow( vtkRenderWindow* renderWindow );
/**
* Enables drawing of the widget.
* If you want to disable it, call the Disable() function.
*/
virtual void Enable();
/**
* Disables drawing of the widget.
* If you want to enable it, call the Enable() function.
*/
virtual void Disable();
/**
* Checks, if the widget is currently
* enabled (visible)
*/
virtual bool IsEnabled();
/**
* Empty implementation, since the VtkWidgetRendering doesn't
* support the requested region concept
*/
virtual void SetRequestedRegionToLargestPossibleRegion();
/**
* Empty implementation, since the VtkWidgetRendering doesn't
* support the requested region concept
*/
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
/**
* Empty implementation, since the VtkWidgetRendering doesn't
* support the requested region concept
*/
virtual bool VerifyRequestedRegion();
/**
* Empty implementation, since the VtkWidgetRendering doesn't
* support the requested region concept
*/
- virtual void SetRequestedRegion(itk::DataObject*);
+ virtual void SetRequestedRegion( const itk::DataObject*);
/**
* Returns the vtkRenderWindow, which is used
* for displaying the widget
*/
virtual vtkRenderWindow* GetRenderWindow();
/**
* Returns the renderer responsible for
* rendering the widget into the
* vtkRenderWindow
*/
virtual vtkRenderer* GetVtkRenderer();
/** Set the vtkWidget to be rendered */
void SetVtkWidget( vtkInteractorObserver *widget );
/** Get the vtkWidget to be rendered */
vtkInteractorObserver *GetVtkWidget() const;
protected:
/**
* Constructor
*/
VtkWidgetRendering();
/**
* Destructor
*/
~VtkWidgetRendering();
vtkRenderWindow* m_RenderWindow;
vtkRenderer* m_Renderer;
vtkInteractorObserver *m_VtkWidget;
bool m_IsEnabled;
};
} //end of namespace mitk
#endif
diff --git a/Core/Code/Resources/Interactions/Legacy/StateMachine.xml b/Core/Code/Resources/Interactions/Legacy/StateMachine.xml
index 7ce0de4ab3..0cd6f2be12 100644
--- a/Core/Code/Resources/Interactions/Legacy/StateMachine.xml
+++ b/Core/Code/Resources/Interactions/Legacy/StateMachine.xml
@@ -1,4061 +1,4101 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- Event_Id = 0: this is a * transition with all other eventId's not declared in that state -->
<mitkInteraktionStates xmlns="http://tempuri.org/StateMachine.xsd" STYLE="User001">
<!-- ***WARNING*** do not use any &, % and so on in NAME -->
<!-- -->
<!-- -->
<!-- EventDescriptions -->
<events STYLE="standard">
<!-- Null Event -->
<!-- not here defined, cause this will never be send from external to mitk (to be mapped in mitkEventMapper to an mitk-event) -->
<!-- -->
<!-- The names of all events that contain mouseinteractions should follow the following guidelines: -->
<!-- -->
<!-- <button-id> mbtn + <action> + <modifier> -->
<!-- -->
<!-- <button-id> MUST BE either left, middle or right -->
<!-- <action> CAN be either empty (button pressed), 'DC' (double-click), 'MouseMove' (pressed + moved) or 'release' (button released). -->
<!-- <modifier> MAY be either 'shift', 'ctrl', 'alt' or a combination of these -->
<!-- three modifiers. MAKE SURE THE CORRECT ORDER IS MAINTAINED! Do not use 'strg' instead of 'ctrl'. -->
<!-- -->
<!-- Following the guidelines make it easier to maintain the list and add new events if necessary. -->
<!-- -->
<!-- left MouseButton -->
<event NAME="left mbtn" ID="1" TYPE="Type_MouseButtonPress" BUTTON="BS_LeftButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- right MouseButton -->
<event NAME="right mbtn" ID="2" TYPE="Type_MouseButtonPress" BUTTON="BS_RightButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- shift + left MouseButton -->
<event NAME="left mbtn + shift" ID="3" TYPE="Type_MouseButtonPress" BUTTON="BS_LeftButton" BUTTONSTATE="0x0100" KEY="Key_none" />
<!-- middle MouseButton -->
<event NAME="middle mbtn" ID="4" TYPE="Type_MouseButtonPress" BUTTON="BS_MidButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- Ctrl + left MouseButton -->
<event NAME="left mbtn + ctrl" ID="5" TYPE="Type_MouseButtonPress" BUTTON="BS_LeftButton" BUTTONSTATE="0x0200" KEY="Key_none" />
<!-- Ctrl + middle MouseButton -->
<event NAME="middle mbtn + ctrl" ID="6" TYPE="Type_MouseButtonPress" BUTTON="BS_MidButton" BUTTONSTATE="0x0200" KEY="Key_none" />
<!-- Ctrl + right MouseButton -->
<event NAME="right mbtn + ctrl" ID="7" TYPE="Type_MouseButtonPress" BUTTON="BS_RightButton" BUTTONSTATE="0x0200" KEY="Key_none" />
<!-- left MouseButton DoubleClick-->
<event NAME="left mbtn DC" ID="8" TYPE="Type_MouseButtonDblClick" BUTTON="BS_LeftButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- MouseWheel-->
<event NAME="MouseWheel" ID="9" TYPE="Type_Wheel" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- ctrl + N -->
<event NAME="N + ctrl" ID="10" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0200" KEY="Key_N" />
<!-- ctrl + E -->
<event NAME="E + ctrl" ID="11" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0200" KEY="Key_E" />
<!-- Delete -->
<event NAME="Delete" ID="12" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Delete" />
<!-- Esc -->
<event NAME="Escape" ID="14" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Escape" />
<!-- N-->
<event NAME="N" ID="13" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_N" />
<!-- P-->
<event NAME="P" ID="15" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_P" />
<!-- R-->
<event NAME="R" ID="16" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_R" />
<!-- T-->
<event NAME="T" ID="17" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_T" />
<!-- S-->
<event NAME="S" ID="18" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_S" />
<!-- E -->
<event NAME="E" ID="19" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_E" />
<!-- ctrl + alt + A -->
<event NAME="A + ctrl + alt" ID="20" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0600" KEY="Key_A" />
<!-- ctrl + alt + B -->
<event NAME="B + ctrl + alt" ID="21" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0600" KEY="Key_B" />
<!-- H-->
<event NAME="H" ID="22" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_H" />
<!-- Return -->
<event NAME="Return" ID="23" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Return" />
<!-- Enter -->
<event NAME="Enter" ID="24" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Enter" />
<!-- Space -->
<event NAME="Space" ID="25" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Space" />
<!-- Plus -->
<event NAME="Plus" ID="26" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Plus" />
<!-- Minus -->
<event NAME="Minus" ID="27" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Minus" />
<!-- ctrl + alt + H -->
<event NAME="H + ctrl + alt" ID="30" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0600" KEY="Key_H" />
<!-- ctrl + alt + I -->
<event NAME="I + ctrl + alt" ID="31" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0600" KEY="Key_I" />
<!-- ctrl + alt + S -->
<event NAME="S + ctrl + alt" ID="40" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0600" KEY="Key_S" />
<!-- ArrowUp -->
<event NAME="ArrowUp" ID="50" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Up" />
<!-- ArrowDown -->
<event NAME="ArrowDown" ID="51" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Down" />
<!-- ArrowLeft -->
<event NAME="ArrowLeft" ID="52" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Left" />
<!-- ArrowRight -->
<event NAME="ArrowRight" ID="53" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Right" />
<!-- ArrowUp + shift -->
<event NAME="ArrowUp + shift" ID="54" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0100" KEY="Key_Up" />
<!-- ArrowDown +shift -->
<event NAME="ArrowDown + shift" ID="55" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0100" KEY="Key_Down" />
<!-- alt -->
<event NAME="alt" ID="90" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0400" KEY="Key_alt" />
<!-- ctrl + B -->
<event NAME="B + ctrl" ID="91" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0200" KEY="Key_B" />
<!-- leftMouseButtonRelease -->
<event NAME="left mbtn release" ID="505" TYPE="Type_MouseButtonRelease" BUTTON="BS_LeftButton" BUTTONSTATE="0x0001" KEY="Key_none" />
<!-- MiddleMouseButtonRelease -->
<event NAME="middle mbtn release" ID="506" TYPE="Type_MouseButtonRelease" BUTTON="BS_MidButton" BUTTONSTATE="0x0004" KEY="Key_none" />
<!-- RightMouseButtonRelease -->
<event NAME="right mbtn release" ID="507" TYPE="Type_MouseButtonRelease" BUTTON="BS_RightButton" BUTTONSTATE="0x0002" KEY="Key_none" />
<!-- shift + left MouseButtonRelease -->
<event NAME="left mbtn release + shift" ID="508" TYPE="Type_MouseButtonRelease" BUTTON="BS_LeftButton" BUTTONSTATE="0x0101" KEY="Key_none" />
<!-- MouseMove -->
<event NAME="MouseMove" ID="520" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- left MouseButton and MouseWheel -->
<event NAME="left mbtn + MouseWheel" ID="521" TYPE="Type_Wheel" BUTTON="BS_LeftButton" BUTTONSTATE="0x0001" KEY="Key_none" />
<!-- right MouseButton and MouseWheel -->
<event NAME="right mbtn + MouseWheel" ID="522" TYPE="Type_Wheel" BUTTON="BS_RightButton" BUTTONSTATE="0x0002" KEY="Key_none" />
<!-- middle MouseButton and MouseWheel -->
<event NAME="middleBN+MouseWheel" ID="523" TYPE="Type_Wheel" BUTTON="BS_MidButton" BUTTONSTATE="0x0004" KEY="Key_none" />
<!-- CTRL and MouseMove -->
<event NAME="CTRL+MouseMove" ID="529" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0200" KEY="Key_none" />
<!-- left MouseButton and MouseMove -->
<event NAME="left mbtn + MouseMove" ID="530" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0001" KEY="Key_none" />
<!-- right MouseButton and MouseMove -->
<event NAME="right mbtn + MouseMove" ID="531" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0002" KEY="Key_none" />
<!-- middle MouseButton and MouseMove -->
<event NAME="middle mbtn + MouseMove" ID="533" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0004" KEY="Key_none" />
<!-- ctrl + left MouseButton and MouseMove -->
<event NAME="left mbtn + MouseMove + ctrl" ID="534" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0201" KEY="Key_none" />
<!-- ctrl + right MouseButton and MouseMove -->
<event NAME="right mbtn + MouseMove + ctrl" ID="535" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0202" KEY="Key_none" />
<!-- ctrl + middle MouseButton and MouseMove -->
<event NAME="middle mbtn + MouseMove + ctrl" ID="536" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0204" KEY="Key_none" />
<!-- ctrl + left MouseButtonRelease -->
<event NAME="left mbtn release + ctrl" ID="537" TYPE="Type_MouseButtonRelease" BUTTON="BS_LeftButton" BUTTONSTATE="0x0201" KEY="Key_none" />
<!-- ctrl + right MouseButtonRelease -->
<event NAME="right mbtn release + ctrl" ID="538" TYPE="Type_MouseButtonRelease" BUTTON="BS_RightButton" BUTTONSTATE="0x0202" KEY="Key_none" />
<!-- ctrl + middle MouseButtonRelease -->
<event NAME="middle mbtn release + ctrl" ID="539" TYPE="Type_MouseButtonRelease" BUTTON="BS_MidButton" BUTTONSTATE="0x0204" KEY="Key_none" />
<!-- shift + Ctrl + left MouseButton -->
<event NAME="left mbtn + shift + ctrl" ID="540" TYPE="Type_MouseButtonPress" BUTTON="BS_LeftButton" BUTTONSTATE="0x0300" KEY="Key_none" />
<!-- shift + Ctrl + left MouseButtonMove -->
<event NAME="left mbtn + MouseMove + shift + ctrl" ID="542" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0301" KEY="Key_none" />
<!-- shift + Ctrl + left MouseButtonRelease -->
<event NAME="left mbtn release + shift + ctrl" ID="543" TYPE="Type_MouseButtonRelease" BUTTON="BS_LeftButton" BUTTONSTATE="0x0301" KEY="Key_none" />
<!-- shift + left MouseButton and MouseMove -->
<event NAME="left mbtn + MouseMove + shift" ID="541" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0101" KEY="Key_none" />
<!-- alt + left MouseButton -->
<event NAME="left mbtn + alt" ID="600" TYPE="Type_MouseButtonPress" BUTTON="BS_LeftButton" BUTTONSTATE="0x0400" KEY="Key_none" />
<!-- alt + left MouseButton and MouseMove -->
<event NAME="left mbtn + MouseMove + alt" ID="610" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0401" KEY="Key_none" />
<!-- alt + leftMouseButtonRelease -->
<event NAME="left mbtn release + alt" ID="620" TYPE="Type_MouseButtonRelease" BUTTON="BS_LeftButton" BUTTONSTATE="0x0401" KEY="Key_none" />
<!-- ctrl + MouseWheel -->
<event NAME="MouseWheel + ctrl" ID="630" TYPE="Type_Wheel" BUTTON="BS_NoButton" BUTTONSTATE="0x0200" KEY="Key_none" />
<!-- alt + MouseWheel -->
<event NAME="MouseWheel + alt" ID="640" TYPE="Type_Wheel" BUTTON="BS_NoButton" BUTTONSTATE="0x0400" KEY="Key_none" />
<!-- alt + middle MouseButton -->
<event NAME="middle mbtn + alt" ID="641" TYPE="Type_MouseButtonPress" BUTTON="BS_MidButton" BUTTONSTATE="0x0400" KEY="Key_none" />
<!-- alt + middle MouseButton and MouseMove -->
<event NAME="middle mbtn + MouseMove + alt" ID="642" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0404" KEY="Key_none" />
<!-- alt + middle MouseButtonRelease -->
<event NAME="middle mbtn release + alt" ID="643" TYPE="Type_MouseButtonRelease" BUTTON="BS_MidButton" BUTTONSTATE="0x0404" KEY="Key_none" />
<!-- alt + shift + right MouseButton -->
<event NAME="right mbtn + shift + alt" ID="644" TYPE="Type_MouseButtonPress" BUTTON="BS_RightButton" BUTTONSTATE="0x0500" KEY="Key_none" />
<!-- alt + shift + right MouseButton and MouseMove -->
<event NAME="right mbtn + MouseMove + shift + alt" ID="645" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0502" KEY="Key_none" />
<!-- alt + shift + right MouseButtonRelease -->
<event NAME="right mbtn release + shift + alt" ID="646" TYPE="Type_MouseButtonRelease" BUTTON="BS_RightButton" BUTTONSTATE="0x0502" KEY="Key_none" />
<!-- shift + rightMouseButtonPress -->
<event NAME="right mbtn + shift" ID="2000" TYPE="Type_MouseButtonPress" BUTTON="BS_RightButton" BUTTONSTATE="0x0100" KEY="Key_none" />
<!-- shift + rightMouseButtonMove -->
<event NAME="right mbtn + MouseMove + shift" ID="2001" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0102" KEY="Key_none" />
<!-- shift + rightMouseButtonRelease -->
<event NAME="right mbtn release + shift" ID="2002" TYPE="Type_MouseButtonRelease" BUTTON="BS_RightButton" BUTTONSTATE="0x0102" KEY="Key_none" />
<!-- shift + middleMouseButtonPress -->
<event NAME="middle mbtn + shift" ID="2003" TYPE="Type_MouseButtonPress" BUTTON="BS_MidButton" BUTTONSTATE="0x0100" KEY="Key_none" />
<!-- shift + middleMouseButtonMove -->
<event NAME="middle mbtn + MouseMove + shift" ID="2004" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0104" KEY="Key_none" />
<!-- shift + middleMouseButtonRelease -->
<event NAME="middle mbtn release + shift" ID="2005" TYPE="Type_MouseButtonRelease" BUTTON="BS_MidButton" BUTTONSTATE="0x0104" KEY="Key_none" />
<event NAME="right mbtn + alt" ID="2006" TYPE="Type_MouseButtonPress" BUTTON="BS_RightButton" BUTTONSTATE="0x0400" KEY="Key_none" />
<event NAME="right mbtn + Mousemove + alt" ID="2007" TYPE="Type_MouseMove" BUTTON="BS_RightButton" BUTTONSTATE="0x0400" KEY="Key_none" />
<event NAME="right mbtn release + alt" ID="2008" TYPE="Type_MouseButtonRelease" BUTTON="BS_RightButton" BUTTONSTATE="0x0400" KEY="Key_none" />
<!-- alt + shift + right MouseButton -->
<event NAME="right mbtn + shift + ctrl" ID="2010" TYPE="Type_MouseButtonPress" BUTTON="BS_RightButton" BUTTONSTATE="0x0301" KEY="Key_none" />
<!-- alt + shift + right MouseButton and MouseMove -->
<event NAME="right mbtn + MouseMove + shift + ctrl" ID="2011" TYPE="Type_MouseMove" BUTTON="BS_NoButton" BUTTONSTATE="0x0301" KEY="Key_none" />
<!-- alt + shift + right MouseButtonRelease -->
<event NAME="right mbtn release + shift + ctrl" ID="2012" TYPE="Type_MouseButtonRelease" BUTTON="BS_RightButton" BUTTONSTATE="0x0301" KEY="Key_none" />
<!-- alt + MouseWheel -->
<event NAME="MouseWheel + shift" ID="2015" TYPE="Type_Wheel" BUTTON="BS_NoButton" BUTTONSTATE="0x0100" KEY="Key_none" />
<!-- -->
<!-- -->
<!-- own thrown events -->
<!-- *****Important*****: has to be set in mitkInteractionConst.h-->
<event NAME="new" ID="1000" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="old" ID="1001" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="finished" ID="1002" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="StSELECT" ID="1003" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="StDESELECT" ID="1004" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="EIDNO" ID="1003" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="EIDYES" ID="1004" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="same" ID="1005" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="no and last object" ID="1006" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="no and not last object" ID="1007" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="last" ID="1008" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="not last" ID="1009" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="SetStateMachineToSelectedMode" ID="1030" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="SetStateMachineToDeselectedMode" ID="1031" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- for n-PointRoi-->
<event NAME="StSMALERNMINUS1 " ID="1010" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<event NAME="StLARGERNMINUS1" ID="1011" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- -->
<event NAME="ActivateTool" ID="1300" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- -->
<!-- Sonstiges -->
<!--<event NAME="PositionEvent" ID="1012" TYPE="Type_MouseButtonPress" BUTTON="BS_LeftButton" BUTTONSTATE="0x0000" KEY="Key_none" />-->
<!-- DoubleClick <event NAME="PositionEvent" ID="510" TYPE="4" BUTTON="0x0001" BUTTONSTATE="0x0000" KEY="0xffff" />-->
<!--<event NAME="StSmallerN" ID="1014" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />-->
<!--<event NAME="StEqualsN" ID="1015" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />-->
<!--<event NAME="StLargerN" ID="1016" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />-->
<!-- for external thrown Events-->
<event NAME="clear" ID="1100" TYPE="Type_User" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- Puncture Application -->
<event NAME="print" ID="3001" TYPE="Type_Application" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_none" />
<!-- A-->
<event NAME="A" ID="4001" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_A" />
<!-- B-->
<event NAME="B" ID="4002" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_B" />
<!-- C-->
<event NAME="C" ID="4003" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_C" />
<!-- D-->
<event NAME="D" ID="4004" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_D" />
<!-- F-->
<event NAME="F" ID="4005" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_F" />
<!-- G-->
<event NAME="G" ID="4006" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_G" />
<!-- I-->
<event NAME="I" ID="4007" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_I" />
<!-- J-->
<event NAME="J" ID="4008" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_J" />
<!-- K-->
<event NAME="K" ID="4009" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_K" />
<!-- L-->
<event NAME="L" ID="4010" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_L" />
<!-- M-->
<event NAME="M" ID="4011" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_M" />
<!-- O-->
<event NAME="O" ID="4012" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_O" />
<!-- Q-->
<event NAME="Q" ID="4013" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Q" />
<!-- U-->
<event NAME="U" ID="4014" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_U" />
<!-- V-->
<event NAME="V" ID="4015" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_V" />
<!-- W-->
<event NAME="W" ID="4016" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_W" />
<!-- X-->
<event NAME="X" ID="4017" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_X" />
<!-- Y-->
<event NAME="Y" ID="4018" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Y" />
<!-- Z-->
<event NAME="Z" ID="4019" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_Z" />
<!-- 1-->
<event NAME="1" ID="4020" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_1" />
<!-- 2-->
<event NAME="2" ID="4021" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_2" />
<!-- 3-->
<event NAME="3" ID="4022" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_3" />
<!-- 4-->
<event NAME="4" ID="4023" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_4" />
<!-- 5-->
<event NAME="5" ID="4024" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_5" />
<!-- 6-->
<event NAME="6" ID="4025" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_6" />
<!-- 7-->
<event NAME="7" ID="4026" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_7" />
<!-- 8-->
<event NAME="8" ID="4027" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_8" />
<!-- 9-->
<event NAME="9" ID="4028" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_9" />
<!-- 0 (zero) -->
<event NAME="0" ID="4029" TYPE="Type_KeyPress" BUTTON="BS_NoButton" BUTTONSTATE="0x0000" KEY="Key_0" />
</events>
<!-- Beginning of state machine patterns-->
<!-- TutorialStep10Begin -->
<stateMachine NAME="SelectAndMoveObjectWithArrowKeys">
<state NAME="start" ID="1" START_STATE="TRUE" X_POS="3" Y_POS="40" WIDTH="100" HEIGHT="50">
<transition NAME="CheckIfObjectIsPicked" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="30" />
<!-- 30 = AcCHECKELEMENT -->
</transition>
</state>
<state NAME="Guard_IsObjectPicked" ID="2" X_POS="282" Y_POS="23" WIDTH="126" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="10" EVENT_ID="1004">
<action ID="65" />
<!-- AcSELECT -->
<action ID="1101" />
<!--AcMODE_SELECT-->
</transition>
<transition NAME="no" NEXT_STATE_ID="1" EVENT_ID="1003">
<action ID="75" />
<!-- AcDESELECT -->
<action ID="1100" />
<!--AcMODE_DESELECT-->
</transition>
</state>
<state NAME="object selected" ID="10" X_POS="714" Y_POS="85" WIDTH="100" HEIGHT="50">
<transition NAME="CheckIfObjectIsPicked" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="30" />
<!-- AcCHECKELEMENT -->
</transition>
<transition NAME="z+" NEXT_STATE_ID="10" EVENT_ID="50">
<action ID="92">
<!-- AcMove -->
<intParameter NAME="DIRECTION_X" VALUE="0" />
<intParameter NAME="DIRECTION_Y" VALUE="0" />
<intParameter NAME="DIRECTION_Z" VALUE="1" />
</action>
</transition>
<transition NAME="z-" NEXT_STATE_ID="10" EVENT_ID="51">
<action ID="92">
<!-- AcMove -->
<intParameter NAME="DIRECTION_X" VALUE="0" />
<intParameter NAME="DIRECTION_Y" VALUE="0" />
<intParameter NAME="DIRECTION_Z" VALUE="-1" />
</action>
</transition>
<transition NAME="x+" NEXT_STATE_ID="10" EVENT_ID="52">
<action ID="92">
<!-- AcMove -->
<intParameter NAME="DIRECTION_X" VALUE="1" />
<intParameter NAME="DIRECTION_Y" VALUE="0" />
<intParameter NAME="DIRECTION_Z" VALUE="0" />
</action>
</transition>
<transition NAME="x-" NEXT_STATE_ID="10" EVENT_ID="53">
<action ID="92">
<!-- AcMove -->
<intParameter NAME="DIRECTION_X" VALUE="-1" />
<intParameter NAME="DIRECTION_Y" VALUE="0" />
<intParameter NAME="DIRECTION_Z" VALUE="0" />
</action>
</transition>
<transition NAME="y+" NEXT_STATE_ID="10" EVENT_ID="54">
<action ID="92">
<!-- AcMove -->
<intParameter NAME="DIRECTION_X" VALUE="0" />
<intParameter NAME="DIRECTION_Y" VALUE="1" />
<intParameter NAME="DIRECTION_Z" VALUE="0" />
</action>
</transition>
<transition NAME="y-" NEXT_STATE_ID="10" EVENT_ID="55">
<action ID="92">
<!-- AcMove -->
<intParameter NAME="DIRECTION_X" VALUE="0" />
<intParameter NAME="DIRECTION_Y" VALUE="-1" />
<intParameter NAME="DIRECTION_Z" VALUE="0" />
</action>
</transition>
</state>
</stateMachine>
<!-- TutorialStep10End -->
<stateMachine NAME="AffineInteractions click to select">
<state NAME="start" ID="1" START_STATE="TRUE" X_POS="3" Y_POS="40" WIDTH="100" HEIGHT="50">
<transition NAME="leftButtonPress" NEXT_STATE_ID="2" EVENT_ID="1">
<!-- 30 = SeCHECKELEMENT -->
<action ID="30" />
</transition>
</state>
<state NAME="object selected check" ID="2" X_POS="282" Y_POS="23" WIDTH="126" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="10" EVENT_ID="1004">
<!-- EIDYES -->
<action ID="0" />
</transition>
<transition NAME="no" NEXT_STATE_ID="1" EVENT_ID="1003">
<!-- EIDNO -->
<action ID="0" />
</transition>
</state>
<state NAME="neutral" ID="10" X_POS="714" Y_POS="85" WIDTH="100" HEIGHT="50">
<transition NAME="leftButtonPress" NEXT_STATE_ID="20" EVENT_ID="1">
<!-- 30 = SeCHECKELEMENT -->
<action ID="30" />
</transition>
<transition NAME="rightButtonPress" NEXT_STATE_ID="31" EVENT_ID="2">
<!-- 1002 = SeSCALESTART -->
<action ID="1002" />
</transition>
<transition NAME="middleButtonPress" NEXT_STATE_ID="41" EVENT_ID="4">
<!-- 1004 = SeROTATESTART -->
<action ID="1004" />
</transition>
</state>
<state NAME="object deselect check" ID="20" X_POS="57" Y_POS="396" WIDTH="122" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="21" EVENT_ID="1004">
<!-- 1000 = SeTRANSLATESTART -->
<action ID="1000" />
</transition>
<transition NAME="no" NEXT_STATE_ID="1" EVENT_ID="1003">
<!-- EIDNO -->
<action ID="0" />
</transition>
</state>
<state NAME="translating" ID="21" X_POS="203" Y_POS="150" WIDTH="100" HEIGHT="50">
<transition NAME="leftButtonMove" NEXT_STATE_ID="21" EVENT_ID="530">
<!-- 1001 = SeTRANSLATE -->
<action ID="1000" />
</transition>
<transition NAME="leftButtonRelease" NEXT_STATE_ID="10" EVENT_ID="505">
<!-- 0 = no action -->
<action ID="0" />
</transition>
</state>
<state NAME="scaling" ID="31" X_POS="347" Y_POS="459" WIDTH="100" HEIGHT="50">
<transition NAME="rightButtonMove" NEXT_STATE_ID="31" EVENT_ID="531">
<!-- 1003 = SeSCALE -->
<action ID="1003" />
</transition>
<transition NAME="rightButtonRelease" NEXT_STATE_ID="10" EVENT_ID="507">
<!-- 0 = no action -->
<action ID="0" />
</transition>
</state>
<state NAME="rotating" ID="41" X_POS="657" Y_POS="465" WIDTH="100" HEIGHT="50">
<transition NAME="middleButtonMove" NEXT_STATE_ID="41" EVENT_ID="533">
<!-- 1005 = SeROTATE -->
<action ID="1005" />
</transition>
<transition NAME="middleButtonRelease" NEXT_STATE_ID="10" EVENT_ID="506">
<!-- 0 = no action -->
<action ID="0" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="AffineInteractions ctrl-drag">
<!-- affine interactions standard statemachine -->
<state NAME="start" ID="0" START_STATE="TRUE" X_POS="29" Y_POS="70" WIDTH="100" HEIGHT="50">
<transition NAME="leftButtonPress" NEXT_STATE_ID="12" EVENT_ID="5">
<!-- CTRL+LBM_Down -->
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
<transition NAME="leftButtonPress" NEXT_STATE_ID="12" EVENT_ID="540">
<!-- SHIFT+CTRL+LBM_Down -->
<action ID="11">
<!--AcADD-->
</action>
</transition>
<transition NAME="middleButtonPress" NEXT_STATE_ID="14" EVENT_ID="6">
<!-- CTRL+MBM_Down -->
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
<transition NAME="rightButtonPress" NEXT_STATE_ID="13" EVENT_ID="7">
<!-- CTRL+RBM_Down -->
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
</state>
<state NAME="picked guard Translate" ID="12" X_POS="376" Y_POS="34" WIDTH="151" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="2" EVENT_ID="1004">
<!-- EIDYES -->
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
<action ID="1000">
<!--AcTRANSLATESTART-->
</action>
</transition>
<transition NAME="no" NEXT_STATE_ID="0" EVENT_ID="1003">
<!-- StNO -->
</transition>
</state>
<state NAME="picked guard Scale" ID="13" X_POS="647" Y_POS="312" WIDTH="100" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="3" EVENT_ID="1004">
<!-- EIDYES -->
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
<action ID="1002">
<!--AcSCALESTART-->
</action>
</transition>
<transition NAME="no" NEXT_STATE_ID="0" EVENT_ID="1003">
<!-- StNO -->
<action ID="0" />
</transition>
</state>
<state NAME="picked guard Rotate" ID="14" X_POS="33" Y_POS="467" WIDTH="110" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="4" EVENT_ID="1004">
<!-- EIDYES -->
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
<action ID="1004" />
</transition>
<transition NAME="no" NEXT_STATE_ID="0" EVENT_ID="1003">
<!-- StNO -->
<action ID="0" />
</transition>
</state>
<state NAME="translating" ID="2" X_POS="724" Y_POS="59" WIDTH="100" HEIGHT="50">
<transition NAME="leftButtonMove" NEXT_STATE_ID="2" EVENT_ID="534">
<!-- CTRL+LBM_Move -->
<action ID="1001">
<!--AcTRANSLATE-->
</action>
</transition>
<transition NAME="leftButtonRelease" NEXT_STATE_ID="0" EVENT_ID="505">
<!-- LBM_Release-->
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
<action ID="1008">
<!--AcTRANSLATEEND-->
</action>
</transition>
<transition NAME="leftButtonRelease" NEXT_STATE_ID="0" EVENT_ID="537">
<!-- CTRL+LBM_Release -->
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
<action ID="1008">
<!--AcTRANSLATEEND-->
</action>
</transition>
</state>
<state NAME="rotating" ID="4" X_POS="371" Y_POS="481" WIDTH="100" HEIGHT="50">
<transition NAME="middleButtonMove" NEXT_STATE_ID="4" EVENT_ID="536">
<!-- CTRL+MBM_Move-->
<action ID="1005">
<!--AcROTATE-->
</action>
</transition>
<transition NAME="middleButtonRelease" NEXT_STATE_ID="0" EVENT_ID="506">
<!-- MBM_Release-->
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
<action ID="1010">
<!--AcROTATEEEND-->
</action>
</transition>
<transition NAME="middleButtonRelease" NEXT_STATE_ID="0" EVENT_ID="539">
<!-- CTRL+MBM_Release-->
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
<action ID="1010">
<!--AcROTATEEEND-->
</action>
</transition>
</state>
<state NAME="scaling" ID="3" X_POS="710" Y_POS="432" WIDTH="100" HEIGHT="50">
<transition NAME="rightButtonMove" NEXT_STATE_ID="3" EVENT_ID="535">
<!-- CTRL+RBM_Move -->
<action ID="1003">
<!--AcROTATE -->
</action>
</transition>
<transition NAME="rightButtonRelease" NEXT_STATE_ID="0" EVENT_ID="507">
<!-- RBM_Release ==> SeSCALE -->
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
<action ID="1009">
<!--AcSCALEEND-->
</action>
</transition>
<transition NAME="rightButtonRelease" NEXT_STATE_ID="0" EVENT_ID="538">
<!-- CTRL+RBM_Release ==> SeSCALE -->
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
<action ID="1009">
<!--AcSCALEEND-->
</action>
</transition>
</state>
</stateMachine>
<!-- obsolete state machine pattern to be removed in future releases
<stateMachine NAME="drag">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="232" Y_POS="131" WIDTH="100" HEIGHT="50">
<transition NAME="check picked" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="80" />
</transition>
<transition NAME="continue" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="90" />
</transition>
<transition NAME="exit" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
</state>
<state NAME="picked guard" ID="2" X_POS="94" Y_POS="360" WIDTH="100" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="3" EVENT_ID="1004">
<action ID="0" />
</transition>
<transition NAME="no" NEXT_STATE_ID="3" EVENT_ID="1003">
<action ID="0" />
</transition>
</state>
<state NAME="move" ID="3" X_POS="368" Y_POS="289" WIDTH="100" HEIGHT="50">
<transition NAME="continue" NEXT_STATE_ID="3" EVENT_ID="530">
<action ID="90" />
</transition>
<transition NAME="exit" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
</state>
</stateMachine>
-->
<stateMachine NAME="dragWithCtrl">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="439" Y_POS="166" WIDTH="100" HEIGHT="50">
<transition NAME="check picked" NEXT_STATE_ID="1" EVENT_ID="5">
<action ID="80" />
</transition>
<transition NAME="continue" NEXT_STATE_ID="1" EVENT_ID="534">
<action ID="90" />
</transition>
<transition NAME="exit" NEXT_STATE_ID="1" EVENT_ID="537">
<action ID="42" />
</transition>
<transition NAME="exit" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
<transition NAME="remove" NEXT_STATE_ID="1" EVENT_ID="12">
<action ID="100">
<!--AcREMOVEPOINT-->
</action>
</transition>
</state>
<!-- not reached so removed!
<state NAME="picked guard" ID="2" X_POS="141" Y_POS="427" WIDTH="100" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="3" EVENT_ID="1004">
<action ID="0" />
</transition>
<transition NAME="no" NEXT_STATE_ID="3" EVENT_ID="1003">
<action ID="0" />
</transition>
</state>
<state NAME="move" ID="3" X_POS="560" Y_POS="381" WIDTH="100" HEIGHT="50">
<transition NAME="continue" NEXT_STATE_ID="3" EVENT_ID="534">
<action ID="90" />
</transition>
<transition NAME="exit" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
<transition NAME="exit" NEXT_STATE_ID="1" EVENT_ID="537">
<action ID="42" />
</transition>
</state>
-->
</stateMachine>
<stateMachine NAME="focus">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="250" Y_POS="191" WIDTH="100" HEIGHT="50">
<transition NAME="changefocus" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="0" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="global">
<!-- Behaviour the global statemachine -->
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="203" Y_POS="168" WIDTH="100" HEIGHT="50">
<transition NAME="edit objects" NEXT_STATE_ID="2" EVENT_ID="1013" />
<!--EIDEDIT-->
<transition NAME="transmitt to all" NEXT_STATE_ID="1" EVENT_ID="0">
<!--EventId = 0-> all other events not defined here-->
<action ID="1200">
<!--AcINFORMLISTENERS-->
</action>
<action ID="1201">
<!--AcASKINTERACTORS-->
</action>
</transition>
</state>
<state NAME="edit object" ID="2" X_POS="508" Y_POS="404" WIDTH="100" HEIGHT="50">
<transition NAME="ready" NEXT_STATE_ID="1" EVENT_ID="1002" />
<!--EIDFINISHED-->
<transition NAME="transmitt to interactors only" NEXT_STATE_ID="2" EVENT_ID="0">
<action ID="1201">
<!--AcASKINTERACTORS-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="leftmouse">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="197" Y_POS="164" WIDTH="100" HEIGHT="50">
<transition NAME="send Koordinates" NEXT_STATE_ID="1" EVENT_ID="1" SIDE_EFFECT_ID="80">
<action ID="80" />
</transition>
<transition NAME="send Koordinates Move" NEXT_STATE_ID="1" EVENT_ID="530" SIDE_EFFECT_ID="80">
<action ID="80" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="measureinteractor">
<!-- Behaviour for measuring a length with lines-->
<state NAME="unbuild" ID="0" START_STATE="TRUE" X_POS="167" Y_POS="49" WIDTH="100" HEIGHT="50">
<transition NAME="forceSSD" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="5">
<!--AcINITNEWOBJECT-->
</action>
<action ID="1550">
<!--AcFORCESUBINTERACTORS-->
</action>
<action ID="1102">
<!--AcMODESUBSELECT-->
</action>
<action ID="2000">
<!--AcTRANSMITEVENT-->
</action>
</transition>
</state>
<state NAME="BuildUpSSD" ID="1" X_POS="433" Y_POS="329" WIDTH="100" HEIGHT="50">
<transition NAME="SubInteractorDeselect" NEXT_STATE_ID="10" EVENT_ID="1020">
<!-- necessary transition of the state subSelected. the event will produced from the hirachical interactor -->
<action ID="1101">
<!--AcMODEDESELECT-->
</action>
</transition>
<transition NAME="reinit" NEXT_STATE_ID="0" EVENT_ID="2">
<action ID="101" />
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
</state>
<state NAME="selected" ID="10" X_POS="617" Y_POS="56" WIDTH="100" HEIGHT="50">
<transition NAME="remove" NEXT_STATE_ID="0" EVENT_ID="12">
<action ID="101" />
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
<transition NAME="reinit" NEXT_STATE_ID="0" EVENT_ID="2">
<action ID="101" />
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="meshmove">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="193" Y_POS="74" WIDTH="100" HEIGHT="50">
<transition NAME="check picked" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="30" />
</transition>
</state>
<state NAME="picked guard" ID="2" X_POS="98" Y_POS="296" WIDTH="100" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="3" EVENT_ID="1004">
<action ID="0" />
</transition>
<transition NAME="no" NEXT_STATE_ID="1" EVENT_ID="1003">
<action ID="0" />
</transition>
</state>
<state NAME="move" ID="3" X_POS="467" Y_POS="276" WIDTH="100" HEIGHT="50">
<transition NAME="continue" NEXT_STATE_ID="3" EVENT_ID="530">
<action ID="90" />
</transition>
<transition NAME="exit" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="666" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="navigation">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="189" Y_POS="175" WIDTH="100" HEIGHT="50">
<transition NAME="send Koordinates press" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="92" />
</transition>
<transition NAME="send Koordinates move" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="92" />
</transition>
<transition NAME="send Koordinates release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="PositionTracker">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="212" Y_POS="188" WIDTH="100" HEIGHT="50">
<transition NAME="Mouse Move" EVENT_ID="520" NEXT_STATE_ID="1">
<action ID="92">
<!--AcMove-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="picking">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="264" Y_POS="239" WIDTH="100" HEIGHT="50">
<transition NAME="do picking" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="1003" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="PressMoveRelease">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="197" Y_POS="183" WIDTH="100" HEIGHT="50">
<transition NAME="send Koordinates press" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="80" />
</transition>
<transition NAME="send Koordinates move" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="90" />
</transition>
<transition NAME="send Koordinates release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="PressMoveReleaseAndPointSetting">
<state NAME="neutral" ID="1" START_STATE="TRUE">
<transition NAME="press" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="80" />
</transition>
<transition NAME="Shift+press" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="10" />
</transition>
<transition NAME="Shift+pressRMB" NEXT_STATE_ID="1" EVENT_ID="2000">
<action ID="6000" />
</transition>
<transition NAME="move" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="90" />
</transition>
<transition NAME="release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
<transition NAME="ENTF" NEXT_STATE_ID="1" EVENT_ID="12">
<action ID="100" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="PressMoveReleaseWithCTRLInversionAllMouseMoves">
<state NAME="neutral" ID="1" START_STATE="TRUE">
<transition NAME="press" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="80" />
</transition>
<transition NAME="CTRL+press" NEXT_STATE_ID="2" EVENT_ID="5">
<action ID="80" />
<action ID="49014" />
</transition>
<transition NAME="move w/ left button" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="90" />
</transition>
<transition NAME="move" NEXT_STATE_ID="1" EVENT_ID="520">
<action ID="90" />
</transition>
<transition NAME="CTRL+move" NEXT_STATE_ID="2" EVENT_ID="529">
<action ID="90" />
<action ID="49014" />
</transition>
<transition NAME="CTRL+move w/ left button" NEXT_STATE_ID="2" EVENT_ID="534">
<action ID="90" />
<action ID="49014" />
</transition>
<transition NAME="release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
</state>
<state NAME="inverted" ID="2">
<transition NAME="move w/ left button" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="90" />
<action ID="49014" />
</transition>
<transition NAME="move" NEXT_STATE_ID="1" EVENT_ID="520">
<action ID="49014" />
<action ID="90" />
</transition>
<transition NAME="CTRL+move" NEXT_STATE_ID="2" EVENT_ID="529">
<action ID="90" />
</transition>
<transition NAME="CTRL+press" NEXT_STATE_ID="2" EVENT_ID="5">
<action ID="80" />
</transition>
<transition NAME="press" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="80" />
</transition>
<transition NAME="CTRL+move w/ left button" NEXT_STATE_ID="2" EVENT_ID="534">
<action ID="90" />
</transition>
<transition NAME="release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
<action ID="49014" />
</transition>
<transition NAME="CTRL+release" NEXT_STATE_ID="2" EVENT_ID="537">
<action ID="42" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="PressMoveReleaseWithCTRLInversion">
<state NAME="neutral" ID="1" START_STATE="TRUE">
<transition NAME="press" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="80" />
</transition>
<transition NAME="CTRL+press" NEXT_STATE_ID="2" EVENT_ID="5">
<action ID="80" />
<action ID="49014" />
</transition>
<transition NAME="move w/ left button" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="90" />
</transition>
<transition NAME="CTRL+move" NEXT_STATE_ID="2" EVENT_ID="534">
<action ID="90" />
<action ID="49014" />
</transition>
<transition NAME="release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
<transition NAME="CTRL+release" NEXT_STATE_ID="1" EVENT_ID="537">
<action ID="49014" />
<action ID="42" />
<action ID="49014" />
</transition>
</state>
<state NAME="inverted" ID="2">
<transition NAME="CTRL+move" NEXT_STATE_ID="2" EVENT_ID="534">
<action ID="90" />
</transition>
<transition NAME="move" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="90" />
<action ID="49014" />
</transition>
<transition NAME="CTRL+release" NEXT_STATE_ID="1" EVENT_ID="537">
<action ID="42" />
<action ID="49014" />
</transition>
<transition NAME="release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
<action ID="49014" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="seedroi">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="381" Y_POS="315" WIDTH="100" HEIGHT="50">
<transition NAME="send Koordinates" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="80" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="seedsinteractor">
<!-- Behaviour of Seed Points -->
<state NAME="drawSeeds" ID="0" START_STATE="TRUE" X_POS="125" Y_POS="102" WIDTH="100" HEIGHT="50">
<transition NAME="drawForegroundSeed" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
<action ID="45">
<!--AcINITFOREGROUND-->
</action>
<action ID="11">
<!--AcADD-->
</action>
</transition>
<transition NAME="drawBackgroundSeed" NEXT_STATE_ID="2" EVENT_ID="2000">
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
<action ID="46">
<!--AcINITBACKGROUND-->
</action>
<action ID="11">
<!--AcADD-->
</action>
</transition>
<transition NAME="drawNeutralSeed" NEXT_STATE_ID="3" EVENT_ID="2003">
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
<action ID="47">
<!--AcINITNEUTRAL-->
</action>
<action ID="11">
<!--AcADD-->
</action>
</transition>
</state>
<state NAME="drawForeground" ID="1" X_POS="515" Y_POS="108" WIDTH="100" HEIGHT="50">
<transition NAME="drawForegroundSeeds" NEXT_STATE_ID="1" EVENT_ID="541">
<action ID="92">
<!--AcMOVE-->
</action>
</transition>
<transition NAME="drawSeeds" NEXT_STATE_ID="0" EVENT_ID="508">
<action ID="44">
<!--AcFINISH-->
</action>
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
</transition>
</state>
<state NAME="drawBackground" ID="2" X_POS="510" Y_POS="323" WIDTH="100" HEIGHT="50">
<transition NAME="drawBackgroundSeeds" NEXT_STATE_ID="2" EVENT_ID="2001">
<action ID="92">
<!--AcMOVE-->
</action>
</transition>
<transition NAME="drawSeeds" NEXT_STATE_ID="0" EVENT_ID="2002">
<action ID="44">
<!--AcFINISH-->
</action>
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
</transition>
</state>
<state NAME="drawNeutral" ID="3" X_POS="290" Y_POS="478" WIDTH="100" HEIGHT="50">
<transition NAME="drawNeutralSeeds" NEXT_STATE_ID="3" EVENT_ID="2004">
<action ID="92">
<!--AcMOVE-->
</action>
</transition>
<transition NAME="drawSeeds" NEXT_STATE_ID="0" EVENT_ID="2005">
<action ID="44">
<!--AcFINISH-->
</action>
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="vesseltreeinteraction">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="268" Y_POS="260" WIDTH="100" HEIGHT="50">
<transition NAME="do picking" NEXT_STATE_ID="1" EVENT_ID="5">
<action ID="1600" />
</transition>
<transition NAME="do picking" NEXT_STATE_ID="1" EVENT_ID="8">
<action ID="1600" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="YetAnotherVesselTreeInteractor">
<!-- state machine for vessel TREE interaction -->
<state NAME="no-vessel-picked" ID="0" START_STATE="TRUE" X_POS="282" Y_POS="146" WIDTH="100" HEIGHT="50">
<transition NAME="checkpicked" NEXT_STATE_ID="1" EVENT_ID="5">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
<transition NAME="checkpicked" NEXT_STATE_ID="1" EVENT_ID="8">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
</state>
<state NAME="check-guard" ID="1" X_POS="91" Y_POS="347" WIDTH="100" HEIGHT="50">
<transition NAME="check-successful" NEXT_STATE_ID="2" EVENT_ID="1004">
<action ID="65">
<!--AcSELECT-->
</action>
</transition>
<transition NAME="check-not-successful" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="75">
<!--AcDESELECT-->
</action>
</transition>
</state>
<state NAME="vessel-picked" ID="2" X_POS="419" Y_POS="340" WIDTH="100" HEIGHT="50">
<transition NAME="checkpicked" NEXT_STATE_ID="1" EVENT_ID="5">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
<transition NAME="checkpicked" NEXT_STATE_ID="1" EVENT_ID="8">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
</state>
</stateMachine>
<!-- state machine for vessel TREE interaction with multiple selection -->
<stateMachine NAME="YetAnotherVesselTreeInteractorMultipleSelection">
<state NAME="no-vessel-picked" ID="0" START_STATE="TRUE" X_POS="282" Y_POS="146" WIDTH="100" HEIGHT="50">
<transition NAME="checkpicked" NEXT_STATE_ID="1" EVENT_ID="5">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
<transition NAME="checkpicked" NEXT_STATE_ID="1" EVENT_ID="8">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
</state>
<state NAME="CheckPicked-GuardState" ID="1" X_POS="91" Y_POS="347" WIDTH="100" HEIGHT="50">
<transition NAME="picked-vessel" NEXT_STATE_ID="2" EVENT_ID="1004">
<action ID="65">
<!--AcSELECT-->
</action>
</transition>
<transition NAME="no-vessel-picked" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="75">
<!--AcDESELECT-->
</action>
</transition>
</state>
<state NAME="vessel-selected" ID="2" X_POS="419" Y_POS="340" WIDTH="100" HEIGHT="50">
<transition NAME="checkpicked" NEXT_STATE_ID="3" EVENT_ID="5">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
<transition NAME="checkpicked" NEXT_STATE_ID="1" EVENT_ID="8">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
</state>
<state NAME="guard-add-vessel2selection" ID="3" X_POS="419" Y_POS="340" WIDTH="100" HEIGHT="50">
<transition NAME="vessel-picked" NEXT_STATE_ID="2" EVENT_ID="1004">
<action ID="61">
<!--AcSELECTANOTHEROBJECT-->
</action>
</transition>
<transition NAME="no-vessel-picked" NEXT_STATE_ID="2" EVENT_ID="1003" />
</state>
</stateMachine>
<stateMachine NAME="TubeGraphInteraction">
<!--state machine for tube graph interactions with multiple selection-->
<state NAME="noTubePicked" ID="0" START_STATE="TRUE" X_POS="282" Y_POS="146" WIDTH="100" HEIGHT="50">
<transition NAME="checkTubePicked" NEXT_STATE_ID="1" EVENT_ID="5">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
<transition NAME="checkTubePicked" NEXT_STATE_ID="1" EVENT_ID="8">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
</state>
<state NAME="checkTubePickedGuardState" ID="1" X_POS="91" Y_POS="" WIDTH="347" HEIGHT="50">
<transition NAME="pickedTube" NEXT_STATE_ID="2" EVENT_ID="1004">
<action ID="65">
<!--AcSELECT-->
</action>
</transition>
<transition NAME="noTubePicked" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="75">
<!--AcDESELECT-->
</action>
</transition>
</state>
<state NAME="tubeSelected" ID="2" X_POS="419" Y_POS="340" WIDTH="100" HEIGHT="50">
<transition NAME="checkPicked" NEXT_STATE_ID="3" EVENT_ID="5">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
<transition NAME="checkPicked" NEXT_STATE_ID="1" EVENT_ID="8">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
</state>
<state NAME="addTubeToSelectionGuardState" ID="3" X_POS="419" Y_POS="340" WIDTH="100" HEIGHT="50">
<transition NAME="tubePicked" NEXT_STATE_ID="2" EVENT_ID="1004">
<action ID="61">
<!--AcSELECTANOTHEROBJECT-->
</action>
</transition>
<transition NAME="noTubePicked" NEXT_STATE_ID="2" EVENT_ID="1003" />
</state>
</stateMachine>
<stateMachine NAME="AriadneAssistent">
<!-- Behaviour of the AriadneAssistent -->
<state NAME="start" ID="1" START_STATE="TRUE" X_POS="500" Y_POS="530" WIDTH="100" HEIGHT="50">
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="chooseApplication" ID="2" X_POS="616" Y_POS="351" WIDTH="100" HEIGHT="50">
<transition NAME="EV_PATH_COLLECTION_SELECTED" NEXT_STATE_ID="3" EVENT_ID="5551003">
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
</transition>
<transition NAME="EV_NAVIGATION_SELECTED" NEXT_STATE_ID="40" EVENT_ID="5551004">
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
</transition>
</state>
<state NAME="choosePathCollection" ID="3" X_POS="657" Y_POS="23" WIDTH="126" HEIGHT="50">
<transition NAME="EV_NEXT" NEXT_STATE_ID="4" EVENT_ID="5551007">
<action ID="5550003">
<!--AC_SET_PREVIOUS_BUTTON_VISIBLE-->
</action>
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="1" />
</action>
</transition>
<transition NAME="EV_NAVIGATION_SELECTED" NEXT_STATE_ID="40" EVENT_ID="5551004" />
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="mountSensorForPathCollection" ID="4" X_POS="331" Y_POS="11" WIDTH="167" HEIGHT="50">
<transition NAME="EV_DONE" NEXT_STATE_ID="5" EVENT_ID="5551008">
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="2" EVENT_ID="5551002">
<action ID="5550004">
<!--AC_SET_PREVIOUS_BUTTON_INVISIBLE-->
</action>
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
<action ID="55500011">
<!--AC_SET_APPLICATION_SELECTED_FALSE-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="0" />
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="sensorMountedForPathCollection" ID="5" X_POS="7" Y_POS="26" WIDTH="191" HEIGHT="50">
<transition NAME="EV_NEXT" NEXT_STATE_ID="7" EVENT_ID="5551007">
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="55500012">
<!--AC_SENSOR_ATTACHED-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="2" />
</action>
<action ID="5550008">
<!--AC_CHECK_LANDMARK_COUNT-->
<intParameter NAME="MIN_COUNT" VALUE="3" />
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="4" EVENT_ID="5551002">
<action ID="5550009">
<!--AC_SET_DONE_FALSE-->
</action>
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="setLandmarks" ID="6" X_POS="229" Y_POS="369" WIDTH="100" HEIGHT="50">
<transition NAME="EV_NEW_LANDMARK" NEXT_STATE_ID="7" EVENT_ID="5551009">
<action ID="5550008">
<!--AC_CHECK_LANDMARK_COUNT-->
<intParameter NAME="MIN_COUNT" VALUE="3" />
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="4" EVENT_ID="5551002">
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="1" />
</action>
<action ID="5550009">
<!--AC_SET_DONE_FALSE-->
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="checkCount" ID="7" X_POS="-5" Y_POS="255" WIDTH="100" HEIGHT="50">
<transition NAME="EV_READY_FOR_COLLECTING_PATH" NEXT_STATE_ID="8" EVENT_ID="5551006">
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
</transition>
<transition NAME="EV_LESS_THEN_MIN_COUNT" NEXT_STATE_ID="6" EVENT_ID="5551005" />
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="readyForCollectingPath" ID="8" X_POS="-5" Y_POS="462" WIDTH="146" HEIGHT="50">
<transition NAME="EV_NEXT" NEXT_STATE_ID="9" EVENT_ID="5551007">
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="4" />
</action>
<action ID="55500014">
<!--AC_START_APPLICATION_TEXT-->
<stringParameter NAME="START_APPLICATION_TEXT" VALUE="Ariadne is now ready for path collection" />
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="Start" />
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="4" EVENT_ID="5551002">
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="1" />
</action>
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="5550009">
<!--AC_SET_DONE_FALSE-->
</action>
</transition>
<transition NAME="EV_REMOVE_LANDMARK" NEXT_STATE_ID="7" EVENT_ID="5551010">
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="&gt;" />
</action>
<action ID="5550008">
<!--AC_CHECK_LANDMARK_COUNT-->
<intParameter NAME="MIN_COUNT" VALUE="3" />
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="collectingPath" ID="9" X_POS="30" Y_POS="607" WIDTH="100" HEIGHT="50">
<transition NAME="EV_NEXT" NEXT_STATE_ID="2" EVENT_ID="5551007">
<action ID="55500013">
<!--AC_CLOSE_ASSISTENT-->
</action>
<action ID="55500011">
<!--AC_SET_APPLICATION_SELECTED_FALSE-->
</action>
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="5550004">
<!--AC_SET_PREVIOUS_BUTTON_INVISIBLE-->
</action>
<action ID="55500016">
<!--AC_START_PATHCOLLECTION-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="0" />
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="&gt;" />
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="8" EVENT_ID="5551002">
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="2" />
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="&gt;" />
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="&gt;" />
</action>
</transition>
</state>
<state NAME="chooseNavigation" ID="40" X_POS="1080" Y_POS="38" WIDTH="100" HEIGHT="50">
<transition NAME="EV_PATH_COLLECTION_SELECTED" NEXT_STATE_ID="3" EVENT_ID="5551003" />
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
<transition NAME="EV_NEXT" NEXT_STATE_ID="41" EVENT_ID="5551007">
<action ID="5550003">
<!--AC_SET_PREVIOUS_BUTTON_VISIBLE-->
</action>
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="3" />
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="chooseData" ID="41" X_POS="1100" Y_POS="199" WIDTH="100" HEIGHT="50">
<transition NAME="EV_DONE" NEXT_STATE_ID="42" EVENT_ID="5551008">
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="2" EVENT_ID="5551002">
<action ID="5550004">
<!--AC_SET_PREVIOUS_BUTTON_INVISIBLE-->
</action>
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
<action ID="55500011">
<!--AC_SET_APPLICATION_SELECTED_FALSE-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="0" />
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="dataChoosed" ID="42" X_POS="1111" Y_POS="353" WIDTH="100" HEIGHT="50">
<transition NAME="EV_NEXT" NEXT_STATE_ID="43" EVENT_ID="5551007">
<action ID="55500017">
<!--AC_LOAD_LANDMARKS-->
</action>
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="1" />
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="2" EVENT_ID="5551002">
<action ID="5550004">
<!--AC_SET_PREVIOUS_BUTTON_INVISIBLE-->
</action>
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
<action ID="55500011">
<!--AC_SET_APPLICATION_SELECTED_FALSE-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="0" />
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="mountSensorForNavigation" ID="43" X_POS="1059" Y_POS="473" WIDTH="144" HEIGHT="50">
<transition NAME="EV_DONE" NEXT_STATE_ID="44" EVENT_ID="5551008">
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="42" EVENT_ID="5551002">
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="3" />
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="sensorMountedForNavigation" ID="44" X_POS="844" Y_POS="613" WIDTH="100" HEIGHT="50">
<transition NAME="EV_NEXT" NEXT_STATE_ID="46" EVENT_ID="5551007">
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="55500012">
<!--AC_SENSOR_ATTACHED-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="2" />
</action>
<action ID="5550008">
<!--AC_CHECK_LANDMARK_COUNT-->
<intParameter NAME="MIN_COUNT" VALUE="3" />
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="43" EVENT_ID="5551002">
<action ID="5550009">
<!--AC_SET_DONE_FALSE-->
</action>
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="setLandmarks" ID="45" X_POS="1110" Y_POS="754" WIDTH="100" HEIGHT="50">
<transition NAME="EV_NEW_LANDMARK" NEXT_STATE_ID="46" EVENT_ID="5551009">
<action ID="5550008">
<!--AC_CHECK_LANDMARK_COUNT-->
<intParameter NAME="MIN_COUNT" VALUE="3" />
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="43" EVENT_ID="5551002">
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="3" />
</action>
<action ID="5550009">
<!--AC_SET_DONE_FALSE-->
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="checkCount" ID="46" X_POS="615" Y_POS="748" WIDTH="100" HEIGHT="50">
<transition NAME="EV_READY_FOR_COLLECTING_PATH" NEXT_STATE_ID="47" EVENT_ID="5551006">
<action ID="5550001">
<!--AC_SET_NEXT_BUTTON_VISIBLE-->
</action>
</transition>
<transition NAME="EV_LESS_THEN_MIN_COUNT" NEXT_STATE_ID="45" EVENT_ID="5551005" />
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="readyForNavigation" ID="47" X_POS="120" Y_POS="750" WIDTH="115" HEIGHT="50">
<transition NAME="EV_NEXT" NEXT_STATE_ID="48" EVENT_ID="5551007">
<action ID="55500018">
<!--AC_CALCULATE_LANDMARK_TRANSFORM-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="4" />
</action>
<action ID="55500014">
<!--AC_START_APPLICATION_TEXT-->
<stringParameter NAME="START_APPLICATION_TEXT" VALUE="Ariadne is now ready for navigation" />
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="Start" />
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="43" EVENT_ID="5551002">
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="3" />
</action>
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="5550009">
<!--AC_SET_DONE_FALSE-->
</action>
</transition>
<transition NAME="EV_REMOVE_LANDMARK" NEXT_STATE_ID="46" EVENT_ID="5551010">
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="&gt;" />
</action>
<action ID="5550008">
<!--AC_CHECK_LANDMARK_COUNT-->
<intParameter NAME="MIN_COUNT" VALUE="3" />
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
</transition>
</state>
<state NAME="Navigation" ID="48" X_POS="164" Y_POS="623" WIDTH="100" HEIGHT="50">
<transition NAME="EV_NEXT" NEXT_STATE_ID="2" EVENT_ID="5551007">
<action ID="55500013">
<!--AC_CLOSE_ASSISTENT-->
</action>
<action ID="55500011">
<!--AC_SET_APPLICATION_SELECTED_FALSE-->
</action>
<action ID="5550002">
<!--AC_SET_NEXT_BUTTON_INVISIBLE-->
</action>
<action ID="5550004">
<!--AC_SET_PREVIOUS_BUTTON_INVISIBLE-->
</action>
<action ID="55500015">
<!--AC_START_NAVIGATION-->
</action>
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="0" />
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="&gt;" />
</action>
</transition>
<transition NAME="EV_PREVIOUS" NEXT_STATE_ID="47" EVENT_ID="5551002">
<action ID="5550005">
<!--AC_SET_ASSISTAND_WIDGET_STECK-->
<intParameter NAME="WIDGET_ID" VALUE="2" />
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="&gt;" />
</action>
</transition>
<transition NAME="EV_INIT" NEXT_STATE_ID="2" EVENT_ID="5551001">
<action ID="55500010">
<!--AC_INIT-->
</action>
<action ID="5550007">
<!--AC_SET_NEXT_BUTTON_TEXT-->
<stringParameter NAME="BUTTON_TEXT" VALUE="&gt;" />
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="AffineInteractions ctrl-drag_marcus">
<state NAME="start" ID="0" START_STATE="TRUE" X_POS="314" Y_POS="214" WIDTH="100" HEIGHT="50">
<transition NAME="leftButtonPress" NEXT_STATE_ID="12" EVENT_ID="1">
<!-- 30 = SeCHECKELEMENT -->
<action ID="30" />
</transition>
<transition NAME="rightButtonPress" NEXT_STATE_ID="13" EVENT_ID="2">
<!-- 1002 = SeSCALESTART -->
<action ID="30" />
</transition>
<transition NAME="middleButtonPress" NEXT_STATE_ID="14" EVENT_ID="4">
<!-- 1004 = SeROTATESTART -->
<action ID="30" />
</transition>
</state>
<state NAME="picked guard Translate" ID="12" X_POS="52" Y_POS="62" WIDTH="143" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="2" EVENT_ID="1004">
<!-- EIDYES -->
<action ID="1000" />
</transition>
<transition NAME="no" NEXT_STATE_ID="0" EVENT_ID="1003">
<!-- StNO -->
<action ID="0" />
</transition>
</state>
<state NAME="picked guard Scale" ID="13" X_POS="848" Y_POS="233" WIDTH="100" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="3" EVENT_ID="1004">
<!-- EIDYES -->
<action ID="1002" />
</transition>
<transition NAME="no" NEXT_STATE_ID="0" EVENT_ID="1003">
<!-- StNO -->
<action ID="0" />
</transition>
</state>
<state NAME="picked guard Rotate" ID="14" X_POS="37" Y_POS="334" WIDTH="100" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="4" EVENT_ID="1004">
<!-- EIDYES -->
<action ID="1004" />
</transition>
<transition NAME="no" NEXT_STATE_ID="0" EVENT_ID="1003">
<!-- StNO -->
<action ID="0" />
</transition>
</state>
<state NAME="translating" ID="2" X_POS="481" Y_POS="47" WIDTH="100" HEIGHT="50">
<transition NAME="leftButtonMove" NEXT_STATE_ID="2" EVENT_ID="530">
<!-- 1000 = SeTRANSLATE -->
<action ID="1001" />
</transition>
<transition NAME="leftButtonRelease" NEXT_STATE_ID="0" EVENT_ID="505">
<!-- 1000 = SeTRANSLATE -->
<action ID="1001" />
</transition>
<transition NAME="leftButtonRelease" NEXT_STATE_ID="0" EVENT_ID="537">
<!-- CTRL+LBM_Release ==> SeTRANSLATE -->
<action ID="1001" />
</transition>
</state>
<state NAME="scaling" ID="3" X_POS="630" Y_POS="461" WIDTH="100" HEIGHT="50">
<transition NAME="rightButtonMove" NEXT_STATE_ID="3" EVENT_ID="531">
<!-- 1003 = SeSCALE -->
<action ID="1003" />
</transition>
<transition NAME="rightButtonRelease" NEXT_STATE_ID="0" EVENT_ID="507">
<!-- 1003 = SeSCALE -->
<action ID="1003" />
</transition>
<transition NAME="rightButtonRelease" NEXT_STATE_ID="0" EVENT_ID="538">
<!-- CTRL+RBM_Release ==> SeSCALE -->
<action ID="1003" />
</transition>
</state>
<state NAME="rotating" ID="4" X_POS="295" Y_POS="487" WIDTH="100" HEIGHT="50">
<transition NAME="middleButtonMove" NEXT_STATE_ID="4" EVENT_ID="533">
<!-- 1005 = SeROTATE -->
<action ID="1005" />
</transition>
<transition NAME="middleButtonRelease" NEXT_STATE_ID="0" EVENT_ID="506">
<!-- 1005 = SeROTATE -->
<action ID="1005" />
</transition>
<transition NAME="middleButtonRelease" NEXT_STATE_ID="0" EVENT_ID="539">
<!-- 1005 = SeROTATE -->
<action ID="1005" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="connectpointsinteractor">
<!-- Behaviour for connecting points using mitk::ConnectPointsInteractor -->
<state NAME="ready" ID="1" START_STATE="TRUE" X_POS="357" Y_POS="236" WIDTH="100" HEIGHT="50">
<transition NAME="addPoint but check n" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="10">
<!--AcADDPOINT-->
</action>
</transition>
<transition NAME="remove" NEXT_STATE_ID="1" EVENT_ID="12">
<action ID="100">
<!--AcREMOVEPOINT-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="coordinate-supply">
<state NAME="neutral" ID="1" START_STATE="TRUE" X_POS="439" Y_POS="228" WIDTH="100" HEIGHT="50">
<transition NAME="send Koordinates release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="EasySegmentation">
<state NAME="Checking for ActivateToolEvents" ID="0" START_STATE="TRUE" X_POS="193" Y_POS="206" WIDTH="174" HEIGHT="50">
<transition NAME="OnActivateToolEvent" EVENT_ID="1300" NEXT_STATE_ID="0">
<action ID="48009">
<!-- AcActivateTool -->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="segmentation-interactor-tool:movenzoom">
<state NAME="Ready to start" ID="0" START_STATE="TRUE">
<transition NAME="OnLeftMouseDown" EVENT_ID="1" NEXT_STATE_ID="3" />
<transition NAME="OnMiddleMouseDown" EVENT_ID="4" NEXT_STATE_ID="1">
<action ID="9">
<!-- AcInitMove -->
</action>
</transition>
<transition NAME="OnRightMouseDown" EVENT_ID="2" NEXT_STATE_ID="2">
<action ID="1011">
<!-- AcInitZoom -->
</action>
</transition>
</state>
<state NAME="Moving" ID="1">
<transition NAME="OnMouseMove" EVENT_ID="533" NEXT_STATE_ID="1">
<action ID="92">
<!-- AcMove -->
</action>
</transition>
<transition NAME="OnMiddleMouseUp" EVENT_ID="506" NEXT_STATE_ID="0" />
</state>
<state NAME="Zooming" ID="2">
<transition NAME="OnMouseMove" EVENT_ID="531" NEXT_STATE_ID="2">
<action ID="1012">
<!-- AcZoom -->
</action>
</transition>
<transition NAME="OnRightMouseUp" EVENT_ID="507" NEXT_STATE_ID="0" />
</state>
<state NAME="Click" ID="3">
<transition NAME="OnLeftMouseUp" EVENT_ID="505" NEXT_STATE_ID="0">
<action ID="31">
<!-- AcCheckObject -->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="segmentation-interactor-tool:needle">
<state NAME="Ready to start" ID="0" START_STATE="TRUE">
<transition NAME="OnMouseMove" EVENT_ID="520" NEXT_STATE_ID="0">
<action ID="49006">
<!-- AcUpdatePoint -->
</action>
</transition>
<transition NAME="OnKeyH" EVENT_ID="22" NEXT_STATE_ID="0">
<action ID="49004">
<!-- AcMovePoint1 -->
</action>
</transition>
<transition NAME="OnKeyT" EVENT_ID="17" NEXT_STATE_ID="0">
<action ID="49005">
<!-- AcMovePoint2 -->
</action>
</transition>
<transition NAME="OnKeyEsc" EVENT_ID="14" NEXT_STATE_ID="7">
<action ID="49009">
<!-- AcDisplayOptions -->
</action>
<action ID="49010">
<!-- AcCycle (cycle to first different needle) -->
</action>
</transition>
<transition NAME="OnLeftMouseDown" EVENT_ID="1" NEXT_STATE_ID="3">
<action ID="31">
<!-- AcCheckObject -->
</action>
</transition>
<transition NAME="OnMiddleMouseDown" EVENT_ID="4" NEXT_STATE_ID="1">
<action ID="9">
<!-- AcInitMove -->
</action>
</transition>
<transition NAME="OnRightMouseDown" EVENT_ID="2" NEXT_STATE_ID="2">
<action ID="1011">
<!-- AcInitZoom -->
</action>
</transition>
<transition NAME="OnShiftLeftMouseDown" EVENT_ID="3" NEXT_STATE_ID="0">
<action ID="21">
<!-- AcCheckPoint -->
</action>
</transition>
</state>
<state NAME="Moving" ID="1">
<transition NAME="OnMouseMove" EVENT_ID="533" NEXT_STATE_ID="1">
<action ID="92">
<!-- AcMove -->
</action>
</transition>
<transition NAME="OnMiddleMouseUp" EVENT_ID="506" NEXT_STATE_ID="0" />
</state>
<state NAME="Zooming" ID="2">
<transition NAME="OnMouseMove" EVENT_ID="531" NEXT_STATE_ID="2">
<action ID="1012">
<!-- AcZoom -->
</action>
</transition>
<transition NAME="OnRightMouseUp" EVENT_ID="507" NEXT_STATE_ID="0" />
</state>
<state NAME="Descision: what to drag?" ID="3">
<transition NAME="OnTip" EVENT_ID="1050" NEXT_STATE_ID="4" />
<transition NAME="OnHead" EVENT_ID="1051" NEXT_STATE_ID="5" />
<transition NAME="OnBody" EVENT_ID="1052" NEXT_STATE_ID="6" />
<transition NAME="OnNothing" EVENT_ID="1003" NEXT_STATE_ID="0" />
</state>
<state NAME="Tip dragging" ID="4">
<transition NAME="OnMouseMove" EVENT_ID="530" NEXT_STATE_ID="4">
<action ID="49002">
<!-- AcRotateAroundHead (Point1)-->
</action>
</transition>
<transition NAME="OnLeftMouseUp" EVENT_ID="505" NEXT_STATE_ID="0" />
</state>
<state NAME="Head dragging" ID="5">
<transition NAME="OnMouseMove" EVENT_ID="530" NEXT_STATE_ID="5">
<action ID="49003">
<!-- AcRotateAroundTip (Point2)-->
</action>
</transition>
<transition NAME="OnLeftMouseUp" EVENT_ID="505" NEXT_STATE_ID="0" />
</state>
<state NAME="Body dragging" ID="6">
<transition NAME="OnMouseMove" EVENT_ID="530" NEXT_STATE_ID="6">
<action ID="1001">
<!-- AcTranslate -->
</action>
</transition>
<transition NAME="OnLeftMouseUp" EVENT_ID="505" NEXT_STATE_ID="0" />
</state>
<state NAME="Needle choosing" ID="7">
<transition NAME="OnKeyEsc" EVENT_ID="14" NEXT_STATE_ID="7">
<action ID="49010">
<!-- AcCycle -->
</action>
</transition>
<transition NAME="OnKeyReturn" EVENT_ID="23" NEXT_STATE_ID="0">
<action ID="49011">
<!-- AcAccept -->
</action>
</transition>
<transition NAME="OnKeyReturn" EVENT_ID="24" NEXT_STATE_ID="0">
<action ID="49011">
<!-- AcAccept -->
</action>
</transition>
<transition NAME="OnKeySpace" EVENT_ID="25" NEXT_STATE_ID="0">
<action ID="49011">
<!-- AcAccept -->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="segmentation-interactor-tool:bubble">
<state NAME="Ready to start" ID="0" START_STATE="TRUE">
<!-- initial state: outside anything and checking for collisions -->
<transition NAME="OnLeftMouseDown" EVENT_ID="1" NEXT_STATE_ID="2">
<action ID="31">
<!-- AcCheckObject -->
</action>
</transition>
</state>
<state NAME="Drawing line" ID="1">
<!-- line drawing started, now always update the end point of the line -->
<transition NAME="OnEscape" EVENT_ID="14" NEXT_STATE_ID="0">
<action ID="48008">
<!-- AcCancel -->
</action>
</transition>
<transition NAME="OnMouseMove" EVENT_ID="530" NEXT_STATE_ID="1">
<action ID="48003">
<!-- AcUpdateLine -->
</action>
</transition>
<transition NAME="OnLeftMouseUp" EVENT_ID="505" NEXT_STATE_ID="0">
<action ID="48005">
<!-- AcTerminateLine -->
</action>
<action ID="48007">
<!-- AcCreateObjectFromLine -->
</action>
<action ID="48008">
<!-- AcCancel -->
</action>
</transition>
</state>
<state NAME="Decide between creating and modifying. modify?" ID="2">
<transition NAME="OnNo" EVENT_ID="1003" NEXT_STATE_ID="1">
<action ID="48004">
<!-- AcInitLine -->
</action>
</transition>
<transition NAME="OnYes" EVENT_ID="1004" NEXT_STATE_ID="6" />
</state>
<state NAME="Decide between left and right movement. Left?" ID="5">
<transition NAME="OnNo" EVENT_ID="1003" NEXT_STATE_ID="6">
<action ID="49012">
<!-- AcIncrease -->
</action>
</transition>
<transition NAME="OnYes" EVENT_ID="1004" NEXT_STATE_ID="6">
<action ID="49013">
<!-- AcDecrease -->
</action>
</transition>
</state>
<state NAME="Decide between left and right movement. Left?" ID="6">
<transition NAME="OnMouseMove" EVENT_ID="530" NEXT_STATE_ID="5">
<action ID="8">
<!-- AcInitMovement -->
</action>
</transition>
<transition NAME="OnMouseUp" EVENT_ID="505" NEXT_STATE_ID="0" />
</state>
</stateMachine>
<stateMachine NAME="pointinteractor">
<state NAME="unselected" ID="0" START_STATE="TRUE" X_POS="17" Y_POS="23" WIDTH="100" HEIGHT="50">
<transition NAME="addPoint" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="1101">
<!--AcMODESELECT-->
</action>
<action ID="10">
<!--AcADDPOINT-->
</action>
<action ID="30">
<!--AcCHECKELEMENT-->
<intParameter NAME="precision" VALUE="4" />
</action>
</transition>
<transition NAME="checkpicked" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="30">
<!--AcCHECKELEMENT-->
<intParameter NAME="precision" VALUE="4" />
</action>
</transition>
</state>
<state NAME="selected" ID="1" X_POS="663" Y_POS="89" WIDTH="100" HEIGHT="50">
<transition NAME="deselect all and add point" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="72">
<!--AcDESELECTALL-->
</action>
<action ID="10">
<!--AcADDPOINT-->
</action>
<action ID="30">
<!--AcCHECKELEMENT-->
<intParameter NAME="precision" VALUE="4" />
</action>
</transition>
<transition NAME="remove" NEXT_STATE_ID="5" EVENT_ID="12">
<action ID="1500">
<!--AcCHECKGREATERONE-->
</action>
</transition>
<transition NAME="checkSamePick" NEXT_STATE_ID="3" EVENT_ID="1">
<action ID="34">
<!--AcCHECKSELECTED-->
<intParameter NAME="precision" VALUE="4" />
</action>
</transition>
<transition NAME="deselect all" NEXT_STATE_ID="0" EVENT_ID="2000">
<action ID="72">
<!--AcDESELECTALL-->
</action>
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
</state>
<state NAME="checkpicked" ID="2" X_POS="385" Y_POS="221" WIDTH="100" HEIGHT="50">
<transition NAME="EIDNo" NEXT_STATE_ID="0" EVENT_ID="1003" />
<transition NAME="EIDYes" NEXT_STATE_ID="1" EVENT_ID="1004">
<action ID="1101">
<!--AcMODESELECT-->
</action>
<action ID="65">
<!--AcSELECT-->
</action>
</transition>
</state>
<state NAME="checkStillPicked" ID="3" X_POS="417" Y_POS="497" WIDTH="100" HEIGHT="50">
<transition NAME="EIDNo" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="72">
<!--AcDESELECTALL-->
</action>
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
<transition NAME="EIDYes" NEXT_STATE_ID="4" EVENT_ID="1004">
<action ID="8">
<!--AcINITMOVEMENT-->
</action>
</transition>
</state>
<state NAME="moves" ID="4" X_POS="799" Y_POS="483" WIDTH="100" HEIGHT="50">
<transition NAME="mousemove" NEXT_STATE_ID="4" EVENT_ID="530">
<action ID="91">
<!--AcMOVESELECTED-->
</action>
</transition>
<transition NAME="finishmove" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42">
<!--AcFINISHMOVEMENT-->
</action>
</transition>
</state>
<state NAME="checkGreaterOne" ID="5" X_POS="416" Y_POS="344" WIDTH="100" HEIGHT="50">
<transition NAME="StYes" NEXT_STATE_ID="1" EVENT_ID="1004">
<action ID="100">
<!--AcREMOVEPOINT-->
</action>
<action ID="61">
<!--AcSELECTANOTHEROBJECT-->
</action>
</transition>
<transition NAME="StNo" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="100">
<!--AcREMOVEPOINT-->
</action>
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="pointselectorinteractor">
<state NAME="unselected" ID="0" START_STATE="TRUE" X_POS="17" Y_POS="23" WIDTH="100" HEIGHT="50">
<transition NAME="addPoint" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="1101">
<!--AcMODESELECT-->
</action>
<action ID="10">
<!--AcADDPOINT-->
</action>
<action ID="30">
<!--AcCHECKELEMENT-->
<intParameter NAME="precision" VALUE="4" />
</action>
</transition>
<transition NAME="checkpicked" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="30">
<!--AcCHECKELEMENT-->
<intParameter NAME="precision" VALUE="4" />
</action>
</transition>
</state>
<state NAME="selected" ID="1" X_POS="663" Y_POS="89" WIDTH="100" HEIGHT="50">
<transition NAME="deselect all and add point" NEXT_STATE_ID="1" EVENT_ID="3">
<action ID="72">
<!--AcDESELECTALL-->
</action>
<action ID="10">
<!--AcADDPOINT-->
</action>
<action ID="30">
<!--AcCHECKELEMENT-->
<intParameter NAME="precision" VALUE="4" />
</action>
</transition>
<transition NAME="remove" NEXT_STATE_ID="5" EVENT_ID="12">
<action ID="1500">
<!--AcCHECKGREATERONE-->
</action>
</transition>
<transition NAME="checkSamePick" NEXT_STATE_ID="3" EVENT_ID="1">
<action ID="34">
<!--AcCHECKSELECTED-->
<intParameter NAME="precision" VALUE="4" />
</action>
</transition>
<transition NAME="deselect all" NEXT_STATE_ID="0" EVENT_ID="2000">
<action ID="72">
<!--AcDESELECTALL-->
</action>
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
</state>
<state NAME="checkpicked" ID="2" X_POS="385" Y_POS="221" WIDTH="100" HEIGHT="50">
<transition NAME="EIDNo" NEXT_STATE_ID="0" EVENT_ID="1003" />
<transition NAME="EIDYes" NEXT_STATE_ID="1" EVENT_ID="1004">
<action ID="1101">
<!--AcMODESELECT-->
</action>
<action ID="65">
<!--AcSELECT-->
</action>
</transition>
</state>
<state NAME="checkStillPicked" ID="3" X_POS="417" Y_POS="497" WIDTH="100" HEIGHT="50">
<transition NAME="EIDNo" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="72">
<!--AcDESELECTALL-->
</action>
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
<transition NAME="EIDYes" NEXT_STATE_ID="4" EVENT_ID="1004">
<action ID="8">
<!--AcINITMOVEMENT-->
</action>
</transition>
</state>
<state NAME="moves" ID="4" X_POS="799" Y_POS="483" WIDTH="100" HEIGHT="50">
<transition NAME="mousemove" NEXT_STATE_ID="4" EVENT_ID="530">
<action ID="91">
<!--AcMOVESELECTED-->
</action>
</transition>
<transition NAME="finishmove" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42">
<!--AcFINISHMOVEMENT-->
</action>
</transition>
</state>
<state NAME="checkGreaterOne" ID="5" X_POS="416" Y_POS="344" WIDTH="100" HEIGHT="50">
<transition NAME="StYes" NEXT_STATE_ID="1" EVENT_ID="1004">
<action ID="100">
<!--AcREMOVEPOINT-->
</action>
<action ID="61">
<!--AcSELECTANOTHEROBJECT-->
</action>
</transition>
<transition NAME="StNo" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="100">
<!--AcREMOVEPOINT-->
</action>
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="pointsetinteractor">
<!-- Behaviour of a set of Points. a defined number of points can be set/removed/selected/deselectd/moved -->
<state NAME="no points or loaded points" ID="1" START_STATE="TRUE" X_POS="1066" Y_POS="281" WIDTH="100" HEIGHT="50">
<transition NAME="0SmallerPointsLoadedSmallerN" NEXT_STATE_ID="2" EVENT_ID="1014" />
<!-- If points have been loaded, goto right state; checked in constructor -->
<transition NAME="PointsLoadedGreaterEqualsN" NEXT_STATE_ID="4" EVENT_ID="1015" />
<!-- If points have been loaded, goto right state; checked in constructor -->
<transition NAME="addPoint but check n" NEXT_STATE_ID="3" EVENT_ID="3">
<action ID="1101" />
<!--AcMODE_SELECT-->
<action ID="32" />
</transition>
<transition NAME="checkn Delete" NEXT_STATE_ID="30" EVENT_ID="12">
<action ID="330" />
<!--AcCHECKNUMBEROFPOINTS-->
</transition>
<transition NAME="SetThisStatemachineOnSelected" NEXT_STATE_ID="1" EVENT_ID="1030">
<action ID="1101" />
<!--AcMODE_SELECT-->
</transition>
<transition NAME="SetThisStatemachineOnDeselected" NEXT_STATE_ID="1" EVENT_ID="1031">
<action ID="1100" />
<!--AcMODE_DESELECT-->
</transition>
</state>
<state NAME="space left" ID="2" X_POS="659" Y_POS="257" WIDTH="100" HEIGHT="50">
<transition NAME="addPoint but check n" NEXT_STATE_ID="3" EVENT_ID="3">
<action ID="32" />
</transition>
<transition NAME="Select or move point Space" NEXT_STATE_ID="10" EVENT_ID="1">
<action ID="30" />
</transition>
<transition NAME="check selected and Delete" NEXT_STATE_ID="31" EVENT_ID="12">
<action ID="340" />
<!--AcCHECKONESELECTED-->
</transition>
<transition NAME="DeselectAll" NEXT_STATE_ID="2" EVENT_ID="14">
<!--Event = ESC-->
<action ID="72" />
<!--AcDESELECTALL-->
<action ID="1100" />
<!--AcMODE_DESELECT-->
</transition>
</state>
<state NAME="checkedN" ID="3" X_POS="745" Y_POS="744" WIDTH="100" HEIGHT="50">
<transition NAME="n smaller N" NEXT_STATE_ID="40" EVENT_ID="1010">
<action ID="37" />
</transition>
<transition NAME="n greater equals N" NEXT_STATE_ID="41" EVENT_ID="1011">
<action ID="37" />
</transition>
</state>
<state NAME="set full" ID="4" X_POS="267" Y_POS="633" WIDTH="100" HEIGHT="50">
<transition NAME="Select or move point FULL" NEXT_STATE_ID="20" EVENT_ID="1">
<action ID="30" />
<!--AcCHECKELEMENT-->
</transition>
<transition NAME="checkn Delete selected Point" NEXT_STATE_ID="30" EVENT_ID="12">
<action ID="330" />
<!--AcCHECKNUMBEROFPOINTS-->
</transition>
<transition NAME="DeselectAll" NEXT_STATE_ID="2" EVENT_ID="14">
<!--Event = ESC-->
<action ID="72" />
<!--AcDESELECTALL-->
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
</state>
<state NAME="picked NotFull" ID="10" X_POS="903" Y_POS="38" WIDTH="100" HEIGHT="50">
<transition NAME="StNo" NEXT_STATE_ID="2" EVENT_ID="1003">
<action ID="72" />
<!--AcDESELECTALL-->
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
<transition NAME="StYes" NEXT_STATE_ID="11" EVENT_ID="1004">
<action ID="34" />
<!--AcCHECKSELECTED-->
<action ID="1101" />
<!--AcMODESELECT-->
</transition>
</state>
<state NAME="already selected Space" ID="11" X_POS="391" Y_POS="11" WIDTH="100" HEIGHT="50">
<transition NAME="StNo" NEXT_STATE_ID="2" EVENT_ID="1003">
<action ID="60" />
</transition>
<transition NAME="StYes" NEXT_STATE_ID="12" EVENT_ID="1004">
<action ID="8" />
</transition>
</state>
<state NAME="move Point Space" ID="12" X_POS="100" Y_POS="99" WIDTH="100" HEIGHT="50">
<transition NAME="move point" NEXT_STATE_ID="12" EVENT_ID="530">
<action ID="91" />
</transition>
<transition NAME="finish move" NEXT_STATE_ID="2" EVENT_ID="505">
<action ID="42" />
</transition>
<transition NAME="Safety init" NEXT_STATE_ID="12" EVENT_ID="1">
<action ID="8" />
</transition>
</state>
<state NAME="picked Full" ID="20" X_POS="122" Y_POS="766" WIDTH="100" HEIGHT="50">
<transition NAME="StNO" NEXT_STATE_ID="4" EVENT_ID="1003">
<action ID="72" />
<!--AcDESELECTALL-->
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
<transition NAME="StYES" NEXT_STATE_ID="21" EVENT_ID="1004">
<action ID="34" />
<!--AcCHECKSELECTED-->
<action ID="1101" />
<!--AcMODESELECT-->
</transition>
</state>
<state NAME="selected Full" ID="21" X_POS="23" Y_POS="485" WIDTH="100" HEIGHT="50">
<transition NAME="StNo" NEXT_STATE_ID="4" EVENT_ID="1003">
<action ID="60" />
<!--AcSELECTPICKEDOBJECT-->
</transition>
<transition NAME="StYes" NEXT_STATE_ID="22" EVENT_ID="1004">
<action ID="8" />
<!--AcINITMOVEMENT-->
</transition>
</state>
<state NAME="move Point Full" ID="22" X_POS="67" Y_POS="255" WIDTH="100" HEIGHT="50">
<!-- since the MouseMove Event is send by QT we don't have the information about the position of the point in the list. we had it before, when we checked, if it was picked, or if it was selected -->
<transition NAME="move point" NEXT_STATE_ID="22" EVENT_ID="530">
<action ID="91" />
</transition>
<transition NAME="finish move" NEXT_STATE_ID="4" EVENT_ID="505">
<action ID="42" />
</transition>
<transition NAME="Safety init" NEXT_STATE_ID="22" EVENT_ID="1">
<action ID="8" />
</transition>
</state>
<state NAME="checkn Delete" ID="30" X_POS="1124" Y_POS="708" WIDTH="100" HEIGHT="50">
<transition NAME="StillFull" NEXT_STATE_ID="4" EVENT_ID="1015">
<action ID="100" />
<!--AcREMOVEPOINT-->
</transition>
<transition NAME="NotEmptyNotFull" NEXT_STATE_ID="2" EVENT_ID="1014">
<action ID="100" />
<!--AcREMOVEPOINT-->
</transition>
<transition NAME="WillBeEmpty" NEXT_STATE_ID="1" EVENT_ID="1017">
<action ID="100" />
<!--AcREMOVEPOINT-->
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
</state>
<state NAME="selected space left" ID="31" X_POS="22" Y_POS="480" WIDTH="90" HEIGHT="50">
<transition NAME="StNo" NEXT_STATE_ID="2" EVENT_ID="1003" />
<transition NAME="StYes" NEXT_STATE_ID="30" EVENT_ID="1004">
<action ID="330" />
<!--AcCHECKNUMBEROFPOINTS-->
</transition>
</state>
<state NAME="checkedPositionEventSmallerN" ID="40" X_POS="267" Y_POS="301" WIDTH="173" HEIGHT="50">
<transition NAME="PositionEvent" NEXT_STATE_ID="2" EVENT_ID="1004">
<action ID="10" />
<!--AcADDPOINT-->
<action ID="1100" />
<!--AcMODE_DESELECT-->
</transition>
<transition NAME="others" NEXT_STATE_ID="2" EVENT_ID="1003">
<action ID="1100" />
<!--AcMODE_DESELECT-->
</transition>
</state>
<state NAME="checkedPositionEventGreaterN" ID="41" X_POS="562" Y_POS="424" WIDTH="168" HEIGHT="50">
<transition NAME="PositionEvent" NEXT_STATE_ID="4" EVENT_ID="1004">
<action ID="10" />
<!--AcADDPOINT-->
<action ID="1100" />
<!--AcMODE_DESELECT-->
</transition>
<transition NAME="others" NEXT_STATE_ID="2" EVENT_ID="1003">
<action ID="1100" />
<!--AcMODE_DESELECT-->
</transition>
</state>
</stateMachine>
<stateMachine NAME="onlymovepointsetinteractor">
<!-- Behaviour of a set of Points. The points can only be selected and moved.-->
<state NAME="no points or loaded points" ID="1" START_STATE="TRUE" X_POS="1066" Y_POS="281" WIDTH="100" HEIGHT="50">
<transition NAME="0SmallerPointsLoadedSmallerN" NEXT_STATE_ID="2" EVENT_ID="1014" />
<!-- If points have been loaded, goto right state; checked in constructor -->
<transition NAME="PointsLoadedGreaterEqualsN" NEXT_STATE_ID="2" EVENT_ID="1015" />
<!-- If points have been loaded, goto right state; checked in constructor -->
<transition NAME="SetThisStatemachineOnSelected" NEXT_STATE_ID="1" EVENT_ID="1030">
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
</transition>
<transition NAME="SetThisStatemachineOnDeselected" NEXT_STATE_ID="1" EVENT_ID="1031">
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
</transition>
</state>
<state NAME="loaded points" ID="2" X_POS="659" Y_POS="257" WIDTH="100" HEIGHT="50">
<transition NAME="Select or move point" NEXT_STATE_ID="10" EVENT_ID="1">
<action ID="30" />
</transition>
<transition NAME="DeselectAll" NEXT_STATE_ID="2" EVENT_ID="14">
<!--Event = ESC-->
<action ID="72">
<!--AcDESELECTALL-->
</action>
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
</transition>
</state>
<state NAME="picked point" ID="10" X_POS="903" Y_POS="38" WIDTH="100" HEIGHT="50">
<transition NAME="StNo" NEXT_STATE_ID="2" EVENT_ID="1003">
<action ID="72">
<!--AcDESELECTALL-->
</action>
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
<transition NAME="StYes" NEXT_STATE_ID="11" EVENT_ID="1004">
<action ID="34">
<!--AcCHECKSELECTED-->
</action>
<action ID="1101">
<!--AcMODESELECT-->
</action>
</transition>
</state>
<state NAME="already selected point" ID="11" X_POS="391" Y_POS="11" WIDTH="100" HEIGHT="50">
<transition NAME="StNo" NEXT_STATE_ID="2" EVENT_ID="1003">
<action ID="60" />
</transition>
<transition NAME="StYes" NEXT_STATE_ID="12" EVENT_ID="1004">
<action ID="8" />
</transition>
</state>
<state NAME="move point" ID="12" X_POS="100" Y_POS="99" WIDTH="100" HEIGHT="50">
<transition NAME="move point" NEXT_STATE_ID="12" EVENT_ID="530">
<action ID="91" />
</transition>
<transition NAME="finish move" NEXT_STATE_ID="2" EVENT_ID="505">
<action ID="42" />
</transition>
<transition NAME="Safety init" NEXT_STATE_ID="12" EVENT_ID="1">
<action ID="8" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="seedpointsetinteractor">
<!-- Behaviour of one Point. Point is added by clicking left Mouse Button and holding Shift-->
<state NAME="no point" ID="1" START_STATE="TRUE" X_POS="59" Y_POS="45" WIDTH="169" HEIGHT="50">
<transition NAME="0SmallerPointsLoadedSmallerN" NEXT_STATE_ID="10" EVENT_ID="1014" />
<!-- If point has been loaded, goto right state; checked in constructor -->
<transition NAME="PointsLoadedGreaterEqualsN" NEXT_STATE_ID="10" EVENT_ID="1015" />
<!-- If point has been loaded, goto right state; checked in constructor -->
<transition NAME="addPoint" NEXT_STATE_ID="2" EVENT_ID="3">
<action ID="1101">
<!--AcMODESELECT-->
</action>
<action ID="37" />
<!--AcCHECKOPERATION-->
</transition>
</state>
<state NAME="checkPositionEvent" ID="2" X_POS="164" Y_POS="334" WIDTH="166" HEIGHT="50">
<transition NAME="PositionEvent" NEXT_STATE_ID="10" EVENT_ID="1004">
<action ID="10" />
<!--AcADDPOINT-->
</transition>
<transition NAME="others" NEXT_STATE_ID="1" EVENT_ID="1003">
<action ID="0" />
</transition>
</state>
<state NAME="point" ID="10" X_POS="914" Y_POS="734" WIDTH="100" HEIGHT="50">
<transition NAME="insertPoint" NEXT_STATE_ID="11" EVENT_ID="3">
<action ID="37" />
<!--AcCHECKOPERATION-->
</transition>
<transition NAME="Select or move point" NEXT_STATE_ID="12" EVENT_ID="1">
<action ID="30" />
<!--AcCHECKELEMENT-->
</transition>
<transition NAME="check selected and delete" NEXT_STATE_ID="15" EVENT_ID="12">
<action ID="340" />
<!--AcCHECKONESELECTED-->
</transition>
</state>
<state NAME="checkedPositionEventPoint" ID="11" X_POS="758" Y_POS="478" WIDTH="100" HEIGHT="50">
<transition NAME="PositionEvent" NEXT_STATE_ID="10" EVENT_ID="1004">
<action ID="103" />
<!--AcREMOVEALL-->
<action ID="10" />
<!--AcADDPOINT-->
</transition>
<transition NAME="others" NEXT_STATE_ID="10" EVENT_ID="1003">
<action ID="0" />
</transition>
</state>
<state NAME="picked point" ID="12" X_POS="23" Y_POS="560" WIDTH="150" HEIGHT="50">
<transition NAME="StNo" NEXT_STATE_ID="10" EVENT_ID="1003">
<action ID="72" />
<!--AcDESELECTALL-->
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
<transition NAME="StYes" NEXT_STATE_ID="13" EVENT_ID="1004">
<action ID="34" />
<!--AcCHECKSELECTED-->
<action ID="1101" />
<!--AcMODESELECT-->
</transition>
</state>
<state NAME="selected" ID="13" X_POS="23" Y_POS="485" WIDTH="100" HEIGHT="50">
<transition NAME="StNo" NEXT_STATE_ID="10" EVENT_ID="1003">
<action ID="60" />
<!--AcSELECTPICKEDOBJECT-->
</transition>
<transition NAME="StYes" NEXT_STATE_ID="14" EVENT_ID="1004">
<action ID="8" />
<!--AcINITMOVEMENT-->
</transition>
</state>
<state NAME="move Point" ID="14" X_POS="76" Y_POS="731" WIDTH="100" HEIGHT="50">
<transition NAME="move point" NEXT_STATE_ID="14" EVENT_ID="530">
<action ID="91" />
<!--AcMOVESELECTED-->
</transition>
<transition NAME="finish move" NEXT_STATE_ID="10" EVENT_ID="505">
<action ID="42" />
<!--AcFINISHMOVEMENT-->
</transition>
<transition NAME="Safety init" NEXT_STATE_ID="14" EVENT_ID="1">
<action ID="8" />
<!--AcINITMOVEMENT-->
</transition>
</state>
<state NAME="already selected" ID="15" X_POS="23" Y_POS="560" WIDTH="150" HEIGHT="50">
<transition NAME="StNo" NEXT_STATE_ID="10" EVENT_ID="1003" />
<transition NAME="StYes" NEXT_STATE_ID="16" EVENT_ID="1004">
<action ID="33" />
<!--AcCHECKEQUALS1-->
</transition>
</state>
<state NAME="delete" ID="16" X_POS="1151" Y_POS="19" WIDTH="100" HEIGHT="50">
<transition NAME="equalsOne" NEXT_STATE_ID="1" EVENT_ID="1004">
<action ID="100" />
<!--AcREMOVEPOINT-->
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
<transition NAME="largerOne" NEXT_STATE_ID="10" EVENT_ID="1003">
<action ID="100" />
<!--AcREMOVEPOINT-->
</transition>
</state>
</stateMachine>
<stateMachine NAME="VesselGraphInteractor">
<state NAME="Start" ID="1" START_STATE="TRUE" X_POS="1390" Y_POS="-1" WIDTH="100" HEIGHT="50">
<transition NAME="goToCheckPicking" NEXT_STATE_ID="2" EVENT_ID="5">
<action ID="31">
<!--AcCHECKOBJECT-->
</action>
</transition>
<transition NAME="goToCheckPicking" NEXT_STATE_ID="2" EVENT_ID="8">
<action ID="31">
<!--AcCHECKOBJECT-->
</action>
</transition>
</state>
<state NAME="CheckPicking" ID="2" X_POS="515" Y_POS="263" WIDTH="100" HEIGHT="50">
<transition NAME="noPicked" NEXT_STATE_ID="4" EVENT_ID="1003">
<action ID="66">
<!-- AcSELECTPOINT -->
</action>
</transition>
<transition NAME="yesPicked" NEXT_STATE_ID="3" EVENT_ID="1004">
<action ID="69">
<!-- AcSELECTSUBOBJECT -->
</action>
</transition>
</state>
<state NAME="OneVesselPicked" ID="3" X_POS="1488" Y_POS="350" WIDTH="100" HEIGHT="50">
<transition NAME="goToCheckPicking" NEXT_STATE_ID="5" EVENT_ID="5">
<action ID="31">
<!-- AcCHECKOBJECT -->
</action>
</transition>
<transition NAME="goToCheckPicking" NEXT_STATE_ID="5" EVENT_ID="8">
<action ID="31">
<!-- AcCHECKOBJECT -->
</action>
</transition>
<transition NAME="delete" NEXT_STATE_ID="1" EVENT_ID="12">
<action ID="104">
<!-- AcREMOVESELECTEDSUBOBJECT -->
</action>
</transition>
<transition NAME="deselectAll" NEXT_STATE_ID="1" EVENT_ID="14">
<action ID="72">
<!-- AcDESELECTALL -->
</action>
</transition>
<transition NAME="searchPeriphery" NEXT_STATE_ID="11" EVENT_ID="15">
<action ID="3000">
<!-- AcPERIPHERYSEARCH -->
</action>
</transition>
<transition NAME="searchToRoot" NEXT_STATE_ID="11" EVENT_ID="16">
<action ID="3001">
<!-- AcROOTSEARCH -->
</action>
</transition>
<transition NAME="searchToThickstVessel" NEXT_STATE_ID="11" EVENT_ID="17">
<action ID="3002">
<!-- AcTHICKSTVESSELSEARCH -->
</action>
</transition>
<!--now follow the attibutations for different vessel types-->
<transition NAME="attributation" NEXT_STATE_ID="3" EVENT_ID="20">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="0" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="3" EVENT_ID="21">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="1" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="3" EVENT_ID="30">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="2" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="3" EVENT_ID="31">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="3" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="3" EVENT_ID="40">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="4" />
</action>
</transition>
<transition NAME="default" NEXT_STATE_ID="1" EVENT_ID="90">
<action ID="3007">
<!-- AcDEFAULT -->
</action>
</transition>
</state>
<state NAME="OnePointPicked" ID="4" X_POS="339" Y_POS="103" WIDTH="100" HEIGHT="50">
<transition NAME="goToCheckPicking" NEXT_STATE_ID="6" EVENT_ID="5">
<action ID="31">
<!-- AcCHECKOBJECT -->
</action>
</transition>
<transition NAME="goToCheckPicking" NEXT_STATE_ID="6" EVENT_ID="8">
<action ID="31">
<!-- AcCHECKOBJECT -->
</action>
</transition>
<transition NAME="deselectAll" NEXT_STATE_ID="1" EVENT_ID="14">
<action ID="72">
<!-- AcDESELECTALL -->
</action>
</transition>
</state>
<state NAME="CheckPicking" ID="5" X_POS="43" Y_POS="721" WIDTH="100" HEIGHT="50">
<transition NAME="noPicked" NEXT_STATE_ID="7" EVENT_ID="1003">
<action ID="66">
<!-- AcSELECTPOINT -->
</action>
</transition>
<transition NAME="yesPicked" NEXT_STATE_ID="13" EVENT_ID="1004">
<action ID="69">
<!-- AcSELECTSUBOBJECT -->
</action>
<action ID="3010">
<!-- AcCHECKBARRIERSTATUS -->
</action>
</transition>
</state>
<state NAME="CheckPicking" ID="6" X_POS="552" Y_POS="156" WIDTH="100" HEIGHT="50">
<transition NAME="noPicked" NEXT_STATE_ID="9" EVENT_ID="1003">
<action ID="66">
<!-- AcSELECTPOINT -->
</action>
</transition>
<transition NAME="yesPicked" NEXT_STATE_ID="7" EVENT_ID="1004">
<action ID="69">
<!-- AcSELECTSUBOBJECT -->
</action>
</transition>
</state>
<state NAME="OneVesselOnePointPicked" ID="7" X_POS="665" Y_POS="378" WIDTH="151" HEIGHT="50">
<transition NAME="ENew" NEXT_STATE_ID="1" EVENT_ID="13">
<action ID="81">
<!-- AcNEWSUBOBJECT -->
</action>
<action ID="72">
<!-- AcDESELECTALL -->
</action>
</transition>
<transition NAME="deselectAll" NEXT_STATE_ID="1" EVENT_ID="14">
<action ID="72">
<!-- AcDESELECTALL -->
</action>
</transition>
<transition NAME="delete" NEXT_STATE_ID="1" EVENT_ID="12">
<action ID="104">
<!-- AcREMOVESELECTEDSUBOBJECT -->
</action>
</transition>
<transition NAME="setVesselElement" NEXT_STATE_ID="7" EVENT_ID="91">
<action ID="3008">
<!-- AcSETVESSELELEMENT-->
</action>
</transition>
<!--now follow the attibutations for different vessel types-->
<transition NAME="attributation" NEXT_STATE_ID="7" EVENT_ID="20">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="0" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="7" EVENT_ID="21">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="1" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="7" EVENT_ID="30">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="2" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="7" EVENT_ID="31">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="3" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="7" EVENT_ID="40">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="4" />
</action>
</transition>
<transition NAME="default" NEXT_STATE_ID="1" EVENT_ID="90">
<action ID="3007">
<!-- AcDEFAULT -->
</action>
</transition>
</state>
<state NAME="TwoVesselsPicked" ID="8" X_POS="77" Y_POS="79" WIDTH="100" HEIGHT="50">
<transition NAME="ENew" NEXT_STATE_ID="1" EVENT_ID="13">
<action ID="81">
<!-- AcNEWSUBOBJECT -->
</action>
<action ID="72">
<!-- AcDESELECTALL -->
</action>
</transition>
<transition NAME="goToCheckPicking" NEXT_STATE_ID="10" EVENT_ID="5">
<action ID="31">
<!-- AcCHECKOBJECT -->
</action>
</transition>
<transition NAME="goToCheckPicking" NEXT_STATE_ID="10" EVENT_ID="8">
<action ID="31">
<!-- AcCHECKOBJECT -->
</action>
</transition>
<transition NAME="searchShortestPathBetween2Edges" NEXT_STATE_ID="11" EVENT_ID="18">
<action ID="3003">
<!-- AcSHORTESTPATHSEARCH -->
</action>
</transition>
<transition NAME="deselectAll" NEXT_STATE_ID="1" EVENT_ID="14">
<action ID="72">
<!-- AcDESELECTALL -->
</action>
</transition>
<transition NAME="delete" NEXT_STATE_ID="1" EVENT_ID="12">
<action ID="104">
<!-- AcREMOVESELECTEDSUBOBJECT -->
</action>
</transition>
<transition NAME="setVesselElement" NEXT_STATE_ID="8" EVENT_ID="91">
<action ID="3008">
<!-- AcSETVESSELELEMENT-->
</action>
</transition>
<!--now follow the attibutations for different vessel types-->
<transition NAME="attributation" NEXT_STATE_ID="8" EVENT_ID="20">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="0" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="8" EVENT_ID="21">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="1" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="8" EVENT_ID="30">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="2" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="8" EVENT_ID="31">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="3" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="8" EVENT_ID="40">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="4" />
</action>
</transition>
<transition NAME="default" NEXT_STATE_ID="1" EVENT_ID="90">
<action ID="3007">
<!-- AcDEFAULT -->
</action>
</transition>
</state>
<state NAME="TwoPointsPicked" ID="9" X_POS="748" Y_POS="140" WIDTH="100" HEIGHT="50">
<transition NAME="ENew" NEXT_STATE_ID="1" EVENT_ID="13">
<action ID="81">
<!-- AcNEWSUBOBJECT -->
</action>
</transition>
<transition NAME="deselectAll" NEXT_STATE_ID="1" EVENT_ID="14">
<action ID="72">
<!-- AcDESELECTALL -->
</action>
</transition>
<transition NAME="setVesselElement" NEXT_STATE_ID="9" EVENT_ID="91">
<action ID="3008">
<!-- AcSETVESSELELEMENT-->
</action>
</transition>
</state>
<state NAME="CheckPicking" ID="10" X_POS="642" Y_POS="805" WIDTH="100" HEIGHT="50">
<transition NAME="noPicked" NEXT_STATE_ID="12" EVENT_ID="1003">
<action ID="36">
<!--AcCHECKGREATERTWO-->
</action>
</transition>
<transition NAME="yesPicked" NEXT_STATE_ID="14" EVENT_ID="1004">
<action ID="69">
<!-- AcSELECTSUBOBJECT -->
</action>
<action ID="3010">
<!-- AcCHECKBARRIERSTATUS -->
</action>
</transition>
</state>
<state NAME="MoreVesselsPicked" ID="11" X_POS="933" Y_POS="754" WIDTH="100" HEIGHT="50">
<transition NAME="delete" NEXT_STATE_ID="1" EVENT_ID="12">
<action ID="104">
<!-- AcDESELECTALL -->
</action>
</transition>
<transition NAME="goToCheckPicking" NEXT_STATE_ID="10" EVENT_ID="5">
<action ID="31">
<!-- AcCHECKOBJECT -->
</action>
</transition>
<transition NAME="goToCheckPicking" NEXT_STATE_ID="10" EVENT_ID="8">
<action ID="31">
<!-- AcCHECKOBJECT -->
</action>
</transition>
<transition NAME="deselectAll" NEXT_STATE_ID="1" EVENT_ID="14">
<action ID="72">
<!-- AcDESELECTALL -->
</action>
</transition>
<transition NAME="singleSignal" NEXT_STATE_ID="3" EVENT_ID="19">
<action ID="3004">
<!-- AcSINGLE -->
</action>
</transition>
<!--now follow the attibutations for different vessel types-->
<transition NAME="attributation" NEXT_STATE_ID="11" EVENT_ID="20">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="0" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="11" EVENT_ID="21">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="1" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="11" EVENT_ID="30">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="2" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="11" EVENT_ID="31">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="3" />
</action>
</transition>
<transition NAME="attributation" NEXT_STATE_ID="11" EVENT_ID="40">
<action ID="3005">
<!-- AcATTRIBUTATION -->
<intParameter NAME="attribute_id" VALUE="4" />
</action>
</transition>
<transition NAME="default" NEXT_STATE_ID="1" EVENT_ID="90">
<action ID="3007">
<!-- AcDEFAULT -->
</action>
</transition>
</state>
<state NAME="CheckNumberPickedVesselsSmaller2" ID="12" X_POS="259" Y_POS="707" WIDTH="188" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="8" EVENT_ID="1004" />
<transition NAME="no" NEXT_STATE_ID="11" EVENT_ID="1003">
<action ID="69">
<!-- AcSELECTSUBOBJECT -->
</action>
</transition>
</state>
<state NAME="CheckBarrierStatus" ID="13" X_POS="8" Y_POS="318" WIDTH="100" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="3" EVENT_ID="1004" />
<transition NAME="no" NEXT_STATE_ID="8" EVENT_ID="1003" />
</state>
<state NAME="CheckBarrierStatus" ID="14" X_POS="557" Y_POS="510" WIDTH="100" HEIGHT="50">
<transition NAME="yes" NEXT_STATE_ID="8" EVENT_ID="1004" />
<transition NAME="no" NEXT_STATE_ID="11" EVENT_ID="1003" />
</state>
</stateMachine>
<stateMachine NAME="slices-rotator">
<state NAME="neutral" ID="1" START_STATE="TRUE">
<!-- mouse down: jump to decision state -->
<transition NAME="mouse down" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="21">
<!-- AcCheckPoint -->
</action>
</transition>
<transition NAME="mouse move" NEXT_STATE_ID="5" EVENT_ID="520">
<action ID="21">
<!-- AcCheckPoint -->
</action>
</transition>
</state>
<state NAME="rotate?" ID="2">
<transition NAME="yes" NEXT_STATE_ID="3" EVENT_ID="1004" />
<transition NAME="no" NEXT_STATE_ID="4" EVENT_ID="1003">
<action ID="92">
<!--AcMove-->
</action>
</transition>
</state>
<state NAME="rotate" ID="3">
<!-- send rotate events -->
<transition NAME="mouse move" NEXT_STATE_ID="3" EVENT_ID="530">
<action ID="1005">
<!--AcRotate-->
</action>
</transition>
<transition NAME="mouse release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="1010">
<!--AcRotateEnd-->
</action>
</transition>
</state>
<state NAME="move" ID="4">
<!-- send move events -->
<transition NAME="mouse move" NEXT_STATE_ID="4" EVENT_ID="530">
<action ID="92">
<!--AcMove-->
</action>
</transition>
<transition NAME="mouse release" NEXT_STATE_ID="1" EVENT_ID="505" />
</state>
<state NAME="rotation possible?" ID="5">
<transition NAME="yes" NEXT_STATE_ID="6" EVENT_ID="1004">
<action ID="1004">
<!--AcRotateStart-->
</action>
</transition>
<transition NAME="no" NEXT_STATE_ID="1" EVENT_ID="1003" />
</state>
<state NAME="rotation possible!" ID="6">
<!-- mouse down: jump to decision state -->
<transition NAME="mouse down" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="21">
<!-- AcCheckPoint -->
</action>
</transition>
<transition NAME="mouse move" NEXT_STATE_ID="7" EVENT_ID="520">
<action ID="21">
<!-- AcCheckPoint -->
</action>
</transition>
</state>
<state NAME="rotation possible?" ID="7">
<transition NAME="yes" NEXT_STATE_ID="6" EVENT_ID="1004" />
<transition NAME="no" NEXT_STATE_ID="1" EVENT_ID="1003">
<action ID="1010">
<!--AcRotateEnd-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="dummy">
<!-- Dummy for a null interaction -->
<state NAME="neutral" ID="0" START_STATE="TRUE">
<transition NAME="stay in dummy" NEXT_STATE_ID="0" EVENT_ID="0" />
</state>
</stateMachine>
<stateMachine NAME="SpaceNavigatorInteraction">
<state NAME="neutral" ID="1" START_STATE="TRUE">
<transition NAME="stay in dummy" NEXT_STATE_ID="1" EVENT_ID="4001">
<action ID="4001" />
<!--AcONTDMOUSEINPUT-->
</transition>
<transition NAME="stay with button down" NEXT_STATE_ID="1" EVENT_ID="4002">
<action ID="4002" />
<!--AcONTDMOUSEKEYDOWN-->
</transition>
</state>
</stateMachine>
<stateMachine NAME="WiiMoteHeadtracking">
<state NAME="headtracking" ID="1" START_STATE="TRUE">
<transition NAME="startState" NEXT_STATE_ID="1" EVENT_ID="4003">
<!--EIDWIIMOTEINPUT-->
<action ID="4003" />
<!--AcONWIIMOTEINPUT-->
</transition>
<transition NAME="buttonState" NEXT_STATE_ID="1" EVENT_ID="4004">
<!--EIDWIIMOTEBUTTON-->
<action ID="4004" />
<!--AcRESETVIEW-->
</transition>
<transition NAME="initCalibration" NEXT_STATE_ID="2" EVENT_ID="5551001">
<!--EV_INIT-->
<action ID="55500010" />
<!--AC_INIT-->
</transition>
</state>
<state NAME="calibration" ID="2">
<transition NAME="collectIRData" NEXT_STATE_ID="2" EVENT_ID="4003">
<!--EIDWIIMOTEINPUT-->
<action ID="21" />
<!--AcCHECKPOINT-->
</transition>
<transition NAME="endCalibration" NEXT_STATE_ID="1" EVENT_ID="5551001">
<!--EV_INIT-->
<action ID="44" />
<!--AcFINISH-->
</transition>
</state>
</stateMachine>
<stateMachine NAME="WiiMoteSurfaceInteraction">
<state NAME="start" ID="1" START_STATE="TRUE">
<transition NAME="initial state" NEXT_STATE_ID="2" EVENT_ID="4005" />
<!--EIDWIIMOTEBUTTONB-->
<transition NAME="reset object" NEXT_STATE_ID="1" EVENT_ID="4004">
<!--EIDWIIMOTEBUTTON-->
<action ID="4004" />
<!--AcRESETVIEW-->
</transition>
</state>
<state NAME="Surface Interaction" ID="2">
<transition NAME="stop Surface Interaction" NEXT_STATE_ID="1" EVENT_ID="5551008">
<!--EV_DONE-->
<action ID="4005">
<!-- AcONWIIMOTEBUTTONRELEASED -->
</action>
</transition>
<transition NAME="Input for Surface Interaction" NEXT_STATE_ID="2" EVENT_ID="4003">
<!--EIDWIIMOTEINPUT-->
<action ID="4003">
<!--AcONWIIMOTEINPUT-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="InteractorTestPattern">
<!-- To Test an Interactor for the right behavior -->
<state NAME="neutral" ID="0" START_STATE="TRUE">
<transition NAME="to1" NEXT_STATE_ID="1" EVENT_ID="4">
<action ID="1101" />
<!--AcMODESELECT-->
</transition>
<transition NAME="to2" NEXT_STATE_ID="2" EVENT_ID="2">
<action ID="1011" />
<!--AcMODESELECT-->
</transition>
</state>
<state NAME="State1" ID="1">
<transition NAME="StayIn1" NEXT_STATE_ID="1" EVENT_ID="533" />
<transition NAME="to0" NEXT_STATE_ID="0" EVENT_ID="506">
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
</state>
<state NAME="State2" ID="2">
<transition NAME="StayIn2" NEXT_STATE_ID="2" EVENT_ID="531" />
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="507">
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
</state>
</stateMachine>
<stateMachine NAME="shapemodelpointsetinteractor">
<state NAME="Interaction Activated, no point loaded yet" ID="1" START_STATE="TRUE" X_POS="457" Y_POS="506" WIDTH="226" HEIGHT="56">
<transition NAME="SetStateMachineOnDeselected" EVENT_ID="1031" NEXT_STATE_ID="1">
<action ID="1100" />
</transition>
<transition NAME="SetStateMachineOnSelected" EVENT_ID="1030" NEXT_STATE_ID="1">
<action ID="1101" />
</transition>
<transition NAME="Add Point" EVENT_ID="3" NEXT_STATE_ID="2">
<action ID="10" />
</transition>
</state>
<state NAME="One Point" ID="2" X_POS="567" Y_POS="145" WIDTH="100" HEIGHT="50">
<transition NAME="Move Point" EVENT_ID="3" NEXT_STATE_ID="2">
<action ID="103" />
<action ID="10" />
</transition>
<transition NAME="Remove Point" EVENT_ID="12" NEXT_STATE_ID="1">
<action ID="100" />
</transition>
<transition NAME="Check if point is hit by mouse click" EVENT_ID="1" NEXT_STATE_ID="3">
<action ID="30" />
</transition>
<transition NAME="name" EVENT_ID="14" NEXT_STATE_ID="2">
<action ID="72" />
<action ID="1100" />
</transition>
</state>
<state NAME="CheckPoint" ID="3" X_POS="64" Y_POS="52" WIDTH="100" HEIGHT="50">
<transition NAME="Point not hit" EVENT_ID="1003" NEXT_STATE_ID="2">
<action ID="72" />
<action ID="1100" />
</transition>
<transition NAME="Point is hit, check if is selected or not" EVENT_ID="1004" NEXT_STATE_ID="5">
<action ID="34" />
<action ID="1101" />
</transition>
</state>
<state NAME="PointMove" ID="4" X_POS="278" Y_POS="422" WIDTH="100" HEIGHT="50">
<transition NAME="Adjust the Mesh according to point move" EVENT_ID="505" NEXT_STATE_ID="2">
<action ID="42" />
</transition>
<transition NAME="name" EVENT_ID="530" NEXT_STATE_ID="4">
<action ID="1236" />
<action ID="91" />
<action ID="1234" />
</transition>
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="4">
<action ID="8" />
</transition>
</state>
<state NAME="Already Selected?" ID="5" X_POS="187" Y_POS="247" WIDTH="100" HEIGHT="50">
<transition NAME="Initialize Movement" EVENT_ID="1004" NEXT_STATE_ID="4">
<action ID="8" />
<action ID="1235" />
</transition>
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="2">
<action ID="60" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="singlepointinteractor">
<!-- Behaviour of one point. This single point can be set, selected and then moved and removed. A setting of a new point will delete the old one.-->
<state NAME="no point or loaded point not selected" ID="1" START_STATE="TRUE" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="SetThisStatemachineOnSelected" NEXT_STATE_ID="1" EVENT_ID="1030">
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
</transition>
<transition NAME="SetThisStatemachineOnDeselected" NEXT_STATE_ID="1" EVENT_ID="1031">
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
</transition>
<transition NAME="addPoint but check n" NEXT_STATE_ID="42" EVENT_ID="3">
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
<action ID="103" />
<action ID="10" />
</transition>
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="43">
<action ID="30" />
</transition>
</state>
<state NAME="picked" ID="20" X_POS="693" Y_POS="587" WIDTH="100" HEIGHT="50">
<transition NAME="StNO" NEXT_STATE_ID="1" EVENT_ID="1003">
<action ID="72">
<!--AcDESELECTALL-->
</action>
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
<transition NAME="StYes" NEXT_STATE_ID="22" EVENT_ID="1004">
<action ID="8">
<!--AcINITMOVEMENT-->
</action>
<action ID="1101" />
</transition>
</state>
<state NAME="move point" ID="22" X_POS="1135" Y_POS="449" WIDTH="100" HEIGHT="50">
<!-- since the MouseMove Event is send by QT we don't have the information about the position of the point in the list. we had it before, when we checked, if it was picked, or if it was selected -->
<transition NAME="move point" NEXT_STATE_ID="22" EVENT_ID="530">
<action ID="91" />
</transition>
<transition NAME="Safety init" NEXT_STATE_ID="22" EVENT_ID="1">
<action ID="8" />
</transition>
<transition NAME="finish move" NEXT_STATE_ID="42" EVENT_ID="505">
<action ID="42" />
</transition>
</state>
<state NAME="point selected" ID="42" X_POS="674" Y_POS="341" WIDTH="100" HEIGHT="50">
<transition NAME="Select or move point FULL" NEXT_STATE_ID="20" EVENT_ID="1">
<action ID="30">
<!--AcCHECKELEMENT-->
</action>
</transition>
<transition NAME="StYes" NEXT_STATE_ID="1" EVENT_ID="12">
<action ID="100" />
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
<transition NAME="name" EVENT_ID="3" NEXT_STATE_ID="42">
<action ID="103" />
<action ID="10" />
</transition>
</state>
<state NAME="picked not yet selected" ID="43" X_POS="681" Y_POS="158" WIDTH="126" HEIGHT="50">
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="42">
<action ID="60" />
</transition>
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="1">
<action ID="72" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="moveNzoom">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initmove" NEXT_STATE_ID="1" EVENT_ID="4">
<action ID="9" />
</transition>
<transition NAME="initzoom" NEXT_STATE_ID="2" EVENT_ID="2">
<action ID="1011" />
</transition>
</state>
<state NAME="move" ID="1" X_POS="170" Y_POS="413" WIDTH="100" HEIGHT="50">
<transition NAME="move" NEXT_STATE_ID="1" EVENT_ID="533">
<action ID="92" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="506">
<action ID="43" />
</transition>
</state>
<state NAME="zoom" ID="2" X_POS="584" Y_POS="432" WIDTH="100" HEIGHT="50">
<transition NAME="zoom" NEXT_STATE_ID="2" EVENT_ID="531">
<action ID="1012" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="507" />
</state>
</stateMachine>
<stateMachine NAME="OnePointDoubleClickInteraction">
<state NAME="empty" ID="0" START_STATE="TRUE">
<transition NAME="doubleclick" NEXT_STATE_ID="1" EVENT_ID="8">
<action ID="10" />
</transition>
<transition NAME="delete" NEXT_STATE_ID="0" EVENT_ID="12">
<action ID="103" />
</transition>
</state>
<state NAME="point available" ID="1">
<transition NAME="doubleclick" NEXT_STATE_ID="1" EVENT_ID="8">
<action ID="103" />
<action ID="10" />
</transition>
<transition NAME="delete" NEXT_STATE_ID="0" EVENT_ID="12">
<action ID="103" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="OnePointMouseMoveInteraction">
<state NAME="empty" ID="0" START_STATE="TRUE">
<transition NAME="mousemove" NEXT_STATE_ID="1" EVENT_ID="520">
<action ID="1101" />
<!--AcMODE_SELECT-->
<action ID="10" />
<!-- Add Point -->
</transition>
<transition NAME="mousewheelmove" NEXT_STATE_ID="1" EVENT_ID="9">
<action ID="1101" />
<!--AcMODE_SELECT-->
<action ID="10" />
<!-- Add Point -->
</transition>
<transition NAME="deleteSafety" NEXT_STATE_ID="0" EVENT_ID="12">
<action ID="103" />
<!-- Remove Point -->
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
</state>
<state NAME="point available" ID="1">
<transition NAME="mousemove" NEXT_STATE_ID="1" EVENT_ID="520">
<action ID="1101" />
<!--AcMODE_SELECT-->
<action ID="103" />
<!-- Remove Point -->
<action ID="10" />
<!-- Add Point -->
</transition>
<transition NAME="mousewheelmove" NEXT_STATE_ID="1" EVENT_ID="9">
<action ID="1101" />
<!--AcMODE_SELECT-->
<action ID="103" />
<!-- Remove Point -->
<action ID="10" />
<!-- Add Point -->
</transition>
<transition NAME="delete" NEXT_STATE_ID="0" EVENT_ID="12">
<action ID="103" />
<!-- Remove Point -->
<action ID="1100" />
<!--AcMODEDESELECT-->
</transition>
</state>
</stateMachine>
<stateMachine NAME="CurveModelInteractor">
<!-- Behaviour of a set of Points. a defined number of points can be set/removed/selected/deselectd/moved -->
<state NAME="Start" ID="42" START_STATE="TRUE" X_POS="918" Y_POS="441" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="43">
<action ID="21" />
</transition>
</state>
<state NAME="IsPointSelected" ID="43" X_POS="470" Y_POS="441" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="42">
<action ID="72" />
</transition>
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="44" />
</state>
<state NAME="PointSelected" ID="44" X_POS="690" Y_POS="204" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="530" NEXT_STATE_ID="44">
<action ID="91" />
</transition>
<transition NAME="name" EVENT_ID="505" NEXT_STATE_ID="42">
<action ID="43" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="singlepointinteractorwithoutshiftclick">
<!-- Behaviour of one point. This single point can be set, selected and then moved and removed. A setting of a new point will delete the old one.-->
<state NAME="no point or loaded point not selected" ID="1" START_STATE="TRUE" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="SetThisStatemachineOnSelected" NEXT_STATE_ID="1" EVENT_ID="1030">
<action ID="1101">
<!--AcMODE_SELECT-->
</action>
</transition>
<transition NAME="SetThisStatemachineOnDeselected" NEXT_STATE_ID="1" EVENT_ID="1031">
<action ID="1100">
<!--AcMODE_DESELECT-->
</action>
</transition>
<transition NAME="addPoint" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="1101" />
<!--AcMODE_SELECT-->
<action ID="103" />
<!--AcREMOVEALL-->
<action ID="10" />
<!--AcADDPOINT-->
</transition>
</state>
<state NAME="point selected" ID="2" X_POS="674" Y_POS="341" WIDTH="100" HEIGHT="50">
<transition NAME="delete point" NEXT_STATE_ID="1" EVENT_ID="12">
<action ID="100" />
<!--AcREMOVEPOINT-->
<action ID="1100">
<!--AcMODEDESELECT-->
</action>
</transition>
<transition NAME="set point" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="103" />
<!--AcREMOVEALL-->
<action ID="10" />
<!--AcADDPOINT-->
</transition>
</state>
</stateMachine>
<stateMachine NAME="SeedpointCorrection">
<state NAME="position check" ID="0" START_STATE="TRUE" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="nothing found" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="48008" />
</transition>
<transition NAME="inside" NEXT_STATE_ID="1" EVENT_ID="1004">
<action ID="31" />
<transition NAME="check position" NEXT_STATE_ID="0" EVENT_ID="520">
<action ID="5000" />
</transition>
<transition NAME="check position 2" NEXT_STATE_ID="0" EVENT_ID="530">
<action ID="5000" />
</transition>
<transition NAME="change BoundingBox" NEXT_STATE_ID="3" EVENT_ID="1013">
<action ID="65" />
</transition>
</transition>
</state>
<state NAME="edit seedpoints" ID="1" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="back to start" NEXT_STATE_ID="0" EVENT_ID="520">
<action ID="12" />
</transition>
<transition NAME="initialize correction" NEXT_STATE_ID="2" EVENT_ID="530">
<action ID="5001" />
</transition>
</state>
<state NAME="correct segmentation" ID="2" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="draw contour" NEXT_STATE_ID="2" EVENT_ID="530">
<action ID="92" />
</transition>
<transition NAME="calculate result" NEXT_STATE_ID="0" EVENT_ID="505">
<action ID="5002" />
</transition>
</state>
<state NAME="init BoundingBox Resizing" ID="3" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="back to start 2" NEXT_STATE_ID="0" EVENT_ID="520">
<action ID="5000" />
</transition>
<transition NAME="add boundingboxinteractor" NEXT_STATE_ID="4" EVENT_ID="1">
<action ID="5003" />
</transition>
</state>
<state NAME="BoundingBox Resizing" ID="4" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="calculate result 2" NEXT_STATE_ID="0" EVENT_ID="23">
<action ID="5004" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="BoundingBox Interaction">
<state NAME="position check" ID="0" START_STATE="TRUE" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="test" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="5000" />
</transition>
<transition NAME="test" NEXT_STATE_ID="3" EVENT_ID="520">
<action ID="5000" />
</transition>
</state>
<state NAME="boundingbox resizing initialization" ID="1" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="nothing found" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="47" />
</transition>
<transition NAME="something found" NEXT_STATE_ID="2" EVENT_ID="1004">
<action ID="94" />
<action ID="110" />
</transition>
</state>
<state NAME="teststate" ID="2" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="test 2" NEXT_STATE_ID="2" EVENT_ID="530">
<action ID="11" />
</transition>
<transition NAME="test 3" NEXT_STATE_ID="0" EVENT_ID="505">
<action ID="5" />
</transition>
<transition NAME="test 9" NEXT_STATE_ID="4" EVENT_ID="1003">
<action ID="0" />
</transition>
</state>
<state NAME="teststate 2" ID="3" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="test 4" NEXT_STATE_ID="3" EVENT_ID="1004">
<action ID="94" />
</transition>
<transition NAME="test 5" NEXT_STATE_ID="0" EVENT_ID="520">
<action ID="5000" />
</transition>
<transition NAME="test 6" NEXT_STATE_ID="0" EVENT_ID="1003">
<action ID="47" />
</transition>
<transition NAME="test 7" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="5000" />
</transition>
</state>
<state NAME="teststate 2" ID="4" X_POS="18" Y_POS="336" WIDTH="197" HEIGHT="50">
<transition NAME="test 8" NEXT_STATE_ID="4" EVENT_ID="530">
<action ID="0" />
</transition>
<transition NAME="test 9" NEXT_STATE_ID="0" EVENT_ID="505">
<action ID="0" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="ToolWithWheelInteraction">
<state NAME="ToolIdle" ID="1" START_STATE="TRUE" X_POS="167" Y_POS="365" WIDTH="100" HEIGHT="50">
<transition NAME="MouseWheel" EVENT_ID="9" NEXT_STATE_ID="1">
<action ID="105" />
</transition>
<transition NAME="send Koordinates press" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="80" />
</transition>
<transition NAME="MouseMove" EVENT_ID="520" NEXT_STATE_ID="1">
<action ID="92" />
</transition>
<transition NAME="name" EVENT_ID="26" NEXT_STATE_ID="1">
<action ID="106" />
</transition>
<transition NAME="name" EVENT_ID="27" NEXT_STATE_ID="1">
<action ID="107" />
</transition>
</state>
<state NAME="ToolInUse" ID="2" X_POS="511" Y_POS="372" WIDTH="100" HEIGHT="50">
<transition NAME="send Koordinates move" NEXT_STATE_ID="2" EVENT_ID="530">
<action ID="90" />
</transition>
<transition NAME="send Koordinates release" NEXT_STATE_ID="1" EVENT_ID="505">
<action ID="42" />
</transition>
<transition NAME="MouseWheel" EVENT_ID="9" NEXT_STATE_ID="2">
<action ID="105" />
</transition>
<transition NAME="name" EVENT_ID="26" NEXT_STATE_ID="2">
<action ID="106" />
</transition>
<transition NAME="name" EVENT_ID="27" NEXT_STATE_ID="2">
<action ID="107" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="AffineInteractor3D">
<state NAME="Start" ID="1" START_STATE="TRUE" X_POS="65" Y_POS="267" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="2">
<action ID="31" />
</transition>
</state>
<state NAME="IsOverObject" ID="2" X_POS="352" Y_POS="267" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="1">
<action ID="70" />
</transition>
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="3">
<action ID="60" />
</transition>
<transition NAME="name" EVENT_ID="9" NEXT_STATE_ID="2">
<action ID="49014" />
</transition>
</state>
<state NAME="ObjectSelected" ID="3" X_POS="719" Y_POS="268" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="2">
<action ID="31" />
</transition>
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="4">
<action ID="9" />
</transition>
<transition NAME="name" EVENT_ID="9" NEXT_STATE_ID="3">
<action ID="49014" />
</transition>
</state>
<state NAME="ObjectInteraction" ID="4" X_POS="598" Y_POS="629" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="530" NEXT_STATE_ID="4">
<action ID="92" />
</transition>
<transition NAME="name" EVENT_ID="505" NEXT_STATE_ID="2">
<action ID="31" />
</transition>
<transition NAME="name" EVENT_ID="521" NEXT_STATE_ID="4">
<action ID="49014" />
<action ID="92" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="alternativeZoom">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initzoom" NEXT_STATE_ID="1" EVENT_ID="7">
<action ID="1011" />
</transition>
</state>
<state NAME="zoom" ID="1" X_POS="584" Y_POS="432" WIDTH="100" HEIGHT="50">
<transition NAME="CtrlZoom" NEXT_STATE_ID="1" EVENT_ID="535">
<action ID="1012" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="538" />
</state>
</stateMachine>
<stateMachine NAME="LeftClickScroll">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initmove" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="9" />
</transition>
</state>
<state NAME="scroll" ID="1" X_POS="170" Y_POS="413" WIDTH="100" HEIGHT="50">
<transition NAME="scroll" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="1013" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="505">
<action ID="43" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="alternativePan">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initshiftmove" NEXT_STATE_ID="1" EVENT_ID="2000">
<action ID="9" />
</transition>
</state>
<state NAME="shiftmove" ID="1" X_POS="170" Y_POS="413" WIDTH="100" HEIGHT="50">
<transition NAME="shiftmove" NEXT_STATE_ID="1" EVENT_ID="2001">
<action ID="92" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="2002">
<action ID="43" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="alternativeScroll">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initmove" NEXT_STATE_ID="1" EVENT_ID="4">
<action ID="9" />
</transition>
</state>
<state NAME="scroll" ID="1" X_POS="170" Y_POS="413" WIDTH="100" HEIGHT="50">
<transition NAME="scroll" NEXT_STATE_ID="1" EVENT_ID="533">
<action ID="1013" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="506">
<action ID="43" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="Pan">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initmove" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="9" />
</transition>
</state>
<state NAME="move" ID="1" X_POS="170" Y_POS="413" WIDTH="100" HEIGHT="50">
<transition NAME="move" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="92" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="505">
<action ID="43" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="alternativeLevelWindow">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initmove" NEXT_STATE_ID="1" EVENT_ID="2">
<action ID="9" />
</transition>
</state>
<state NAME="levelwindow" ID="1" X_POS="584" Y_POS="432" WIDTH="100" HEIGHT="50">
<transition NAME="levelwindow" NEXT_STATE_ID="1" EVENT_ID="531">
<action ID="1014" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="507" >
<action ID="43" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="LevelWindow">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initmove" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="9" />
</transition>
</state>
<state NAME="levelwindow" ID="1" X_POS="584" Y_POS="432" WIDTH="100" HEIGHT="50">
<transition NAME="levelwindow" NEXT_STATE_ID="1" EVENT_ID="530">
<action ID="1014" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="505" >
<action ID="43" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="ToolCallbackInteraction">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initmove" NEXT_STATE_ID="1" EVENT_ID="1">
<action ID="9" />
</transition>
</state>
<state NAME="InInteraction" ID="1" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="finishmove" NEXT_STATE_ID="0" EVENT_ID="1003" />
</state>
</stateMachine>
<stateMachine NAME="BinaryImageInteractor">
<state START_STATE="TRUE" NAME="UndecidedState" ID="1" X_POS="374" Y_POS="98" WIDTH="139" HEIGHT="50">
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="2" >
<action ID="30" />
</transition>
</state>
<state NAME="IsOverImage" ID="2" >
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="1" />
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="3" />
</state>
<state NAME="Hovering" ID="3" >
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="2">
<action ID="30" />
</transition>
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="11">
<action ID="60" />
</transition>
<transition NAME="name" EVENT_ID="2" NEXT_STATE_ID="3">
<action ID="61" />
</transition>
<transition NAME="name" EVENT_ID="1013" NEXT_STATE_ID="6">
<action ID="6" />
</transition>
</state>
<state NAME="CorrectionMode" ID="6" X_POS="749" Y_POS="498" WIDTH="188" HEIGHT="51">
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="7">
<action ID="8" />
</transition>
<transition NAME="name" EVENT_ID="1002" NEXT_STATE_ID="1">
<action ID="40">
<!--End of correction mode - hide sphere-->
</action>
</transition>
<transition NAME="name" EVENT_ID="27" NEXT_STATE_ID="6">
<action ID="107" />
</transition>
<transition NAME="name" EVENT_ID="26" NEXT_STATE_ID="6">
<action ID="106" />
</transition>
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="6">
<action ID="49006" />
</transition>
<transition NAME="name" EVENT_ID="9" NEXT_STATE_ID="6">
<action ID="49006" />
</transition>
<transition NAME="name" EVENT_ID="630" NEXT_STATE_ID="6">
<action ID="49007" />
</transition>
</state>
<state NAME="DragSegmentationSurface" ID="7" X_POS="95" Y_POS="473" WIDTH="202" HEIGHT="50">
<transition NAME="name" EVENT_ID="530" NEXT_STATE_ID="7">
<action ID="90" />
</transition>
<transition NAME="name" EVENT_ID="505" NEXT_STATE_ID="7">
<action ID="43" />
</transition>
<transition NAME="name" EVENT_ID="1002" NEXT_STATE_ID="1">
<action ID="40" />
</transition>
</state>
<state NAME="CheckIfImageIsSelected" ID="11" X_POS="771" Y_POS="201" WIDTH="255" HEIGHT="50">
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="1" />
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="6">
<action ID="6">
<!--Initialize correction mode, visualize a sphere-->
</action>
</transition>
</state>
</stateMachine>
<stateMachine NAME="PlanarFigureInteractor">
<!-- Behaviour of a set of Points. a defined number of points can be set/removed/selected/deselectd/moved -->
<state NAME="Start" ID="42" START_STATE="TRUE" X_POS="1368" Y_POS="736" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="0" NEXT_STATE_ID="49">
<action ID="31" />
</transition>
</state>
<state NAME="FigurePlaced" ID="45" X_POS="836" Y_POS="715" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="45">
<action ID="90" />
</transition>
<transition NAME="name" EVENT_ID="8" NEXT_STATE_ID="54">
<action ID="33" />
</transition>
<transition NAME="name" EVENT_ID="530" NEXT_STATE_ID="57">
<action ID="90" />
</transition>
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="58">
<action ID="21" />
</transition>
</state>
<state NAME="ControlPointSelected" ID="47" X_POS="74" Y_POS="665" WIDTH="128" HEIGHT="50">
<transition NAME="name" EVENT_ID="530" NEXT_STATE_ID="47">
<action ID="90" />
</transition>
<transition NAME="name" EVENT_ID="505" NEXT_STATE_ID="51">
<action ID="76" />
</transition>
</state>
<state NAME="IsLastControlPoint" ID="48" X_POS="1102" Y_POS="732" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="42" />
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="45">
<action ID="10" />
</transition>
</state>
<state NAME="IsPlaced" ID="49" X_POS="1302" Y_POS="201" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="50" />
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="51" />
</state>
<state NAME="PlaceFigure" ID="50" X_POS="868" Y_POS="293" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="45">
<action ID="11" />
</transition>
</state>
<state NAME="EditFigure" ID="51" X_POS="804" Y_POS="199" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="52">
<action ID="341" />
</transition>
</state>
<state NAME="IsOverFigure" ID="52" X_POS="340" Y_POS="170" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="51" />
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="53" />
</state>
<state NAME="FigureHover" ID="53" X_POS="563" Y_POS="326" WIDTH="115" HEIGHT="50">
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="52">
<action ID="341" />
</transition>
<transition NAME="name" EVENT_ID="2" NEXT_STATE_ID="60">
<action ID="60" />
</transition>
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="65">
<action ID="34" />
</transition>
</state>
<state NAME="IsMinFigureFinished" ID="54" X_POS="972" Y_POS="929" WIDTH="110" HEIGHT="50">
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="42" />
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="45" />
</state>
<state NAME="ResetFigure" ID="55" X_POS="610" Y_POS="934" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="47" />
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="45" />
</state>
<state NAME="FigurePlacedByDrag" ID="57" X_POS="1047" Y_POS="391" WIDTH="138" HEIGHT="50">
<transition NAME="name" EVENT_ID="530" NEXT_STATE_ID="57">
<action ID="90" />
</transition>
<transition NAME="name" EVENT_ID="505" NEXT_STATE_ID="58">
<action ID="21" />
</transition>
</state>
<state NAME="IsPointValid" ID="58" X_POS="1212" Y_POS="555" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="48">
<action ID="32" />
</transition>
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="45" />
</state>
<state NAME="FigureSelectedForDelete" ID="60" X_POS="308" Y_POS="532" WIDTH="132" HEIGHT="50">
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="52">
<action ID="100" />
</transition>
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="52" >
<action ID="48000" />
</transition>
</state>
<state NAME="IsOverControlPoint" ID="59" X_POS="586" Y_POS="636" WIDTH="120" HEIGHT="50">
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="55">
<action ID="66" />
</transition>
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="47">
<action ID="10" />
</transition>
</state>
<state NAME="FigureSeleced" ID="65" X_POS="740" Y_POS="487" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="1003" NEXT_STATE_ID="53" />
<transition NAME="name" EVENT_ID="1004" NEXT_STATE_ID="59">
<action ID="60" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="FiberBundleInteractor">
<!-- working with mitk::FiberBundles -->
<state NAME="Start" ID="123451" START_STATE="TRUE" X_POS="1368" Y_POS="736" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="123451">
<!-- on EIDMOUSEMOVE keep in state and do AcCHECKHOVERING (which throws EIDFIGUREHOVER or EIDNOFIGUREHOVER if applicable) -->
<action ID="341" />
</transition>
<transition NAME="name" EVENT_ID="12340" NEXT_STATE_ID="123452">
<!-- on EIDFIGUREHOVER go to HoverFiber and do AcSELECTPICKEDOBJECT -->
<action ID="60" />
</transition>
</state>
<state NAME="HoverFiber" ID="123452" X_POS="340" Y_POS="170" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="520" NEXT_STATE_ID="123452">
<!-- on EIDMOUSEMOVE keep state and do AcCHECKHOVERING (which throws EIDFIGUREHOVER or EIDNOFIGUREHOVER if applicable) -->
<action ID="341" />
</transition>
<transition NAME="name" EVENT_ID="12340" NEXT_STATE_ID="123452">
<!-- on EIDFIGUREHOVER keep state and do AcSELECTPICKEDOBJECT -->
<action ID="60" />
</transition>
<transition NAME="name" EVENT_ID="12341" NEXT_STATE_ID="123451">
<!-- on EIDNOFIGUREHOVER go to Start and do AcDESELECTALL -->
<action ID="72" />
</transition>
<transition NAME="name" EVENT_ID="1" NEXT_STATE_ID="123452">
<!-- on EIDLEFTMOUSEBTN keep state and do AcREMOVE -->
<action ID="101" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="Scroll">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initmove" NEXT_STATE_ID="1" EVENT_ID="540">
<action ID="9" />
</transition>
<transition NAME="altinitmove" EVENT_ID="600" NEXT_STATE_ID="1">
<action ID="9" />
</transition>
</state>
<state NAME="scroll" ID="1" X_POS="170" Y_POS="413" WIDTH="100" HEIGHT="50">
<transition NAME="scroll" NEXT_STATE_ID="1" EVENT_ID="542">
<action ID="1013" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="543">
<action ID="43" />
</transition>
<transition NAME="altfinish" EVENT_ID="620" NEXT_STATE_ID="0">
<action ID="43" />
</transition>
<transition NAME="altscroll" EVENT_ID="610" NEXT_STATE_ID="1">
<action ID="1013" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="Zoom">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="initzoom" NEXT_STATE_ID="2" EVENT_ID="1">
<action ID="1011" />
</transition>
<transition NAME="name" EVENT_ID="600" NEXT_STATE_ID="2">
<action ID="1011" />
</transition>
</state>
<state NAME="zoom" ID="2" X_POS="584" Y_POS="432" WIDTH="100" HEIGHT="50">
<transition NAME="zoom" NEXT_STATE_ID="2" EVENT_ID="530">
<action ID="1012" />
</transition>
<transition NAME="finish" NEXT_STATE_ID="0" EVENT_ID="505" />
<transition NAME="name" EVENT_ID="620" NEXT_STATE_ID="0" />
<transition NAME="name" EVENT_ID="610" NEXT_STATE_ID="2">
<action ID="1012" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="MouseWheelScroll">
<state NAME="neutral" ID="0" START_STATE="TRUE" X_POS="288" Y_POS="81" WIDTH="100" HEIGHT="50">
<transition NAME="name" EVENT_ID="9" NEXT_STATE_ID="0">
<action ID="1015" />
</transition>
<transition NAME="name" EVENT_ID="640" NEXT_STATE_ID="0">
<action ID="1015" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="ContextMenuInteractor">
<state NAME="initial" ID="1" START_STATE="TRUE">
<transition NAME="press" NEXT_STATE_ID="2" EVENT_ID="2" />
</state>
<state NAME="contextmenu" ID="2" >
<transition NAME="moved" NEXT_STATE_ID="1" EVENT_ID="531" />
<transition NAME="contextmenu" NEXT_STATE_ID="1" EVENT_ID="507">
<action ID="30" />
</transition>
</state>
</stateMachine>
<stateMachine NAME="ContourModelInteractor">
<state NAME="Start" ID="1" START_STATE="TRUE">
<transition NAME="checkPointClick" NEXT_STATE_ID="10" EVENT_ID="1"> <!-- left mbtn = 1 -->
<action ID="21"/> <!-- AcCHECKPOINT = 21 -->
</transition>
<transition NAME="checkContourClick" NEXT_STATE_ID="20" EVENT_ID="5"> <!-- left mbtn + ctrl = 5 -->
<action ID="31"/> <!-- AcCHECKOBJECT = 31 -->
</transition>
</state>
<state NAME="Guard_CheckPointClick" ID="10" ><!-- check click on point -->
<transition NAME="yes" NEXT_STATE_ID="2" EVENT_ID="1004"> <!-- EIDYES = 1004 -->
<!-- no action -->
</transition>
<transition NAME="no" NEXT_STATE_ID="1" EVENT_ID="1003"> <!-- EIDNO = 1003 -->
<!-- no action -->
</transition>
</state>
<state NAME="EditPoint" ID="2" >
<transition NAME="mouseMove" NEXT_STATE_ID="2" EVENT_ID="530"> <!-- left MouseButton and MouseMove = 530 -->
<action ID="90" /> <!-- AcMOVEPOINT = 90 -->
</transition>
<transition NAME="mouseRelease" NEXT_STATE_ID="4" EVENT_ID="505"> <!-- left mbtn release = 505 -->
<!-- no action -->
</transition>
</state>
<state NAME="PointSelected" ID="4" >
<transition NAME="checkPointClick" NEXT_STATE_ID="10" EVENT_ID="1"> <!-- left mbtn = 1 -->
<action ID="21"/> <!-- AcCHECKPOINT = 21 -->
</transition>
<transition NAME="Delete" NEXT_STATE_ID="1" EVENT_ID="12"> <!-- Delete = 12 -->
<action ID="120"/> <!-- AcDELETEPOINT = 120 -->
<action ID="44" /> <!-- AcFINISH = 44 -->
</transition>
<transition NAME="Esc" NEXT_STATE_ID="1" EVENT_ID="14"> <!-- Esc = 14 -->
<action ID="44" /> <!-- AcFINISH = 44 -->
</transition>
</state>
<state NAME="Guard_CheckContourClick" ID="20" ><!-- check click on contouor -->
<transition NAME="yes" NEXT_STATE_ID="3" EVENT_ID="1004"> <!-- EIDYES = 1004 -->
<!-- no action -->
</transition>
<transition NAME="no" NEXT_STATE_ID="1" EVENT_ID="1003"> <!-- EIDNO = 1003 -->
<!-- no action -->
</transition>
</state>
<state NAME="EditContour" ID="3" >
<transition NAME="mouseMoveContour" NEXT_STATE_ID="3" EVENT_ID="534"> <!-- CTRL+leftBN+MouseMove = 534 -->
<action ID="92" /> <!-- AcMOVE = 92 -->
</transition>
<transition NAME="mouseReleaseContour" NEXT_STATE_ID="1" EVENT_ID="505"> <!-- left mbtn release = 505 -->
<action ID="44" /> <!-- AcFINISH = 44 -->
</transition>
<transition NAME="mouseCtrlReleaseContour" NEXT_STATE_ID="1" EVENT_ID="537"> <!-- CTRL+leftBNRelease = 537 -->
<action ID="44" /> <!-- AcFINISH = 44 -->
</transition>
</state>
</stateMachine>
+ <stateMachine NAME="LiveWireTool">
+ <state NAME="Start" ID="1" START_STATE="TRUE">
+ <transition NAME="initLiveWire" NEXT_STATE_ID="2" EVENT_ID="8"> <!-- left mbtn DC = 8 -->
+ <action ID="5" /> <!-- AcINITNEWOBJECT = 5 -->
+ </transition>
+ </state>
+ <state NAME="Active" ID="2" >
+ <transition NAME="addPoint" NEXT_STATE_ID="2" EVENT_ID="1"> <!-- left mbtn = 1 -->
+ <action ID="10" /> <!-- AcADDPOINT = 10 -->
+ </transition>
+ <transition NAME="mouseMove" NEXT_STATE_ID="2" EVENT_ID="520"> <!-- MouseMove = 520 -->
+ <action ID="92" /> <!-- AcMOVE = 92 -->
+ </transition>
+ <transition NAME="Delete" NEXT_STATE_ID="2" EVENT_ID="12"> <!-- Delete = 12 -->
+ <action ID="120"/> <!-- AcDELETEPOINT = 120 -->
+ </transition>
+ <transition NAME="Esc" NEXT_STATE_ID="2" EVENT_ID="14"> <!-- Esc = 14 -->
+ <action ID="120"/> <!-- AcDELETEPOINT = 120 -->
+ </transition>
+ <transition NAME="doubleClick" NEXT_STATE_ID="20" EVENT_ID="8"> <!-- left mbtn DC = 8 -->
+ <!-- transition to checkState -->
+ <action ID="21"/> <!-- AcCHECKPOINT = 21 -->
+ </transition>
+ <transition NAME="ctrlMove" NEXT_STATE_ID="2" EVENT_ID="529"> <!-- Ctrl+MouseMove = 529 -->
+ <!-- transition to checkState -->
+ <action ID="12"/> <!-- AcADDLINE = 12 -->
+ </transition>
+ <transition NAME="ctrlAddPoint" NEXT_STATE_ID="2" EVENT_ID="5"> <!-- left mbtn + ctrl = 5 -->
+ <action ID="10" /> <!-- AcADDPOINT = 10 -->
+ </transition>
+ </state>
+ <state NAME="Guard_lastPointClicked" ID="20" ><!-- check doubleClick on last point -->
+ <transition NAME="yes" NEXT_STATE_ID="1" EVENT_ID="1004"> <!-- EIDYES = 1004 -->
+ <action ID="44" /> <!-- AcFINISH = 44 -->
+ </transition>
+ <transition NAME="no" NEXT_STATE_ID="2" EVENT_ID="1003"> <!-- EIDNO = 1003 -->
+ <action ID="10" /> <!-- AcADDPOINT = 10 -->
+ </transition>
+ </state>
+ </stateMachine>
</mitkInteraktionStates>
<!-- DOCUMENTATION -->
<!-- This is StateMachine.xml. Includes Information about different StateMachines and Events. Used by EventMapper and StateMachineFactory -->
<!-- /** \example StateMachine.xml -->
<!-- -->
<!-- -->
<!-- FAQ -->
<!-- Question: the Application, that is loading this file doesn't act on the Interaction. Why? -->
<!-- The QXMLFileLoader probably isn't able to load the file due to an error.-->
<!-- Check the file for XML-Syntax like "<" at beginning and "/>" at end -->
diff --git a/Core/Code/Testing/CMakeLists.txt b/Core/Code/Testing/CMakeLists.txt
index 389f4becfc..e79b882f3d 100644
--- a/Core/Code/Testing/CMakeLists.txt
+++ b/Core/Code/Testing/CMakeLists.txt
@@ -1,114 +1,170 @@
# The core tests need relaxed compiler flags...
# TODO fix core tests to compile without these additional no-error flags
if(MSVC_VERSION)
# disable deprecated warnings (they would lead to errors)
mitkFunctionCheckCAndCXXCompilerFlags("/wd4996" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
else()
mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=deprecated" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=deprecated-declarations" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
MITK_CREATE_MODULE_TESTS(LABELS MITK-Core)
# MITK_INSTALL_TARGETS(EXECUTABLES MitkTestDriver)
mitkAddCustomModuleTest(mitkDICOMLocaleTest_spacingOk_CT mitkDICOMLocaleTest ${MITK_DATA_DIR}/spacing-ok-ct.dcm)
mitkAddCustomModuleTest(mitkDICOMLocaleTest_spacingOk_MR mitkDICOMLocaleTest ${MITK_DATA_DIR}/spacing-ok-mr.dcm)
mitkAddCustomModuleTest(mitkDICOMLocaleTest_spacingOk_SC mitkDICOMLocaleTest ${MITK_DATA_DIR}/spacing-ok-sc.dcm)
mitkAddCustomModuleTest(mitkVolumeCalculatorTest_Png2D-bw mitkVolumeCalculatorTest ${MITK_DATA_DIR}/Png2D-bw.png ${MITK_DATA_DIR}/Pic2DplusT.nrrd)
mitkAddCustomModuleTest(mitkEventMapperTest_Test1And2 mitkEventMapperTest ${MITK_DATA_DIR}/TestStateMachine1.xml ${MITK_DATA_DIR}/TestStateMachine2.xml)
mitkAddCustomModuleTest(mitkEventConfigTest_CreateObjectInDifferentWays mitkEventConfigTest ${MITK_SOURCE_DIR}/Core/Code/Testing/Resources/Interactions/StatemachineConfigTest.xml)
#mitkAddCustomModuleTest(mitkNodeDependentPointSetInteractorTest mitkNodeDependentPointSetInteractorTest ${MITK_DATA_DIR}/Pic3D.pic.gz ${MITK_DATA_DIR}/BallBinary30x30x30.pic.gz)
mitkAddCustomModuleTest(mitkNodeDependentPointSetInteractorTest mitkNodeDependentPointSetInteractorTest ${MITK_DATA_DIR}/Pic3D.nrrd ${MITK_DATA_DIR}/BallBinary30x30x30.nrrd)
mitkAddCustomModuleTest(mitkDataStorageTest_US4DCyl mitkDataStorageTest ${MITK_DATA_DIR}/US4DCyl.nrrd)
mitkAddCustomModuleTest(mitkStateMachineFactoryTest_TestStateMachine1_2 mitkStateMachineFactoryTest ${MITK_DATA_DIR}/TestStateMachine1.xml ${MITK_DATA_DIR}/TestStateMachine2.xml)
mitkAddCustomModuleTest(mitkDicomSeriesReaderTest_CTImage mitkDicomSeriesReaderTest ${MITK_DATA_DIR}/TinyCTAbdomen)
mitkAddCustomModuleTest(mitkPointSetReaderTest mitkPointSetReaderTest ${MITK_DATA_DIR}/PointSetReaderTestData.mps)
mitkAddCustomModuleTest(mitkImageTest_4DImageData mitkImageTest ${MITK_DATA_DIR}/US4DCyl.nrrd)
mitkAddCustomModuleTest(mitkImageTest_2D+tImageData mitkImageTest ${MITK_DATA_DIR}/Pic2DplusT.nrrd)
mitkAddCustomModuleTest(mitkImageTest_3DImageData mitkImageTest ${MITK_DATA_DIR}/Pic3D.nrrd)
mitkAddCustomModuleTest(mitkImageTest_brainImage mitkImageTest ${MITK_DATA_DIR}/brain.mhd)
#mitkAddCustomModuleTest(mitkImageTest_color2DImage mitkImageTest ${MITK_DATA_DIR}/NrrdWritingTestImage.jpg)
mitkAddCustomModuleTest(mitkIOUtilTest mitkIOUtilTest #test for a randomly chosen Pic3D swivelled slice
${MITK_DATA_DIR}/Pic3D.nrrd
${MITK_DATA_DIR}/pointSet.mps
${MITK_DATA_DIR}/binary.stl
)
mitkAddCustomModuleTest(mitkLevelWindowManagerTest mitkLevelWindowManagerTest
${MITK_DATA_DIR}/Pic3D.nrrd
)
if(WIN32 OR APPLE OR MITK_ENABLE_GUI_TESTING) ### since the rendering test's do not run in ubuntu, yet, we build them only for other systems or if the user explicitly sets the variable MITK_ENABLE_GUI_TESTING
mitkAddCustomModuleTest(mitkImageVtkMapper2D_rgbaImage640x480 mitkImageVtkMapper2DTest
${MITK_DATA_DIR}/RenderingTestData/rgbaImage.png #input image to load in data storage
-V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/rgbaImage640x480REF.png #corresponding reference screenshot
)
mitkAddCustomModuleTest(mitkImageVtkMapper2D_pic3d640x480 mitkImageVtkMapper2DTest #test for standard Pic3D axial slice
${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage
-V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3d640x480REF.png #corresponding reference screenshot
)
mitkAddCustomModuleTest(mitkImageVtkMapper2D_pic3dColorBlue640x480 mitkImageVtkMapper2DColorTest #test for color property (=blue) Pic3D sagittal slice
${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage
-V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dColorBlue640x480REF.png #corresponding reference screenshot
)
mitkAddCustomModuleTest(mitkImageVtkMapper2D_pic3dLevelWindow640x480 mitkImageVtkMapper2DLevelWindowTest #test for levelwindow property (=blood) #Pic3D sagittal slice
${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage
-V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dLevelWindowBlood640x480REF.png #corresponding reference #screenshot
)
-#mitkAddCustomModuleTest(mitkImageVtkMapper2D_pic3dOpacity640x480 mitkImageVtkMapper2DOpacityTest #test for opacity (=0.5) Pic3D coronal slice
-# ${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage
-# -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dOpacity640x480REF.png #corresponding reference screenshot
-#)
+mitkAddCustomModuleTest(mitkImageVtkMapper2D_pic3dOpacity640x480 mitkImageVtkMapper2DOpacityTest #test for opacity (=0.5) Pic3D coronal slice
+ ${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage
+ -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dOpacity640x480REF.png corresponding reference screenshot
+)
mitkAddCustomModuleTest(mitkImageVtkMapper2D_pic3dSwivel640x480 mitkImageVtkMapper2DSwivelTest #test for a randomly chosen Pic3D swivelled slice
${MITK_DATA_DIR}/Pic3D.nrrd #input image to load in data storage
-V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dSwivel640x480REF.png #corresponding reference screenshot
)
+mitkAddCustomModuleTest(mitkPointSetVtkMapper2D_openMeAlone640x480 mitkPointSetVtkMapper2DTest
+ ${MITK_DATA_DIR}/RenderingTestData/openMeAlone.mps #input point set to load in data storage
+ -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/openMeAlone640x480REF.png #corresponding reference screenshot
+)
+mitkAddCustomModuleTest(mitkPointSetVtkMapper2D_Pic3DPointSetForPic3D640x480 mitkPointSetVtkMapper2DImageTest
+ ${MITK_DATA_DIR}/Pic3D.nrrd ${MITK_DATA_DIR}/RenderingTestData/PointSetForPic3D.mps #input point set and image to load in data storage
+ -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/Pic3DPointSetForPic3D640x480REF.png #corresponding reference screenshot
+)
+mitkAddCustomModuleTest(mitkPointSetVtkMapper2D_openMeAloneGlyphType640x480 mitkPointSetVtkMapper2DGlyphTypeTest
+ ${MITK_DATA_DIR}/RenderingTestData/openMeAlone.mps #input point set to load in data storage
+ -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/openMeAloneGlyphType640x480REF.png #corresponding reference screenshot
+)
+
+#Test reslice interpolation
+#note: nearest mode is already tested by swivel test
+mitkAddCustomModuleTest(ResliceInterpolationIsLinear mitkImageVtkMapper2DResliceInterpolationPropertyTest
+ 1 #linear
+ ${MITK_DATA_DIR}/Pic3D.nrrd
+ -V
+ ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dRefLinear.png #corresponding reference screenshot LINEAR
+)
+
+mitkAddCustomModuleTest(ResliceInterpolationIsCubic mitkImageVtkMapper2DResliceInterpolationPropertyTest
+ 3 #cubic
+ ${MITK_DATA_DIR}/Pic3D.nrrd
+ -V
+ ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/pic3dRefCubic.png #corresponding reference screenshot CUBIC
+)
+#End test reslice interpolation
+
+# Testing of the rendering of binary images
+mitkAddCustomModuleTest(mitkImageVtkMapper2D_binaryTestImage640x480 mitkImageVtkMapper2DTest #test for standard Pic3D axial slice
+ ${MITK_DATA_DIR}/RenderingTestData/binaryImage.nrrd #input image to load in data storage
+ -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/binaryImage640x480REF.png #corresponding reference screenshot
+)
+mitkAddCustomModuleTest(mitkImageVtkMapper2D_binaryTestImageWithRef640x480 mitkImageVtkMapper2DTest #test for standard Pic3D axial slice
+ ${MITK_DATA_DIR}/Pic3D.nrrd ${MITK_DATA_DIR}/RenderingTestData/binaryImage.nrrd #input image to load in data storage
+ -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/binaryImageWithRef640x480REF.png #corresponding reference screenshot
+)
+# End of binary image tests
mitkAddCustomModuleTest(mitkSurfaceVtkMapper3DTest_TextureProperty mitkSurfaceVtkMapper3DTest
${MITK_DATA_DIR}/ToF-Data/Kinect_LiverPhantom.vtp
${MITK_DATA_DIR}/ToF-Data/Kinect_LiverPhantom_RGBImage.nrrd
-V
${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/texturedLiver640x480REF.png #corresponding reference screenshot
)
mitkAddCustomModuleTest(mitkImageVtkMapper2DTransferFunctionTest_Png2D-bw mitkImageVtkMapper2DTransferFunctionTest
${MITK_DATA_DIR}/Png2D-bw.png
-V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/Png2D-bw-TransferFunctionRGBImage640x480REF.png #corresponding reference screenshot
)
+mitkAddCustomModuleTest(mitkSurfaceGLMapper2DColorTest_RedBall mitkSurfaceGLMapper2DColorTest
+ ${MITK_DATA_DIR}/ball.stl
+ -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/ballColorRed640x480REF.png #corresponding reference screenshot
+)
+
+mitkAddCustomModuleTest(mitkSurfaceGLMapper2DColorTest_DasArmeSchwein mitkSurfaceGLMapper2DColorTest
+ ${MITK_DATA_DIR}/binary.stl
+ -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/binaryColorRed640x480REF.png #corresponding reference screenshot
+)
+
+mitkAddCustomModuleTest(mitkSurfaceGLMapper2DOpacityTest_BallOpacity mitkSurfaceGLMapper2DOpacityTest #opacity = 50% (0.5)
+ ${MITK_DATA_DIR}/ball.stl
+ -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/ballOpacity640x480REF.png #corresponding reference screenshot
+)
+
+#Removed due to high rendering error.
#mitkAddCustomModuleTest(mitkSurfaceVtkMapper3DTexturedSphereTest_Football mitkSurfaceVtkMapper3DTexturedSphereTest
# ${MITK_DATA_DIR}/RenderingTestData/texture.jpg #input texture
# -V
# ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/texturedSphere640x480REF.png corresponding reference screenshot
#)
-SET_PROPERTY(TEST mitkImageVtkMapper2D_rgbaImage640x480 mitkImageVtkMapper2D_pic3d640x480 mitkImageVtkMapper2D_pic3dColorBlue640x480 mitkImageVtkMapper2D_pic3dLevelWindow640x480 mitkImageVtkMapper2D_pic3dSwivel640x480 mitkImageVtkMapper2DTransferFunctionTest_Png2D-bw #mitkSurfaceVtkMapper3DTest_TextureProperty #mitkSurfaceVtkMapper3DTexturedSphereTest_Football #mitkImageVtkMapper2D_pic3dOpacity640x480
+SET_PROPERTY(TEST mitkImageVtkMapper2D_rgbaImage640x480 mitkImageVtkMapper2D_pic3d640x480 mitkImageVtkMapper2D_pic3dColorBlue640x480 mitkImageVtkMapper2D_pic3dLevelWindow640x480 mitkImageVtkMapper2D_pic3dSwivel640x480 mitkImageVtkMapper2DTransferFunctionTest_Png2D-bw mitkImageVtkMapper2D_pic3dOpacity640x480 mitkSurfaceGLMapper2DOpacityTest_BallOpacity mitkSurfaceGLMapper2DColorTest_DasArmeSchwein mitkSurfaceGLMapper2DColorTest_RedBall mitkSurfaceVtkMapper3DTest_TextureProperty mitkPointSetVtkMapper2D_Pic3DPointSetForPic3D640x480 mitkPointSetVtkMapper2D_openMeAlone640x480 mitkPointSetVtkMapper2D_openMeAloneGlyphType640x480 #mitkSurfaceVtkMapper3DTexturedSphereTest_Football
PROPERTY RUN_SERIAL TRUE)
endif()
add_test(mitkPointSetLocaleTest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} mitkPointSetLocaleTest ${MITK_DATA_DIR}/pointSet.mps)
set_property(TEST mitkPointSetLocaleTest PROPERTY LABELS MITK-Core)
add_test(mitkImageWriterTest_nrrdImage ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} mitkImageWriterTest ${MITK_DATA_DIR}/NrrdWritingTestImage.jpg)
add_test(mitkImageWriterTest_2DPNGImage ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} mitkImageWriterTest ${MITK_DATA_DIR}/Png2D-bw.png)
add_test(mitkImageWriterTest_rgbPNGImage ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} mitkImageWriterTest ${MITK_DATA_DIR}/RenderingTestData/rgbImage.png)
add_test(mitkImageWriterTest_rgbaPNGImage ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} mitkImageWriterTest ${MITK_DATA_DIR}/RenderingTestData/rgbaImage.png)
set_property(TEST mitkImageWriterTest_nrrdImage PROPERTY LABELS MITK-Core)
set_property(TEST mitkImageWriterTest_2DPNGImage PROPERTY LABELS MITK-Core)
set_property(TEST mitkImageWriterTest_rgbPNGImage PROPERTY LABELS MITK-Core)
set_property(TEST mitkImageWriterTest_rgbaPNGImage PROPERTY LABELS MITK-Core)
add_subdirectory(DICOMTesting)
diff --git a/Core/Code/Testing/DICOMTesting/Testing/CMakeLists.txt b/Core/Code/Testing/DICOMTesting/Testing/CMakeLists.txt
index e485caa93c..7d33452f40 100644
--- a/Core/Code/Testing/DICOMTesting/Testing/CMakeLists.txt
+++ b/Core/Code/Testing/DICOMTesting/Testing/CMakeLists.txt
@@ -1,80 +1,89 @@
MITK_CREATE_MODULE_TESTS(LABELS MITK-Core)
include(mitkFunctionAddTestLabel)
# verify minimum expectations:
# files are recognized as DICOM
# loading files results in a given number of images
mitkAddCustomModuleTest(mitkDICOMTestingSanityTest_NoFiles mitkDICOMTestingSanityTest 0)
mitkAddCustomModuleTest(mitkDICOMTestingSanityTest_CTImage mitkDICOMTestingSanityTest 1 ${MITK_DATA_DIR}/spacing-ok-ct.dcm)
mitkAddCustomModuleTest(mitkDICOMTestingSanityTest_MRImage mitkDICOMTestingSanityTest 1 ${MITK_DATA_DIR}/spacing-ok-mr.dcm)
mitkAddCustomModuleTest(mitkDICOMTestingSanityTest_SCImage mitkDICOMTestingSanityTest 1 ${MITK_DATA_DIR}/spacing-ok-sc.dcm)
mitkAddCustomModuleTest(mitkDICOMTestingSanityTest_NoImagePositionPatient mitkDICOMTestingSanityTest 1 ${MITK_DATA_DIR}/spacing-ok-sc-no2032.dcm)
set(VERIFY_DUMP_CMD ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/VerifyDICOMMitkImageDump)
set(CT_ABDOMEN_DIR ${MITK_DATA_DIR}/TinyCTAbdomen)
set(MR_HEART_DIR ${MITK_DATA_DIR}/3D+t-Heart)
set(CT_TILT_HEAD_DIR ${MITK_DATA_DIR}/TiltHead)
set(CT_TILT_DIR ${MITK_DATA_DIR}/TiltedData)
set(SOP_CLASSES_DIR ${MITK_DATA_DIR}/DICOMReader)
# these variables could be passed as parameters to a generic test creation function
set(TESTS_DIR Tests)
set(INPUT_LISTNAME input)
set(EXPECTED_DUMP expected.dump)
function(AddDicomTestsFromDataRepository CURRENT_DATASET_DIR TESTS_DIR INPUT_LISTNAME EXPECTED_DUMP)
# find all test input lists
file(GLOB_RECURSE allInputs ${CURRENT_DATASET_DIR}/${TESTS_DIR}/*/${INPUT_LISTNAME})
function(expectFileExists filename)
if(NOT EXISTS ${filename})
message(SEND_ERROR "Test case expected file ${filename} which does not exist! Please fix your CMake code or file layout.")
endif(NOT EXISTS ${filename})
endfunction(expectFileExists)
foreach(input ${allInputs})
+
# extract only the name of the directory of this very test case
string(REGEX REPLACE ".*${TESTS_DIR}/([^/]+)/.*" "\\1" input ${input})
set(inputfilelist "${CURRENT_DATASET_DIR}/${TESTS_DIR}/${input}/${INPUT_LISTNAME}")
set(expecteddump "${CURRENT_DATASET_DIR}/${TESTS_DIR}/${input}/${EXPECTED_DUMP}")
set(testname "DICOM_Load_${input}")
+ # Disable testing this file due to bug:
+ # http://bugs.mitk.org/show_bug.cgi?id=14954
+ # After this has been fixed in ITK (probably vesion 4.4.0)
+ # this file can be included again.
+ if(NOT input STREQUAL "OT-PAL-8-face")
+
#message(STATUS "DICOM loading test case '${input}'")
expectFileExists(${inputfilelist})
expectFileExists(${expecteddump})
# TODO provide error messages if input not valid
set(dicomFiles) # clear list
# read list of file names from file "input"
file(STRINGS ${inputfilelist} rawDicomFiles)
foreach(raw ${rawDicomFiles})
# prepend each file with an abosolute path
set(fileWithFullPath ${CURRENT_DATASET_DIR}/${raw})
list(APPEND dicomFiles ${fileWithFullPath})
endforeach(raw ${rawDicomFiles})
#message(STATUS " Load ${dicomFiles}")
add_test(${testname}
${VERIFY_DUMP_CMD} ${expecteddump} ${dicomFiles})
mitkFunctionAddTestLabel(${testname})
+ endif()
+
endforeach(input allInputs)
endfunction(AddDicomTestsFromDataRepository CURRENT_DATASET_DIR TESTS_DIR INPUT_LISTNAME EXPECTED_DUMP)
AddDicomTestsFromDataRepository(${CT_ABDOMEN_DIR} ${TESTS_DIR} ${INPUT_LISTNAME} ${EXPECTED_DUMP})
AddDicomTestsFromDataRepository(${CT_TILT_HEAD_DIR} ${TESTS_DIR} ${INPUT_LISTNAME} ${EXPECTED_DUMP})
AddDicomTestsFromDataRepository(${CT_TILT_DIR} ${TESTS_DIR} ${INPUT_LISTNAME} ${EXPECTED_DUMP})
AddDicomTestsFromDataRepository(${MR_HEART_DIR} ${TESTS_DIR} ${INPUT_LISTNAME} ${EXPECTED_DUMP})
AddDicomTestsFromDataRepository(${SOP_CLASSES_DIR} ${TESTS_DIR} ${INPUT_LISTNAME} ${EXPECTED_DUMP})
diff --git a/Core/Code/Testing/DICOMTesting/mitkTestDICOMLoading.cpp b/Core/Code/Testing/DICOMTesting/mitkTestDICOMLoading.cpp
index 55a7ee71b1..22a727e10e 100644
--- a/Core/Code/Testing/DICOMTesting/mitkTestDICOMLoading.cpp
+++ b/Core/Code/Testing/DICOMTesting/mitkTestDICOMLoading.cpp
@@ -1,443 +1,443 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//#define MBILOG_ENABLE_DEBUG
#include "mitkTestDICOMLoading.h"
#include <stack>
mitk::TestDICOMLoading::TestDICOMLoading()
:m_PreviousCLocale(NULL)
{
}
void mitk::TestDICOMLoading::SetDefaultLocale()
{
// remember old locale only once
if (m_PreviousCLocale == NULL)
{
m_PreviousCLocale = setlocale(LC_NUMERIC, NULL);
// set to "C"
setlocale(LC_NUMERIC, "C");
m_PreviousCppLocale = std::cin.getloc();
std::locale l( "C" );
std::cin.imbue(l);
std::cout.imbue(l);
}
}
void mitk::TestDICOMLoading::ResetUserLocale()
{
if (m_PreviousCLocale)
{
setlocale(LC_NUMERIC, m_PreviousCLocale);
std::cin.imbue(m_PreviousCppLocale);
std::cout.imbue(m_PreviousCppLocale);
m_PreviousCLocale = NULL;
}
}
mitk::TestDICOMLoading::ImageList mitk::TestDICOMLoading::LoadFiles( const StringContainer& files )
{
for (StringContainer::const_iterator iter = files.begin();
iter != files.end();
++iter)
{
MITK_DEBUG << "File " << *iter;
}
ImageList result;
DicomSeriesReader::FileNamesGrouping seriesInFiles = DicomSeriesReader::GetSeries( files, true );
// TODO sort series UIDs, implementation of map iterator might differ on different platforms (or verify this is a standard topic??)
for (DicomSeriesReader::FileNamesGrouping::const_iterator seriesIter = seriesInFiles.begin();
seriesIter != seriesInFiles.end();
++seriesIter)
{
StringContainer files = seriesIter->second.GetFilenames();
DataNode::Pointer node = DicomSeriesReader::LoadDicomSeries( files );
if (node.IsNotNull())
{
Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
result.push_back( image );
}
else
{
}
}
return result;
}
std::string
-mitk::TestDICOMLoading::TypeIDToString(const std::type_info& ti)
+mitk::TestDICOMLoading::ComponentTypeToString(int type)
{
- if (ti == typeid(unsigned char))
+ if (type == itk::ImageIOBase::UCHAR)
return "UCHAR";
- else if (ti == typeid(char))
+ else if (type == itk::ImageIOBase::CHAR)
return "CHAR";
- else if (ti == typeid(unsigned short))
+ else if (type == itk::ImageIOBase::USHORT)
return "USHORT";
- else if (ti == typeid(short))
+ else if (type == itk::ImageIOBase::SHORT)
return "SHORT";
- else if (ti == typeid(unsigned int))
+ else if (type == itk::ImageIOBase::UINT)
return "UINT";
- else if (ti == typeid(int))
+ else if (type == itk::ImageIOBase::INT)
return "INT";
- else if (ti == typeid(long unsigned int))
+ else if (type == itk::ImageIOBase::ULONG)
return "ULONG";
- else if (ti == typeid(long int))
+ else if (type == itk::ImageIOBase::LONG)
return "LONG";
- else if (ti == typeid(float))
+ else if (type == itk::ImageIOBase::FLOAT)
return "FLOAT";
- else if (ti == typeid(double))
+ else if (type == itk::ImageIOBase::DOUBLE)
return "DOUBLE";
else
return "UNKNOWN";
}
// add a line to stringstream result (see DumpImageInformation
#define DumpLine(field, data) DumpILine(0, field, data)
// add an indented(!) line to stringstream result (see DumpImageInformation
#define DumpILine(indent, field, data) \
{ \
std::string DumpLine_INDENT; DumpLine_INDENT.resize(indent, ' ' ); \
result << DumpLine_INDENT << field << ": " << data << "\n"; \
}
std::string
mitk::TestDICOMLoading::DumpImageInformation( const Image* image )
{
std::stringstream result;
if (image == NULL) return result.str();
SetDefaultLocale();
// basic image data
- DumpLine( "Pixeltype", TypeIDToString( (image->GetPixelType().GetTypeId()) ));
+ DumpLine( "Pixeltype", ComponentTypeToString(image->GetPixelType().GetComponentType()) );
DumpLine( "BitsPerPixel", image->GetPixelType().GetBpe() );
DumpLine( "Dimension", image->GetDimension() );
result << "Dimensions: ";
for (unsigned int dim = 0; dim < image->GetDimension(); ++dim)
result << image->GetDimension(dim) << " ";
result << "\n";
// geometry data
result << "Geometry: \n";
Geometry3D* geometry = image->GetGeometry();
if (geometry)
{
AffineTransform3D* transform = geometry->GetIndexToWorldTransform();
if (transform)
{
result << " " << "Matrix: ";
const AffineTransform3D::MatrixType& matrix = transform->GetMatrix();
for (unsigned int i = 0; i < 3; ++i)
for (unsigned int j = 0; j < 3; ++j)
result << matrix[i][j] << " ";
result << "\n";
result << " " << "Offset: ";
const AffineTransform3D::OutputVectorType& offset = transform->GetOffset();
for (unsigned int i = 0; i < 3; ++i)
result << offset[i] << " ";
result << "\n";
result << " " << "Center: ";
const AffineTransform3D::InputPointType& center = transform->GetCenter();
for (unsigned int i = 0; i < 3; ++i)
result << center[i] << " ";
result << "\n";
result << " " << "Translation: ";
const AffineTransform3D::OutputVectorType& translation = transform->GetTranslation();
for (unsigned int i = 0; i < 3; ++i)
result << translation[i] << " ";
result << "\n";
result << " " << "Scale: ";
const double* scale = transform->GetScale();
for (unsigned int i = 0; i < 3; ++i)
result << scale[i] << " ";
result << "\n";
result << " " << "Origin: ";
const Point3D& origin = geometry->GetOrigin();
for (unsigned int i = 0; i < 3; ++i)
result << origin[i] << " ";
result << "\n";
result << " " << "Spacing: ";
const Vector3D& spacing = geometry->GetSpacing();
for (unsigned int i = 0; i < 3; ++i)
result << spacing[i] << " ";
result << "\n";
result << " " << "TimeBounds: ";
const TimeBounds timeBounds = geometry->GetTimeBounds();
for (unsigned int i = 0; i < 2; ++i)
result << timeBounds[i] << " ";
result << "\n";
}
}
ResetUserLocale();
return result.str();
}
std::string
mitk::TestDICOMLoading::trim(const std::string& pString,
const std::string& pWhitespace)
{
const size_t beginStr = pString.find_first_not_of(pWhitespace);
if (beginStr == std::string::npos)
{
// no content
return "";
}
const size_t endStr = pString.find_last_not_of(pWhitespace);
const size_t range = endStr - beginStr + 1;
return pString.substr(beginStr, range);
}
std::string
mitk::TestDICOMLoading::reduce(const std::string& pString,
const std::string& pFill,
const std::string& pWhitespace)
{
// trim first
std::string result(trim(pString, pWhitespace));
// replace sub ranges
size_t beginSpace = result.find_first_of(pWhitespace);
while (beginSpace != std::string::npos)
{
const size_t endSpace =
result.find_first_not_of(pWhitespace, beginSpace);
const size_t range = endSpace - beginSpace;
result.replace(beginSpace, range, pFill);
const size_t newStart = beginSpace + pFill.length();
beginSpace = result.find_first_of(pWhitespace, newStart);
}
return result;
}
bool
mitk::TestDICOMLoading::CompareSpacedValueFields( const std::string& reference,
const std::string& test,
double /*eps*/ )
{
bool result(true);
// tokenize string, compare each token, if possible by float comparison
std::stringstream referenceStream(reduce(reference));
std::stringstream testStream(reduce(test));
std::string refToken;
std::string testToken;
while ( std::getline( referenceStream, refToken, ' ' ) &&
std::getline ( testStream, testToken, ' ' ) )
{
float refNumber;
float testNumber;
if ( this->StringToNumber(refToken, refNumber) )
{
if ( this->StringToNumber(testToken, testNumber) )
{
// print-out compared tokens if DEBUG output allowed
MITK_DEBUG << "Reference Token '" << refToken << "'" << " value " << refNumber
<< ", test Token '" << testToken << "'" << " value " << testNumber;
bool old_result = result;
result &= ( fabs(refNumber - testNumber) < mitk::eps );
// log the token/number which causes the test to fail
if( old_result != result)
{
MITK_ERROR << std::setprecision(16) << "Reference Token '" << refToken << "'" << " value " << refNumber
<< ", test Token '" << testToken << "'" << " value " << testNumber;
MITK_ERROR << "[FALSE] - difference: " << std::setprecision(16) << fabs(refNumber - testNumber) << " EPS: " << mitk::eps;
}
}
else
{
MITK_ERROR << refNumber << " cannot be compared to '" << testToken << "'";
}
}
else
{
MITK_DEBUG << "Token '" << refToken << "'" << " handled as string";
result &= refToken == testToken;
}
}
if ( std::getline( referenceStream, refToken, ' ' ) )
{
MITK_ERROR << "Reference string still had values when test string was already parsed: ref '" << reference << "', test '" << test << "'";
result = false;
}
else if ( std::getline( testStream, testToken, ' ' ) )
{
MITK_ERROR << "Test string still had values when reference string was already parsed: ref '" << reference << "', test '" << test << "'";
result = false;
}
return result;
}
bool
mitk::TestDICOMLoading::CompareImageInformationDumps( const std::string& referenceDump,
const std::string& testDump )
{
KeyValueMap reference = ParseDump(referenceDump);
KeyValueMap test = ParseDump(testDump);
bool testResult(true);
// verify all expected values
for (KeyValueMap::const_iterator refIter = reference.begin();
refIter != reference.end();
++refIter)
{
const std::string& refKey = refIter->first;
const std::string& refValue = refIter->second;
if ( test.find(refKey) != test.end() )
{
const std::string& testValue = test[refKey];
bool thisTestResult = CompareSpacedValueFields( refValue, testValue );
testResult &= thisTestResult;
MITK_DEBUG << refKey << ": '" << refValue << "' == '" << testValue << "' ? " << (thisTestResult?"YES":"NO");
}
else
{
MITK_ERROR << "Reference dump contains a key'" << refKey << "' (value '" << refValue << "')." ;
MITK_ERROR << "This key is expected to be generated for tests (but was not). Most probably you need to update your test data.";
return false;
}
}
// now check test dump does not contain any additional keys
for (KeyValueMap::const_iterator testIter = test.begin();
testIter != test.end();
++testIter)
{
const std::string& key = testIter->first;
const std::string& value = testIter->second;
if ( reference.find(key) == reference.end() )
{
MITK_ERROR << "Test dump contains an unexpected key'" << key << "' (value '" << value << "')." ;
MITK_ERROR << "This key is not expected. Most probably you need to update your test data.";
return false;
}
}
return testResult;
}
mitk::TestDICOMLoading::KeyValueMap
mitk::TestDICOMLoading::ParseDump( const std::string& dump )
{
KeyValueMap parsedResult;
std::string shredder(dump);
std::stack<std::string> surroundingKeys;
std::stack<std::string::size_type> expectedIndents;
expectedIndents.push(0);
while (true)
{
std::string::size_type newLinePos = shredder.find( '\n' );
if (newLinePos == std::string::npos || newLinePos == 0) break;
std::string line = shredder.substr( 0, newLinePos );
shredder = shredder.erase( 0, newLinePos+1 );
std::string::size_type keyPosition = line.find_first_not_of( ' ' );
std::string::size_type colonPosition = line.find( ':' );
std::string key = line.substr(keyPosition, colonPosition - keyPosition);
std::string::size_type firstSpacePosition = key.find_first_of(" ");
if (firstSpacePosition != std::string::npos)
{
key.erase(firstSpacePosition);
}
if ( keyPosition > expectedIndents.top() )
{
// more indent than before
expectedIndents.push(keyPosition);
}
else if (keyPosition == expectedIndents.top() )
{
if (!surroundingKeys.empty())
{
surroundingKeys.pop(); // last of same length
}
}
else
{
// less indent than before
do expectedIndents.pop();
while (expectedIndents.top() != keyPosition); // unwind until current indent is found
}
if (!surroundingKeys.empty())
{
key = surroundingKeys.top() + "." + key; // construct current key name
}
surroundingKeys.push(key); // this is the new embracing key
std::string value = line.substr(colonPosition+1);
MITK_DEBUG << " Key: '" << key << "' value '" << value << "'" ;
parsedResult[key] = value; // store parsing result
}
return parsedResult;
}
diff --git a/Core/Code/Testing/DICOMTesting/mitkTestDICOMLoading.h b/Core/Code/Testing/DICOMTesting/mitkTestDICOMLoading.h
index 9b17eddd61..596d032985 100644
--- a/Core/Code/Testing/DICOMTesting/mitkTestDICOMLoading.h
+++ b/Core/Code/Testing/DICOMTesting/mitkTestDICOMLoading.h
@@ -1,105 +1,105 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkTestDICOMLoading_h
#define mitkTestDICOMLoading_h
#include "mitkDicomSeriesReader.h"
#include "mitkDICOMTestingExports.h"
namespace mitk
{
class mitkDICOMTesting_EXPORT TestDICOMLoading
{
public:
typedef DicomSeriesReader::StringContainer StringContainer;
typedef std::list<DataNode::Pointer> NodeList;
typedef std::list<Image::Pointer> ImageList;
TestDICOMLoading();
ImageList
LoadFiles( const StringContainer& files );
/**
\brief Dump relevant image information for later comparison.
\sa CompareImageInformationDumps
*/
std::string
DumpImageInformation( const Image* image );
/**
\brief Compare two image information dumps.
\return true, if dumps are sufficiently equal (see parameters)
\sa DumpImageInformation
*/
bool
CompareImageInformationDumps( const std::string& reference,
const std::string& test );
private:
typedef std::map<std::string,std::string> KeyValueMap;
void SetDefaultLocale();
void ResetUserLocale();
- std::string TypeIDToString( const std::type_info& );
+ std::string ComponentTypeToString( int type );
KeyValueMap ParseDump( const std::string& dump );
bool CompareSpacedValueFields( const std::string& reference,
const std::string& test,
double eps = mitk::eps );
/**
Compress whitespace in string
\param pString input string
\param pFill replacement whitespace (only whitespace in string after reduction)
\param pWhitespace characters handled as whitespace
*/
std::string reduce(const std::string& pString,
const std::string& pFill = " ",
const std::string& pWhitespace = " \t");
/**
Remove leading and trailing whitespace
\param pString input string
\param pWhitespace characters handled as whitespace
*/
std::string trim(const std::string& pString,
const std::string& pWhitespace = " \t");
template<typename T>
bool StringToNumber(const std::string& s, T& value)
{
std::stringstream stream(s);
stream >> value;
return !stream.fail();
}
const char* m_PreviousCLocale;
std::locale m_PreviousCppLocale;
};
}
#endif
diff --git a/Core/Code/Testing/files.cmake b/Core/Code/Testing/files.cmake
index 7ff86f8b64..bed30965d6 100644
--- a/Core/Code/Testing/files.cmake
+++ b/Core/Code/Testing/files.cmake
@@ -1,145 +1,151 @@
# tests with no extra command line parameter
set(MODULE_TESTS
mitkAccessByItkTest.cpp
mitkCoreObjectFactoryTest.cpp
mitkMaterialTest.cpp
mitkActionTest.cpp
mitkDispatcherTest.cpp
mitkEnumerationPropertyTest.cpp
mitkEventTest.cpp
mitkFocusManagerTest.cpp
mitkGenericPropertyTest.cpp
mitkGeometry3DTest.cpp
mitkGeometryDataToSurfaceFilterTest.cpp
mitkGlobalInteractionTest.cpp
mitkImageDataItemTest.cpp
#mitkImageMapper2DTest.cpp
mitkImageGeneratorTest.cpp
mitkBaseDataTest.cpp
#mitkImageToItkTest.cpp
+ mitkImportItkImageTest.cpp
+ mitkGrabItkImageMemoryTest.cpp
mitkInstantiateAccessFunctionTest.cpp
mitkInteractorTest.cpp
- mitkInteractionEventTest.cpp
- mitkITKThreadingTest.cpp
+ #mitkITKThreadingTest.cpp
mitkLevelWindowTest.cpp
mitkMessageTest.cpp
#mitkPipelineSmartPointerCorrectnessTest.cpp
mitkPixelTypeTest.cpp
mitkPlaneGeometryTest.cpp
mitkPointSetFileIOTest.cpp
mitkPointSetTest.cpp
mitkPointSetWriterTest.cpp
mitkPointSetReaderTest.cpp
mitkPointSetInteractorTest.cpp
mitkPropertyTest.cpp
mitkPropertyListTest.cpp
#mitkRegistrationBaseTest.cpp
#mitkSegmentationInterpolationTest.cpp
mitkSlicedGeometry3DTest.cpp
mitkSliceNavigationControllerTest.cpp
mitkStateMachineTest.cpp
##mitkStateMachineContainerTest.cpp ## rewrite test, indirect since no longer exported Bug 14529
mitkStateTest.cpp
mitkSurfaceTest.cpp
mitkSurfaceToSurfaceFilterTest.cpp
mitkTimeSlicedGeometryTest.cpp
mitkTransitionTest.cpp
mitkUndoControllerTest.cpp
mitkVtkWidgetRenderingTest.cpp
mitkVerboseLimitedLinearUndoTest.cpp
mitkWeakPointerTest.cpp
mitkTransferFunctionTest.cpp
#mitkAbstractTransformGeometryTest.cpp
mitkStepperTest.cpp
itkTotalVariationDenoisingImageFilterTest.cpp
mitkRenderingManagerTest.cpp
vtkMitkThickSlicesFilterTest.cpp
mitkNodePredicateSourceTest.cpp
mitkVectorTest.cpp
mitkClippedSurfaceBoundsCalculatorTest.cpp
- #QmitkRenderingTestHelper.cpp
mitkExceptionTest.cpp
mitkExtractSliceFilterTest.cpp
mitkLogTest.cpp
mitkImageDimensionConverterTest.cpp
mitkLoggingAdapterTest.cpp
mitkUIDGeneratorTest.cpp
mitkShaderRepositoryTest.cpp
)
# test with image filename as an extra command line parameter
set(MODULE_IMAGE_TESTS
mitkPlanePositionManagerTest.cpp
mitkSurfaceVtkWriterTest.cpp
#mitkImageSliceSelectorTest.cpp
mitkImageTimeSelectorTest.cpp
# mitkVtkPropRendererTest.cpp
mitkDataNodeFactoryTest.cpp
#mitkSTLFileReaderTest.cpp
mitkImageAccessorTest.cpp
)
# list of images for which the tests are run
set(MODULE_TESTIMAGES
# Pic-Factory no more available in Core, test images now in .nrrd format
US4DCyl.nrrd
Pic3D.nrrd
Pic2DplusT.nrrd
BallBinary30x30x30.nrrd
binary.stl
ball.stl
)
set(MODULE_CUSTOM_TESTS
#mitkLabeledImageToSurfaceFilterTest.cpp
#mitkExternalToolsTest.cpp
mitkDataStorageTest.cpp
mitkDataNodeTest.cpp
mitkDicomSeriesReaderTest.cpp
mitkDICOMLocaleTest.cpp
mitkEventMapperTest.cpp
mitkEventConfigTest.cpp
mitkNodeDependentPointSetInteractorTest.cpp
mitkStateMachineFactoryTest.cpp
mitkPointSetLocaleTest.cpp
mitkImageTest.cpp
mitkImageWriterTest.cpp
mitkImageVtkMapper2DTest.cpp
mitkImageVtkMapper2DLevelWindowTest.cpp
mitkImageVtkMapper2DOpacityTest.cpp
+ mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp
mitkImageVtkMapper2DColorTest.cpp
mitkImageVtkMapper2DSwivelTest.cpp
mitkImageVtkMapper2DTransferFunctionTest.cpp
mitkIOUtilTest.cpp
mitkSurfaceVtkMapper3DTest
mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
+ mitkSurfaceGLMapper2DColorTest.cpp
+ mitkSurfaceGLMapper2DOpacityTest.cpp
mitkVolumeCalculatorTest.cpp
mitkLevelWindowManagerTest.cpp
+ mitkPointSetVtkMapper2DTest.cpp
+ mitkPointSetVtkMapper2DImageTest.cpp
+ mitkPointSetVtkMapper2DGlyphTypeTest.cpp
)
set(MODULE_RESOURCE_FILES
Interactions/AddAndRemovePoints.xml
Interactions/globalConfig.xml
Interactions/StatemachineTest.xml
Interactions/StatemachineConfigTest.xml
)
# Create an artificial module initializing class for
# the usServiceListenerTest.cpp
usFunctionGenerateModuleInit(testdriver_init_file
NAME ${MODULE_NAME}TestDriver
DEPENDS "Mitk"
VERSION "0.1.0"
EXECUTABLE
)
# Embed the resources
set(testdriver_resources )
usFunctionEmbedResources(testdriver_resources
EXECUTABLE_NAME ${MODULE_NAME}TestDriver
ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Resources
FILES ${MODULE_RESOURCE_FILES}
)
set(TEST_CPP_FILES ${testdriver_init_file} ${testdriver_resources})
diff --git a/Core/Code/Testing/mitkBaseDataTest.cpp b/Core/Code/Testing/mitkBaseDataTest.cpp
index ba44088653..7f4fb8b044 100644
--- a/Core/Code/Testing/mitkBaseDataTest.cpp
+++ b/Core/Code/Testing/mitkBaseDataTest.cpp
@@ -1,120 +1,118 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBaseDataTestImplementation.h"
#include "mitkStringProperty.h"
#include "mitkTestingMacros.h"
#include "itkImage.h"
int mitkBaseDataTest(int /*argc*/, char* /*argv*/[])
{
MITK_TEST_BEGIN("BaseData")
//Create a BaseData implementation
MITK_INFO << "Creating a base data instance...";
mitk::BaseDataTestImplementation::Pointer baseDataImpl = mitk::BaseDataTestImplementation::New();
MITK_TEST_CONDITION_REQUIRED(baseDataImpl.IsNotNull(),"Testing instantiation");
MITK_TEST_CONDITION(baseDataImpl->IsInitialized(), "BaseDataTestImplementation is initialized");
MITK_TEST_CONDITION(baseDataImpl->IsEmpty(), "BaseDataTestImplementation is initialized and empty");
- MITK_TEST_CONDITION(baseDataImpl->GetExternalReferenceCount()== baseDataImpl->GetReferenceCount(), "Checks external reference count!");
mitk::BaseDataTestImplementation::Pointer cloneBaseData = baseDataImpl->Clone();
MITK_TEST_CONDITION_REQUIRED(cloneBaseData.IsNotNull(),"Testing instantiation of base data clone");
MITK_TEST_CONDITION(cloneBaseData->IsInitialized(), "Clone of BaseDataTestImplementation is initialized");
MITK_TEST_CONDITION(cloneBaseData->IsEmpty(), "Clone of BaseDataTestImplementation is initialized and empty");
- MITK_TEST_CONDITION(cloneBaseData->GetExternalReferenceCount()== cloneBaseData->GetReferenceCount(), "Checks external reference count of base data clone!");
MITK_INFO << "Testing setter and getter for geometries...";
//test method GetTimeSlicedGeometry()
MITK_TEST_CONDITION(baseDataImpl->GetTimeSlicedGeometry(), "Testing creation of TimeSlicedGeometry");
mitk::TimeSlicedGeometry* geo = NULL;
baseDataImpl->SetGeometry(geo);
MITK_TEST_CONDITION(baseDataImpl->GetTimeSlicedGeometry() == NULL, "Reset Geometry");
mitk::TimeSlicedGeometry::Pointer geo2 = mitk::TimeSlicedGeometry::New();
baseDataImpl->SetGeometry(geo2);
baseDataImpl->InitializeTimeSlicedGeometry(2);
MITK_TEST_CONDITION(baseDataImpl->GetTimeSlicedGeometry() == geo2, "Correct Reinit of TimeslicedGeometry");
//test method GetGeometry(int timeStep)
MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1) != NULL, "... and single Geometries");
//test method Expand(unsigned int timeSteps)
baseDataImpl->Expand(5);
MITK_TEST_CONDITION(baseDataImpl->GetTimeSteps() == 5, "Expand the geometry to further time slices!");
//test method GetUpdatedGeometry(int timeStep);
mitk::Geometry3D::Pointer geo3 = mitk::Geometry3D::New();
mitk::TimeSlicedGeometry::Pointer timeSlicedGeometry = baseDataImpl->GetTimeSlicedGeometry();
if (timeSlicedGeometry.IsNotNull() )
{
timeSlicedGeometry->SetGeometry3D(geo3, 1);
}
MITK_TEST_CONDITION(baseDataImpl->GetUpdatedGeometry(1) == geo3, "Set Geometry for time step 1");
MITK_TEST_CONDITION(baseDataImpl->GetMTime()!= 0, "Check if modified time is set");
baseDataImpl->SetClonedGeometry(geo3, 1);
float x[3];
x[0] = 2;
x[1] = 4;
x[2] = 6;
mitk::Point3D p3d(x);
baseDataImpl->SetOrigin(p3d);
geo3->SetOrigin(p3d);
MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing Origin set");
cloneBaseData = baseDataImpl->Clone();
MITK_TEST_CONDITION(cloneBaseData->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing origin set in clone!");
MITK_TEST_CONDITION(!baseDataImpl->IsEmptyTimeStep(1), "Is not empty before clear()!");
baseDataImpl->Clear();
MITK_TEST_CONDITION(baseDataImpl->IsEmptyTimeStep(1), "...but afterwards!");
//test method Set-/GetProperty()
baseDataImpl->SetProperty("property38", mitk::StringProperty::New("testproperty"));
//baseDataImpl->SetProperty("visibility", mitk::BoolProperty::New());
MITK_TEST_CONDITION(baseDataImpl->GetProperty("property38")->GetValueAsString() == "testproperty","Check if base property is set correctly!");
cloneBaseData = baseDataImpl->Clone();
MITK_TEST_CONDITION(cloneBaseData->GetProperty("property38")->GetValueAsString() == "testproperty", "Testing origin set in clone!");
//test method Set-/GetPropertyList
mitk::PropertyList::Pointer propertyList = mitk::PropertyList::New();
propertyList->SetFloatProperty("floatProperty1", 123.45);
propertyList->SetBoolProperty("visibility",true);
propertyList->SetStringProperty("nameXY","propertyName");
baseDataImpl->SetPropertyList(propertyList);
bool value = false;
MITK_TEST_CONDITION(baseDataImpl->GetPropertyList() == propertyList, "Check if base property list is set correctly!");
MITK_TEST_CONDITION(baseDataImpl->GetPropertyList()->GetBoolProperty("visibility", value) == true, "Check if base property is set correctly in the property list!");
//test method UpdateOutputInformation()
baseDataImpl->UpdateOutputInformation();
MITK_TEST_CONDITION(baseDataImpl->GetUpdatedTimeSlicedGeometry() == geo2, "TimeSlicedGeometry update!");
//Test method CopyInformation()
mitk::BaseDataTestImplementation::Pointer newBaseData = mitk::BaseDataTestImplementation::New();
newBaseData->CopyInformation(baseDataImpl);
MITK_TEST_CONDITION_REQUIRED( newBaseData->GetTimeSlicedGeometry()->GetTimeSteps() == 5, "Check copying of of Basedata Data Object!");
MITK_TEST_END()
}
diff --git a/Core/Code/Testing/mitkDataNodeTest.cpp b/Core/Code/Testing/mitkDataNodeTest.cpp
index 258838f21d..fe23f53ca8 100644
--- a/Core/Code/Testing/mitkDataNodeTest.cpp
+++ b/Core/Code/Testing/mitkDataNodeTest.cpp
@@ -1,300 +1,300 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkDataNode.h"
#include <vtkWindow.h>
#include "mitkVtkPropRenderer.h"
#include "mitkTestingMacros.h"
#include "mitkGlobalInteraction.h"
#include <iostream>
//Basedata Test
#include <mitkRenderWindowFrame.h>
#include <mitkGeometryData.h>
#include <mitkGeometry2DData.h>
#include <mitkGradientBackground.h>
#include <mitkManufacturerLogo.h>
#include <mitkPointSet.h>
#include <mitkImage.h>
#include <mitkSurface.h>
//Mapper Test
#include <mitkGeometry2DDataMapper2D.h>
#include <mitkGeometry2DDataMapper2D.h>
#include <mitkImageVtkMapper2D.h>
-#include <mitkPointSetGLMapper2D.h>
#include <mitkPolyDataGLMapper2D.h>
#include <mitkSurfaceGLMapper2D.h>
#include <mitkGeometry2DDataVtkMapper3D.h>
#include <mitkPointSetVtkMapper3D.h>
+#include <mitkPointSetVtkMapper2D.h>
#include <mitkSurfaceVtkMapper3D.h>
#include <mitkVolumeDataVtkMapper3D.h>
//Interactors
#include <mitkAffineInteractor.h>
#include <mitkPointSetInteractor.h>
//Propertylist Test
/**
* Simple example for a test for the (non-existent) class "DataNode".
*
* argc and argv are the command line parameters which were passed to
* the ADD_TEST command in the CMakeLists.txt file. For the automatic
* tests, argv is either empty for the simple tests or contains the filename
* of a test image for the image tests (see CMakeLists.txt).
*/
class mitkDataNodeTestClass { public:
static void TestDataSetting(mitk::DataNode::Pointer dataNode)
{
mitk::BaseData::Pointer baseData;
//NULL pointer Test
dataNode->SetData(baseData);
MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a NULL pointer was set correctly" )
baseData = mitk::RenderWindowFrame::New();
dataNode->SetData(baseData);
MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a RenderWindowFrame object was set correctly" )
// MITK_TEST_CONDITION( baseData->GetGeometry(0)->GetVtkTransform() == dataNode->GetVtkTransform(0), "Testing if a NULL pointer was set correctly" )
baseData = mitk::GeometryData::New();
dataNode->SetData(baseData);
MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a GeometryData object was set correctly" )
baseData = mitk::Geometry2DData::New();
dataNode->SetData(baseData);
MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a Geometry2DData object was set correctly" )
baseData = mitk::GradientBackground::New();
dataNode->SetData(baseData);
MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a GradientBackground object was set correctly" )
baseData = mitk::ManufacturerLogo::New();
dataNode->SetData(baseData);
MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a ManufacturerLogo object was set correctly" )
baseData = mitk::PointSet::New();
dataNode->SetData(baseData);
MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a PointSet object was set correctly" )
baseData = mitk::Image::New();
dataNode->SetData(baseData);
MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a Image object was set correctly" )
baseData = mitk::Surface::New();
dataNode->SetData(baseData);
MITK_TEST_CONDITION( baseData == dataNode->GetData(), "Testing if a Surface object was set correctly" )
}
static void TestMapperSetting(mitk::DataNode::Pointer dataNode)
{
//tests the SetMapper() method
//in dataNode is a mapper vector which can be accessed by index
//in this test method we use only slot 0 (filled with null) and slot 1
//so we also test the destructor of the mapper classes
mitk::Mapper::Pointer mapper;
dataNode->SetMapper(0,mapper);
MITK_TEST_CONDITION( mapper == dataNode->GetMapper(0), "Testing if a NULL pointer was set correctly" )
mapper = mitk::Geometry2DDataMapper2D::New();
dataNode->SetMapper(1,mapper);
MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a Geometry2DDataMapper2D was set correctly" )
MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
mapper = mitk::ImageVtkMapper2D::New();
dataNode->SetMapper(1,mapper);
MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a ImageVtkMapper2D was set correctly" )
MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
- mapper = mitk::PointSetGLMapper2D::New();
+ mapper = mitk::PointSetVtkMapper2D::New();
dataNode->SetMapper(1,mapper);
- MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a PointSetGLMapper2D was set correctly" )
+ MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a PointSetVtkMapper2D was set correctly" )
MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
dataNode->SetMapper(1,mapper);
MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a PolyDataGLMapper2D was set correctly" )
MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
mapper = mitk::SurfaceGLMapper2D::New();
dataNode->SetMapper(1,mapper);
MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a SurfaceGLMapper2D was set correctly" )
MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
mapper = mitk::Geometry2DDataVtkMapper3D::New();
dataNode->SetMapper(1,mapper);
MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a Geometry2DDataVtkMapper3D was set correctly" )
MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
mapper = mitk::PointSetVtkMapper3D::New();
dataNode->SetMapper(1,mapper);
MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a PointSetVtkMapper3D was set correctly" )
MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
mapper = mitk::SurfaceVtkMapper3D::New();
dataNode->SetMapper(1,mapper);
MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a SurfaceVtkMapper3D was set correctly" )
MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
mapper = mitk::VolumeDataVtkMapper3D::New();
dataNode->SetMapper(1,mapper);
MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a VolumeDataVtkMapper3D was set correctly" )
MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
//linker error
//mapper = mitk::LineVtkMapper3D::New();
//dataNode->SetMapper(1,mapper);
//MITK_TEST_CONDITION( mapper == dataNode->GetMapper(1), "Testing if a LineVtkMapper3D was set correctly" )
//MITK_TEST_CONDITION( dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode" )
}
static void TestInteractorSetting(mitk::DataNode::Pointer dataNode)
{
//this method tests the SetInteractor() and GetInteractor methods
//the Interactor base class calls the DataNode->SetInteractor method
mitk::Interactor::Pointer interactor;
MITK_TEST_CONDITION( interactor == dataNode->GetInteractor(), "Testing if a NULL pointer was set correctly (Interactor)" )
interactor = mitk::AffineInteractor::New("AffineInteractions click to select", dataNode);
dataNode->EnableInteractor();
dataNode->DisableInteractor();
MITK_TEST_CONDITION( interactor == dataNode->GetInteractor(), "Testing if a AffineInteractor was set correctly" )
interactor = mitk::PointSetInteractor::New("AffineInteractions click to select", dataNode);
MITK_TEST_CONDITION( interactor == dataNode->GetInteractor(), "Testing if a PointSetInteractor was set correctly" )
}
static void TestPropertyList(mitk::DataNode::Pointer dataNode)
{
mitk::PropertyList::Pointer propertyList = dataNode->GetPropertyList();
MITK_TEST_CONDITION(dataNode->GetPropertyList() != NULL, "Testing if the constructor set the propertylist" )
dataNode->SetIntProperty("int", -31337);
int x;
dataNode->GetIntProperty("int", x);
MITK_TEST_CONDITION(x == -31337, "Testing Set/GetIntProperty");
dataNode->SetBoolProperty("bool", true);
bool b;
dataNode->GetBoolProperty("bool", b);
MITK_TEST_CONDITION(b == true, "Testing Set/GetBoolProperty");
dataNode->SetFloatProperty("float", -31.337);
float y;
dataNode->GetFloatProperty("float", y);
MITK_TEST_CONDITION(y - -31.337 < 0.01, "Testing Set/GetFloatProperty");
dataNode->SetStringProperty("string", "MITK");
std::string s = "GANZVIELPLATZ";
dataNode->GetStringProperty("string", s);
MITK_TEST_CONDITION(s == "MITK", "Testing Set/GetStringProperty");
std::string name = "MyTestName";
dataNode->SetName(name.c_str());
MITK_TEST_CONDITION(dataNode->GetName() == name, "Testing Set/GetName");
name = "MySecondTestName";
dataNode->SetName(name);
MITK_TEST_CONDITION(dataNode->GetName() == name, "Testing Set/GetName(std::string)");
MITK_TEST_CONDITION(propertyList == dataNode->GetPropertyList(), "Testing if the propertylist has changed during the last tests" )
}
static void TestSelected(mitk::DataNode::Pointer dataNode)
{
vtkRenderWindow *renderWindow = vtkRenderWindow::New();
mitk::VtkPropRenderer::Pointer base = mitk::VtkPropRenderer::New( "the first renderer", renderWindow, mitk::RenderingManager::GetInstance() );
//with BaseRenderer==Null
MITK_TEST_CONDITION(!dataNode->IsSelected(), "Testing if this node is not set as selected" )
dataNode->SetSelected(true);
MITK_TEST_CONDITION(dataNode->IsSelected(), "Testing if this node is set as selected" )
dataNode->SetSelected(false);
dataNode->SetSelected(true,base);
MITK_TEST_CONDITION(dataNode->IsSelected(base), "Testing if this node with right base renderer is set as selected" )
//Delete RenderWindow correctly
renderWindow->Delete();
}
static void TestGetMTime(mitk::DataNode::Pointer dataNode)
{
unsigned long time;
time = dataNode->GetMTime();
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
dataNode->SetData(pointSet);
MITK_TEST_CONDITION( time != dataNode->GetMTime(), "Testing if the node timestamp is updated after adding data to the node" )
mitk::Point3D point;
point.Fill(3.0);
pointSet->SetPoint(0,point);
//less or equal because dataNode timestamp is little later then the basedata timestamp
MITK_TEST_CONDITION( pointSet->GetMTime() <= dataNode->GetMTime(), "Testing if the node timestamp is updated after base data was modified" )
// testing if changing anything in the property list also sets the node in a modified state
unsigned long lastModified = dataNode->GetMTime();
dataNode->SetIntProperty("testIntProp", 2344);
MITK_TEST_CONDITION( lastModified <= dataNode->GetMTime(), "Testing if the node timestamp is updated after property list was modified" )
}
}; //mitkDataNodeTestClass
int mitkDataNodeTest(int /* argc */, char* /*argv*/[])
{
// always start with this!
MITK_TEST_BEGIN("DataNode")
// Global interaction must(!) be initialized
mitk::GlobalInteraction::GetInstance()->Initialize("global");
// let's create an object of our class
mitk::DataNode::Pointer myDataNode = mitk::DataNode::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myDataNode.IsNotNull(),"Testing instantiation")
//test setData() Method
mitkDataNodeTestClass::TestDataSetting(myDataNode);
mitkDataNodeTestClass::TestMapperSetting(myDataNode);
//
//note, that no data is set to the dataNode
mitkDataNodeTestClass::TestInteractorSetting(myDataNode);
mitkDataNodeTestClass::TestPropertyList(myDataNode);
mitkDataNodeTestClass::TestSelected(myDataNode);
mitkDataNodeTestClass::TestGetMTime(myDataNode);
// write your own tests here and use the macros from mitkTestingMacros.h !!!
// do not write to std::cout and do not return from this function yourself!
// always end with this!
MITK_TEST_END()
}
diff --git a/Core/Code/Testing/mitkEventConfigTest.cpp b/Core/Code/Testing/mitkEventConfigTest.cpp
index 2419f5ae7f..f3db0b9efd 100644
--- a/Core/Code/Testing/mitkEventConfigTest.cpp
+++ b/Core/Code/Testing/mitkEventConfigTest.cpp
@@ -1,151 +1,151 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTestingMacros.h"
#include "mitkEventConfig.h"
#include "mitkPropertyList.h"
#include "mitkInteractionEvent.h"
#include "mitkInteractionEventConst.h"
#include "mitkMouseMoveEvent.h"
#include "mitkMouseWheelEvent.h"
#include "mitkMouseReleaseEvent.h"
#include "mitkInteractionKeyEvent.h"
#include "mitkMousePressEvent.h"
#include "mitkModule.h"
#include "mitkGetModuleContext.h"
#include <string>
#include <iostream>
#include <fstream>
int mitkEventConfigTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("EventConfig")
if (argc != 2) {
MITK_ERROR << "Test needs configuration test file as parameter.";
return -1;
}
/*
* Loads a test a Config file and test if Config is build up correctly,
* and if mapping from mitkEvents to EventVariant names works properly.
* Indirectly this also tests the EventFactory Class, since we also test if the events have been constructed properly.
*
* The configuration object is constructed in three different ways,
* each one is tested here.
*/
// Construction using compiled-in resrouces:
mitk::Module *module = mitk::GetModuleContext()->GetModule();
mitk::EventConfig newConfig("StatemachineConfigTest.xml",module);
MITK_TEST_CONDITION_REQUIRED(
newConfig.IsValid() == true
, "01 Check if file can be loaded and is valid" );
/*
* Test the global properties:
* Test if stored values match the ones in the test config file.
*/
mitk::PropertyList::Pointer properties = newConfig.GetAttributes();
std::string prop1, prop2;
MITK_TEST_CONDITION_REQUIRED(
properties->GetStringProperty("property1",prop1) &&
prop1 == "yes" &&
properties->GetStringProperty("scrollModus",prop2) &&
prop2 == "leftright"
, "02 Check Global Properties");
/*
* Check if Events get mapped to the proper Variants
*/
mitk::Point2D pos;
mitk::MousePressEvent::Pointer mpe1 = mitk::MousePressEvent::New(NULL,pos,mitk::InteractionEvent::MiddleMouseButton | mitk::InteractionEvent::LeftMouseButton ,mitk::InteractionEvent::ControlKey | mitk::InteractionEvent::AltKey,mitk::InteractionEvent::LeftMouseButton );
mitk::MousePressEvent::Pointer standard1 = mitk::MousePressEvent::New(NULL,pos,mitk::InteractionEvent::LeftMouseButton,mitk::InteractionEvent::NoKey ,mitk::InteractionEvent::LeftMouseButton );
mitk::MouseMoveEvent::Pointer mme1 = mitk::MouseMoveEvent::New(NULL,pos,mitk::InteractionEvent::RightMouseButton | mitk::InteractionEvent::LeftMouseButton,mitk::InteractionEvent::ShiftKey );
mitk::MouseMoveEvent::Pointer mme2 = mitk::MouseMoveEvent::New(NULL,pos,mitk::InteractionEvent::RightMouseButton,mitk::InteractionEvent::ShiftKey );
mitk::MouseWheelEvent::Pointer mwe1 = mitk::MouseWheelEvent::New(NULL,pos,mitk::InteractionEvent::RightMouseButton,mitk::InteractionEvent::ShiftKey,-2 );
mitk::InteractionKeyEvent::Pointer ke = mitk::InteractionKeyEvent::New(NULL,"l",mitk::InteractionEvent::NoKey );
MITK_TEST_CONDITION_REQUIRED(
newConfig.GetMappedEvent(mpe1.GetPointer()) == "Variant1" &&
newConfig.GetMappedEvent(standard1.GetPointer()) == "Standard1" &&
newConfig.GetMappedEvent(mme1.GetPointer()) == "Move2" &&
newConfig.GetMappedEvent(ke.GetPointer()) == "Key1" &&
newConfig.GetMappedEvent(mme2.GetPointer()) == "" // does not exist in file
, "03 Check Mouse- and Key-Events " );
// Construction providing a input stream
std::ifstream configStream(argv[1]);
mitk::EventConfig newConfig2(configStream);
MITK_TEST_CONDITION_REQUIRED(
newConfig2.IsValid() == true
, "01 Check if file can be loaded and is valid" );
/*
* Test the global properties:
* Test if stored values match the ones in the test config file.
*/
properties = newConfig2.GetAttributes();
MITK_TEST_CONDITION_REQUIRED(
properties->GetStringProperty("property1",prop1) &&
prop1 == "yes" &&
properties->GetStringProperty("scrollModus",prop2) &&
prop2 == "leftright"
, "02 Check Global Properties");
/*
* Check if Events get mapped to the proper Variants
*/
MITK_TEST_CONDITION_REQUIRED(
newConfig2.GetMappedEvent(mpe1.GetPointer()) == "Variant1" &&
newConfig2.GetMappedEvent(standard1.GetPointer()) == "Standard1" &&
newConfig2.GetMappedEvent(mme1.GetPointer()) == "Move2" &&
newConfig2.GetMappedEvent(ke.GetPointer()) == "Key1" &&
newConfig2.GetMappedEvent(mme2.GetPointer()) == "" // does not exist in file
, "03 Check Mouse- and Key-Events " );
// always end with this!
// Construction providing a property list
mitk::PropertyList::Pointer propertyList1 = mitk::PropertyList::New();
- propertyList1->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventClass.c_str(), "MousePressEvent");
- propertyList1->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventVariant.c_str(), "MousePressEventVariant");
+ propertyList1->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventClass().c_str(), "MousePressEvent");
+ propertyList1->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventVariant().c_str(), "MousePressEventVariant");
propertyList1->SetStringProperty("Modifiers","CTRL,ALT");
mitk::PropertyList::Pointer propertyList2 = mitk::PropertyList::New();
- propertyList2->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventClass.c_str(), "MOUSERELEASEEVENT");
- propertyList2->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventVariant.c_str(), "MouseReleaseEventVariant");
+ propertyList2->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventClass().c_str(), "MOUSERELEASEEVENT");
+ propertyList2->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventVariant().c_str(), "MouseReleaseEventVariant");
propertyList2->SetStringProperty("Modifiers","SHIFT");
std::vector<mitk::PropertyList::Pointer>* configDescription = new std::vector<mitk::PropertyList::Pointer>();
configDescription->push_back(propertyList1);
configDescription->push_back(propertyList2);
mitk::EventConfig newConfig3(*configDescription);
mitk::MousePressEvent::Pointer mousePress1 = mitk::MousePressEvent::New(NULL,pos,mitk::InteractionEvent::NoButton,mitk::InteractionEvent::AltKey | mitk::InteractionEvent::ControlKey ,mitk::InteractionEvent::NoButton );
mitk::MouseReleaseEvent::Pointer mousePress2 = mitk::MouseReleaseEvent::New(NULL,pos,mitk::InteractionEvent::NoButton,mitk::InteractionEvent::ShiftKey ,mitk::InteractionEvent::NoButton );
MITK_TEST_CONDITION_REQUIRED(
newConfig3.GetMappedEvent(mousePress1.GetPointer()) == "MousePressEventVariant" &&
newConfig3.GetMappedEvent(mousePress2.GetPointer()) == "MouseReleaseEventVariant"
, "04 Check Mouseevents from PropertyLists" );
MITK_TEST_END()
}
diff --git a/Core/Code/Testing/mitkGrabItkImageMemoryTest.cpp b/Core/Code/Testing/mitkGrabItkImageMemoryTest.cpp
new file mode 100644
index 0000000000..55e6c8446b
--- /dev/null
+++ b/Core/Code/Testing/mitkGrabItkImageMemoryTest.cpp
@@ -0,0 +1,130 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkTestingMacros.h"
+#include "mitkITKImageImport.h"
+
+#include "mitkImagePixelReadAccessor.h"
+
+#include <itkThresholdImageFilter.h>
+
+#include "mitkImageAccessByItk.h"
+
+/**
+ * An ITK-based filter for thresholding.
+ *
+ * The filter represents the typical usage of ITK-like filters inside MITK. It is to be called for an mitk::Image
+ * by using the AccessByItk macro. The filter executes the binary threshold filter and imports the result into the
+ * output by using the ImportItkImage method.
+ *
+ * @param output mitk::Image to hold the result of the filter
+ * @param th[] two double values to set the lower/upper threshold
+ */
+//! [ItkThresholdFilter]
+template<typename TPixel, unsigned int VDimensions>
+static void ItkThresholdFilter(
+ const itk::Image<TPixel, VDimensions>* image,
+ mitk::Image::Pointer& output,
+ const double th[])
+{
+ typedef itk::Image<TPixel, VDimensions> InputImageType;
+ typedef itk::Image<TPixel, VDimensions> OutputImageType;
+ typedef itk::ThresholdImageFilter< InputImageType > ThresholdFilterType;
+
+ typename ThresholdFilterType::Pointer thresholder =
+ ThresholdFilterType::New();
+ thresholder->SetInput(image);
+ thresholder->ThresholdOutside(th[0], th[1]);
+ thresholder->Update();
+
+ try
+ {
+ output = mitk::GrabItkImageMemory(thresholder->GetOutput());
+ }
+ catch(itk::ExceptionObject&)
+ {
+ MITK_TEST_FAILED_MSG(<<"Thresholding computation failed");
+ }
+}
+//! [ItkThresholdFilter]
+
+/**
+ * Creates an mitk::Image, executes the binary threshold filter through AccessByItk and
+ * checks whether the image data was correctly imported back to an mitk::Image.
+ */
+template< typename TPixel>
+bool Assert_ItkImportWithinAccessByItkSucceded_ReturnsTrue()
+{
+ // data for 3x3x3 image
+ const unsigned int dimensions[3] = {3,3,3};
+ TPixel* image_data = new TPixel[27];
+
+ // ground truth for result check
+ TPixel* ground_truth = new TPixel[27];
+ double threshold[2] = { 90.0, 180.0 };
+
+ // fill image
+ for( unsigned int i=0; i<27; i++)
+ {
+ image_data[i] = static_cast<TPixel>(i * 10);
+
+ ground_truth[i] = 0;
+ if( image_data[i] >= threshold[0] && image_data[i] <= threshold[1] )
+ ground_truth[i] = static_cast<TPixel>(i * 10);
+
+ }
+
+ mitk::Image::Pointer input = mitk::Image::New();
+ input->Initialize( mitk::MakeScalarPixelType<TPixel>(), 3, dimensions );
+ input->SetImportVolume( image_data );
+
+//! [OutOfScopeCall]
+ mitk::Image::Pointer output = mitk::Image::New();
+ AccessByItk_2(input, ItkThresholdFilter, output, threshold );
+//! [OutOfScopeCall]
+
+ mitk::ImagePixelReadAccessor< TPixel, 3 > readAccessor( output );
+ const TPixel* output_data = readAccessor.GetConstData();
+
+ bool equal = true;
+ for( unsigned int i=0; i<27; i++)
+ {
+
+ equal &= (ground_truth[i] == output_data[i]);
+ if(!equal)
+ {
+ MITK_INFO << " :: At position " << i << " : " <<ground_truth[i] << " ? " << output_data[i] << "\n";
+ break;
+ }
+ }
+
+ MITK_TEST_CONDITION(equal, " Imported output data equals the ground truth");
+
+ return equal;
+
+}
+
+int mitkGrabItkImageMemoryTest( int /*argc*/, char* /*argv*/[] )
+{
+ MITK_TEST_BEGIN("mitkGrabItkImageMemoryTest")
+
+ Assert_ItkImportWithinAccessByItkSucceded_ReturnsTrue<short>();// "Import successful on 3D short");
+ Assert_ItkImportWithinAccessByItkSucceded_ReturnsTrue<float>();// "Import succesfull on float");
+ Assert_ItkImportWithinAccessByItkSucceded_ReturnsTrue<unsigned char>();// "Import succesfull on uchar");
+ Assert_ItkImportWithinAccessByItkSucceded_ReturnsTrue<int>();// "Import succesfull on int");
+
+ MITK_TEST_END()
+}
diff --git a/Core/Code/Testing/mitkImageDimensionConverterTest.cpp b/Core/Code/Testing/mitkImageDimensionConverterTest.cpp
index 611093614e..ff084a8523 100644
--- a/Core/Code/Testing/mitkImageDimensionConverterTest.cpp
+++ b/Core/Code/Testing/mitkImageDimensionConverterTest.cpp
@@ -1,292 +1,292 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// mitk includes
#include <mitkImage.h>
#include <mitkImageDataItem.h>
#include <mitkImageCast.h>
#include "mitkItkImageFileReader.h"
#include <mitkTestingMacros.h>
#include <mitkImageStatisticsHolder.h>
#include <mitkConvert2Dto3DImageFilter.h>
#include <mitkRotationOperation.h>
#include <mitkInteractionConst.h>
#include <mitkImageWriter.h>
#include <mitkPlaneOperation.h>
#include "mitkTestingConfig.h"
#include "mitkItkImageFileReader.h"
// itk includes
#include <itkImage.h>
#include <itkMersenneTwisterRandomVariateGenerator.h>
// stl includes
#include <fstream>
// vtk includes
#include <vtkImageData.h>
int mitkImageDimensionConverterTest(int argc, char* argv[])
{
MITK_TEST_BEGIN(mitkImageDimensionConverterTest);
// Define an epsilon which is the allowed error
float eps = 0.00001;
// Define helper variables
float error = 0;
bool matrixIsEqual = true;
std::stringstream sstream;
mitk::ImageWriter::Pointer imageWriter = mitk::ImageWriter::New();
mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
mitk::Convert2Dto3DImageFilter::Pointer convertFilter = mitk::Convert2Dto3DImageFilter::New();
///////////////////////////////////////
// Create 2D Image with a 3D rotation from scratch.
typedef itk::Image<double,2> ImageType;
ImageType::Pointer itkImage = ImageType::New();
ImageType::RegionType myRegion;
ImageType::SizeType mySize;
ImageType::IndexType myIndex;
ImageType::SpacingType mySpacing;
mySpacing[0] = 1;
mySpacing[1] = 1;
myIndex[0] = 0;
myIndex[1] = 0;
mySize[0] = 50;
mySize[1] = 50;
myRegion.SetSize( mySize);
myRegion.SetIndex( myIndex );
itkImage->SetSpacing(mySpacing);
itkImage->SetRegions( myRegion);
itkImage->Allocate();
itkImage->FillBuffer(50);
mitk::Image::Pointer mitkImage2D;
mitk::CastToMitkImage(itkImage,mitkImage2D);
// rotate
mitk::Point3D p;
p[0] = 1;
p[1] = 3;
p[2] = 5;
mitk::Vector3D v;
v[0] = 0.3;
v[1] = 1;
v[2] = 0.1;
mitk::RotationOperation op(mitk::OpROTATE, p, v, 35);
mitkImage2D->GetGeometry()->ExecuteOperation(&op);
// Save original Geometry infos
mitk::Vector3D Original_col0, Original_col1, Original_col2;
- Original_col0.Set_vnl_vector(mitkImage2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
- Original_col1.Set_vnl_vector(mitkImage2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
- Original_col2.Set_vnl_vector(mitkImage2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
+ Original_col0.SetVnlVector(mitkImage2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
+ Original_col1.SetVnlVector(mitkImage2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
+ Original_col2.SetVnlVector(mitkImage2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
MITK_INFO << "Rotated Matrix: " << Original_col0 << " " << Original_col1 << " " << Original_col2;
mitk::Point3D Original_Origin = mitkImage2D->GetGeometry()->GetOrigin();
mitk::Vector3D Original_Spacing = mitkImage2D->GetGeometry()->GetSpacing();
MITK_TEST_CONDITION_REQUIRED( mitkImage2D->GetDimension() == 2 , "Created Image is Dimension 2");
///////////////////////////////////////
// mitkImage2D is now a 2D image with 3D Geometry information.
// Save it without conversion and load it again. It should have an identitiy matrix
sstream.clear();
sstream << MITK_TEST_OUTPUT_DIR << "" << "/rotatedImage2D";
imageWriter->SetInput(mitkImage2D);
imageWriter->SetFileName(sstream.str().c_str());
imageWriter->SetExtension(".nrrd");
imageWriter->Write();
sstream << ".nrrd";
imageReader->SetFileName(sstream.str().c_str());
imageReader->Update();
mitk::Image::Pointer imageLoaded2D = imageReader->GetOutput();
// check if image can be loaded
MITK_TEST_CONDITION_REQUIRED( imageLoaded2D.IsNotNull() , "Loading saved 2D Image");
MITK_TEST_CONDITION_REQUIRED( imageLoaded2D->GetDimension() == 2 , "Loaded Image is Dimension 2");
// check if spacing is ok
mitk::Vector3D Loaded2D_Spacing = imageLoaded2D->GetGeometry()->GetSpacing();
error = abs(Loaded2D_Spacing[0] - Original_Spacing[0]) +
abs(Loaded2D_Spacing[1] - Original_Spacing[1]) +
abs(Loaded2D_Spacing[2] - 1) ;
MITK_TEST_CONDITION_REQUIRED( error < eps , "Compare Geometry: Spacing");
// Check origin
mitk::Point3D Loaded2D_Origin = imageLoaded2D->GetGeometry()->GetOrigin();
error = abs(Loaded2D_Origin[0] - Original_Origin[0]) +
abs(Loaded2D_Origin[1] - Original_Origin[1]) +
abs(Loaded2D_Origin[2] - 0) ;
MITK_TEST_CONDITION_REQUIRED( error < eps, "Compare Geometry: Origin");
// Check matrix
mitk::Vector3D Loaded2D_col0, Loaded2D_col1, Loaded2D_col2;
- Loaded2D_col0.Set_vnl_vector(imageLoaded2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
- Loaded2D_col1.Set_vnl_vector(imageLoaded2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
- Loaded2D_col2.Set_vnl_vector(imageLoaded2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
+ Loaded2D_col0.SetVnlVector(imageLoaded2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
+ Loaded2D_col1.SetVnlVector(imageLoaded2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
+ Loaded2D_col2.SetVnlVector(imageLoaded2D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
if (
(abs(1 - Loaded2D_col0[0]) > eps) ||
(abs(0 - Loaded2D_col0[1]) > eps) ||
(abs(0 - Loaded2D_col0[2]) > eps) ||
(abs(0 - Loaded2D_col1[0]) > eps) ||
(abs(1 - Loaded2D_col1[1]) > eps) ||
(abs(0 - Loaded2D_col1[2]) > eps) ||
(abs(0 - Loaded2D_col2[0]) > eps) ||
(abs(0 - Loaded2D_col2[1]) > eps) ||
(abs(1 - Loaded2D_col2[2]) > eps) )
{
matrixIsEqual = false;
}
else
matrixIsEqual = true;
MITK_TEST_CONDITION_REQUIRED( matrixIsEqual , "Compare Geometry: Matrix");
///////////////////////////////////////
// mitkImage2D is a 2D image with 3D Geometry information.
// Convert it with filter to a 3D image and check if everything went well
convertFilter->SetInput(mitkImage2D);
convertFilter->Update();
mitk::Image::Pointer mitkImage3D = convertFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED( mitkImage3D->GetDimension() == 3 , "Converted Image is Dimension 3");
// check if geometry is still same
mitk::Vector3D Converted_Spacing = mitkImage3D->GetGeometry()->GetSpacing();
error = abs(Converted_Spacing[0] - Original_Spacing[0]) +
abs(Converted_Spacing[1] - Original_Spacing[1]) +
abs(Converted_Spacing[2] - Original_Spacing[2]) ;
MITK_TEST_CONDITION_REQUIRED( error < eps , "Compare Geometry: Spacing");
mitk::Point3D Converted_Origin = mitkImage3D->GetGeometry()->GetOrigin();
error = abs(Converted_Origin[0] - Original_Origin[0]) +
abs(Converted_Origin[1] - Original_Origin[1]) +
abs(Converted_Origin[2] - Original_Origin[2]) ;
MITK_INFO << Converted_Origin << " and " << Original_Origin;
MITK_TEST_CONDITION_REQUIRED( error < eps , "Compare Geometry: Origin");
mitk::Vector3D Converted_col0, Converted_col1, Converted_col2;
- Converted_col0.Set_vnl_vector(mitkImage3D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
- Converted_col1.Set_vnl_vector(mitkImage3D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
- Converted_col2.Set_vnl_vector(mitkImage3D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
+ Converted_col0.SetVnlVector(mitkImage3D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
+ Converted_col1.SetVnlVector(mitkImage3D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
+ Converted_col2.SetVnlVector(mitkImage3D->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
if (
(abs(Original_col0[0] - Converted_col0[0]) > eps) ||
(abs(Original_col0[1] - Converted_col0[1]) > eps) ||
(abs(Original_col0[2] - Converted_col0[2]) > eps) ||
(abs(Original_col1[0] - Converted_col1[0]) > eps) ||
(abs(Original_col1[1] - Converted_col1[1]) > eps) ||
(abs(Original_col1[2] - Converted_col1[2]) > eps) ||
(abs(Original_col2[0] - Converted_col2[0]) > eps) ||
(abs(Original_col2[1] - Converted_col2[1]) > eps) ||
(abs(Original_col2[2] - Converted_col2[2]) > eps) )
{
MITK_INFO << "Oh No! Original Image Matrix and Converted Image Matrix are different!";
MITK_INFO << "original Image:" << Original_col0 << " " << Original_col1 << " " << Original_col2;
MITK_INFO << "converted Image:" << Converted_col0 << " " << Converted_col1 << " " << Converted_col2;
matrixIsEqual = false;
}
else
matrixIsEqual = true;
MITK_TEST_CONDITION_REQUIRED( matrixIsEqual , "Compare Geometry: Matrix");
///////////////////////////////////////
// So far it seems good! now try to save and load the file
std::stringstream sstream2;
sstream2 << MITK_TEST_OUTPUT_DIR << "" << "/rotatedImage";
imageWriter->SetInput(mitkImage3D);
imageWriter->SetFileName(sstream2.str().c_str());
imageWriter->SetExtension(".nrrd");
imageWriter->Write();
sstream2 << ".nrrd";
imageReader->SetFileName(sstream2.str().c_str());
imageReader->Update();
mitk::Image::Pointer imageLoaded = imageReader->GetOutput();
// check if image can be loaded
MITK_TEST_CONDITION_REQUIRED( imageLoaded.IsNotNull() , "Loading saved Image");
// check if loaded image is still what it should be:
MITK_TEST_CONDITION_REQUIRED( imageLoaded->GetDimension() == 3 , "Loaded Image is Dimension 3");
// check if geometry is still same
mitk::Vector3D Loaded_Spacing = imageLoaded->GetGeometry()->GetSpacing();
error = abs(Loaded_Spacing[0] - Original_Spacing[0]) +
abs(Loaded_Spacing[1] - Original_Spacing[1]) +
abs(Loaded_Spacing[2] - Original_Spacing[2]) ;
MITK_TEST_CONDITION_REQUIRED( error < eps , "Compare Geometry: Spacing");
mitk::Point3D Loaded_Origin = imageLoaded->GetGeometry()->GetOrigin();
error = abs(Loaded_Origin[0] - Original_Origin[0]) +
abs(Loaded_Origin[1] - Original_Origin[1]) +
abs(Loaded_Origin[2] - Original_Origin[2]) ;
MITK_TEST_CONDITION_REQUIRED( error < eps , "Compare Geometry: Origin");
mitk::Vector3D Loaded_col0, Loaded_col1, Loaded_col2;
- Loaded_col0.Set_vnl_vector(imageLoaded->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
- Loaded_col1.Set_vnl_vector(imageLoaded->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
- Loaded_col2.Set_vnl_vector(imageLoaded->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
+ Loaded_col0.SetVnlVector(imageLoaded->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
+ Loaded_col1.SetVnlVector(imageLoaded->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
+ Loaded_col2.SetVnlVector(imageLoaded->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
if (
(abs(Original_col0[0] - Loaded_col0[0]) > eps) ||
(abs(Original_col0[1] - Loaded_col0[1]) > eps) ||
(abs(Original_col0[2] - Loaded_col0[2]) > eps) ||
(abs(Original_col1[0] - Loaded_col1[0]) > eps) ||
(abs(Original_col1[1] - Loaded_col1[1]) > eps) ||
(abs(Original_col1[2] - Loaded_col1[2]) > eps) ||
(abs(Original_col2[0] - Loaded_col2[0]) > eps) ||
(abs(Original_col2[1] - Loaded_col2[1]) > eps) ||
(abs(Original_col2[2] - Loaded_col2[2]) > eps) )
{
MITK_INFO << "Oh No! Original Image Matrix and Converted Image Matrix are different!";
MITK_INFO << "original Image:" << Original_col0 << " " << Original_col1 << " " << Original_col2;
MITK_INFO << "converted Image:" << Loaded_col0 << " " << Loaded_col1 << " " << Loaded_col2;
matrixIsEqual = false;
}
else
matrixIsEqual = true;
MITK_TEST_CONDITION_REQUIRED( matrixIsEqual , "Compare Geometry: Matrix");
-
+return 0;
MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkImageGeneratorTest.cpp b/Core/Code/Testing/mitkImageGeneratorTest.cpp
index 771245cbaa..007b98bb17 100644
--- a/Core/Code/Testing/mitkImageGeneratorTest.cpp
+++ b/Core/Code/Testing/mitkImageGeneratorTest.cpp
@@ -1,98 +1,98 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include "mitkImage.h"
#include "mitkImageStatisticsHolder.h"
#include "mitkImageGenerator.h"
int mitkImageGeneratorTest(int /*argc*/, char* /*argv*/[])
{
MITK_TEST_BEGIN("ImageGeneratorTest");
//create some images with arbitrary parameters (corner cases)
mitk::Image::Pointer image2Da = mitk::ImageGenerator::GenerateRandomImage<float>(120, 205, 0, 0, 0.1, 0.2, 0.3, 577, 23);
mitk::Image::Pointer image2Db = mitk::ImageGenerator::GenerateRandomImage<unsigned char>(1, 1, 0, 0);
mitk::Image::Pointer image3Da = mitk::ImageGenerator::GenerateRandomImage<int>(512, 205, 1, 0);
mitk::Image::Pointer image3Db = mitk::ImageGenerator::GenerateRandomImage<double>(512, 532, 112, 0);
mitk::Image::Pointer image4Da = mitk::ImageGenerator::GenerateRandomImage<float>(120, 205, 78, 1);
mitk::Image::Pointer image4Db = mitk::ImageGenerator::GenerateRandomImage<unsigned char>(550, 33, 78, 150);
mitk::Image::Pointer image3Dc = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(1, 2, 3, 4, 5, 6);
MITK_TEST_CONDITION_REQUIRED(fabs(image2Da->GetGeometry()->GetSpacing()[0]-0.1)<0.0001, "Testing if spacing x is set correctly.");
MITK_TEST_CONDITION_REQUIRED(fabs(image2Da->GetGeometry()->GetSpacing()[1]-0.2)<0.0001, "Testing if spacing y is set correctly.");
MITK_TEST_CONDITION_REQUIRED(fabs(image2Da->GetGeometry()->GetSpacing()[2]-0.3)<0.0001, "Testing if spacing z is set correctly.");
MITK_TEST_CONDITION_REQUIRED(fabs(image2Db->GetGeometry()->GetSpacing()[0]-1.0)<0.0001, "Testing if default spacing x is set correctly.");
MITK_TEST_CONDITION_REQUIRED(fabs(image2Db->GetGeometry()->GetSpacing()[1]-1.0)<0.0001, "Testing if default spacing y is set correctly.");
MITK_TEST_CONDITION_REQUIRED(fabs(image2Db->GetGeometry()->GetSpacing()[2]-1.0)<0.0001, "Testing if default spacing z is set correctly.");
MITK_TEST_CONDITION_REQUIRED(fabs(image3Dc->GetGeometry()->GetSpacing()[0]-4)<0.0001, "Testing if spacing x is set correctly.");
MITK_TEST_CONDITION_REQUIRED(fabs(image3Dc->GetGeometry()->GetSpacing()[1]-5)<0.0001, "Testing if spacing y is set correctly.");
MITK_TEST_CONDITION_REQUIRED(fabs(image3Dc->GetGeometry()->GetSpacing()[2]-6)<0.0001, "Testing if spacing z is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image2Da->GetDimension() == 2, "Testing if the dimension is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image2Db->GetDimension() == 2, "Testing if the dimension is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image3Da->GetDimension() == 2, "Testing if the dimension is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image3Db->GetDimension() == 3, "Testing if the dimension is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image4Da->GetDimension() == 3, "Testing if the dimension is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image4Db->GetDimension() == 4, "Testing if the dimension is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image2Da->GetDimension(0) == 120, "Testing if the dimensions are set correctly.");
MITK_TEST_CONDITION_REQUIRED(image2Db->GetDimension(1) == 1, "Testing if the dimensions are set correctly.");
MITK_TEST_CONDITION_REQUIRED(image3Da->GetDimension(2) == 1, "Testing if the dimensions are set correctly.");
MITK_TEST_CONDITION_REQUIRED(image3Db->GetDimension(2) == 112, "Testing if the dimensions are set correctly.");
MITK_TEST_CONDITION_REQUIRED(image4Da->GetDimension(3) == 1, "Testing if the dimensions are set correctly.");
MITK_TEST_CONDITION_REQUIRED(image4Db->GetDimension(3) == 150, "Testing if the dimensions are set correctly.");
MITK_TEST_CONDITION_REQUIRED(image3Dc->GetDimension(0) == 1, "Testing if image3Dc dimension x is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image3Dc->GetDimension(1) == 2, "Testing if image3Dc dimension y is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image3Dc->GetDimension(2) == 3, "Testing if image3Dc dimension z is set correctly.");
itk::ImageIOBase::IOPixelType scalarType = itk::ImageIOBase::SCALAR;
- MITK_TEST_CONDITION_REQUIRED(image2Da->GetPixelType().GetTypeId() == typeid(float), "Testing if the data type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image2Da->GetPixelType().GetPixelTypeId() == scalarType, "Testing if the pixel type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image2Db->GetPixelType().GetTypeId() == typeid(unsigned char), "Testing if the data type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image2Db->GetPixelType().GetPixelTypeId() == scalarType, "Testing if the data type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image3Da->GetPixelType().GetTypeId() == typeid(int), "Testing if the data type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image3Da->GetPixelType().GetPixelTypeId() == scalarType, "Testing if the pixel type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image3Db->GetPixelType().GetTypeId() == typeid(double), "Testing if the data type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image3Db->GetPixelType().GetPixelTypeId() == scalarType, "Testing if the pixel type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image4Da->GetPixelType().GetTypeId() == typeid(float), "Testing if the data type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image4Da->GetPixelType().GetPixelTypeId() == scalarType, "Testing if the pixel type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image4Db->GetPixelType().GetTypeId() == typeid(unsigned char), "Testing if the data type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image4Db->GetPixelType().GetPixelTypeId() == scalarType, "Testing if the pixel type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image3Dc->GetPixelType().GetTypeId() == typeid(unsigned int), "Testing if the data type is set correctly.");
- MITK_TEST_CONDITION_REQUIRED(image3Dc->GetPixelType().GetPixelTypeId() == scalarType, "Testing if the pixel type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image2Da->GetPixelType().GetComponentType() == itk::ImageIOBase::FLOAT, "Testing if the data type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image2Da->GetPixelType().GetPixelType() == scalarType, "Testing if the pixel type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image2Db->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR, "Testing if the data type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image2Db->GetPixelType().GetPixelType() == scalarType, "Testing if the data type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image3Da->GetPixelType().GetComponentType() == itk::ImageIOBase::INT, "Testing if the data type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image3Da->GetPixelType().GetPixelType() == scalarType, "Testing if the pixel type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image3Db->GetPixelType().GetComponentType() == itk::ImageIOBase::DOUBLE, "Testing if the data type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image3Db->GetPixelType().GetPixelType() == scalarType, "Testing if the pixel type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image4Da->GetPixelType().GetComponentType() == itk::ImageIOBase::FLOAT, "Testing if the data type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image4Da->GetPixelType().GetPixelType() == scalarType, "Testing if the pixel type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image4Db->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR, "Testing if the data type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image4Db->GetPixelType().GetPixelType() == scalarType, "Testing if the pixel type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image3Dc->GetPixelType().GetComponentType() == itk::ImageIOBase::UINT, "Testing if the data type is set correctly.");
+ MITK_TEST_CONDITION_REQUIRED(image3Dc->GetPixelType().GetPixelType() == scalarType, "Testing if the pixel type is set correctly.");
MITK_TEST_CONDITION_REQUIRED(image2Da->GetStatistics()->GetScalarValueMax() <= 577, "Testing if max value holds");
MITK_TEST_CONDITION_REQUIRED(image2Da->GetStatistics()->GetScalarValueMin() >= 23, "Testing if min value holds");
MITK_TEST_CONDITION_REQUIRED(image3Da->GetStatistics()->GetScalarValueMax() <= 1000, "Testing if max value holds");
MITK_TEST_CONDITION_REQUIRED(image3Da->GetStatistics()->GetScalarValueMin() >= 0, "Testing if min value holds");
unsigned int* image3DcBuffer = (unsigned int*)image3Dc->GetData();
for(unsigned int i = 0; i < 2*3; i++)
{
MITK_TEST_CONDITION_REQUIRED(image3DcBuffer[i]==i, "Testing if gradient image values are set correctly");
}
MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkImageTest.cpp b/Core/Code/Testing/mitkImageTest.cpp
index d31c5de747..aff7a8715b 100644
--- a/Core/Code/Testing/mitkImageTest.cpp
+++ b/Core/Code/Testing/mitkImageTest.cpp
@@ -1,384 +1,432 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// mitk includes
#include <mitkImage.h>
#include <mitkImageDataItem.h>
#include <mitkImageCast.h>
#include "mitkItkImageFileReader.h"
#include <mitkTestingMacros.h>
#include <mitkImageStatisticsHolder.h>
+#include "mitkImageGenerator.h"
// itk includes
#include <itkImage.h>
#include <itkMersenneTwisterRandomVariateGenerator.h>
// stl includes
#include <fstream>
// vtk includes
#include <vtkImageData.h>
// Checks if reference count is correct after using GetVtkImageData()
bool ImageVtkDataReferenceCheck(const char* fname) {
const std::string filename = std::string(fname);
mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
try
{
imageReader->SetFileName(filename);
imageReader->Update();
}
catch(...) {
MITK_TEST_FAILED_MSG(<< "Could not read file for testing: " << filename);
return false;
}
{
mitk::Image::Pointer image = imageReader->GetOutput();
vtkImageData* vtk = image->GetVtkImageData();
if(vtk == NULL)
return false;
-
- if(image->GetExternalReferenceCount() != 1)
- return false;
}
return true;
}
+class mitkImageTestClass
+{
+public:
+ void SetClonedGeometry_None_ClonedEqualInput()
+ {
+ mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(100, 100, 100, 1, 0.2, 0.3, 0.4);
+
+ //-----------------
+ // geometry information for image
+ mitk::Point3D origin;
+ mitk::Vector3D right, bottom;
+ mitk::Vector3D spacing;
+ mitk::FillVector3D(origin, 17.0, 19.92, 7.83);
+ mitk::FillVector3D(right, 1.0, 2.0, 3.0);
+ mitk::FillVector3D(bottom, 0.0, -3.0, 2.0);
+ mitk::FillVector3D(spacing, 0.78, 0.91, 2.23);
+
+ //InitializeStandardPlane(rightVector, downVector, spacing)
+ mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
+ planegeometry->InitializeStandardPlane(100, 100, right, bottom, &spacing);
+ planegeometry->SetOrigin(origin);
+ planegeometry->ChangeImageGeometryConsideringOriginOffset(true);
+
+ image->SetClonedGeometry(planegeometry);
+
+ mitk::Geometry3D::Pointer imageGeometry = image->GetGeometry();
+ itk::ScalableAffineTransform<mitk::ScalarType,3>* frameNew = imageGeometry->GetIndexToWorldTransform();
+ itk::ScalableAffineTransform<mitk::ScalarType,3>* frameOld = planegeometry->GetIndexToWorldTransform();
+ bool matrixEqual = true;
+ for (int i = 0; i < 16; ++i)
+ {
+ double valueNew = *(frameNew->GetMatrix()[i]);
+ double valueOld = *(frameOld->GetMatrix()[i]);
+
+ //MITK_INFO << "Index: " << i << " Old: " << valueOld << " New: " << valueNew << " Difference:" << valueOld-valueNew<< std::endl;
+ matrixEqual = matrixEqual && mitk::Equal(valueNew, valueOld, mitk::eps);
+ }
+
+ // Disabled because this test fails on the dashboard. Does not fail on my machine.
+ // See Bug 6505
+ // MITK_TEST_CONDITION(matrixEqual, "Matrix elements of cloned matrix equal original matrix");
+
+ }
+};
+
+
int mitkImageTest(int argc, char* argv[])
{
MITK_TEST_BEGIN(mitkImageTest);
+ mitkImageTestClass tester;
+ tester.SetClonedGeometry_None_ClonedEqualInput();
+
+
//Create Image out of nowhere
mitk::Image::Pointer imgMem = mitk::Image::New();
mitk::PixelType pt = mitk::MakeScalarPixelType<int>();
unsigned int dim[]={100,100,20};
MITK_TEST_CONDITION_REQUIRED( imgMem.IsNotNull(), "An image was created. ");
// Initialize image
imgMem->Initialize( pt, 3, dim);
MITK_TEST_CONDITION_REQUIRED( imgMem->IsInitialized(), "Image::IsInitialized() ?");
MITK_TEST_CONDITION_REQUIRED( imgMem->GetPixelType() == pt, "PixelType was set correctly.");
int *p = (int*)imgMem->GetData();
MITK_TEST_CONDITION( p != NULL, "GetData() returned not-NULL pointer.");
// FIXME: this is directly changing the image data
// filling image
const unsigned int size = dim[0]*dim[1]*dim[2];
for(unsigned int i=0; i<size; ++i, ++p)
*p= (signed int)i;
// Getting it again and compare with filled values:
int *p2 = (int*)imgMem->GetData();
MITK_TEST_CONDITION( p2 != NULL, "GetData() returned not-NULL pointer.");
bool isEqual = true;
for(unsigned int i=0; i<size; ++i, ++p2)
{
if(*p2 != (signed int) i )
{
isEqual = false;
}
}
MITK_TEST_CONDITION( isEqual, "The values previously set as data are correct [pixelwise comparison].");
// Testing GetSliceData() and compare with filled values:
p2 = (int*)imgMem->GetSliceData(dim[2]/2)->GetData();
MITK_TEST_CONDITION_REQUIRED( p2 != NULL, "Valid slice data returned");
unsigned int xy_size = dim[0]*dim[1];
unsigned int start_mid_slice = (dim[2]/2)*xy_size;
isEqual = true;
for(unsigned int i=0; i<xy_size; ++i, ++p2)
{
if(*p2!=(signed int)(i+start_mid_slice))
{
isEqual = false;
}
}
MITK_TEST_CONDITION( isEqual, "The SliceData are correct [pixelwise comparison]. ");
imgMem = mitk::Image::New();
// testing re-initialization of test image
mitk::PixelType pType = mitk::MakePixelType<int, int, 1>();
imgMem->Initialize( pType , 3, dim);
MITK_TEST_CONDITION_REQUIRED(imgMem->GetDimension()== 3, "Testing initialization parameter dimension!");
MITK_TEST_CONDITION_REQUIRED(imgMem->GetPixelType() == pType, "Testing initialization parameter pixeltype!");
MITK_TEST_CONDITION_REQUIRED(imgMem->GetDimension(0) == dim[0] &&
imgMem->GetDimension(1)== dim[1] && imgMem->GetDimension(2)== dim[2], "Testing initialization of dimensions!");
MITK_TEST_CONDITION( imgMem->IsInitialized(), "Image is initialized.");
// Setting volume again:
imgMem->SetVolume(imgMem->GetData());
//-----------------
// geometry information for image
mitk::Point3D origin;
mitk::Vector3D right, bottom;
mitk::Vector3D spacing;
mitk::FillVector3D(origin, 17.0, 19.92, 7.83);
mitk::FillVector3D(right, 1.0, 2.0, 3.0);
mitk::FillVector3D(bottom, 0.0, -3.0, 2.0);
mitk::FillVector3D(spacing, 0.78, 0.91, 2.23);
//InitializeStandardPlane(rightVector, downVector, spacing)
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
planegeometry->InitializeStandardPlane(100, 100, right, bottom, &spacing);
planegeometry->SetOrigin(origin);
// Testing Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int slices) with PlaneGeometry and GetData(): ";
imgMem->Initialize( mitk::MakePixelType<int, int, 1>(), *planegeometry);
MITK_TEST_CONDITION_REQUIRED( imgMem->GetGeometry()->GetOrigin() == static_cast<mitk::Geometry3D*>(planegeometry)->GetOrigin(), "Testing correct setting of geometry via initialize!");
p = (int*)imgMem->GetData();
MITK_TEST_CONDITION_REQUIRED( p!=NULL, "GetData() returned valid pointer.");
// Testing Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry) and GetData(): ";
imgMem->Initialize( mitk::MakePixelType<int, int, 1>() , 40, *planegeometry);
p = (int*)imgMem->GetData();
MITK_TEST_CONDITION_REQUIRED( p!=NULL, "GetData() returned valid pointer.");
//-----------------
// testing origin information and methods
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin), "Testing correctness of origin via GetGeometry()->GetOrigin(): ");
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetOrigin(), origin), "Testing correctness of origin via GetTimeSlicedGeometry()->GetOrigin(): ");
// Setting origin via SetOrigin(origin): ";
mitk::FillVector3D(origin, 37.0, 17.92, 27.83);
imgMem->SetOrigin(origin);
// Test origin
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin), "Testing correctness of changed origin via GetGeometry()->GetOrigin(): ");
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetOrigin(), origin), "Testing correctness of changed origin via GetTimeSlicedGeometry()->GetOrigin(): ");
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(), origin), "Testing correctness of changed origin via GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(): ");
//-----------------
// testing spacing information and methods
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing), "Testing correct spacing from Geometry3D!");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetSpacing(), spacing), "Testing correctspacing from TimeSlicedGeometry!");
mitk::FillVector3D(spacing, 7.0, 0.92, 1.83);
imgMem->SetSpacing(spacing);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing), "Testing correctness of changed spacing via GetGeometry()->GetSpacing(): ");
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetSpacing(), spacing), "Testing correctness of changed spacing via GetTimeSlicedGeometry()->GetSpacing(): ");
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(), spacing), "Testing correctness of changed spacing via GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(): ");
mitk::Image::Pointer vecImg = mitk::Image::New();
vecImg->Initialize( imgMem->GetPixelType(), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/ );
vecImg->SetImportChannel(imgMem->GetData(), 0, mitk::Image::CopyMemory );
vecImg->SetImportChannel(imgMem->GetData(), 1, mitk::Image::CopyMemory );
MITK_TEST_CONDITION_REQUIRED(vecImg->GetChannelData(0)->GetData() != NULL && vecImg->GetChannelData(1)->GetData() != NULL, "Testing set and return of channel data!");
MITK_TEST_CONDITION_REQUIRED( vecImg->IsValidSlice(0,0,1) , "");
MITK_TEST_OUTPUT(<< " Testing whether CopyMemory worked");
MITK_TEST_CONDITION_REQUIRED(imgMem->GetData() != vecImg->GetData(), "");
MITK_TEST_OUTPUT(<< " Testing destruction after SetImportChannel");
vecImg = NULL;
MITK_TEST_CONDITION_REQUIRED(vecImg.IsNull() , "testing destruction!");
//-----------------
MITK_TEST_OUTPUT(<< "Testing initialization via vtkImageData");
MITK_TEST_OUTPUT(<< " Setting up vtkImageData");
vtkImageData* vtkimage = vtkImageData::New();
vtkimage->Initialize();
vtkimage->SetDimensions( 2, 3, 4);
double vtkorigin[] = {-350,-358.203, -1363.5};
vtkimage->SetOrigin(vtkorigin);
mitk::Point3D vtkoriginAsMitkPoint;
mitk::vtk2itk(vtkorigin, vtkoriginAsMitkPoint);
double vtkspacing[] = {1.367, 1.367, 2};
vtkimage->SetSpacing(vtkspacing);
vtkimage->SetScalarType( VTK_SHORT );
vtkimage->AllocateScalars();
std::cout<<"[PASSED]"<<std::endl;
MITK_TEST_OUTPUT(<< " Testing mitk::Image::Initialize(vtkImageData*, ...)");
mitk::Image::Pointer mitkByVtkImage = mitk::Image::New();
mitkByVtkImage ->Initialize(vtkimage);
MITK_TEST_CONDITION_REQUIRED(mitkByVtkImage->IsInitialized(), "");
vtkimage->Delete();
MITK_TEST_OUTPUT(<< " Testing whether spacing has been correctly initialized from vtkImageData");
mitk::Vector3D spacing2 = mitkByVtkImage->GetGeometry()->GetSpacing();
mitk::Vector3D vtkspacingAsMitkVector;
mitk::vtk2itk(vtkspacing, vtkspacingAsMitkVector);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(spacing2,vtkspacingAsMitkVector), "");
MITK_TEST_OUTPUT(<< " Testing whether GetSlicedGeometry(0)->GetOrigin() has been correctly initialized from vtkImageData");
mitk::Point3D origin2 = mitkByVtkImage->GetSlicedGeometry(0)->GetOrigin();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
MITK_TEST_OUTPUT(<< " Testing whether GetGeometry()->GetOrigin() has been correctly initialized from vtkImageData");
origin2 = mitkByVtkImage->GetGeometry()->GetOrigin();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
MITK_TEST_OUTPUT(<< " Testing whether GetTimeSlicedGeometry()->GetOrigin() has been correctly initialized from vtkImageData");
origin2 = mitkByVtkImage->GetTimeSlicedGeometry()->GetOrigin();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
// TODO test the following initializers on channel-incorporation
// void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, unsigned int *dimensions, unsigned int channels)
// void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
// void mitk::Image::Initialize(const mitk::Image* image)
// void mitk::Image::Initialize(const mitkIpPicDescriptor* pic, int channels, int tDim, int sDim)
//mitk::Image::Pointer vecImg = mitk::Image::New();
//vecImg->Initialize(PixelType(typeid(float), 6, itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
//vecImg->Initialize(PixelType(typeid(itk::Vector<float,6>)), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
// testing access by index coordinates and by world coordinates
MITK_TEST_CONDITION_REQUIRED(argc == 2, "Check if test image is accessible!");
const std::string filename = std::string(argv[1]);
mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
try
{
imageReader->SetFileName(filename);
imageReader->Update();
}
catch(...) {
MITK_TEST_FAILED_MSG(<< "Could not read file for testing: " << filename);
return 0;
}
mitk::Image::Pointer image = imageReader->GetOutput();
// generate a random point in world coordinates
mitk::Point3D xMax, yMax, zMax, xMaxIndex, yMaxIndex, zMaxIndex;
xMaxIndex.Fill(0.0f);
yMaxIndex.Fill(0.0f);
zMaxIndex.Fill(0.0f);
xMaxIndex[0] = image->GetLargestPossibleRegion().GetSize()[0];
yMaxIndex[1] = image->GetLargestPossibleRegion().GetSize()[1];
zMaxIndex[2] = image->GetLargestPossibleRegion().GetSize()[2];
image->GetGeometry()->IndexToWorld(xMaxIndex, xMax);
image->GetGeometry()->IndexToWorld(yMaxIndex, yMax);
image->GetGeometry()->IndexToWorld(zMaxIndex, zMax);
MITK_INFO << "Origin " << image->GetGeometry()->GetOrigin()[0] << " "<< image->GetGeometry()->GetOrigin()[1] << " "<< image->GetGeometry()->GetOrigin()[2] << "";
MITK_INFO << "MaxExtend " << xMax[0] << " "<< yMax[1] << " "<< zMax[2] << "";
mitk::Point3D point;
itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
randomGenerator->Initialize( std::rand() ); // initialize with random value, to get sensible random points for the image
point[0] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[0], xMax[0]);
point[1] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[1], yMax[1]);
point[2] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[2], zMax[2]);
MITK_INFO << "RandomPoint " << point[0] << " "<< point[1] << " "<< point[2] << "";
// test values and max/min
mitk::ScalarType imageMin = image->GetStatistics()->GetScalarValueMin();
mitk::ScalarType imageMax = image->GetStatistics()->GetScalarValueMax();
mitk::ScalarType value = image->GetPixelValueByWorldCoordinate(point);
MITK_INFO << imageMin << " "<< imageMax << " "<< value << "";
MITK_TEST_CONDITION( (value >= imageMin && value <= imageMax), "Value returned is between max/min");
// test accessing PixelValue with coordinate leading to a negative index
const mitk::Point3D geom_origin = image->GetGeometry()->GetOrigin();
const mitk::Point3D geom_center = image->GetGeometry()->GetCenter();
const unsigned int timestep = 0;
// shift position from origin outside of the image ( in the opposite direction to [center-origin] vector which points in the inside)
mitk::Point3D position = geom_origin + (geom_origin - geom_center);
MITK_TEST_CONDITION_REQUIRED( image->GetPixelValueByWorldCoordinate(position, timestep) == 0, "Test access to the outside of the image")
// testing the clone method of mitk::Image
mitk::Image::Pointer cloneImage = image->Clone();
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension() == image->GetDimension(), "Clone (testing dimension)");
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetPixelType() == image->GetPixelType(), "Clone (testing pixel type)");
// After cloning an image the geometry of both images should be equal too
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetGeometry()->GetOrigin() == image->GetGeometry()->GetOrigin(), "Clone (testing origin)");
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetGeometry()->GetSpacing() == image->GetGeometry()->GetSpacing(), "Clone (testing spacing)");
MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(cloneImage->GetGeometry()->GetIndexToWorldTransform()->GetMatrix(), image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix()),
"Clone (testing transformation matrix)");
MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(cloneImage->GetTimeSlicedGeometry()->GetGeometry3D(cloneImage->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix(),
cloneImage->GetTimeSlicedGeometry()->GetGeometry3D(image->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix()), "Clone(testing time sliced geometry)");
for (unsigned int i = 0u; i < cloneImage->GetDimension(); ++i)
{
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension(i) == image->GetDimension(i), "Clone (testing dimension " << i << ")");
}
//access via itk
if(image->GetDimension()> 3) // CastToItk only works with 3d images so we need to check for 4d images
{
mitk::ImageTimeSelector::Pointer selector = mitk::ImageTimeSelector::New();
selector->SetTimeNr(0);
selector->SetInput(image);
selector->Update();
image = selector->GetOutput();
}
if(image->GetDimension()==3)
{
typedef itk::Image<float,3> ItkFloatImage3D;
ItkFloatImage3D::Pointer itkimage;
mitk::CastToItkImage(image, itkimage);
MITK_TEST_CONDITION_REQUIRED(itkimage.IsNotNull(), "Test conversion to itk::Image!");
mitk::Point3D itkPhysicalPoint;
image->GetGeometry()->WorldToItkPhysicalPoint(point, itkPhysicalPoint);
MITK_INFO << "ITKPoint " << itkPhysicalPoint[0] << " "<< itkPhysicalPoint[1] << " "<< itkPhysicalPoint[2] << "";
mitk::Point3D backTransformedPoint;
image->GetGeometry()->ItkPhysicalPointToWorld(itkPhysicalPoint, backTransformedPoint);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(point,backTransformedPoint), "Testing world->itk-physical->world consistency");
itk::Index<3> idx;
bool status = itkimage->TransformPhysicalPointToIndex(itkPhysicalPoint, idx);
MITK_INFO << "ITK Index " << idx[0] << " "<< idx[1] << " "<< idx[2] << "";
if(status)
{
float valByItk = itkimage->GetPixel(idx);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(valByItk, value), "Compare value of pixel returned by mitk in comparison to itk");
}
else
{
MITK_WARN<< "Index is out buffered region!";
}
}
else
{
MITK_INFO << "Image does not contain three dimensions, some test cases are skipped!";
}
// clone generated 3D image with one slice in z direction (cf. bug 11058)
unsigned int* threeDdim = new unsigned int[3];
threeDdim[0] = 100;
threeDdim[1] = 200;
threeDdim[2] = 1;
mitk::Image::Pointer threeDImage = mitk::Image::New();
threeDImage->Initialize(mitk::MakeScalarPixelType<float>(), 3, threeDdim);
mitk::Image::Pointer cloneThreeDImage = threeDImage->Clone();
// check that the clone image has the same dimensionality as the source image
MITK_TEST_CONDITION_REQUIRED( cloneThreeDImage->GetDimension() == 3, "Testing if the clone image initializes with 3D!");
MITK_TEST_CONDITION_REQUIRED( ImageVtkDataReferenceCheck(argv[1]), "Checking reference count of Image after using GetVtkImageData()");
MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkImageVtkMapper2DColorTest.cpp b/Core/Code/Testing/mitkImageVtkMapper2DColorTest.cpp
index 47cbb6e9e0..50a793ebb8 100644
--- a/Core/Code/Testing/mitkImageVtkMapper2DColorTest.cpp
+++ b/Core/Code/Testing/mitkImageVtkMapper2DColorTest.cpp
@@ -1,74 +1,53 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include "mitkTestingMacros.h"
#include "mitkRenderingTestHelper.h"
//VTK
#include <vtkRegressionTestImage.h>
int mitkImageVtkMapper2DColorTest(int argc, char* argv[])
{
- // load all arguments into a datastorage, take last argument as reference rendering
- // setup a renderwindow of fixed size X*Y
- // render the datastorage
- // compare rendering to reference image
- MITK_TEST_BEGIN("mitkImageVtkMapper2DTest")
-
- // enough parameters?
- if ( argc < 2 )
- {
- MITK_TEST_OUTPUT( << "Usage: " << std::string(*argv) << " [file1 file2 ...] outputfile" )
- MITK_TEST_OUTPUT( << "Will render a central axial slice of all given files into outputfile" )
- exit( EXIT_SUCCESS );
- }
-
- mitkRenderingTestHelper renderingHelper(640, 480, argc, argv);
- //Set the opacity for all images
- renderingHelper.SetImageProperty("color", mitk::ColorProperty::New(0.0f, 0.0f, 255.0f));
- //for now this test renders in sagittal view direction
- renderingHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal);
- renderingHelper.Render();
-
- //use this to generate a reference screenshot or save the file:
- bool generateReferenceScreenshot = false;
- if(generateReferenceScreenshot)
- {
- renderingHelper.SaveAsPNG("/home/kilgus/Pictures/RenderingTestData/output.png");
- }
-
- //### Usage of vtkRegressionTestImage:
- //vtkRegressionTestImage( vtkRenderWindow )
- //Set a vtkRenderWindow containing the desired scene.
- //vtkRegressionTestImage automatically searches in argc and argv[]
- //for a path a valid image with -V. If the test failed with the
- //first image (foo.png) check if there are images of the form
- //foo_N.png (where N=1,2,3...) and compare against them.
- renderingHelper.PrepareRender();
- int retVal = vtkRegressionTestImage( renderingHelper.GetVtkRenderWindow() );
-
- //retVal meanings: (see VTK/Rendering/vtkTesting.h)
- //0 = test failed
- //1 = test passed
- //2 = test not run
- //3 = something with vtkInteraction
- MITK_TEST_CONDITION( retVal == 1, "VTK test result positive" );
-
- MITK_TEST_END();
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkImageVtkMapper2DTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+ //Set the opacity for all images
+ renderingHelper.SetImageProperty("color", mitk::ColorProperty::New(0.0f, 0.0f, 255.0f));
+ //for now this test renders in sagittal view direction
+ renderingHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal);
+
+ //####################
+ //Use this to generate a reference screenshot or save the file.
+ //(Only in your local version of the test!)
+ if(false)
+ {
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/RenderingTestData/output.png");
+ }
+ //####################
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkImageVtkMapper2DLevelWindowTest.cpp b/Core/Code/Testing/mitkImageVtkMapper2DLevelWindowTest.cpp
index da113a3356..d763a4b1fe 100644
--- a/Core/Code/Testing/mitkImageVtkMapper2DLevelWindowTest.cpp
+++ b/Core/Code/Testing/mitkImageVtkMapper2DLevelWindowTest.cpp
@@ -1,81 +1,58 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include "mitkTestingMacros.h"
#include "mitkRenderingTestHelper.h"
#include <mitkLevelWindowProperty.h>
#include <mitkLevelWindowPreset.h>
//VTK
#include <vtkRegressionTestImage.h>
int mitkImageVtkMapper2DLevelWindowTest(int argc, char* argv[])
{
- // load all arguments into a datastorage, take last argument as reference rendering
- // setup a renderwindow of fixed size X*Y
- // render the datastorage
- // compare rendering to reference image
- MITK_TEST_BEGIN("mitkImageVtkMapper2DTest")
-
- // enough parameters?
- if ( argc < 2 )
- {
- MITK_TEST_OUTPUT( << "Usage: " << std::string(*argv) << " [file1 file2 ...] outputfile" )
- MITK_TEST_OUTPUT( << "Will render a central axial slice of all given files into outputfile" )
- exit( EXIT_SUCCESS );
- }
-
- mitkRenderingTestHelper renderingHelper(640, 480, argc, argv);
- //chose a level window: here we randomly chosen the blood preset.
- mitk::LevelWindowPreset* levelWindowPreset = mitk::LevelWindowPreset::New();
- bool loadedPreset = levelWindowPreset->LoadPreset();
- MITK_TEST_CONDITION_REQUIRED(loadedPreset == true, "Testing if level window preset could be loaded");
- double level = levelWindowPreset->getLevel("Blood");
- double window = levelWindowPreset->getWindow("Blood");
- //apply level window to all images
- renderingHelper.SetImageProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(level, window)) );
- //for now this test renders Sagittal
- renderingHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal);
- renderingHelper.Render();
-
- //use this to generate a reference screenshot or save the file:
- bool generateReferenceScreenshot = false;
- if(generateReferenceScreenshot)
- {
- renderingHelper.SaveAsPNG("/home/kilgus/Pictures/RenderingTestData/output.png");
- }
-
- //### Usage of vtkRegressionTestImage:
- //vtkRegressionTestImage( vtkRenderWindow )
- //Set a vtkRenderWindow containing the desired scene.
- //vtkRegressionTestImage automatically searches in argc and argv[]
- //for a path a valid image with -V. If the test failed with the
- //first image (foo.png) check if there are images of the form
- //foo_N.png (where N=1,2,3...) and compare against them.
- renderingHelper.PrepareRender();
- int retVal = vtkRegressionTestImage( renderingHelper.GetVtkRenderWindow() );
-
- //retVal meanings: (see VTK/Rendering/vtkTesting.h)
- //0 = test failed
- //1 = test passed
- //2 = test not run
- //3 = something with vtkInteraction
- MITK_TEST_CONDITION( retVal == 1, "VTK test result positive" );
-
- MITK_TEST_END();
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkImageVtkMapper2DTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+ //chose a level window: here we randomly chosen the blood preset.
+ mitk::LevelWindowPreset* levelWindowPreset = mitk::LevelWindowPreset::New();
+ bool loadedPreset = levelWindowPreset->LoadPreset();
+ MITK_TEST_CONDITION_REQUIRED(loadedPreset == true, "Testing if level window preset could be loaded");
+ double level = levelWindowPreset->getLevel("Blood");
+ double window = levelWindowPreset->getWindow("Blood");
+ //apply level window to all images
+ renderingHelper.SetImageProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(level, window)) );
+ //for now this test renders Sagittal
+ renderingHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal);
+
+ //use this to generate a reference screenshot or save the file:
+ bool generateReferenceScreenshot = false;
+ if(generateReferenceScreenshot)
+ {
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/RenderingTestData/output.png");
+ }
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkImageVtkMapper2DOpacityTest.cpp b/Core/Code/Testing/mitkImageVtkMapper2DOpacityTest.cpp
index 1cafc6de51..b8e2579a4d 100644
--- a/Core/Code/Testing/mitkImageVtkMapper2DOpacityTest.cpp
+++ b/Core/Code/Testing/mitkImageVtkMapper2DOpacityTest.cpp
@@ -1,74 +1,51 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include "mitkTestingMacros.h"
#include "mitkRenderingTestHelper.h"
//VTK
#include <vtkRegressionTestImage.h>
int mitkImageVtkMapper2DOpacityTest(int argc, char* argv[])
{
- // load all arguments into a datastorage, take last argument as reference rendering
- // setup a renderwindow of fixed size X*Y
- // render the datastorage
- // compare rendering to reference image
- MITK_TEST_BEGIN("mitkImageVtkMapper2DTest")
-
- // enough parameters?
- if ( argc < 2 )
- {
- MITK_TEST_OUTPUT( << "Usage: " << std::string(*argv) << " [file1 file2 ...] outputfile" )
- MITK_TEST_OUTPUT( << "Will render a central axial slice of all given files into outputfile" )
- exit( EXIT_SUCCESS );
- }
-
- mitkRenderingTestHelper renderingHelper(640, 480, argc, argv);
- //Set the opacity for all images
- renderingHelper.SetImageProperty("opacity", mitk::FloatProperty::New(0.5f));
- //for now this test renders in coronal view direction
- renderingHelper.SetViewDirection(mitk::SliceNavigationController::Frontal);
- renderingHelper.Render();
-
- //use this to generate a reference screenshot or save the file:
- bool generateReferenceScreenshot = false;
- if(generateReferenceScreenshot)
- {
- renderingHelper.SaveAsPNG("/home/kilgus/Pictures/RenderingTestData/output.png");
- }
-
- //### Usage of vtkRegressionTestImage:
- //vtkRegressionTestImage( vtkRenderWindow )
- //Set a vtkRenderWindow containing the desired scene.
- //vtkRegressionTestImage automatically searches in argc and argv[]
- //for a path a valid image with -V. If the test failed with the
- //first image (foo.png) check if there are images of the form
- //foo_N.png (where N=1,2,3...) and compare against them.
- renderingHelper.PrepareRender();
- int retVal = vtkRegressionTestImage( renderingHelper.GetVtkRenderWindow() );
-
- //retVal meanings: (see VTK/Rendering/vtkTesting.h)
- //0 = test failed
- //1 = test passed
- //2 = test not run
- //3 = something with vtkInteraction
- MITK_TEST_CONDITION( retVal == 1, "VTK test result positive" );
-
- MITK_TEST_END();
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkImageVtkMapper2DTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+ //Set the opacity for all images
+ renderingHelper.SetImageProperty("opacity", mitk::FloatProperty::New(0.5f));
+ //for now this test renders in coronal view direction
+ renderingHelper.SetViewDirection(mitk::SliceNavigationController::Frontal);
+
+ //use this to generate a reference screenshot or save the file:
+ bool generateReferenceScreenshot = false;
+ if(generateReferenceScreenshot)
+ {
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/RenderingTestData/output.png");
+ }
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp b/Core/Code/Testing/mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp
new file mode 100644
index 0000000000..66e91183bf
--- /dev/null
+++ b/Core/Code/Testing/mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp
@@ -0,0 +1,85 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//MITK
+#include "mitkTestingMacros.h"
+#include "mitkRenderingTestHelper.h"
+#include <mitkNodePredicateDataType.h>
+#include "mitkIOUtil.h"
+#include "mitkDataNode.h"
+
+//VTK
+#include <vtkRegressionTestImage.h>
+#include <mitkVtkResliceInterpolationProperty.h>
+
+
+int mitkImageVtkMapper2DResliceInterpolationPropertyTest(int argc, char* argv[])
+{
+ //load all arguments into a datastorage, take last argument as reference
+ //setup a renderwindow of fixed size X*Y
+ //render the datastorage
+ //compare rendering to reference image
+ //note: this test is supposed to test the reslice interpolation modes not the swiveling itself
+ MITK_TEST_BEGIN("mitkImageVtkMapper2DResliceInterpolationPropertyTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+
+ //get resliceInterpolation from comandline arg
+ int resliceInterpolation = atoi(argv[argc-4]);
+
+ //Set interpolation mode for rendering
+ renderingHelper.SetImageProperty("reslice interpolation", mitk::VtkResliceInterpolationProperty::New( resliceInterpolation ));
+
+ /*+++rotate plane+++*/
+ //center point for rotation
+ mitk::Point3D centerPoint;
+ centerPoint.Fill(0.0f);
+ //vector for rotating the slice
+ mitk::Vector3D rotationVector;
+ rotationVector.SetElement(0, 0.2);
+ rotationVector.SetElement(1, 0.3);
+ rotationVector.SetElement(2, 0.5);
+ //sets a swivel direction for the image
+
+ //new version of setting the center point:
+ mitk::Image::Pointer image = static_cast<mitk::Image*>(renderingHelper.GetDataStorage()->GetNode(mitk::NodePredicateDataType::New("Image"))->GetData());
+
+ //get the center point of the image
+ centerPoint = image->GetGeometry()->GetCenter();
+
+ //rotate the image arround its own center
+ renderingHelper.ReorientSlices(centerPoint, rotationVector);
+
+
+ //use this to generate a reference screenshot or save the file:
+ bool generateReferenceScreenshot = false;
+ if(generateReferenceScreenshot)
+ {
+ renderingHelper.Render();
+ renderingHelper.SaveReferenceScreenShot("C:\\Users\\schroedt\\Pictures\\RenderingTestData\\Pic3dRefLinear.png");
+ }
+
+ //threshold for CompareRenderWindowAgainstReference
+ double threshold = 0.35;//difference between interpolation modes is very small
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv, threshold) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+
+
+
+ MITK_TEST_END();
+}
diff --git a/Core/Code/Testing/mitkImageVtkMapper2DSwivelTest.cpp b/Core/Code/Testing/mitkImageVtkMapper2DSwivelTest.cpp
index 58b356a3f6..1442ff9f40 100644
--- a/Core/Code/Testing/mitkImageVtkMapper2DSwivelTest.cpp
+++ b/Core/Code/Testing/mitkImageVtkMapper2DSwivelTest.cpp
@@ -1,89 +1,66 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include "mitkTestingMacros.h"
#include "mitkRenderingTestHelper.h"
#include <mitkNodePredicateDataType.h>
//VTK
#include <vtkRegressionTestImage.h>
int mitkImageVtkMapper2DSwivelTest(int argc, char* argv[])
{
- //load all arguments into a datastorage, take last argument as reference
- //setup a renderwindow of fixed size X*Y
- //render the datastorage
- //compare rendering to reference image
- MITK_TEST_BEGIN("mitkImageVtkMapper2DSwivelTest")
-
- // enough parameters?
- if ( argc < 2 )
- {
- MITK_TEST_OUTPUT( << "Usage: " << std::string(*argv) << " [file1 file2 ...] outputfile" )
- MITK_TEST_OUTPUT( << "Will render a central axial slice of all given files into outputfile" )
- exit( EXIT_SUCCESS );
- }
-
- mitkRenderingTestHelper renderingHelper(640, 480, argc, argv);
- //center point for rotation
- mitk::Point3D centerPoint;
- centerPoint.Fill(0.0f);
- //vector for rotating the slice
- mitk::Vector3D rotationVector;
- rotationVector.SetElement(0, 0.2);
- rotationVector.SetElement(1, 0.3);
- rotationVector.SetElement(2, 0.5);
- //sets a swivel direction for the image
-
- //new version of setting the center point:
- mitk::Image::Pointer image = static_cast<mitk::Image*>(renderingHelper.GetDataStorage()->GetNode(mitk::NodePredicateDataType::New("Image"))->GetData());
-
- //get the center point of the image
- centerPoint = image->GetGeometry()->GetCenter();
-
- //rotate the image arround its own center
- renderingHelper.ReorientSlices(centerPoint, rotationVector);
- renderingHelper.Render();
-
- //use this to generate a reference screenshot or save the file:
- bool generateReferenceScreenshot = false;
- if(generateReferenceScreenshot)
- {
- renderingHelper.SaveAsPNG("/media/hdd/thomasHdd/Pictures/RenderingTestData/pic3dSwivel640x480REF.png");
- }
-
- //### Usage of vtkRegressionTestImage:
- //vtkRegressionTestImage( vtkRenderWindow )
- //Set a vtkRenderWindow containing the desired scene.
- //vtkRegressionTestImage automatically searches in argc and argv[]
- //for a path a valid image with -V. If the test failed with the
- //first image (foo.png) check if there are images of the form
- //foo_N.png (where N=1,2,3...) and compare against them.
- renderingHelper.PrepareRender();
- int retVal = vtkRegressionTestImage( renderingHelper.GetVtkRenderWindow() );
-
- //retVal meanings: (see VTK/Rendering/vtkTesting.h)
- //0 = test failed
- //1 = test passed
- //2 = test not run
- //3 = something with vtkInteraction
- MITK_TEST_CONDITION( retVal == 1, "VTK test result positive" );
-
- MITK_TEST_END();
+ //load all arguments into a datastorage, take last argument as reference
+ //setup a renderwindow of fixed size X*Y
+ //render the datastorage
+ //compare rendering to reference image
+ MITK_TEST_BEGIN("mitkImageVtkMapper2DSwivelTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+ //center point for rotation
+ mitk::Point3D centerPoint;
+ centerPoint.Fill(0.0f);
+ //vector for rotating the slice
+ mitk::Vector3D rotationVector;
+ rotationVector.SetElement(0, 0.2);
+ rotationVector.SetElement(1, 0.3);
+ rotationVector.SetElement(2, 0.5);
+ //sets a swivel direction for the image
+
+ //new version of setting the center point:
+ mitk::Image::Pointer image = static_cast<mitk::Image*>(renderingHelper.GetDataStorage()->GetNode(mitk::NodePredicateDataType::New("Image"))->GetData());
+
+ //get the center point of the image
+ centerPoint = image->GetGeometry()->GetCenter();
+
+ //rotate the image arround its own center
+ renderingHelper.ReorientSlices(centerPoint, rotationVector);
+
+ //use this to generate a reference screenshot or save the file:
+ bool generateReferenceScreenshot = false;
+ if(generateReferenceScreenshot)
+ {
+ renderingHelper.SaveReferenceScreenShot("/media/hdd/thomasHdd/Pictures/RenderingTestData/pic3dSwivel640x480REF.png");
+ }
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkImageVtkMapper2DTest.cpp b/Core/Code/Testing/mitkImageVtkMapper2DTest.cpp
index 5d155c1d67..64d9f5f13d 100644
--- a/Core/Code/Testing/mitkImageVtkMapper2DTest.cpp
+++ b/Core/Code/Testing/mitkImageVtkMapper2DTest.cpp
@@ -1,70 +1,47 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include "mitkTestingMacros.h"
#include "mitkRenderingTestHelper.h"
//VTK
#include <vtkRegressionTestImage.h>
int mitkImageVtkMapper2DTest(int argc, char* argv[])
{
- // load all arguments into a datastorage, take last argument as reference rendering
- // setup a renderwindow of fixed size X*Y
- // render the datastorage
- // compare rendering to reference image
- MITK_TEST_BEGIN("mitkImageVtkMapper2DTest")
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkImageVtkMapper2DTest")
- // enough parameters?
- if ( argc < 2 )
- {
- MITK_TEST_OUTPUT( << "Usage: " << std::string(*argv) << " [file1 file2 ...] outputfile" )
- MITK_TEST_OUTPUT( << "Will render a central axial slice of all given files into outputfile" )
- exit( EXIT_SUCCESS );
- }
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
- mitkRenderingTestHelper renderingHelper(640, 480, argc, argv);
- renderingHelper.Render();
+ //use this to generate a reference screenshot or save the file:
+ bool generateReferenceScreenshot = false;
+ if(generateReferenceScreenshot)
+ {
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/RenderingTestData/output.png");
+ }
- //use this to generate a reference screenshot or save the file:
- bool generateReferenceScreenshot = false;
- if(generateReferenceScreenshot)
- {
- renderingHelper.SaveAsPNG("/home/kilgus/Pictures/RenderingTestData/output.png");
- }
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
- //### Usage of vtkRegressionTestImage:
- //vtkRegressionTestImage( vtkRenderWindow )
- //Set a vtkRenderWindow containing the desired scene.
- //vtkRegressionTestImage automatically searches in argc and argv[]
- //for a path a valid image with -V. If the test failed with the
- //first image (foo.png) check if there are images of the form
- //foo_N.png (where N=1,2,3...) and compare against them.
- renderingHelper.PrepareRender();
- int retVal = vtkRegressionTestImage( renderingHelper.GetVtkRenderWindow() );
-
- //retVal meanings: (see VTK/Rendering/vtkTesting.h)
- //0 = test failed
- //1 = test passed
- //2 = test not run
- //3 = something with vtkInteraction
- MITK_TEST_CONDITION( retVal == 1, "VTK test result positive" );
-
- MITK_TEST_END();
+ MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkImageVtkMapper2DTransferFunctionTest.cpp b/Core/Code/Testing/mitkImageVtkMapper2DTransferFunctionTest.cpp
index 6f5e720acb..fe957919d3 100644
--- a/Core/Code/Testing/mitkImageVtkMapper2DTransferFunctionTest.cpp
+++ b/Core/Code/Testing/mitkImageVtkMapper2DTransferFunctionTest.cpp
@@ -1,89 +1,63 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include "mitkTestingMacros.h"
#include "mitkRenderingTestHelper.h"
//VTK
#include <vtkRegressionTestImage.h>
#include <mitkTransferFunctionProperty.h>
#include <mitkTransferFunction.h>
#include <mitkRenderingModeProperty.h>
int mitkImageVtkMapper2DTransferFunctionTest(int argc, char* argv[])
{
- // load all arguments into a datastorage, take last argument as reference rendering
- // setup a renderwindow of fixed size X*Y
- // render the datastorage
- // compare rendering to reference image
- MITK_TEST_BEGIN("mitkImageVtkMapper2DTransferFunctionTest")
-
- // enough parameters?
- if ( argc < 2 )
- {
- MITK_TEST_OUTPUT( << "Usage: " << std::string(*argv) << " [file1 file2 ...] outputfile" )
- MITK_TEST_OUTPUT( << "Will render a central axial slice of all given files into outputfile" )
- exit( EXIT_SUCCESS );
- }
- mitkRenderingTestHelper renderingHelper(640, 480, argc, argv);
-
- //define an arbitrary colortransferfunction
- vtkSmartPointer<vtkColorTransferFunction> colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
- colorTransferFunction->SetColorSpaceToRGB();
- colorTransferFunction->AddRGBPoint(0.0, 1, 0, 0); //black = red
- colorTransferFunction->AddRGBPoint(127.5, 0, 1, 0); //grey = green
- colorTransferFunction->AddRGBPoint(255.0, 0, 0, 1); //white = blue
- mitk::TransferFunction::Pointer transferFucntion = mitk::TransferFunction::New();
- transferFucntion->SetColorTransferFunction( colorTransferFunction );
-
- //set the rendering mode to use the transfer function
- renderingHelper.SetImageProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR));
- //set the property for the image
- renderingHelper.SetImageProperty("Image Rendering.Transfer Function", mitk::TransferFunctionProperty::New(transferFucntion));
-
- renderingHelper.Render();
-
- //use this to generate a reference screenshot or save the file:
- bool generateReferenceScreenshot = false;
- if(generateReferenceScreenshot)
- {
- renderingHelper.SaveAsPNG("/home/kilgus/Pictures/RenderingTestData/output.png");
- }
-
- renderingHelper.PrepareRender();
- //### Usage of vtkRegressionTestImage:
- //vtkRegressionTestImage( vtkRenderWindow )
- //Set a vtkRenderWindow containing the desired scene.
- //vtkRegressionTestImage automatically searches in argc and argv[]
- //for a path a valid image with -V. If the test failed with the
- //first image (foo.png) check if there are images of the form
- //foo_N.png (where N=1,2,3...) and compare against them.
- //Default tolerance for rendering tests is 10 (set by VTK).
- //For this case, small artifacts in Windows occur and boundaries of the fonts,
- //thus we double the default tolerance threshold and set it to 20.
- int retVal = vtkTesting::Test(argc, argv, renderingHelper.GetVtkRenderWindow(), 20 );
-
- //retVal meanings: (see VTK/Rendering/vtkTesting.h)
- //0 = test failed
- //1 = test passed
- //2 = test not run
- //3 = something with vtkInteraction
- MITK_TEST_CONDITION( retVal == 1, "VTK test result positive" );
-
- MITK_TEST_END();
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkImageVtkMapper2DTransferFunctionTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+
+ //define an arbitrary colortransferfunction
+ vtkSmartPointer<vtkColorTransferFunction> colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
+ colorTransferFunction->SetColorSpaceToRGB();
+ colorTransferFunction->AddRGBPoint(0.0, 1, 0, 0); //black = red
+ colorTransferFunction->AddRGBPoint(127.5, 0, 1, 0); //grey = green
+ colorTransferFunction->AddRGBPoint(255.0, 0, 0, 1); //white = blue
+ mitk::TransferFunction::Pointer transferFucntion = mitk::TransferFunction::New();
+ transferFucntion->SetColorTransferFunction( colorTransferFunction );
+
+ //set the rendering mode to use the transfer function
+ renderingHelper.SetImageProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR));
+ //set the property for the image
+ renderingHelper.SetImageProperty("Image Rendering.Transfer Function", mitk::TransferFunctionProperty::New(transferFucntion));
+
+ //use this to generate a reference screenshot or save the file:
+ bool generateReferenceScreenshot = false;
+ if(generateReferenceScreenshot)
+ {
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/RenderingTestData/output.png");
+ }
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv, 20.0) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkImportItkImageTest.cpp b/Core/Code/Testing/mitkImportItkImageTest.cpp
new file mode 100644
index 0000000000..db55e5bdc7
--- /dev/null
+++ b/Core/Code/Testing/mitkImportItkImageTest.cpp
@@ -0,0 +1,240 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkTestingMacros.h"
+#include "mitkITKImageImport.h"
+
+#include "mitkImagePixelReadAccessor.h"
+
+#include <itkImageRegionConstIteratorWithIndex.h>
+#include <itkRandomImageSource.h>
+
+
+/**
+ * Create a test image with random pixel values. The image size is determined by the input parameter.
+ *
+ * @param size the number of voxels in each dimension
+ */
+template <typename TPixel, unsigned int VDimension>
+typename itk::Image<TPixel, VDimension>::Pointer CreateTestImageRandom( short int size )
+{
+ typedef typename itk::Image< TPixel, VDimension> ImageType;
+ typedef typename ImageType::Pointer ImagePointer;
+
+ itk::Size<VDimension> regionSize;
+ regionSize.Fill(size);
+
+ typename itk::RandomImageSource<ImageType>::Pointer randomImageSource = itk::RandomImageSource<ImageType>::New();
+ randomImageSource->SetNumberOfThreads(1); // to produce non-random results
+ randomImageSource->SetSize(regionSize);
+ randomImageSource->Update();
+
+ return randomImageSource->GetOutput();
+}
+
+/**
+ * Create a test image with a single pixel value. The image size is determined by the input parameter.
+ *
+ * @param value the pixel value the created image is filled with
+ * @param size the number of voxels in each dimension
+ */
+template <typename TPixel, unsigned int VDimension>
+typename itk::Image<TPixel, VDimension>::Pointer CreateTestImageFixedValue(size_t size, TPixel value)
+{
+ typedef typename itk::Image< TPixel, VDimension> ImageType;
+ typedef typename ImageType::Pointer ImagePointer;
+
+ typename ImageType::RegionType imageRegion;
+ typename ImageType::RegionType::SizeType regionSize;
+ regionSize.Fill(size);
+
+ typename ImageType::RegionType::IndexType regionIndex;
+ regionIndex.Fill(0);
+ imageRegion.SetSize( regionSize );
+ imageRegion.SetIndex( regionIndex );
+
+ typename ImageType::SpacingType imageSpacing;
+ imageSpacing.Fill(1.0f);
+
+ typename ImageType::PointType imageOrigin;
+ imageOrigin.Fill(0.0f);
+
+ ImagePointer itkImage = ImageType::New();
+
+ itkImage->SetRegions( imageRegion );
+ itkImage->SetOrigin( imageOrigin );
+ itkImage->SetSpacing( imageSpacing );
+ itkImage->Allocate();
+
+ itkImage->FillBuffer( value );
+
+ return itkImage;
+}
+
+
+
+
+/**
+ * Compares the meta information of both given images for equality.
+ */
+template <typename ImageType>
+bool Assert_ImageMetaData_AreEqual( typename ImageType::Pointer itkImage, mitk::Image::Pointer mitkImage )
+{
+ bool return_value = true;
+
+ typename ImageType::RegionType itkRegion = itkImage->GetLargestPossibleRegion();
+ typename ImageType::SizeType itkImageSize = itkRegion.GetSize();
+
+ // check dimension
+ for( unsigned int idx=0; idx < mitkImage->GetDimension(); idx++)
+ {
+ return_value &= ( itkImageSize[idx] == mitkImage->GetDimension(idx) );
+ }
+ MITK_TEST_CONDITION( return_value, " - Dimensions equal!")
+
+ // check pixel type
+ bool ptype_compare = ( mitkImage->GetPixelType() == mitk::MakePixelType<ImageType>() );
+ return_value &= ptype_compare;
+ MITK_TEST_CONDITION( ptype_compare, " - Pixel types equal!")
+
+ mitk::Geometry3D* imageGeometry = mitkImage->GetGeometry();
+ const mitk::Point3D origin = imageGeometry->GetOrigin();
+
+ bool origin_compare = true;
+ for( unsigned int idx=0; idx < 3; idx++)
+ {
+ origin_compare &= ( itkImage->GetOrigin()[idx] == origin[idx] );
+ }
+ return_value &= origin_compare;
+ MITK_TEST_CONDITION( origin_compare, " - Origin equals!")
+
+ return return_value;
+}
+
+/**
+ * Generates a random itk image and imports it to mitk image through ImportItkImage and compares the values
+ * voxel-wise afterwards
+ */
+template <typename TPixel, unsigned int VDimension>
+void Assert_ItkImageImportRandomValuesSucceded_ReturnsTrue()
+{
+ std::stringstream msg;
+ msg << "Current type: (Random Image, " << VDimension << "D):" << typeid(TPixel).name() << "\n";
+ std::cout << msg.str();
+
+ bool assert_value = true;
+
+ typedef typename itk::Image< TPixel, VDimension> ImageType;
+ typedef typename ImageType::Pointer ImagePointer;
+
+ ImagePointer itkImage = CreateTestImageRandom<TPixel, VDimension>(5);
+
+ mitk::Image::Pointer output_import = mitk::ImportItkImage( itkImage );
+
+ itk::ImageRegionConstIteratorWithIndex< ImageType > iter( itkImage, itkImage->GetLargestPossibleRegion() );
+ iter.GoToBegin();
+
+ mitk::ImagePixelReadAccessor< TPixel, VDimension > readAccessor( output_import );
+
+ bool difference = false;
+ while( !iter.IsAtEnd() )
+ {
+ TPixel ref = iter.Get();
+ TPixel val = readAccessor.GetPixelByIndex( iter.GetIndex() );
+
+ difference |= ( ref != val );
+ if( difference )
+ {
+ std::cout << iter.GetIndex() << ":" << ref << " ? " << val << "\n";
+ }
+ ++iter;
+ }
+
+ assert_value = Assert_ImageMetaData_AreEqual<ImageType>( itkImage, output_import );
+
+ MITK_TEST_CONDITION( assert_value && (!difference), "Pixel values are same in voxel-wise comparison." );
+
+}
+
+/**
+ * Generates an itk image with fixed pixel value and imports it to mitk image through ImportItkImage
+ * and compares the values voxel-wise afterwards
+ */
+template <typename TPixel, unsigned int VDimension>
+void Assert_ItkImageImportSucceded_ReturnsTrue()
+{
+ std::stringstream msg;
+ msg << "Current type: " << VDimension << "D):" << typeid(TPixel).name() << "\n";
+ std::cout << msg.str();
+
+ bool assert_value = true;
+
+ typedef typename itk::Image< TPixel, VDimension> ImageType;
+ typedef typename ImageType::Pointer ImagePointer;
+
+ ImagePointer itkImage = CreateTestImageFixedValue<TPixel, VDimension>(5, itk::NumericTraits<TPixel>::min());
+
+ mitk::Image::Pointer output_import = mitk::ImportItkImage( itkImage );
+
+ itk::ImageRegionConstIteratorWithIndex< ImageType > iter( itkImage, itkImage->GetLargestPossibleRegion() );
+ iter.GoToBegin();
+
+ mitk::ImagePixelReadAccessor< TPixel, VDimension > readAccessor( output_import );
+
+ bool difference = false;
+ while( !iter.IsAtEnd() )
+ {
+ TPixel ref = iter.Get();
+ TPixel val = readAccessor.GetPixelByIndex( iter.GetIndex() );
+
+ difference |= ( ref != val );
+ if( difference )
+ {
+ std::cout << iter.GetIndex() << ":" << ref << " ? " << val << "\n";
+ }
+
+ ++iter;
+ }
+
+ assert_value = Assert_ImageMetaData_AreEqual<ImageType>( itkImage, output_import );
+
+ MITK_TEST_CONDITION( assert_value && (!difference), "Pixel values are same in voxel-wise comparison." );
+
+}
+
+int mitkImportItkImageTest(int /*argc*/, char* /*argv*/[])
+{
+
+ MITK_TEST_BEGIN("mitkImportItkImageTest")
+
+ Assert_ItkImageImportSucceded_ReturnsTrue<short, 3>();// "Import succesfull on 3D short");
+ Assert_ItkImageImportSucceded_ReturnsTrue<float, 3>();// "Import succesfull on float");
+ Assert_ItkImageImportSucceded_ReturnsTrue<unsigned char, 3>();// "Import succesfull on uchar");
+ Assert_ItkImageImportSucceded_ReturnsTrue<int, 3>();// "Import succesfull on int");
+
+ Assert_ItkImageImportRandomValuesSucceded_ReturnsTrue<short, 3>();// "Import succesfull on 3D short");
+ Assert_ItkImageImportRandomValuesSucceded_ReturnsTrue<float, 3>();// "Import succesfull on float");
+ Assert_ItkImageImportRandomValuesSucceded_ReturnsTrue<unsigned char, 3>();// "Import succesfull on uchar");
+ Assert_ItkImageImportRandomValuesSucceded_ReturnsTrue<int, 3>();// "Import succesfull on int");
+
+ Assert_ItkImageImportRandomValuesSucceded_ReturnsTrue<short, 4>();// "Import succesfull on 3D short");
+ Assert_ItkImageImportRandomValuesSucceded_ReturnsTrue<float, 4>();// "Import succesfull on float");
+ Assert_ItkImageImportRandomValuesSucceded_ReturnsTrue<unsigned char, 4>();// "Import succesfull on uchar");
+ Assert_ItkImageImportRandomValuesSucceded_ReturnsTrue<int, 4>();// "Import succesfull on int");
+
+ MITK_TEST_END()
+
+}
diff --git a/Core/Code/Testing/mitkPixelTypeTest.cpp b/Core/Code/Testing/mitkPixelTypeTest.cpp
index bf8c410658..356cbb6bc7 100644
--- a/Core/Code/Testing/mitkPixelTypeTest.cpp
+++ b/Core/Code/Testing/mitkPixelTypeTest.cpp
@@ -1,108 +1,110 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTestingMacros.h"
#include "mitkPixelType.h"
#include <itkImage.h>
#include <mitkLogMacros.h>
struct MyObscurePixelType
{
typedef float ValueType;
static const size_t Length = 2;
float val1;
int val2;
};
//## Documentation
//## main testing method
int mitkPixelTypeTest(int /*argc*/, char* /*argv*/[])
{
MITK_TEST_BEGIN("PixelTypeTest");
MITK_INFO << "ptype = mitk::MakePixelType<int, int, 5>();";
MITK_INFO << "itkPtype = mitk::MakePixelType<ItkImageType>();\n with itk::Image<itk::FixedArray< int, 5>, 3> ItkImageType";
mitk::PixelType ptype = mitk::MakePixelType<int, int, 5>();
typedef itk::Image<itk::FixedArray< int, 5>, 3> ItkImageType;
mitk::PixelType itkPtype = mitk::MakePixelType<ItkImageType>();
- MITK_TEST_CONDITION_REQUIRED( ptype.GetTypeId() == typeid(int), "GetTypeId()");
+ MITK_TEST_CONDITION_REQUIRED( ptype.GetComponentType() == itk::ImageIOBase::INT, "GetComponentType()");
// MITK_TEST_CONDITION( ptype.GetPixelTypeId() == typeid(ItkImageType), "GetPixelTypeId()");
- MITK_INFO << ptype.GetItkTypeAsString();
+ MITK_INFO << ptype.GetPixelTypeAsString();
MITK_INFO << typeid(ItkImageType).name();
MITK_TEST_CONDITION_REQUIRED( ptype.GetBpe() == 8*sizeof(int)*5, "[ptype] GetBpe()");
MITK_TEST_CONDITION_REQUIRED( ptype.GetNumberOfComponents() == 5, "[ptype]GetNumberOfComponents()");
MITK_TEST_CONDITION_REQUIRED( ptype.GetBitsPerComponent() == 8*sizeof(int), "[ptype]GetBitsPerComponent()");
MITK_TEST_CONDITION_REQUIRED( itkPtype.GetBpe() == 8*sizeof(int)*5, "[itkPType] GetBpe()");
MITK_TEST_CONDITION_REQUIRED( itkPtype.GetNumberOfComponents() == 5, "[itkPType] GetNumberOfComponents()");
MITK_TEST_CONDITION_REQUIRED( itkPtype.GetBitsPerComponent() == 8*sizeof(int), "[itkPType] GetBitsPerComponent()");
// MITK_TEST_CONDITION_REQUIRED( itkPtype == ptype, "[itkPtype = ptype]");
- //MITK_TEST_CONDITION( ptype.GetItkTypeAsString().compare("unknown") == 0, "GetItkTypeAsString()");
+ //MITK_TEST_CONDITION( ptype.GetPixelTypeAsString().compare("unknown") == 0, "GetPixelTypeAsString()");
{
{
mitk::PixelType ptype2( ptype);
- MITK_TEST_CONDITION_REQUIRED( ptype2.GetTypeId() == typeid(int), "ptype2( ptype)- GetTypeId()");
- MITK_TEST_CONDITION( ptype2.GetPixelTypeId() == ptype.GetPixelTypeId(), "ptype2( ptype)-GetPixelTypeId(");
+ MITK_TEST_CONDITION_REQUIRED( ptype2.GetComponentType() == itk::ImageIOBase::INT, "ptype2( ptype)- GetComponentType()");
+ MITK_TEST_CONDITION( ptype2.GetPixelType() == ptype.GetPixelType(), "ptype2( ptype)-GetPixelType(");
+ MITK_TEST_CONDITION( ptype2.GetComponentType() == ptype.GetComponentType(), "ptype2( ptype)-GetComponentType(");
MITK_TEST_CONDITION_REQUIRED( ptype2.GetBpe() == 8*sizeof(int)*5, "ptype2( ptype)-GetBpe()");
MITK_TEST_CONDITION_REQUIRED( ptype2.GetNumberOfComponents() == 5, "ptype2( ptype)-GetNumberOfComponents()");
MITK_TEST_CONDITION_REQUIRED( ptype2.GetBitsPerComponent() == 8*sizeof(int), "ptype2( ptype)-GetBitsPerComponent()");
- // MITK_TEST_CONDITION_REQUIRED( ptype.GetItkTypeAsString().compare("unknown") == 0, "ptype2( ptype)-GetItkTypeAsString()");
+ // MITK_TEST_CONDITION_REQUIRED( ptype.GetPixelTypeAsString().compare("unknown") == 0, "ptype2( ptype)-GetPixelTypeAsString()");
}
{
mitk::PixelType ptype2 = ptype;
- MITK_TEST_CONDITION_REQUIRED( ptype2.GetTypeId() == typeid(int), "ptype2 = ptype- GetTypeId()");
- MITK_TEST_CONDITION( ptype2.GetPixelTypeId() == ptype.GetPixelTypeId(), "ptype2 = ptype- GetPixelTypeId(");
+ MITK_TEST_CONDITION_REQUIRED( ptype2.GetComponentType() == itk::ImageIOBase::INT, "ptype2 = ptype- GetComponentType()");
+ MITK_TEST_CONDITION( ptype2.GetPixelType() == ptype.GetPixelType(), "ptype2 = ptype- GetPixelType(");
+ MITK_TEST_CONDITION( ptype2.GetComponentType() == ptype.GetComponentType(), "ptype2( ptype)-GetComponentType(");
MITK_TEST_CONDITION_REQUIRED( ptype2.GetBpe() == 8*sizeof(int)*5, "ptype2 = ptype- GetBpe()");
MITK_TEST_CONDITION_REQUIRED( ptype2.GetNumberOfComponents() == 5, "ptype2 = ptype- GetNumberOfComponents()");
MITK_TEST_CONDITION_REQUIRED( ptype2.GetBitsPerComponent() == 8*sizeof(int), "ptype2 = ptype- GetBitsPerComponent()");
- // MITK_TEST_CONDITION_REQUIRED( ptype.GetItkTypeAsString().compare("unknown") == 0, "ptype2 = ptype- GetItkTypeAsString()");
+ // MITK_TEST_CONDITION_REQUIRED( ptype.GetPixelTypeAsString().compare("unknown") == 0, "ptype2 = ptype- GetPixelTypeAsString()");
}
{
mitk::PixelType ptype2 = ptype;
MITK_TEST_CONDITION_REQUIRED( ptype == ptype2, "operator ==");
//MITK_TEST_CONDITION_REQUIRED( ptype == typeid(int), "operator ==");
//mitk::PixelType ptype3 = mitk::MakePixelType<char, char ,5>;
//MITK_TEST_CONDITION_REQUIRED( ptype != ptype3, "operator !=");
//MITK_TEST_CONDITION_REQUIRED( *ptype3 != typeid(int), "operator !=");
}
}
// test instantiation
typedef itk::Image< MyObscurePixelType > MyObscureImageType;
mitk::PixelType obscurePixelType = mitk::MakePixelType< MyObscureImageType >();
- MITK_TEST_CONDITION( obscurePixelType.GetPixelTypeId() == itk::ImageIOBase::UNKNOWNPIXELTYPE, "PixelTypeId is 'UNKNOWN' ");
+ MITK_TEST_CONDITION( obscurePixelType.GetPixelType() == itk::ImageIOBase::UNKNOWNPIXELTYPE, "PixelTypeId is 'UNKNOWN' ");
MITK_TEST_CONDITION( obscurePixelType.GetNumberOfComponents() == MyObscurePixelType::Length, "Lenght was set correctly");
- MITK_TEST_CONDITION( obscurePixelType.GetTypeId() == typeid(MyObscurePixelType::ValueType), "ValueType corresponds." );
+ MITK_TEST_CONDITION( obscurePixelType.GetComponentType() == mitk::MapPixelComponentType<MyObscurePixelType::ValueType>::value, "ValueType corresponds." );
// test CastableTo
MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkPlaneGeometryTest.cpp b/Core/Code/Testing/mitkPlaneGeometryTest.cpp
index b72633d1c2..36f8d2130e 100644
--- a/Core/Code/Testing/mitkPlaneGeometryTest.cpp
+++ b/Core/Code/Testing/mitkPlaneGeometryTest.cpp
@@ -1,1008 +1,1023 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlaneGeometry.h"
#include "mitkRotationOperation.h"
#include "mitkInteractionConst.h"
#include "mitkLine.h"
#include "mitkTestingMacros.h"
#include <vnl/vnl_quaternion.h>
#include <vnl/vnl_quaternion.txx>
#include <fstream>
+#include <iomanip>
int mappingTests2D(const mitk::PlaneGeometry* planegeometry, const mitk::ScalarType& width, const mitk::ScalarType& height, const mitk::ScalarType& widthInMM, const mitk::ScalarType& heightInMM, const mitk::Point3D& origin, const mitk::Vector3D& right, const mitk::Vector3D& bottom)
{
std::cout << "Testing mapping Map(pt2d_mm(x=widthInMM/2.3,y=heightInMM/2.5), pt3d_mm) and compare with expected: ";
mitk::Point2D pt2d_mm;
mitk::Point3D pt3d_mm, expected_pt3d_mm;
pt2d_mm[0] = widthInMM/2.3; pt2d_mm[1] = heightInMM/2.5;
expected_pt3d_mm = origin+right*(pt2d_mm[0]/right.GetNorm())+bottom*(pt2d_mm[1]/bottom.GetNorm());
planegeometry->Map(pt2d_mm, pt3d_mm);
if(mitk::Equal(pt3d_mm, expected_pt3d_mm) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing mapping Map(pt3d_mm, pt2d_mm) and compare with expected: ";
mitk::Point2D testpt2d_mm;
planegeometry->Map(pt3d_mm, testpt2d_mm);
- if(mitk::Equal(pt2d_mm, testpt2d_mm, 2*mitk::eps) == false)
+ std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
+ std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
+ std::cout << std::setprecision(12) << "10*mitk::eps " << 10*mitk::eps << std::endl;
+ //This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
+ if(mitk::Equal(pt2d_mm, testpt2d_mm, 10*mitk::eps) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing IndexToWorld(pt2d_units, pt2d_mm) and compare with expected: ";
mitk::Point2D pt2d_units;
pt2d_units[0] = width/2.0; pt2d_units[1] = height/2.0;
pt2d_mm[0] = widthInMM/2.0; pt2d_mm[1] = heightInMM/2.0;
planegeometry->IndexToWorld(pt2d_units, testpt2d_mm);
- if(mitk::Equal(pt2d_mm, testpt2d_mm, 2*mitk::eps) == false)
+
+ std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
+ std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
+ std::cout << std::setprecision(12) << "10*mitk::eps " << 10*mitk::eps << std::endl;
+ //This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
+ if(mitk::Equal(pt2d_mm, testpt2d_mm, 10*mitk::eps) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing WorldToIndex(pt2d_mm, pt2d_units) and compare with expected: ";
mitk::Point2D testpt2d_units;
planegeometry->WorldToIndex(pt2d_mm, testpt2d_units);
- if(mitk::Equal(pt2d_units, testpt2d_units, 3*mitk::eps) == false)
+
+ std::cout << std::setprecision(12) << "Expected pt2d_units " << pt2d_units << std::endl;
+ std::cout << std::setprecision(12) << "Result testpt2d_units " << testpt2d_units << std::endl;
+ std::cout << std::setprecision(12) << "10*mitk::eps " << 10*mitk::eps << std::endl;
+ //This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
+ if(mitk::Equal(pt2d_units, testpt2d_units, 10*mitk::eps) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
return EXIT_SUCCESS;
}
int TestCase1210()
{
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, down, spacing;
mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
mitk::FillVector3D(right,
1.015625, 1.015625, 1.1999969482421875
);
mitk::FillVector3D(down,
1.4012984643248170709237295832899161312802619418765e-45, 0, 0
);
mitk::FillVector3D(spacing,
0, 1.4713633875410579244699160624544119378442750389703e-43, 9.2806360452222355258639080851310540729807238879469e-32
);
std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
planegeometry->InitializeStandardPlane(right, down, &spacing);
/*
std::cout << "Testing width, height and thickness (in units): ";
if((mitk::Equal(planegeometry->GetExtent(0),width)==false) ||
(mitk::Equal(planegeometry->GetExtent(1),height)==false) ||
(mitk::Equal(planegeometry->GetExtent(2),1)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm): ";
if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM)==false) ||
(mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM)==false) ||
(mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
*/
std::cout<<"[PASSED]"<<std::endl;
return EXIT_SUCCESS;
}
/**
* @brief This method tests method IntersectionPoint
*
* See also bug #7151. (ref 2 this test: iggy)
* This test was written due to incorrect calculation of the intersection point
* between a given line and plane. This only occured when the pointdistance of
* the line was less than 1.
* Test Behavour:
* ==============
* we have a given line and a given plane.
* we let the line intersect the plane.
* when testing several positions on the line the resulting intersection point must be the same
* we test a position where the distance between the correspoinding points is < 0 and another position where the distance is > 0.
*
*/
int TestIntersectionPoint()
{
//init plane with its parameter
mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
origin[0] = 0.0;
origin[1] = 2.0;
origin[2] = 0.0;
mitk::Vector3D normal;
normal[0] = 0.0;
normal[1] = 1.0;
normal[2] = 0.0;
myPlaneGeometry->InitializePlane(origin,normal);
//generate points and line for intersection testing
//point distance of given line > 1
mitk::Point3D pointP1;
pointP1[0] = 2.0;
pointP1[1] = 1.0;
pointP1[2] = 0.0;
mitk::Point3D pointP2;
pointP2[0] = 2.0;
pointP2[1] = 4.0;
pointP2[2] = 0.0;
mitk::Vector3D lineDirection;
lineDirection[0] = pointP2[0] - pointP1[0];
lineDirection[1] = pointP2[1] - pointP1[1];
lineDirection[2] = pointP2[2] - pointP1[2];
mitk::Line3D xingline( pointP1, lineDirection );
mitk::Point3D calcXingPoint;
myPlaneGeometry->IntersectionPoint(xingline, calcXingPoint);
//point distance of given line < 1
mitk::Point3D pointP3;
pointP3[0] = 2.0;
pointP3[1] = 2.2;
pointP3[2] = 0.0;
mitk::Point3D pointP4;
pointP4[0] = 2.0;
pointP4[1] = 1.7;
pointP4[2] = 0.0;
mitk::Vector3D lineDirection2;
lineDirection2[0] = pointP4[0] - pointP3[0];
lineDirection2[1] = pointP4[1] - pointP3[1];
lineDirection2[2] = pointP4[2] - pointP3[2];
mitk::Line3D xingline2( pointP3, lineDirection2 );
mitk::Point3D calcXingPoint2;
myPlaneGeometry->IntersectionPoint( xingline2, calcXingPoint2 );
//intersection points must be the same
if (calcXingPoint == calcXingPoint2) {
return EXIT_SUCCESS;
} else {
return EXIT_FAILURE;
}
}
/**
* @brief This method tests method ProjectPointOntoPlane.
*
* See also bug #3409.
*/
int TestProjectPointOntoPlane()
{
mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
//create normal
mitk::Vector3D normal;
normal[0] = 0.0;
normal[1] = 0.0;
normal[2] = 1.0;
//create origin
mitk::Point3D origin;
origin[0] = -27.582859;
origin[1] = 50;
origin[2] = 200.27742;
//initialize plane geometry
myPlaneGeometry->InitializePlane(origin,normal);
//output to descripe the test
std::cout << "Testing PlaneGeometry according to bug #3409" << std::endl;
std::cout << "Our normal is: " << normal << std::endl;
std::cout << "So ALL projected points should have exactly the same z-value!" << std::endl;
//create a number of points
mitk::Point3D myPoints[5];
myPoints[0][0] = -27.582859;
myPoints[0][1] = 50.00;
myPoints[0][2] = 200.27742;
myPoints[1][0] = -26.58662;
myPoints[1][1] = 50.00;
myPoints[1][2] = 200.19026;
myPoints[2][0] = -26.58662;
myPoints[2][1] = 50.00;
myPoints[2][2] = 200.33124;
myPoints[3][0] = 104.58662;
myPoints[3][1] = 452.12313;
myPoints[3][2] = 866.41236;
myPoints[4][0] = -207.58662;
myPoints[4][1] = 312.00;
myPoints[4][2] = -300.12346;
//project points onto plane
mitk::Point3D myProjectedPoints[5];
for ( unsigned int i = 0; i < 5; ++i )
{
myProjectedPoints[i] = myPlaneGeometry->ProjectPointOntoPlane( myPoints[i] );
}
//compare z-values with z-value of plane (should be equal)
bool allPointsOnPlane = true;
for ( unsigned int i = 0; i < 5; ++i )
{
if ( fabs(myProjectedPoints[i][2] - origin[2]) > mitk::sqrteps )
{
allPointsOnPlane = false;
}
}
if (!allPointsOnPlane)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
return EXIT_SUCCESS;
}
}
int mitkPlaneGeometryTest(int /*argc*/, char* /*argv*/[])
{
int result;
/*
// the following can be used to reproduce a bug in ITK matrix inversion
// which was found while investigating bug #1210.
result = TestCase1210();
if(result!=EXIT_SUCCESS)
return result;
*/
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
mitk::ScalarType width, height;
mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
width = 100; widthInMM = width;
height = 200; heightInMM = height;
thicknessInMM = 1.0;
mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
mitk::FillVector3D(right, widthInMM, 0, 0);
mitk::FillVector3D(bottom, 0, heightInMM, 0);
mitk::FillVector3D(normal, 0, 0, thicknessInMM);
std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
- planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector());
+ planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector());
std::cout << "Testing width, height and thickness (in units): ";
if((mitk::Equal(planegeometry->GetExtent(0),width)==false) ||
(mitk::Equal(planegeometry->GetExtent(1),height)==false) ||
(mitk::Equal(planegeometry->GetExtent(2),1)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm): ";
if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM)==false) ||
(mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM)==false) ||
(mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector(): ";
if((mitk::Equal(planegeometry->GetAxisVector(0), right)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing = {1.0, 1.0, 1.5}): "<<std::endl;
mitk::Vector3D spacing;
thicknessInMM = 1.5;
normal.Normalize(); normal *= thicknessInMM;
mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
- planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector(), &spacing);
+ planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
std::cout << "Testing width, height and thickness (in units): ";
if((mitk::Equal(planegeometry->GetExtent(0),width)==false) ||
(mitk::Equal(planegeometry->GetExtent(1),height)==false) ||
(mitk::Equal(planegeometry->GetExtent(2),1)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm): ";
if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM)==false) ||
(mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM)==false) ||
(mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector(): ";
if((mitk::Equal(planegeometry->GetAxisVector(0), right)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing SetExtentInMM(2, ...), querying by GetExtentInMM(2): ";
thicknessInMM = 3.5;
normal.Normalize(); normal *= thicknessInMM;
planegeometry->SetExtentInMM(2, thicknessInMM);
if(mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing SetExtentInMM(2, ...), querying by GetAxisVector(2) and comparing to normal: ";
if(mitk::Equal(planegeometry->GetAxisVector(2), normal)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing SetOrigin: ";
planegeometry->SetOrigin(origin);
if(mitk::Equal(planegeometry->GetOrigin(), origin)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() after SetOrigin: ";
if((mitk::Equal(planegeometry->GetAxisVector(0), right)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
if(result!=EXIT_SUCCESS)
return result;
std::cout << "Changing the IndexToWorldTransform to a rotated version by SetIndexToWorldTransform() (keep origin): "<<std::endl;
mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = planegeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
mitk::VnlVector axis(3);
mitk::FillVector3D(axis, 1.0, 1.0, 1.0); axis.normalize();
vnl_quaternion<mitk::ScalarType> rotation(axis, 0.223);
vnlmatrix = rotation.rotation_matrix_transpose()*vnlmatrix;
mitk::Matrix3D matrix;
matrix = vnlmatrix;
transform->SetMatrix(matrix);
transform->SetOffset(planegeometry->GetIndexToWorldTransform()->GetOffset());
- right.Set_vnl_vector( rotation.rotation_matrix_transpose()*right.Get_vnl_vector() );
- bottom.Set_vnl_vector(rotation.rotation_matrix_transpose()*bottom.Get_vnl_vector());
- normal.Set_vnl_vector(rotation.rotation_matrix_transpose()*normal.Get_vnl_vector());
+ right.SetVnlVector( rotation.rotation_matrix_transpose()*right.GetVnlVector() );
+ bottom.SetVnlVector(rotation.rotation_matrix_transpose()*bottom.GetVnlVector());
+ normal.SetVnlVector(rotation.rotation_matrix_transpose()*normal.GetVnlVector());
planegeometry->SetIndexToWorldTransform(transform);
//The origin changed,because m_Origin=m_IndexToWorldTransform->GetOffset()+GetAxisVector(2)*0.5
//and the AxisVector changes due to the rotation. In other words: the rotation was done around
//the corner of the box, not around the planes origin. Now change it to a rotation around
//the origin, simply by re-setting the origin to the original one:
planegeometry->SetOrigin(origin);
mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
std::cout << "Testing whether SetIndexToWorldTransform kept origin: ";
if(mitk::Equal(planegeometry->GetOrigin(), origin)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
MITK_TEST_OUTPUT( << "Testing consistancy of index and world coordinates. ");
mitk::Point2D point; point[0] = 4; point[1] = 3;
mitk::Point2D dummy;
planegeometry->WorldToIndex(point, dummy);
planegeometry->IndexToWorld(dummy, dummy);
MITK_TEST_CONDITION_REQUIRED(dummy == point, "");
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm) of rotated version: ";
if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM)==false) ||
(mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM)==false) ||
(mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() of rotated version: ";
if((mitk::Equal(planegeometry->GetAxisVector(0), right)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ";
if((mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(),planegeometry->GetExtentInMM(0))==false) ||
(mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(),planegeometry->GetExtentInMM(1))==false) ||
(mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(),planegeometry->GetExtentInMM(2))==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
if(result!=EXIT_SUCCESS)
return result;
std::cout << "Testing SetSizeInUnits() of rotated version: "<<std::endl;
width *= 2;
height *= 3;
planegeometry->SetSizeInUnits(width, height);
std::cout << "Testing width, height and thickness (in units): ";
if((mitk::Equal(planegeometry->GetExtent(0),width)==false) ||
(mitk::Equal(planegeometry->GetExtent(1),height)==false) ||
(mitk::Equal(planegeometry->GetExtent(2),1)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm) of version with changed size in units: ";
if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM) || !mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM) || !mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() of version with changed size in units: ";
if((mitk::Equal(planegeometry->GetAxisVector(0), right)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ";
if((mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(),planegeometry->GetExtentInMM(0))==false) ||
(mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(),planegeometry->GetExtentInMM(1))==false) ||
(mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(),planegeometry->GetExtentInMM(2))==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
if(result!=EXIT_SUCCESS)
return result;
std::cout << "Testing Clone(): ";
mitk::PlaneGeometry::Pointer clonedplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(planegeometry->Clone().GetPointer());
if((clonedplanegeometry.IsNull()) || (clonedplanegeometry->GetReferenceCount()!=1))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing origin of cloned version: ";
if(mitk::Equal(clonedplanegeometry->GetOrigin(), origin)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in units) of cloned version: ";
if((mitk::Equal(clonedplanegeometry->GetExtent(0),width)==false) ||
(mitk::Equal(clonedplanegeometry->GetExtent(1),height)==false) ||
(mitk::Equal(clonedplanegeometry->GetExtent(2),1)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm) of cloned version: ";
if(!mitk::Equal(clonedplanegeometry->GetExtentInMM(0), widthInMM) || !mitk::Equal(clonedplanegeometry->GetExtentInMM(1), heightInMM) || !mitk::Equal(clonedplanegeometry->GetExtentInMM(2), thicknessInMM))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() of cloned version: ";
if((mitk::Equal(clonedplanegeometry->GetAxisVector(0), right)==false) || (mitk::Equal(clonedplanegeometry->GetAxisVector(1), bottom)==false) || (mitk::Equal(clonedplanegeometry->GetAxisVector(2), normal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(clonedplanegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
if(result!=EXIT_SUCCESS)
return result;
// Clone, move, rotate and test for 'IsParallel' and 'IsOnPlane'
std::cout << "Testing Clone(): ";
mitk::PlaneGeometry::Pointer clonedplanegeometry2 = dynamic_cast<mitk::PlaneGeometry*>(planegeometry->Clone().GetPointer());
if((clonedplanegeometry2.IsNull()) || (clonedplanegeometry2->GetReferenceCount()!=1))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout << "Testing if cloned and original version are at the same place: ";
if(mitk::Equal(clonedplanegeometry2->IsOnPlane(planegeometry), true) ==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing if the origin is on the plane: ";
if(mitk::Equal(clonedplanegeometry2->IsOnPlane(origin), true)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
mitk::VnlVector newaxis(3);
mitk::FillVector3D(newaxis, 1.0, 1.0, 1.0); newaxis.normalize();
vnl_quaternion<mitk::ScalarType> rotation2(newaxis, 0.0);
mitk::Vector3D clonednormal = clonedplanegeometry2->GetNormal();
mitk::Point3D clonedorigin = clonedplanegeometry2->GetOrigin();
mitk::RotationOperation* planerot = new mitk::RotationOperation( mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector( 0 ), 180.0 );
clonedplanegeometry2->ExecuteOperation( planerot );
std::cout << "Testing whether the flipped plane is still the original plane: ";
if( mitk::Equal( clonedplanegeometry2->IsOnPlane(planegeometry), true )==false )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
clonedorigin += clonednormal;
clonedplanegeometry2->SetOrigin( clonedorigin );
std::cout << "Testing if the translated (cloned, flipped) plane is parallel to its origin plane: ";
if( mitk::Equal( clonedplanegeometry2->IsParallel(planegeometry), true )==false )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
delete planerot;
planerot = new mitk::RotationOperation( mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector( 0 ), 0.5 );
clonedplanegeometry2->ExecuteOperation( planerot );
std::cout << "Testing if a non-paralell plane gets recognized as not paralell [rotation +0.5 degree] : ";
if( mitk::Equal( clonedplanegeometry2->IsParallel(planegeometry), false )==false )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
delete planerot;
planerot = new mitk::RotationOperation( mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector( 0 ), -1.0 );
clonedplanegeometry2->ExecuteOperation( planerot );
std::cout << "Testing if a non-paralell plane gets recognized as not paralell [rotation -0.5 degree] : ";
if( mitk::Equal( clonedplanegeometry2->IsParallel(planegeometry), false )==false )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
delete planerot;
planerot = new mitk::RotationOperation( mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector( 0 ), 360.5 );
clonedplanegeometry2->ExecuteOperation( planerot );
std::cout << "Testing if a non-paralell plane gets recognized as not paralell [rotation 360 degree] : ";
if( mitk::Equal( clonedplanegeometry2->IsParallel(planegeometry), true )==false )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition = 0, frontside=true): " <<std::endl;
planegeometry->InitializeStandardPlane(clonedplanegeometry);
std::cout << "Testing origin of axially initialized version: ";
if(mitk::Equal(planegeometry->GetOrigin(), origin)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetCornerPoint(0) of axially initialized version: ";
if(mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in units) of axially initialized version (should be same as in mm due to unit spacing, except for thickness, which is always 1): ";
if(!mitk::Equal(planegeometry->GetExtent(0), width) || !mitk::Equal(planegeometry->GetExtent(1), height) || !mitk::Equal(planegeometry->GetExtent(2), 1))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm) of axially initialized version: ";
if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM) || !mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM) || !mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() of axially initialized version: ";
if((mitk::Equal(planegeometry->GetAxisVector(0), right)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), bottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), normal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
if(result!=EXIT_SUCCESS)
return result;
mitk::Vector3D newright, newbottom, newnormal;
mitk::ScalarType newthicknessInMM;
std::cout << "Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Frontal, zPosition = 0, frontside=true): " <<std::endl;
planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Frontal);
newright = right;
newbottom = normal; newbottom.Normalize(); newbottom *= thicknessInMM;
newthicknessInMM = heightInMM/height*1.0/*extent in normal direction is 1*/;
newnormal = -bottom; newnormal.Normalize(); newnormal *= newthicknessInMM;
std::cout << "Testing GetCornerPoint(0) of frontally initialized version: ";
if(mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
//ok, corner was fine, so we can dare to believe the origin is ok.
origin = planegeometry->GetOrigin();
std::cout << "Testing width, height and thickness (in units) of frontally initialized version: ";
if(!mitk::Equal(planegeometry->GetExtent(0), width) || !mitk::Equal(planegeometry->GetExtent(1), 1) || !mitk::Equal(planegeometry->GetExtent(2), 1))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm) of frontally initialized version: ";
if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM) || !mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM) || !mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() of frontally initialized version: ";
if((mitk::Equal(planegeometry->GetAxisVector(0), newright)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), newbottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), newnormal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(planegeometry, width, 1, widthInMM, thicknessInMM, origin, newright, newbottom);
if(result!=EXIT_SUCCESS)
return result;
std::cout << "Changing plane to in-plane unit spacing using SetSizeInUnits: " <<std::endl;
planegeometry->SetSizeInUnits(planegeometry->GetExtentInMM(0), planegeometry->GetExtentInMM(1));
std::cout << "Testing origin of unit spaced, frontally initialized version: ";
if(mitk::Equal(planegeometry->GetOrigin(), origin)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ";
if(!mitk::Equal(planegeometry->GetExtent(0), widthInMM) || !mitk::Equal(planegeometry->GetExtent(1), thicknessInMM) || !mitk::Equal(planegeometry->GetExtent(2), 1))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ";
if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM) || !mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM) || !mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() of unit spaced, frontally initialized version: ";
if((mitk::Equal(planegeometry->GetAxisVector(0), newright)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), newbottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), newnormal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
if(result!=EXIT_SUCCESS)
return result;
std::cout << "Changing plane to unit spacing also in normal direction using SetExtentInMM(2, 1.0): " <<std::endl;
planegeometry->SetExtentInMM(2, 1.0);
newnormal.Normalize();
std::cout << "Testing origin of unit spaced, frontally initialized version: ";
if(mitk::Equal(planegeometry->GetOrigin(), origin)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ";
if(!mitk::Equal(planegeometry->GetExtent(0), widthInMM) || !mitk::Equal(planegeometry->GetExtent(1), thicknessInMM) || !mitk::Equal(planegeometry->GetExtent(2), 1))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ";
if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM) || !mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM) || !mitk::Equal(planegeometry->GetExtentInMM(2), 1.0))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() of unit spaced, frontally initialized version: ";
if((mitk::Equal(planegeometry->GetAxisVector(0), newright)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), newbottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), newnormal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
if(result!=EXIT_SUCCESS)
return result;
std::cout << "Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Sagittal, zPosition = 0, frontside=true): " <<std::endl;
planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Sagittal);
newright = bottom;
newthicknessInMM = widthInMM/width*1.0/*extent in normal direction is 1*/;
newnormal = right; newnormal.Normalize(); newnormal *= newthicknessInMM;
std::cout << "Testing GetCornerPoint(0) of sagitally initialized version: ";
if(mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
//ok, corner was fine, so we can dare to believe the origin is ok.
origin = planegeometry->GetOrigin();
std::cout << "Testing width, height and thickness (in units) of sagitally initialized version: ";
if(!mitk::Equal(planegeometry->GetExtent(0), height) || !mitk::Equal(planegeometry->GetExtent(1), 1) || !mitk::Equal(planegeometry->GetExtent(2), 1))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm) of sagitally initialized version: ";
if(!mitk::Equal(planegeometry->GetExtentInMM(0), heightInMM) || !mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM) || !mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() of sagitally initialized version: ";
if((mitk::Equal(planegeometry->GetAxisVector(0), newright)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), newbottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), newnormal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(planegeometry, height, 1, heightInMM, thicknessInMM, origin, newright, newbottom);
if(result!=EXIT_SUCCESS)
return result;
//set origin back to the one of the axial slice:
origin = clonedplanegeometry->GetOrigin();
std::cout << "Testing backside initialization: InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition = 0, frontside=false, rotated=true): " <<std::endl;
planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Axial, 0, false, true);
mitk::Point3D backsideorigin;
backsideorigin=origin+clonedplanegeometry->GetAxisVector(1);//+clonedplanegeometry->GetAxisVector(2);
std::cout << "Testing origin of backsidedly, axially initialized version: ";
if(mitk::Equal(planegeometry->GetOrigin(), backsideorigin)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetCornerPoint(0) of sagitally initialized version: ";
mitk::Point3D backsidecornerpoint0;
backsidecornerpoint0 = cornerpoint0+clonedplanegeometry->GetAxisVector(1);//+clonedplanegeometry->GetAxisVector(2);
if(mitk::Equal(planegeometry->GetCornerPoint(0), backsidecornerpoint0)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in units) of backsidedly, axially initialized version (should be same as in mm due to unit spacing, except for thickness, which is always 1): ";
if(!mitk::Equal(planegeometry->GetExtent(0), width) || !mitk::Equal(planegeometry->GetExtent(1), height) || !mitk::Equal(planegeometry->GetExtent(2), 1))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ";
if(!mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM) || !mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM) || !mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector() of backsidedly, axially initialized version: ";
if((mitk::Equal(planegeometry->GetAxisVector(0), right)==false) || (mitk::Equal(planegeometry->GetAxisVector(1), -bottom)==false) || (mitk::Equal(planegeometry->GetAxisVector(2), -normal)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
result = mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, backsideorigin, right, -bottom);
if(result!=EXIT_SUCCESS)
return result;
// test method mitk::PlaneGeometry::ProjectPointOntoPlane()
// (see also bug #3409)
result = TestProjectPointOntoPlane();
if(result!=EXIT_SUCCESS)
return result;
// testing mitk::PlaneGeometry::IntersectionPoint()
std::cout << std::endl;
std::cout << "Testing IntersectionPoint using given plane and given line: ";
result = TestIntersectionPoint();
if (result != EXIT_SUCCESS) {
std::cout << "[FAILED]" << std::endl;
return result;
}
std::cout<<"[PASSED]"<<std::endl<<std::endl;
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}
diff --git a/Core/Code/Testing/mitkPlanePositionManagerTest.cpp b/Core/Code/Testing/mitkPlanePositionManagerTest.cpp
index 8e33299c28..30638faf26 100644
--- a/Core/Code/Testing/mitkPlanePositionManagerTest.cpp
+++ b/Core/Code/Testing/mitkPlanePositionManagerTest.cpp
@@ -1,271 +1,271 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkRotationOperation.h"
#include "mitkTestingMacros.h"
#include "mitkPlanePositionManager.h"
#include "mitkSliceNavigationController.h"
#include "mitkGeometry3D.h"
#include "mitkPlaneGeometry.h"
#include "mitkImage.h"
#include "mitkSurface.h"
#include "mitkStandaloneDataStorage.h"
#include "mitkDataNode.h"
#include "mitkStringProperty.h"
#include "mitkBaseProperty.h"
#include "mitkInteractionConst.h"
#include "vnl/vnl_vector.h"
#include <itkAffineGeometryFrame.h>
#include "mitkGetModuleContext.h"
std::vector<mitk::PlaneGeometry::Pointer> m_Geometries;
std::vector<unsigned int> m_SliceIndices;
mitk::PlanePositionManagerService* m_Service;
int SetUpBeforeTest()
{
//Getting Service
mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
m_Service = dynamic_cast<mitk::PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
if (m_Service == 0)
return EXIT_FAILURE;
//Creating different Geometries
m_Geometries.reserve(100);
mitk::PlaneGeometry::PlaneOrientation views[] = {mitk::PlaneGeometry::Axial, mitk::PlaneGeometry::Sagittal, mitk::PlaneGeometry::Frontal};
for (unsigned int i = 0; i < 100; ++i)
{
mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
mitk::ScalarType width = 256+(0.01*i);
mitk::ScalarType height = 256+(0.002*i);
mitk::Vector3D right;
mitk::Vector3D down;
right[0] = 1;
right[1] = i;
right[2] = 0.5;
down[0] = i*0.02;
down[1] = 1;
down[2] = i*0.03;
mitk::Vector3D spacing;
mitk::FillVector3D(spacing, 1.0*0.02*i, 1.0*0.15*i, 1.0);
mitk::Vector3D rightVector;
mitk::FillVector3D(rightVector, 0.02*(i+1), 0+(0.05*i), 1.0);
mitk::Vector3D downVector;
mitk::FillVector3D(downVector, 1, 3-0.01*i, 0.0345*i);
vnl_vector<mitk::ScalarType> normal = vnl_cross_3d(rightVector.GetVnlVector(), downVector.GetVnlVector());
normal.normalize();
normal *= 1.5;
mitk::Vector3D origin;
origin.Fill(1);
origin[0] = 12 + 0.03*i;
mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
mitk::Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightVector.GetVnlVector());
matrix.GetVnlMatrix().set_column(1, downVector.GetVnlVector());
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
transform->SetOffset(origin);
plane->InitializeStandardPlane(width, height, transform,
views[i%3], i,
true, false);
m_Geometries.push_back(plane);
}
return EXIT_SUCCESS;
}
int testAddPlanePosition()
{
MITK_TEST_OUTPUT(<<"Starting Test: ######### A d d P l a n e P o s i t i o n #########");
MITK_TEST_CONDITION(m_Service != NULL, "Testing getting of PlanePositionManagerService");
unsigned int currentID(m_Service->AddNewPlanePosition(m_Geometries.at(0),0));
bool error = ((m_Service->GetNumberOfPlanePositions() != 1)||(currentID != 0));
if(error)
{
MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == 1,"Checking for correct number of planepositions");
MITK_TEST_CONDITION(currentID == 0, "Testing for correct ID");
return EXIT_FAILURE;
}
//Adding new planes
for(unsigned int i = 1; i < m_Geometries.size(); ++i)
{
unsigned int newID = m_Service->AddNewPlanePosition(m_Geometries.at(i),i);
error = ((m_Service->GetNumberOfPlanePositions() != i+1)||(newID != (currentID+1)));
if (error)
{
MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == i+1,"Checking for correct number of planepositions");
MITK_TEST_CONDITION(newID == (currentID+1), "Testing for correct ID");
MITK_TEST_OUTPUT(<<"New: "<<newID<<" Last: "<<currentID);
return EXIT_FAILURE;
}
currentID = newID;
}
unsigned int numberOfPlanePos = m_Service->GetNumberOfPlanePositions();
//Adding existing planes -> nothing should change
for(unsigned int i = 0; i < (m_Geometries.size()-1)*0.5; ++i)
{
unsigned int newID = m_Service->AddNewPlanePosition(m_Geometries.at(i*2),i*2);
error = ((m_Service->GetNumberOfPlanePositions() != numberOfPlanePos)||(newID != i*2));
if (error)
{
MITK_TEST_CONDITION( m_Service->GetNumberOfPlanePositions() == numberOfPlanePos, "Checking for correct number of planepositions");
MITK_TEST_CONDITION(newID == i*2, "Testing for correct ID");
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
int testGetPlanePosition()
{
mitk::PlaneGeometry* plane;
mitk::RestorePlanePositionOperation* op;
bool error(true);
MITK_TEST_OUTPUT(<<"Starting Test: ######### G e t P l a n e P o s i t i o n #########");
//Testing for existing planepositions
for (unsigned int i = 0; i < m_Geometries.size(); ++i)
{
plane = m_Geometries.at(i);
op = m_Service->GetPlanePosition(i);
error = ( !mitk::Equal(op->GetHeight(),plane->GetExtent(1)) ||
!mitk::Equal(op->GetWidth(),plane->GetExtent(0)) ||
!mitk::Equal(op->GetSpacing(),plane->GetSpacing()) ||
!mitk::Equal(op->GetTransform()->GetOffset(),plane->GetIndexToWorldTransform()->GetOffset()) ||
- !mitk::Equal(op->GetDirectionVector().Get_vnl_vector(),plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).normalize()) ||
+ !mitk::Equal(op->GetDirectionVector().GetVnlVector(),plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).normalize()) ||
!mitk::MatrixEqualElementWise(op->GetTransform()->GetMatrix(), plane->GetIndexToWorldTransform()->GetMatrix()) );
if( error )
{
MITK_TEST_OUTPUT(<<"Iteration: "<<i)
MITK_TEST_CONDITION( mitk::Equal(op->GetHeight(),plane->GetExtent(1)) && mitk::Equal(op->GetWidth(),plane->GetExtent(0)), "Checking for correct extent");
MITK_TEST_CONDITION( mitk::Equal(op->GetSpacing(),plane->GetSpacing()), "Checking for correct spacing");
MITK_TEST_CONDITION( mitk::Equal(op->GetTransform()->GetOffset(),plane->GetIndexToWorldTransform()->GetOffset()), "Checking for correct offset");
MITK_INFO<<"Op: "<<op->GetDirectionVector()<<" plane: "<<plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2)<<"\n";
- MITK_TEST_CONDITION( mitk::Equal(op->GetDirectionVector().Get_vnl_vector(),plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2)), "Checking for correct direction");
+ MITK_TEST_CONDITION( mitk::Equal(op->GetDirectionVector().GetVnlVector(),plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2)), "Checking for correct direction");
MITK_TEST_CONDITION( mitk::MatrixEqualElementWise(op->GetTransform()->GetMatrix(), plane->GetIndexToWorldTransform()->GetMatrix()), "Checking for correct matrix");
return EXIT_FAILURE;
}
}
//Testing for not existing planepositions
error = ( m_Service->GetPlanePosition(100000000) != 0 ||
m_Service->GetPlanePosition(-1) != 0 );
if (error)
{
MITK_TEST_CONDITION(m_Service->GetPlanePosition(100000000) == 0, "Trying to get non existing pos");
MITK_TEST_CONDITION(m_Service->GetPlanePosition(-1) == 0, "Trying to get non existing pos");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int testRemovePlanePosition()
{
MITK_TEST_OUTPUT(<<"Starting Test: ######### R e m o v e P l a n e P o s i t i o n #########");
unsigned int size = m_Service->GetNumberOfPlanePositions();
bool removed (true);
//Testing for invalid IDs
removed = m_Service->RemovePlanePosition( -1 );
removed = m_Service->RemovePlanePosition( 1000000 );
unsigned int size2 = m_Service->GetNumberOfPlanePositions();
if (removed)
{
MITK_TEST_CONDITION(removed == false, "Testing remove not existing planepositions");
MITK_TEST_CONDITION(size == size2, "Testing remove not existing planepositions");
return EXIT_FAILURE;
}
//Testing for valid IDs
for (unsigned int i = 0; i < m_Geometries.size()*0.5; i++)
{
removed = m_Service->RemovePlanePosition( i );
unsigned int size2 = m_Service->GetNumberOfPlanePositions();
removed = (size2 == (size-(i+1)));
if (!removed)
{
MITK_TEST_CONDITION(removed == true, "Testing remove existing planepositions");
MITK_TEST_CONDITION(size == (size-i+1), "Testing remove existing planepositions");
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
int testRemoveAll()
{
MITK_TEST_OUTPUT(<<"Starting Test: ######### R e m o v e A l l #########");
unsigned int numPos = m_Service->GetNumberOfPlanePositions();
MITK_INFO<<numPos;
m_Service->RemoveAllPlanePositions();
bool error (true);
error = (m_Service->GetNumberOfPlanePositions() != 0 ||
m_Service->GetPlanePosition(60) != 0);
if (error)
{
MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == 0, "Testing remove all pos");
MITK_TEST_CONDITION(m_Service->GetPlanePosition(60) == 0, "Testing remove all pos");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int mitkPlanePositionManagerTest(int, char* [])
{
MITK_TEST_OUTPUT(<<"Starting Test PlanePositionManager");
SetUpBeforeTest();
int result;
MITK_TEST_CONDITION_REQUIRED( (result = testAddPlanePosition()) == EXIT_SUCCESS, "");
MITK_TEST_CONDITION_REQUIRED( (result = testGetPlanePosition()) == EXIT_SUCCESS, "");
MITK_TEST_CONDITION_REQUIRED( (result = testRemovePlanePosition()) == EXIT_SUCCESS, "");
MITK_TEST_CONDITION_REQUIRED( (result = testRemoveAll()) == EXIT_SUCCESS, "");
return EXIT_SUCCESS;
}
diff --git a/Core/Code/Testing/mitkPointSetVtkMapper2DGlyphTypeTest.cpp b/Core/Code/Testing/mitkPointSetVtkMapper2DGlyphTypeTest.cpp
new file mode 100644
index 0000000000..3844e00431
--- /dev/null
+++ b/Core/Code/Testing/mitkPointSetVtkMapper2DGlyphTypeTest.cpp
@@ -0,0 +1,55 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//MITK
+#include "mitkTestingMacros.h"
+#include "mitkRenderingTestHelper.h"
+#include <mitkNodePredicateDataType.h>
+#include <mitkEnumerationProperty.h>
+#include <mitkBaseProperty.h>
+#include <mitkPointSet.h>
+
+//VTK
+#include <vtkRegressionTestImage.h>
+
+
+int mitkPointSetVtkMapper2DGlyphTypeTest(int argc, char* argv[])
+{
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkPointSetVtkMapper2DGlyphTypeTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+
+ renderingHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal);
+
+ mitk::EnumerationProperty* eP = dynamic_cast<mitk::EnumerationProperty*> (renderingHelper.GetDataStorage()->GetNode(mitk::NodePredicateDataType::New("PointSet"))->GetProperty("Pointset.2D.shape"));
+ // render triangles instead of crosses
+ eP->SetValue(5);
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ //use this to generate a reference screenshot or save the file:
+ if(false)
+ {
+ renderingHelper.SaveReferenceScreenShot("C:/development_ITK4/output.png");
+ }
+
+ MITK_TEST_END();
+}
\ No newline at end of file
diff --git a/Core/Code/Testing/mitkPointSetVtkMapper2DImageTest.cpp b/Core/Code/Testing/mitkPointSetVtkMapper2DImageTest.cpp
new file mode 100644
index 0000000000..7eca24edd4
--- /dev/null
+++ b/Core/Code/Testing/mitkPointSetVtkMapper2DImageTest.cpp
@@ -0,0 +1,45 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//MITK
+#include "mitkTestingMacros.h"
+#include "mitkRenderingTestHelper.h"
+
+//VTK
+#include <vtkRegressionTestImage.h>
+
+
+int mitkPointSetVtkMapper2DImageTest(int argc, char* argv[])
+{
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkPointSetVtkMapper2DImageTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ //use this to generate a reference screenshot or save the file:
+ if(false)
+ {
+ renderingHelper.SaveReferenceScreenShot("C:/development_ITK4/output.png");
+ }
+
+ MITK_TEST_END();
+}
\ No newline at end of file
diff --git a/Core/Code/Testing/mitkPointSetVtkMapper2DTest.cpp b/Core/Code/Testing/mitkPointSetVtkMapper2DTest.cpp
new file mode 100644
index 0000000000..8006128422
--- /dev/null
+++ b/Core/Code/Testing/mitkPointSetVtkMapper2DTest.cpp
@@ -0,0 +1,48 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//MITK
+#include "mitkTestingMacros.h"
+#include "mitkRenderingTestHelper.h"
+
+//VTK
+#include <vtkRegressionTestImage.h>
+
+
+int mitkPointSetVtkMapper2DTest(int argc, char* argv[])
+{
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkPointSetVtkMapper2DTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+
+ // sagittal view direction
+ renderingHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal);
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ //use this to generate a reference screenshot or save the file:
+ if(false)
+ {
+ renderingHelper.SaveReferenceScreenShot("C:/development_ITK4/output.png");
+ }
+
+ MITK_TEST_END();
+}
\ No newline at end of file
diff --git a/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp b/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
index cda5f45f9b..aac7d81e95 100644
--- a/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
+++ b/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
@@ -1,577 +1,577 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSliceNavigationController.h"
#include "mitkPlaneGeometry.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkTimeSlicedGeometry.h"
#include "mitkRotationOperation.h"
#include "mitkInteractionConst.h"
#include "mitkPlanePositionManager.h"
#include "mitkTestingMacros.h"
#include "mitkGetModuleContext.h"
#include <vnl/vnl_quaternion.h>
#include <vnl/vnl_quaternion.txx>
#include <fstream>
bool operator==(const mitk::Geometry3D & left, const mitk::Geometry3D & right)
{
mitk::BoundingBox::BoundsArrayType leftbounds, rightbounds;
leftbounds =left.GetBounds();
rightbounds=right.GetBounds();
unsigned int i;
for(i=0;i<6;++i)
if(mitk::Equal(leftbounds[i],rightbounds[i])==false) return false;
const mitk::Geometry3D::TransformType::MatrixType & leftmatrix = left.GetIndexToWorldTransform()->GetMatrix();
const mitk::Geometry3D::TransformType::MatrixType & rightmatrix = right.GetIndexToWorldTransform()->GetMatrix();
unsigned int j;
for(i=0;i<3;++i)
{
const mitk::Geometry3D::TransformType::MatrixType::ValueType* leftvector = leftmatrix[i];
const mitk::Geometry3D::TransformType::MatrixType::ValueType* rightvector = rightmatrix[i];
for(j=0;j<3;++j)
if(mitk::Equal(leftvector[i],rightvector[i])==false) return false;
}
const mitk::Geometry3D::TransformType::OffsetType & leftoffset = left.GetIndexToWorldTransform()->GetOffset();
const mitk::Geometry3D::TransformType::OffsetType & rightoffset = right.GetIndexToWorldTransform()->GetOffset();
for(i=0;i<3;++i)
if(mitk::Equal(leftoffset[i],rightoffset[i])==false) return false;
return true;
}
int compareGeometry(const mitk::Geometry3D & geometry,
const mitk::ScalarType& width, const mitk::ScalarType& height, const mitk::ScalarType& numSlices,
const mitk::ScalarType& widthInMM, const mitk::ScalarType& heightInMM, const mitk::ScalarType& thicknessInMM,
const mitk::Point3D& cornerpoint0, const mitk::Vector3D& right, const mitk::Vector3D& bottom, const mitk::Vector3D& normal)
{
std::cout << "Testing width, height and thickness (in units): ";
if((mitk::Equal(geometry.GetExtent(0),width)==false) ||
(mitk::Equal(geometry.GetExtent(1),height)==false) ||
(mitk::Equal(geometry.GetExtent(2),numSlices)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm): ";
if((mitk::Equal(geometry.GetExtentInMM(0),widthInMM)==false) ||
(mitk::Equal(geometry.GetExtentInMM(1),heightInMM)==false) ||
(mitk::Equal(geometry.GetExtentInMM(2),thicknessInMM)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector(): ";
std::cout << "dir=0 ";
mitk::Vector3D dv;
dv=right; dv.Normalize(); dv*=widthInMM;
if((mitk::Equal(geometry.GetAxisVector(0), dv)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]";
std::cout << ", dir=1 ";
dv=bottom; dv.Normalize(); dv*=heightInMM;
if((mitk::Equal(geometry.GetAxisVector(1), dv)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]";
std::cout << ", dir=2 ";
dv=normal; dv.Normalize(); dv*=thicknessInMM;
if((mitk::Equal(geometry.GetAxisVector(2), dv)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing offset: ";
if((mitk::Equal(geometry.GetCornerPoint(0),cornerpoint0)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
return EXIT_SUCCESS;
}
int testGeometry(const mitk::Geometry3D * geometry,
const mitk::ScalarType& width, const mitk::ScalarType& height, const mitk::ScalarType& numSlices,
const mitk::ScalarType& widthInMM, const mitk::ScalarType& heightInMM, const mitk::ScalarType& thicknessInMM,
const mitk::Point3D& cornerpoint0, const mitk::Vector3D& right, const mitk::Vector3D& bottom, const mitk::Vector3D& normal)
{
int result=EXIT_FAILURE;
std::cout << "Comparing GetCornerPoint(0) of Geometry3D with provided cornerpoint0: ";
if(mitk::Equal(geometry->GetCornerPoint(0), cornerpoint0)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Creating and initializing a SliceNavigationController with the Geometry3D: ";
mitk::SliceNavigationController::Pointer sliceCtrl = mitk::SliceNavigationController::New();
sliceCtrl->SetInputWorldGeometry(geometry);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Axial): ";
sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing Update(): ";
sliceCtrl->Update();
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing result of CreatedWorldGeometry(): ";
mitk::Point3D axialcornerpoint0;
axialcornerpoint0 = cornerpoint0+bottom+normal*(numSlices-1+0.5); //really -1?
result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), width, height, numSlices, widthInMM, heightInMM, thicknessInMM*numSlices, axialcornerpoint0, right, bottom*(-1.0), normal*(-1.0));
if(result!=EXIT_SUCCESS)
{
std::cout<<"[FAILED]"<<std::endl;
return result;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Frontal): ";
sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Frontal);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing Update(): ";
sliceCtrl->Update();
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing result of CreatedWorldGeometry(): ";
mitk::Point3D frontalcornerpoint0;
frontalcornerpoint0 = cornerpoint0+geometry->GetAxisVector(1)*(+0.5/geometry->GetExtent(1));
result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), width, numSlices, height, widthInMM, thicknessInMM*numSlices, heightInMM, frontalcornerpoint0, right, normal, bottom);
if(result!=EXIT_SUCCESS)
{
std::cout<<"[FAILED]"<<std::endl;
return result;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Sagittal): ";
sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Sagittal);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing Update(): "<<std::endl;
sliceCtrl->Update();
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing result of CreatedWorldGeometry(): ";
mitk::Point3D sagittalcornerpoint0;
sagittalcornerpoint0 = cornerpoint0+geometry->GetAxisVector(0)*(+0.5/geometry->GetExtent(0));
result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), height, numSlices, width, heightInMM, thicknessInMM*numSlices, widthInMM, sagittalcornerpoint0, bottom, normal, right);
if(result!=EXIT_SUCCESS)
{
std::cout<<"[FAILED]"<<std::endl;
return result;
}
std::cout<<"[PASSED]"<<std::endl;
return EXIT_SUCCESS;
}
int testReorientPlanes ()
{
//Create PlaneGeometry
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
mitk::ScalarType width, height;
mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
width = 100; widthInMM = width;
height = 200; heightInMM = height;
thicknessInMM = 1.5;
mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
mitk::FillVector3D(right, widthInMM, 0, 0);
mitk::FillVector3D(bottom, 0, heightInMM, 0);
mitk::FillVector3D(normal, 0, 0, thicknessInMM);
mitk::Vector3D spacing;
normal.Normalize(); normal *= thicknessInMM;
mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
- planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector(), &spacing);
+ planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
planegeometry->SetOrigin(origin);
//Create SlicedGeometry3D out of planeGeometry
mitk::SlicedGeometry3D::Pointer slicedgeometry1 = mitk::SlicedGeometry3D::New();
unsigned int numSlices = 20;
slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
//Create another slicedgeo which will be rotated
mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New();
slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
//Create geo3D as reference
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetBounds(slicedgeometry1->GetBounds());
geometry->SetIndexToWorldTransform(slicedgeometry1->GetIndexToWorldTransform());
//Initialize planes
for (int i=0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry1->SetGeometry2D(geo2d,i);
}
for (int i=0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry2->SetGeometry2D(geo2d,i);
}
slicedgeometry1->SetReferenceGeometry(geometry);
slicedgeometry2->SetReferenceGeometry(geometry);
//Create SNC
mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
sliceCtrl1->SetInputWorldGeometry(slicedgeometry1);
sliceCtrl1->Update();
mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
sliceCtrl2->SetInputWorldGeometry(slicedgeometry2);
sliceCtrl2->Update();
slicedgeometry1->SetSliceNavigationController(sliceCtrl1);
slicedgeometry2->SetSliceNavigationController(sliceCtrl2);
// Whats current geometry?
MITK_INFO << "center: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
MITK_INFO << "normal: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetNormal();
MITK_INFO << "origin: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin();
MITK_INFO << "axis0 : " << sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0);
MITK_INFO << "aixs1 : " << sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1);
//
// Now reorient slices (ONE POINT, ONE NORMAL)
mitk::Point3D oldCenter, oldOrigin;
mitk::Vector3D oldAxis0, oldAxis1;
oldCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
oldOrigin = sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin();
oldAxis0 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0);
oldAxis1 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1);
mitk::Point3D orientCenter;
mitk::Vector3D orientNormal;
orientCenter = oldCenter;
mitk::FillVector3D(orientNormal, 0.3, 0.1, 0.8);
orientNormal.Normalize();
sliceCtrl1->ReorientSlices(orientCenter,orientNormal);
mitk::Point3D newCenter, newOrigin;
mitk::Vector3D newNormal;
newCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
newOrigin = sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin();
newNormal = sliceCtrl1->GetCurrentPlaneGeometry()->GetNormal();
newNormal.Normalize();
itk::Index<3> orientCenterIdx;
itk::Index<3> newCenterIdx;
sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(orientCenter, orientCenterIdx);
sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(newCenter, newCenterIdx);
if (
(newCenterIdx != orientCenterIdx) ||
( !mitk::Equal(orientNormal, newNormal) )
)
{
MITK_INFO << "Reorient Planes (1 point, 1 vector) not working as it should";
MITK_INFO << "orientCenterIdx: " << orientCenterIdx;
MITK_INFO << "newCenterIdx: " << newCenterIdx;
MITK_INFO << "orientNormal: " << orientNormal;
MITK_INFO << "newNormal: " << newNormal;
return EXIT_FAILURE;
}
//
// Now reorient slices (center, vec0, vec1 )
mitk::Vector3D orientAxis0, orientAxis1, newAxis0, newAxis1;
mitk::FillVector3D(orientAxis0, 1.0, 0.0, 0.0);
mitk::FillVector3D(orientAxis1, 0.0, 1.0, 0.0);
orientAxis0.Normalize();
orientAxis1.Normalize();
sliceCtrl1->ReorientSlices(orientCenter,orientAxis0, orientAxis1);
newAxis0 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0);
newAxis1 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1);
newCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
newAxis0.Normalize();
newAxis1.Normalize();
sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(orientCenter, orientCenterIdx);
sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(newCenter, newCenterIdx);
if (
(newCenterIdx != orientCenterIdx) ||
( !mitk::Equal(orientAxis0, newAxis0) ) ||
( !mitk::Equal(orientAxis1, newAxis1) )
)
{
MITK_INFO << "Reorient Planes (point, vec, vec) not working as it should";
MITK_INFO << "orientCenterIdx: " << orientCenterIdx;
MITK_INFO << "newCenterIdx: " << newCenterIdx;
MITK_INFO << "orientAxis0: " << orientAxis0;
MITK_INFO << "newAxis0: " << newAxis0;
MITK_INFO << "orientAxis1: " << orientAxis1;
MITK_INFO << "newAxis1: " << newAxis1;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int testRestorePlanePostionOperation ()
{
//Create PlaneGeometry
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
mitk::ScalarType width, height;
mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
width = 100; widthInMM = width;
height = 200; heightInMM = height;
thicknessInMM = 1.5;
mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
mitk::FillVector3D(right, widthInMM, 0, 0);
mitk::FillVector3D(bottom, 0, heightInMM, 0);
mitk::FillVector3D(normal, 0, 0, thicknessInMM);
mitk::Vector3D spacing;
normal.Normalize(); normal *= thicknessInMM;
mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
- planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector(), &spacing);
+ planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
planegeometry->SetOrigin(origin);
//Create SlicedGeometry3D out of planeGeometry
mitk::SlicedGeometry3D::Pointer slicedgeometry1 = mitk::SlicedGeometry3D::New();
unsigned int numSlices = 300;
slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
//Create another slicedgeo which will be rotated
mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New();
slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
//Create geo3D as reference
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetBounds(slicedgeometry1->GetBounds());
geometry->SetIndexToWorldTransform(slicedgeometry1->GetIndexToWorldTransform());
//Initialize planes
for (int i=0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry1->SetGeometry2D(geo2d,i);
}
for (int i=0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry2->SetGeometry2D(geo2d,i);
}
slicedgeometry1->SetReferenceGeometry(geometry);
slicedgeometry2->SetReferenceGeometry(geometry);
//Create SNC
mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
sliceCtrl1->SetInputWorldGeometry(slicedgeometry1);
sliceCtrl1->Update();
mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
sliceCtrl2->SetInputWorldGeometry(slicedgeometry2);
sliceCtrl2->Update();
slicedgeometry1->SetSliceNavigationController(sliceCtrl1);
slicedgeometry2->SetSliceNavigationController(sliceCtrl2);
//Rotate slicedgeo2
double angle = 63.84;
mitk::Vector3D rotationVector; mitk::FillVector3D( rotationVector, 0.5, 0.95, 0.23 );
mitk::Point3D center = slicedgeometry2->GetCenter();
mitk::RotationOperation* op = new mitk::RotationOperation( mitk::OpROTATE, center, rotationVector, angle );
slicedgeometry2->ExecuteOperation(op);
sliceCtrl2->Update();
mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
service->AddNewPlanePosition(slicedgeometry2->GetGeometry2D(0), 178);
sliceCtrl1->ExecuteOperation(service->GetPlanePosition(0));
sliceCtrl1->Update();
mitk::Geometry2D* planeRotated = slicedgeometry2->GetGeometry2D(178);
mitk::Geometry2D* planeRestored = dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetGeometry2D(178);
try{
MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(planeRotated->GetIndexToWorldTransform()->GetMatrix(), planeRestored->GetIndexToWorldTransform()->GetMatrix()),"Testing for IndexToWorld");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(planeRotated->GetOrigin(), planeRestored->GetOrigin(),2*mitk::eps),"Testing for origin");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(planeRotated->GetSpacing(), planeRestored->GetSpacing()),"Testing for spacing");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(slicedgeometry2->GetDirectionVector(), dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetDirectionVector()),"Testing for directionvector");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(slicedgeometry2->GetSlices(), dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetSlices()),"Testing for numslices");
MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(slicedgeometry2->GetIndexToWorldTransform()->GetMatrix(), dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetIndexToWorldTransform()->GetMatrix()),"Testing for IndexToWorld");
}
catch(...)
{
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int mitkSliceNavigationControllerTest(int /*argc*/, char* /*argv*/[])
{
int result=EXIT_FAILURE;
std::cout << "Creating and initializing a PlaneGeometry: ";
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
mitk::ScalarType width, height;
mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
width = 100; widthInMM = width;
height = 200; heightInMM = height;
thicknessInMM = 1.5;
// mitk::FillVector3D(origin, 0, 0, thicknessInMM*0.5);
mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
mitk::FillVector3D(right, widthInMM, 0, 0);
mitk::FillVector3D(bottom, 0, heightInMM, 0);
mitk::FillVector3D(normal, 0, 0, thicknessInMM);
mitk::Vector3D spacing;
normal.Normalize(); normal *= thicknessInMM;
mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
- planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector(), &spacing);
+ planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
planegeometry->SetOrigin(origin);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Creating and initializing a SlicedGeometry3D with the PlaneGeometry: ";
mitk::SlicedGeometry3D::Pointer slicedgeometry = mitk::SlicedGeometry3D::New();
unsigned int numSlices = 5;
slicedgeometry->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Creating a Geometry3D with the same extent as the SlicedGeometry3D: ";
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetBounds(slicedgeometry->GetBounds());
geometry->SetIndexToWorldTransform(slicedgeometry->GetIndexToWorldTransform());
std::cout<<"[PASSED]"<<std::endl;
mitk::Point3D cornerpoint0;
cornerpoint0 = geometry->GetCornerPoint(0);
result=testGeometry(geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal);
if(result!=EXIT_SUCCESS)
return result;
mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
transform->SetMatrix(geometry->GetIndexToWorldTransform()->GetMatrix());
mitk::BoundingBox::Pointer boundingbox = geometry->CalculateBoundingBoxRelativeToTransform(transform);
geometry->SetBounds(boundingbox->GetBounds());
cornerpoint0 = geometry->GetCornerPoint(0);
result=testGeometry(geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal);
if(result!=EXIT_SUCCESS)
return result;
std::cout << "Changing the IndexToWorldTransform of the geometry to a rotated version by SetIndexToWorldTransform() (keep cornerpoint0): ";
transform = mitk::AffineTransform3D::New();
mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = planegeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
mitk::VnlVector axis(3);
mitk::FillVector3D(axis, 1.0, 1.0, 1.0); axis.normalize();
vnl_quaternion<mitk::ScalarType> rotation(axis, 0.223);
vnlmatrix = rotation.rotation_matrix_transpose()*vnlmatrix;
mitk::Matrix3D matrix;
matrix = vnlmatrix;
transform->SetMatrix(matrix);
transform->SetOffset(cornerpoint0.GetVectorFromOrigin());
- right.Set_vnl_vector( rotation.rotation_matrix_transpose()*right.Get_vnl_vector() );
- bottom.Set_vnl_vector(rotation.rotation_matrix_transpose()*bottom.Get_vnl_vector());
- normal.Set_vnl_vector(rotation.rotation_matrix_transpose()*normal.Get_vnl_vector());
+ right.SetVnlVector( rotation.rotation_matrix_transpose()*right.GetVnlVector() );
+ bottom.SetVnlVector(rotation.rotation_matrix_transpose()*bottom.GetVnlVector());
+ normal.SetVnlVector(rotation.rotation_matrix_transpose()*normal.GetVnlVector());
geometry->SetIndexToWorldTransform(transform);
std::cout<<"[PASSED]"<<std::endl;
cornerpoint0 = geometry->GetCornerPoint(0);
result = testGeometry(geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal);
if(result!=EXIT_SUCCESS)
return result;
//Testing Execute RestorePlanePositionOperation
result = testRestorePlanePostionOperation();
if(result!=EXIT_SUCCESS)
return result;
//Testing ReorientPlanes
result = testReorientPlanes();
if(result!=EXIT_SUCCESS)
return result;
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}
diff --git a/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp b/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp
index f28d01a567..8f804a05e4 100644
--- a/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp
+++ b/Core/Code/Testing/mitkSlicedGeometry3DTest.cpp
@@ -1,256 +1,256 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImage.h"
#include "mitkPlaneGeometry.h"
#include "mitkTimeSlicedGeometry.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkTestingMacros.h"
#include <vnl/vnl_quaternion.h>
#include <vnl/vnl_quaternion.txx>
#include <fstream>
void mitkSlicedGeometry3D_ChangeImageGeometryConsideringOriginOffset_Test()
{
//Tests for Offset
MITK_TEST_OUTPUT( << "====== NOW RUNNING: Tests for pixel-center-based offset concerns ========");
// create a SlicedGeometry3D
mitk::SlicedGeometry3D::Pointer slicedGeo3D=mitk::SlicedGeometry3D::New();
int num_slices = 5;
slicedGeo3D->InitializeSlicedGeometry(num_slices); // 5 slices
mitk::Point3D newOrigin;
newOrigin[0] = 91.3;
newOrigin[1] = -13.3;
newOrigin[2] = 0;
slicedGeo3D->SetOrigin(newOrigin);
mitk::Vector3D newSpacing;
newSpacing[0] = 1.0f;
newSpacing[1] = 0.9f;
newSpacing[2] = 0.3f;
slicedGeo3D->SetSpacing(newSpacing);
// create subslices as well
for (int i=0; i < num_slices; i++)
{
mitk::Geometry2D::Pointer geo2d = mitk::Geometry2D::New();
geo2d->Initialize();
slicedGeo3D->SetGeometry2D(geo2d,i);
}
// now run tests
MITK_TEST_OUTPUT( << "Testing whether slicedGeo3D->GetImageGeometry() is false by default");
MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetImageGeometry()==false, "");
MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==false by default");
mitk::Geometry3D* subSliceGeo2D_first = slicedGeo3D->GetGeometry2D(0);
mitk::Geometry3D* subSliceGeo2D_last = slicedGeo3D->GetGeometry2D(num_slices-1);
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetImageGeometry()==false, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetImageGeometry()==false, "");
// Save some Origins and cornerpoints
mitk::Point3D OriginSlicedGeo( slicedGeo3D->GetOrigin() );
mitk::Point3D OriginFirstGeo( subSliceGeo2D_first->GetOrigin() );
mitk::Point3D OriginLastGeo( subSliceGeo2D_last->GetOrigin() );
mitk::Point3D CornerPoint0SlicedGeo(slicedGeo3D->GetCornerPoint(0));
mitk::Point3D CornerPoint1FirstGeo(subSliceGeo2D_first->GetCornerPoint(1));
mitk::Point3D CornerPoint2LastGeo(subSliceGeo2D_last->GetCornerPoint(2));
MITK_TEST_OUTPUT( << "Calling slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(true)");
//std::cout << "vorher Origin: " << subSliceGeo2D_first->GetOrigin() << std::endl;
//std::cout << "vorher Corner: " << subSliceGeo2D_first->GetCornerPoint(0) << std::endl;
slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(true);
//std::cout << "nachher Origin: " << subSliceGeo2D_first->GetOrigin() << std::endl;
//std::cout << "nachher Corner: " << subSliceGeo2D_first->GetCornerPoint(0) << std::endl;
MITK_TEST_OUTPUT( << "Testing whether slicedGeo3D->GetImageGeometry() is now true");
MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetImageGeometry()==true, "");
MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==true now");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetImageGeometry()==true, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetImageGeometry()==true, "");
MITK_TEST_OUTPUT( << "Testing wether offset has been added to origins");
// Manually adding Offset.
OriginSlicedGeo[0] += (slicedGeo3D->GetSpacing()[0]) / 2;
OriginSlicedGeo[1] += (slicedGeo3D->GetSpacing()[1]) / 2;
OriginSlicedGeo[2] += (slicedGeo3D->GetSpacing()[2]) / 2;
OriginFirstGeo[0] += (subSliceGeo2D_first->GetSpacing()[0]) / 2;
OriginFirstGeo[1] += (subSliceGeo2D_first->GetSpacing()[1]) / 2;
OriginFirstGeo[2] += (subSliceGeo2D_first->GetSpacing()[2]) / 2;
OriginLastGeo[0] += (subSliceGeo2D_last->GetSpacing()[0]) / 2;
OriginLastGeo[1] += (subSliceGeo2D_last->GetSpacing()[1]) / 2;
OriginLastGeo[2] += (subSliceGeo2D_last->GetSpacing()[2]) / 2;
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetCornerPoint(1)==CornerPoint1FirstGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetCornerPoint(2)==CornerPoint2LastGeo, "");
MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetCornerPoint(0)==CornerPoint0SlicedGeo, "");
MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetOrigin()==OriginSlicedGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetOrigin()==OriginFirstGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetOrigin()==OriginLastGeo, "");
MITK_TEST_OUTPUT( << "Calling slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(false)");
slicedGeo3D->ChangeImageGeometryConsideringOriginOffset(false);
MITK_TEST_OUTPUT( << "Testing whether slicedGeo3D->GetImageGeometry() is now false");
MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetImageGeometry()==false, "");
MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==false now");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetImageGeometry()==false, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetImageGeometry()==false, "");
MITK_TEST_OUTPUT( << "Testing wether offset has been added to origins of geometry");
// Manually substracting Offset.
OriginSlicedGeo[0] -= (slicedGeo3D->GetSpacing()[0]) / 2;
OriginSlicedGeo[1] -= (slicedGeo3D->GetSpacing()[1]) / 2;
OriginSlicedGeo[2] -= (slicedGeo3D->GetSpacing()[2]) / 2;
OriginFirstGeo[0] -= (subSliceGeo2D_first->GetSpacing()[0]) / 2;
OriginFirstGeo[1] -= (subSliceGeo2D_first->GetSpacing()[1]) / 2;
OriginFirstGeo[2] -= (subSliceGeo2D_first->GetSpacing()[2]) / 2;
OriginLastGeo[0] -= (subSliceGeo2D_last->GetSpacing()[0]) / 2;
OriginLastGeo[1] -= (subSliceGeo2D_last->GetSpacing()[1]) / 2;
OriginLastGeo[2] -= (subSliceGeo2D_last->GetSpacing()[2]) / 2;
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetCornerPoint(1)==CornerPoint1FirstGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetCornerPoint(2)==CornerPoint2LastGeo, "");
MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetCornerPoint(0)==CornerPoint0SlicedGeo, "");
MITK_TEST_CONDITION_REQUIRED( slicedGeo3D->GetOrigin()==OriginSlicedGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_first->GetOrigin()==OriginFirstGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo2D_last->GetOrigin()==OriginLastGeo, "");
MITK_TEST_OUTPUT( << "ALL SUCCESSFULLY!");
}
int mitkSlicedGeometry3DTest(int /*argc*/, char* /*argv*/[])
{
mitk::PlaneGeometry::Pointer planegeometry1 = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
mitk::ScalarType width, height;
mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
width = 100; widthInMM = width;
height = 200; heightInMM = height;
thicknessInMM = 3.5;
mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
mitk::FillVector3D(right, widthInMM, 0, 0);
mitk::FillVector3D(bottom, 0, heightInMM, 0);
mitk::FillVector3D(normal, 0, 0, thicknessInMM);
std::cout << "Initializing planegeometry1 by InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
- planegeometry1->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector());
+ planegeometry1->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector());
std::cout << "Setting planegeometry2 to a cloned version of planegeometry1: "<<std::endl;
mitk::PlaneGeometry::Pointer planegeometry2;
planegeometry2 = dynamic_cast<mitk::PlaneGeometry*>(planegeometry1->Clone().GetPointer());;
std::cout << "Changing the IndexToWorldTransform of planegeometry2 to a rotated version by SetIndexToWorldTransform() (keep origin): "<<std::endl;
mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = planegeometry2->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
mitk::VnlVector axis(3);
mitk::FillVector3D(axis, 1.0, 1.0, 1.0); axis.normalize();
vnl_quaternion<mitk::ScalarType> rotation(axis, 0.123);
vnlmatrix = rotation.rotation_matrix_transpose()*vnlmatrix;
mitk::Matrix3D matrix;
matrix = vnlmatrix;
transform->SetMatrix(matrix);
transform->SetOffset(planegeometry2->GetIndexToWorldTransform()->GetOffset());
- right.Set_vnl_vector( rotation.rotation_matrix_transpose()*right.Get_vnl_vector() );
- bottom.Set_vnl_vector(rotation.rotation_matrix_transpose()*bottom.Get_vnl_vector());
- normal.Set_vnl_vector(rotation.rotation_matrix_transpose()*normal.Get_vnl_vector());
+ right.SetVnlVector( rotation.rotation_matrix_transpose()*right.GetVnlVector() );
+ bottom.SetVnlVector(rotation.rotation_matrix_transpose()*bottom.GetVnlVector());
+ normal.SetVnlVector(rotation.rotation_matrix_transpose()*normal.GetVnlVector());
planegeometry2->SetIndexToWorldTransform(transform);
std::cout << "Setting planegeometry3 to the backside of planegeometry2: " <<std::endl;
mitk::PlaneGeometry::Pointer planegeometry3 = mitk::PlaneGeometry::New();
planegeometry3->InitializeStandardPlane(planegeometry2, mitk::PlaneGeometry::Axial, 0, false);
std::cout << "Testing SlicedGeometry3D::InitializeEvenlySpaced(planegeometry3, zSpacing = 1, slices = 5, flipped = false): " <<std::endl;
mitk::SlicedGeometry3D::Pointer slicedWorldGeometry=mitk::SlicedGeometry3D::New();
unsigned int numSlices = 5;
slicedWorldGeometry->InitializeEvenlySpaced(planegeometry3, 1, numSlices, false);
std::cout << "Testing availability and type (PlaneGeometry) of first geometry in the SlicedGeometry3D: ";
mitk::PlaneGeometry* accessedplanegeometry3 = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetGeometry2D(0));
if(accessedplanegeometry3==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing whether the first geometry in the SlicedGeometry3D is identical to planegeometry3 by axis comparison and origin: "<<std::endl;
if((mitk::Equal(accessedplanegeometry3->GetAxisVector(0), planegeometry3->GetAxisVector(0))==false) ||
(mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1))==false) ||
(mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2))==false) ||
(mitk::Equal(accessedplanegeometry3->GetOrigin(), planegeometry3->GetOrigin())==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing availability and type (PlaneGeometry) of the last geometry in the SlicedGeometry3D: ";
mitk::PlaneGeometry* accessedplanegeometry3last = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetGeometry2D(numSlices-1));
mitk::Point3D origin3last; origin3last = planegeometry3->GetOrigin()+slicedWorldGeometry->GetDirectionVector()*(numSlices-1);
if(accessedplanegeometry3last==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing whether the last geometry in the SlicedGeometry3D is identical to planegeometry3 by axis comparison: "<<std::endl;
if((mitk::Equal(accessedplanegeometry3last->GetAxisVector(0), planegeometry3->GetAxisVector(0))==false) ||
(mitk::Equal(accessedplanegeometry3last->GetAxisVector(1), planegeometry3->GetAxisVector(1))==false) ||
(mitk::Equal(accessedplanegeometry3last->GetAxisVector(2), planegeometry3->GetAxisVector(2))==false) ||
(mitk::Equal(accessedplanegeometry3last->GetOrigin(), origin3last)==false) ||
(mitk::Equal(accessedplanegeometry3last->GetIndexToWorldTransform()->GetOffset(), origin3last.GetVectorFromOrigin())==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Again for first slice - Testing availability and type (PlaneGeometry) of first geometry in the SlicedGeometry3D: ";
accessedplanegeometry3 = dynamic_cast<mitk::PlaneGeometry*>(slicedWorldGeometry->GetGeometry2D(0));
if(accessedplanegeometry3==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Again for first slice - Testing whether the first geometry in the SlicedGeometry3D is identical to planegeometry3 by axis comparison and origin: "<<std::endl;
if((mitk::Equal(accessedplanegeometry3->GetAxisVector(0), planegeometry3->GetAxisVector(0))==false) ||
(mitk::Equal(accessedplanegeometry3->GetAxisVector(1), planegeometry3->GetAxisVector(1))==false) ||
(mitk::Equal(accessedplanegeometry3->GetAxisVector(2), planegeometry3->GetAxisVector(2))==false) ||
(mitk::Equal(accessedplanegeometry3->GetOrigin(), planegeometry3->GetOrigin())==false) ||
(mitk::Equal(accessedplanegeometry3->GetIndexToWorldTransform()->GetOffset(), planegeometry3->GetOrigin().GetVectorFromOrigin())==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
mitkSlicedGeometry3D_ChangeImageGeometryConsideringOriginOffset_Test();
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}
diff --git a/Core/Code/Testing/mitkSurfaceGLMapper2DColorTest.cpp b/Core/Code/Testing/mitkSurfaceGLMapper2DColorTest.cpp
new file mode 100644
index 0000000000..174a5e98ac
--- /dev/null
+++ b/Core/Code/Testing/mitkSurfaceGLMapper2DColorTest.cpp
@@ -0,0 +1,51 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//MITK
+#include "mitkTestingMacros.h"
+#include "mitkRenderingTestHelper.h"
+#include <mitkNodePredicateDataType.h>
+
+//VTK
+#include <vtkRegressionTestImage.h>
+
+
+int mitkSurfaceGLMapper2DColorTest(int argc, char* argv[])
+{
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkSurfaceGLMapper2DColorTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+ //Set the opacity for all images
+
+ renderingHelper.GetDataStorage()->GetNode(mitk::NodePredicateDataType::New("Surface"))->SetProperty("color", mitk::ColorProperty::New(255.0f, 0.0f, 0.0f));
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ //####################
+ //Use this to generate a reference screenshot or save the file.
+ //(Only in your local version of the test!)
+ if(false)
+ {
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/RenderingTestData/output.png");
+ }
+ //####################
+ MITK_TEST_END();
+}
diff --git a/Core/Code/Testing/mitkSurfaceGLMapper2DOpacityTest.cpp b/Core/Code/Testing/mitkSurfaceGLMapper2DOpacityTest.cpp
new file mode 100644
index 0000000000..ad02205ac0
--- /dev/null
+++ b/Core/Code/Testing/mitkSurfaceGLMapper2DOpacityTest.cpp
@@ -0,0 +1,51 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//MITK
+#include "mitkTestingMacros.h"
+#include "mitkRenderingTestHelper.h"
+#include <mitkNodePredicateDataType.h>
+
+//VTK
+#include <vtkRegressionTestImage.h>
+
+
+int mitkSurfaceGLMapper2DOpacityTest(int argc, char* argv[])
+{
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ MITK_TEST_BEGIN("mitkSurfaceGLMapper2DOpacityTest")
+
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+ //Set the opacity for all images
+
+ renderingHelper.GetDataStorage()->GetNode(mitk::NodePredicateDataType::New("Surface"))->SetProperty("opacity", mitk::FloatProperty::New(0.5f));
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ //####################
+ //Use this to generate a reference screenshot or save the file.
+ //(Only in your local version of the test!)
+ if(false)
+ {
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/RenderingTestData/output.png");
+ }
+ //####################
+ MITK_TEST_END();
+}
diff --git a/Core/Code/Testing/mitkSurfaceToSurfaceFilterTest.cpp b/Core/Code/Testing/mitkSurfaceToSurfaceFilterTest.cpp
index 6c1c8e6570..f5c8e15ddd 100644
--- a/Core/Code/Testing/mitkSurfaceToSurfaceFilterTest.cpp
+++ b/Core/Code/Testing/mitkSurfaceToSurfaceFilterTest.cpp
@@ -1,122 +1,122 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSurface.h"
#include "mitkSurfaceToSurfaceFilter.h"
#include "mitkCommon.h"
#include "mitkVector.h"
#include "mitkTimeSlicedGeometry.h"
#include "vtkPolyData.h"
#include "vtkSphereSource.h"
#include <fstream>
int mitkSurfaceToSurfaceFilterTest(int /*argc*/, char* /*argv*/[])
{
mitk::Surface::Pointer surface;
surface = mitk::Surface::New();
vtkSphereSource* sphereSource = vtkSphereSource::New();
sphereSource->SetCenter(0,0,0);
sphereSource->SetRadius(5.0);
sphereSource->SetThetaResolution(10);
sphereSource->SetPhiResolution(10);
sphereSource->Update();
vtkPolyData* polys = sphereSource->GetOutput();
surface->SetVtkPolyData( polys );
sphereSource->Delete();
mitk::SurfaceToSurfaceFilter::Pointer filter = mitk::SurfaceToSurfaceFilter::New();
std::cout << "Testing mitk::SurfaceToSurfaceFilter::SetInput() and ::GetNumberOfInputs() : " ;
filter->SetInput( surface );
if ( filter->GetNumberOfInputs() < 1 )
{
std::cout<<"[FAILED] : zero inputs set "<<std::endl;
return EXIT_FAILURE;
}
std::cout << "Testing if GetInput returns the right Input : " << std::endl;
if ( filter->GetInput() != surface )
{
std::cout<<"[FAILED] : GetInput does not return correct input. "<<std::endl;
return EXIT_FAILURE;
}
std::cout << "[SUCCESS] : input correct" << std::endl;
if ( filter->GetInput(5) != NULL )
{
std::cout<<"[FAILED] : GetInput returns inputs that were not set. "<<std::endl;
return EXIT_FAILURE;
}
std::cout << "[SUCCESS] : Input nr.5 was not set -> is NULL" << std::endl;
std::cout << "Testing whether Output is created correctly : " << std::endl;
if ( filter->GetNumberOfOutputs() != filter->GetNumberOfInputs() )
{
std::cout <<"[FAILED] : number of outputs != number of inputs" << std::endl;
return EXIT_FAILURE;
}
std::cout << "[SUCCESS] : number of inputs == number of outputs." << std::endl;
- mitk::Surface::Pointer outputSurface = filter->GetOutput(0);
+ mitk::Surface::Pointer outputSurface = filter->GetOutput();
if ( outputSurface->GetVtkPolyData()->GetNumberOfPolys() != surface->GetVtkPolyData()->GetNumberOfPolys() )
{
std::cout << "[FAILED] : number of Polys in PolyData of output != number of Polys in PolyData of input" << std::endl;
return EXIT_FAILURE;
}
std::cout << "[SUCCESS] : number of Polys in PolyData of input and output are identical." << std::endl;
filter->Update();
- outputSurface = filter->GetOutput(0);
+ outputSurface = filter->GetOutput();
if ( outputSurface->GetSizeOfPolyDataSeries() != surface->GetSizeOfPolyDataSeries() )
{
std::cout << "[FAILED] : number of PolyDatas in PolyDataSeries of output != number of PolyDatas of input" << std::endl;
return EXIT_FAILURE;
}
std::cout << "[SUCCESS] : Size of PolyDataSeries of input and output are identical." << std::endl;
- std::cout << "Testing removeInputs() : " << std::endl;
- unsigned int numOfInputs = filter->GetNumberOfInputs();
- filter->RemoveInputs( mitk::Surface::New() );
- if ( filter->GetNumberOfInputs() != numOfInputs )
- {
- std::cout << "[FAILED] : input was removed that was not set." << std::endl;
- return EXIT_FAILURE;
- }
- std::cout << "[SUCCESS] : no iput was removed that was not set." << std::endl;
- filter->RemoveInputs( surface );
- if ( filter->GetNumberOfInputs() != 0 )
- {
- std::cout << "[FAILED] : existing input was not removed correctly." << std::endl;
- return EXIT_FAILURE;
- }
- std::cout << "[SUCCESS] : existing input was removed correctly." << std::endl;
+ //std::cout << "Testing RemoveInputs() : " << std::endl;
+ //unsigned int numOfInputs = filter->GetNumberOfInputs();
+ //filter->RemoveInputs( mitk::Surface::New() );
+ //if ( filter->GetNumberOfInputs() != numOfInputs )
+ //{
+ // std::cout << "[FAILED] : input was removed that was not set." << std::endl;
+ // return EXIT_FAILURE;
+ //}
+ //std::cout << "[SUCCESS] : no input was removed that was not set." << std::endl;
+ //filter->RemoveInputs( surface );
+ //if ( filter->GetNumberOfInputs() != 0 )
+ //{
+ // std::cout << "[FAILED] : existing input was not removed correctly." << std::endl;
+ // return EXIT_FAILURE;
+ //}
+ //std::cout << "[SUCCESS] : existing input was removed correctly." << std::endl;
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}
diff --git a/Core/Code/Testing/mitkSurfaceVtkMapper3DTest.cpp b/Core/Code/Testing/mitkSurfaceVtkMapper3DTest.cpp
index c94526cdd3..fcfa38a019 100644
--- a/Core/Code/Testing/mitkSurfaceVtkMapper3DTest.cpp
+++ b/Core/Code/Testing/mitkSurfaceVtkMapper3DTest.cpp
@@ -1,129 +1,105 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include "mitkTestingMacros.h"
#include "mitkRenderingTestHelper.h"
#include <mitkNodePredicateDataType.h>
#include <mitkSmartPointerProperty.h>
#include <mitkSurface.h>
//VTK
#include <vtkRegressionTestImage.h>
#include <vtkFloatArray.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <mitkIOUtil.h>
#include <vtkSphereSource.h>
#include <vtkTextureMapToSphere.h>
#include <vtkCamera.h>
int mitkSurfaceVtkMapper3DTest(int argc, char* argv[])
{
// load all arguments into a datastorage, take last argument as reference rendering
// setup a renderwindow of fixed size X*Y
// render the datastorage
// compare rendering to reference image
MITK_TEST_BEGIN("mitkSurfaceVtkMapper3DTest")
- // enough parameters?
- if ( argc < 2 )
- {
- MITK_TEST_OUTPUT( << "Usage: " << std::string(*argv) << " [file1 file2 ...] outputfile" )
- MITK_TEST_OUTPUT( << "Will render a central axial slice of all given files into outputfile" )
- exit( EXIT_SUCCESS );
- }
-
- mitkRenderingTestHelper renderingHelper(640, 480, argc, argv);
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
//3D rendering test, thus 3D mapper ID.
renderingHelper.SetMapperID(mitk::BaseRenderer::Standard3D);
vtkSmartPointer<vtkFloatArray> textureCoordinates =
vtkSmartPointer<vtkFloatArray>::New();
textureCoordinates->SetNumberOfComponents(2);
textureCoordinates->SetName("TextureCoordinates");
mitk::Image::Pointer textureImage = static_cast< mitk::Image* > ( renderingHelper.GetDataStorage()->GetNode( mitk::NodePredicateDataType::New("Image"))->GetData() );
//generate texture coordinates assuming that surface and texture can be mapped 1 to 1
unsigned int* dims = textureImage->GetDimensions();
for(unsigned int j = 0; j < dims[1]; ++j)
{
for(unsigned int i = 0; i < dims[0]; ++i)
{
int pixelID = i + j*dims[0];
float xNorm = (((float)i)/dims[0]);
float yNorm = ((float)j)/dims[1];
textureCoordinates->InsertTuple2(pixelID, xNorm, yNorm);
}
}
mitk::Surface::Pointer surfaceToPutTextureOn = static_cast< mitk::Surface* > ( renderingHelper.GetDataStorage()->GetNode( mitk::NodePredicateDataType::New("Surface"))->GetData() );
surfaceToPutTextureOn->GetVtkPolyData()->GetPointData()->SetTCoords(textureCoordinates);
mitk::SmartPointerProperty::Pointer textureProperty = mitk::SmartPointerProperty::New(textureImage);
renderingHelper.GetDataStorage()->GetNode(mitk::NodePredicateDataType::New("Surface"))->SetProperty("Surface.Texture", textureProperty);
//remove the image from the data storage in order to not disturb the world geometry
//(only the surface geometry should be used for rendering)
renderingHelper.GetDataStorage()->Remove( renderingHelper.GetDataStorage()->GetNode( mitk::NodePredicateDataType::New("Image")) );
//Perform reinit, because we removed data.
mitk::RenderingManager::GetInstance()->InitializeViews( renderingHelper.GetDataStorage()->ComputeBoundingGeometry3D(renderingHelper.GetDataStorage()->GetAll()) );
//Find a nice camera position to view the surface from the front.
//This has to be done after calling renderingHelper.Render(),
//because it would overwrite the camera position with global reinit.
//It is not necessary, but else the surface is ugly rendered from the side.
mitk::Point3D surfaceCenter= surfaceToPutTextureOn->GetGeometry()->GetCenter();
vtkCamera* camera3d = renderingHelper.GetVtkRenderer()->GetActiveCamera();
//1m distance to camera should be a nice default value for most cameras
camera3d->SetPosition(0,0,-1000);
camera3d->SetViewUp(0,-1,0);
camera3d->SetFocalPoint(0,0,surfaceCenter[2]);
camera3d->SetViewAngle(40);
// camera3d->SetClippingRange(1, 10000);
renderingHelper.GetVtkRenderer()->ResetCamera();
-
- renderingHelper.Render();
//use this to generate a reference screenshot or save the file:
bool generateReferenceScreenshot = false;
if(generateReferenceScreenshot)
{
- renderingHelper.SaveAsPNG("/home/kilgus/Pictures/RenderingTestData/output.png");
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/RenderingTestData/output.png");
}
- //### Usage of vtkRegressionTestImage:
- //vtkRegressionTestImage( vtkRenderWindow )
- //Set a vtkRenderWindow containing the desired scene.
- //vtkRegressionTestImage automatically searches in argc and argv[]
- //for a path a valid image with -V. If the test failed with the
- //first image (foo.png) check if there are images of the form
- //foo_N.png (where N=1,2,3...) and compare against them.
- renderingHelper.PrepareRender();
- int retVal = vtkRegressionTestImage( renderingHelper.GetVtkRenderWindow() );
-
- //retVal meanings: (see VTK/Rendering/vtkTesting.h)
- //0 = test failed
- //1 = test passed
- //2 = test not run
- //3 = something with vtkInteraction
- MITK_TEST_CONDITION( retVal == 1, "VTK test result positive" );
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkSurfaceVtkMapper3DTexturedSphereTest.cpp b/Core/Code/Testing/mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
index 2fd221aadc..ea862bc4f1 100644
--- a/Core/Code/Testing/mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
+++ b/Core/Code/Testing/mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
@@ -1,114 +1,90 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include "mitkTestingMacros.h"
#include "mitkRenderingTestHelper.h"
#include <mitkNodePredicateDataType.h>
#include <mitkSmartPointerProperty.h>
#include <mitkSurface.h>
//VTK
#include <vtkRegressionTestImage.h>
#include <vtkFloatArray.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <mitkIOUtil.h>
#include <vtkSphereSource.h>
#include <vtkTextureMapToSphere.h>
/**
* @brief mitkSurfaceVtkMapper3DTexturedSphereTest This test puts a texture onto a sphere. It is a nice example how to use VTK methods to generate texture coordinates for MITK surfaces.
* @param argv Just any image serving as texture.
*/
int mitkSurfaceVtkMapper3DTexturedSphereTest(int argc, char* argv[])
{
// load all arguments into a datastorage, take last argument as reference rendering
// setup a renderwindow of fixed size X*Y
// render the datastorage
// compare rendering to reference image
MITK_TEST_BEGIN("mitkSurfaceVtkMapper3DTexturedSphereTest")
- // enough parameters?
- if ( argc < 2 )
- {
- MITK_TEST_OUTPUT( << "Usage: " << std::string(*argv) << " [file1 file2 ...] outputfile" )
- MITK_TEST_OUTPUT( << "Will render a central axial slice of all given files into outputfile" )
- exit( EXIT_SUCCESS );
- }
-
- mitkRenderingTestHelper renderingHelper(640, 480, argc, argv);
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
//This is a test for a 3D surface, thus we need to set the mapper ID to 3D
renderingHelper.SetMapperID(mitk::BaseRenderer::Standard3D);
//######## Exmaple code begin ########
//Generate a sphere in order to map texture on it
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetThetaResolution(12);
sphere->SetPhiResolution(12);
sphere->SetRadius(50.0); //just to make it huge
sphere->SetCenter(50,0,0); //just to center the sphere in the screen
//taken from VTK example: http://www.vtk.org/Wiki/VTK/Examples/Python/Visualization/SphereTexture
vtkSmartPointer<vtkTextureMapToSphere> mapToSphere = vtkSmartPointer<vtkTextureMapToSphere>::New();
mapToSphere->SetInputConnection(sphere->GetOutputPort());
mapToSphere->PreventSeamOn();
//get the texture image from the helper's data storage
mitk::Image::Pointer textureImage = static_cast< mitk::Image* > ( renderingHelper.GetDataStorage()->GetNode( mitk::NodePredicateDataType::New("Image"))->GetData() );
//Generate MITK surface
mitk::Surface::Pointer surfaceToPutTextureOn = mitk::Surface::New();
surfaceToPutTextureOn->SetVtkPolyData(static_cast<vtkPolyData*>(mapToSphere->GetOutput()));
//Generate a node
mitk::DataNode::Pointer surfaceNode = mitk::DataNode::New();
surfaceNode->SetData( surfaceToPutTextureOn );
//Make a Property and add to the node
mitk::SmartPointerProperty::Pointer textureProperty = mitk::SmartPointerProperty::New(textureImage);
surfaceNode->SetProperty("Surface.Texture", textureProperty);
//add to data storage
renderingHelper.AddNodeToStorage(surfaceNode);
//######## Exmaple code end ########
- renderingHelper.Render();
-
//use this to generate a reference screenshot or save the file:
bool generateReferenceScreenshot = false;
if(generateReferenceScreenshot)
{
- renderingHelper.SaveAsPNG("/home/kilgus/Pictures/RenderingTestData/output.png");
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/RenderingTestData/output.png");
}
- //### Usage of vtkRegressionTestImage:
- //vtkRegressionTestImage( vtkRenderWindow )
- //Set a vtkRenderWindow containing the desired scene.
- //vtkRegressionTestImage automatically searches in argc and argv[]
- //for a path a valid image with -V. If the test failed with the
- //first image (foo.png) check if there are images of the form
- //foo_N.png (where N=1,2,3...) and compare against them.
- renderingHelper.PrepareRender();
- int retVal = vtkRegressionTestImage( renderingHelper.GetVtkRenderWindow() );
-
- //retVal meanings: (see VTK/Rendering/vtkTesting.h)
- //0 = test failed
- //1 = test passed
- //2 = test not run
- //3 = something with vtkInteraction
- MITK_TEST_CONDITION( retVal == 1, "VTK test result positive" );
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv, 50.0) == true, "CompareRenderWindowAgainstReference test result positive?" );
MITK_TEST_END();
}
diff --git a/Core/Code/Testing/mitkTimeSlicedGeometryTest.cpp b/Core/Code/Testing/mitkTimeSlicedGeometryTest.cpp
index 2c619ab331..c51954516e 100644
--- a/Core/Code/Testing/mitkTimeSlicedGeometryTest.cpp
+++ b/Core/Code/Testing/mitkTimeSlicedGeometryTest.cpp
@@ -1,453 +1,453 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImage.h"
#include "mitkPlaneGeometry.h"
#include "mitkTimeSlicedGeometry.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkGeometry2D.h"
#include "mitkTestingMacros.h"
#include <vnl/vnl_quaternion.h>
#include <vnl/vnl_quaternion.txx>
#include <fstream>
void mitkTimeSlicedGeometry_ChangeImageGeometryConsideringOriginOffset_Test()
{
// additional tests to check the function ChangeImageGeometryConsideringOriginOffset(..)
//first create a new timeslicedgeometry
mitk::TimeSlicedGeometry::Pointer geoTime = mitk::TimeSlicedGeometry::New();
mitk::Geometry3D::Pointer geo3d = mitk::Geometry3D::New();
geo3d->Initialize();
int numOfTimeSteps = 5;
geoTime->InitializeEvenlyTimed(geo3d, numOfTimeSteps);
for (int i=0; i < numOfTimeSteps; i++)
{
mitk::Geometry3D::Pointer geo3d_sub = mitk::Geometry3D::New();
geo3d_sub->Initialize();
geoTime->SetGeometry3D(geo3d_sub, i);
}
MITK_TEST_OUTPUT( << "Testing whether geoTime->GetImageGeometry() is false by default");
MITK_TEST_CONDITION_REQUIRED( geoTime->GetImageGeometry()==false, "");
MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the geoTime have GetImageGeometry()==false by default");
mitk::Geometry3D* subSliceGeo3D_first = geoTime->GetGeometry3D(0);
mitk::Geometry3D* subSliceGeo3D_last = geoTime->GetGeometry3D(numOfTimeSteps-1);
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetImageGeometry()==false, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetImageGeometry()==false, "");
// Save some Origins and cornerpoints
mitk::Point3D OriginTimeGeo( geoTime->GetOrigin() );
mitk::Point3D OriginFirstGeo( subSliceGeo3D_first->GetOrigin() );
mitk::Point3D OriginLastGeo( subSliceGeo3D_last->GetOrigin() );
mitk::Point3D CornerPoint0TimeGeo(geoTime->GetCornerPoint(0));
mitk::Point3D CornerPoint1FirstGeo(subSliceGeo3D_first->GetCornerPoint(1));
mitk::Point3D CornerPoint2LastGeo(subSliceGeo3D_last->GetCornerPoint(2));
//std::cout << "vorher Origin: " << subSliceGeo3D_first->GetOrigin() << std::endl;
//std::cout << "vorher Corner: " << subSliceGeo3D_first->GetCornerPoint(0) << std::endl;
MITK_TEST_OUTPUT( << "Calling geoTime->ChangeImageGeometryConsideringOriginOffset(true)");
geoTime->ChangeImageGeometryConsideringOriginOffset(true);
//std::cout << "nachher Origin: " << subSliceGeo3D_first->GetOrigin() << std::endl;
//std::cout << "nachher Corner: " << subSliceGeo3D_first->GetCornerPoint(0) << std::endl;
MITK_TEST_OUTPUT( << "Testing whether geoTime->GetImageGeometry() is now true");
MITK_TEST_CONDITION_REQUIRED( geoTime->GetImageGeometry()==true, "");
MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the SlicedGeometry3D have GetImageGeometry()==true now");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetImageGeometry()==true, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetImageGeometry()==true, "");
MITK_TEST_OUTPUT( << "Testing wether offset has been added to origins");
// Manually adding Offset.
OriginTimeGeo[0] += (geoTime->GetSpacing()[0]) / 2;
OriginTimeGeo[1] += (geoTime->GetSpacing()[1]) / 2;
OriginTimeGeo[2] += (geoTime->GetSpacing()[2]) / 2;
OriginFirstGeo[0] += (subSliceGeo3D_first->GetSpacing()[0]) / 2;
OriginFirstGeo[1] += (subSliceGeo3D_first->GetSpacing()[1]) / 2;
OriginFirstGeo[2] += (subSliceGeo3D_first->GetSpacing()[2]) / 2;
OriginLastGeo[0] += (subSliceGeo3D_last->GetSpacing()[0]) / 2;
OriginLastGeo[1] += (subSliceGeo3D_last->GetSpacing()[1]) / 2;
OriginLastGeo[2] += (subSliceGeo3D_last->GetSpacing()[2]) / 2;
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetCornerPoint(1)==CornerPoint1FirstGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetCornerPoint(2)==CornerPoint2LastGeo, "");
MITK_TEST_CONDITION_REQUIRED( geoTime->GetCornerPoint(0)==CornerPoint0TimeGeo, "");
MITK_TEST_CONDITION_REQUIRED( geoTime->GetOrigin()==OriginTimeGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetOrigin()==OriginFirstGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetOrigin()==OriginLastGeo, "");
MITK_TEST_OUTPUT( << "Calling geoTime->ChangeImageGeometryConsideringOriginOffset(false)");
geoTime->ChangeImageGeometryConsideringOriginOffset(false);
MITK_TEST_OUTPUT( << "Testing whether geoTime->GetImageGeometry() is now false");
MITK_TEST_CONDITION_REQUIRED( geoTime->GetImageGeometry()==false, "");
MITK_TEST_OUTPUT( << "Testing whether first and last geometry in the geoTime have GetImageGeometry()==false now");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetImageGeometry()==false, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetImageGeometry()==false, "");
MITK_TEST_OUTPUT( << "Testing wether offset has been added to origins");
// Manually substracting Offset.
OriginTimeGeo[0] -= (geoTime->GetSpacing()[0]) / 2;
OriginTimeGeo[1] -= (geoTime->GetSpacing()[1]) / 2;
OriginTimeGeo[2] -= (geoTime->GetSpacing()[2]) / 2;
OriginFirstGeo[0] -= (subSliceGeo3D_first->GetSpacing()[0]) / 2;
OriginFirstGeo[1] -= (subSliceGeo3D_first->GetSpacing()[1]) / 2;
OriginFirstGeo[2] -= (subSliceGeo3D_first->GetSpacing()[2]) / 2;
OriginLastGeo[0] -= (subSliceGeo3D_last->GetSpacing()[0]) / 2;
OriginLastGeo[1] -= (subSliceGeo3D_last->GetSpacing()[1]) / 2;
OriginLastGeo[2] -= (subSliceGeo3D_last->GetSpacing()[2]) / 2;
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetCornerPoint(1)==CornerPoint1FirstGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetCornerPoint(2)==CornerPoint2LastGeo, "");
MITK_TEST_CONDITION_REQUIRED( geoTime->GetCornerPoint(0)==CornerPoint0TimeGeo, "");
MITK_TEST_CONDITION_REQUIRED( geoTime->GetOrigin()==OriginTimeGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_first->GetOrigin()==OriginFirstGeo, "");
MITK_TEST_CONDITION_REQUIRED( subSliceGeo3D_last->GetOrigin()==OriginLastGeo, "");
}
int mitkTimeSlicedGeometryTest(int /*argc*/, char* /*argv*/[])
{
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
mitk::ScalarType width, height;
mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
width = 100; widthInMM = width*0.5;
height = 200; heightInMM = height*1.2;
thicknessInMM = 1.5;
mitk::FillVector3D(origin, 2.5, -3.3, 17.2);
mitk::FillVector3D(right, widthInMM, 0, 0);
mitk::FillVector3D(bottom, 0, heightInMM, 0);
mitk::FillVector3D(normal, 0, 0, thicknessInMM);
std::cout << "Creating TimeSlicedGeometry" <<std::endl;
mitk::TimeSlicedGeometry::Pointer timeSlicedGeometry = mitk::TimeSlicedGeometry::New();
if(timeSlicedGeometry.IsNull())
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
unsigned int numOfTimeSteps = 5;
std::cout << "Testing TimeSlicedGeometry::Initialize(timesteps = " << numOfTimeSteps << "): " <<std::endl;
timeSlicedGeometry->InitializeEvenlyTimed(numOfTimeSteps);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::GetTimeSteps()==" << numOfTimeSteps << ": " <<std::endl;
if(timeSlicedGeometry->GetTimeSteps()!=numOfTimeSteps)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::GetEvenlyTimed(): " <<std::endl;
if(timeSlicedGeometry->GetEvenlyTimed()!=true)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
mitk::TimeBounds timeBounds1;
timeBounds1[0] = 1.3;
timeBounds1[1] = 2.4;
std::cout << "Initializing a PlaneGeometry by InitializeStandardPlane(rightVector, downVector, spacing = NULL): "<<std::endl;
- planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector());
+ planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector());
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Setting TimeBounds of PlaneGeometry by SetTimeBounds(): "<<std::endl;
planegeometry->SetTimeBounds(timeBounds1);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing PlaneGeometry::GetTimeBounds(): "<<std::endl;
if(planegeometry->GetTimeBounds() != timeBounds1)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
--numOfTimeSteps;
std::cout << "Testing TimeSlicedGeometry::InitializeEvenlyTimed(planegeometry, timesteps = " << numOfTimeSteps << "): " <<std::endl;
mitk::TimeSlicedGeometry::Pointer timeSlicedGeometry2 = mitk::TimeSlicedGeometry::New();
timeSlicedGeometry2->InitializeEvenlyTimed(planegeometry, numOfTimeSteps);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::GetTimeSteps()==" << numOfTimeSteps << ": " <<std::endl;
if(timeSlicedGeometry2->GetTimeSteps() != numOfTimeSteps)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::GetEvenlyTimed(): " <<std::endl;
if(timeSlicedGeometry2->GetEvenlyTimed()!=true)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::TimeStepToMS(): " << std::endl;
if(fabs(timeSlicedGeometry2->TimeStepToMS( 2 ) - 3.5) > mitk::eps)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::MSToTimeStep(): " << std::endl;
if(timeSlicedGeometry2->MSToTimeStep( 3.6 ) != 2)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::TimeStepToTimeStep(): " << std::endl;
// Re-use timeSlicedGeometry with new time bounds
mitk::TimeBounds timeBounds;
timeBounds[0] = 0.0;
timeBounds[1] = 1.0;
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->Initialize();
geometry->SetTimeBounds( timeBounds );
timeSlicedGeometry->InitializeEvenlyTimed( geometry, numOfTimeSteps+1 );
if(timeSlicedGeometry2->TimeStepToTimeStep( timeSlicedGeometry, 4 ) != 2)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing availability and type (PlaneGeometry) of first geometry in the TimeSlicedGeometry: ";
mitk::PlaneGeometry* accessedplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(timeSlicedGeometry2->GetGeometry3D(0));
if(accessedplanegeometry==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing identity of first geometry to the planegeometry in the TimeSlicedGeometry (should not be cloned): ";
if(accessedplanegeometry != planegeometry.GetPointer())
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing whether the spatial part of the first geometry in the TimeSlicedGeometry is identical to planegeometry by axis comparison and origin: "<<std::endl;
if((mitk::Equal(accessedplanegeometry->GetAxisVector(0), planegeometry->GetAxisVector(0))==false) ||
(mitk::Equal(accessedplanegeometry->GetAxisVector(1), planegeometry->GetAxisVector(1))==false) ||
(mitk::Equal(accessedplanegeometry->GetAxisVector(2), planegeometry->GetAxisVector(2))==false) ||
(mitk::Equal(accessedplanegeometry->GetOrigin(), planegeometry->GetOrigin())==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing timebounds of first geometry: "<<std::endl;
if( timeBounds1 != accessedplanegeometry->GetTimeBounds() )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing availability and type (PlaneGeometry) of second geometry in the TimeSlicedGeometry: ";
mitk::PlaneGeometry* secondplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(timeSlicedGeometry2->GetGeometry3D(1));
if(secondplanegeometry==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing PlaneGeometry::GetTimeBounds(): "<<std::endl;
const mitk::TimeBounds & secondtimebounds = secondplanegeometry->GetTimeBounds();
if( (timeBounds1[1] != secondtimebounds[0]) || (secondtimebounds[1] != secondtimebounds[0] + timeBounds1[1]-timeBounds1[0]) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing whether the spatial part of the second geometry in the TimeSlicedGeometry is identical to planegeometry by axis comparison and origin: "<<std::endl;
if((mitk::Equal(secondplanegeometry->GetAxisVector(0), planegeometry->GetAxisVector(0))==false) ||
(mitk::Equal(secondplanegeometry->GetAxisVector(1), planegeometry->GetAxisVector(1))==false) ||
(mitk::Equal(secondplanegeometry->GetAxisVector(2), planegeometry->GetAxisVector(2))==false) ||
(mitk::Equal(secondplanegeometry->GetOrigin(), planegeometry->GetOrigin())==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
// non-evenly-timed
std::cout << "Creating (new) TimeSlicedGeometry" <<std::endl;
timeSlicedGeometry2 = mitk::TimeSlicedGeometry::New();
if(timeSlicedGeometry2.IsNull())
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
numOfTimeSteps += 7;
std::cout << "Testing TimeSlicedGeometry::InitializeEmpty(timesteps = " << numOfTimeSteps << "): " <<std::endl;
timeSlicedGeometry2->InitializeEmpty(numOfTimeSteps);
std::cout << "Testing TimeSlicedGeometry::GetEvenlyTimed():" <<std::endl;
if(timeSlicedGeometry2->GetEvenlyTimed()!=false)
{
std::cout<<"[FAILED]"<<std::endl; ///\todo additionally test Initialize, default should be non-evenly-timed
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::SetEvenlyTimed(false):" <<std::endl;
timeSlicedGeometry2->SetEvenlyTimed(false);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::GetEvenlyTimed()==false:" <<std::endl;
if(timeSlicedGeometry2->GetEvenlyTimed()!=false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::GetTimeSteps()==" << numOfTimeSteps << ": " <<std::endl;
if(timeSlicedGeometry2->GetTimeSteps() != numOfTimeSteps)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing availability of first geometry in the TimeSlicedGeometry (should not exist): ";
mitk::Geometry3D* accessedgeometry = timeSlicedGeometry2->GetGeometry3D(0);
if(accessedgeometry!=NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::SetGeometry3D(planegeometry, timesteps = 0): " <<std::endl;
timeSlicedGeometry2->SetGeometry3D(planegeometry, 0);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing availability and type (PlaneGeometry) of first geometry in the TimeSlicedGeometry: ";
accessedplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(timeSlicedGeometry2->GetGeometry3D(0));
if(accessedplanegeometry==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing identity of first geometry to the planegeometry in the TimeSlicedGeometry: ";
if(accessedplanegeometry != planegeometry.GetPointer())
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing availability of second geometry in the TimeSlicedGeometry (should not exist): ";
accessedgeometry = timeSlicedGeometry2->GetGeometry3D(1);
if(accessedgeometry!=NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Setting planegeometry2 to a cloned version of planegeometry: "<<std::endl;
mitk::PlaneGeometry::Pointer planegeometry2;
planegeometry2 = dynamic_cast<mitk::PlaneGeometry*>(planegeometry->Clone().GetPointer());;
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Changing timebounds of planegeometry2: "<<std::endl;
mitk::TimeBounds timeBounds3;
timeBounds3[0] = timeBounds[1];
timeBounds3[1] = timeBounds3[0]+13.2334;
planegeometry2->SetTimeBounds(timeBounds3);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing TimeSlicedGeometry::SetGeometry3D(planegeometry2, timesteps = 1): " <<std::endl;
timeSlicedGeometry2->SetGeometry3D(planegeometry2, 1);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing availability and type (PlaneGeometry) of second geometry in the TimeSlicedGeometry: ";
accessedplanegeometry = dynamic_cast<mitk::PlaneGeometry*>(timeSlicedGeometry2->GetGeometry3D(1));
if(accessedplanegeometry==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing identity of second geometry to the planegeometry2 in the TimeSlicedGeometry: ";
if(accessedplanegeometry != planegeometry2.GetPointer())
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing timebounds of second geometry: "<<std::endl;
if( timeBounds3 != accessedplanegeometry->GetTimeBounds() )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
// run additional tests to check the function ChangeImageGeometryConsideringOriginOffset(..)
mitkTimeSlicedGeometry_ChangeImageGeometryConsideringOriginOffset_Test();
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}
diff --git a/Core/Code/Testing/mitkVectorTest.cpp b/Core/Code/Testing/mitkVectorTest.cpp
index 5718a58413..f5ed207d5c 100644
--- a/Core/Code/Testing/mitkVectorTest.cpp
+++ b/Core/Code/Testing/mitkVectorTest.cpp
@@ -1,125 +1,137 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkVector.h>
int mitkVectorTest(int /*argc*/, char* /*argv*/[])
{
MITK_TEST_BEGIN("mitkVector");
// test itk vector equality methods
itk::Vector<float,3> itkVector_1;
itkVector_1[0] = 4.6;
itkVector_1[1] = 9.76543;
itkVector_1[2] = 746.09;
itk::Vector<float,3> itkVector_2;
itk::Vector<float,3> itkVector_3;
for (int i=0; i<3; i++)
{
itkVector_2[i] = itkVector_1[i] - mitk::eps*1.1;
itkVector_3[i] = itkVector_1[i] - mitk::eps*0.9;
}
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(itkVector_1,itkVector_1), "Test vector equality using the same vector with mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(!mitk::Equal(itkVector_1,itkVector_2), "Test vector equality using different vectors with an element-wise difference greater than mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(itkVector_1,itkVector_3), "Test vector equality using different vectors with an element-wise difference less than mitk::eps");
+ MITK_TEST_CONDITION(mitk::Equal(itkVector_1,itkVector_1), "Test vector equality using the same vector with mitk::eps");
+ MITK_TEST_CONDITION(!mitk::Equal(itkVector_1,itkVector_2), "Test vector equality using different vectors with an element-wise difference greater than mitk::eps");
+ MITK_TEST_CONDITION( mitk::Equal(itkVector_1, itkVector_2, mitk::eps*1.2f), "Vectors are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
+ MITK_TEST_CONDITION(mitk::Equal(itkVector_1,itkVector_3), "Test vector equality using different vectors with an element-wise difference less than mitk::eps");
// test itk point equality methods
itk::Point<float,3> itkPoint_1;
itk::Point<float,3> itkPoint_2;
itk::Point<float,3> itkPoint_3;
for (int i=0; i<3; i++)
{
itkPoint_1[i] = itkVector_1[i];
itkPoint_2[i] = itkVector_2[i];
itkPoint_3[i] = itkVector_3[i];
}
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(itkPoint_1,itkPoint_1), "Test point equality using the same point with mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(!mitk::Equal(itkPoint_1,itkPoint_2), "Test point equality using different points with an element-wise difference greater than mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(itkPoint_1,itkPoint_3), "Test point equality using different points with an element-wise difference less than mitk::eps");
+ MITK_TEST_CONDITION(mitk::Equal(itkPoint_1,itkPoint_1), "Test point equality using the same point with mitk::eps");
+ MITK_TEST_CONDITION(!mitk::Equal(itkPoint_1,itkPoint_2), "Test point equality using different points with an element-wise difference greater than mitk::eps");
+ MITK_TEST_CONDITION( mitk::Equal(itkPoint_1, itkPoint_2, mitk::eps * 1.2f), "Points are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
+ MITK_TEST_CONDITION(mitk::Equal(itkPoint_1,itkPoint_3), "Test point equality using different points with an element-wise difference less than mitk::eps");
// test mitk vnl vector equality methods
mitk::VnlVector mitk_vnl_vector_1(3);
mitk::VnlVector mitk_vnl_vector_2(3);
mitk::VnlVector mitk_vnl_vector_3(3);
for (int i=0; i<3; i++)
{
mitk_vnl_vector_1.put(i,itkVector_1[i]);
mitk_vnl_vector_2.put(i,itkVector_2[i]);
mitk_vnl_vector_3.put(i,itkVector_1[i]);
}
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_1), "Test mitk vnl vector equality using the same mitk vnl vector with mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(!mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_2), "Test mitk vnl vector equality using different mitk vnl vectors with an element-wise difference greater than mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_3), "Test mitk vnl vector equality using different mitk vnl vectors with an element-wise difference less than mitk::eps");
+
+ MITK_TEST_CONDITION(mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_1), "Test mitk vnl vector equality using the same mitk vnl vector with mitk::eps");
+ MITK_TEST_CONDITION(!mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_2), "Test mitk vnl vector equality using different mitk vnl vectors with an element-wise difference greater than mitk::eps");
+ MITK_TEST_CONDITION( mitk::Equal(mitk_vnl_vector_1, mitk_vnl_vector_2, mitk::eps*1.2), "Vnl vectors are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
+ MITK_TEST_CONDITION(mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_3), "Test mitk vnl vector equality using different mitk vnl vectors with an element-wise difference less than mitk::eps");
+
// test vnl_vector equality method
- vnl_vector_fixed<mitk::ScalarType,7> vnlVector_1;
+ typedef mitk::ScalarType VnlValueType;
+ vnl_vector_fixed<VnlValueType,7> vnlVector_1;
vnlVector_1[3] = 56.98;
vnlVector_1[4] = 22.32;
vnlVector_1[5] = 1.00;
- vnlVector_1[6] = 119.02;
- vnl_vector_fixed<mitk::ScalarType,7> vnlVector_2;
- vnl_vector_fixed<mitk::ScalarType,7> vnlVector_3;
+ vnlVector_1[6] = 746.09;
+ vnl_vector_fixed<VnlValueType,7> vnlVector_2;
+ vnl_vector_fixed<VnlValueType,7> vnlVector_3;
for (int i=0; i<7; i++)
{
if (i<3)
{
vnlVector_1.put(i,itkVector_1[i]);
}
- vnlVector_2[i] = vnlVector_1[i]- sqrt(mitk::eps/6.9);
- vnlVector_3[i] = vnlVector_1[i]- sqrt(mitk::eps/7.1);
+
+ vnlVector_2[i] = vnlVector_1[i] - mitk::eps * 1.1f;
+ vnlVector_3[i] = vnlVector_1[i] - mitk::eps * 0.9f;
}
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(vnlVector_1,vnlVector_1), "Test vnl vector equality using the same vnl vector with mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(!mitk::Equal(vnlVector_1,vnlVector_2), "Test vnl vector equality using different vnl vectors with an element-wise difference greater than mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(vnlVector_1,vnlVector_3), "Test vnl vector equality using different vnl vectors with an element-wise difference less than mitk::eps");
+
+ MITK_TEST_CONDITION( (mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_1)), "vnl_fixed : v_1 == v_1 ");
+ // the v_2 is constructed so that the equality test fails for mitk::eps, the norm of the difference between the vectors is 7 * eps/6.9
+ MITK_TEST_CONDITION(!(mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_2)), "vnl_fixed : v_1 != v_2 with mitk::eps ");
+ // increase the epsilon value used for testing equality - should now pass ( 1.2 * mitk::eps > 7 * mitk::eps/6.9 )
+ MITK_TEST_CONDITION( (mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_2, mitk::eps*1.2f)) , "vnl_fixed : v_1 == v_2 with eps = 1.2 * mitk::eps ");
+ MITK_TEST_CONDITION( (mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_3, mitk::eps)), "vnl_fixed : v_1 == v_3 with eps = 0.8 * mitk::eps ");
+ MITK_TEST_CONDITION(!(mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_3, mitk::eps*0.8f)), "vnl_fixed : v_1 != v_3 with eps = 0.8 * mitk::eps ");
// test scalar equality method
double scalar1 = 0.5689;
double scalar2 = scalar1 + mitk::eps;
double scalar3 = scalar1 + mitk::eps*0.95;
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(scalar1,scalar1), "Test scalar equality using the same scalar with mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(!mitk::Equal(scalar1,scalar2), "Test scalar equality using the different scalars with a difference greater than mitk::eps");
- MITK_TEST_CONDITION_REQUIRED(mitk::Equal(scalar1,scalar3), "Test scalar equality using the different scalars with a difference less than mitk::eps");
+ MITK_TEST_CONDITION(mitk::Equal(scalar1,scalar1), "Test scalar equality using the same scalar with mitk::eps");
+ MITK_TEST_CONDITION(!mitk::Equal(scalar1,scalar2), "Test scalar equality using the different scalars with a difference greater than mitk::eps");
+ MITK_TEST_CONDITION(mitk::Equal(scalar1,scalar3), "Test scalar equality using the different scalars with a difference less than mitk::eps");
// test matrix equality methods
vnl_matrix_fixed<mitk::ScalarType,3,3> vnlMatrix3x3_1;
vnlMatrix3x3_1(0,0) = 1.1;
vnlMatrix3x3_1(0,1) = 0.4;
vnlMatrix3x3_1(0,2) = 5.3;
vnlMatrix3x3_1(1,0) = 2.7;
vnlMatrix3x3_1(1,1) = 3578.56418;
vnlMatrix3x3_1(1,2) = 123.56;
vnlMatrix3x3_1(2,0) = 546.89;
vnlMatrix3x3_1(2,1) = 0.0001;
vnlMatrix3x3_1(2,2) = 1.0;
vnl_matrix_fixed<mitk::ScalarType,3,3> vnlMatrix3x3_2;
vnlMatrix3x3_2(0,0) = 1.1000009;
vnlMatrix3x3_2(0,1) = 0.4000009;
vnlMatrix3x3_2(0,2) = 5.3000009;
vnlMatrix3x3_2(1,0) = 2.7000009;
vnlMatrix3x3_2(1,1) = 3578.5641809;
vnlMatrix3x3_2(1,2) = 123.5600009;
vnlMatrix3x3_2(2,0) = 546.8900009;
vnlMatrix3x3_2(2,1) = 0.0001009;
vnlMatrix3x3_2(2,2) = 1.0000009;
mitk::ScalarType epsilon = 0.000001;
- MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_1,0.0),"Test for matrix equality with given epsilon=0.0 and exactly the same matrix elements");
- MITK_TEST_CONDITION_REQUIRED(!mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_2,0.0),"Test for matrix equality with given epsilon=0.0 and slightly different matrix elements");
- MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_2,epsilon),"Test for matrix equality with given epsilon and slightly different matrix elements");
- MITK_TEST_CONDITION_REQUIRED(!mitk::MatrixEqualRMS(vnlMatrix3x3_1,vnlMatrix3x3_2,0.0),"Test for matrix equality with given epsilon=0.0 and slightly different matrix elements");
- MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualRMS(vnlMatrix3x3_1,vnlMatrix3x3_2,epsilon),"Test for matrix equality with given epsilon and slightly different matrix elements");
+ MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_1,0.0),"Test for matrix equality with given epsilon=0.0 and exactly the same matrix elements");
+ MITK_TEST_CONDITION(!mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_2,0.0),"Test for matrix equality with given epsilon=0.0 and slightly different matrix elements");
+ MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_2,epsilon),"Test for matrix equality with given epsilon and slightly different matrix elements");
+ MITK_TEST_CONDITION(!mitk::MatrixEqualRMS(vnlMatrix3x3_1,vnlMatrix3x3_2,0.0),"Test for matrix equality with given epsilon=0.0 and slightly different matrix elements");
+ MITK_TEST_CONDITION(mitk::MatrixEqualRMS(vnlMatrix3x3_1,vnlMatrix3x3_2,epsilon),"Test for matrix equality with given epsilon and slightly different matrix elements");
MITK_TEST_END();
}
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index a962092fd6..68c903a914 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,360 +1,363 @@
set(H_FILES
Algorithms/itkImportMitkImageContainer.h
Algorithms/itkImportMitkImageContainer.txx
Algorithms/itkLocalVariationImageFilter.h
Algorithms/itkLocalVariationImageFilter.txx
Algorithms/itkMITKScalarImageToHistogramGenerator.h
Algorithms/itkMITKScalarImageToHistogramGenerator.txx
Algorithms/itkTotalVariationDenoisingImageFilter.h
Algorithms/itkTotalVariationDenoisingImageFilter.txx
Algorithms/itkTotalVariationSingleIterationImageFilter.h
Algorithms/itkTotalVariationSingleIterationImageFilter.txx
Algorithms/mitkBilateralFilter.h
Algorithms/mitkBilateralFilter.cpp
Algorithms/mitkInstantiateAccessFunctions.h
Algorithms/mitkPixelTypeList.h
# Preprocessor macros taken from Boost
Algorithms/mitkPPArithmeticDec.h
Algorithms/mitkPPArgCount.h
Algorithms/mitkPPCat.h
Algorithms/mitkPPConfig.h
Algorithms/mitkPPControlExprIIf.h
Algorithms/mitkPPControlIf.h
Algorithms/mitkPPControlIIf.h
Algorithms/mitkPPDebugError.h
Algorithms/mitkPPDetailAutoRec.h
Algorithms/mitkPPDetailDMCAutoRec.h
Algorithms/mitkPPExpand.h
Algorithms/mitkPPFacilitiesEmpty.h
Algorithms/mitkPPFacilitiesExpand.h
Algorithms/mitkPPLogicalBool.h
Algorithms/mitkPPRepetitionDetailDMCFor.h
Algorithms/mitkPPRepetitionDetailEDGFor.h
Algorithms/mitkPPRepetitionDetailFor.h
Algorithms/mitkPPRepetitionDetailMSVCFor.h
Algorithms/mitkPPRepetitionFor.h
Algorithms/mitkPPSeqElem.h
Algorithms/mitkPPSeqForEach.h
Algorithms/mitkPPSeqForEachProduct.h
Algorithms/mitkPPSeq.h
Algorithms/mitkPPSeqEnum.h
Algorithms/mitkPPSeqSize.h
Algorithms/mitkPPSeqToTuple.h
Algorithms/mitkPPStringize.h
Algorithms/mitkPPTupleEat.h
Algorithms/mitkPPTupleElem.h
Algorithms/mitkPPTupleRem.h
Algorithms/mitkClippedSurfaceBoundsCalculator.h
Algorithms/mitkExtractSliceFilter.h
Algorithms/mitkConvert2Dto3DImageFilter.h
Algorithms/mitkPlaneClipping.h
Common/mitkExceptionMacro.h
Common/mitkServiceBaseObject.h
Common/mitkTestingMacros.h
DataManagement/mitkImageAccessByItk.h
DataManagement/mitkImageCast.h
DataManagement/mitkImagePixelAccessor.h
DataManagement/mitkImagePixelReadAccessor.h
DataManagement/mitkImagePixelWriteAccessor.h
DataManagement/mitkImageReadAccessor.h
DataManagement/mitkImageWriteAccessor.h
DataManagement/mitkITKImageImport.h
DataManagement/mitkITKImageImport.txx
DataManagement/mitkImageToItk.h
DataManagement/mitkImageToItk.txx
Interactions/mitkEventMapperAddOn.h
Interfaces/mitkIDataNodeReader.h
+ Rendering/mitkLocalStorageHandler.h
+
IO/mitkPixelTypeTraits.h
)
set(CPP_FILES
Algorithms/mitkBaseDataSource.cpp
- Algorithms/mitkBaseProcess.cpp
Algorithms/mitkDataNodeSource.cpp
Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
Algorithms/mitkHistogramGenerator.cpp
Algorithms/mitkImageChannelSelector.cpp
Algorithms/mitkImageSliceSelector.cpp
Algorithms/mitkImageSource.cpp
Algorithms/mitkImageTimeSelector.cpp
Algorithms/mitkImageToImageFilter.cpp
Algorithms/mitkPointSetSource.cpp
Algorithms/mitkPointSetToPointSetFilter.cpp
Algorithms/mitkRGBToRGBACastImageFilter.cpp
Algorithms/mitkSubImageSelector.cpp
Algorithms/mitkSurfaceSource.cpp
Algorithms/mitkSurfaceToSurfaceFilter.cpp
Algorithms/mitkUIDGenerator.cpp
Algorithms/mitkVolumeCalculator.cpp
Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
Algorithms/mitkExtractSliceFilter.cpp
Algorithms/mitkConvert2Dto3DImageFilter.cpp
Controllers/mitkBaseController.cpp
Controllers/mitkCallbackFromGUIThread.cpp
Controllers/mitkCameraController.cpp
Controllers/mitkCameraRotationController.cpp
Controllers/mitkCoreActivator.cpp
Controllers/mitkFocusManager.cpp
Controllers/mitkLimitedLinearUndo.cpp
Controllers/mitkOperationEvent.cpp
Controllers/mitkPlanePositionManager.cpp
Controllers/mitkProgressBar.cpp
Controllers/mitkRenderingManager.cpp
Controllers/mitkSliceNavigationController.cpp
Controllers/mitkSlicesCoordinator.cpp
Controllers/mitkSlicesRotator.cpp
Controllers/mitkSlicesSwiveller.cpp
Controllers/mitkStatusBar.cpp
Controllers/mitkStepper.cpp
Controllers/mitkTestManager.cpp
Controllers/mitkUndoController.cpp
Controllers/mitkVerboseLimitedLinearUndo.cpp
Controllers/mitkVtkInteractorCameraController.cpp
Controllers/mitkVtkLayerController.cpp
DataManagement/mitkAbstractTransformGeometry.cpp
DataManagement/mitkAnnotationProperty.cpp
DataManagement/mitkApplicationCursor.cpp
DataManagement/mitkBaseData.cpp
DataManagement/mitkBaseProperty.cpp
DataManagement/mitkClippingProperty.cpp
DataManagement/mitkChannelDescriptor.cpp
DataManagement/mitkColorProperty.cpp
DataManagement/mitkDataStorage.cpp
#DataManagement/mitkDataTree.cpp
DataManagement/mitkDataNode.cpp
DataManagement/mitkDataNodeFactory.cpp
#DataManagement/mitkDataTreeStorage.cpp
DataManagement/mitkDisplayGeometry.cpp
DataManagement/mitkEnumerationProperty.cpp
DataManagement/mitkGeometry2D.cpp
DataManagement/mitkGeometry2DData.cpp
DataManagement/mitkGeometry3D.cpp
DataManagement/mitkGeometryData.cpp
DataManagement/mitkGroupTagProperty.cpp
DataManagement/mitkImage.cpp
DataManagement/mitkImageAccessorBase.cpp
DataManagement/mitkImageCaster.cpp
DataManagement/mitkImageCastPart1.cpp
DataManagement/mitkImageCastPart2.cpp
DataManagement/mitkImageCastPart3.cpp
DataManagement/mitkImageCastPart4.cpp
DataManagement/mitkImageDataItem.cpp
DataManagement/mitkImageDescriptor.cpp
DataManagement/mitkImageVtkAccessor.cpp
DataManagement/mitkImageStatisticsHolder.cpp
DataManagement/mitkLandmarkBasedCurvedGeometry.cpp
DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
DataManagement/mitkLandmarkProjector.cpp
DataManagement/mitkLevelWindow.cpp
DataManagement/mitkLevelWindowManager.cpp
DataManagement/mitkLevelWindowPreset.cpp
DataManagement/mitkLevelWindowProperty.cpp
DataManagement/mitkLookupTable.cpp
DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
DataManagement/mitkMemoryUtilities.cpp
DataManagement/mitkModalityProperty.cpp
DataManagement/mitkModeOperation.cpp
DataManagement/mitkNodePredicateAnd.cpp
DataManagement/mitkNodePredicateBase.cpp
DataManagement/mitkNodePredicateCompositeBase.cpp
DataManagement/mitkNodePredicateData.cpp
DataManagement/mitkNodePredicateDataType.cpp
DataManagement/mitkNodePredicateDimension.cpp
DataManagement/mitkNodePredicateFirstLevel.cpp
DataManagement/mitkNodePredicateNot.cpp
DataManagement/mitkNodePredicateOr.cpp
DataManagement/mitkNodePredicateProperty.cpp
DataManagement/mitkNodePredicateSource.cpp
DataManagement/mitkPlaneOrientationProperty.cpp
DataManagement/mitkPlaneGeometry.cpp
DataManagement/mitkPlaneOperation.cpp
DataManagement/mitkPointOperation.cpp
DataManagement/mitkPointSet.cpp
DataManagement/mitkProperties.cpp
DataManagement/mitkPropertyList.cpp
DataManagement/mitkRestorePlanePositionOperation.cpp
DataManagement/mitkRotationOperation.cpp
DataManagement/mitkSlicedData.cpp
DataManagement/mitkSlicedGeometry3D.cpp
DataManagement/mitkSmartPointerProperty.cpp
DataManagement/mitkStandaloneDataStorage.cpp
DataManagement/mitkStateTransitionOperation.cpp
DataManagement/mitkStringProperty.cpp
DataManagement/mitkSurface.cpp
DataManagement/mitkSurfaceOperation.cpp
DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
DataManagement/mitkTimeSlicedGeometry.cpp
DataManagement/mitkTransferFunction.cpp
DataManagement/mitkTransferFunctionProperty.cpp
DataManagement/mitkTransferFunctionInitializer.cpp
DataManagement/mitkVector.cpp
DataManagement/mitkVtkInterpolationProperty.cpp
DataManagement/mitkVtkRepresentationProperty.cpp
DataManagement/mitkVtkResliceInterpolationProperty.cpp
DataManagement/mitkVtkScalarModeProperty.cpp
DataManagement/mitkVtkVolumeRenderingProperty.cpp
DataManagement/mitkWeakPointerProperty.cpp
DataManagement/mitkRenderingModeProperty.cpp
DataManagement/mitkShaderProperty.cpp
DataManagement/mitkResliceMethodProperty.cpp
DataManagement/mitkMaterial.cpp
+ DataManagement/mitkPointSetShapeProperty.cpp
Interactions/mitkAction.cpp
Interactions/mitkAffineInteractor.cpp
Interactions/mitkBindDispatcherInteractor.cpp
Interactions/mitkCoordinateSupplier.cpp
Interactions/mitkDataInteractor.cpp
Interactions/mitkDispatcher.cpp
Interactions/mitkDisplayCoordinateOperation.cpp
Interactions/mitkDisplayInteractor.cpp
Interactions/mitkDisplayPositionEvent.cpp
# Interactions/mitkDisplayVectorInteractorLevelWindow.cpp # legacy, prob even now unneeded
# Interactions/mitkDisplayVectorInteractorScroll.cpp
Interactions/mitkEvent.cpp
Interactions/mitkEventConfig.cpp
Interactions/mitkEventDescription.cpp
Interactions/mitkEventFactory.cpp
Interactions/mitkInteractionEventHandler.cpp
Interactions/mitkEventMapper.cpp
Interactions/mitkEventStateMachine.cpp
Interactions/mitkGlobalInteraction.cpp
Interactions/mitkInteractor.cpp
Interactions/mitkInternalEvent.cpp
Interactions/mitkInteractionEvent.cpp
Interactions/mitkInteractionEventConst.cpp
Interactions/mitkInteractionPositionEvent.cpp
Interactions/mitkInteractionKeyEvent.cpp
Interactions/mitkMousePressEvent.cpp
Interactions/mitkMouseMoveEvent.cpp
Interactions/mitkMouseReleaseEvent.cpp
Interactions/mitkMouseWheelEvent.cpp
Interactions/mitkMouseModeSwitcher.cpp
Interactions/mitkMouseMovePointSetInteractor.cpp
Interactions/mitkMoveBaseDataInteractor.cpp
Interactions/mitkNodeDepententPointSetInteractor.cpp
Interactions/mitkPointSetDataInteractor.cpp
Interactions/mitkPointSetInteractor.cpp
Interactions/mitkPositionEvent.cpp
Interactions/mitkPositionTracker.cpp
Interactions/mitkStateMachineAction.cpp
Interactions/mitkStateMachineState.cpp
Interactions/mitkStateMachineTransition.cpp
Interactions/mitkState.cpp
Interactions/mitkStateMachineContainer.cpp
Interactions/mitkStateEvent.cpp
Interactions/mitkStateMachine.cpp
Interactions/mitkStateMachineFactory.cpp
Interactions/mitkTransition.cpp
Interactions/mitkWheelEvent.cpp
Interactions/mitkKeyEvent.cpp
Interactions/mitkVtkEventAdapter.cpp
Interactions/mitkVtkInteractorStyle.cxx
Interactions/mitkCrosshairPositionEvent.cpp
Interfaces/mitkInteractionEventObserver.cpp
Interfaces/mitkIShaderRepository.cpp
IO/mitkBaseDataIOFactory.cpp
IO/mitkCoreDataNodeReader.cpp
IO/mitkDicomSeriesReader.cpp
IO/mitkFileReader.cpp
IO/mitkFileSeriesReader.cpp
IO/mitkFileWriter.cpp
#IO/mitkIpPicGet.c
IO/mitkImageGenerator.cpp
IO/mitkImageWriter.cpp
IO/mitkImageWriterFactory.cpp
IO/mitkItkImageFileIOFactory.cpp
IO/mitkItkImageFileReader.cpp
IO/mitkItkLoggingAdapter.cpp
IO/mitkItkPictureWrite.cpp
IO/mitkIOUtil.cpp
IO/mitkLookupTableProperty.cpp
IO/mitkOperation.cpp
#IO/mitkPicFileIOFactory.cpp
#IO/mitkPicFileReader.cpp
#IO/mitkPicFileWriter.cpp
#IO/mitkPicHelper.cpp
#IO/mitkPicVolumeTimeSeriesIOFactory.cpp
#IO/mitkPicVolumeTimeSeriesReader.cpp
IO/mitkPixelType.cpp
IO/mitkPointSetIOFactory.cpp
IO/mitkPointSetReader.cpp
IO/mitkPointSetWriter.cpp
IO/mitkPointSetWriterFactory.cpp
IO/mitkRawImageFileReader.cpp
IO/mitkStandardFileLocations.cpp
IO/mitkSTLFileIOFactory.cpp
IO/mitkSTLFileReader.cpp
IO/mitkSurfaceVtkWriter.cpp
IO/mitkSurfaceVtkWriterFactory.cpp
IO/mitkVtkLoggingAdapter.cpp
IO/mitkVtiFileIOFactory.cpp
IO/mitkVtiFileReader.cpp
IO/mitkVtkImageIOFactory.cpp
IO/mitkVtkImageReader.cpp
IO/mitkVtkSurfaceIOFactory.cpp
IO/mitkVtkSurfaceReader.cpp
IO/vtkPointSetXMLParser.cpp
IO/mitkLog.cpp
Rendering/mitkBaseRenderer.cpp
Rendering/mitkVtkMapper.cpp
Rendering/mitkRenderWindowFrame.cpp
Rendering/mitkGeometry2DDataMapper2D.cpp
Rendering/mitkGeometry2DDataVtkMapper3D.cpp
Rendering/mitkGLMapper.cpp
Rendering/mitkGradientBackground.cpp
Rendering/mitkManufacturerLogo.cpp
Rendering/mitkMapper.cpp
Rendering/mitkPointSetGLMapper2D.cpp
+ Rendering/mitkPointSetVtkMapper2D.cpp
Rendering/mitkPointSetVtkMapper3D.cpp
Rendering/mitkPolyDataGLMapper2D.cpp
Rendering/mitkSurfaceGLMapper2D.cpp
Rendering/mitkSurfaceVtkMapper3D.cpp
Rendering/mitkVolumeDataVtkMapper3D.cpp
Rendering/mitkVtkPropRenderer.cpp
Rendering/mitkVtkWidgetRendering.cpp
Rendering/vtkMitkRectangleProp.cpp
Rendering/vtkMitkRenderProp.cpp
Rendering/mitkVtkEventProvider.cpp
Rendering/mitkRenderWindow.cpp
Rendering/mitkRenderWindowBase.cpp
Rendering/mitkShaderRepository.cpp
Rendering/mitkImageVtkMapper2D.cpp
Rendering/vtkMitkThickSlicesFilter.cpp
Rendering/vtkMitkLevelWindowFilter.cpp
Rendering/vtkNeverTranslucentTexture.cpp
Rendering/mitkRenderingTestHelper.cpp
Common/mitkException.cpp
Common/mitkCommon.h
Common/mitkCoreObjectFactoryBase.cpp
Common/mitkCoreObjectFactory.cpp
Common/mitkCoreServices.cpp
)
list(APPEND CPP_FILES ${CppMicroServices_SOURCES})
set(RESOURCE_FILES
Interactions/globalConfig.xml
Interactions/DisplayInteraction.xml
Interactions/DisplayConfig.xml
Interactions/DisplayConfigPACS.xml
Interactions/DisplayConfigPACSPan.xml
Interactions/DisplayConfigPACSScroll.xml
Interactions/DisplayConfigPACSZoom.xml
Interactions/DisplayConfigPACSLevelWindow.xml
Interactions/DisplayConfigMITK.xml
Interactions/PointSet.xml
Interactions/Legacy/StateMachine.xml
Interactions/Legacy/DisplayConfigMITKTools.xml
Interactions/PointSetConfig.xml
Shaders/mitkShaderLighting.xml
mitkLevelWindowPresets.xml
)
diff --git a/Core/Documentation/Doxygen/Concepts/DataInteraction.dox b/Core/Documentation/Doxygen/Concepts/DataInteraction.dox
index 6c74c6b905..8d4be67bc1 100644
--- a/Core/Documentation/Doxygen/Concepts/DataInteraction.dox
+++ b/Core/Documentation/Doxygen/Concepts/DataInteraction.dox
@@ -1,204 +1,224 @@
/**
\page DataInteractionPage Interaction Concepts
\tableofcontents
\section InteractionPage_Introduction Introduction to Interaction in MITK
Interaction is a very important task in medical image processing software. Therefore MITK provides a special interaction concept
that provides the developer with an easy way to develop and maintain user interaction separately from the algorithms processing the input.
This allows e.g. for common interaction schemes to be re-used in different contexts.
The core of the interaction concept is based on entities called \b DataInteractors that listen for certain pre-defined events and execute
actions when such an event is triggered.\n
In the following the different components of the interaction concept are explained.
First a a high-level overview about how the different components interact is given, then some parts are explained in more detail.
\subsection FurtherReadingInteraction Topics related to interaction - further information:
See the \ref DataInteractionTechnicalPage page for a more technical explanation. \n
Consult \ref HowToUseDataInteractor for usage information.\n
-See \ref SectionImplementationDataInteractor for an example on how to implement a new DataInteractor \n
+See \ref SectionImplementationDataInteractor for an example on how to implement a new mitk::DataInteractor \n
for information about how to create new events refer to ImplementNewEventsPage.\n
The documentation of the depricated former concept can be found at \ref InteractionPage.
+\n
+For a list of changes with respect to the previous interaction concept please refer to the \ref InteractionMigration
-\section HandlingSection Event Handling & Window Manager Abstraction
+\section HandlingSection Event Handling & GUI Toolkit Abstraction
-The following sequence diagram gives an examplary overview of the process from creating an event until executing an action in the DataInteractor.
-This diagram assumes the usage of the Qt framework, but also shows that the interaction concept itself is implemented independent of any specific window manager.
+The following sequence diagram gives an exemplary overview of the process from creating an event until executing an action in the mitk::DataInteractor.
+This diagram assumes the usage of the Qt framework, but also shows that the interaction concept itself is implemented independent of any specific
+graphical user interface toolkit.
\image html event_handling.png
<ol>
<li>a user event is triggered and send to MITK
- <li>this layler serves as an adapter from window manager (here Qt) events to MITK internal events (later refered to as InteractionEvents).
- <li>once the event is adapted it is send to a Dispatcher, which is linked to a render window, to be handled.
- <li>on Dispatcher level all objects are known that can react to incoming events (DataInteractors)
- <li>a DataInteractor is offered an event and checks its EventConfig object, which returns if a variant if this event has been defined for this DataInteractor.
+ <li>this layer serves as an adapter from the GUI toolkit (here Qt) events to MITK internal events (later referred to as \link mitk::InteractionEvent InteractionEvents\endlink).
+ <li>once the event is adapted it is send to a mitk::Dispatcher, which is linked to a render window, to be handled.
+ <li>on the mitk::Dispatcher level all objects are known that can react to incoming events (mitk::DataInteractor and mitk::InteractionEventObserver instances)
+ <li>a mitk::DataInteractor is offered an event and checks its mitk::EventConfig object, which returns if a variant of this event has been defined for this DataInteractor.
<li>if the DataInteractor has a variant for the event, it consults its state machine to check if the input can be handled in the current state
- <li>the actions asociated with a state change (transition) are executed and the event is successfully handled.
+ <li>the actions associated with a state change (transition) are executed and the event is successfully handled.
</ol>
\section EventPage Events
Events can describe any sort of user input, such as key strokes, mouse clicks or touch gestures.
These events are mapped from an UI framework like Qt to an MITK internal representation
-and send to the Dispatcher which in turn deals with further processing of the event.
-These events are not limited to classical input devices but can be extened at will, by introducing new classes which e.g. describe
+and send to the mitk::Dispatcher which in turn deals with further processing of the event.
+These events are not limited to classical input devices but can be extended at will, by introducing new classes which e.g. describe
events from tracking devices, etc. Refer to \subpage ImplementNewEventsPage to see how new events and thereby input devices can be integrated.
For an overview of available Events see mitk::InteractionEvent, for on overview of parameters see the \subpage DataInteractionTechnicalPage.
\section InteractionEventHandlerSection InteractionEventHandler
-Is the term describing objects in general that can handle events. These objects can be devided into two groups, namely
-DataInteractors and InteractionEventObserver. Their difference is that DataInteractors are linked with a DataNode which they manipulate,
-whereas InteractionEventObserver do not have a DataNode and therefore are not supposed to manipulate any data.
+Is the term describing objects in general that can handle events. These objects can be divided into two groups, namely
+\link mitk::DataInteractor DataInteractors\endlink and mitk::InteractionEventObserver. Their difference is that mitk::DataInteractor instances are
+linked with a mitk::DataNode which they manipulate, whereas mitk::InteractionEventObserver instances do not have a mitk::DataNode and therefore
+are not supposed to manipulate any data.
\dot
digraph linker_deps {
node [shape=record, fontname=Helvetica, fontsize=10];
a [ label="InteractionEventHandler" ];
- d [ label="{StateMachine|HandleEvent()}" ];
- b [ label="{DataInteractor|HandleEvent()}" ];
- c [ label="{InteractionEventObserver|Notify()}" ];
+ d [ label="{EventStateMachine|HandleEvent()}" ];
+ b [ label="{DataInteractor|PerformAction()}" ];
a -> d;
d -> b;
- d -> c;
}
\enddot
\subsection DataInteractorsSection DataInteractors
-DataInteractors are specialized InteractionEventHandler which handle events for one spefific DataNode. They are implemented following a concept called state machines
+DataInteractors are specialized mitk::InteractionEventHandler which handle events for one spefific DataNode. They are implemented following a concept called state machines
(see e.g. <a href="http://en.wikipedia.org/wiki/Mealy_machine"> Wikipedia </a>).
\subsubsection StateMachinesSection StateMachines
-A specific events action is usually desired to dependent on the content of the data object the state of the interaction.
-For example if the when adding a line by clicking with the mouse, the first to clicks are supposed to add a point.
+A specific events action is usually desired to depend on the content of the data object and the state of the interaction.
+For example when adding a line by clicking with the mouse, the first two clicks are supposed to add a point.
But the second click should additionally finish the interaction and a subsequent third click should be ignored.
State machines provide a great way to model such interaction in which the same user interaction can trigger different actions
depending on the current state. Therefore DataInteractors work with so called state machine patterns.
The basic idea here is that each interaction can be described by states
and transitions which in turn trigger actions.
-These patterns define a workflow and different patterns can be applied to the same DataInteractor and cause this DataInteractor
+These patterns define a workflow and different patterns can be applied to the same mitk::DataInteractor and cause this mitk::DataInteractor
to perform different user interactions.
This principle is best described by an example.
-Imagine a DataInteractor with the functionality (1) to add Points at a given mouse position and connect them by a line and (2) check if two
-points are on the same position. Using this DataInteractor, different StateMachine patterns/descriptions
-can be given which each cause the DataInteractor to perform different interaction schemes.
+Imagine a mitk::DataInteractor with the functionality (1) to add Points at a given mouse position and connect them by a line and (2) check if two
+points are on the same position. Using this mitk::DataInteractor, different mitk::StateMachine patterns/descriptions
+can be given which each cause the mitk::DataInteractor to perform different interaction schemes.
<b>State machine pattern 1:
We want the user to draw a line. A simple state machine could express this by three states like this:</b>
\dot
digraph linker_deps {
node [shape=circle, fontname=Helvetica, fontsize=10];
a [ label="NoPoints" ];
b [ label="OnePoint" ];
c [ label="TwoPoints" ];
a -> b [label="MousePress/AddPoint",fontname=Helvetica, fontsize=10];
b -> c [label="MousePress/AddPoint",fontname=Helvetica, fontsize=10];
{ rank=same; a b c }
}
\enddot
With each MousePress event the AddPoint function is called and adds a point at the mouse position, unless two points already exist.
<b>State machine pattern 2:
-The same DataInteractor can also operate after the following state machine, which models the interaction to input a closed contour.
-The DataInteractor can detect an AddPoint event on an already existing point and will trigger a PointsMatch event.</b>
+The same mitk::DataInteractor can also operate after the following state machine, which models the interaction to input a closed contour.
+The mitk::DataInteractor can detect an AddPoint event on an already existing point and will trigger a PointsMatch event.</b>
\dot
digraph {
node [shape=circle, fontname=Helvetica, fontsize=10];
a [ label="StartState" ];
b [ label="ClosedContour"];
a -> a [label="MousePress/AddPoint",fontname=Helvetica, fontsize=10];
a -> b [label="PointsMatch/AddPoint",fontname=Helvetica, fontsize=10];
}
\enddot
In this way state machines provide both, a nice and structured way to represent interaction tasks and description of the interaction which is separated from the code.
One DataInteractor can be re-used for different tasks by simply exchanging the state machine pattern. These patterns are described in XML files.
\subsubsection DefinitionStateMachine Definition of a State Machine
The definition is made up out of three components.
<ul>
<li> States - represent the current status of the interaction
<li> Transitions - describe the events needed to change from one state to another
<li> Actions - are executed, when a transition is taken
</ul>
Each state machine needs exactly one designated start state into which the state machine is set in the beginning.
An example of a state machine describing the interaction of example 2 looks like this:
\code
<statemachine>
<state name="StartState" startstate="true" >
<transition event_class="MousePressEvent" event_variant="MousePress" target="StartState">
<action name="AddPoint"/>
</transition>
<transition event_class="InternalEvent" event_variant="PointsMatch" target="ClosedContour">
<action name="AddPoint"/>
</transition>
</state>
<state name="ClosedContour"/>
</statemachine>
\endcode
<b>Example 1: State machine pattern, that describes adding points to a contour until the PointsMatch event is triggered.</b>
-For a more detailed desciption of state machine patterns see here.
+For a more detailed description of state machine patterns see here.
\subsection InteractionEventObserverSection InteractionEventObserver
-InteractionEventObserver are objects which will receive all user input and are intented for observation only, they should never modify any DataNodes.
-For InteractionEventObserver it is optional to use the state machine functionality, the default is without. How to use the state machine functionality
- is described in the documentation of mitk::InteractionEventObserver::Notify.
-
-\subsection ConfigurationSection Configuration
-In a lot of cases it is preferable to implement interactions independent of a specific event (e.g. left click with mouse), such that is it possible
-to easily change this. This is achieved through configuration of InteractionEventHandlers. This allows to change the behavior at runtime.
-The InteractionEventHandler provides an interface to easily modify the user input that triggers an action by loading a different configuration, this allows to implement
-user-specific behavior of the software on an abstract level and to switch in at runtime.
-This is achieved through XML files describing a configuration. These files can be loaded by the InteractionEventHandler and will lead to an internal mapping
-from specific user input to an absract description of the event given in the config file.
+mitk::InteractionEventObserver instances are objects which will receive all user input and are intended for observation only,
+they should never modify any DataNodes.
+For mitk::InteractionEventObserver it is optional to use the state machine functionality, the default is without. How to use the state machine functionality
+is described in the documentation of mitk::InteractionEventObserver::Notify.
-In order to do this we distinguish between a spefic event and an event variant. A specific event is described by its event class, which determines the
-category of an event, e.g. the class MousePressEvent, and its parameter which make this event unique, e.g. LeftMouseButton pressed and no modifier keys pressed.
-The event variant is a name that is assigned to a spefific event, and to which an InteractionEventHandler listens.
+\dot
+digraph event_observer {
+ node [shape=record, fontname=Helvetica, fontsize=10];
+ c [ label="{InteractionEventObserver|Notify()}" ];
+ a [ label="InteractionEventHandler" ];
+ b [ label="{EventStateMachine|HandleEvent()}" ];
+ d [ label="{MyCustomObserver|PerformAction()}" ];
+ c -> d;
+ a -> b;
+ b -> d [style="dashed",label="optional"];
+}
+\enddot
-To illustrate this, an example is given here for two different configuration files. We assume an InteractionEventHandler that listens to the event variant 'AddPoint',
-two possible config files could then look like this:
+\subsection ConfigurationSection Configuration
+In a lot of cases it is preferable to implement interactions independent of a specific event (e.g. left click with mouse), such that it is possible
+to easily change this. This is achieved through configuration of \link mitk::InteractioinEventHandler InteractionEventHandlers\endlink.
+This allows to change the behavior at runtime.
+The mitk::InteractionEventHandler class provides an interface to easily modify the user input that triggers an action by loading a different
+configuration. This allows to implement
+user-specific behavior of the software on an abstract level and to switch it at runtime.
+This is achieved through XML files describing a configuration. These files can be loaded by the mitk::InteractionEventHandler and will lead to an internal mapping
+from specific user input to an abstract description of the event given in the config file.
+
+In order to do this we distinguish between a specific event and an event variant. A specific event is described by its event class, which determines the
+category of an event, e.g. the class mitk::MousePressEvent, and its parameter which make this event unique, e.g. LeftMouseButton pressed and no modifier keys pressed.
+The event variant is a name that is assigned to a specific event, and to which an mitk::InteractionEventHandler listens.
+
+To illustrate this, an example is given here for two different configuration files. We assume that a mitk::InteractionEventHandler listens to the
+event variant 'AddPoint', two possible config files could then look like this:
\code
<config name="one">
<event_variant name="MousePress" class="MousePressEvent">
<attribute name="EventButton" value="LeftMouseButton"/>
</event_variant>
</config>
\endcode
<b>Example 2: Event description of a left click with the mouse</b>
and
\code
<config name="two">
<event_variant name="MousePress" class="MousePressEvent">
<attribute name="EventButton" value="RightMouseButton"/>
<attribute name="Modifiers" value="shift"/>
</event_variant>
</config>
\endcode
<b>Example 3: Event description of a left click with the mouse while pressing the shift-key</b>
-If the InteractionEventHandler is loaded with the first configuration the event variant 'MousePress' is triggered when the user performs a mouse click,
+If the mitk::InteractionEventHandler is loaded with the first configuration the event variant 'MousePress' is triggered when the user performs a mouse click,
while when the second configuration is loaded 'MousePress' is triggered when the user performs a right click while pressing the shift button.
-In this way all objects derived by InteractionEventHandler can be configured. For a detailed description about how to create the XML file see \ref ConfigurationTechnical .
+In this way all objects derived from mitk::InteractionEventHandler can be configured. For a detailed description about how to create the XML file see the
+\ref DataInteractionTechnicalPage page.
\section DispatcherSection Dispatcher
-This unit receives all events and distributes them to the DataInteractors. This is done by ordering the DataInteractors according to the layer of their
-DataNode in descending order. Then the event is offered to the first DataInteractor, which in turn checks if it can handle the event. This is done
-for each DataInteractor until the first processes the event, after this the other DataInteractors are skipped and all InteractionEventObservers are notified.
+Instances of mitk::Dispatcher receive all events and distribute them to their related mitk::DataInteractor instances. This is done by ordering
+the DataInteractors according to the layer of their
+mitk::DataNode in descending order. Then the event is offered to the first mitk::DataInteractor, which in turn checks if it can handle the event. This is done
+for each mitk::DataInteractor until the first processes the event, after this the other DataInteractors are skipped and all InteractionEventObservers are notified.
*/
diff --git a/Core/Documentation/Doxygen/Concepts/DataInteractionTechnical.dox b/Core/Documentation/Doxygen/Concepts/DataInteractionTechnical.dox
index 45e2f161b5..01447e6b83 100644
--- a/Core/Documentation/Doxygen/Concepts/DataInteractionTechnical.dox
+++ b/Core/Documentation/Doxygen/Concepts/DataInteractionTechnical.dox
@@ -1,116 +1,115 @@
/**
\page DataInteractionTechnicalPage Interaction Concept Implementation
\tableofcontents
This page describes some technicalities of the implementation and the workflow, for a detailed list of tutorials see \ref FurtherReadingInteraction .
\section DataInteractionTechnicalPage_Introduction Description of Interaction Concept Implementation in MITK
\section DispatcherSection Dispatcher
-After an event is received by the Dispatcher it is given to a DataInteractor that has to decide if it can process this event.
+After an event is received by the mitk::Dispatcher it is given to a mitk::DataInteractor that has to decide if it can process this event.
On a high level this is done by the mitk::EventStateMachine.
First the state machine asks if the received event is known in the
-configuration. If it does the matching variant name is returned. Then the state machine checks if there exists a transition
+configuration. If it is, the matching variant name is returned. Then the state machine checks if there exists a transition
in its current state that is triggered by this event variant. If this is the case all actions that are associated with this transition
-are queried and executed. The actions themselves are implemented on DataInteractor level. The following diagram illustrates the process:
+are queried and executed. The actions themselves are implemented on mitk::DataInteractor level. The following diagram illustrates the process:
\image html sm_and_config.png
-Each BaseRenderer creates a mitk::BindDispatcherInteractor object which encapsulates the connection between the DataStorage and the Dispatcher,
-and thereby allowing a DataInteractor to register with a Dispatcher when only knowing the DataNode.
+Each mitk::BaseRenderer creates a mitk::BindDispatcherInteractor object which encapsulates the connection between the mitk::DataStorage and
+the mitk::Dispatcher, and thereby allowing a mitk::DataInteractor to register with a mitk::Dispatcher when only knowing the mitk::DataNode.
-BindDispatcherInteractor creates a new Dispatcher object and registers for DataNode events at the DataStorage, as a callback function the
-Dispatchers AddDataInteractor() and RemoveDataInteractor() functions are set.
+mitk::BindDispatcherInteractor creates a new mitk::Dispatcher object and registers for mitk::DataNode events at the mitk::DataStorage, as a callback function the
+dispatchers AddDataInteractor() and RemoveDataInteractor() functions are set.
\dot
digraph {
node [shape=record, fontname=Helvetica, fontsize=10];
a [ label="{BaseRenderer|m_BindDispatcherInteractor}"];
b [ label="{BindDispatcherInteractor|m_Dispatcher\n m_DataStorage}" ];
c [ label="Dispatcher" ];
d [ label="DataStorage" ];
a -> b;
b -> c;
b -> d;
}
\enddot
-This way the Dispatcher is notified about all changes regarding
-DataNodes that are shown in the BaseRenderer. When a node is added, remove or modified the Dispatcher can check it a DataInterator is set,
-and accordingly add or remove this DataInteractor from its internal list.
+This way the mitk::Dispatcher is notified about all changes regarding
+DataNodes that are shown in the mitk::BaseRenderer. When a node is added, remove or modified the mitk::Dispatcher can check if a mitk::DataInterator is set,
+and accordingly add or remove this mitk::DataInteractor from its internal list.
\dot
digraph {
node [shape=record, fontname=Helvetica, fontsize=10];
d [ label="DataInteractor" ];
a [ label="DataNode" ];
b [ label="DataStorage" ];
c [ label="Dispatcher" ];
e [ label="BaseRenderer"]
edge [fontname=Helvetica, fontsize=10]
d -> a [label="SetDataInteractor(this)"];
a -> b [label="Modified()"];
b -> c [label="NodeModified(dataNode)"];
e -> c [label="HandleEvent(interactionEvent)"];
{ rank=same; b c a }
{ rank=same; e }
}
\enddot
-Events that are generated within the scope of the BaseRenderer are sent to the associated Dispatcher to be handled.
+Events that are generated within the scope of the mitk::BaseRenderer are sent to the associated mitk::Dispatcher to be handled.
\subsection DispatcherEventDistSection Event Distribution
- A Dispatcher can operate in different processing modes, which determine how the interactor that receives an event is chosen.
- These modes are managed and set by the Dispatcher itself.
+ A mitk::Dispatcher can operate in different processing modes, which determine how the interactor that receives an event is chosen.
+ These modes are managed and set by the mitk::Dispatcher itself.
<ul>
<li> \b Regular: \n
DataInteractors are sorted by their layer, and distribution is stared with the top-most.
- <li> \bConnected \b Mouse \b Action:
-
- A connected mouse action is described by the sequence of Mouse-Press, (optionally) Mouse-Move , Mouse-Release Events.\n
- Within this sequence all events are sent to the same DateInteractor, the one which received the event from the Mouse-Press action.\n
+ <li> <b>Connected Mouse Action</b>: \n
+ A connected mouse action is described by the sequence of Mouse-Press, (optionally) Mouse-Move , Mouse-Release Events.\n
+ Within this sequence all events are sent to the same mitk::DataInteractor, the one which received the event from the Mouse-Press action.\n
\b m_ConnectedMouseAction - is set to true, when a Mouse-Down Event occurs and a DataInterator takes the event and
\b m_SelectedInteractor is then set to this DataInteractor.\n
\b m_ConnectedMouseAction is reset to false, after the Mouse-Release Event occurs,\n
while it is true, the m_SelectedInteractor is the only one that receives Mouse-Events.
- <li> \b Grab \b Input:\n
- Whenever a DataInteractor performs a state change into a state that is marked by the grab input-tag, the Dispatcher switches into this mode.
- As long as it is in this mode ONLY the selected DataInteractor will receive the event. This mode is ended when the DataInteractor switches back to
- a state without a tag/ or the REGULAR-tag.\n
- \note In this mode EventObservers will NOT receive the events.
+ <li> <b>Grab Input</b>:\n
+ Whenever a mitk::DataInteractor performs a state change into a state that is marked by the grab input-tag, the mitk::Dispatcher switches into this mode.
+ As long as it is in this mode ONLY the selected mitk::DataInteractor will receive the event. This mode is ended when the mitk::DataInteractor
+ switches back to a state without a tag/ or the REGULAR-tag.\n
+ \note In this mode mitk::InteractionEventObserver instances will NOT receive the events.
<li> \b Prefer \b Input: \n
- Basically works as Grab Input, with the difference that if the Interactor in an prefer input state, cannot process the event offered,
+ Basically works as Grab Input, with the difference that if the mitk::DataInteractor is in the prefer input state but cannot process the event offered,
it will be offered to the other interactors in the regular way.\n
- In this mode EventObservers ARE informed.
+ In this mode mitk::InteractionEventObserver instances ARE informed.
</ul>
\section StateMachineSection State Machine & Configuration
A mitk::EventStateMachine points to a \b state, which in turn references \b transitions
(which describe a change from one state to another) and \b actions (indicating which functions are executed when a transition is taken).
\dot
digraph {
node [shape=record, fontname=Helvetica, fontsize=10];
d [ label="{StateMachine|m_CurrentState}" ];
a [ label="{StateMachineState|m_Transitions}" ];
b [ label="{StateMachineTransitions|m_Actions}"];
c [ label="{StateMachineAction}"];
edge [fontname=Helvetica, fontsize=10]
d -> a [label="1 : 1"];
a -> b [label="1 : n"];
b -> c [label="1 : n"];
}
\enddot
- */
\ No newline at end of file
+ */
diff --git a/Core/Documentation/Doxygen/Concepts/Interaction.dox b/Core/Documentation/Doxygen/Concepts/Interaction.dox
index 4bbd0207fc..7f9d700bd8 100644
--- a/Core/Documentation/Doxygen/Concepts/Interaction.dox
+++ b/Core/Documentation/Doxygen/Concepts/Interaction.dox
@@ -1,124 +1,126 @@
/**
@depricated
\page InteractionPage Interaction and Undo/Redo Concepts
\note The following page refers to the depricated interaction frame work. Please refer to \ref DataInteractionPage for information about the current one.
\section InteractionPage_Introduction Interaction in MITK
\b Interaction is one of the most important tasks in clinically useful image processing software.
Due to that, MITK has a special interaction concept, with which the developer can map the desired interaction.
For a simple change in interaction he doesn't have to change the code. All information about the sequence
of the interaction is stored in an XML-file that is loaded by the application during startup procedure at runtime.
That even allows the storage of different interaction patterns, e.g. an interaction behaviour like in MS PowerPoint,
in Adobe Photoshop or like the interaction behaviour on a medical image retrieval system.
\section InteractionPage_Statemachines_Implementation Statemachines to implement Interaction
The interaction in MITK is implemented with the concept of state machines (by Mealy).
This concept allows to build the steps of interaction with different states, which each have different conditions, very alike the different interactions that may have to be build to develop medical imaging applications.
Furthermore state machines can be implemented using object oriented programming (OOP). Due to that we can abstract from the section of code, that implements the interaction and focus on the sequence of interaction. What steps must the user do first before the program can compute a result? For example he has to declare three points in space first and these points are the input of a filter so only after the definition of the points, the filter can produce a result. The according interaction sequence will inform the filter after the third point is set and not before that. Now the filter after an adaption only needs two points as an input. The sequence of the interaction can be easily changed if it is build up as a sequence of objects and not hard implemented in a e.g. switch/case block. Or the user wants to add a point in the scene with the right mouse button instead of the left. Wouldn't it be nice to only change the definition of an interaction sequence rather than having to search through the code and changing every single if/else condition?
\subsection InteractionPage_Statemachine State Machine
So a separation of the definition of a sequence in interaction and its implementation is a useful step in the development of an
interactive application.
To be able to do that, we implemented the concept of state machines with several classes: States, Transitions and Actions define the interaction pattern. The state machine itself adds the handling of events, that are sent to it.
\image html statemachine.jpg
\subsubsection InteractionPage_ExampleA Example A:
A deterministic Mealy state machine has always one current state (here state 1). If an event 1 is sent to the state machine, it searches in its current state for a transition that waits for event 1 (here transition 1). The state machine finds transition 1, changes the current state to state2, as the transition points to it and executes actions 1 and 2. Now state 2 is the current state. The state machine receives an event 2 and searches for an according transition. Transition 2 waits for event 2, and since the transition leads to state 2 the current state is not changed. Action 3 and 4 are executed. Now Event 3 gets send to the state machine but the state machine can't find an according transition in state 2. Only transition 2 , that waits for event 2 and transition 4, that waits for event 4 are defined in that state. So the state machine ignores the event and doesn't change the state or execute an action. Now the state machine receives an event 4 and finds transition 3. So now the current state changes from state 2 to state 1 and actions 5 and 1 are executed.
Several actions can be defined in one transition. The execution of an action is the active part of the state machine. Here is where the state machine can make changes in data, e.g. add a Point into a list.
See mitk::StateMachine, mitk::State, mitk::Event, mitk::Action, mitk::Transition, mitk::Interactor
\subsection InteractionPage_GuardState Guard States
Guard States are a special kind of states. The action, that is executed after the state is set as current state, sends a new event to the state machine, which leads out of the guard state. So the state machine will only stay in a guard state for a short time. This kind of state is used to check different conditions, e.g. if an Object is picked or whether a set of points will be full after the addition of one point.
\image html statemachine_guard.jpg
\subsubsection InteractionPage_ExampleB Example B:
Event 1 is sent to the state machine. This leads the current state from state 1 into state check. The action 1 is executed. This action checks a condition and puts the result into a new event, that is sent and handled by the same (this) state machine. E.g. is the object picked with the received mouse-coordinate? The event, that is generated, will be Yes or No. In case of event No, the state machine sets the current state back to state 1 and executes action 2. In case of event Yes, the state machine changes the state from state check into state 2 and executes action 3, which e.g. can select said object.
\subsection InteractionPage_XMLDefinitionStatemachine Definition of a State machine
-Due to the separation of the definition of an interaction sequence and its implementation, the definition has to be archived somewhere, where the application can reach it during startup and build up all the objects (states, transitions and actions) that represent the sequence of a special interaction. In MITK, these informations are defined in an XML-file (usually in Core/Code/Interactions/StateMachine.xml and Plugins/org.mitk.gui.qt.application/resources/StateMachine.xml, the duplication is currently needed due to design decisions).
+Due to the separation of the definition of an interaction sequence and its implementation, the definition has to be archived somewhere, where the application can reach it during startup and build up all the objects (states, transitions and actions) that represent the sequence of a special interaction. In MITK, these informations are defined in an XML-file (usually in Core/Code/Resources/Interactions/Legacy/StateMachine.xml)
+\note Please note that since this is a resource which is compiled into the executable, changes you make to this file will only be reflected in application behavior after you recompile your code.
+
The structure is the following (from \ref InteractionPage_ExampleA) :
\code
<stateMachine NAME="statemachine1"><!-- defining a new state machine with its name -->
<state NAME="State1" ID="1" START_STATE="TRUE"><!-- new state tag; start state of the state machine; ID=1 -->
<transition NAME="transition1" NEXT_STATE_ID="2" EVENT_ID="1"><!-- transition, waits for event ID=1 and leads to state 2 -->
<action ID="1" /><!-- action ID = 1 shall be executed -->
<action ID="2" /><!-- action ID = 2 shall be executed -->
</transition><!-- end of transition -->
</state><!-- end of state ID = 1 -->
<state NAME="state2" ID="2">
<transition NAME="transition2" NEXT_STATE_ID="2" EVENT_ID="2">
<action ID="3" />
<action ID="4" />
</transition>
<transition NAME="transition3" NEXT_STATE_ID="1" EVENT_ID="4" >
<action ID="5" />
<action ID="1" />
</transition>
</state>
</stateMachine>
\endcode
The identification numbers (ID) inside a state machine have to be unique. Each state machine has to have one state, that is defined as the start-state of that state machine. This means, initially, the current state of the state machine is the start-state.
The Event-Ids seen above are also defined in the statemachine.xml file. They specify a unique number for a combination of input-conditions (key, mouse and so on). See \ref InteractionPage_InteractionEvents for further informations.
The statemachine is compiled into an application at compile time.
The definition of one single state machine is called the \a statemachine-pattern. Since this pattern is build up during startup with objects (states, transitions and actions) and these objects only hold information about what interaction may be done at the current state, we can also reuse the pattern.
\note You as a developer don't necessarily have to implement your own XML-File! We already have defined some interaction-patterns (e.g. for setting Points in 2D or 3D) which you can use and adapt.
\subsubsection InteractionPage_ReusePattern Reuse of Interaction Patterns
If we for example have a pattern called "pointset", which defines how the user can set different points into the scene and there is an instance of a state machine called "PointSetInteractor". This state machine has a pointer pointing to the current state in its assigned state machine pattern. Several events are send to the state machine, which moves the pointer from one state to the next, according to the transitions, and executes the actions, referenced in the transitions.
But now a new instance of the class "PointSetInteractor" has to be build. So we reuse the pattern and let the current state pointer of the new object point to the start state of the pattern "pointset". The implementation of the actions is \b not done inside a class of the pattern (\a state, \a transition, \a action), it is done inside a state machine class (see the reference for mitkStatemachine).
\subsection InteractionPage_InteractionEvents Events
During runtime, events are thrown from e.g. the mouse to the operating system, are then send to your graphical user interface and from there it has to be send to the MITK-object called \a mitkEventMapper. This class maps the events received with an internal list of all events that can be understood in MITK. The definition of all understandable events is also located in the XML-File the state machines are defined in. If the received event can be found in the list, an internal mitk-eventnumber is added to the event and send to the object \a mitkGlobalInteraction.
See mitk::Event, mitk::GlobalInteraction
\subsection InteractionPage_GlobalInteraction GlobalInteraction
This object administers the transmission of events to registered state machines. There can be two kinds of state machines, the ones that are only listening and ones that also change data. Listening state machines are here called Listeners and state machines that also change data are called Interactors.
\note The discrimination between \a Listener and \a Interactor is only made in mitkGlobalInteraction.
As Listener an object derived from class StateMachine can be added and removed from GlobalInteraction and as Interactor an object derived from class Interactor can be added and removed. See the interaction class diagram for further information.
To add or remove a state machine to the list of registered interactors, call \a AddInteractor or \a RemoveInteractor of \a GlobalInteraction or to add or remove a listener call \a AddListener of \a RemoveListener. Listeners are always provided with the events. Interactors shall only be provided with an event, if they can handle the event. Because of that the method CanHandleEvent is called, which is implemented in each Interactor. This method analyses the event and returns a value between 0 (can't handle event) and 1 (Best choice to handle the event). Information, that can help to calculate this jurisdiction can be the bounding box of the interacted data and the picked mouse-position stored in the event.
So after the object \a GlobalInteraction has received an event, it sends this event to all registered Listeners and then asks all registered Interactors through the method \a CanHandleEvent how good each Interactor can handle this event. The Interactor which can handle the event the best receives the event. Also see the documented code in \a mitkGlobalInteraction.
To not ask all registered interactors on a new event, the class \a Interactor also has a mode, which can be one of the following: deselected, subselected (deprecated since HierarchicalInteraction has been removed), selected. These modes are also used for the event mechanism.
If an interactor is in a state, where the user builds up a graphical object, it is likely that the following events are also for the build of the object. Here the interactor is in mode selected as long as the interactor couldn't handle an event. Then it changes to mode deselected. The mode changes are done in the actions through operations (described further down) and so declared inside the interaction pattern.
See mitk::GlobalInteraction
\subsection InteractionPage_Interactors Interactors
The class \a Interactor is the superclass for all state machines, that solve the interaction for a single data-object.
An example is the class \a mitkPointSetInteractor which handles the interaction of the data \a mitkPointSet. Inside the class \a mitkPointSetInteractor all actions, defined in the interaction-pattern "pointsetinteractor", are implemented. Inside the implementation of these actions (\a ExecuteAction(...) ), so called \a mitkOperations are created, filled with information and send to the \a mitkUndoController and to \a mitkOperactionActor (the data, the interaction is handled for).
See mitk::Interactor
\subsection InteractionPage_ExecOperations Executing Operations
The class mitkOperation and its subclasses basically holds all information needed to execute a certain change of data.
This change of data is only done inside the data-class itself, which is derived from the interface \a mitkOperationActor. Interactors handle the interaction through state-differentiation and combine all informations about the change in a \a mitkOperation and send this operation-object to the method ExecuteOperation (of data-class). Here the necessary data is extracted and then the change of data is performed.
When the operation-object, here called do-operation, is created inside the method \a ExecuteAction (in class \a mitkInteractor), an undo-operation is also created and together with the do-operation stored in an object called \a OperationEvent. After the Interactor has sent the do-operation to the data, the operation-event-object then is sent to the instance of class \a mitkUndoController, which administrates the undo-mechanism.
See mitk::Operation, mitk::OperationActor
\subsection InteractionPage_UndoController UndoController
The instance of class \a mitkUndoController administrates different Undo-Models. Currently implemented is a limited linear Undo.
Only one Undo-Model can be activated at a time. The UndoController sends the received operation events further to the current Undo-Model, which then stores it according to the model. If the method \a Undo() of UndoController is called (e.g. Undo-Button pressed from ) the call is send to the current Undo-Model. Here the undo-operation from the last operation event in list is taken and send to the data, referenced in a pointer which is also stored in the operation-event. A call of the method \a Redo() is handled accordingly.
See mitk::UndoController, mitk::LimitedLinearUndo
\subsection InteractionPage_references References
[Bin99] Robert V. Binder. Testing Object-Oriented Systems: Models, Patterns, and Tools. Addison-Wesley, 1999
*/
diff --git a/Core/Documentation/Doxygen/Concepts/Pipelining.dox b/Core/Documentation/Doxygen/Concepts/Pipelining.dox
index 576fd2bdfb..5b97d384eb 100644
--- a/Core/Documentation/Doxygen/Concepts/Pipelining.dox
+++ b/Core/Documentation/Doxygen/Concepts/Pipelining.dox
@@ -1,94 +1,94 @@
/**
\page PipelineingConceptPage Pipelining Concept
Available Sections:
-# \ref PipelineingConceptPage_Introduction "Introduction to Pipelining"
-# \ref PipelineingConceptPage_InMITK "Pipelining in MITK"
-# \ref PipelineingConceptPage_Update "The Update() Mechanism"
-# \ref PipelineingConceptPage_Hierarchy "Pipeline Hierarchy"
-# \ref PipelineingConceptPage_WorkWith "Working with Filter"
-# \ref PipelineingConceptPage_Setup "Setting Up a Pipeline"
-# \ref PipelineingConceptPage_Implement "Writing your own Filter"
\section PipelineingConceptPage_Introduction Introduction to Pipelining
Image processing in MITK draws heavily from the pipelining concept, and a clear understaning of it is crucial when developing with MITK. This document will first clarify the general idea behind pipelining and then discuss some MITK specifics that you should know about.
In the real world, a pipeline connects a source of some kind with a consumer of another. So we identify three key concepts:
1. The source, which generates data of some kind.
-2. The pipeline, which transports the data. Many different pipeline segements can be switched in line to achieve this.
+2. The pipeline, which transports the data. Many different pipeline segments can be switched in line to achieve this.
3. The consumer, which uses the data to do something of interest.
The analogy to real pipelines falls a little short in one point: A physical pipeline would never process it's contents, while in software development a pipeline usually does (this is why they are often dubbed filters as well). One might ask why one shouldn't just implement the processing logic in the consumer onject itself, since it onviously knows best what to do with it's data. The two main reasons for this are reusability and flexibility. Say, one wants to display a bone segmentation from a CT-image. Let's also assume for the sake of this introduction, that this is a simple task. One could build a monolithic class that solves the problem. Or one builds a pipeline between the displaying class and the source. We know that bones are very bright in a CT Scan, so we use a treshold filter, and then a segmentation Filter to solve the problem.
\image html pipelining_example_ct.png
Now let's further assume that after successfully selling this new technology to a large firm, we plan to do the same with ultrasound imaging technology. The brithness relations in Ultrasound images are basically the same, but ultrasound images are very noisy, and the contrast is significantly lower. Since we used pipelining, this is no problem: We don't need to change our old segmentation class - we just plug two new filters in front of the pipeline:
\image html pipelining_example_us.png
This may seem trivial, but when working with several input streams from many different devices that themselves stem from many different vendors, pipelining can save the day when it comes to broad range support of different specifications.
\section PipelineingConceptPage_InMITK Pipelining in MITK
\subsection PipelineingConceptPage_Update The Update() Mechanism
The flow of data inside a pipeline is triggered by only one function call to the consumer, which is Update(). Each part of the pipeline then triggers the Update() method of it's antecessor. Finally, the source creates a new batch of data using it's own GenerateData() method, and notifies its successor that new data is available. The pipeline can then start to process the data until the finished data batch is available as an output of the last Filter.
\image html pipelining_update.png
\subsection PipelineingConceptPage_Hierarchy The Pipeline Hierarchy
Tha base class for all parts of the pipeline except the consumer (which can be of any class) is mitk::Baseprocess. This class introduces the ability to process data, has an output and may have an input as well. You will however rarly work with this class directly.
\image html pipelining_hierarchy.png
Several source classes extend BaseProcess. Depending on the type of data they deliver, these are ImageSource, PointSetSource and SurfaceSource. All of these mark the start of a pipeline.
The filters themselves extend one of the source classes. This may not immediately make sense, but remember that a filter basically is a source with an additional input.
\section PipelineingConceptPage_WorkWith Working with Filter
\subsection PipelineingConceptPage_Setup Setting Up a Pipeline
\verbatim
// Create Participants
mitk::USVideoDevice::Pointer videoDevice = mitk::USVideoDevice::New("-1", "Manufacturer", "Model");
TestUSFilter::Pointer filter = TestUSFilter::New();
// Make Videodevice produce it's first set of Data, so it's output isn't empty
videoDevice->Update();
// attacht filter input to device output
filter->SetInput(videoDevice->GetOutput());
// Pipeline is now functional
filter->Update();
\endverbatim
\subsection PipelineingConceptPage_Implement Writing Your Own Filter
When writing your first Filter, this is the recommended way to go about:
- Identify which kinds of Data you require for input, and which for output
- According to the information from step one, extend the most specific subclass of BaseProcess available. E.g. a filter that processes images, should extend ImageToImageFilter.
- Identify how many inputs and how many outputs you require.
- In the constructor, define the number of outputs, and create an output.
\verbatim
//set number of outputs
this->SetNumberOfOutputs(1);
//create a new output
mitk::Image::Pointer newOutput = mitk::Image::New();
this->SetNthOutput(0, newOutput);
\endverbatim
- Implement MakeOutput(). This Method creats a new, clean Output that can be written to. Refer to Filters with similiar task for this.
- Implement GenerateData(). This Method will generate the output based on the input it. At time of execution you can assume that the Data in input is a new set.
*/
\ No newline at end of file
diff --git a/Core/Documentation/Doxygen/Concepts/QVTKRendering.dox b/Core/Documentation/Doxygen/Concepts/QVTKRendering.dox
index fd50b5c7e7..6140aba57f 100644
--- a/Core/Documentation/Doxygen/Concepts/QVTKRendering.dox
+++ b/Core/Documentation/Doxygen/Concepts/QVTKRendering.dox
@@ -1,100 +1,125 @@
/**
\page QVTKRendering Rendering Concept
The MITK rendering pipeline is derived from the VTK rendering pipeline.
\section QVTKRendering_Pipeline_VTK VTK Rendering Pipeline
\image html RenderingOverviewVTK.png "Rendering in VTK"
In VTK, the vtkRenderWindow coordinates the rendering process. Several vtkRenderers may be associated to one vtkRenderWindow.
All visible objects, which can exist in a rendered scene (2D and 3D scene), inherit from vtkProp (or any subclass e.g. vtkActor).
A vtkPropAssembly is an assembly of several vtkProps, which appears like one single vtkProp.
MITK uses a new interface class, the "vtkMitkRenderProp", which is inherited from vtkProp. Similar to a vtkPropAssembly, all MITK rendering stuff is performed via this interface class.
Thus, the MITK rendering process is completely integrated into the VTK rendering pipeline. From VTK point of view, MITK renders like a custom vtkProp object.
More information about the VTK rendering pipeline can be found at http://www.vtk.org and in the several VTK books.
\section QVTKRendering_Pipeline_MITK MITK Rendering Pipeline
This process is tightly connected to VTK, which makes it straight forward and simple. We use the above mentioned "vtkMitkRenderProp" in conjunction with the mitk::VtkPropRenderer for integration into the VTK pipeline. The QmitkRenderWindow does not inherit from mitk::RenderWindow, but from the QVTKWidget, which is provided by VTK.
The main classes of the MITK rendering process can be illustrated like this:
\image html qVtkRenderingClassOverview.png "Rendering in MITK"
A render request to the vtkRenderWindow does not only update the VTK pipeline, but also the MITK pipeline. However, the mitk::RenderingManager still coordinates the rendering update behavior.
Update requests should be sent to the RenderingManager, which then, if needed, will request an update of the overall vtkRenderWindow. The vtkRenderWindow then starts to call the Render() function of all vtkRenderers, which are associated to the vtkRenderWindow. Currently, MITK uses specific vtkRenderers (outside the standard MITK rendering pipeline) for purposes, like displaying a gradient background (mitk::GradientBackground), displaying video sources (QmitkVideoBackround and mitk::VideoSource), or displaying a (department) logo (mitk::ManufacturerLogo), etc..
Despite these specific renderers, a kind of "SceneRenderer" is member of each QmitkRenderWindow. This vtkRenderer is associated with the custom vtkMitkRenderProp and is responsible for the MITK rendering.
The vtkRenderer calls four different functions in vtkMitkRenderProp, namely RenderOpaqueGeometry(), RenderTranslucentPolygonalGeometry(), RenderVolumetricGeometry() and RenderOverlay(). These function calls are forwarded to the mitk::VtkPropRenderer.
Then, depending on the mapper type (OpenGL- or VTK-based), OpenGL is enabled or disabled. In the case of OpenGL rendering, the Paint()-method of each individual mapper is called. If the mapper is VTK-based, the four function calls are forwarded to mitk::VtkMapper and within these methods the corresponding VtkProp is evaluated.
Both strategies are illustrated in the sequence diagrams below:
\image html qVtkRenderingSequenceVTK.png "Sequence diagram for MITK VTK rendering"
In MITK, VTK-based mapper are more common and we recommend on implementing VTK-based mappers. However, MITK supports OpenGL-based mappers as well.
\image html qVtkRenderingSequenceGL.png "Sequence diagram for MITK OpenGL rendering"
\section QVTKRendering_Mapper MITK Mapper Architecture
Mappers are used to transform the input data in tangible primitives, such as surfaces, points, lines, etc. The base class of all mappers is mitk::Mapper. The mapper hierarchy reflects the two possible ways to render in MITK: Subclasses of mitk::Mapper control the creation of rendering primitives
that interface to the graphics library (e.g. via OpenGL, vtk). The mapper architecture is illustrated in the following UML diagram:
\image html qVtkRenderingMapper.jpg "Mapper architecture"
mitk::Mapper::Update() calls the time step of the input data for the specified renderer and checks whether the time step is valid and calls method mitk::Mapper::GenerateDataForRenderer(), which is reimplemented in the individual mappers and should be used to generate primitives.
mitk::Mapper::SetDefaultProperties() should be used to define mapper-specific properties.
\section QVTKRendering_programmerGuide User Guide: Programming hints for rendering related stuff (in plugins)
\li The QmitkRenderWindow can be accessed like this: this->GetRenderWindowPart()->GetRenderWindow("axial");
\li The vtkRenderWindow can be accessed like this: this->GetRenderWindowPart()->GetRenderWindow("axial")->GetVtkRenderWindow();
\li The mitkBaseRenderer can be accessed like this: mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetInstance(this->GetRenderWindowPart()->GetRenderWindow("sagittal")->GetRenderWindow());
\li An update request of the overall QmitkStdMultiWidget can be performed with: this->GetRenderWindowPart()->GetRenderingManager()->RequestUpdateAll();
\li A single QmitkRenderWindow update request can be done like this: this->GetRenderWindowPart()->GetRenderingManager()->RequestUpdate(this->GetRenderWindowPart()->GetRenderWindow("axial")->GetVtkRenderWindow());
\note The usage of ForceImmediateUpdateAll() is not desired in most common use-cases.
\subsection QVTKRendering_distinctRenderWindow Setting up a distinct Rendering-Pipeline
It is sometimes desired to have one (or more) QmitkRenderWindows that are managed totally independent of the 'usual' renderwindows defined by the QmitkStdMultiWidget.
This may include the data that is rendered as well as possible interactions. In order to achieve this, a set of objects is needed:
\li mitk::RenderingManager -> Manages the rendering
\li mitk::DataStorage -> Manages the data that is rendered
\li mitk::GlobalInteraction -> Manages all interaction
\li QmitkRenderWindow -> Actually visualizes the data
The actual setup, respectively the connection, of these classes is rather simple:
\code
// create a new instance of mitk::RenderingManager
mitk::RenderingManager::Pointer renderingManager = mitk::RenderingManager::New();
// create new instances of DataStorage and GlobalInteraction
mitk::DataStorage::Pointer dataStorage = mitk::DataStorage::New();
mitk::GlobalInteraction::Pointer globalInteraction = mitk::GlobalInteraction::New();
// add both to the RenderingManager
renderingManager->SetDataStorage( dataStorage );
renderingManager->SetGlobalInteraction( globalInteraction );
// now create a new QmitkRenderWindow with this renderingManager as parameter
QmitkRenderWindow* renderWindow = new QmitkRenderWindow( parent, "name", renderer, renderingManager );
\endcode
That is basically all you need to setup your own rendering pipeline.
Obviously you have to add all data you want to render to your new DataStorage. If you want to interact with this renderwindow, you will also have
to add additional Interactors/Listeners.
\note Dynamic casts of a mitk::BaseRenderer class to an OpenGLRenderer (or now, to an VtkPropRenderer) should be avoided. The "MITK Scene" vtkRenderer and the vtkRenderWindow as well, are therefore now included in the mitk::BaseRenderer.
+\subsection QVTKRendering_userGuideMapper How to write your own Mapper
+
+If you want to write your own mapper, you first need to decide whether you want to write a VTK-based mapper or a GL-based mapper.
+We recommend to write a VTK-based mapper, as VTK is easy to learn and some GL-based mappers can have unexpected site effects.
+However, you need to derive from the respective classes.
+
+In the following we provide some programming hints for writing a Vtk-based mapper:
+
+\li include mitkLocalStorageHandler.h and derive from class BaseLocalStorage as a nested class in your own mapper. The LocalStorage instance should
+contain all VTK ressources such as actors, textures, mappers, polydata etc.
+The LocalStorageHandler is responsible for providing a LocalStorage to a concrete mitk::Mapper subclass. Each RenderWindow / mitk::BaseRenderer is
+assigned its own LocalStorage instance so that all contained ressources (actors, shaders, textures, ...) are provided individually per window.
+
+\li GenerateDataForRenderer() should be reimplemented in order to generate the primitives that should be rendered. This method is called in each Mapper::Update() pass, thus,
+all primitives that are rendered are recomputed. Employ LocalStorage::IsGenerateDataRequired() to determine whether it is necessary to generate the primitives again. It is not
+necessary to generate them again in case the scene has just been translated or rotated.
+
+\li For 2D mappers, it is necessary to determine the 3D primitives close to the current plane that should be drawn. Use
+ planeGeometry = renderer->GetSliceNavigationController()->GetCurrentPlaneGeometry() to get the current plane. The distance to it can be determined by using planeGeometry->DistanceFromPlane(point).
+
+\li Reimplement GetVtkProp(), that should return the specific VtkProp generated in GenerateDataForRender() (e.g. a single actor or a propassembly, which is a combination of different actors).
+The VtkProp is picked up in one of the four render passes and thus integrated into the VTK render pipeline.
+
+\li SetDefaultProperties() should be used to define mapper-specific properties.
+
*/
diff --git a/Core/Documentation/Doxygen/Concepts/images/geometryoverview/CoordinateTypes.png b/Core/Documentation/Doxygen/Concepts/images/geometryoverview/CoordinateTypes.png
index c7585e19bf..a2d87a5614 100644
Binary files a/Core/Documentation/Doxygen/Concepts/images/geometryoverview/CoordinateTypes.png and b/Core/Documentation/Doxygen/Concepts/images/geometryoverview/CoordinateTypes.png differ
diff --git a/Core/Documentation/Doxygen/Concepts/images/pipelining/pipelining_example_us.png b/Core/Documentation/Doxygen/Concepts/images/pipelining/pipelining_example_us.png
index 00f1c88427..1ea5fcc538 100644
Binary files a/Core/Documentation/Doxygen/Concepts/images/pipelining/pipelining_example_us.png and b/Core/Documentation/Doxygen/Concepts/images/pipelining/pipelining_example_us.png differ
diff --git a/Documentation/Doxygen/DeveloperManual/Starting/GettingToKnow/Tutorial/Step10.dox b/Documentation/Doxygen/DeveloperManual/Starting/GettingToKnow/Tutorial/Step10.dox
index 542dd477c9..6ba5548bb1 100644
--- a/Documentation/Doxygen/DeveloperManual/Starting/GettingToKnow/Tutorial/Step10.dox
+++ b/Documentation/Doxygen/DeveloperManual/Starting/GettingToKnow/Tutorial/Step10.dox
@@ -1,432 +1,438 @@
/**
\page Step10Page MITK Tutorial - Step 10: Adding new Interaction
\tableofcontents
\section HowToUseDataInteractor How to use an existing DataInteractor
MITK provides finished DataInteractors for a variety of tasks, they can be found in Code/Core/Interactors. They can be used with
-state machine patterns and config files located under Resources/Interaction.
+state machine patterns and config files located under Resources/Interactions.
-A DataInteractor consists of four parts. The class describing the functionality and two XML files; one describes the state machine pattern, that is the workflow of an interaction and
-the second describes the user events which trigger an action. Lastly every DataInteractor works on a DataNode in which it stores and manipulates data.
-To use a DataInteractor these parts have to be brought together.
+A mitk::DataInteractor consists of four parts. The class describing the functionality and two XML files; one describes the state machine pattern, that is the workflow of an interaction and
+the second describes the user events which trigger an action. Lastly every mitk::DataInteractor works on a mitk::DataNode in which it stores and manipulates data.
+To use a mitk::DataInteractor these parts have to be brought together.
-<b>This code demonstrates the use of an existing DataInteractor exemplary for the PointSetDataInteractor:</b>
+<b>This code demonstrates the use of an existing mitk::DataInteractor exemplary for the mitk::PointSetDataInteractor:</b>
-First we need a DataNode that is added to the DataStorage.
+First we need a mitk::DataNode that is added to the mitk::DataStorage.
\code
mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
GetDataStorage()->Add(dataNode.GetPointer());
\endcode
-Then we create an instance of to PointSetDataInteractor and load a statemachine pattern as well as a configuration
+Then we create an instance of a mitk::PointSetDataInteractor and load a statemachine pattern as well as a configuration
for it:
\code
m_CurrentInteractor = mitk::PointSetDataInteractor::New();
m_CurrentInteractor->LoadStateMachine("PointSet.xml");
- m_CurrentInteractor->LoadEventConfig("PointSetConfig.xml");
+ m_CurrentInteractor->SetEventConfig("PointSetConfig.xml");
\endcode
-Lastly the DataNode is added to the DataInteractor
+Lastly the mitk::DataNode is added to the mitk::DataInteractor
\code
m_CurrentInteractor->SetDataNode(dataNode);
\endcode
-now the DataInteractor is ready for usage.
+now the mitk::DataInteractor is ready for usage.
\section SectionImplementationDataInteractor How to implement a new DataInteractor
This second part of the tutorial step goes beyond the activation of an interactor, that modifies data by user interaction) as shown above. It shows what needs to be implemented to add a new way of interaction within your MITK application.
Please see \ref DataInteractionPage as an introduction to the MITK interaction mechanism, you may also want to read \ref DataInteractionTechnicalPage.
This tutorial is structured as follows: The first section deals with config files, describing all the parameters of events and how to use them
in a configuration file. In the second section the basics are described that are needed to write a state machine pattern. The last section
-deals with brining configuration, state machine pattern and code together and gives an examplary implementation of a DataInteractor.
+deals with brining configuration, state machine pattern and code together and gives an exemplary implementation of a mitk::DataInteractor.
\section ConfigFileDescriptionSection How to create a Config-File
\subsection EventDescriptionSection Event Description
Events are described by their parameters. Each event type has its own set of parameters that can be set in the configuration file.
-If a parameter is ommitted it is set to its default value. Following all possible parameters are listed and described, to which parameters
-events have is decribed in their respective documentation.
+If a parameter is omitted it is set to its default value. All possible parameters are listed and described below. Event parameters
+are also described in the documentation of the event class itself.
Mandatory for each event description is the event class and the event variant. The parameters of an event are set by attribute tags.
\note Refer to \ref EventClassSection for the meaning of event class.
\b Mouse \b Buttons \n
-mitk::MouseButtons represent the buttons. They can be used for two attributes. First the EventButton which describes the button that triggered the event,
-this allways is a single button. Secondly the ButtonState attribute that describes which buttons were pressed at the moment the event has been generated.
-For example assume the right mouse button and the middle mouse button are already pressed, now also the left mouse button is pressed too and generates a second event,
+mitk::InteractionEvent::MouseButtons represent the buttons. They can be used for two attributes. First the EventButton attribute which describes
+the button that triggered the event,
+this always is a single button. Secondly the ButtonState attribute that describes which buttons were pressed at the moment the event has been generated.
+For example assume the right mouse button and the middle mouse button are already pressed, now the left mouse button is pressed too and generates a second event,
this would be described as follows:
\code
<attribute name="EventButton" value="LeftMouseButton"/>
<attribute name="ButtonState" value="RightMouseButton,MiddleMouseButton"/>
\endcode
-Note: Technically the LeftMouseButton is also pressed and should be listed in the ButtonState, but this is taken care of by the mitk:EventFactory .
+Note: Technically the LeftMouseButton is also pressed and should be listed in the ButtonState, but this is taken care of by the mitk::EventFactory .
<b> Key Events</b> \n
mitk::InteractionKeyEvent represents a pressed key, which key is pressed is provided with the Key attribute like this
\code
<attribute name="Key" value="A"/>
\endcode
or
\code
<attribute name="Key" value="Escape"/>
\endcode
-\note Key Events do not require an explicit configuration all, for all key events there exists
+\note Key Events do not require an explicit configuration, for all key events there exists
a predefined event variant with the name 'Std' + value, that is key a is named 'StdA'.
The names for special keys are listed here:
-\dontinclude mitkInteractionEventConst.h
+\dontinclude mitkInteractionEvent.h
\skipline // Special Keys
\until // End special keys
<b> Modifier Keys</b> \n
-mitk::ModifierKeys represent the combination of pressed modifier keys, several modifier keys pressed at the same time
+mitk::InteractionEvent::ModifierKeys represent the combination of pressed modifier keys, several modifier keys pressed at the same time
are denoted by listing them all separated by commas.
\code
<!-- shift and control key are pressed -->
<attribute name="Modifiers" value="shift,ctrl"/>
\endcode
\b ScrollDirection \n
This attribute is unique to the mitk::MouseWheelEvent and describes the direction in which the mouse wheel is rotated. In the event description actual only the direction is provided,
but the event is generated with the actual value, and this value can be retrieved from the object.
\code
<attribute name="ScrollDirection" value="up"/>
<!-- or -->
<attribute name="ScrollDirection" value="down"/>
\endcode
\subsection ExamplesSection Examples
Examples for key events:
\code
<config>
<!-- Event of key 'a' pressed -->
<event_variant class="InteractionKeyEvent" name="StdA">
<attribute name="Key" value="A"/>
</event_variant>
<!-- Event of key 'b' pressed while modifiers ctrl and shift are pressed-->
<event_variant class="InteractionKeyEvent" name="StdA">
<attribute name="Key" value="A"/>
<attribute name="Modifiers" value="shift,ctrl"/>
</event_variant>
</config>
\endcode
Examples for MousePress events:
\code
<!-- Standard left click -->
<config>
<event_variant class="MousePressEvent" name="StdMousePressPrimaryButton">
<attribute name="EventButton" value="LeftMouseButton"/>
</event_variant>
<!-- right click with control key pressed-->
<event_variant class="MousePressEvent" name="RightWithCTRL">
<attribute name="EventButton" value="RightMouseButton"/>
<attribute name="Modifiers" value="ctrl"/>
</event_variant>
</config>
\endcode
There exists a standard configuration file for the most common events called GlobalConfig.xml that can be used to as a default and can be extended
by a specific definition.
\subsection ParameterDescriptionSection Parameter Description
It is also possible to store parameters in the config file. Those are stored using the param-tag, like this:
\code
<config name="example2">
<param name="property1" value="yes"/>
<param name="scrollModus" value="leftright"/>
</config>
\endcode
Within the application these properties can then be access via a mitk::PropertyList like this:
\code
// sm - state machine loaded with config file example2
mitk::PropertyList::Pointer properties = GetAttributes();
std::string prop1;
properties->GetStringProperty("property1",prop1);
\endcode
\section HowToStateMachine HowTo Write a State Machine
A state machine pattern is described in a XML file.
\subsection StateSection States
States are described using the state-tag. Each state has to have a name. Exactly one state has to be as start state in
each state machine to indicate the state in which the state machine is set when it is constructed.
So a valid, but rather useless state machine would like like this:
\code
<statemachine>
<state name="start" startstate="true"/>
</statemachine>
\endcode
Optionally a state can be assigned a special mode that influences the event distribution.
These modes are GRAB_INPUT , PREFER_INPUT and REGULAR (where REGULAR is default and does not need to be indicated).
See \ref DispatcherEventDistSection for a description of these modes. Use the special modes only when necessary as they prevent other DataInteractors to
receive events.
\code
<!-- example -->
<state name="someState" startstate="true" state_mode="GRAB_INPUT"/>
\endcode
\subsection TransitionSection Transitions
-Transitions are part of a state and describe all possible state switches, and are therefore important for modelling an interaction scheme.
+Transitions are part of a state and describe all possible state switches, and are therefore important for modeling an interaction scheme.
Transitions consist a part that describes the event which triggers the transition (event class and event variant) and a target which is state
to which the state machine switches after executing a transition.
An event class describes the event type (see mitk::InteractionEvent for the different classes) and the event variant is a specification thereof
and the exact description is taken from a config file. Together they determine which event can trigger this transition.
For example this state machine will switch from state A to state B when the StdMousePressPrimaryButton event (left mouse button is pressed) occurs.
\subsubsection EventClassSection Event Class
The event class description supports the polymorphism of the event classes. Therefore state machine patters should be written in the most
general ways possible.
So for a given class hierarchy like this:
\dot
digraph {
node [shape=record, fontname=Helvetica, fontsize=10];
- a [ label="{PositionEvent}"];
+ a [ label="{InteractionPositionEvent}"];
b [ label="{MousePressEvent}" ];
c [ label="MouseReleaseEvent" ];
d [ label="TouchEvent", style=dotted ];
a -> b;
a -> c;
a -> d;
}
\enddot
-in the state machine pattern the PositionEvent can be declared as event class to restrict to the events which hold a position information.
-The actual implementation is then given in the configuration file. In this case it allows to define event of the classes PositionEvent itself, or
-MousePressEvent,MouseReleaseEvent,TouchEvent.
+in the state machine pattern the mitk::InteractionPositionEvent can be declared as event class to restrict to the events which hold a position information.
+The actual implementation is then given in the configuration file. In this case it allows to define events of the classes mitk::InteractionPositionEvent
+itself, or mitk::MousePressEvent, mitk::MouseReleaseEvent, mitk::TouchEvent.
This has the advantage that the patterns remain the same no matter what input devices are used, and the state machine patterns can be configured
-for newly added event classes as long as they match the class hierachy (this ensures they hold the neccessary properties).
+for newly added event classes as long as they match the class hierarchy (this ensures they hold the necessary properties).
\code
<statemachine>
<state name="A" startstate="true">
<transition event_class="MousePressEvent" event_variant="StdMousePressPrimaryButton" target="B"/>
<state/>
<state name="B" />
</statemachine>
\endcode
\subsection ActionSection Actions
-Actions can be added to transitions and represent functions in the DataInteractor that are executed on taking a transition.
+Actions can be added to transitions and represent functions in the mitk::DataInteractor that are executed on taking a transition.
The following simple state machine will listen for left mouse clicks and execute two actions (and actually never stop).
\code
<statemachine>
<state name="start" startstate="true">
<transition event_class="MousePressEvent" event_variant="StdMousePressPrimaryButton" target="start">
<action name="addPoint"/>
<action name="countClicks"/>
</transition>
</state>
</statemachine>
\endcode
-In order to tell the DataInteractor which function to execute these actions are made known to the DataInteractor using
-the CONNECT_FUNCTION macro. This example assumes that there exists an ExampleInteractor which inherits from DataInteractor.
+In order to tell the mitk::DataInteractor which function to execute these actions are made known to the mitk::DataInteractor using
+the CONNECT_FUNCTION macro. This example assumes that there exists an ExampleInteractor which inherits from mitkDataInteractor.
This class implements the functions AddPoint and CountClicks. The actions are introduced by implementing the virtual method
ConnectActionsAndFunctions():
\code
void mitk::ExampleInteractor::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("addPoint", AddPoint);
CONNECT_FUNCTION("countClicks", CountClicks);
}
\endcode
-\section HowToDataInteractor Implementation a new DataInteractor
+\section ReferenceToIncludeFiles Integration of the pattern and configuration files
+
+See \ref IncludeFiles for a description.
+
+
+\section HowToDataInteractor Implementation of a new mitk::DataInteractor
DataInteractors are to inherit from mitk::DataInteractor. Their functionality is implemented in functions that follow this interface:
\code
bool SomeFunctionality(StateMachineAction* , InteractionEvent*);
\endcode
Your functions are connected with actions by implementing the function ConnectActionsAndFunctions(), e.g.
\code
void mitk::ExampleInteractor::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("addPoint", AddPoint);
CONNECT_FUNCTION("enoughPoints", EnoughPoints);
}
\endcode
Now all that is left it to write a state machine pattern and a config file as is described in the tutorials.
\subsection ExampleInternalEvent PointSetDataInteractor
To provide a useful example the mitk::PointSetDataInteractor is annotated with comments that describe the important parts for an implementation
-of a DataInteractor.
+of a mitk::DataInteractor.
-This step assumes knowlege of the Interaction concept described in \ref DataInteractionPage and some background of the implementation which is described in
+This step assumes knowledge of the Interaction concept described in \ref DataInteractionPage and some background of the implementation which is described in
\ref DataInteractionPageTechnical. Please refer to these pages before proceeding.
DataInteractor are to inherit from mitk::DataInteractor. Their functionality is implemented in functions that follow this interface:
\code
bool SomeFunctionality(StateMachineAction* , InteractionEvent*);
\endcode
Your functions are connected with actions by implementing the function ConnectActionsAndFunctions(), e.g.
\code
void mitk::ExampleInteractor::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("addPoint", AddPoint);
CONNECT_FUNCTION("enoughPoints", EnoughPoints);
}
\endcode
Now all that is left it to write a state machine pattern and a config file as is described in the tutorials.
\subsection ExampleInternalEvent Example Interactor using InternalEvent
-A useful tool in creating DataInteractors are mitk::InternalEvents which allow to the DataInteractor send signals on its own.
-The following will describe how to build a DataInteractor that allows to add points until a certain number of points is reached.
+A useful tool in creating DataInteractors is mitk::InternalEvent which allows the mitk::DataInteractor to send signals on its own.
+The following will describe how to build a mitk::DataInteractor that allows to add points until a certain number of points is reached.
The number of accepted points is provided in the config file as a parameter.
-So we start by writing a state machine pattern that add points until it receives an InternalEvent telling it, that enough points
+So we start by writing a state machine pattern that add points until it receives an mitk::InternalEvent telling it, that enough points
have been added.
\code
<statemachine>
<state name="start" startstate="true" >
<transition event_class="MousePressEvent" event_variant="AddPointClick" target="start">
<action name="addPoint"/>
</transition>
<transition event_class="InternalEvent" event_variant="enoughPointsAdded" target="final">
<action name="enoughPoints"/>
</transition>
</state>
<state name="final">
<--! dead state, nothing happens any more, once we reached this -->
</state>
</statemachine>
\endcode
<b> </b>
In our config file we set the number of maximal points to 10, and define AddPointClick as a right mouse click with the
ctrl button pressed.
\code
<config>
<param name="NumberOfPoints" value="10">
<event_variant class="MousePressEvent" name="AddPointClick">
<attribute name="EventButton" value="RightMouseButton"/>
<attribute name="Modifiers" value="ctrl"/>
</event_variant>
</config>
\endcode
-The implementation is desribed in the following. \see Step10.h \see Step10.cpp
+The implementation is described in the following. \see Step10.h \see Step10.cpp
\dontinclude Step10.h
Implementation of protected functions:
\skipline protected:
\until virtual void ConfigurationChanged();
<b> ConnectActionsAndFunctions </b> - Is inherited from mitk::InteractionStateMachine, here action strings from the xml are connected with
-functions in the Interactor (as seen above). In our example this looks like this:
+functions in the mitk::DataInteractor (as seen above). In our example this looks like this:
\dontinclude Step10.cpp
\skipline void mitk::ExampleInteractor::ConnectActionsAndFunctions()
\until }
<b> ConfigurationChanged </b> - Is called whenever a new configuration file is loaded (by the mitk::InteractionEventHandler super class),
this function allows to implement initialization code that depends on configuration values. In our example we want to set the limit of
allowed points:
\dontinclude Step10.cpp
\skipline void mitk::ExampleInteractor::ConfigurationChang
\until }
Next the actual functionality of the DataInteractor is implemented, by providing one function per action, following this prototype:
\code
bool FUNCTION_NAME (StateMachineAction* , InteractionEvent*);
\endcode
\dontinclude Step10.h
\skipline private:
\until bool EnoughPoints(StateMac
Each function has to return a boolean value. True if the action has been executed, and false if the action has not been executed.
\dontinclude Step10.cpp
\skipline bool mitk::ExampleInteractor::AddPoint(StateM
\until //-
Here we see an internal event used to signal that the point set reached the maximal number of allowed points.
The event is created and added to the Dispatchers event queue.
\dontinclude Step10.cpp
\skipline // create internal
\until positionEvent->GetSender(
-\note That internal events do not need any mapping to event variants. Their signal same is equivalent with the event variant.
+\note Internal events do not need any mapping to event variants. Their signal same is equivalent with the event variant.
-<b> There are also two documented classes implementing a DataInteractor and an InteractionEventObserver which can be looked at for further
+<b> There are also two documented classes implementing a mitk::DataInteractor and a mitk::InteractionEventObserver which can be looked at for further
understanding: </b>
\see mitk::PointSetDataInteractor
\see mitk::DisplayInteractor
Have fun with creating your own interaction and please think about contributing it to MITK!
<b>
If you meet any difficulties during this step, don't hesitate to ask on the MITK mailing list mitk-users@lists.sourceforge.net!
People there are kind and will try to help you. </b>
\ref Step09Page "[Previous step]" \ref TutorialPage "[Main tutorial page]"
*/
diff --git a/Documentation/Doxygen/DeveloperManual/Toolkit/ModuleManuals/InteractionMigration.dox b/Documentation/Doxygen/DeveloperManual/Toolkit/ModuleManuals/InteractionMigration.dox
new file mode 100644
index 0000000000..f52a7ff02c
--- /dev/null
+++ b/Documentation/Doxygen/DeveloperManual/Toolkit/ModuleManuals/InteractionMigration.dox
@@ -0,0 +1,178 @@
+/**
+
+\page InteractionMigration Migration Guide to new Interaction Concept
+
+\tableofcontents
+
+
+\section GeneralChanges General Changes
+
+\subsection StatemachineDefinitions
+
+Previously the statemachine pattern along with the event description has been stored in a single file (StateMachine.xml).
+Now the pattern and the events are separated from each other. The statemachine pattern describes the workflow and the configuration
+file describes which specific event triggers an action in the workflow. Every pattern is now put into a single file (for inclusion refer to \ref IncludeFiles ).
+
+The pattern description has to be completely rewritten, but is pretty straight forward based on the old one, how to do this is explained here \ref HowToStateMachine .
+Here an example is shown for a simple state containing a transition and a parameter.
+
+\code
+<state NAME="neutral" ID="1" START_STATE="TRUE">
+ <transition NAME="Shift+press" NEXT_STATE_ID="1" EVENT_ID="3">
+ <action ID="10" />
+ <intParameter NAME="DIRECTION_X" VALUE="0" />
+ </transition>
+</state>
+\endcode
+<b> Example snippet (old) </b>
+
+
+
+\code
+<state name="neutral" startstate="true">
+ <transition event_class="MousePressEvent" event_variant="MouseLeftButtonPressed" target="neutral">
+ <action name="addPoint"/>
+ </transition>
+</state>
+\endcode
+<b> Example snippet (new) </b>
+
+Changes:
+<ul>
+ <li> ID is dropped, states are referenced now by their name
+ <li> transition now longer have names
+ <li> NEXT_STATE_ID becomes target
+ <li> action ids become names, these names are used in the interactor to connect an action with a function
+ <li> parameters are stored in the configuration file
+ <li> EVENT_ID is replaced by event_class and event_variant (see below)
+</ul>
+
+Event_class describes the class of the event (see \ref EventClassSection ) - the event_variant provides a name that is used in the configuration file
+to give an explicit description of the event (or the globalConfig.xml is loaded as configuration file and standard values are used).
+
+Configuration files for state machines are described here: \ref ConfigFileDescriptionSection .
+
+\subsection InteractorStruture Structure of an Interactor
+
+Actions are now directly connected to functions in the DataInteractors, so the classic switch statement becomes obsolete:
+
+\code
+bool mitk::SomeInteractor::ExecuteAction(Action* action, mitk::StateEvent const* stateEvent)
+{
+ switch (action->GetActionId())
+ {
+ case Action1:
+ ...
+ case Action2:
+ ...
+ }
+}
+\endcode
+
+changes to
+
+\code
+void mitk::ExampleInteractor::ConnectActionsAndFunctions()
+{
+CONNECT_FUNCTION("stringOfActionFromXmlFile", Action1);
+CONNECT_FUNCTION("stringOfActionFromXmlFile2", Action2);
+...
+}
+
+bool Action1(StateMachineAction* , InteractionEvent*)
+{
+...
+}
+...
+\endcode
+
+where each action is implemented as a function. See \ref HowToDataInteractor .
+
+
+\subsection GuardStates Guard States
+
+Formerly there where so called guard states, which cause a transition only if certain conditions are met. These states have been removed,
+as a replacement serve the InternalEvents which can be triggered from within a data interactor. An example showing how to use them is given in \ref ExampleInternalEvent .
+
+\subsection IncludeFiles Register statemachine patterns and configuration w/o the build system
+
+There are different ways to load a statemachine pattern or configuration objects from files.
+If you are working in a module you can use the resources to easily load patterns and configurations.
+To use this place your XML file in the 'Resources/Interactions' folder of the respective module, and add the file path to the corresponding files.cmake in the resource section
+like this:
+\code
+set(RESOURCE_FILES
+Interactions/dummyStatemachine.xml
+)
+\endcode
+
+Loading the statemachine pattern can then be done by simply calling
+\code
+#include "mitkModule.h"
+#include <mitkGetModuleContext.h>
+
+Module* module = GetModuleContext()->GetModule();
+
+mitk::PointSetDataInteractor::m_CurrentInteractor = mitk::PointSetDataInteractor::New();
+m_CurrentInteractor->LoadStateMachine("dummyStatemachine.xml", module);
+\endcode
+here module is optional, if none is provided the core module is assumed.
+
+The third possibility is to build up a configuration by vector of mitk::PropertyLists, where each item describes an event configuration.
+
+In the following example a configuration is build which defines two event variants using basic properties,
+for a full list of usable properties see mitkInteractionEventConst.h
+\code
+#include "mitkPropertyList.h"
+
+#include "mitkEventConfig.h"
+
+// First event
+mitk::PropertyList::Pointer propertyList1 = mitk::PropertyList::New();
+// Setting the EventClass property to 'MousePressEvent'
+propertyList1->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventClass.c_str(), "MousePressEvent");
+// Setting the Event variant value to 'MousePressEventVariantÄ
+propertyList1->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventVariant.c_str(), "MousePressEventVariant");
+// set control and alt buttons as modifiers
+propertyList1->SetStringProperty("Modifiers","CTRL,ALT");
+// Second event
+mitk::PropertyList::Pointer propertyList2 = mitk::PropertyList::New();
+propertyList2->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventClass.c_str(), "MouseReleaseEvent");
+propertyList2->SetStringProperty(mitk::InteractionEventConst::xmlParameterEventVariant.c_str(), "MouseReleaseEventVariant");
+propertyList2->SetStringProperty("Modifiers","SHIFT");
+
+// putting both descriptions in a vector
+std::vector<mitk::PropertyList::Pointer>* configDescription = new std::vector<mitk::PropertyList::Pointer>();
+configDescription->push_back(propertyList1);
+configDescription->push_back(propertyList2);
+// create the config object
+mitk::EventConfig newConfig(configDescription);
+\endcode
+
+\section ModifyDisplayInteractorBehavior How to modify the display interactor behavior
+
+Sometimes it may be desirable to change the behaviour of the mitk::DisplayInteractor which controls zooming, panning and scrolling, e.g. when a
+Tool is activated that reacts to the same events. Changing the behavior of the DisplayInteractor (or possibly any other EventHandler) can be achieved from anywhere
+in the code by requesting the InteractionEventObserver and assigning an alternative configuration to it, as demonstrated in this example:
+
+\code
+
+std::ifstream* configStream = new std::ifstream( #path to alternative configuration file# );
+mitk::EventConfig newConfig(configStream);
+
+// Requesting all registered EventObservers
+std::list<mitk::ServiceReference> listEventObserver = GetModuleContext()->GetServiceReferences<InteractionEventObserver>();
+
+for (std::list<mitk::ServiceReference>::iterator it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
+{
+ DisplayInteractor* displayInteractor = dynamic_cast<DisplayInteractor*>(GetModuleContext()->GetService<InteractionEventObserver>(*it));
+ // filtering: only adjust the DisplayInteractor
+ if (displayInteractor != NULL)
+ {
+ displayInteractor->SetEventConfig(newConfig);
+ }
+}
+
+\endcode
+
+*/
diff --git a/Documentation/Doxygen/DeveloperManual/Toolkit/ModuleManuals/MITKModuleManualsList.dox b/Documentation/Doxygen/DeveloperManual/Toolkit/ModuleManuals/MITKModuleManualsList.dox
index f2a4ff42fb..01b29f539b 100644
--- a/Documentation/Doxygen/DeveloperManual/Toolkit/ModuleManuals/MITKModuleManualsList.dox
+++ b/Documentation/Doxygen/DeveloperManual/Toolkit/ModuleManuals/MITKModuleManualsList.dox
@@ -1,22 +1,25 @@
/**
\page MITKModuleManualsListPage MITK Module Manuals
\section MITKModuleManualsListPageOverview Overview
The modules are shared libraries that provide functionality that can be used by developers.
\section MITKModuleManualsListPageModuleManualList List of Module Manuals
\li \subpage IGTGeneralModulePage
\li \subpage MitkOpenCL_Overview
\li \subpage SimulationManualPage
\li \subpage GeneratingDeviceModulesPage
\li \subpage mitkPython_Overview
\section MITKModuleManualsListPageAdditionalInformation Additional Information on Certain Modules
\li \ref PlanarPropertiesPage
\li \subpage DiffusionImagingPropertiesPage
\li \subpage ConnectomicsRenderingPropertiesPage
+\section MITKMigrationGuides Migration Guides
+
+ \li \subpage InteractionMigration
*/
diff --git a/Documentation/Doxygen/UserManual/MITKPluginManualsList.dox b/Documentation/Doxygen/UserManual/MITKPluginManualsList.dox
index e39be9efb1..89b0531026 100644
--- a/Documentation/Doxygen/UserManual/MITKPluginManualsList.dox
+++ b/Documentation/Doxygen/UserManual/MITKPluginManualsList.dox
@@ -1,42 +1,43 @@
/**
\page PluginListPage MITK Plugin Manuals
\section PluginListPageOverview Overview
The plugins and bundles provide much of the extended functionality of MITK. Each encapsulates a solution to a problem and associated features. This way one can easily assemble the necessary capabilites for a workflow without adding a lot of bloat, by combining plugins as needed.
The distinction between developer and end user use is for convenience only and mainly distinguishes which group a plugin is primarily aimed at.
\section PluginListPageEndUserPluginList List of Plugins for End User Use
\li \subpage org_blueberry_ui_qt_log
\li \subpage org_mitk_views_basicimageprocessing
\li \subpage org_mitk_views_cmdlinemodules
\li \subpage org_mitk_views_datamanager
+ \li \subpage org_mitk_gui_qt_dicom
\li \subpage org_mitk_gui_qt_diffusionimaging
\li \subpage org_mitk_views_imagecropper
\li \subpage org_mitk_views_imagenavigator
\li \subpage org_mitk_gui_qt_measurementtoolbox
- \li \subpage org_mitk_views_moviemaker
\li \subpage org_mitk_views_meshdecimation
+ \li \subpage org_mitk_views_moviemaker
\li \subpage org_mitk_views_pointsetinteraction
+ \li \subpage org_mitk_gui_qt_python
\li \subpage org_mitk_gui_qt_registration
\li \subpage org_mitk_views_segmentation
- \li \subpage org_mitk_views_volumevisualization
- \li \subpage org_mitk_gui_qt_dicom
+ \li \subpage org_mitk_gui_qt_simulation
\li \subpage org_mitk_gui_qt_ultrasound
- \li \subpage org_mitk_gui_qt_python
+ \li \subpage org_mitk_views_volumevisualization
\section PluginListPageDevPluginList List of Plugins for Developer Use and Examples
\li \subpage org_surfacematerialeditor
\li \subpage org_toftutorial
\li \subpage org_mitk_gui_qt_examples
\li \subpage org_mitkexamplesopencv
\li \ref org_mitk_gui_qt_igtexample
\li \ref org_mitk_gui_qt_igttracking
\li \subpage org_blueberry_ui_qt_objectinspector
\li \subpage org_mitk_gui_InteractionTests
*/
diff --git a/Examples/QtAppExample/CMakeLists.txt b/Examples/QtAppExample/CMakeLists.txt
index 5105f5ea17..0ff4fa624d 100644
--- a/Examples/QtAppExample/CMakeLists.txt
+++ b/Examples/QtAppExample/CMakeLists.txt
@@ -1,34 +1,34 @@
-cmake_minimum_required(VERSION 2.8.4)
+cmake_minimum_required(VERSION 2.8.5)
project(QtAppExample)
find_package(MITK REQUIRED)
# Check that MITK has been build with Qt support
if(NOT MITK_USE_QT)
message(SEND_ERROR "MITK needs to be built with MITK_USE_QT set to ON")
endif()
# Check prerequisites for this application.
# We need the Qmitk module.
MITK_CHECK_MODULE(result Qmitk)
if(result)
message(SEND_ERROR "MITK module(s) \"${result}\" not available from the MITK build at ${MITK_DIR}")
endif()
# Set-up the build system to use the Qmitk module
MITK_USE_MODULE(Qmitk)
include_directories(${ALL_INCLUDE_DIRECTORIES})
link_directories(${ALL_LIBRARY_DIRS})
add_executable(${PROJECT_NAME} Step1.cpp)
target_link_libraries(${PROJECT_NAME} ${ALL_LIBRARIES})
# This is for subproject support inside the MITK source tree.
# Ignore/remove the following code if you build an external application.
set_property(TARGET ${PROJECT_NAME} PROPERTY LABELS ${MITK_DEFAULT_SUBPROJECTS})
foreach(subproject ${MITK_DEFAULT_SUBPROJECTS})
add_dependencies(${subproject} ${PROJECT_NAME})
endforeach()
diff --git a/Modules/CMakeLists.txt b/Modules/CMakeLists.txt
index 6b2972b4f4..285ec89342 100644
--- a/Modules/CMakeLists.txt
+++ b/Modules/CMakeLists.txt
@@ -1,60 +1,61 @@
set(LIBPOSTFIX "Ext")
# Modules must be listed according to their dependencies
set(module_dirs
SceneSerializationBase
PlanarFigure
ImageExtraction
ImageStatistics
LegacyAdaptors
IpPicSupport
MitkExt
SceneSerialization
+ GraphAlgorithms
Segmentation
PlanarFigureSegmentation
Qmitk
QmitkExt
- GraphAlgorithms
+ Properties
DiffusionImaging
GPGPU
IGT
CameraCalibration
IGTUI
RigidRegistration
RigidRegistrationUI
DeformableRegistration
DeformableRegistrationUI
OpenCL
OpenCVVideoSupport
Overlays
InputDevices
ToFHardware
ToFProcessing
ToFUI
US
ClippingTools
USUI
DicomUI
Simulation
Python
)
set(MITK_DEFAULT_SUBPROJECTS MITK-Modules)
foreach(module_dir ${module_dirs})
add_subdirectory(${module_dir})
endforeach()
if(MITK_PRIVATE_MODULES)
file(GLOB all_subdirs RELATIVE ${MITK_PRIVATE_MODULES} ${MITK_PRIVATE_MODULES}/*)
foreach(subdir ${all_subdirs})
string(FIND ${subdir} "." _result)
if(_result EQUAL -1)
if(EXISTS ${MITK_PRIVATE_MODULES}/${subdir}/CMakeLists.txt)
message(STATUS "Found private module ${subdir}")
add_subdirectory(${MITK_PRIVATE_MODULES}/${subdir} private_modules/${subdir})
endif()
endif()
endforeach()
endif(MITK_PRIVATE_MODULES)
diff --git a/Modules/CameraCalibration/mitkCameraIntrinsics.cpp b/Modules/CameraCalibration/mitkCameraIntrinsics.cpp
index d08e191844..6b3f8a1165 100644
--- a/Modules/CameraCalibration/mitkCameraIntrinsics.cpp
+++ b/Modules/CameraCalibration/mitkCameraIntrinsics.cpp
@@ -1,516 +1,510 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkCameraIntrinsics.h"
#include <itkMutexLockHolder.h>
#include <mitkEndoMacros.h>
#include <mitkEndoDebug.h>
mitk::CameraIntrinsics::CameraIntrinsics()
: m_Valid(false), m_Mutex(itk::FastMutexLock::New())
{
m_CameraMatrix = cv::Mat::zeros(3, 3, cv::DataType<double>::type);
m_CameraMatrix.at<double>(2,2) = 1.0;
m_DistorsionCoeffs = cv::Mat::zeros(1, 5, cv::DataType<double>::type);
}
mitk::CameraIntrinsics::CameraIntrinsics(const CameraIntrinsics& other)
: itk::Object()
, mitk::XMLSerializable()
, m_Valid(false)
, m_Mutex(itk::FastMutexLock::New())
{
this->Copy(&other);
}
mitk::CameraIntrinsics::~CameraIntrinsics()
{
}
bool mitk::CameraIntrinsics::Equals( const CameraIntrinsics* other ) const
{
return other->GetDistorsionCoeffsAsPoint4D()==
this->GetDistorsionCoeffsAsPoint4D() &&
other->GetFocalPoint()==
this->GetFocalPoint() &&
other->GetPrincipalPoint()
== this->GetPrincipalPoint();
}
void mitk::CameraIntrinsics::Copy(const CameraIntrinsics* other)
{
this->SetIntrinsics( other->GetCameraMatrix().clone()
, other->GetDistorsionCoeffs().clone() );
this->SetValid(other->m_Valid);
}
bool mitk::CameraIntrinsics::IsValid() const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
return m_Valid;
}
vnl_matrix_fixed<mitk::ScalarType, 3, 3>
mitk::CameraIntrinsics::GetVnlCameraMatrix() const
{
vnl_matrix_fixed<mitk::ScalarType, 3, 3> mat;
mat.set_identity();
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
mat(0,0) = m_CameraMatrix.at<double>(0,0);
mat(1,1) = m_CameraMatrix.at<double>(1,1);
mat(0,2) = m_CameraMatrix.at<double>(0,2);
mat(1,2) = m_CameraMatrix.at<double>(1,2);
}
return mat;
}
void mitk::CameraIntrinsics::SetCameraMatrix(
const vnl_matrix_fixed<mitk::ScalarType, 3, 3>& _CameraMatrix )
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
m_CameraMatrix.at<double>(0,0) = _CameraMatrix(0,0);
m_CameraMatrix.at<double>(1,1) = _CameraMatrix(1,1);
m_CameraMatrix.at<double>(0,2) = _CameraMatrix(0,2);
m_CameraMatrix.at<double>(1,2) = _CameraMatrix(1,2);
}
vnl_matrix_fixed<mitk::ScalarType, 3, 4>
mitk::CameraIntrinsics::GetVnlCameraMatrix3x4() const
{
vnl_matrix_fixed<mitk::ScalarType, 3, 4> mat;
mat.fill(0);
mat.update( this->GetVnlCameraMatrix().as_matrix() );
return mat;
}
void mitk::CameraIntrinsics::SetIntrinsics( const cv::Mat& _CameraMatrix
, const cv::Mat& _DistorsionCoeffs)
{
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
if( _CameraMatrix.cols != 3 || _CameraMatrix.rows != 3)
throw std::invalid_argument("Wrong format of camera matrix. Should be 3x3"
" double.");
endoAssertMsg( (_DistorsionCoeffs.cols == 5) &&
_DistorsionCoeffs.rows == 1, "Wrong format of distorsion coefficients"
" vector. Should be 5x1 double.");
m_CameraMatrix = _CameraMatrix.clone();
m_DistorsionCoeffs = _DistorsionCoeffs.clone();
m_Valid = true;
}
this->Modified();
}
void mitk::CameraIntrinsics::SetIntrinsics( const mitk::Point3D& focalPoint,
const mitk::Point3D& principalPoint,
const mitk::Point4D& distortionCoefficients)
{
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
m_CameraMatrix.at<double>(0,0) = focalPoint[0];
m_CameraMatrix.at<double>(1,1) = focalPoint[1];
m_CameraMatrix.at<double>(0,2) = principalPoint[0];
m_CameraMatrix.at<double>(1,2) = principalPoint[1];
m_DistorsionCoeffs.at<double>(0,0) = distortionCoefficients[0];
m_DistorsionCoeffs.at<double>(0,1) = distortionCoefficients[1];
m_DistorsionCoeffs.at<double>(0,2) = distortionCoefficients[2];
m_DistorsionCoeffs.at<double>(0,3) = distortionCoefficients[3];
}
this->Modified();
}
void mitk::CameraIntrinsics::SetFocalLength( double x, double y )
{
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
m_CameraMatrix.at<double>(0,0) = x;
m_CameraMatrix.at<double>(1,1) = y;
}
this->Modified();
}
void mitk::CameraIntrinsics::SetPrincipalPoint( double x, double y )
{
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
m_CameraMatrix.at<double>(0,2) = x;
m_CameraMatrix.at<double>(1,2) = y;
}
this->Modified();
}
void mitk::CameraIntrinsics::SetDistorsionCoeffs( double k1, double k2,
double p1, double p2 )
{
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
m_DistorsionCoeffs.at<double>(0,0) = k1;
m_DistorsionCoeffs.at<double>(0,1) = k2;
m_DistorsionCoeffs.at<double>(0,2) = p1;
m_DistorsionCoeffs.at<double>(0,3) = p2;
}
this->Modified();
}
cv::Mat mitk::CameraIntrinsics::GetCameraMatrix() const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
return m_CameraMatrix.clone(); // return a copy of this small matrix
}
cv::Mat mitk::CameraIntrinsics::GetDistorsionCoeffs() const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
return m_DistorsionCoeffs.clone(); // return a copy of this small matrix
}
cv::Mat mitk::CameraIntrinsics::GetDistorsionCoeffs()
{
const CameraIntrinsics* intrinsics = this;
return intrinsics->GetDistorsionCoeffs();
}
std::string mitk::CameraIntrinsics::ToString() const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
std::ostringstream s; s.precision(12);
const cv::Mat& CameraMatrix = m_CameraMatrix;
const cv::Mat& DistorsionCoeffs = m_DistorsionCoeffs;
s.str(""); s << this->GetNameOfClass() << ": ";
s << "fx = " << CameraMatrix.at<double>(0,0);
s << ", fy = " << CameraMatrix.at<double>(1,1);
s << ", cx = " << CameraMatrix.at<double>(0,2);
s << ", cy = " << CameraMatrix.at<double>(1,2);
s << ", k1 = " << DistorsionCoeffs.at<double>(0,0);
s << ", k2 = " << DistorsionCoeffs.at<double>(0,1);
s << ", p1 = " << DistorsionCoeffs.at<double>(0,2);
s << ", p2 = " << DistorsionCoeffs.at<double>(0,3);
//s << ", k3 = " << DistorsionCoeffs.at<double>(0,4);
return s.str();
}
void mitk::CameraIntrinsics::ToXML(TiXmlElement* elem) const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
elem->SetValue(this->GetNameOfClass());
std::ostringstream s; s.precision(12);
const cv::Mat& CameraMatrix = m_CameraMatrix;
s.str(""); s << CameraMatrix.at<double>(0,0);
elem->SetAttribute( "fx", s.str() );
s.str(""); s << CameraMatrix.at<double>(1,1);
elem->SetAttribute( "fy", s.str() );
s.str(""); s << CameraMatrix.at<double>(0,2);
elem->SetAttribute( "cx", s.str() );
s.str(""); s << CameraMatrix.at<double>(1,2);
elem->SetAttribute( "cy", s.str() );
const cv::Mat& DistorsionCoeffs = m_DistorsionCoeffs;
s.str(""); s << DistorsionCoeffs.at<double>(0,0);
elem->SetAttribute( "k1", s.str() );
s.str(""); s << DistorsionCoeffs.at<double>(0,1);
elem->SetAttribute( "k2", s.str() );
s.str(""); s << DistorsionCoeffs.at<double>(0,2);
elem->SetAttribute( "p1", s.str() );
s.str(""); s << DistorsionCoeffs.at<double>(0,3);
elem->SetAttribute( "p2", s.str() );
elem->SetAttribute("Valid", m_Valid);
//s.str(""); s << DistorsionCoeffs.at<double>(4,0);
//elem->SetAttribute( "k3", s.str() );
}
void mitk::CameraIntrinsics::FromGMLCalibrationXML(TiXmlElement* elem)
{
assert( elem );
assert( elem->ValueStr() == "results" );
cv::Mat CameraMatrix = cv::Mat::zeros(3, 3, cv::DataType<double>::type);
CameraMatrix.at<double>(2,2) = 1.0;
cv::Mat DistorsionCoeffs = cv::Mat::zeros(1, 5, cv::DataType<double>::type);
TiXmlElement* focus_lenXElem = elem->FirstChildElement("focus_lenX");
endoAssert( focus_lenXElem != 0 );
CameraMatrix.at<double>(0,0) = atof( focus_lenXElem->GetText() );
TiXmlElement* focus_lenYElem = elem->FirstChildElement("focus_lenY");
endoAssert( focus_lenYElem != 0 );
CameraMatrix.at<double>(1,1) = atof( focus_lenYElem->GetText() );
TiXmlElement* PrincipalXElem = elem->FirstChildElement("PrincipalX");
endoAssert( PrincipalXElem != 0 );
CameraMatrix.at<double>(0,2) = atof( PrincipalXElem->GetText() );
TiXmlElement* PrincipalYElem = elem->FirstChildElement("PrincipalY");
endoAssert( PrincipalYElem != 0 );
CameraMatrix.at<double>(1,2) = atof( PrincipalYElem->GetText() );
// DISTORSION COEFFS
TiXmlElement* Dist1Elem = elem->FirstChildElement("Dist1");
endoAssert( Dist1Elem != 0 );
DistorsionCoeffs.at<double>(0,0) = atof( Dist1Elem->GetText() );
TiXmlElement* Dist2Elem = elem->FirstChildElement("Dist2");
endoAssert( Dist2Elem != 0 );
DistorsionCoeffs.at<double>(0,1) = atof( Dist2Elem->GetText() );
TiXmlElement* Dist3Elem = elem->FirstChildElement("Dist3");
endoAssert( Dist3Elem != 0 );
DistorsionCoeffs.at<double>(0,2) = atof( Dist3Elem->GetText() );
TiXmlElement* Dist4Elem = elem->FirstChildElement("Dist4");
endoAssert( Dist4Elem != 0 );
DistorsionCoeffs.at<double>(0,3) = atof( Dist4Elem->GetText() );
int valid = 0;
elem->QueryIntAttribute("Valid", &valid);
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
m_Valid = static_cast<bool>(valid);
m_CameraMatrix = CameraMatrix;
m_DistorsionCoeffs = DistorsionCoeffs;
}
this->Modified();
}
void mitk::CameraIntrinsics::FromXML(TiXmlElement* elem)
{
endoAssert ( elem );
MITK_DEBUG << elem->Value();
std::string filename;
if(elem->QueryStringAttribute("file", &filename) == TIXML_SUCCESS)
{
this->FromXMLFile(filename);
return;
}
else if(strcmp(elem->Value(), "CalibrationProject") == 0)
{
this->FromGMLCalibrationXML(elem->FirstChildElement("results"));
return;
}
assert ( elem );
if(strcmp(elem->Value(), this->GetNameOfClass()) != 0)
elem = elem->FirstChildElement(this->GetNameOfClass());
std::ostringstream err;
// CAMERA MATRIX
cv::Mat CameraMatrix = cv::Mat::zeros(3, 3, cv::DataType<double>::type);
CameraMatrix.at<double>(2,2) = 1.0;
float val = 0.0f;
if(elem->QueryFloatAttribute("fx", &val) == TIXML_SUCCESS)
CameraMatrix.at<double>(0,0) = val;
else
err << "fx, ";
if(elem->QueryFloatAttribute("fy", &val) == TIXML_SUCCESS)
CameraMatrix.at<double>(1,1) = val;
else
err << "fy, ";
if(elem->QueryFloatAttribute("cx", &val) == TIXML_SUCCESS)
CameraMatrix.at<double>(0,2) = val;
else
err << "cx, ";
if(elem->QueryFloatAttribute("cy", &val) == TIXML_SUCCESS)
CameraMatrix.at<double>(1,2) = val;
else
err << "cy, ";
// DISTORSION COEFFS
endodebug( "creating DistorsionCoeffs from XML file")
cv::Mat DistorsionCoeffs = cv::Mat::zeros(1, 5, cv::DataType<double>::type);
if(elem->QueryFloatAttribute("k1", &val) == TIXML_SUCCESS)
DistorsionCoeffs.at<double>(0,0) = val;
else
err << "k1, ";
if(elem->QueryFloatAttribute("k2", &val) == TIXML_SUCCESS)
DistorsionCoeffs.at<double>(0,1) = val;
else
err << "k2, ";
if(elem->QueryFloatAttribute("p1", &val) == TIXML_SUCCESS)
DistorsionCoeffs.at<double>(0,2) = val;
else
err << "p1, ";
if(elem->QueryFloatAttribute("p2", &val) == TIXML_SUCCESS)
DistorsionCoeffs.at<double>(0,3) = val;
else
err << "p2, ";
DistorsionCoeffs.at<double>(0,4) = 0.0;
/*if(elem->QueryFloatAttribute("k3", &val) == TIXML_SUCCESS)
DistorsionCoeffs.at<double>(4,0) = val;
else
err << "k3, ";*/
std::string errorStr = err.str();
int errLength = errorStr.length();
if(errLength > 0)
{
errorStr = errorStr.substr(0, errLength-2);
errorStr.append(" not found");
throw std::invalid_argument(err.str());
}
int valid = 0;
elem->QueryIntAttribute("Valid", &valid);
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
m_Valid = static_cast<bool>(valid);
m_CameraMatrix = CameraMatrix;
m_DistorsionCoeffs = DistorsionCoeffs;
}
this->Modified();
}
double mitk::CameraIntrinsics::GetFocalLengthX() const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
double FocalLengthX = m_CameraMatrix.at<double>(0,0);
return FocalLengthX;
}
double mitk::CameraIntrinsics::GetFocalLengthY() const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
double FocalLengthY = m_CameraMatrix.at<double>(1,1);;
return FocalLengthY;
}
double mitk::CameraIntrinsics::GetPrincipalPointX() const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
double PrincipalPointX = m_CameraMatrix.at<double>(0,2);
return PrincipalPointX;
}
double mitk::CameraIntrinsics::GetPrincipalPointY() const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
double PrincipalPointY = m_CameraMatrix.at<double>(1,2);
return PrincipalPointY;
}
mitk::Point4D mitk::CameraIntrinsics::GetDistorsionCoeffsAsPoint4D() const
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
mitk::Point4D coeffs;
coeffs[0] = m_DistorsionCoeffs.at<double>(0,0);
coeffs[1] = m_DistorsionCoeffs.at<double>(0,1);
coeffs[2] = m_DistorsionCoeffs.at<double>(0,2);
coeffs[3] = m_DistorsionCoeffs.at<double>(0,3);
return coeffs;
}
mitk::Point3D mitk::CameraIntrinsics::GetFocalPoint() const
{
mitk::Point3D p;
p[0] = this->GetFocalLengthX();
p[1] = this->GetFocalLengthY();
p[2] = 0;
return p;
}
mitk::Point3D mitk::CameraIntrinsics::GetPrincipalPoint() const
{
mitk::Point3D p;
p[0] = this->GetPrincipalPointX();
p[1] = this->GetPrincipalPointY();
p[2] = 0;
return p;
}
vnl_vector_fixed<mitk::ScalarType, 2>
mitk::CameraIntrinsics::GetFocalPointAsVnlVector() const
{
vnl_vector_fixed<mitk::ScalarType, 2> vec;
vec[0] = this->GetFocalLengthX();
vec[1] = this->GetFocalLengthY();
return vec;
}
vnl_vector_fixed<mitk::ScalarType, 2>
mitk::CameraIntrinsics::GetPrincipalPointAsVnlVector() const
{
vnl_vector_fixed<mitk::ScalarType, 2> vec;
vec[0] = this->GetPrincipalPointX();
vec[1] = this->GetPrincipalPointY();
return vec;
}
std::ostream& operator<< (std::ostream& os, mitk::CameraIntrinsics::Pointer p)
{
os << p->ToString();
return os;
}
std::string mitk::CameraIntrinsics::GetString()
{
return this->ToString();
}
std::string mitk::CameraIntrinsics::ToOctaveString(
const std::string& varName)
{
std::ostringstream s;
s << varName << " = [" << this->GetFocalLengthX() << " 0 "
<< this->GetPrincipalPointX() << "; 0 " <<
this->GetFocalLengthY() << " " << this->GetPrincipalPointY() << ";"
<< " 0 0 1 ];";
return s.str();
}
void mitk::CameraIntrinsics::SetValid( bool valid )
{
itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
m_Valid = valid;
}
-mitk::CameraIntrinsics::Pointer mitk::CameraIntrinsics::Clone() const
-{
- Pointer result = dynamic_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::CameraIntrinsics::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Modules/CameraCalibration/mitkCameraIntrinsics.h b/Modules/CameraCalibration/mitkCameraIntrinsics.h
index 4c6e3acc5a..2b9cb96ee0 100644
--- a/Modules/CameraCalibration/mitkCameraIntrinsics.h
+++ b/Modules/CameraCalibration/mitkCameraIntrinsics.h
@@ -1,144 +1,144 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkCameraIntrinsics_h
#define mitkCameraIntrinsics_h
#include <mitkCommon.h>
#include <mitkVector.h>
#include <itkDataObject.h>
#include <itkFastMutexLock.h>
#include <cv.h>
#include <vnl/vnl_matrix_fixed.h>
#include "mitkXMLSerializable.h"
#include <mitkCameraCalibrationExports.h>
int mitkCameraIntrinsicsTest(int argc, char* argv[]);
namespace mitk
{
///
/// \brief class representing camera intrinsics and related functions
///
class mitkCameraCalibration_EXPORT CameraIntrinsics: virtual public itk::Object,
virtual public mitk::XMLSerializable
{
public:
///
/// for testing purposes
///
friend int mitkCameraIntrinsicsTest(int argc, char* argv[]);
///
/// smartpointer typedefs
///
mitkClassMacro(CameraIntrinsics, itk::Object);
///
/// the static new function
///
itkFactorylessNewMacro(Self);
///
/// make a clone of this intrinsics
///
- Pointer Clone() const;
+ itkCloneMacro(Self)
///
/// copy information from other to this
///
void Copy(const CameraIntrinsics* other);
///
/// checks two intrinsics for equality
///
bool Equals( const CameraIntrinsics* other ) const;
///
/// \return the intrinsic parameter matrix as a 3x3 vnl matrix
///
vnl_matrix_fixed<mitk::ScalarType, 3, 3> GetVnlCameraMatrix() const;
///
/// \return the intrinsic parameter matrix as a 3x4 vnl matrix
/// (the last column only containing zeros)
///
vnl_matrix_fixed<mitk::ScalarType, 3, 4> GetVnlCameraMatrix3x4() const;
///
/// \return true if the intrinsics are set (some plausibility checks
/// may be done here)
///
bool IsValid() const;
void SetValid(bool valid);
cv::Mat GetCameraMatrix() const;
cv::Mat GetDistorsionCoeffs();
cv::Mat GetDistorsionCoeffs() const;
void ToXML(TiXmlElement* elem) const;
std::string ToString() const;
std::string GetString();
double GetFocalLengthX() const;
double GetFocalLengthY() const;
double GetPrincipalPointX() const;
double GetPrincipalPointY() const;
mitk::Point4D GetDistorsionCoeffsAsPoint4D() const;
mitk::Point3D GetFocalPoint() const;
mitk::Point3D GetPrincipalPoint() const;
vnl_vector_fixed<mitk::ScalarType, 2> GetFocalPointAsVnlVector() const;
vnl_vector_fixed<mitk::ScalarType, 2> GetPrincipalPointAsVnlVector() const;
///
/// set a new camera matrix utilizing a vnl matrix
///
void SetCameraMatrix( const vnl_matrix_fixed<mitk::ScalarType, 3, 3>&
_CameraMatrix );
void SetIntrinsics( const cv::Mat& _CameraMatrix
, const cv::Mat& _DistorsionCoeffs);
void SetFocalLength( double x, double y );
void SetPrincipalPoint( double x, double y );
void SetDistorsionCoeffs( double k1, double k2, double p1, double p2 );
void SetIntrinsics( const mitk::Point3D& focalPoint,
const mitk::Point3D& principalPoint,
const mitk::Point4D& distortionCoefficients);
void FromXML(TiXmlElement* elem);
void FromGMLCalibrationXML(TiXmlElement* elem);
std::string ToOctaveString(const std::string& varName="CameraIntrinsics");
virtual ~CameraIntrinsics();
protected:
CameraIntrinsics();
CameraIntrinsics(const CameraIntrinsics& other);
cv::Mat m_CameraMatrix;
cv::Mat m_DistorsionCoeffs;
bool m_Valid;
itk::FastMutexLock::Pointer m_Mutex;
private:
virtual itk::LightObject::Pointer InternalClone() const;
};
} // namespace mitk
mitkCameraCalibration_EXPORT std::ostream& operator<<
(std::ostream& os, mitk::CameraIntrinsics::Pointer p);
#endif // mitkCameraIntrinsics_h
diff --git a/Modules/CameraCalibration/mitkCameraIntrinsicsProperty.cpp b/Modules/CameraCalibration/mitkCameraIntrinsicsProperty.cpp
index fb9aefcd13..eed4e54674 100644
--- a/Modules/CameraCalibration/mitkCameraIntrinsicsProperty.cpp
+++ b/Modules/CameraCalibration/mitkCameraIntrinsicsProperty.cpp
@@ -1,68 +1,62 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkCameraIntrinsicsProperty.h"
namespace mitk {
bool CameraIntrinsicsProperty::IsEqual(const BaseProperty& property) const
{
return this->m_Value->Equals(static_cast<const Self&>(property).m_Value.GetPointer());
}
bool CameraIntrinsicsProperty::Assign(const BaseProperty& property)
{
this->m_Value = static_cast<const Self&>(property).m_Value;
return true;
}
std::string CameraIntrinsicsProperty::GetValueAsString() const
{
std::stringstream myStr;
myStr << GetValue();
return myStr.str();
}
CameraIntrinsicsProperty::CameraIntrinsicsProperty()
: BaseProperty()
{}
CameraIntrinsicsProperty::CameraIntrinsicsProperty(const CameraIntrinsicsProperty& other)
: BaseProperty(other)
{
}
CameraIntrinsicsProperty::CameraIntrinsicsProperty( mitk::CameraIntrinsics::Pointer value )
: BaseProperty(), m_Value( value )
{}
-CameraIntrinsicsProperty::Pointer CameraIntrinsicsProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer CameraIntrinsicsProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
}
// namespace mitk
diff --git a/Modules/CameraCalibration/mitkCameraIntrinsicsProperty.h b/Modules/CameraCalibration/mitkCameraIntrinsicsProperty.h
index 44baecdb4f..52326c8a39 100644
--- a/Modules/CameraCalibration/mitkCameraIntrinsicsProperty.h
+++ b/Modules/CameraCalibration/mitkCameraIntrinsicsProperty.h
@@ -1,77 +1,75 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKCAMERAINTRINSICSPROPERTY_H
#define MITKCAMERAINTRINSICSPROPERTY_H
#include "mitkBaseProperty.h"
#include "mitkCameraIntrinsics.h"
namespace mitk {
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
class mitkCameraCalibration_EXPORT CameraIntrinsicsProperty : public BaseProperty
{
public:
typedef mitk::CameraIntrinsics::Pointer ValueType;
mitkClassMacro(CameraIntrinsicsProperty, BaseProperty);
itkNewMacro(CameraIntrinsicsProperty);
mitkNewMacro1Param(CameraIntrinsicsProperty, mitk::CameraIntrinsics::Pointer);
- Pointer Clone() const;
-
itkSetMacro(Value, mitk::CameraIntrinsics::Pointer );
itkGetConstMacro(Value, mitk::CameraIntrinsics::Pointer );
std::string GetValueAsString() const;
using BaseProperty::operator=;
protected:
mitk::CameraIntrinsics::Pointer m_Value;
CameraIntrinsicsProperty();
CameraIntrinsicsProperty(const CameraIntrinsicsProperty&);
CameraIntrinsicsProperty( mitk::CameraIntrinsics::Pointer value );
private:
// purposely not implemented
CameraIntrinsicsProperty& operator=(const CameraIntrinsicsProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
virtual bool IsEqual(const BaseProperty& property) const;
virtual bool Assign(const BaseProperty& property);
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace mitk
#endif // MITKCAMERAINTRINSICSPROPERTY_H
diff --git a/Modules/CameraCalibration/mitkTransform.cpp b/Modules/CameraCalibration/mitkTransform.cpp
index 937e85407a..c0151ef3b7 100644
--- a/Modules/CameraCalibration/mitkTransform.cpp
+++ b/Modules/CameraCalibration/mitkTransform.cpp
@@ -1,749 +1,749 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTransform.h"
#include <fstream>
#include <vnl/vnl_inverse.h>
#include <mitkVnlVectorFixedCaster.h>
#include <mitkVnlVectorFromCvMat.h>
#include <mitkVnlMatrixFromCvMat.h>
#include <mitkCvMatFromVnlVector.h>
namespace mitk
{
// DO NOT CHANGE THE VALUES OF THESE CONSTANTS!!
const std::string Transform::UNKNOWN_TYPE = "Unknown type";
const std::string Transform::ENDOSCOPE_SCOPE_TOOL = "Endoscope scope tool";
const std::string Transform::ENDOSCOPE_CAM_TOOL = "Endoscope camera tool";
const std::string Transform::CHESSBOARD_TOOL = "Chessboard tool";
const std::string Transform::POINTER_TOOL = "Pointer tool";
const std::string Transform::POINTER_TO_CHESSBOARD_ORIGIN = "Pointer to chessboard origin";
const std::string Transform::POINTER_TO_CHESSBOARD_X_SUPPORT_POINT = "Pointer to chessboard X support origin";
const std::string Transform::POINTER_TO_CHESSBOARD_Y_SUPPORT_POINT = "Pointer to chessboard Y support origin";
const std::string Transform::BOARD_TO_BOARD_TOOL = "Board to board tool";
const std::string Transform::REFERENCE_CAMERA_TRANSFORM = "Reference camera transform";
const std::string Transform::REFERENCE_SCOPE_TRANSFORM = "Reference scope transform";
const std::string Transform::EYE_TO_HAND_TRANSFORM = "Eye to hand transform";
const std::string Transform::CAMERA_EXTRINSICS = "Camera extrinsics";
Transform::Transform()
: m_NavData(mitk::NavigationData::New()), m_Type( UNKNOWN_TYPE )
{
vnl_matrix_fixed<mitk::ScalarType, 3, 3> rot;
rot.set_identity();
this->SetRotation( rot );
}
Transform::Transform(const mitk::NavigationData* nd)
: m_NavData(mitk::NavigationData::New()), m_Type( UNKNOWN_TYPE )
{
m_NavData->Graft(nd);
}
Transform::Transform(const std::string& s)
: m_NavData(mitk::NavigationData::New()), m_Type( s )
{
vnl_matrix_fixed<mitk::ScalarType, 3, 3> rot;
rot.set_identity();
this->SetRotation( rot );
}
void Transform::Copy(const mitk::NavigationData* nd)
{
(const_cast<mitk::NavigationData*>(m_NavData.GetPointer()))->Graft(nd);
}
void Transform::Concatenate( mitk::Transform* transform )
{
vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat = transform->GetMatrix();
mat = mat * this->GetMatrix(); //
this->SetMatrix( mat );
}
void Transform::Concatenate( const vnl_matrix_fixed<mitk::ScalarType, 4, 4>&
transform )
{
Transform::Pointer t = Transform::New();
t->SetMatrix( transform );
this->Concatenate( t );
}
void Transform::Concatenate( const vtkMatrix4x4* transform )
{
Transform::Pointer t = Transform::New();
t->SetMatrix( transform );
this->Concatenate( t );
}
void Transform::Reset()
{
mitk::NavigationData::Pointer nd
= NavigationData::New();
this->Copy( nd );
}
void Transform::SetOrientation(
const vnl_quaternion<mitk::ScalarType>& orientation)
{
m_NavData->SetOrientation(orientation);
this->Modified();
}
void Transform::SetTranslation( const vnl_vector_fixed<mitk::ScalarType, 3>&
transl)
{
mitk::Point3D p;
for(unsigned int i=0; i<3; ++i)
p[i] = transl[i];
m_NavData->SetPosition(p);
this->Modified();
}
void Transform::SetTranslation( float* array )
{
vnl_vector_fixed<mitk::ScalarType, 3> vec;
for(unsigned int i=0; i<vec.size(); i++)
vec(i) = array[i];
this->SetTranslation( vec );
}
void Transform::SetRotation( float* array )
{
vnl_matrix_fixed<mitk::ScalarType, 3, 3> mat;
unsigned int row = 0;
unsigned int col = 0;
for(unsigned int i=0; i<mat.rows()*mat.cols(); i++)
{
if( i > 0 && i % 3 == 0 )
{
++row;
col = 0;
}
mat(row,col) = array[i];
++col;
}
this->SetRotation( mat );
}
void Transform::SetOrientation( const vnl_quaternion<double>& orientation)
{
vnl_vector_fixed<mitk::ScalarType, 4> qvec;
VnlVectorFixedCaster<double, mitk::ScalarType, 4> caster( &orientation, &qvec );
caster.Update();
mitk::Quaternion p( qvec );
this->SetOrientation( p );
}
vnl_vector_fixed<double, 3> Transform::GetVnlDoubleTranslation() const
{
vnl_vector_fixed<mitk::ScalarType, 3> vecFloat = this->GetVnlTranslation();
vnl_vector_fixed<double, 3> vecDouble;
VnlVectorFixedCaster<mitk::ScalarType, double, 3> caster( &vecFloat, &vecDouble );
caster.Update();
return vecDouble;
}
void Transform::SetTranslation( const vnl_vector<double>& transl)
{
vnl_vector_fixed<double, 3> dTransl(transl);
vnl_vector_fixed<mitk::ScalarType, 3> fTransl;
VnlVectorFixedCaster<double, mitk::ScalarType, 3> caster( &dTransl, &fTransl );
caster.Update();
this->SetTranslation( fTransl );
}
vnl_quaternion<double> Transform::GetVnlDoubleQuaternion() const
{
mitk::Quaternion fOrientation = this->GetOrientation();
vnl_quaternion<double> dOrientation;
VnlVectorFixedCaster<mitk::ScalarType, double, 4> caster( &fOrientation, &dOrientation );
caster.Update();
return dOrientation;
}
void Transform::FromCSVFile(const std::string& file)
{
std::ifstream csvFile (file.c_str());
endoAssert ( csvFile.fail() == false );
mitk::Transform::Pointer transform = mitk::Transform::New();
vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat;
std::string line;
mitk::ScalarType d = 0.0f;
int row=0,column = 0;
while (std::getline (csvFile, line))
{
std::istringstream linestream(line);
std::string item;
column = 0;
while (std::getline (linestream, item, ','))
{
std::istringstream number;
number.str(item);
number >> d;
mat(row, column) = d;
++column;
}
++row;
}
endoAssert( row == 4 && column == 4 );
transform->SetMatrix( mat );
this->SetNavigationData( transform->GetNavigationData() );
// modified is called in SetNavigationData
}
std::string Transform::ToCSVString() const
{
std::ostringstream s; s.precision(12);
vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat
= this->GetMatrix();
for( unsigned int j=0; j<mat.rows(); ++j )
{
for( unsigned int k=0; k<mat.cols(); ++k )
{
s << mat(j,k);
if(k+1<mat.cols())
s << ",";
}
if(j+1<mat.rows())
s << std::endl;
}
return s.str();
}
std::string Transform::ToMatlabString(const std::string& varname
, bool printLastRow) const
{
std::ostringstream s; s.precision(12);
vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat
= this->GetMatrix();
s << varname << " = [";
for( unsigned int j=0; j<mat.rows(); ++j )
{
if( !printLastRow && j+1 == mat.rows() )
break;
for( unsigned int k=0; k<mat.cols(); ++k )
{
s << mat(j,k) << " ";
}
s << ";";
}
s << "];" << std::endl;
return s.str();
}
void Transform::Copy( const mitk::Transform* transform )
{
m_NavData->Graft(transform->GetNavigationData());
m_Type = transform->GetType();
}
mitk::Transform::Pointer Transform::Clone() const
{
Transform::Pointer copy = Transform::New();
copy->Copy( this );
return copy;
}
void Transform::SetMatrix( const vtkMatrix4x4* mat)
{
vnl_matrix_fixed<mitk::ScalarType, 4, 4> vnlMat;
for(unsigned int i=0; i<4; ++i)
for(unsigned int j=0; j<4; ++j)
vnlMat(i,j) = mat->GetElement(i, j);
this->SetMatrix( vnlMat );
}
void Transform::ToCSVFile(const std::string& file) const
{
std::ofstream csvFile;
csvFile.open(file.c_str());
endoAssert ( csvFile.fail() == false );
csvFile << this->ToCSVString();
csvFile.close();
}
void Transform::ToMatlabFile(const std::string& file
, const std::string& varname) const
{
std::ofstream csvFile;
csvFile.open(file.c_str());
endoAssert ( csvFile.fail() == false );
csvFile << this->ToMatlabString(varname);
csvFile.close();
}
void Transform::SetNavigationData( const mitk::NavigationData* naviData )
{
endoAssert( naviData != 0 );
m_NavData->Graft( naviData );
this->Modified();
}
void Transform::SetRotation( vnl_matrix_fixed<mitk::ScalarType, 3, 3>& mat)
{
this->m_NavData->SetOrientation( mitk::Quaternion(mat) );
this->Modified();
}
void Transform::SetRotation( vnl_matrix<mitk::ScalarType>& mat)
{
vnl_matrix_fixed<mitk::ScalarType, 3, 3> tmp(mat);
this->SetRotation( tmp );
}
void Transform::SetPosition( const mitk::Point3D& transl)
{
this->SetTranslation( transl.GetVnlVector() );
}
void Transform::SetTranslation( double array[3] )
{
mitk::Point3D p;
for(unsigned int i = 0; i < 3; ++i)
p.SetElement(i, array[i]);
this->SetTranslation( p.GetVnlVector() );
}
void Transform::SetRotation( double array[3][3] )
{
vnl_matrix_fixed<mitk::ScalarType, 3, 3> mat;
for(unsigned int i = 0; i < 3; ++i)
for(unsigned int j = 0; j < 3; ++j)
mat(i, j) = array[i][j];
this->SetRotation( mat );
}
void Transform::Invert()
{
vnl_matrix_fixed<mitk::ScalarType, 4, 4> tmp(this->GetMatrix());
this->SetMatrix( vnl_inverse( tmp ) );
}
void Transform::SetMatrix(
const vnl_matrix_fixed<mitk::ScalarType, 4, 4>& mat)
{
// set translation first
vnl_vector<mitk::ScalarType> transl = mat.get_column(3);
mitk::Point3D p;
for(unsigned int i=0; i<3; ++i)
p[i] = transl[i];
m_NavData->SetPosition(p);
// set rotation
vnl_matrix_fixed<mitk::ScalarType, 3, 3> rotMatFixed(
mat.extract(3,3));
this->SetRotation(rotMatFixed);
}
bool Transform::IsValid() const
{
return m_NavData->IsDataValid();
}
void Transform::SetTranslation( const cv::Mat& transl)
{
vnl_vector<mitk::ScalarType> vec(3);
VnlVectorFromCvMat<mitk::ScalarType> _VnlVectorFromCvMat( &transl, &vec );
_VnlVectorFromCvMat.Update();
this->SetTranslation( vnl_vector_fixed<mitk::ScalarType, 3>( vec ) );
}
void Transform::SetRotation( const cv::Mat& mat )
{
vnl_matrix<mitk::ScalarType> vnlMat(3, 3);
VnlMatrixFromCvMat<mitk::ScalarType> _VnlMatrixFromCvMat( &mat, &vnlMat );
_VnlMatrixFromCvMat.Update();
vnl_matrix_fixed<mitk::ScalarType, 3, 3> vnlMatFixed(vnlMat);
this->SetRotation(vnlMatFixed);
}
void Transform::SetRotationVector( const cv::Mat& rotVec )
{
cv::Mat rotMat;
cv::Rodrigues( rotVec, rotMat );
vnl_matrix<mitk::ScalarType> vnlMat(3, 3);
VnlMatrixFromCvMat<mitk::ScalarType> _VnlMatrixFromCvMat( &rotMat, &vnlMat );
_VnlMatrixFromCvMat.Update();
vnl_matrix_fixed<mitk::ScalarType, 3, 3> vnlMatFixed(vnlMat);
this->SetRotation( vnlMatFixed );
}
//# getter
mitk::NavigationData::Pointer Transform::GetNavigationData() const
{
return m_NavData;
}
mitk::Point3D Transform::GetTranslation() const
{
return m_NavData->GetPosition();
}
mitk::Point3D Transform::GetPosition() const
{
return m_NavData->GetPosition();
}
mitk::Quaternion Transform::GetOrientation() const
{
return m_NavData->GetOrientation();
}
void Transform::GetMatrix(vtkMatrix4x4* matrix) const
{
vnl_matrix_fixed<mitk::ScalarType, 4, 4> vnlMat = this->GetMatrix();
for(unsigned int i=0; i<vnlMat.rows(); ++i)
for(unsigned int j=0; j<vnlMat.cols(); ++j)
matrix->SetElement(i,j, vnlMat(i,j));
}
void Transform::GetVtkOpenGlMatrix(vtkMatrix4x4* matrix) const
{
vnl_matrix<mitk::ScalarType> vnlRotation
= this->GetVnlRotationMatrix().as_matrix();
// normalize rows of rotation matrix
vnlRotation.normalize_rows();
vnl_matrix<mitk::ScalarType> vnlInverseRotation(3,3);
// invert rotation
vnlInverseRotation = vnl_matrix_inverse<mitk::ScalarType>(vnlRotation);
vnl_vector<mitk::ScalarType> vnlTranslation
= this->GetPosition().GetVnlVector();
// rotate translation vector by inverse rotation P = P'
vnlTranslation = vnlInverseRotation * vnlTranslation;
vnlTranslation *= -1; // save -P'
// set position
mitk::Transform::Pointer tmp = mitk::Transform::New();
tmp->SetTranslation( vnlTranslation );
tmp->SetRotation( vnlRotation );
tmp->GetMatrix(matrix);
}
mitk::Point3D Transform::TransformPoint(mitk::Point3D point) const
{
itk::Matrix<mitk::ScalarType,3,3> R(GetVnlRotationMatrix());
itk::Point<mitk::ScalarType,3> pointR = (R * point);
mitk::Point3D retPoint = pointR;
retPoint[0] = pointR[0] + GetPosition()[0];
retPoint[1] = pointR[1] + GetPosition()[1];
retPoint[2] = pointR[2] + GetPosition()[2];
return retPoint;
}
//# cv getter
cv::Mat Transform::GetCvTranslation() const
{
cv::Mat mat;
vnl_vector<mitk::ScalarType> vec = this->GetVnlTranslation().as_vector();
endodebugvar( vec )
CvMatFromVnlVector<mitk::ScalarType> _CvMatFromVnlVector(&vec, &mat);
_CvMatFromVnlVector.Update();
return mat;
}
cv::Mat Transform::GetCvRotationMatrix() const
{
cv::Mat mat;
vnl_matrix<mitk::ScalarType> vec = this->GetVnlRotationMatrix().as_matrix();
endodebugvar( vec )
CvMatFromVnlMatrix<mitk::ScalarType> _CvMatFromVnlMatrix(&vec, &mat);
_CvMatFromVnlMatrix.Update();
return mat;
}
cv::Mat Transform::GetCvMatrix() const
{
cv::Mat mat;
vnl_matrix<mitk::ScalarType> vec = this->GetMatrix().as_matrix();
CvMatFromVnlMatrix<mitk::ScalarType> _CvMatFromVnlMatrix(&vec, &mat);
_CvMatFromVnlMatrix.Update();
return mat;
}
cv::Mat Transform::GetCvRotationVector() const
{
cv::Mat rotVec(3,1,cv::DataType<mitk::ScalarType>::type);
cv::Rodrigues( this->GetCvRotationMatrix(), rotVec );
return rotVec;
}
//# vnl getter
vnl_vector_fixed<mitk::ScalarType, 3> Transform::GetVnlTranslation() const
{
vnl_vector_fixed<mitk::ScalarType, 3> vec(m_NavData->GetPosition()
.GetVnlVector());
return vec;
}
vnl_matrix_fixed<mitk::ScalarType, 3, 3> Transform::GetVnlRotationMatrix() const
{
return m_NavData->GetOrientation().rotation_matrix_transpose();
}
vnl_matrix_fixed<double, 4, 4> Transform::GetVnlDoubleMatrix() const
{
vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat = this->GetMatrix();
vnl_matrix_fixed<double, 4, 4> doubleMat;
for(unsigned int i=0; i<mat.rows(); ++i)
for(unsigned int j=0; j<mat.cols(); ++j)
doubleMat(i,j) = static_cast<double>( mat(i,j) );
return doubleMat;
}
vnl_matrix_fixed<mitk::ScalarType, 4, 4> Transform::GetMatrix()
const
{
vnl_vector_fixed<mitk::ScalarType, 3> transl = this->GetVnlTranslation();
vnl_matrix_fixed<mitk::ScalarType, 3, 3> rot = this->GetVnlRotationMatrix();
vnl_matrix_fixed<mitk::ScalarType, 4, 4> homMat;
homMat.set_identity();
//std::cout << homMat << std::endl;
for(unsigned int i=0; i<rot.rows(); ++i)
for(unsigned int j=0; j<rot.cols(); ++j)
homMat(i,j) = rot(i,j);
for(unsigned int i=0; i<transl.size(); ++i)
homMat(i,3) = transl[i];
return homMat;
}
void Transform::TransposeRotation()
{
vnl_matrix_fixed<mitk::ScalarType, 3, 3> rotMat = this->GetVnlRotationMatrix().transpose();
this->SetRotation( rotMat );
}
void Transform::SetValid( bool valid )
{
if( m_NavData->IsDataValid() == valid )
return;
m_NavData->SetDataValid( valid );
this->Modified();
}
std::string mitk::Transform::ToString() const
{
std::ostringstream s; s.precision(12);
mitk::NavigationData::PositionType position;
position.Fill(0.0);
position = m_NavData->GetPosition();
mitk::NavigationData::OrientationType orientation(0.0, 0.0, 0.0, 0.0);
orientation = m_NavData->GetOrientation();
s << "Translation: [" << position[0] << ", " << position[1] << ", "
<< position[2] << "]";
s << ", orientation: [" << orientation[0] << ", " << orientation[1] << ", "
<< orientation[2] << ", " << orientation[3] << "]";
s << ", valid: [" << (this->IsValid()? "true": "false") << "]";
return s.str();
}
void mitk::Transform::ToXML(TiXmlElement* elem) const
{
std::string value = elem->ValueStr();
if(value.empty())
elem->SetValue(this->GetNameOfClass());
mitk::NavigationData::PositionType position;
position.Fill(0.0);
position = m_NavData->GetPosition();
mitk::NavigationData::OrientationType orientation(0.0, 0.0, 0.0, 0.0);
orientation = m_NavData->GetOrientation();
mitk::NavigationData::CovarianceMatrixType matrix;
matrix.SetIdentity();
matrix = m_NavData->GetCovErrorMatrix();
bool hasPosition = true;
hasPosition = m_NavData->GetHasPosition();
bool hasOrientation = true;
hasOrientation = m_NavData->GetHasOrientation();
bool dataValid = false;
dataValid = m_NavData->IsDataValid();
mitk::NavigationData::TimeStampType timestamp=0.0;
elem->SetAttribute("Type", m_Type);
elem->SetDoubleAttribute("Time", timestamp);
elem->SetDoubleAttribute("X", position[0]);
elem->SetDoubleAttribute("Y", position[1]);
elem->SetDoubleAttribute("Z", position[2]);
elem->SetDoubleAttribute("QX", orientation[0]);
elem->SetDoubleAttribute("QY", orientation[1]);
elem->SetDoubleAttribute("QZ", orientation[2]);
elem->SetDoubleAttribute("QR", orientation[3]);
elem->SetDoubleAttribute("C00", matrix[0][0]);
elem->SetDoubleAttribute("C01", matrix[0][1]);
elem->SetDoubleAttribute("C02", matrix[0][2]);
elem->SetDoubleAttribute("C03", matrix[0][3]);
elem->SetDoubleAttribute("C04", matrix[0][4]);
elem->SetDoubleAttribute("C05", matrix[0][5]);
elem->SetDoubleAttribute("C10", matrix[1][0]);
elem->SetDoubleAttribute("C11", matrix[1][1]);
elem->SetDoubleAttribute("C12", matrix[1][2]);
elem->SetDoubleAttribute("C13", matrix[1][3]);
elem->SetDoubleAttribute("C14", matrix[1][4]);
elem->SetDoubleAttribute("C15", matrix[1][5]);
if (dataValid)
elem->SetAttribute("Valid",1);
else
elem->SetAttribute("Valid",0);
if (hasOrientation)
elem->SetAttribute("hO",1);
else
elem->SetAttribute("hO",0);
if (hasPosition)
elem->SetAttribute("hP",1);
else
elem->SetAttribute("hP",0);
}
void mitk::Transform::FromXML(TiXmlElement* elem)
{
assert(elem);
mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
mitk::NavigationData::PositionType position;
mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
mitk::NavigationData::TimeStampType timestamp = -1;
mitk::NavigationData::CovarianceMatrixType matrix;
bool hasPosition = true;
bool hasOrientation = true;
bool dataValid = false;
position.Fill(0.0);
matrix.SetIdentity();
std::string type = Transform::UNKNOWN_TYPE;
elem->QueryStringAttribute("Type", &type);
elem->QueryDoubleAttribute("Time",&timestamp);
// position and orientation is mandatory!
if(elem->QueryFloatAttribute("X", &position[0]) != TIXML_SUCCESS)
throw std::invalid_argument("No X position found in xml");
if(elem->QueryFloatAttribute("Y", &position[1]) != TIXML_SUCCESS)
throw std::invalid_argument("No Y position found in xml");
if(elem->QueryFloatAttribute("Z", &position[2]) != TIXML_SUCCESS)
throw std::invalid_argument("No Z position found in xml");
if(elem->QueryFloatAttribute("QX", &orientation[0]) != TIXML_SUCCESS)
throw std::invalid_argument("No QX orientation found in xml");
if(elem->QueryFloatAttribute("QY", &orientation[1]) != TIXML_SUCCESS)
throw std::invalid_argument("No QY orientation found in xml");
if(elem->QueryFloatAttribute("QZ", &orientation[2]) != TIXML_SUCCESS)
throw std::invalid_argument("No QZ orientation found in xml");
if(elem->QueryFloatAttribute("QR", &orientation[3]) != TIXML_SUCCESS)
throw std::invalid_argument("No QR orientation found in xml");
elem->QueryFloatAttribute("C00", &matrix[0][0]);
elem->QueryFloatAttribute("C01", &matrix[0][1]);
elem->QueryFloatAttribute("C02", &matrix[0][2]);
elem->QueryFloatAttribute("C03", &matrix[0][3]);
elem->QueryFloatAttribute("C04", &matrix[0][4]);
elem->QueryFloatAttribute("C05", &matrix[0][5]);
elem->QueryFloatAttribute("C10", &matrix[1][0]);
elem->QueryFloatAttribute("C11", &matrix[1][1]);
elem->QueryFloatAttribute("C12", &matrix[1][2]);
elem->QueryFloatAttribute("C13", &matrix[1][3]);
elem->QueryFloatAttribute("C14", &matrix[1][4]);
elem->QueryFloatAttribute("C15", &matrix[1][5]);
int tmpval = 0;
elem->QueryIntAttribute("Valid", &tmpval);
if (tmpval == 0)
dataValid = false;
else
dataValid = true;
tmpval = 0;
elem->QueryIntAttribute("hO", &tmpval);
if (tmpval == 0)
hasOrientation = false;
else
hasOrientation = true;
tmpval = 0;
elem->QueryIntAttribute("hP", &tmpval);
if (tmpval == 0)
hasPosition = false;
else
hasPosition = true;
- nd->SetTimeStamp(timestamp);
+ nd->SetIGTTimeStamp(timestamp);
nd->SetPosition(position);
nd->SetOrientation(orientation);
nd->SetCovErrorMatrix(matrix);
nd->SetDataValid(dataValid);
nd->SetHasOrientation(hasOrientation);
nd->SetHasPosition(hasPosition);
m_NavData = nd;
m_Type = type;
this->Modified();
}
} // namespace mitk
std::ostream& operator<< (std::ostream& os, mitk::Transform::Pointer p)
{
os << p->ToString();
return os;
}
diff --git a/Modules/DeformableRegistration/mitkBSplineRegistration.cpp b/Modules/DeformableRegistration/mitkBSplineRegistration.cpp
index 4f4cbe1fca..668a4ce3e3 100644
--- a/Modules/DeformableRegistration/mitkBSplineRegistration.cpp
+++ b/Modules/DeformableRegistration/mitkBSplineRegistration.cpp
@@ -1,370 +1,370 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkImageCast.h>
#include "itkImageFileWriter.h"
#include "itkWarpImageFilter.h"
#include "itkImageRegionIterator.h"
#include "mitkBSplineRegistration.h"
#include "itkBSplineDeformableTransform.h"
//#include "itkLBFGSOptimizer.h"
#include "itkMeanSquaresImageToImageMetric.h"
#include "itkMattesMutualInformationImageToImageMetric.h"
#include "itkResampleImageFilter.h"
#include "itkImageRegistrationMethod.h"
#include "itkBSplineDeformableTransformInitializer.h"
#include "mitkOptimizerFactory.h"
#include "mitkMetricFactory.h"
#include <itkRescaleIntensityImageFilter.h>
#include <itkHistogramMatchingImageFilter.h>
namespace mitk {
BSplineRegistration::BSplineRegistration():
m_Iterations(50),
m_ResultName("deformedImage.mhd"),
m_SaveResult(true),
m_SaveDeformationField(false),
m_UpdateInputImage(false),
m_MatchHistograms(true),
m_Metric(0)
{
m_Observer = mitk::RigidRegistrationObserver::New();
}
BSplineRegistration::~BSplineRegistration()
{
}
void BSplineRegistration::SetNumberOfIterations(int iterations)
{
m_Iterations = iterations;
}
void BSplineRegistration::SetSaveResult(bool saveResult)
{
m_SaveResult = saveResult;
}
void BSplineRegistration::SetResultFileName(const char* resultName)
{
m_ResultName = resultName;
}
template < typename TPixel, unsigned int VImageDimension >
void BSplineRegistration::GenerateData2( itk::Image<TPixel, VImageDimension>* itkImage1)
{
std::cout << "start bspline registration" << std::endl;
// Typedefs
typedef typename itk::Image< TPixel, VImageDimension > InternalImageType;
typedef typename itk::Vector< float, VImageDimension > VectorPixelType;
typedef typename itk::Image< VectorPixelType, VImageDimension > DeformationFieldType;
typedef itk::BSplineDeformableTransform<
double,
VImageDimension,
3 > TransformType;
typedef typename TransformType::ParametersType ParametersType;
//typedef itk::LBFGSOptimizer OptimizerType;
typedef itk::SingleValuedNonLinearOptimizer OptimizerType;
//typedef itk::SingleValuedCostFunction MetricType;
typedef itk::MattesMutualInformationImageToImageMetric<
InternalImageType,
InternalImageType > MetricType;
typedef itk::MeanSquaresImageToImageMetric<
InternalImageType,
InternalImageType > MetricTypeMS;
typedef itk::LinearInterpolateImageFunction<
InternalImageType,
double > InterpolatorType;
typedef itk::ImageRegistrationMethod<
InternalImageType,
InternalImageType > RegistrationType;
typedef typename itk::WarpImageFilter<
InternalImageType,
InternalImageType,
DeformationFieldType > WarperType;
typedef typename TransformType::SpacingType SpacingType;
typedef typename TransformType::OriginType OriginType;
typedef itk::ResampleImageFilter<
InternalImageType,
InternalImageType > ResampleFilterType;
typedef itk::Image< TPixel, VImageDimension > OutputImageType;
// Sample new image with the same image type as the fixed image
typedef itk::CastImageFilter<
InternalImageType,
InternalImageType > CastFilterType;
typedef itk::Vector< float, VImageDimension > VectorType;
typedef itk::Image< VectorType, VImageDimension > DeformationFieldType;
typedef itk::BSplineDeformableTransformInitializer <
TransformType,
InternalImageType > InitializerType;
typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
typename RegistrationType::Pointer registration = RegistrationType::New();
typename InitializerType::Pointer initializer = InitializerType::New();
typename TransformType::Pointer transform = TransformType::New();
if(m_Metric==0 || m_Metric==1)
{
typename MetricType::Pointer metric = MetricType::New();
metric->SetNumberOfHistogramBins( 32);
metric->SetNumberOfSpatialSamples(90000);
registration->SetMetric( metric );
}
else{
typename MetricTypeMS::Pointer metric = MetricTypeMS::New();
registration->SetMetric( metric );
}
typename OptimizerFactory::Pointer optFac = OptimizerFactory::New();
optFac->SetOptimizerParameters(m_OptimizerParameters);
optFac->SetNumberOfTransformParameters(transform->GetNumberOfParameters());
OptimizerType::Pointer optimizer = optFac->GetOptimizer();
optimizer->AddObserver(itk::AnyEvent(), m_Observer);
//typedef mitk::MetricFactory <TPixel, VImageDimension> MetricFactoryType;
//typename MetricFactoryType::Pointer metricFac = MetricFactoryType::New();
//metricFac->SetMetricParameters(m_MetricParameters);
////MetricType::Pointer metric = metricFac->GetMetric();
typename InternalImageType::Pointer fixedImage = InternalImageType::New();
mitk::CastToItkImage(m_ReferenceImage, fixedImage);
typename InternalImageType::Pointer movingImage = itkImage1;
typename InternalImageType::RegionType fixedRegion = fixedImage->GetBufferedRegion();
typename InternalImageType::RegionType movingRegion = movingImage->GetBufferedRegion();
if(m_MatchHistograms)
{
typedef itk::RescaleIntensityImageFilter<InternalImageType,InternalImageType> FilterType;
typedef itk::HistogramMatchingImageFilter<InternalImageType,InternalImageType> HEFilterType;
typename FilterType::Pointer inputRescaleFilter = FilterType::New();
typename FilterType::Pointer referenceRescaleFilter = FilterType::New();
referenceRescaleFilter->SetInput(fixedImage);
inputRescaleFilter->SetInput(movingImage);
TPixel desiredMinimum = 0;
TPixel desiredMaximum = 255;
referenceRescaleFilter->SetOutputMinimum( desiredMinimum );
referenceRescaleFilter->SetOutputMaximum( desiredMaximum );
referenceRescaleFilter->UpdateLargestPossibleRegion();
inputRescaleFilter->SetOutputMinimum( desiredMinimum );
inputRescaleFilter->SetOutputMaximum( desiredMaximum );
inputRescaleFilter->UpdateLargestPossibleRegion();
// Histogram match the images
typename HEFilterType::Pointer intensityEqualizeFilter = HEFilterType::New();
intensityEqualizeFilter->SetReferenceImage( inputRescaleFilter->GetOutput() );
intensityEqualizeFilter->SetInput( referenceRescaleFilter->GetOutput() );
intensityEqualizeFilter->SetNumberOfHistogramLevels( 64 );
intensityEqualizeFilter->SetNumberOfMatchPoints( 12 );
intensityEqualizeFilter->ThresholdAtMeanIntensityOn();
intensityEqualizeFilter->Update();
//fixedImage = referenceRescaleFilter->GetOutput();
//movingImage = IntensityEqualizeFilter->GetOutput();
fixedImage = intensityEqualizeFilter->GetOutput();
movingImage = inputRescaleFilter->GetOutput();
}
//
registration->SetOptimizer( optimizer );
registration->SetInterpolator( interpolator );
registration->SetFixedImage( fixedImage );
registration->SetMovingImage( movingImage );
registration->SetFixedImageRegion(fixedRegion );
initializer->SetTransform(transform);
initializer->SetImage(fixedImage);
initializer->SetNumberOfGridNodesInsideTheImage( m_NumberOfGridPoints );
initializer->InitializeTransform();
registration->SetTransform( transform );
const unsigned int numberOfParameters = transform->GetNumberOfParameters();
typename itk::BSplineDeformableTransform<
double,
VImageDimension,
3 >::ParametersType parameters;
parameters.set_size(numberOfParameters);
parameters.Fill( 0.0 );
transform->SetParameters( parameters );
// We now pass the parameters of the current transform as the initial
// parameters to be used when the registration process starts.
registration->SetInitialTransformParameters( transform->GetParameters() );
std::cout << "Intial Parameters = " << std::endl;
std::cout << transform->GetParameters() << std::endl;
std::cout << std::endl << "Starting Registration" << std::endl;
try
{
double tstart(clock());
- registration->StartRegistration();
+ registration->Update();
double time = clock() - tstart;
time = time / CLOCKS_PER_SEC;
MITK_INFO << "Registration time: " << time;
}
catch( itk::ExceptionObject & err )
{
std::cerr << "ExceptionObject caught !" << std::endl;
std::cerr << err << std::endl;
}
typename OptimizerType::ParametersType finalParameters =
registration->GetLastTransformParameters();
std::cout << "Last Transform Parameters" << std::endl;
std::cout << finalParameters << std::endl;
transform->SetParameters( finalParameters );
/*
ResampleFilterType::Pointer resampler = ResampleFilterType::New();
resampler->SetTransform( transform );
resampler->SetInput( movingImage );
resampler->SetSize( fixedImage->GetLargestPossibleRegion().GetSize() );
resampler->SetOutputOrigin( fixedImage->GetOrigin() );
resampler->SetOutputSpacing( fixedImage->GetSpacing() );
resampler->SetOutputDirection( fixedImage->GetDirection() );
resampler->SetDefaultPixelValue( 100 );
resampler->SetInterpolator( interpolator);
resampler->Update();*/
// Generate deformation field
typename DeformationFieldType::Pointer field = DeformationFieldType::New();
field->SetRegions( movingRegion );
field->SetOrigin( movingImage->GetOrigin() );
field->SetSpacing( movingImage->GetSpacing() );
field->SetDirection( movingImage->GetDirection() );
field->Allocate();
typedef itk::ImageRegionIterator< DeformationFieldType > FieldIterator;
FieldIterator fi( field, movingRegion );
fi.GoToBegin();
typename TransformType::InputPointType fixedPoint;
typename TransformType::OutputPointType movingPoint;
typename DeformationFieldType::IndexType index;
VectorType displacement;
while( ! fi.IsAtEnd() )
{
index = fi.GetIndex();
field->TransformIndexToPhysicalPoint( index, fixedPoint );
movingPoint = transform->TransformPoint( fixedPoint );
displacement = movingPoint - fixedPoint;
fi.Set( displacement );
++fi;
}
// Use the deformation field to warp the moving image
typename WarperType::Pointer warper = WarperType::New();
warper->SetInput( movingImage );
warper->SetInterpolator( interpolator );
warper->SetOutputSpacing( movingImage->GetSpacing() );
warper->SetOutputOrigin( movingImage->GetOrigin() );
warper->SetOutputDirection( movingImage->GetDirection() );
- warper->SetDeformationField( field );
+ warper->SetDisplacementField( field );
warper->Update();
typename InternalImageType::Pointer result = warper->GetOutput();
if(m_UpdateInputImage)
{
Image::Pointer outputImage = this->GetOutput();
mitk::CastToMitkImage( result, outputImage );
}
// Save the deformationfield resulting from the registration
if(m_SaveDeformationField)
{
typedef itk::ImageFileWriter< DeformationFieldType > FieldWriterType;
typename FieldWriterType::Pointer fieldWriter = FieldWriterType::New();
fieldWriter->SetInput( field );
fieldWriter->SetFileName( m_DeformationFileName );
try
{
fieldWriter->Update();
}
catch( itk::ExceptionObject & excp )
{
std::cerr << "Exception thrown " << std::endl;
std::cerr << excp << std::endl;
//return EXIT_FAILURE;
}
}
}
} // end namespace
diff --git a/Modules/DeformableRegistration/mitkDemonsRegistration.cpp b/Modules/DeformableRegistration/mitkDemonsRegistration.cpp
index a4bef674e1..65f49cc8ec 100644
--- a/Modules/DeformableRegistration/mitkDemonsRegistration.cpp
+++ b/Modules/DeformableRegistration/mitkDemonsRegistration.cpp
@@ -1,266 +1,266 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkImageCast.h>
#include "itkImageFileWriter.h"
#include "itkWarpImageFilter.h"
#include "itkImageRegionIterator.h"
#include "mitkDemonsRegistration.h"
namespace mitk {
DemonsRegistration::DemonsRegistration():
m_Iterations(50),
m_StandardDeviation(1.0),
m_FieldName("newField.mhd"),
m_ResultName("deformedImage.mhd"),
m_SaveField(true),
m_SaveResult(true),
m_DeformationField(NULL)
{
}
DemonsRegistration::~DemonsRegistration()
{
}
void DemonsRegistration::SetNumberOfIterations(int iterations)
{
m_Iterations = iterations;
}
void DemonsRegistration::SetStandardDeviation(float deviation)
{
m_StandardDeviation = deviation;
}
void DemonsRegistration::SetSaveDeformationField(bool saveField)
{
m_SaveField = saveField;
}
void DemonsRegistration::SetDeformationFieldFileName(const char* fieldName)
{
m_FieldName = fieldName;
}
void DemonsRegistration::SetSaveResult(bool saveResult)
{
m_SaveResult = saveResult;
}
void DemonsRegistration::SetResultFileName(const char* resultName)
{
m_ResultName = resultName;
}
itk::Image<itk::Vector<float, 3>,3>::Pointer DemonsRegistration::GetDeformationField()
{
return m_DeformationField;
}
template < typename TPixel, unsigned int VImageDimension >
void DemonsRegistration::GenerateData2( itk::Image<TPixel, VImageDimension>* itkImage1)
{
typedef typename itk::Image< TPixel, VImageDimension > FixedImageType;
typedef typename itk::Image< TPixel, VImageDimension > MovingImageType;
typedef float InternalPixelType;
typedef typename itk::Image< InternalPixelType, VImageDimension > InternalImageType;
typedef typename itk::CastImageFilter< FixedImageType,
InternalImageType > FixedImageCasterType;
typedef typename itk::CastImageFilter< MovingImageType,
InternalImageType > MovingImageCasterType;
typedef typename itk::Image< InternalPixelType, VImageDimension > InternalImageType;
typedef typename itk::Vector< float, VImageDimension > VectorPixelType;
typedef typename itk::Image< VectorPixelType, VImageDimension > DeformationFieldType;
typedef typename itk::DemonsRegistrationFilter<
InternalImageType,
InternalImageType,
DeformationFieldType> RegistrationFilterType;
typedef typename itk::WarpImageFilter<
MovingImageType,
MovingImageType,
DeformationFieldType > WarperType;
typedef typename itk::LinearInterpolateImageFunction<
MovingImageType,
double > InterpolatorType;
typedef TPixel OutputPixelType;
typedef typename itk::Image< OutputPixelType, VImageDimension > OutputImageType;
typedef typename itk::CastImageFilter<
MovingImageType,
OutputImageType > CastFilterType;
typedef typename itk::ImageFileWriter< OutputImageType > WriterType;
typedef typename itk::ImageFileWriter< DeformationFieldType > FieldWriterType;
typename FixedImageType::Pointer fixedImage = FixedImageType::New();
mitk::CastToItkImage(m_ReferenceImage, fixedImage);
typename MovingImageType::Pointer movingImage = itkImage1;
if (fixedImage.IsNotNull() && movingImage.IsNotNull())
{
typename RegistrationFilterType::Pointer filter = RegistrationFilterType::New();
this->AddStepsToDo(4);
typename itk::ReceptorMemberCommand<DemonsRegistration>::Pointer command = itk::ReceptorMemberCommand<DemonsRegistration>::New();
command->SetCallbackFunction(this, &DemonsRegistration::SetProgress);
filter->AddObserver( itk::IterationEvent(), command );
typename FixedImageCasterType::Pointer fixedImageCaster = FixedImageCasterType::New();
fixedImageCaster->SetInput(fixedImage);
filter->SetFixedImage( fixedImageCaster->GetOutput() );
typename MovingImageCasterType::Pointer movingImageCaster = MovingImageCasterType::New();
movingImageCaster->SetInput(movingImage);
filter->SetMovingImage(movingImageCaster->GetOutput());
filter->SetNumberOfIterations( m_Iterations );
filter->SetStandardDeviations( m_StandardDeviation );
filter->Update();
typename WarperType::Pointer warper = WarperType::New();
typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
warper->SetInput( movingImage );
warper->SetInterpolator( interpolator );
warper->SetOutputSpacing( fixedImage->GetSpacing() );
warper->SetOutputOrigin( fixedImage->GetOrigin() );
warper->SetOutputDirection( fixedImage->GetDirection());
- warper->SetDeformationField( filter->GetOutput() );
+ warper->SetDisplacementField( filter->GetOutput() );
warper->Update();
Image::Pointer outputImage = this->GetOutput();
mitk::CastToMitkImage( warper->GetOutput(), outputImage );
typename WriterType::Pointer writer = WriterType::New();
typename CastFilterType::Pointer caster = CastFilterType::New();
writer->SetFileName( m_ResultName );
caster->SetInput( warper->GetOutput() );
writer->SetInput( caster->GetOutput() );
if(m_SaveResult)
{
writer->Update();
}
if (VImageDimension == 2)
{
typedef DeformationFieldType VectorImage2DType;
typedef typename DeformationFieldType::PixelType Vector2DType;
typename VectorImage2DType::ConstPointer vectorImage2D = filter->GetOutput();
typename VectorImage2DType::RegionType region2D = vectorImage2D->GetBufferedRegion();
typename VectorImage2DType::IndexType index2D = region2D.GetIndex();
typename VectorImage2DType::SizeType size2D = region2D.GetSize();
typedef typename itk::Vector< float, 3 > Vector3DType;
typedef typename itk::Image< Vector3DType, 3 > VectorImage3DType;
typedef typename itk::ImageFileWriter< VectorImage3DType > WriterType;
typename WriterType::Pointer writer3D = WriterType::New();
typename VectorImage3DType::Pointer vectorImage3D = VectorImage3DType::New();
typename VectorImage3DType::RegionType region3D;
typename VectorImage3DType::IndexType index3D;
typename VectorImage3DType::SizeType size3D;
index3D[0] = index2D[0];
index3D[1] = index2D[1];
index3D[2] = 0;
size3D[0] = size2D[0];
size3D[1] = size2D[1];
size3D[2] = 1;
region3D.SetSize( size3D );
region3D.SetIndex( index3D );
typename VectorImage2DType::SpacingType spacing2D = vectorImage2D->GetSpacing();
typename VectorImage3DType::SpacingType spacing3D;
spacing3D[0] = spacing2D[0];
spacing3D[1] = spacing2D[1];
spacing3D[2] = 1.0;
vectorImage3D->SetSpacing( spacing3D );
vectorImage3D->SetRegions( region3D );
vectorImage3D->Allocate();
typedef typename itk::ImageRegionConstIterator< VectorImage2DType > Iterator2DType;
typedef typename itk::ImageRegionIterator< VectorImage3DType > Iterator3DType;
Iterator2DType it2( vectorImage2D, region2D );
Iterator3DType it3( vectorImage3D, region3D );
it2.GoToBegin();
it3.GoToBegin();
Vector2DType vector2D;
Vector3DType vector3D;
vector3D[2] = 0; // set Z component to zero.
while( !it2.IsAtEnd() )
{
vector2D = it2.Get();
vector3D[0] = vector2D[0];
vector3D[1] = vector2D[1];
it3.Set( vector3D );
++it2;
++it3;
}
writer3D->SetInput( vectorImage3D );
m_DeformationField = vectorImage3D;
writer3D->SetFileName( m_FieldName );
try
{
if(m_SaveField)
{
writer3D->Update();
}
}
catch( itk::ExceptionObject & excp )
{
MITK_ERROR << excp << std::endl;
}
}
else
{
typename FieldWriterType::Pointer fieldwriter = FieldWriterType::New();
fieldwriter->SetFileName(m_FieldName);
fieldwriter->SetInput( filter->GetOutput() );
m_DeformationField = (itk::Image<itk::Vector<float, 3>,3> *)(filter->GetOutput());
if(m_SaveField)
{
fieldwriter->Update();
}
}
this->SetRemainingProgress(4);
}
}
} // end namespace
diff --git a/Modules/DeformableRegistration/mitkSymmetricForcesDemonsRegistration.cpp b/Modules/DeformableRegistration/mitkSymmetricForcesDemonsRegistration.cpp
index 6282328d80..70a1f35a8e 100644
--- a/Modules/DeformableRegistration/mitkSymmetricForcesDemonsRegistration.cpp
+++ b/Modules/DeformableRegistration/mitkSymmetricForcesDemonsRegistration.cpp
@@ -1,266 +1,266 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkImageCast.h>
#include "itkImageFileWriter.h"
#include "itkWarpImageFilter.h"
-#include "itkInverseDeformationFieldImageFilter.h"
+
+#include "itkInverseDisplacementFieldImageFilter.h"
+
#include "mitkSymmetricForcesDemonsRegistration.h"
namespace mitk {
SymmetricForcesDemonsRegistration::SymmetricForcesDemonsRegistration():
m_Iterations(50),
m_StandardDeviation(1.0),
m_FieldName("newField.mhd"),
m_ResultName("deformedImage.mhd"),
m_SaveField(true),
m_SaveResult(true),
m_DeformationField(NULL)
{
}
SymmetricForcesDemonsRegistration::~SymmetricForcesDemonsRegistration()
{
}
void SymmetricForcesDemonsRegistration::SetNumberOfIterations(int iterations)
{
m_Iterations = iterations;
}
void SymmetricForcesDemonsRegistration::SetStandardDeviation(float deviation)
{
m_StandardDeviation = deviation;
}
void SymmetricForcesDemonsRegistration::SetSaveDeformationField(bool saveField)
{
m_SaveField = saveField;
}
void SymmetricForcesDemonsRegistration::SetDeformationFieldFileName(const char* fieldName)
{
m_FieldName = fieldName;
}
void SymmetricForcesDemonsRegistration::SetSaveResult(bool saveResult)
{
m_SaveResult = saveResult;
}
void SymmetricForcesDemonsRegistration::SetResultFileName(const char* resultName)
{
m_ResultName = resultName;
}
itk::Image<class itk::Vector<float, 3>,3>::Pointer SymmetricForcesDemonsRegistration::GetDeformationField()
{
return m_DeformationField;
}
template < typename TPixel, unsigned int VImageDimension >
void SymmetricForcesDemonsRegistration::GenerateData2( itk::Image<TPixel, VImageDimension>* itkImage1)
{
typedef typename itk::Image< TPixel, VImageDimension > FixedImageType;
typedef typename itk::Image< TPixel, VImageDimension > MovingImageType;
typedef float InternalPixelType;
typedef typename itk::Image< InternalPixelType, VImageDimension > InternalImageType;
typedef typename itk::CastImageFilter< FixedImageType,
InternalImageType > FixedImageCasterType;
typedef typename itk::CastImageFilter< MovingImageType,
InternalImageType > MovingImageCasterType;
typedef typename itk::Vector< float, VImageDimension > VectorPixelType;
typedef typename itk::Image< VectorPixelType, VImageDimension > DeformationFieldType;
typedef typename itk::SymmetricForcesDemonsRegistrationFilter<
InternalImageType,
InternalImageType,
DeformationFieldType> RegistrationFilterType;
typedef typename itk::WarpImageFilter<
MovingImageType,
MovingImageType,
DeformationFieldType > WarperType;
typedef typename itk::LinearInterpolateImageFunction<
MovingImageType,
double > InterpolatorType;
typedef TPixel OutputPixelType;
typedef typename itk::Image< OutputPixelType, VImageDimension > OutputImageType;
typedef typename itk::CastImageFilter<
MovingImageType,
OutputImageType > CastFilterType;
typedef typename itk::ImageFileWriter< OutputImageType > WriterType;
typedef typename itk::ImageFileWriter< DeformationFieldType > FieldWriterType;
- typedef typename itk::InverseDeformationFieldImageFilter<DeformationFieldType, DeformationFieldType> InverseFilterType;
-
typename FixedImageType::Pointer fixedImage = FixedImageType::New();
mitk::CastToItkImage(m_ReferenceImage, fixedImage);
typename MovingImageType::Pointer movingImage = itkImage1;
if (fixedImage.IsNotNull() && movingImage.IsNotNull())
{
typename RegistrationFilterType::Pointer filter = RegistrationFilterType::New();
this->AddStepsToDo(4);
itk::ReceptorMemberCommand<SymmetricForcesDemonsRegistration>::Pointer command = itk::ReceptorMemberCommand<SymmetricForcesDemonsRegistration>::New();
command->SetCallbackFunction(this, &SymmetricForcesDemonsRegistration::SetProgress);
filter->AddObserver( itk::IterationEvent(), command );
typename FixedImageCasterType::Pointer fixedImageCaster = FixedImageCasterType::New();
fixedImageCaster->SetInput(fixedImage);
filter->SetFixedImage( fixedImageCaster->GetOutput() );
typename MovingImageCasterType::Pointer movingImageCaster = MovingImageCasterType::New();
movingImageCaster->SetInput(movingImage);
filter->SetMovingImage(movingImageCaster->GetOutput());
filter->SetNumberOfIterations( m_Iterations );
filter->SetStandardDeviations( m_StandardDeviation );
filter->Update();
typename WarperType::Pointer warper = WarperType::New();
typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
warper->SetInput( movingImage );
warper->SetInterpolator( interpolator );
warper->SetOutputSpacing( fixedImage->GetSpacing() );
warper->SetOutputOrigin( fixedImage->GetOrigin() );
- warper->SetDeformationField( filter->GetOutput() );
+ warper->SetDisplacementField( filter->GetOutput() );
warper->Update();
typename WriterType::Pointer writer = WriterType::New();
typename CastFilterType::Pointer caster = CastFilterType::New();
writer->SetFileName( m_ResultName );
caster->SetInput( warper->GetOutput() );
writer->SetInput( caster->GetOutput() );
if(m_SaveResult)
{
writer->Update();
}
Image::Pointer outputImage = this->GetOutput();
mitk::CastToMitkImage( warper->GetOutput(), outputImage );
if (VImageDimension == 2)
{
typedef DeformationFieldType VectorImage2DType;
typedef typename DeformationFieldType::PixelType Vector2DType;
typename VectorImage2DType::ConstPointer vectorImage2D = filter->GetOutput();
typename VectorImage2DType::RegionType region2D = vectorImage2D->GetBufferedRegion();
typename VectorImage2DType::IndexType index2D = region2D.GetIndex();
typename VectorImage2DType::SizeType size2D = region2D.GetSize();
typedef typename itk::Vector< float, 3 > Vector3DType;
typedef typename itk::Image< Vector3DType, 3 > VectorImage3DType;
typedef typename itk::ImageFileWriter< VectorImage3DType > WriterType;
WriterType::Pointer writer3D = WriterType::New();
VectorImage3DType::Pointer vectorImage3D = VectorImage3DType::New();
VectorImage3DType::RegionType region3D;
VectorImage3DType::IndexType index3D;
VectorImage3DType::SizeType size3D;
index3D[0] = index2D[0];
index3D[1] = index2D[1];
index3D[2] = 0;
size3D[0] = size2D[0];
size3D[1] = size2D[1];
size3D[2] = 1;
region3D.SetSize( size3D );
region3D.SetIndex( index3D );
typename VectorImage2DType::SpacingType spacing2D = vectorImage2D->GetSpacing();
VectorImage3DType::SpacingType spacing3D;
spacing3D[0] = spacing2D[0];
spacing3D[1] = spacing2D[1];
spacing3D[2] = 1.0;
vectorImage3D->SetSpacing( spacing3D );
vectorImage3D->SetRegions( region3D );
vectorImage3D->Allocate();
typedef typename itk::ImageRegionConstIterator< VectorImage2DType > Iterator2DType;
typedef typename itk::ImageRegionIterator< VectorImage3DType > Iterator3DType;
Iterator2DType it2( vectorImage2D, region2D );
Iterator3DType it3( vectorImage3D, region3D );
it2.GoToBegin();
it3.GoToBegin();
Vector2DType vector2D;
Vector3DType vector3D;
vector3D[2] = 0; // set Z component to zero.
while( !it2.IsAtEnd() )
{
vector2D = it2.Get();
vector3D[0] = vector2D[0];
vector3D[1] = vector2D[1];
it3.Set( vector3D );
++it2;
++it3;
}
writer3D->SetInput( vectorImage3D );
m_DeformationField = vectorImage3D;
writer3D->SetFileName( m_FieldName );
try
{
if(m_SaveField)
{
writer3D->Update();
}
}
catch( itk::ExceptionObject & excp )
{
MITK_ERROR << excp << std::endl;
}
}
else
{
typename FieldWriterType::Pointer fieldwriter = FieldWriterType::New();
fieldwriter->SetFileName( m_FieldName );
fieldwriter->SetInput( filter->GetOutput() );
//m_DeformationField = filter->GetOutput();
m_DeformationField = (itk::Image<itk::Vector<float, 3>,3> *)(filter->GetOutput()); //see BUG #3732
if(m_SaveField)
{
fieldwriter->Update();
}
}
this->SetRemainingProgress(4);
}
}
} // end namespace
diff --git a/Modules/DeformableRegistrationUI/QmitkDemonsRegistrationView.cpp b/Modules/DeformableRegistrationUI/QmitkDemonsRegistrationView.cpp
index cce6579206..c61104c767 100644
--- a/Modules/DeformableRegistrationUI/QmitkDemonsRegistrationView.cpp
+++ b/Modules/DeformableRegistrationUI/QmitkDemonsRegistrationView.cpp
@@ -1,214 +1,214 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <qvalidator.h>
#include <mitkImageCast.h>
#include <stdio.h>
#include <stdlib.h>
#include <mitkLevelWindowProperty.h>
#include <mitkRenderingManager.h>
#include "itkRegularStepGradientDescentOptimizer.h"
#include <qfiledialog.h>
#include <qmessagebox.h>
#include "QmitkDemonsRegistrationView.h"
#include "ui_QmitkDemonsRegistrationViewControls.h"
#include "mitkITKImageImport.h"
#include "mitkProgressBar.h"
QmitkDemonsRegistrationView::QmitkDemonsRegistrationView(QWidget* parent, Qt::WindowFlags f ) : QWidget( parent, f ),
m_FixedNode(NULL), m_MovingNode(NULL), m_ResultImage(NULL), m_ResultDeformationField(NULL)
{
m_Controls.setupUi(parent);
QValidator* validatorHistogramLevels = new QIntValidator(1, 20000000, this);
m_Controls.m_NumberOfHistogramLevels->setValidator(validatorHistogramLevels);
QValidator* validatorMatchPoints = new QIntValidator(1, 20000000, this);
m_Controls.m_NumberOfMatchPoints->setValidator(validatorMatchPoints);
QValidator* validatorIterations = new QIntValidator(1, 20000000, this);
m_Controls.m_Iterations->setValidator(validatorIterations);
QValidator* validatorStandardDeviation = new QDoubleValidator(0, 20000000, 2, this);
m_Controls.m_StandardDeviation->setValidator(validatorStandardDeviation);
}
QmitkDemonsRegistrationView::~QmitkDemonsRegistrationView()
{
}
int QmitkDemonsRegistrationView::GetNumberOfIterations()
{
return atoi(m_Controls.m_Iterations->text().toLatin1());
}
float QmitkDemonsRegistrationView::GetStandardDeviation()
{
return atof(m_Controls.m_StandardDeviation->text().toLatin1());
}
mitk::Image::Pointer QmitkDemonsRegistrationView::GetResultImage()
{
return m_ResultImage;
}
mitk::Image::Pointer QmitkDemonsRegistrationView::GetResultDeformationfield()
{
return m_ResultDeformationField;
}
void QmitkDemonsRegistrationView::CalculateTransformation()
{
if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
{
mitk::Image::Pointer fimage = dynamic_cast<mitk::Image*>(m_FixedNode->GetData());
mitk::Image::Pointer mimage = dynamic_cast<mitk::Image*>(m_MovingNode->GetData());
// workaround to ensure that fimage covers a bigger region than mimage
mitk::Image::RegionType fimageRegion = fimage->GetLargestPossibleRegion();
mitk::Image::RegionType mimageRegion = mimage->GetLargestPossibleRegion();
if (!((fimageRegion.GetSize(0)>=mimageRegion.GetSize(0))&&(fimageRegion.GetSize(1)>=mimageRegion.GetSize(1))
&&(fimageRegion.GetSize(2)>=mimageRegion.GetSize(2))))
{
QMessageBox::information(NULL,"Registration","Fixed image must be equal or bigger in size than moving image.");
return;
}
if ( m_Controls.m_RegistrationSelection->currentIndex() == 0)
{
mitk::DemonsRegistration::Pointer registration = mitk::DemonsRegistration::New();
registration->SetSaveDeformationField(false);
registration->SetSaveResult(false);
registration->SetReferenceImage(fimage);
registration->SetNumberOfIterations(atoi(m_Controls.m_Iterations->text().toLatin1()));
registration->SetStandardDeviation(atof(m_Controls.m_StandardDeviation->text().toLatin1()));
if (m_Controls.m_UseHistogramMatching->isChecked())
{
mitk::HistogramMatching::Pointer histogramMatching = mitk::HistogramMatching::New();
histogramMatching->SetReferenceImage(fimage);
histogramMatching->SetInput(mimage);
histogramMatching->SetNumberOfHistogramLevels(atoi(m_Controls.m_NumberOfHistogramLevels->text().toLatin1()));
histogramMatching->SetNumberOfMatchPoints(atoi(m_Controls.m_NumberOfMatchPoints->text().toLatin1()));
histogramMatching->SetThresholdAtMeanIntensity(m_Controls.m_ThresholdAtMeanIntensity->isChecked());
histogramMatching->Update();
mitk::Image::Pointer histimage = histogramMatching->GetOutput();
if (histimage.IsNotNull())
{
registration->SetInput(histimage);
}
else
{
registration->SetInput(mimage);
}
}
else
{
registration->SetInput(mimage);
}
try
{
registration->Update();
}
catch (itk::ExceptionObject& excpt)
{
QMessageBox::information( this, "Registration exception", excpt.GetDescription(), QMessageBox::Ok );
mitk::ProgressBar::GetInstance()->Progress(4);
return;
}
m_ResultImage = registration->GetOutput();
typedef itk::Image<itk::Vector<float,3>, 3> VectorImageType;
VectorImageType::Pointer deformationField = registration->GetDeformationField();
- m_ResultDeformationField = mitk::ImportItkImage(deformationField);
+ m_ResultDeformationField = mitk::ImportItkImage(deformationField)->Clone();
}
else if(m_Controls.m_RegistrationSelection->currentIndex() == 1)
{
mitk::SymmetricForcesDemonsRegistration::Pointer registration = mitk::SymmetricForcesDemonsRegistration::New();
registration->SetSaveDeformationField(false);
registration->SetSaveResult(false);
registration->SetReferenceImage(fimage);
registration->SetNumberOfIterations(atoi(m_Controls.m_Iterations->text().toLatin1()));
registration->SetStandardDeviation(atof(m_Controls.m_StandardDeviation->text().toLatin1()));
if (m_Controls.m_UseHistogramMatching->isChecked())
{
mitk::HistogramMatching::Pointer histogramMatching = mitk::HistogramMatching::New();
histogramMatching->SetReferenceImage(fimage);
histogramMatching->SetInput(mimage);
histogramMatching->SetNumberOfHistogramLevels(atoi(m_Controls.m_NumberOfHistogramLevels->text().toLatin1()));
histogramMatching->SetNumberOfMatchPoints(atoi(m_Controls.m_NumberOfMatchPoints->text().toLatin1()));
histogramMatching->SetThresholdAtMeanIntensity(m_Controls.m_ThresholdAtMeanIntensity->isChecked());
histogramMatching->Update();
mitk::Image::Pointer histimage = histogramMatching->GetOutput();
if (histimage.IsNotNull())
{
registration->SetInput(histimage);
}
else
{
registration->SetInput(mimage);
}
}
else
{
registration->SetInput(mimage);
}
try
{
registration->Update();
}
catch (itk::ExceptionObject& excpt)
{
QMessageBox::information( this, "Registration exception", excpt.GetDescription(), QMessageBox::Ok );
mitk::ProgressBar::GetInstance()->Progress(4);
return;
}
m_ResultImage = registration->GetOutput();
typedef itk::Image<itk::Vector<float,3>, 3> VectorImageType;
VectorImageType::Pointer deformationField = registration->GetDeformationField();
- m_ResultDeformationField = mitk::ImportItkImage(deformationField);
+ m_ResultDeformationField = mitk::ImportItkImage(deformationField)->Clone();
}
}
}
void QmitkDemonsRegistrationView::SetFixedNode( mitk::DataNode * fixedNode )
{
m_FixedNode = fixedNode;
}
void QmitkDemonsRegistrationView::SetMovingNode( mitk::DataNode * movingNode )
{
m_MovingNode = movingNode;
}
void QmitkDemonsRegistrationView::UseHistogramMatching( bool useHM )
{
if (useHM)
{
m_Controls.numberOfHistogramLevels->setEnabled(true);
m_Controls.m_NumberOfHistogramLevels->setEnabled(true);
m_Controls.numberOfMatchPoints->setEnabled(true);
m_Controls.m_NumberOfMatchPoints->setEnabled(true);
m_Controls.thresholdAtMeanIntensity->setEnabled(true);
m_Controls.m_ThresholdAtMeanIntensity->setEnabled(true);
}
else
{
m_Controls.numberOfHistogramLevels->setEnabled(false);
m_Controls.m_NumberOfHistogramLevels->setEnabled(false);
m_Controls.numberOfMatchPoints->setEnabled(false);
m_Controls.m_NumberOfMatchPoints->setEnabled(false);
m_Controls.thresholdAtMeanIntensity->setEnabled(false);
m_Controls.m_ThresholdAtMeanIntensity->setEnabled(false);
}
}
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.cpp
index e3972cb7ff..5baaf2fa7e 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.cpp
@@ -1,183 +1,186 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#include <itkConnectomicsNetworkToConnectivityMatrixImageFilter.h>
+#ifndef ITK_ConnectomicsNetworkToConnectivityMatrixImageFilter_CPP
+#define ITK_ConnectomicsNetworkToConnectivityMatrixImageFilter_CPP
#include <itkImageRegionIterator.h>
#include <vector>
itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::ConnectomicsNetworkToConnectivityMatrixImageFilter()
: m_BinaryConnectivity(false)
, m_RescaleConnectivity(false)
, m_InputNetwork(NULL)
{
}
itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::~ConnectomicsNetworkToConnectivityMatrixImageFilter()
{
}
void itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::GenerateData()
{
this->AllocateOutputs();
OutputImageType::Pointer output = this->GetOutput();
if(m_InputNetwork.IsNull())
{
MITK_ERROR << "Failed to generate data, no valid network was set.";
return;
}
typedef mitk::ConnectomicsNetwork::NetworkType NetworkType;
typedef boost::graph_traits< NetworkType >::vertex_descriptor DescriptorType;
typedef boost::graph_traits< NetworkType >::vertex_iterator IteratorType;
// prepare connectivity matrix for data
std::vector< std::vector< int > > connectivityMatrix;
int numberOfVertices = m_InputNetwork->GetNumberOfVertices();
connectivityMatrix.resize( numberOfVertices );
for( int index(0); index < numberOfVertices; index++ )
{
connectivityMatrix[ index ].resize( numberOfVertices );
}
// Create LabelToIndex translation
std::map< std::string, DescriptorType > labelToIndexMap;
NetworkType boostGraph = *(m_InputNetwork->GetBoostGraph());
// translate index to label
IteratorType iterator, end;
boost::tie(iterator, end) = boost::vertices( boostGraph );
for ( ; iterator != end; ++iterator)
{
labelToIndexMap.insert(
std::pair< std::string, DescriptorType >(
boostGraph[ *iterator ].label, *iterator )
);
}
std::vector< std::string > indexToLabel;
// translate index to label
indexToLabel.resize( numberOfVertices );
boost::tie(iterator, end) = boost::vertices( boostGraph );
for ( ; iterator != end; ++iterator)
{
indexToLabel[ *iterator ] = boostGraph[ *iterator ].label;
}
//translate label to position
std::vector< std::string > positionToLabelVector;
positionToLabelVector = indexToLabel;
std::sort ( positionToLabelVector.begin(), positionToLabelVector.end() );
for( int outerLoop( 0 ); outerLoop < numberOfVertices; outerLoop++ )
{
DescriptorType fromVertexDescriptor = labelToIndexMap.find( positionToLabelVector[ outerLoop ] )->second;
for( int innerLoop( outerLoop + 1 ); innerLoop < numberOfVertices; innerLoop++ )
{
DescriptorType toVertexDescriptor = labelToIndexMap.find( positionToLabelVector[ innerLoop ] )->second;
int weight( 0 );
if( boost::edge(toVertexDescriptor, fromVertexDescriptor, boostGraph ).second )
{
weight = m_InputNetwork->GetEdge( fromVertexDescriptor , toVertexDescriptor ).weight;;
}
connectivityMatrix[outerLoop][innerLoop] = weight;
connectivityMatrix[innerLoop][outerLoop] = weight;
}
}
OutputImageType::SpacingType spacing;
spacing[0] = 1.0;
spacing[1] = 1.0;
OutputImageType::PointType origin;
origin[0] = 0.0;
origin[1] = 0.0;
OutputImageType::IndexType index;
index[0] = 0.0;
index[1] = 0.0;
OutputImageType::SizeType size;
size[0] = numberOfVertices;
size[1] = numberOfVertices;
OutputImageType::RegionType region;
region.SetIndex( index );
region.SetSize( size );
output->SetSpacing( spacing ); // Set the image spacing
output->SetOrigin( origin ); // Set the image origin
output->SetRegions( region );
output->Allocate();
output->FillBuffer(0);
itk::ImageRegionIterator< OutputImageType > it_connect(output, output->GetLargestPossibleRegion());
int counter( 0 );
double rescaleFactor( 1.0 );
double rescaleMax( 255.0 );
if( m_RescaleConnectivity )
{
rescaleFactor = rescaleMax / m_InputNetwork->GetMaximumWeight();
}
// Colour pixels according to connectivity
if( m_BinaryConnectivity )
{
// binary connectivity
while( !it_connect.IsAtEnd() )
{
if( connectivityMatrix[ ( counter - counter % numberOfVertices ) / numberOfVertices][ counter % numberOfVertices ] )
{
it_connect.Set( 1 );
}
else
{
it_connect.Set( 0 );
}
++it_connect;
counter++;
}
}
else
{
// if desired rescale to the 0-255 range
while( !it_connect.IsAtEnd() )
{
it_connect.Set( ( unsigned short ) rescaleFactor *
connectivityMatrix[ ( counter - counter % numberOfVertices ) / numberOfVertices][ counter % numberOfVertices ]
);
++it_connect;
counter++;
}
}
-}
\ No newline at end of file
+}
+
+#endif
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.h b/Modules/DiffusionImaging/Connectomics/Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.h
index 63be78c456..6d984feba8 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.h
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.h
@@ -1,82 +1,80 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef ITK_ConnectomicsNetworkToConnectivityMatrixImageFilter_H
#define ITK_ConnectomicsNetworkToConnectivityMatrixImageFilter_H
// ITK includes
#include <itkImageSource.h>
#include <itkImage.h>
// MITK includes
#include "mitkConnectomicsNetwork.h"
-#include "ConnectomicsExports.h"
-
namespace itk
{
- class Connectomics_EXPORT ConnectomicsNetworkToConnectivityMatrixImageFilter : public ImageSource< itk::Image< unsigned short, 2 > >
+ class ConnectomicsNetworkToConnectivityMatrixImageFilter : public ImageSource< itk::Image< unsigned short, 2 > >
{
public:
typedef ConnectomicsNetworkToConnectivityMatrixImageFilter Self;
typedef ProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
typedef itk::Image< unsigned short, 2 > OutputImageType;
typedef OutputImageType::PixelType OutPixelType;
typedef mitk::ConnectomicsNetwork InputType;
itkNewMacro(Self)
- itkTypeMacro( ConnectomicsNetworkToConnectivityMatrixImageFilter, ImageSource )
+ itkTypeMacro( ConnectomicsNetworkToConnectivityMatrixImageFilter, ImageSource )
- /** Get/Set m_BinaryConnectivity **/
- itkSetMacro( BinaryConnectivity, bool)
- itkGetMacro( BinaryConnectivity, bool)
+ /** Get/Set m_BinaryConnectivity **/
+ itkSetMacro( BinaryConnectivity, bool)
+ itkGetMacro( BinaryConnectivity, bool)
- /** Get/Set m_RescaleConnectivity **/
- itkSetMacro( RescaleConnectivity, bool)
- itkGetMacro( RescaleConnectivity, bool)
+ /** Get/Set m_RescaleConnectivity **/
+ itkSetMacro( RescaleConnectivity, bool)
+ itkGetMacro( RescaleConnectivity, bool)
- itkSetMacro( InputNetwork, InputType::Pointer)
+ itkSetMacro( InputNetwork, InputType::Pointer)
- void GenerateData();
+ void GenerateData();
protected:
ConnectomicsNetworkToConnectivityMatrixImageFilter();
virtual ~ConnectomicsNetworkToConnectivityMatrixImageFilter();
/** Controls whether the connectivity matrix is binary */
bool m_BinaryConnectivity;
/** Controls whether the connectivity matrix entries are rescaled to lie between 0 and 255*/
bool m_RescaleConnectivity;
InputType::Pointer m_InputNetwork;
};
}
-//#ifndef ITK_MANUAL_INSTANTIATION
-//#include "itkConnectomicsNetworkToConnectivityMatrixImageFilter.cpp"
-//#endif
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkConnectomicsNetworkToConnectivityMatrixImageFilter.cpp"
+#endif
#endif /* ITK_ConnectomicsNetworkToConnectivityMatrixImageFilter_H */
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSimulatedAnnealingManager.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSimulatedAnnealingManager.cpp
index e4c3db0c8d..08eead78cb 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSimulatedAnnealingManager.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSimulatedAnnealingManager.cpp
@@ -1,95 +1,95 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkConnectomicsSimulatedAnnealingManager.h"
//for random number generation
-#include "vxl/core/vnl/vnl_random.h"
-#include "vxl/core/vnl/vnl_math.h"
+#include "vnl/vnl_random.h"
+#include "vnl/vnl_math.h"
mitk::ConnectomicsSimulatedAnnealingManager::ConnectomicsSimulatedAnnealingManager()
: m_Permutation( 0 )
{
}
mitk::ConnectomicsSimulatedAnnealingManager::~ConnectomicsSimulatedAnnealingManager()
{
}
bool mitk::ConnectomicsSimulatedAnnealingManager::AcceptChange( double costBefore, double costAfter, double temperature )
{
if( costAfter <= costBefore )
{// if cost is lower after
return true;
}
//the random number generators
vnl_random rng( (unsigned int) rand() );
//randomly generate threshold
const double threshold = rng.drand64( 0.0 , 1.0);
//the likelihood of acceptance
double likelihood = std::exp( - ( costAfter - costBefore ) / temperature );
if( threshold < likelihood )
{
return true;
}
return false;
}
void mitk::ConnectomicsSimulatedAnnealingManager::SetPermutation( mitk::ConnectomicsSimulatedAnnealingPermutationBase::Pointer permutation )
{
m_Permutation = permutation;
}
void mitk::ConnectomicsSimulatedAnnealingManager::RunSimulatedAnnealing(
double temperature,
double stepSize
)
{
if( m_Permutation.IsNull() )
{
MBI_ERROR << "Trying to run simulated annealing on empty permutation.";
return;
}
if( !m_Permutation->HasCostFunction() )
{
MBI_ERROR << "Trying to run simulated annealing on empty cost function.";
return;
}
// Initialize the associated permutation
m_Permutation->Initialize();
for( double currentTemperature( temperature );
currentTemperature > 0.00001;
currentTemperature = currentTemperature / stepSize )
{
// Run Permutations at the current temperature
m_Permutation->Permutate( currentTemperature );
}
// Clean up result
m_Permutation->CleanUp();
}
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSimulatedAnnealingPermutationModularity.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSimulatedAnnealingPermutationModularity.cpp
index c6d01363a0..f829603066 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSimulatedAnnealingPermutationModularity.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSimulatedAnnealingPermutationModularity.cpp
@@ -1,544 +1,544 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkConnectomicsSimulatedAnnealingPermutationModularity.h"
#include "mitkConnectomicsSimulatedAnnealingCostFunctionModularity.h"
#include "mitkConnectomicsSimulatedAnnealingManager.h"
//for random number generation
-#include "vxl/core/vnl/vnl_random.h"
-#include "vxl/core/vnl/vnl_math.h"
+#include "vnl/vnl_random.h"
+#include "vnl/vnl_math.h"
mitk::ConnectomicsSimulatedAnnealingPermutationModularity::ConnectomicsSimulatedAnnealingPermutationModularity()
{
}
mitk::ConnectomicsSimulatedAnnealingPermutationModularity::~ConnectomicsSimulatedAnnealingPermutationModularity()
{
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::SetNetwork(
mitk::ConnectomicsNetwork::Pointer theNetwork )
{
m_Network = theNetwork;
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::Initialize()
{
// create entry for every vertex
std::vector< VertexDescriptorType > vertexVector = m_Network->GetVectorOfAllVertexDescriptors();
const int vectorSize = vertexVector.size();
for( int index( 0 ); index < vectorSize; index++)
{
m_BestSolution.insert( std::pair<VertexDescriptorType, int>( vertexVector[ index ], 0 ) );
}
// initialize with random distribution of n modules
int n( 5 );
randomlyAssignNodesToModules( &m_BestSolution, n );
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::Permutate( double temperature )
{
ToModuleMapType currentSolution = m_BestSolution;
ToModuleMapType currentBestSolution = m_BestSolution;
int factor = 1;
int numberOfVertices = m_BestSolution.size();
int singleNodeMaxNumber = factor * numberOfVertices * numberOfVertices;
int moduleMaxNumber = factor * numberOfVertices;
double currentBestCost = Evaluate( &currentBestSolution );
// do singleNodeMaxNumber node permutations and evaluate
for(int loop( 0 ); loop < singleNodeMaxNumber; loop++)
{
permutateMappingSingleNodeShift( &currentSolution, m_Network );
if( AcceptChange( currentBestCost, Evaluate( &currentSolution ), temperature ) )
{
currentBestSolution = currentSolution;
currentBestCost = Evaluate( &currentBestSolution );
}
}
// do moduleMaxNumber module permutations
for(int loop( 0 ); loop < moduleMaxNumber; loop++)
{
permutateMappingModuleChange( &currentSolution, temperature, m_Network );
if( AcceptChange( currentBestCost, Evaluate( &currentSolution ), temperature ) )
{
currentBestSolution = currentSolution;
currentBestCost = Evaluate( &currentBestSolution );
}
}
// store the best solution after the run
m_BestSolution = currentBestSolution;
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::CleanUp()
{
// delete empty modules, if any
for( int loop( 0 ); loop < getNumberOfModules( &m_BestSolution ) ; loop++ )
{
if( getNumberOfVerticesInModule( &m_BestSolution, loop ) < 1 )
{
removeModule( &m_BestSolution, loop );
}
}
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::permutateMappingSingleNodeShift(
ToModuleMapType *vertexToModuleMap, mitk::ConnectomicsNetwork::Pointer network )
{
const int nodeCount = vertexToModuleMap->size();
const int moduleCount = getNumberOfModules( vertexToModuleMap );
// the random number generators
vnl_random rng( (unsigned int) rand() );
unsigned long randomNode = rng.lrand32( nodeCount - 1 );
// move the node either to any existing module, or to its own
//unsigned long randomModule = rng.lrand32( moduleCount );
unsigned long randomModule = rng.lrand32( moduleCount - 1 );
// do some sanity checks
if ( nodeCount < 2 )
{
// no sense in doing anything
return;
}
const std::vector< VertexDescriptorType > allNodesVector
= network->GetVectorOfAllVertexDescriptors();
ToModuleMapType::iterator iter = vertexToModuleMap->find( allNodesVector[ randomNode ] );
const int previousModuleNumber = iter->second;
// if we move the node to its own module, do nothing
if( previousModuleNumber == randomModule )
{
return;
}
iter->second = randomModule;
if( getNumberOfVerticesInModule( vertexToModuleMap, previousModuleNumber ) < 1 )
{
removeModule( vertexToModuleMap, previousModuleNumber );
}
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::permutateMappingModuleChange(
ToModuleMapType *vertexToModuleMap, double currentTemperature, mitk::ConnectomicsNetwork::Pointer network )
{
//the random number generators
vnl_random rng( (unsigned int) rand() );
//randomly generate threshold
const double threshold = rng.drand64( 0.0 , 1.0);
//for deciding whether to join two modules or split one
double splitThreshold = 0.5;
//stores whether to join or two split
bool joinModules( false );
//select random module
int numberOfModules = getNumberOfModules( vertexToModuleMap );
unsigned long randomModuleA = rng.lrand32( numberOfModules - 1 );
//select the second module to join, if joining
unsigned long randomModuleB = rng.lrand32( numberOfModules - 1 );
if( ( threshold < splitThreshold ) && ( randomModuleA != randomModuleB ) )
{
joinModules = true;
}
if( joinModules )
{
// this being an kommutative operation, we will always join B to A
joinTwoModules( vertexToModuleMap, randomModuleA, randomModuleB );
//eliminate the empty module
removeModule( vertexToModuleMap, randomModuleB );
}
else
{
//split module
splitModule( vertexToModuleMap, currentTemperature, network, randomModuleA );
}
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::joinTwoModules(
ToModuleMapType *vertexToModuleMap, int moduleA, int moduleB )
{
ToModuleMapType::iterator iter = vertexToModuleMap->begin();
ToModuleMapType::iterator end = vertexToModuleMap->end();
while( iter != end )
{
// if vertex belongs to module B move it to A
if( iter->second == moduleB )
{
iter->second = moduleA;
}
iter++;
}// end while( iter != end )
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::splitModule(
ToModuleMapType *vertexToModuleMap, double currentTemperature, mitk::ConnectomicsNetwork::Pointer network, int moduleToSplit )
{
if( m_Depth == 0 )
{
// do nothing
return;
}
// if the module contains only one node, no more division is sensible
if( getNumberOfVerticesInModule( vertexToModuleMap, moduleToSplit ) < 2 )
{
// do nothing
return;
}
// create subgraph of the module, that is to be splitted
mitk::ConnectomicsNetwork::Pointer subNetwork = mitk::ConnectomicsNetwork::New();
VertexToVertexMapType graphToSubgraphVertexMap;
VertexToVertexMapType subgraphToGraphVertexMap;
extractModuleSubgraph( vertexToModuleMap, network, moduleToSplit, subNetwork, &graphToSubgraphVertexMap, &subgraphToGraphVertexMap );
// The submap
ToModuleMapType vertexToModuleSubMap;
// copy vertices
VertexToVertexMapType::iterator iter = graphToSubgraphVertexMap.begin();
VertexToVertexMapType::iterator end = graphToSubgraphVertexMap.end();
// run simulated annealing on the subgraph to determine how the module should be split
if( m_Depth > 0 && m_StepSize > 0 )
{
mitk::ConnectomicsSimulatedAnnealingManager::Pointer manager = mitk::ConnectomicsSimulatedAnnealingManager::New();
mitk::ConnectomicsSimulatedAnnealingPermutationModularity::Pointer permutation = mitk::ConnectomicsSimulatedAnnealingPermutationModularity::New();
mitk::ConnectomicsSimulatedAnnealingCostFunctionModularity::Pointer costFunction = mitk::ConnectomicsSimulatedAnnealingCostFunctionModularity::New();
permutation->SetCostFunction( costFunction.GetPointer() );
permutation->SetNetwork( subNetwork );
permutation->SetDepth( m_Depth - 1 );
permutation->SetStepSize( m_StepSize * 2 );
manager->SetPermutation( permutation.GetPointer() );
manager->RunSimulatedAnnealing( currentTemperature, m_StepSize * 2 );
vertexToModuleSubMap = permutation->GetMapping();
}
// now carry the information over to the original map
std::vector< int > moduleTranslationVector;
moduleTranslationVector.resize( getNumberOfModules( &vertexToModuleSubMap ), 0 );
int originalNumber = getNumberOfModules( vertexToModuleMap );
// the new parts are added at the end
for(int index( 0 ); index < moduleTranslationVector.size() ; index++)
{
moduleTranslationVector[ index ] = originalNumber + index;
}
ToModuleMapType::iterator iter2 = vertexToModuleSubMap.begin();
ToModuleMapType::iterator end2 = vertexToModuleSubMap.end();
while( iter2 != end2 )
{
// translate vertex descriptor from subgraph to graph
VertexDescriptorType key = subgraphToGraphVertexMap.find( iter2->first )->second;
// translate module number from subgraph to graph
int value = moduleTranslationVector[ iter2->second ];
// change the corresponding entry
vertexToModuleMap->find( key )->second = value;
iter2++;
}
// remove the now empty module, that was splitted
removeModule( vertexToModuleMap, moduleToSplit );
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::extractModuleSubgraph(
ToModuleMapType *vertexToModuleMap,
mitk::ConnectomicsNetwork::Pointer network,
int moduleToSplit,
mitk::ConnectomicsNetwork::Pointer subNetwork,
VertexToVertexMapType* graphToSubgraphVertexMap,
VertexToVertexMapType* subgraphToGraphVertexMap )
{
const std::vector< VertexDescriptorType > allNodesVector = network->GetVectorOfAllVertexDescriptors();
// add vertices to subgraph
for( int nodeNumber( 0 ); nodeNumber < allNodesVector.size() ; nodeNumber++)
{
int correspondingModule = vertexToModuleMap->find( allNodesVector[ nodeNumber ] )->second;
if( moduleToSplit == vertexToModuleMap->find( allNodesVector[ nodeNumber ] )->second )
{
int id = network->GetNode( allNodesVector[ nodeNumber ] ).id;
VertexDescriptorType newVertex = subNetwork->AddVertex( id );
graphToSubgraphVertexMap->insert(
std::pair<VertexDescriptorType, VertexDescriptorType>(
allNodesVector[ nodeNumber ], newVertex
)
);
subgraphToGraphVertexMap->insert(
std::pair<VertexDescriptorType, VertexDescriptorType>(
newVertex, allNodesVector[ nodeNumber ]
)
);
}
}
// add edges to subgraph
VertexToVertexMapType::iterator iter = graphToSubgraphVertexMap->begin();
VertexToVertexMapType::iterator end = graphToSubgraphVertexMap->end();
while( iter != end )
{
const std::vector< VertexDescriptorType > adjacentNodexVector
= network->GetVectorOfAdjacentNodes( iter->first );
for( int adjacentNodeNumber( 0 ); adjacentNodeNumber < adjacentNodexVector.size() ; adjacentNodeNumber++)
{
// if the adjacent vertex is part of the subgraph,
// add edge, if it does not exist yet, else do nothing
VertexDescriptorType adjacentVertex = adjacentNodexVector[ adjacentNodeNumber ];
if( graphToSubgraphVertexMap->count( adjacentVertex ) > 0 )
{
if( !subNetwork->EdgeExists( iter->second, graphToSubgraphVertexMap->find( adjacentVertex )->second ) )
{ //edge exists in parent network, but not yet in sub network
const VertexDescriptorType vertexA = iter->second;
const VertexDescriptorType vertexB = graphToSubgraphVertexMap->find( adjacentVertex )->second;
const int sourceID = network->GetNode( vertexA ).id;
const int targetID = network->GetNode( vertexB ).id;
const int weight = network->GetEdge( iter->first, graphToSubgraphVertexMap->find( adjacentVertex )->first ).weight;
subNetwork->AddEdge( vertexA , vertexB, sourceID, targetID, weight );
}
}
}
iter++;
}// end while( iter != end )
}
int mitk::ConnectomicsSimulatedAnnealingPermutationModularity::getNumberOfModules(
ToModuleMapType *vertexToModuleMap ) const
{
int maxModule( 0 );
ToModuleMapType::iterator iter = vertexToModuleMap->begin();
ToModuleMapType::iterator end = vertexToModuleMap->end();
while( iter != end )
{
if( iter->second > maxModule )
{
maxModule = iter->second;
}
iter++;
}
return maxModule + 1;
}
int mitk::ConnectomicsSimulatedAnnealingPermutationModularity::getNumberOfVerticesInModule(
ToModuleMapType *vertexToModuleMap, int module ) const
{
int number( 0 );
ToModuleMapType::iterator iter = vertexToModuleMap->begin();
ToModuleMapType::iterator end = vertexToModuleMap->end();
while( iter != end )
{
if( iter->second == module )
{
number++;
}
iter++;
}
return number;
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::removeModule(
ToModuleMapType *vertexToModuleMap, int module )
{
int lastModuleNumber = getNumberOfModules( vertexToModuleMap ) - 1;
if( module == lastModuleNumber )
{
// no need to do anything, the last module is deleted "automatically"
return;
}
if( getNumberOfVerticesInModule( vertexToModuleMap, module ) > 0 )
{
MBI_WARN << "Trying to remove non-empty module";
return;
}
ToModuleMapType::iterator iter = vertexToModuleMap->begin();
ToModuleMapType::iterator end = vertexToModuleMap->end();
while( iter != end )
{
if( iter->second == lastModuleNumber )
{
// renumber last module to to-be-deleted module
iter->second = module;
}
iter++;
}
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::randomlyAssignNodesToModules(
ToModuleMapType *vertexToModuleMap, int numberOfIntendedModules )
{
// we make sure that each intended module contains *at least* one node
// thus if more modules are asked for than node exists we will only generate
// as many modules as there are nodes
if( numberOfIntendedModules > vertexToModuleMap->size() )
{
MBI_ERROR << "Tried to generate more modules than vertices were provided";
numberOfIntendedModules = vertexToModuleMap->size();
}
//the random number generators
vnl_random rng( (unsigned int) rand() );
std::vector< int > histogram;
std::vector< int > nodeList;
histogram.resize( numberOfIntendedModules, 0 );
nodeList.resize( vertexToModuleMap->size(), 0 );
int numberOfVertices = vertexToModuleMap->size();
//randomly distribute nodes to modules
for( int nodeIndex( 0 ); nodeIndex < nodeList.size(); nodeIndex++ )
{
//select random module
nodeList[ nodeIndex ] = rng.lrand32( numberOfIntendedModules - 1 );
histogram[ nodeList[ nodeIndex ] ]++;
}
// make sure no module contains no node, if one does assign it one of a random module
// that does contain at least two
for( int moduleIndex( 0 ); moduleIndex < histogram.size(); moduleIndex++ )
{
while( histogram[ moduleIndex ] == 0 )
{
int randomNodeIndex = rng.lrand32( numberOfVertices - 1 );
if( histogram[ nodeList[ randomNodeIndex ] ] > 1 )
{
histogram[ moduleIndex ]++;
histogram[ nodeList[ randomNodeIndex ] ]--;
nodeList[ randomNodeIndex ] = moduleIndex;
}
}
}
ToModuleMapType::iterator iter = vertexToModuleMap->begin();
ToModuleMapType::iterator end = vertexToModuleMap->end();
for( int index( 0 ); ( iter != end ) && ( index < nodeList.size() ); index++, iter++ )
{
iter->second = nodeList[ index ] ;
}
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::SetMapping( ToModuleMapType mapping )
{
m_BestSolution = mapping;
}
mitk::ConnectomicsSimulatedAnnealingPermutationModularity::ToModuleMapType
mitk::ConnectomicsSimulatedAnnealingPermutationModularity::GetMapping()
{
return m_BestSolution;
}
double mitk::ConnectomicsSimulatedAnnealingPermutationModularity::Evaluate( ToModuleMapType* mapping ) const
{
mitk::ConnectomicsSimulatedAnnealingCostFunctionModularity* costMapping =
dynamic_cast<mitk::ConnectomicsSimulatedAnnealingCostFunctionModularity*>( m_CostFunction.GetPointer() );
if( costMapping )
{
return costMapping->Evaluate( m_Network, mapping );
}
else
{
return 0;
}
}
bool mitk::ConnectomicsSimulatedAnnealingPermutationModularity::AcceptChange( double costBefore, double costAfter, double temperature ) const
{
if( costAfter <= costBefore )
{// if cost is lower after
return true;
}
//the random number generators
vnl_random rng( (unsigned int) rand() );
//randomly generate threshold
const double threshold = rng.drand64( 0.0 , 1.0);
//the likelihood of acceptance
double likelihood = std::exp( - ( costAfter - costBefore ) / temperature );
if( threshold < likelihood )
{
return true;
}
return false;
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::SetDepth( int depth )
{
m_Depth = depth;
}
void mitk::ConnectomicsSimulatedAnnealingPermutationModularity::SetStepSize( double size )
{
m_StepSize = size;
}
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSyntheticNetworkGenerator.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSyntheticNetworkGenerator.cpp
index 702ae23677..ca95ef4f94 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSyntheticNetworkGenerator.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsSyntheticNetworkGenerator.cpp
@@ -1,363 +1,363 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkConnectomicsSyntheticNetworkGenerator.h"
#include <sstream>
#include <vector>
#include "mitkConnectomicsConstantsManager.h"
#include <vtkMatrix4x4.h>
//for random number generation
-#include "vxl/core/vnl/vnl_random.h"
-#include "vxl/core/vnl/vnl_math.h"
+#include "vnl/vnl_random.h"
+#include "vnl/vnl_math.h"
mitk::ConnectomicsSyntheticNetworkGenerator::ConnectomicsSyntheticNetworkGenerator()
: m_LastGenerationWasSuccess( false )
{
}
mitk::ConnectomicsSyntheticNetworkGenerator::~ConnectomicsSyntheticNetworkGenerator()
{
}
mitk::ConnectomicsNetwork::Pointer mitk::ConnectomicsSyntheticNetworkGenerator::CreateSyntheticNetwork(int networkTypeId, int paramterOne, double parameterTwo)
{
mitk::ConnectomicsNetwork::Pointer network = mitk::ConnectomicsNetwork::New();
m_LastGenerationWasSuccess = false;
// give the network an artificial geometry
network->SetGeometry( this->GenerateDefaultGeometry() );
switch (networkTypeId) {
case 0:
GenerateSyntheticCubeNetwork( network, paramterOne, parameterTwo );
break;
case 1:
GenerateSyntheticCenterToSurfaceNetwork( network, paramterOne, parameterTwo );
break;
case 2:
GenerateSyntheticRandomNetwork( network, paramterOne, parameterTwo );
break;
case 3:
//GenerateSyntheticScaleFreeNetwork( network, 1000 );
break;
case 4:
//GenerateSyntheticSmallWorldNetwork( network, 1000 );
break;
default:
MBI_ERROR << "Unrecognized Network ID";
}
network->UpdateBounds();
return network;
}
mitk::Geometry3D::Pointer mitk::ConnectomicsSyntheticNetworkGenerator::GenerateDefaultGeometry()
{
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
double zero( 0.0 );
double one( 1.0 );
// origin = {0,0,0}
mitk::Point3D origin;
origin[0] = zero;
origin[1] = zero;
origin[2] = zero;
geometry->SetOrigin(origin);
// spacing = {1,1,1}
float spacing[3];
spacing[0] = one;
spacing[1] = one;
spacing[2] = one;
geometry->SetSpacing(spacing);
// transform
vtkMatrix4x4* transformMatrix = vtkMatrix4x4::New();
transformMatrix->SetElement(0,0,one);
transformMatrix->SetElement(1,0,zero);
transformMatrix->SetElement(2,0,zero);
transformMatrix->SetElement(0,1,zero);
transformMatrix->SetElement(1,1,one);
transformMatrix->SetElement(2,1,zero);
transformMatrix->SetElement(0,2,zero);
transformMatrix->SetElement(1,2,zero);
transformMatrix->SetElement(2,2,one);
transformMatrix->SetElement(0,3,origin[0]);
transformMatrix->SetElement(1,3,origin[1]);
transformMatrix->SetElement(2,3,origin[2]);
transformMatrix->SetElement(3,3,1);
geometry->SetIndexToWorldTransformByVtkMatrix( transformMatrix );
geometry->SetImageGeometry(true);
return geometry;
}
void mitk::ConnectomicsSyntheticNetworkGenerator::GenerateSyntheticCubeNetwork(
mitk::ConnectomicsNetwork::Pointer network, int cubeExtent, double distance )
{
// map for storing the conversion from indices to vertex descriptor
std::map< int, mitk::ConnectomicsNetwork::VertexDescriptorType > idToVertexMap;
int vertexID(0);
for( int loopX( 0 ); loopX < cubeExtent; loopX++ )
{
for( int loopY( 0 ); loopY < cubeExtent; loopY++ )
{
for( int loopZ( 0 ); loopZ < cubeExtent; loopZ++ )
{
std::vector< float > position;
std::string label;
std::stringstream labelStream;
labelStream << vertexID;
label = labelStream.str();
position.push_back( loopX * distance );
position.push_back( loopY * distance );
position.push_back( loopZ * distance );
mitk::ConnectomicsNetwork::VertexDescriptorType newVertex = network->AddVertex( vertexID );
network->SetLabel( newVertex, label );
network->SetCoordinates( newVertex, position );
if ( idToVertexMap.count( vertexID ) > 0 )
{
MITK_ERROR << "Aborting network creation, duplicate vertex ID generated.";
m_LastGenerationWasSuccess = false;
return;
}
idToVertexMap.insert( std::pair< int, mitk::ConnectomicsNetwork::VertexDescriptorType >( vertexID, newVertex) );
vertexID++;
}
}
}
int edgeID(0), edgeSourceID(0), edgeTargetID(0);
// uniform weight of one
int edgeWeight(1);
mitk::ConnectomicsNetwork::VertexDescriptorType source;
mitk::ConnectomicsNetwork::VertexDescriptorType target;
for( int loopX( 0 ); loopX < cubeExtent; loopX++ )
{
for( int loopY( 0 ); loopY < cubeExtent; loopY++ )
{
for( int loopZ( 0 ); loopZ < cubeExtent; loopZ++ )
{
// to avoid creating an edge twice (this being an undirected graph) we only generate
// edges in three directions, the others will be supplied by the corresponding nodes
if( loopX != 0 )
{
edgeTargetID = edgeSourceID - cubeExtent * cubeExtent;
source = idToVertexMap.find( edgeSourceID )->second;
target = idToVertexMap.find( edgeTargetID )->second;
network->AddEdge( source, target, edgeSourceID, edgeTargetID, edgeWeight);
edgeID++;
}
if( loopY != 0 )
{
edgeTargetID = edgeSourceID - cubeExtent;
source = idToVertexMap.find( edgeSourceID )->second;
target = idToVertexMap.find( edgeTargetID )->second;
network->AddEdge( source, target, edgeSourceID, edgeTargetID, edgeWeight);
edgeID++;
}
if( loopZ != 0 )
{
edgeTargetID = edgeSourceID - 1;
source = idToVertexMap.find( edgeSourceID )->second;
target = idToVertexMap.find( edgeTargetID )->second;
network->AddEdge( source, target, edgeSourceID, edgeTargetID, edgeWeight);
edgeID++;
}
edgeSourceID++;
} // end for( int loopZ( 0 ); loopZ < cubeExtent; loopZ++ )
} // end for( int loopY( 0 ); loopY < cubeExtent; loopY++ )
} // end for( int loopX( 0 ); loopX < cubeExtent; loopX++ )
m_LastGenerationWasSuccess = true;
}
void mitk::ConnectomicsSyntheticNetworkGenerator::GenerateSyntheticCenterToSurfaceNetwork(
mitk::ConnectomicsNetwork::Pointer network, int numberOfPoints, double radius )
{
//the random number generators
unsigned int randomOne = (unsigned int) rand();
unsigned int randomTwo = (unsigned int) rand();
vnl_random rng( (unsigned int) rand() );
vnl_random rng2( (unsigned int) rand() );
mitk::ConnectomicsNetwork::VertexDescriptorType centerVertex;
int vertexID(0);
{ //add center vertex
std::vector< float > position;
std::string label;
std::stringstream labelStream;
labelStream << vertexID;
label = labelStream.str();
position.push_back( 0 );
position.push_back( 0 );
position.push_back( 0 );
centerVertex = network->AddVertex( vertexID );
network->SetLabel( centerVertex, label );
network->SetCoordinates( centerVertex, position );
}//end add center vertex
// uniform weight of one
int edgeWeight(1);
mitk::ConnectomicsNetwork::VertexDescriptorType source;
mitk::ConnectomicsNetwork::VertexDescriptorType target;
//add vertices on sphere surface
for( int loopID( 1 ); loopID < numberOfPoints; loopID++ )
{
std::vector< float > position;
std::string label;
std::stringstream labelStream;
labelStream << loopID;
label = labelStream.str();
//generate random, uniformly distributed points on a sphere surface
const double uVariable = rng.drand64( 0.0 , 1.0);
const double vVariable = rng.drand64( 0.0 , 1.0);
const double phi = 2 * vnl_math::pi * uVariable;
const double theta = std::acos( 2 * vVariable - 1 );
double xpos = radius * std::cos( phi ) * std::sin( theta );
double ypos = radius * std::sin( phi ) * std::sin( theta );
double zpos = radius * std::cos( theta );
position.push_back( xpos );
position.push_back( ypos );
position.push_back( zpos );
mitk::ConnectomicsNetwork::VertexDescriptorType newVertex = network->AddVertex( loopID );
network->SetLabel( newVertex, label );
network->SetCoordinates( newVertex, position );
network->AddEdge( newVertex, centerVertex, loopID, 0, edgeWeight);
}
m_LastGenerationWasSuccess = true;
}
void mitk::ConnectomicsSyntheticNetworkGenerator::GenerateSyntheticRandomNetwork(
mitk::ConnectomicsNetwork::Pointer network, int numberOfPoints, double threshold )
{
// as the surface is proportional to the square of the radius the density stays the same
double radius = 5 * std::sqrt( (float) numberOfPoints );
//the random number generators
unsigned int randomOne = (unsigned int) rand();
unsigned int randomTwo = (unsigned int) rand();
vnl_random rng( (unsigned int) rand() );
vnl_random rng2( (unsigned int) rand() );
// map for storing the conversion from indices to vertex descriptor
std::map< int, mitk::ConnectomicsNetwork::VertexDescriptorType > idToVertexMap;
//add vertices on sphere surface
for( int loopID( 0 ); loopID < numberOfPoints; loopID++ )
{
std::vector< float > position;
std::string label;
std::stringstream labelStream;
labelStream << loopID;
label = labelStream.str();
//generate random, uniformly distributed points on a sphere surface
const double uVariable = rng.drand64( 0.0 , 1.0);
const double vVariable = rng.drand64( 0.0 , 1.0);
const double phi = 2 * vnl_math::pi * uVariable;
const double theta = std::acos( 2 * vVariable - 1 );
double xpos = radius * std::cos( phi ) * std::sin( theta );
double ypos = radius * std::sin( phi ) * std::sin( theta );
double zpos = radius * std::cos( theta );
position.push_back( xpos );
position.push_back( ypos );
position.push_back( zpos );
mitk::ConnectomicsNetwork::VertexDescriptorType newVertex = network->AddVertex( loopID );
network->SetLabel( newVertex, label );
network->SetCoordinates( newVertex, position );
if ( idToVertexMap.count( loopID ) > 0 )
{
MITK_ERROR << "Aborting network creation, duplicate vertex ID generated.";
m_LastGenerationWasSuccess = false;
return;
}
idToVertexMap.insert( std::pair< int, mitk::ConnectomicsNetwork::VertexDescriptorType >( loopID, newVertex) );
}
int edgeID(0);
// uniform weight of one
int edgeWeight(1);
mitk::ConnectomicsNetwork::VertexDescriptorType source;
mitk::ConnectomicsNetwork::VertexDescriptorType target;
for( int loopID( 0 ); loopID < numberOfPoints; loopID++ )
{
// to avoid creating an edge twice (this being an undirected graph) we only
// potentially generate edges with all nodes with a bigger ID
for( int innerLoopID( loopID ); innerLoopID < numberOfPoints; innerLoopID++ )
{
if( rng.drand64( 0.0 , 1.0) > threshold)
{
// do nothing
}
else
{
source = idToVertexMap.find( loopID )->second;
target = idToVertexMap.find( innerLoopID )->second;
network->AddEdge( source, target, loopID, innerLoopID, edgeWeight);
edgeID++;
}
} // end for( int innerLoopID( loopID ); innerLoopID < numberOfPoints; innerLoopID++ )
} // end for( int loopID( 0 ); loopID < numberOfPoints; loopID++ )
m_LastGenerationWasSuccess = true;
}
bool mitk::ConnectomicsSyntheticNetworkGenerator::WasGenerationSuccessfull()
{
return m_LastGenerationWasSuccess;
}
diff --git a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
index 6150e1beca..ef432a30b4 100644
--- a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
+++ b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
@@ -1,689 +1,689 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkConnectomicsNetwork.h"
#include <boost/graph/clustering_coefficient.hpp>
#include <boost/graph/betweenness_centrality.hpp>
/* Constructor and Destructor */
mitk::ConnectomicsNetwork::ConnectomicsNetwork()
: m_IsModified( false )
{
}
mitk::ConnectomicsNetwork::~ConnectomicsNetwork()
{
}
/* Wrapper methods */
bool mitk::ConnectomicsNetwork::EdgeExists(
mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB ) const
{
return boost::edge(vertexA, vertexB, m_Network ).second;
}
void mitk::ConnectomicsNetwork::IncreaseEdgeWeight(
mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB )
{
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight++;
SetIsModified( true );
}
void mitk::ConnectomicsNetwork::AddEdge(
mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
mitk::ConnectomicsNetwork::VertexDescriptorType vertexB
)
{
AddEdge(vertexA, vertexB, m_Network[ vertexA ].id, m_Network[ vertexB ].id );
}
void mitk::ConnectomicsNetwork::AddEdge(
mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
mitk::ConnectomicsNetwork::VertexDescriptorType vertexB,
int sourceID, int targetID, int weight )
{
boost::add_edge( vertexA, vertexB, m_Network );
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].sourceId = sourceID;
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].targetId = targetID;
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight = weight;
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].edge_weight = 1.0;
SetIsModified( true );
}
mitk::ConnectomicsNetwork::VertexDescriptorType mitk::ConnectomicsNetwork::AddVertex( int id )
{
VertexDescriptorType vertex = boost::add_vertex( m_Network );
m_Network[vertex].id = id;
SetIsModified( true );
return vertex;
}
void mitk::ConnectomicsNetwork::SetLabel(
mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::string inLabel )
{
m_Network[vertex].label = inLabel;
SetIsModified( true );
}
void mitk::ConnectomicsNetwork::SetCoordinates(
mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::vector< float > inCoordinates )
{
m_Network[vertex].coordinates = inCoordinates;
SetIsModified( true );
}
void mitk::ConnectomicsNetwork::clear()
{
m_Network.clear();
SetIsModified( true );
}
/* Superclass methods, that need to be implemented */
void mitk::ConnectomicsNetwork::UpdateOutputInformation()
{
}
void mitk::ConnectomicsNetwork::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::ConnectomicsNetwork::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::ConnectomicsNetwork::VerifyRequestedRegion()
{
return true;
}
-void mitk::ConnectomicsNetwork::SetRequestedRegion( itk::DataObject *data )
+void mitk::ConnectomicsNetwork::SetRequestedRegion(const itk::DataObject *data )
{
}
std::vector< mitk::ConnectomicsNetwork::NetworkNode >
mitk::ConnectomicsNetwork::GetVectorOfAllNodes() const
{
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::vertices( m_Network );
std::vector< NetworkNode > vectorOfNodes;
for ( ; iterator != end; ++iterator)
{
NetworkNode tempNode;
// the value of an iterator is a descriptor
tempNode = m_Network[ *iterator ];
vectorOfNodes.push_back( tempNode );
}
return vectorOfNodes;
}
std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
mitk::ConnectomicsNetwork::GetVectorOfAllVertexDescriptors() const
{
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::vertices( m_Network );
std::vector< VertexDescriptorType > vectorOfDescriptors;
for ( ; iterator != end; ++iterator)
{
vectorOfDescriptors.push_back( *iterator );
}
return vectorOfDescriptors;
}
std::vector< std::pair<
std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode >
, mitk::ConnectomicsNetwork::NetworkEdge > >
mitk::ConnectomicsNetwork::GetVectorOfAllEdges() const
{
boost::graph_traits<NetworkType>::edge_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::edges( m_Network );
std::vector<
std::pair<
std::pair< NetworkNode, NetworkNode >
, NetworkEdge
>
> vectorOfEdges;
for ( ; iterator != end; ++iterator)
{
NetworkNode sourceNode, targetNode;
NetworkEdge tempEdge;
// the value of an iterator is a descriptor
tempEdge = m_Network[ *iterator ];
sourceNode = m_Network[ boost::source( *iterator, m_Network ) ];
targetNode = m_Network[ boost::target( *iterator, m_Network ) ];
std::pair< NetworkNode, NetworkNode > nodePair( sourceNode, targetNode );
std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > edgePair( nodePair, tempEdge);
vectorOfEdges.push_back( edgePair );
}
return vectorOfEdges;
}
int mitk::ConnectomicsNetwork::GetNumberOfVertices() const
{
return boost::num_vertices( m_Network );
}
int mitk::ConnectomicsNetwork::GetNumberOfEdges() const
{
return boost::num_edges( m_Network );
}
int mitk::ConnectomicsNetwork::GetMaximumWeight() const
{
int maxWeight( 0 );
boost::graph_traits<NetworkType>::edge_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::edges( m_Network );
for ( ; iterator != end; ++iterator)
{
int tempWeight;
// the value of an iterator is a descriptor
tempWeight = m_Network[ *iterator ].weight;
if( tempWeight > maxWeight )
{
maxWeight = tempWeight;
}
}
return maxWeight;
}
int mitk::ConnectomicsNetwork::GetNumberOfSelfLoops()
{
int noOfSelfLoops( 0 );
std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > >
edgeVector = GetVectorOfAllEdges();
for( int index = 0; index < edgeVector.size() ; index++ )
{
double sourceX, sourceY, sourceZ, targetX, targetY, targetZ;
sourceX = edgeVector[ index ].first.first.coordinates[0] ;
sourceY = edgeVector[ index ].first.first.coordinates[1] ;
sourceZ = edgeVector[ index ].first.first.coordinates[2] ;
targetX = edgeVector[ index ].first.second.coordinates[0] ;
targetY = edgeVector[ index ].first.second.coordinates[1] ;
targetZ = edgeVector[ index ].first.second.coordinates[2] ;
// if the coordinates are the same
if(
sourceX > ( targetX - 0.01 ) &&
sourceX < ( targetX + 0.01 ) &&
sourceY > ( targetY - 0.01 ) &&
sourceY < ( targetY + 0.01 ) &&
sourceZ > ( targetZ - 0.01 ) &&
sourceZ < ( targetZ + 0.01 )
)
{
noOfSelfLoops++;
}
}
return noOfSelfLoops;
}
double mitk::ConnectomicsNetwork::GetAverageDegree()
{
double vertices = (double) GetNumberOfVertices();
double edges = (double) GetNumberOfEdges();
return ( ( edges * 2.0 ) / vertices );
}
double mitk::ConnectomicsNetwork::GetConnectionDensity()
{
double vertices = (double) GetNumberOfVertices();
double edges = (double) GetNumberOfEdges();
double numberOfPossibleEdges = vertices * ( vertices - 1 ) / 2 ;
return ( edges / numberOfPossibleEdges );
}
std::vector< int > mitk::ConnectomicsNetwork::GetDegreeOfNodes( ) const
{
std::vector< int > vectorOfDegree;
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
// sets iterator to start end end to end
boost::tie( iterator, end ) = boost::vertices( m_Network );
vectorOfDegree.resize( this->GetNumberOfVertices() );
for ( ; iterator != end; ++iterator)
{
// the value of an iterator is a descriptor
vectorOfDegree[ m_Network[ *iterator ].id ] = GetVectorOfAdjacentNodes( *iterator ).size();
}
return vectorOfDegree;
}
std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
mitk::ConnectomicsNetwork::GetVectorOfAdjacentNodes( mitk::ConnectomicsNetwork::VertexDescriptorType vertex ) const
{
std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType > vectorOfAdjacentNodes;
boost::graph_traits<NetworkType>::adjacency_iterator adjIter, adjEnd;
boost::tie( adjIter, adjEnd ) = boost::adjacent_vertices( vertex, m_Network);
for ( ; adjIter != adjEnd; ++adjIter)
{
vectorOfAdjacentNodes.push_back( *adjIter );
}
return vectorOfAdjacentNodes;
}
int mitk::ConnectomicsNetwork::GetMaximumDegree() const
{
int maximumDegree( 0 );
std::vector< int > vectorOfDegree = GetDegreeOfNodes();
for( int index( 0 ); index < vectorOfDegree.size(); ++index )
{
if( maximumDegree < vectorOfDegree[ index ] )
{
maximumDegree = vectorOfDegree[ index ];
}
}
return maximumDegree;
}
std::vector< double > mitk::ConnectomicsNetwork::GetLocalClusteringCoefficients( ) const
{
std::vector< double > vectorOfClusteringCoefficients;
typedef boost::graph_traits<NetworkType>::vertex_iterator vertexIter;
vectorOfClusteringCoefficients.resize( this->GetNumberOfVertices() );
std::pair<vertexIter, vertexIter> vertexPair;
//for every vertex calculate the clustering coefficient
for (vertexPair = vertices(m_Network); vertexPair.first != vertexPair.second; ++vertexPair.first)
{
vectorOfClusteringCoefficients[ m_Network[ *vertexPair.first ].id ] =
boost::clustering_coefficient(m_Network,*vertexPair.first) ;
}
return vectorOfClusteringCoefficients;
}
std::vector< double > mitk::ConnectomicsNetwork::GetClusteringCoefficientsByDegree( )
{
std::vector< double > vectorOfClusteringCoefficients = GetLocalClusteringCoefficients();
std::vector< int > vectorOfDegree = GetDegreeOfNodes();
std::vector< double > vectorOfClusteringCoefficientsByDegree;
vectorOfClusteringCoefficientsByDegree.resize( GetMaximumDegree() + 1, 0 );
// c_{mean}(k) = frac{1}_{N_{k}} sum_{i in Y(k)} c_{i}
// where N_{k} is the number of vertices of degree k
// Y(k) is the set of vertices of degree k
// c_{i} is the local clustering coefficient of vertex i
for( int degree( 0 ); degree < vectorOfClusteringCoefficientsByDegree.size(); ++degree )
{
vectorOfClusteringCoefficientsByDegree[ degree ] = 0;
int n_k( 0 );
for( int index( 0 ); index < vectorOfDegree.size(); ++index )
{
if( degree == vectorOfDegree[ index ] )
{// if in Y( degree )
vectorOfClusteringCoefficientsByDegree[ degree ] += vectorOfClusteringCoefficients[ index ];
n_k++;
}
}
if( n_k != 0 )
{
vectorOfClusteringCoefficientsByDegree[ degree ] =
vectorOfClusteringCoefficientsByDegree[ degree ] / n_k;
}
}
return vectorOfClusteringCoefficientsByDegree;
}
double mitk::ConnectomicsNetwork::GetGlobalClusteringCoefficient( )
{
double globalClusteringCoefficient( 0.0 );
std::vector< double > vectorOfClusteringCoefficientsByDegree = GetClusteringCoefficientsByDegree();
std::vector< int > vectorOfDegree = GetDegreeOfNodes();
std::vector< int > degreeDistribution;
degreeDistribution.resize( vectorOfClusteringCoefficientsByDegree.size(), 0 );
int normalizationParameter( 0 );
for( int index( 0 ); index < vectorOfDegree.size(); ++index )
{
degreeDistribution[ vectorOfDegree[ index ] ]++;
normalizationParameter++;
}
// c_{mean} = sum_{k} P_{k} c_{mean}(k)
// where P_{k} is the degree distribution
// k is the degree
for( int degree( 0 ); degree < degreeDistribution.size(); ++degree )
{
globalClusteringCoefficient +=
degreeDistribution[ degree ] / ( (double) normalizationParameter)
* vectorOfClusteringCoefficientsByDegree[ degree ];
}
return globalClusteringCoefficient;
}
mitk::ConnectomicsNetwork::NetworkType* mitk::ConnectomicsNetwork::GetBoostGraph()
{
return &m_Network;
}
bool mitk::ConnectomicsNetwork::GetIsModified() const
{
return m_IsModified;
}
void mitk::ConnectomicsNetwork::SetIsModified( bool value)
{
m_IsModified = value;
}
mitk::ConnectomicsNetwork::NetworkNode mitk::ConnectomicsNetwork::GetNode( VertexDescriptorType vertex ) const
{
return m_Network[ vertex ];
}
mitk::ConnectomicsNetwork::NetworkEdge mitk::ConnectomicsNetwork::GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const
{
return m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ];
}
void mitk::ConnectomicsNetwork::UpdateBounds( )
{
float min = itk::NumericTraits<float>::min();
float max = itk::NumericTraits<float>::max();
float bounds[] = {max, min, max, min, max, min};
std::vector< mitk::ConnectomicsNetwork::NetworkNode > nodeVector = this->GetVectorOfAllNodes();
if( nodeVector.size() == 0 )
{
bounds[0] = 0;
bounds[1] = 1;
bounds[2] = 0;
bounds[3] = 1;
bounds[4] = 0;
bounds[5] = 1;
}
// for each direction, make certain the point is in between
for( int index(0), end(nodeVector.size()) ; index < end; index++ )
{
for( int direction(0); direction < nodeVector.at( index ).coordinates.size(); direction++ )
{
if( nodeVector.at( index ).coordinates.at(direction) < bounds[ 2 * direction ] )
{
bounds[ 2 * direction ] = nodeVector.at( index ).coordinates.at(direction);
}
if( nodeVector.at( index ).coordinates.at(direction) > bounds[ 2 * direction + 1] )
{
bounds[ 2 * direction + 1] = nodeVector.at( index ).coordinates.at(direction);
}
}
}
// provide some border margin
for(int i=0; i<=4; i+=2)
{
bounds[i] -=10;
}
for(int i=1; i<=5; i+=2)
{
bounds[i] +=10;
}
this->GetGeometry()->SetFloatBounds(bounds);
this->GetTimeSlicedGeometry()->UpdateInformation();
}
void mitk::ConnectomicsNetwork::PruneUnconnectedSingleNodes()
{
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
// set to true if iterators are invalidated by deleting a vertex
bool vertexHasBeenRemoved( true );
// if no vertex has been removed in the last loop, we are done
while( vertexHasBeenRemoved )
{
vertexHasBeenRemoved = false;
// sets iterator to start and end to end
boost::tie(iterator, end) = boost::vertices( m_Network );
for ( ; iterator != end && !vertexHasBeenRemoved; ++iterator)
{
// If the node has no adjacent vertices it should be deleted
if( GetVectorOfAdjacentNodes( *iterator ).size() == 0 )
{
vertexHasBeenRemoved = true;
// this invalidates all iterators
boost::remove_vertex( *iterator, m_Network );
}
}
}
UpdateIDs();
}
void mitk::ConnectomicsNetwork::UpdateIDs()
{
boost::graph_traits<NetworkType>::vertex_iterator v_i, v_end;
boost::graph_traits<NetworkType>::edge_iterator e_i, e_end;
// update node ids
boost::tie( v_i, v_end ) = boost::vertices( m_Network );
for ( ; v_i != v_end; ++v_i)
{
m_Network[*v_i].id = *v_i;
}
// update edge information
boost::tie(e_i, e_end) = boost::edges( m_Network );
for ( ; e_i != e_end; ++e_i)
{
m_Network[ *e_i ].sourceId = m_Network[ boost::source( *e_i, m_Network ) ].id;
m_Network[ *e_i ].targetId = m_Network[ boost::target( *e_i, m_Network ) ].id;
}
this->SetIsModified( true );
}
void mitk::ConnectomicsNetwork::PruneEdgesBelowWeight( int targetWeight )
{
boost::graph_traits<NetworkType>::edge_iterator iterator, end;
// set to true if iterators are invalidated by deleting a vertex
bool edgeHasBeenRemoved( true );
// if no vertex has been removed in the last loop, we are done
while( edgeHasBeenRemoved )
{
edgeHasBeenRemoved = false;
// sets iterator to start and end to end
boost::tie(iterator, end) = boost::edges( m_Network );
for ( ; iterator != end && !edgeHasBeenRemoved; ++iterator)
{
// If the node has no adjacent edges it should be deleted
if( m_Network[ *iterator ].weight < targetWeight )
{
edgeHasBeenRemoved = true;
// this invalidates all iterators
boost::remove_edge( *iterator, m_Network );
}
}
}
// this will remove any nodes which, after deleting edges are now
// unconnected, also this calls UpdateIDs()
PruneUnconnectedSingleNodes();
}
std::vector< double > mitk::ConnectomicsNetwork::GetNodeBetweennessVector() const
{
std::vector< double > betweennessVector;
betweennessVector.clear();
betweennessVector.resize( this->GetNumberOfVertices() );
boost::brandes_betweenness_centrality(
m_Network,
boost::centrality_map(
boost::make_iterator_property_map( betweennessVector.begin(), boost::get( &NetworkNode::id, m_Network ), double() )
).vertex_index_map( boost::get( &NetworkNode::id, m_Network ) )
);
return betweennessVector;
}
std::vector< double > mitk::ConnectomicsNetwork::GetEdgeBetweennessVector() const
{
// std::map used for convenient initialization
typedef std::map<EdgeDescriptorType, int> EdgeIndexStdMap;
EdgeIndexStdMap stdEdgeIndex;
// associative property map needed for iterator property map-wrapper
typedef boost::associative_property_map< EdgeIndexStdMap > EdgeIndexMap;
EdgeIndexMap edgeIndex(stdEdgeIndex);
boost::graph_traits<NetworkType>::edge_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::edges( m_Network );
int i(0);
for ( ; iterator != end; ++iterator, ++i)
{
stdEdgeIndex.insert(std::pair< EdgeDescriptorType, int >( *iterator, i));
}
// Define EdgeCentralityMap
std::vector< double > edgeBetweennessVector(boost::num_edges( m_Network ), 0.0);
// Create the external property map
boost::iterator_property_map< std::vector< double >::iterator, EdgeIndexMap >
e_centrality_map(edgeBetweennessVector.begin(), edgeIndex);
// Define VertexCentralityMap
typedef boost::property_map< NetworkType, boost::vertex_index_t>::type VertexIndexMap;
VertexIndexMap vertexIndex = get(boost::vertex_index, m_Network );
std::vector< double > betweennessVector(boost::num_vertices( m_Network ), 0.0);
// Create the external property map
boost::iterator_property_map< std::vector< double >::iterator, VertexIndexMap >
v_centrality_map(betweennessVector.begin(), vertexIndex);
boost::brandes_betweenness_centrality( m_Network, v_centrality_map, e_centrality_map );
return edgeBetweennessVector;
}
std::vector< double > mitk::ConnectomicsNetwork::GetShortestDistanceVectorFromLabel( std::string targetLabel ) const
{
std::vector< VertexDescriptorType > predecessorMap( boost::num_vertices( m_Network ) );
int numberOfNodes( boost::num_vertices( m_Network ) );
std::vector< double > distanceMatrix;
distanceMatrix.resize( numberOfNodes );
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
boost::tie(iterator, end) = boost::vertices( m_Network );
while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
{
++iterator;
}
if( iterator == end )
{
MITK_WARN << "Label not found";
return distanceMatrix;
}
boost::dijkstra_shortest_paths(m_Network, *iterator, boost::predecessor_map(&predecessorMap[ 0 ]).distance_map(&distanceMatrix[ 0 ]).weight_map( boost::get( &NetworkEdge::edge_weight ,m_Network ) ) ) ;
return distanceMatrix;
}
bool mitk::ConnectomicsNetwork::CheckForLabel( std::string targetLabel ) const
{
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
boost::tie(iterator, end) = boost::vertices( m_Network );
while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
{
++iterator;
}
if( iterator == end )
{
return false;
}
return true;
}
diff --git a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.h b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.h
index e2a3d49623..002c5c3fbe 100644
--- a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.h
+++ b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.h
@@ -1,227 +1,227 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_ConnectomicsNetwork_H
#define _MITK_ConnectomicsNetwork_H
#include "ConnectomicsExports.h"
#include "mitkBaseData.h"
#include <boost/graph/adjacency_list.hpp>
namespace mitk {
/**
* \brief Connectomics Network Class
*
* This class is designed to represent a connectomics network (brain network). It encapsulates a
* boost adjacency list and provides additional capabilities. The information contained in the nodes and edges is:
*
* Network Node:
* <ul>
* <li> int ID - The id of the node
* <li> string label - The label of the node, this can be any string, such as an anatomical label
* <li> vector<float> coordinates - The coordinates the node should be displayed at
* </ul>
*
* Network Edge:
* <ul>
* <li> int sourceId - The Id of the source node
* <li> int targetId - The Id of the target node
* <li> int weight - Weight of the edge as int (used for counting fibers)
* <li> double edge_weight - Used for boost and algorithms, should be between 0 and 1
* </ul>
*/
class Connectomics_EXPORT ConnectomicsNetwork : public BaseData
{
public:
/** Structs for the graph */
/** The Node */
struct NetworkNode
{
int id;
std::string label;
std::vector< float > coordinates;
};
/** The Edge */
struct NetworkEdge
{
int sourceId;
int targetId;
int weight; // For now the number of times it was present
double edge_weight; // For boost, currently set to 1 by default for unweighted calculations
};
/** Typedefs **/
//typedef boost::adjacency_list< boost::listS, boost::listS, boost::undirectedS, NetworkNode, NetworkEdge > NetworkType;
typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, NetworkNode, NetworkEdge > NetworkType;
typedef boost::graph_traits<NetworkType>::vertex_descriptor VertexDescriptorType;
typedef boost::graph_traits<NetworkType>::edge_descriptor EdgeDescriptorType;
// virtual methods that need to be implemented
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
- virtual void SetRequestedRegion( itk::DataObject *data );
+ virtual void SetRequestedRegion(const itk::DataObject *data );
// Macros
mitkClassMacro( ConnectomicsNetwork, BaseData );
itkNewMacro( Self );
////////////////// Interface ///////////////////
/** return whether an edge exists between the two given vertices */
bool EdgeExists( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const;
/** increase the weight of an edge between the two given vertices */
void IncreaseEdgeWeight( VertexDescriptorType vertexA, VertexDescriptorType vertexB );
/** add an edge between two given vertices */
void AddEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB);
/** add an edge between two given vertices ( with a specific weight ) */
void AddEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB, int sourceID, int targetID, int weight = 1 );
/** add a vertex with a specified id */
VertexDescriptorType AddVertex( int id);
/** set the label of a vertex */
void SetLabel( VertexDescriptorType vertex, std::string inLabel );
/** set the coordinates of a vertex */
void SetCoordinates( VertexDescriptorType vertex, std::vector< float > inCoordinates );
/** clear the graph */
void clear();
/** return the node struct for a given node descriptor */
NetworkNode GetNode( VertexDescriptorType vertex ) const;
/** return the edge struct for two given node descriptors */
NetworkEdge GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const;
/** get vector containing all the nodes of the network */
std::vector< NetworkNode > GetVectorOfAllNodes() const;
/** get vector containing all the vertex descriptors of the network */
std::vector< VertexDescriptorType > GetVectorOfAllVertexDescriptors() const;
/** get vector containing the descriptors of nodes adjacent to the vertex denoted by the given descriptor */
std::vector< VertexDescriptorType > GetVectorOfAdjacentNodes( VertexDescriptorType vertex ) const;
/** get vector containing all the edges of the network and the connected nodes */
std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > > GetVectorOfAllEdges() const;
/** get overall number of vertices in the network */
int GetNumberOfVertices() const;
/** get overall number of edges in the network */
int GetNumberOfEdges() const;
/** get number of vertices, that are connected to themselves */
int GetNumberOfSelfLoops();
/** get number of vertices, that are connected to themselves */
double GetAverageDegree();
/** get number of edges divided by number of possible edges */
double GetConnectionDensity();
/** Get the maximum weight of all edges */
int GetMaximumWeight() const;
/** Get a vector in the format vector[ vertexID ] = degree */
std::vector< int > GetDegreeOfNodes( ) const;
/** Get the maximum degree of all nodes */
int GetMaximumDegree() const;
/** Get a vector in the format vector[ vertexID ] = clustering coefficient */
std::vector< double > GetLocalClusteringCoefficients( ) const;
/** Get a vector in the format vector[ degree ] = average clustering coefficient */
std::vector< double > GetClusteringCoefficientsByDegree( );
/** Get the global clustering coefficient */
double GetGlobalClusteringCoefficient( );
/** Get the betweenness centrality for each vertex in form of a vector of length (number vertices)*/
std::vector< double > GetNodeBetweennessVector() const;
/** Get the betweenness centrality for each edge in form of a vector of length (number edges)*/
std::vector< double > GetEdgeBetweennessVector() const;
/** Check whether a vertex with the specified label exists*/
bool CheckForLabel( std::string targetLabel ) const;
/** Get the shortest distance from a specified vertex to all other vertices in form of a vector of length (number vertices)*/
std::vector< double > GetShortestDistanceVectorFromLabel( std::string targetLabel ) const;
/** Access boost graph directly */
NetworkType* GetBoostGraph();
/** Get the modified flag */
bool GetIsModified() const;
/** Set the modified flag */
void SetIsModified( bool );
/** Update the bounds of the geometry to fit the network */
void UpdateBounds( );
/** Remove nodes not connected to any other node */
void PruneUnconnectedSingleNodes();
/** Remove edges below the specified weight
*
* targetWeight is the number of connecting fibers
*
* This will remove unconnected nodes after removal
*/
void PruneEdgesBelowWeight( int targetWeight );
protected:
ConnectomicsNetwork();
virtual ~ConnectomicsNetwork();
/** This function will relabel all vertices and edges in a continuous manner
*
* Mainly important after removing vertices, to make sure that the ids run continuously from
* 0 to number of vertices - 1 and edge target and source ids match the corresponding node.
*/
void UpdateIDs();
NetworkType m_Network;
/// Flag which indicates whether the network has been modified since the last check
///
/// mainly for rendering purposes
bool m_IsModified;
private:
};
} // namespace mitk
#endif /* _MITK_ConnectomicsNetwork_H */
diff --git a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetworkReader.cpp b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetworkReader.cpp
index 318233b549..5e007a1381 100644
--- a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetworkReader.cpp
+++ b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetworkReader.cpp
@@ -1,260 +1,275 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkConnectomicsNetworkReader.h"
#include "mitkConnectomicsNetworkDefinitions.h"
#include <tinyxml.h>
#include "itksys/SystemTools.hxx"
#include <vtkMatrix4x4.h>
void mitk::ConnectomicsNetworkReader::GenerateData()
{
MITK_INFO << "Reading connectomics network";
if ( ( ! m_OutputCache ) )
{
Superclass::SetNumberOfRequiredOutputs(0);
this->GenerateOutputInformation();
}
if (!m_OutputCache)
{
itkWarningMacro("Tree cache is empty!");
}
Superclass::SetNumberOfRequiredOutputs(1);
Superclass::SetNthOutput(0, m_OutputCache.GetPointer());
}
void mitk::ConnectomicsNetworkReader::GenerateOutputInformation()
{
m_OutputCache = OutputType::New();
std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
ext = itksys::SystemTools::LowerCase(ext);
if ( m_FileName == "")
{
MITK_ERROR << "No file name specified.";
}
else if (ext == ".cnf")
{
try
{
TiXmlDocument doc( m_FileName );
bool loadOkay = doc.LoadFile();
if(!loadOkay)
{
mitkThrow() << "Could not open file " << m_FileName << " for reading.";
}
TiXmlHandle hDoc(&doc);
TiXmlElement* pElem;
TiXmlHandle hRoot(0);
pElem = hDoc.FirstChildElement().Element();
// save this for later
hRoot = TiXmlHandle(pElem);
pElem = hRoot.FirstChildElement(mitk::ConnectomicsNetworkDefinitions::XML_GEOMETRY).Element();
// read geometry
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
// read origin
mitk::Point3D origin;
double temp = 0;
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_X, &temp);
origin[0] = temp;
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_Y, &temp);
origin[1] = temp;
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_Z, &temp);
origin[2] = temp;
geometry->SetOrigin(origin);
// read spacing
float spacing[3];
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_X, &temp);
spacing[0] = temp;
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_Y, &temp);
spacing[1] = temp;
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_Z, &temp);
spacing[2] = temp;
geometry->SetSpacing(spacing);
// read transform
vtkMatrix4x4* m = vtkMatrix4x4::New();
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XX, &temp);
m->SetElement(0,0,temp);
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XY, &temp);
m->SetElement(1,0,temp);
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XZ, &temp);
m->SetElement(2,0,temp);
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YX, &temp);
m->SetElement(0,1,temp);
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YY, &temp);
m->SetElement(1,1,temp);
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YZ, &temp);
m->SetElement(2,1,temp);
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZX, &temp);
m->SetElement(0,2,temp);
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZY, &temp);
m->SetElement(1,2,temp);
pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZZ, &temp);
m->SetElement(2,2,temp);
m->SetElement(0,3,origin[0]);
m->SetElement(1,3,origin[1]);
m->SetElement(2,3,origin[2]);
m->SetElement(3,3,1);
geometry->SetIndexToWorldTransformByVtkMatrix(m);
geometry->SetImageGeometry(true);
m_OutputCache->SetGeometry(geometry);
// read network
std::map< int, mitk::ConnectomicsNetwork::VertexDescriptorType > idToVertexMap;
// read vertices
pElem = hRoot.FirstChildElement(mitk::ConnectomicsNetworkDefinitions::XML_VERTICES).Element();
{
// walk through the vertices
TiXmlElement* vertexElement = pElem->FirstChildElement();
for( vertexElement; vertexElement; vertexElement=vertexElement->NextSiblingElement())
{
std::vector< float > pos;
std::string label;
int vertexID(0);
vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_X, &temp);
pos.push_back(temp);
vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_Y, &temp);
pos.push_back(temp);
vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_Z, &temp);
pos.push_back(temp);
vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_ID, &vertexID);
vertexElement->QueryStringAttribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_LABEL, &label);
mitk::ConnectomicsNetwork::VertexDescriptorType newVertex = m_OutputCache->AddVertex( vertexID );
m_OutputCache->SetLabel( newVertex, label );
m_OutputCache->SetCoordinates( newVertex, pos );
if ( idToVertexMap.count( vertexID ) > 0 )
{
MITK_ERROR << "Aborting network creation, duplicate vertex ID in file.";
return;
}
idToVertexMap.insert( std::pair< int, mitk::ConnectomicsNetwork::VertexDescriptorType >( vertexID, newVertex) );
}
}
// read edges
pElem = hRoot.FirstChildElement(mitk::ConnectomicsNetworkDefinitions::XML_EDGES).Element();
{
// walk through the edges
TiXmlElement* edgeElement = pElem->FirstChildElement();
for( edgeElement; edgeElement; edgeElement=edgeElement->NextSiblingElement())
{
int edgeID(0), edgeSourceID(0), edgeTargetID(0), edgeWeight(0);
edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_ID, &edgeID);
edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_SOURCE_ID, &edgeSourceID);
edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_TARGET_ID, &edgeTargetID);
edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_WEIGHT_ID, &edgeWeight);
mitk::ConnectomicsNetwork::VertexDescriptorType source = idToVertexMap.find( edgeSourceID )->second;
mitk::ConnectomicsNetwork::VertexDescriptorType target = idToVertexMap.find( edgeTargetID )->second;
m_OutputCache->AddEdge( source, target, edgeSourceID, edgeTargetID, edgeWeight);
}
}
m_OutputCache->UpdateBounds();
MITK_INFO << "Network read";
}
catch (mitk::Exception e)
{
MITK_ERROR << e.GetDescription();
}
catch(...)
{
MITK_ERROR << "Unknown error occured while trying to read file.";
}
}
}
void mitk::ConnectomicsNetworkReader::Update()
{
this->GenerateData();
}
const char* mitk::ConnectomicsNetworkReader::GetFileName() const
{
return m_FileName.c_str();
}
void mitk::ConnectomicsNetworkReader::SetFileName(const char* aFileName)
{
m_FileName = aFileName;
}
const char* mitk::ConnectomicsNetworkReader::GetFilePrefix() const
{
return m_FilePrefix.c_str();
}
void mitk::ConnectomicsNetworkReader::SetFilePrefix(const char* aFilePrefix)
{
m_FilePrefix = aFilePrefix;
}
const char* mitk::ConnectomicsNetworkReader::GetFilePattern() const
{
return m_FilePattern.c_str();
}
void mitk::ConnectomicsNetworkReader::SetFilePattern(const char* aFilePattern)
{
m_FilePattern = aFilePattern;
}
bool mitk::ConnectomicsNetworkReader::CanReadFile(
const std::string filename, const std::string /*filePrefix*/,
const std::string /*filePattern*/)
{
// First check the extension
if( filename == "" )
{
return false;
}
std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
ext = itksys::SystemTools::LowerCase(ext);
if (ext == ".cnf")
{
return true;
}
return false;
}
+mitk::BaseDataSource::DataObjectPointer mitk::ConnectomicsNetworkReader::MakeOutput(const DataObjectIdentifierType &name)
+{
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
+ {
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
+ }
+ return static_cast<itk::DataObject*>(OutputType::New().GetPointer());
+}
+
+mitk::BaseDataSource::DataObjectPointer mitk::ConnectomicsNetworkReader::MakeOutput(DataObjectPointerArraySizeType /*idx*/)
+{
+ return OutputType::New().GetPointer();
+}
+
diff --git a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetworkReader.h b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetworkReader.h
index ed266699e8..878b02623d 100644
--- a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetworkReader.h
+++ b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetworkReader.h
@@ -1,71 +1,73 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkConnectomicsNetworkReader_h
#define __mitkConnectomicsNetworkReader_h
#include "mitkCommon.h"
#include "mitkFileReader.h"
#include "mitkConnectomicsNetwork.h"
namespace mitk
{
/** \brief The reader for connectomics network files (.cnf)
*/
- class ConnectomicsNetworkReader : public FileReader, public BaseProcess
+ class ConnectomicsNetworkReader : public FileReader, public BaseDataSource
{
public:
typedef mitk::ConnectomicsNetwork OutputType;
- mitkClassMacro( ConnectomicsNetworkReader, BaseProcess );
+ mitkClassMacro( ConnectomicsNetworkReader, BaseDataSource );
itkNewMacro(Self);
const char* GetFileName() const;
void SetFileName(const char* aFileName);
const char* GetFilePrefix() const;
void SetFilePrefix(const char* aFilePrefix);
const char* GetFilePattern() const;
void SetFilePattern(const char* aFilePattern);
static bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern);
virtual void Update();
+ BaseDataSource::DataObjectPointer MakeOutput(const DataObjectIdentifierType &name);
+ BaseDataSource::DataObjectPointer MakeOutput( DataObjectPointerArraySizeType idx);
protected:
/** Does the real work. */
virtual void GenerateData();
virtual void GenerateOutputInformation();
OutputType::Pointer m_OutputCache;
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
private:
void operator=(const Self&); //purposely not implemented
};
} //namespace MITK
#endif // __mitkConnectomicsNetworkReader_h
diff --git a/Modules/DiffusionImaging/Connectomics/files.cmake b/Modules/DiffusionImaging/Connectomics/files.cmake
index b4e38aee12..20ad44f508 100644
--- a/Modules/DiffusionImaging/Connectomics/files.cmake
+++ b/Modules/DiffusionImaging/Connectomics/files.cmake
@@ -1,88 +1,88 @@
set(CPP_FILES
# DataStructures Connectomics
IODataStructures/mitkConnectomicsNetwork.cpp
IODataStructures/mitkConnectomicsNetworkReader.cpp
IODataStructures/mitkConnectomicsNetworkIOFactory.cpp
IODataStructures/mitkConnectomicsNetworkSerializer.cpp
IODataStructures/mitkConnectomicsNetworkWriter.cpp
IODataStructures/mitkConnectomicsNetworkWriterFactory.cpp
IODataStructures/mitkConnectomicsNetworkDefinitions.cpp
IODataStructures/mitkConnectomicsConstantsManager.cpp
# DataStructures
IODataStructures/mitkConnectomicsObjectFactory.cpp
# Rendering Connectomics
Rendering/mitkConnectomicsNetworkMapper3D.cpp
Rendering/mitkConnectomicsRenderingSchemeProperty.cpp
Rendering/mitkConnectomicsRenderingEdgeFilteringProperty.cpp
Rendering/mitkConnectomicsRenderingNodeFilteringProperty.cpp
Rendering/mitkConnectomicsRenderingEdgeColorParameterProperty.cpp
Rendering/mitkConnectomicsRenderingEdgeRadiusParameterProperty.cpp
Rendering/mitkConnectomicsRenderingNodeColorParameterProperty.cpp
Rendering/mitkConnectomicsRenderingNodeRadiusParameterProperty.cpp
Rendering/mitkConnectomicsRenderingNodeThresholdParameterProperty.cpp
Rendering/mitkConnectomicsRenderingEdgeThresholdParameterProperty.cpp
# Algorithms Connectomics
Algorithms/mitkConnectomicsNetworkCreator.cpp
Algorithms/mitkConnectomicsHistogramBase.cpp
Algorithms/mitkConnectomicsDegreeHistogram.cpp
Algorithms/mitkConnectomicsShortestPathHistogram.cpp
Algorithms/mitkConnectomicsBetweennessHistogram.cpp
Algorithms/mitkConnectomicsHistogramCache.cpp
Algorithms/mitkConnectomicsSyntheticNetworkGenerator.cpp
+ #Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.cpp
Algorithms/mitkConnectomicsSimulatedAnnealingPermutationBase.cpp
Algorithms/mitkConnectomicsSimulatedAnnealingPermutationModularity.cpp
Algorithms/mitkConnectomicsSimulatedAnnealingManager.cpp
Algorithms/mitkConnectomicsSimulatedAnnealingCostFunctionBase.cpp
Algorithms/mitkConnectomicsSimulatedAnnealingCostFunctionModularity.cpp
- Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.cpp
)
set(H_FILES
# Rendering Connectomics
Rendering/mitkConnectomicsNetworkMapper3D.h
Rendering/mitkConnectomicsRenderingProperties.h
Rendering/mitkConnectomicsRenderingSchemeProperty.h
Rendering/mitkConnectomicsRenderingEdgeFilteringProperty.h
Rendering/mitkConnectomicsRenderingNodeFilteringProperty.h
Rendering/mitkConnectomicsRenderingEdgeColorParameterProperty.h
Rendering/mitkConnectomicsRenderingEdgeRadiusParameterProperty.h
Rendering/mitkConnectomicsRenderingNodeColorParameterProperty.h
Rendering/mitkConnectomicsRenderingNodeRadiusParameterProperty.h
Rendering/mitkConnectomicsRenderingNodeThresholdParameterProperty.h
Rendering/mitkConnectomicsRenderingEdgeThresholdParameterProperty.h
# Datastructures Connectomics
IODataStructures/mitkConnectomicsNetwork.h
IODataStructures/mitkConnectomicsNetworkReader.h
IODataStructures/mitkConnectomicsNetworkIOFactory.h
IODataStructures/mitkConnectomicsNetworkSerializer.h
IODataStructures/mitkConnectomicsNetworkWriter.h
IODataStructures/mitkConnectomicsNetworkWriterFactory.h
IODataStructures/mitkConnectomicsNetworkDefinitions.h
IODataStructures/mitkConnectomicsConstantsManager.h
# Algorithms Connectomics
Algorithms/mitkConnectomicsNetworkCreator.h
Algorithms/mitkConnectomicsHistogramBase.h
Algorithms/mitkConnectomicsDegreeHistogram.h
Algorithms/mitkConnectomicsShortestPathHistogram.h
Algorithms/mitkConnectomicsBetweennessHistogram.h
Algorithms/mitkConnectomicsHistogramCache.h
Algorithms/mitkConnectomicsSyntheticNetworkGenerator.h
Algorithms/mitkConnectomicsSimulatedAnnealingPermutationBase.h
Algorithms/mitkConnectomicsSimulatedAnnealingPermutationModularity.h
Algorithms/mitkConnectomicsSimulatedAnnealingManager.h
Algorithms/mitkConnectomicsSimulatedAnnealingCostFunctionBase.h
Algorithms/mitkConnectomicsSimulatedAnnealingCostFunctionModularity.h
Algorithms/itkConnectomicsNetworkToConnectivityMatrixImageFilter.h
)
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.cpp
index d7db42fc99..adbd2d633c 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.cpp
@@ -1,795 +1,795 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkAnalyticalDiffusionQballReconstructionImageFilter_cpp
#define __itkAnalyticalDiffusionQballReconstructionImageFilter_cpp
#include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#include <itkArray.h>
#include <vnl/vnl_vector.h>
#include <boost/version.hpp>
#include <stdio.h>
#include <locale>
#define _USE_MATH_DEFINES
#include <math.h>
#include <boost/math/special_functions.hpp>
#include "itkPointShell.h"
using namespace boost::math;
namespace itk {
#define QBALL_ANAL_RECON_PI M_PI
template< class T, class TG, class TO, int L, int NODF>
AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::AnalyticalDiffusionQballReconstructionImageFilter() :
m_GradientDirectionContainer(NULL),
m_NumberOfGradientDirections(0),
m_NumberOfBaselineImages(1),
m_Threshold(NumericTraits< ReferencePixelType >::NonpositiveMin()),
m_BValue(1.0),
m_Lambda(0.0),
m_DirectionsDuplicated(false),
m_Delta1(0.001),
m_Delta2(0.001)
{
// At least 1 inputs is necessary for a vector image.
// For images added one at a time we need at least six
this->SetNumberOfRequiredInputs( 1 );
}
template<
class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NOrderL,
int NrOdfDirections>
typename itk::AnalyticalDiffusionQballReconstructionImageFilter<
TReferenceImagePixelType,TGradientImagePixelType,TOdfPixelType,
NOrderL,NrOdfDirections>::OdfPixelType
itk::AnalyticalDiffusionQballReconstructionImageFilter
<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,
NOrderL, NrOdfDirections>
::Normalize( OdfPixelType odf,
typename NumericTraits<ReferencePixelType>::AccumulateType b0 )
{
switch( m_NormalizationMethod )
{
case QBAR_STANDARD:
{
TOdfPixelType sum = 0;
for(int i=0; i<NrOdfDirections; i++)
{
sum += odf[i];
}
if(sum>0)
odf /= sum;
return odf;
break;
}
case QBAR_B_ZERO_B_VALUE:
{
for(int i=0; i<NrOdfDirections; i++)
{
odf[i] = ((TOdfPixelType)log((TOdfPixelType)b0)-odf[i])/m_BValue;
}
return odf;
break;
}
case QBAR_B_ZERO:
{
odf *= 1.0/b0;
return odf;
break;
}
case QBAR_NONE:
{
return odf;
break;
}
case QBAR_ADC_ONLY:
{
for(int i=0; i<NrOdfDirections; i++)
{
odf[i] = ((TOdfPixelType)log((TOdfPixelType)b0)-odf[i])/m_BValue;
}
return odf;
break;
}
case QBAR_RAW_SIGNAL:
{
return odf;
break;
}
case QBAR_SOLID_ANGLE:
{
for(int i=0; i<NrOdfDirections; i++)
odf[i] *= QBALL_ANAL_RECON_PI*4/NrOdfDirections;
break;
}
case QBAR_NONNEG_SOLID_ANGLE:
{
break;
}
}
return odf;
}
template<
class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NOrderL,
int NrOdfDirections>
vnl_vector<TOdfPixelType>
itk::AnalyticalDiffusionQballReconstructionImageFilter
<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,
NOrderL, NrOdfDirections>
::PreNormalize( vnl_vector<TOdfPixelType> vec,
typename NumericTraits<ReferencePixelType>::AccumulateType b0 )
{
switch( m_NormalizationMethod )
{
case QBAR_STANDARD:
{
return vec;
break;
}
case QBAR_B_ZERO_B_VALUE:
{
int n = vec.size();
for(int i=0; i<n; i++)
{
if (vec[i]<=0)
vec[i] = 0.001;
vec[i] = log(vec[i]);
}
return vec;
break;
}
case QBAR_B_ZERO:
{
return vec;
break;
}
case QBAR_NONE:
{
return vec;
break;
}
case QBAR_ADC_ONLY:
{
int n = vec.size();
for(int i=0; i<n; i++)
{
if (vec[i]<=0)
vec[i] = 0.001;
vec[i] = log(vec[i]);
}
return vec;
break;
}
case QBAR_RAW_SIGNAL:
{
return vec;
break;
}
case QBAR_SOLID_ANGLE:
case QBAR_NONNEG_SOLID_ANGLE:
{
int n = vec.size();
double b0f = (double)b0;
for(int i=0; i<n; i++)
{
vec[i] = vec[i]/b0f;
if (vec[i]<0)
vec[i] = m_Delta1;
else if (vec[i]<m_Delta1)
vec[i] = m_Delta1/2 + vec[i]*vec[i]/(2*m_Delta1);
else if (vec[i]>=1)
vec[i] = 1-m_Delta2/2;
else if (vec[i]>=1-m_Delta2)
vec[i] = 1-m_Delta2/2-(1-vec[i])*(1-vec[i])/(2*m_Delta2);
vec[i] = log(-log(vec[i]));
}
return vec;
break;
}
}
return vec;
}
template< class T, class TG, class TO, int L, int NODF>
void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::BeforeThreadedGenerateData()
{
// If we have more than 2 inputs, then each input, except the first is a
// gradient image. The number of gradient images must match the number of
// gradient directions.
//const unsigned int numberOfInputs = this->GetNumberOfInputs();
// There need to be at least 6 gradient directions to be able to compute the
// tensor basis
if( m_NumberOfGradientDirections < (L*L + L + 2)/2 + L )
{
itkExceptionMacro( << "Not enough gradient directions supplied (" << m_NumberOfGradientDirections << "). At least " << (L*L + L + 2)/2 + L << " needed for SH-order " << L);
}
// Input must be an itk::VectorImage.
std::string gradientImageClassName(
this->ProcessObject::GetInput(0)->GetNameOfClass());
if ( strcmp(gradientImageClassName.c_str(),"VectorImage") != 0 )
{
itkExceptionMacro( <<
"There is only one Gradient image. I expect that to be a VectorImage. "
<< "But its of type: " << gradientImageClassName );
}
this->ComputeReconstructionMatrix();
typename GradientImagesType::Pointer img = static_cast< GradientImagesType * >(
this->ProcessObject::GetInput(0) );
m_BZeroImage = BZeroImageType::New();
m_BZeroImage->SetSpacing( img->GetSpacing() ); // Set the image spacing
m_BZeroImage->SetOrigin( img->GetOrigin() ); // Set the image origin
m_BZeroImage->SetDirection( img->GetDirection() ); // Set the image direction
m_BZeroImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
m_BZeroImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
m_BZeroImage->Allocate();
m_ODFSumImage = BZeroImageType::New();
m_ODFSumImage->SetSpacing( img->GetSpacing() ); // Set the image spacing
m_ODFSumImage->SetOrigin( img->GetOrigin() ); // Set the image origin
m_ODFSumImage->SetDirection( img->GetDirection() ); // Set the image direction
m_ODFSumImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
m_ODFSumImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
m_ODFSumImage->Allocate();
m_CoefficientImage = CoefficientImageType::New();
m_CoefficientImage->SetSpacing( img->GetSpacing() ); // Set the image spacing
m_CoefficientImage->SetOrigin( img->GetOrigin() ); // Set the image origin
m_CoefficientImage->SetDirection( img->GetDirection() ); // Set the image direction
m_CoefficientImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
m_CoefficientImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
m_CoefficientImage->Allocate();
if(m_NormalizationMethod == QBAR_SOLID_ANGLE || m_NormalizationMethod == QBAR_NONNEG_SOLID_ANGLE)
m_Lambda = 0.0;
}
template< class T, class TG, class TO, int L, int NODF>
void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int )
+ ThreadIdType )
{
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
oit.GoToBegin();
ImageRegionIterator< BZeroImageType > oit2(m_BZeroImage, outputRegionForThread);
oit2.GoToBegin();
ImageRegionIterator< FloatImageType > oit3(m_ODFSumImage, outputRegionForThread);
oit3.GoToBegin();
ImageRegionIterator< CoefficientImageType > oit4(m_CoefficientImage, outputRegionForThread);
oit4.GoToBegin();
typedef ImageRegionConstIterator< GradientImagesType > GradientIteratorType;
typedef typename GradientImagesType::PixelType GradientVectorType;
typename GradientImagesType::Pointer gradientImagePointer = NULL;
// Would have liked a dynamic_cast here, but seems SGI doesn't like it
// The enum will ensure that an inappropriate cast is not done
gradientImagePointer = static_cast< GradientImagesType * >(
this->ProcessObject::GetInput(0) );
GradientIteratorType git(gradientImagePointer, outputRegionForThread );
git.GoToBegin();
// Compute the indicies of the baseline images and gradient images
std::vector<unsigned int> baselineind; // contains the indicies of
// the baseline images
std::vector<unsigned int> gradientind; // contains the indicies of
// the gradient images
for(GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
gdcit != this->m_GradientDirectionContainer->End(); ++gdcit)
{
if(gdcit.Value().one_norm() <= 0.0)
baselineind.push_back(gdcit.Index());
else
gradientind.push_back(gdcit.Index());
}
if( m_DirectionsDuplicated )
{
int gradIndSize = gradientind.size();
for(int i=0; i<gradIndSize; i++)
gradientind.push_back(gradientind[i]);
}
while( !git.IsAtEnd() )
{
GradientVectorType b = git.Get();
typename NumericTraits<ReferencePixelType>::AccumulateType b0 = NumericTraits<ReferencePixelType>::Zero;
// Average the baseline image pixels
for(unsigned int i = 0; i < baselineind.size(); ++i)
{
b0 += b[baselineind[i]];
}
b0 /= this->m_NumberOfBaselineImages;
OdfPixelType odf(0.0);
typename CoefficientImageType::PixelType coeffPixel(0.0);
vnl_vector<TO> B(m_NumberOfGradientDirections);
if( (b0 != 0) && (b0 >= m_Threshold) )
{
for( unsigned int i = 0; i< m_NumberOfGradientDirections; i++ )
{
B[i] = static_cast<TO>(b[gradientind[i]]);
}
B = PreNormalize(B, b0);
if(m_NormalizationMethod == QBAR_SOLID_ANGLE)
{
vnl_vector<TO> coeffs(m_NumberCoefficients);
coeffs = ( (*m_CoeffReconstructionMatrix) * B );
coeffs[0] += 1.0/(2.0*sqrt(QBALL_ANAL_RECON_PI));
odf = ( (*m_SphericalHarmonicBasisMatrix) * coeffs ).data_block();
coeffPixel = coeffs.data_block();
}
else if(m_NormalizationMethod == QBAR_NONNEG_SOLID_ANGLE)
{
/** this would be the place to implement a non-negative
* solver for quadratic programming problem:
* min .5*|| Bc-s ||^2 subject to -CLPc <= 4*pi*ones
* (refer to MICCAI 2009 Goh et al. "Estimating ODFs with PDF constraints")
* .5*|| Bc-s ||^2 == .5*c'B'Bc - x'B's + .5*s's
*/
itkExceptionMacro( << "Nonnegative Solid Angle not yet implemented");
}
else
{
vnl_vector<TO> coeffs(m_NumberCoefficients);
coeffs = ( (*m_CoeffReconstructionMatrix) * B );
coeffs[0] += 1.0/(2.0*sqrt(QBALL_ANAL_RECON_PI));
coeffPixel = coeffs.data_block();
odf = ( (*m_ReconstructionMatrix) * B ).data_block();
}
odf = Normalize(odf, b0);
}
oit.Set( odf );
oit2.Set( b0 );
float sum = 0;
for (int k=0; k<odf.Size(); k++)
sum += (float) odf[k];
oit3.Set( sum-1 );
oit4.Set(coeffPixel);
++oit; // odf image iterator
++oit3; // odf sum image iterator
++oit2; // b0 image iterator
++oit4; // coefficient image iterator
++git; // Gradient image iterator
}
std::cout << "One Thread finished reconstruction" << std::endl;
}
template< class T, class TG, class TO, int L, int NODF>
void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::tofile2(vnl_matrix<double> *pA, std::string fname)
{
vnl_matrix<double> A = (*pA);
ofstream myfile;
std::locale C("C");
std::locale originalLocale = myfile.getloc();
myfile.imbue(C);
myfile.open (fname.c_str());
myfile << "A1=[";
for(int i=0; i<A.rows(); i++)
{
for(int j=0; j<A.columns(); j++)
{
myfile << A(i,j) << " ";
if(j==A.columns()-1 && i!=A.rows()-1)
myfile << ";";
}
}
myfile << "];";
myfile.close();
myfile.imbue( originalLocale );
}
template< class T, class TG, class TO, int L, int NODF>
void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::Cart2Sph(double x, double y, double z, double *spherical)
{
double phi, theta, r;
r = sqrt(x*x+y*y+z*z);
if( r<mitk::eps )
{
theta = M_PI/2;
phi = M_PI/2;
}
else
{
theta = acos(z/r);
phi = atan2(y, x);
}
spherical[0] = phi;
spherical[1] = theta;
spherical[2] = r;
}
template< class T, class TG, class TO, int L, int NODF>
double AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::Yj(int m, int l, double theta, double phi)
{
if (m<0)
return sqrt(2.0)*spherical_harmonic_r(l, -m, theta, phi);
else if (m==0)
return spherical_harmonic_r(l, m, theta, phi);
else
return pow(-1.0,m)*sqrt(2.0)*spherical_harmonic_i(l, m, theta, phi);
return 0;
}
template< class T, class TG, class TO, int L, int NODF>
double AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::Legendre0(int l)
{
if( l%2 != 0 )
{
return 0;
}
else
{
double prod1 = 1.0;
for(int i=1;i<l;i+=2) prod1 *= i;
double prod2 = 1.0;
for(int i=2;i<=l;i+=2) prod2 *= i;
return pow(-1.0,l/2.0)*(prod1/prod2);
}
}
template< class T, class TG, class TO, int L, int NODF>
void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::ComputeReconstructionMatrix()
{
//for(int i=-6;i<7;i++)
// std::cout << boost::math::legendre_p<double>(6, i, 0.65657) << std::endl;
if( m_NumberOfGradientDirections < (L*L + L + 2)/2 + L )
{
itkExceptionMacro( << "Not enough gradient directions supplied (" << m_NumberOfGradientDirections << "). At least " << (L*L + L + 2)/2 + L << " needed for SH-order " << L);
}
{
// check for duplicate diffusion gradients
bool warning = false;
for(GradientDirectionContainerType::ConstIterator gdcit1 = this->m_GradientDirectionContainer->Begin();
gdcit1 != this->m_GradientDirectionContainer->End(); ++gdcit1)
{
for(GradientDirectionContainerType::ConstIterator gdcit2 = this->m_GradientDirectionContainer->Begin();
gdcit2 != this->m_GradientDirectionContainer->End(); ++gdcit2)
{
if(gdcit1.Value() == gdcit2.Value() && gdcit1.Index() != gdcit2.Index())
{
itkWarningMacro( << "Some of the Diffusion Gradients equal each other. Corresponding image data should be averaged before calling this filter." );
warning = true;
break;
}
}
if (warning) break;
}
// handle acquisition schemes where only half of the spherical
// shell is sampled by the gradient directions. In this case,
// each gradient direction is duplicated in negative direction.
vnl_vector<double> centerMass(3);
centerMass.fill(0.0);
int count = 0;
for(GradientDirectionContainerType::ConstIterator gdcit1 = this->m_GradientDirectionContainer->Begin();
gdcit1 != this->m_GradientDirectionContainer->End(); ++gdcit1)
{
if(gdcit1.Value().one_norm() > 0.0)
{
centerMass += gdcit1.Value();
count ++;
}
}
centerMass /= count;
if(centerMass.two_norm() > 0.1)
{
m_DirectionsDuplicated = true;
m_NumberOfGradientDirections *= 2;
}
}
vnl_matrix<double> *Q = new vnl_matrix<double>(3, m_NumberOfGradientDirections);
{
int i = 0;
for(GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
gdcit != this->m_GradientDirectionContainer->End(); ++gdcit)
{
if(gdcit.Value().one_norm() > 0.0)
{
double x = gdcit.Value().get(0);
double y = gdcit.Value().get(1);
double z = gdcit.Value().get(2);
double cart[3];
Cart2Sph(x,y,z,cart);
(*Q)(0,i) = cart[0];
(*Q)(1,i) = cart[1];
(*Q)(2,i++) = cart[2];
}
}
if(m_DirectionsDuplicated)
{
for(GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
gdcit != this->m_GradientDirectionContainer->End(); ++gdcit)
{
if(gdcit.Value().one_norm() > 0.0)
{
double x = gdcit.Value().get(0);
double y = gdcit.Value().get(1);
double z = gdcit.Value().get(2);
double cart[3];
Cart2Sph(x,y,z,cart);
(*Q)(0,i) = cart[0];
(*Q)(1,i) = cart[1];
(*Q)(2,i++) = cart[2];
}
}
}
}
int l = L;
m_NumberCoefficients = (int)(l*l + l + 2.0)/2.0 + l;
vnl_matrix<double>* B = new vnl_matrix<double>(m_NumberOfGradientDirections,m_NumberCoefficients);
vnl_matrix<double>* _L = new vnl_matrix<double>(m_NumberCoefficients,m_NumberCoefficients);
_L->fill(0.0);
vnl_matrix<double>* LL = new vnl_matrix<double>(m_NumberCoefficients,m_NumberCoefficients);
LL->fill(0.0);
vnl_matrix<double>* P = new vnl_matrix<double>(m_NumberCoefficients,m_NumberCoefficients);
P->fill(0.0);
vnl_matrix<double>* Inv = new vnl_matrix<double>(m_NumberCoefficients,m_NumberCoefficients);
P->fill(0.0);
vnl_vector<int>* lj = new vnl_vector<int>(m_NumberCoefficients);
m_LP = new vnl_vector<double>(m_NumberCoefficients);
for(unsigned int i=0; i<m_NumberOfGradientDirections; i++)
{
for(int k=0; k<=l; k+=2)
{
for(int m=-k; m<=k; m++)
{
int j = (k*k + k + 2)/2 + m - 1;
(*_L)(j,j) = -k*(k+1);
(*m_LP)(j) = -k*(k+1);
(*lj)[j] = k;
double phi = (*Q)(0,i);
double th = (*Q)(1,i);
(*B)(i,j) = Yj(m,k,th,phi);
}
}
}
//vnl_matrix<double> temp((*_L)*(*_L));
LL->update(*_L);
*LL *= *_L;
//tofile2(LL,"LL");
for(int i=0; i<m_NumberCoefficients; i++)
{
// here we leave out the 2*pi multiplication from Descoteaux
// this is because we do not want the real integral value
// but an average value over the equator.
if(m_NormalizationMethod == QBAR_SOLID_ANGLE || m_NormalizationMethod == QBAR_NONNEG_SOLID_ANGLE)
{
(*P)(i,i) = 2.0*QBALL_ANAL_RECON_PI*Legendre0((*lj)[i]);
(*m_LP)(i) *= (*P)(i,i);
}
else
{
(*P)(i,i) = Legendre0((*lj)[i]);
}
}
m_B_t = new vnl_matrix<double>(B->transpose());
//tofile2(&m_B_t,"m_B_t");
vnl_matrix<double> B_t_B = (*m_B_t) * (*B);
//tofile2(&B_t_B,"B_t_B");
vnl_matrix<double> lambdaLL(m_NumberCoefficients,m_NumberCoefficients);
lambdaLL.update((*LL));
lambdaLL *= m_Lambda;
//tofile2(&lambdaLL,"lLL");
vnl_matrix<double> tmp( B_t_B + lambdaLL);
vnl_matrix_inverse<double> *pseudoInverse
= new vnl_matrix_inverse<double>( tmp );
(*Inv) = pseudoInverse->pinverse();
//tofile2(Inv,"Inv");
vnl_matrix<double> temp((*Inv) * (*m_B_t));
double fac1 = (1.0/(16.0*QBALL_ANAL_RECON_PI*QBALL_ANAL_RECON_PI));
switch(m_NormalizationMethod)
{
case QBAR_ADC_ONLY:
case QBAR_RAW_SIGNAL:
break;
case QBAR_STANDARD:
case QBAR_B_ZERO_B_VALUE:
case QBAR_B_ZERO:
case QBAR_NONE:
temp = (*P) * temp;
break;
case QBAR_SOLID_ANGLE:
temp = fac1 * (*P) * (*_L) * temp;
break;
case QBAR_NONNEG_SOLID_ANGLE:
break;
}
//tofile2(&temp,"A");
m_CoeffReconstructionMatrix = new vnl_matrix<TO>(m_NumberCoefficients,m_NumberOfGradientDirections);
for(int i=0; i<m_NumberCoefficients; i++)
{
for(unsigned int j=0; j<m_NumberOfGradientDirections; j++)
{
(*m_CoeffReconstructionMatrix)(i,j) = (float) temp(i,j);
}
}
// this code goes to the image adapter coeffs->odfs later
int NOdfDirections = NODF;
vnl_matrix_fixed<double, 3, NODF>* U =
itk::PointShell<NODF, vnl_matrix_fixed<double, 3, NODF> >::DistributePointShell();
m_SphericalHarmonicBasisMatrix = new vnl_matrix<TO>(NOdfDirections,m_NumberCoefficients);
vnl_matrix<double>* sphericalHarmonicBasisMatrix2
= new vnl_matrix<double>(NOdfDirections,m_NumberCoefficients);
for(int i=0; i<NOdfDirections; i++)
{
double x = (*U)(0,i);
double y = (*U)(1,i);
double z = (*U)(2,i);
double cart[3];
Cart2Sph(x,y,z,cart);
(*U)(0,i) = cart[0];
(*U)(1,i) = cart[1];
(*U)(2,i) = cart[2];
}
for(int i=0; i<NOdfDirections; i++)
{
for(int k=0; k<=l; k+=2)
{
for(int m=-k; m<=k; m++)
{
int j = (k*k + k + 2)/2 + m - 1;
double phi = (*U)(0,i);
double th = (*U)(1,i);
(*m_SphericalHarmonicBasisMatrix)(i,j) = Yj(m,k,th,phi);
(*sphericalHarmonicBasisMatrix2)(i,j) = (*m_SphericalHarmonicBasisMatrix)(i,j);
}
}
}
m_ReconstructionMatrix = new vnl_matrix<TO>(NOdfDirections,m_NumberOfGradientDirections);
*m_ReconstructionMatrix = (*m_SphericalHarmonicBasisMatrix) * (*m_CoeffReconstructionMatrix);
}
template< class T, class TG, class TO, int L, int NODF>
void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::SetGradientImage( GradientDirectionContainerType *gradientDirection,
const GradientImagesType *gradientImage )
{
this->m_GradientDirectionContainer = gradientDirection;
unsigned int numImages = gradientDirection->Size();
this->m_NumberOfBaselineImages = 0;
for(GradientDirectionContainerType::Iterator it = this->m_GradientDirectionContainer->Begin();
it != this->m_GradientDirectionContainer->End(); it++)
{
if(it.Value().one_norm() <= 0.0)
{
this->m_NumberOfBaselineImages++;
}
else // Normalize non-zero gradient directions
{
it.Value() = it.Value() / it.Value().two_norm();
}
}
this->m_NumberOfGradientDirections = numImages - this->m_NumberOfBaselineImages;
// ensure that the gradient image we received has as many components as
// the number of gradient directions
if( gradientImage->GetVectorLength() != this->m_NumberOfBaselineImages + m_NumberOfGradientDirections )
{
itkExceptionMacro( << m_NumberOfGradientDirections << " gradients + " << this->m_NumberOfBaselineImages
<< "baselines = " << m_NumberOfGradientDirections + this->m_NumberOfBaselineImages
<< " directions specified but image has " << gradientImage->GetVectorLength()
<< " components.");
}
this->ProcessObject::SetNthInput( 0, const_cast< GradientImagesType* >(gradientImage) );
}
template< class T, class TG, class TO, int L, int NODF>
void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
::PrintSelf(std::ostream& os, Indent indent) const
{
std::locale C("C");
std::locale originalLocale = os.getloc();
os.imbue(C);
Superclass::PrintSelf(os,indent);
os << indent << "OdfReconstructionMatrix: " << m_ReconstructionMatrix << std::endl;
if ( m_GradientDirectionContainer )
os << indent << "GradientDirectionContainer: " << m_GradientDirectionContainer << std::endl;
else
os << indent << "GradientDirectionContainer: (Gradient directions not set)" << std::endl;
os << indent << "NumberOfGradientDirections: " << m_NumberOfGradientDirections << std::endl;
os << indent << "NumberOfBaselineImages: " << m_NumberOfBaselineImages << std::endl;
os << indent << "Threshold for reference B0 image: " << m_Threshold << std::endl;
os << indent << "BValue: " << m_BValue << std::endl;
os.imbue( originalLocale );
}
}
#endif // __itkAnalyticalDiffusionQballReconstructionImageFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
index 2a837f283a..a1a0aa2e2d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
@@ -1,282 +1,282 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkAnalyticalDiffusionQballReconstructionImageFilter_h_
#define __itkAnalyticalDiffusionQballReconstructionImageFilter_h_
#include "itkImageToImageFilter.h"
#include "vnl/vnl_vector_fixed.h"
#include "vnl/vnl_matrix.h"
#include "vnl/algo/vnl_svd.h"
#include "itkVectorContainer.h"
#include "itkVectorImage.h"
namespace itk{
/** \class AnalyticalDiffusionQballReconstructionImageFilter
* \brief This class takes as input one or more reference image (acquired in the
* absence of diffusion sensitizing gradients) and 'n' diffusion
* weighted images and their gradient directions and computes an image of
* orientation distribution function coefficients in a spherical harmonic basis.
*
* \par Inputs and Usage
* \par
* When you have the 'n' gradient and one or more reference images in a single
* multi-component image (VectorImage), you can specify the images as
* \code
* filter->SetGradientImage( directionsContainer, vectorImage );
* \endcode
* Note that this method is used to specify both the reference and gradient images.
* This is convenient when the DWI images are read in using the
* <a href="http://wiki.na-mic.org/Wiki/index.php/NAMIC_Wiki:DTI:Nrrd_format">NRRD</a>
* format. Like the Nrrd format, the reference images are those components of the
* vectorImage whose gradient direction is (0,0,0). If more than one reference image
* is present, they are averaged prior to the reconstruction.
*
* \par Outputs
* The output image is an image of vectors that must be understood as ODFs:
* \code
* Image< Vector< TPixelType, OdfNrDirections >, 3 >
* \endcode
*
* \par Parameters
* \li Threshold - Threshold on the reference image data. The output ODF will
* be a null pdf for pixels in the reference image that have a value less
* than this.
* \li BValue - See the documentation of SetBValue().
* \li At least 6 gradient images must be specified for the filter to be able
* to run. If the input gradient directions g_i are majorly sampled on one half
* of the sqhere, then each input image I_i will be duplicated and assign -g_i
* in order to guarantee stability of the algorithm.
* \li OdfDirections - directions of resulting orientation distribution function
* \li EquatorNrSamplingPoints - number of sampling points on equator when
* performing Funk Radeon Transform (FRT)
* \li BasisFunctionCenters - the centers of the basis functions are used for
* the sRBF (spherical radial basis functions interpolation). If not set, they
* will be defaulted to equal m_EquatorNrSamplingPoints
*
* \par Template parameters
* The class is templated over
* \li the pixel type of the reference and gradient images
* (expected to be scalar data types)
* \li the internal representation of the ODF pixels (double, float etc).
* \li the number of OdfDirections
* \li the number of basis function centers for the sRBF
*
* \par References:
* \li<a href="http://www3.interscience.wiley.com/cgi-bin/fulltext/109800293/PDFSTART">[1]</a>
* <em>Tuch DS,
* "Q-ball imaging", Magn Reson Med. 2004 Dec;52(6):1358-72.</em>
*
*/
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NOrderL,
int NrOdfDirections>
class AnalyticalDiffusionQballReconstructionImageFilter :
public ImageToImageFilter< Image< TReferenceImagePixelType, 3 >,
Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > >
{
public:
enum Normalization {
QBAR_STANDARD,
QBAR_B_ZERO_B_VALUE,
QBAR_B_ZERO,
QBAR_NONE,
QBAR_ADC_ONLY,
QBAR_RAW_SIGNAL,
QBAR_SOLID_ANGLE,
QBAR_NONNEG_SOLID_ANGLE
};
typedef AnalyticalDiffusionQballReconstructionImageFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< TReferenceImagePixelType, 3>,
Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > > Superclass;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(AnalyticalDiffusionQballReconstructionImageFilter, ImageToImageFilter)
typedef TReferenceImagePixelType ReferencePixelType;
typedef TGradientImagePixelType GradientPixelType;
typedef Vector< TOdfPixelType, NrOdfDirections > OdfPixelType;
typedef TOdfPixelType BZeroPixelType;
/** Reference image data, This image is aquired in the absence
* of a diffusion sensitizing field gradient */
typedef typename Superclass::InputImageType ReferenceImageType;
typedef Image< OdfPixelType, 3 > OdfImageType;
typedef OdfImageType OutputImageType;
typedef Image< Vector< TOdfPixelType, (NOrderL*NOrderL + NOrderL + 2)/2 + NOrderL >, 3 > CoefficientImageType;
typedef Image< BZeroPixelType, 3 > BZeroImageType;
typedef typename Superclass::OutputImageRegionType
OutputImageRegionType;
/** Typedef defining one (of the many) gradient images. */
typedef Image< GradientPixelType, 3 > GradientImageType;
/** An alternative typedef defining one (of the many) gradient images.
* It will be assumed that the vectorImage has the same dimension as the
* Reference image and a vector length parameter of \c n (number of
* gradient directions)*/
typedef VectorImage< GradientPixelType, 3 > GradientImagesType;
/** Holds the ODF reconstruction matrix */
typedef vnl_matrix< TOdfPixelType >*
OdfReconstructionMatrixType;
typedef vnl_matrix< double > CoefficientMatrixType;
/** Holds each magnetic field gradient used to acquire one DWImage */
typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
/** Container to hold gradient directions of the 'n' DW measurements */
typedef VectorContainer< unsigned int,
GradientDirectionType > GradientDirectionContainerType;
/** set method to add gradient directions and its corresponding
* image. The image here is a VectorImage. The user is expected to pass the
* gradient directions in a container. The ith element of the container
* corresponds to the gradient direction of the ith component image the
* VectorImage. For the baseline image, a vector of all zeros
* should be set.*/
void SetGradientImage( GradientDirectionContainerType *,
const GradientImagesType *image);
/** Get reference image */
virtual ReferenceImageType * GetReferenceImage()
{ return ( static_cast< ReferenceImageType *>(this->ProcessObject::GetInput(0)) ); }
/** Return the gradient direction. idx is 0 based */
virtual GradientDirectionType GetGradientDirection( unsigned int idx) const
{
if( idx >= m_NumberOfGradientDirections )
itkExceptionMacro( << "Gradient direction " << idx << "does not exist" );
return m_GradientDirectionContainer->ElementAt( idx+1 );
}
static void tofile2(vnl_matrix<double> *A, std::string fname);
static void Cart2Sph(double x, double y, double z, double* cart);
static double Yj(int m, int k, double theta, double phi);
double Legendre0(int l);
OdfPixelType Normalize(OdfPixelType odf, typename NumericTraits<ReferencePixelType>::AccumulateType b0 );
vnl_vector<TOdfPixelType> PreNormalize( vnl_vector<TOdfPixelType> vec, typename NumericTraits<ReferencePixelType>::AccumulateType b0 );
/** Threshold on the reference image data. The output ODF will be a null
* pdf for pixels in the reference image that have a value less than this
* threshold. */
itkSetMacro( Threshold, ReferencePixelType )
itkGetMacro( Threshold, ReferencePixelType )
itkSetMacro( NormalizationMethod, Normalization)
itkGetMacro( NormalizationMethod, Normalization )
typedef Image<float, 3> FloatImageType;
itkGetMacro( BZeroImage, typename BZeroImageType::Pointer)
itkGetMacro( ODFSumImage, typename FloatImageType::Pointer)
itkGetMacro( CoefficientImage, typename CoefficientImageType::Pointer)
itkSetMacro( BValue, TOdfPixelType)
#ifdef GetBValue
#undef GetBValue
#endif
itkGetConstReferenceMacro( BValue, TOdfPixelType)
itkSetMacro( Lambda, double )
itkGetMacro( Lambda, double )
#ifdef ITK_USE_CONCEPT_CHECKING
/** Begin concept checking */
itkConceptMacro(ReferenceEqualityComparableCheck,
(Concept::EqualityComparable<ReferencePixelType>));
itkConceptMacro(TensorEqualityComparableCheck,
(Concept::EqualityComparable<OdfPixelType>));
itkConceptMacro(GradientConvertibleToDoubleCheck,
(Concept::Convertible<GradientPixelType, double>));
itkConceptMacro(DoubleConvertibleToTensorCheck,
(Concept::Convertible<double, OdfPixelType>));
itkConceptMacro(GradientReferenceAdditiveOperatorsCheck,
(Concept::AdditiveOperators<GradientPixelType, GradientPixelType,
ReferencePixelType>));
itkConceptMacro(ReferenceOStreamWritableCheck,
(Concept::OStreamWritable<ReferencePixelType>));
itkConceptMacro(TensorOStreamWritableCheck,
(Concept::OStreamWritable<OdfPixelType>));
/** End concept checking */
#endif
protected:
AnalyticalDiffusionQballReconstructionImageFilter();
~AnalyticalDiffusionQballReconstructionImageFilter() {};
void PrintSelf(std::ostream& os, Indent indent) const;
void ComputeReconstructionMatrix();
void BeforeThreadedGenerateData();
void ThreadedGenerateData( const
- OutputImageRegionType &outputRegionForThread, int);
+ OutputImageRegionType &outputRegionForThread, ThreadIdType);
private:
OdfReconstructionMatrixType m_ReconstructionMatrix;
OdfReconstructionMatrixType m_CoeffReconstructionMatrix;
OdfReconstructionMatrixType m_SphericalHarmonicBasisMatrix;
/** container to hold gradient directions */
GradientDirectionContainerType::Pointer m_GradientDirectionContainer;
/** Number of gradient measurements */
unsigned int m_NumberOfGradientDirections;
/** Number of baseline images */
unsigned int m_NumberOfBaselineImages;
/** Threshold on the reference image data */
ReferencePixelType m_Threshold;
/** LeBihan's b-value for normalizing tensors */
TOdfPixelType m_BValue;
typename BZeroImageType::Pointer m_BZeroImage;
double m_Lambda;
bool m_DirectionsDuplicated;
Normalization m_NormalizationMethod;
int m_NumberCoefficients;
vnl_matrix<double>* m_B_t;
vnl_vector<double>* m_LP;
FloatImageType::Pointer m_ODFSumImage;
typename CoefficientImageType::Pointer m_CoefficientImage;
TOdfPixelType m_Delta1;
TOdfPixelType m_Delta2;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkAnalyticalDiffusionQballReconstructionImageFilter.cpp"
#endif
#endif //__itkAnalyticalDiffusionQballReconstructionImageFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.cpp
index 0142bf9960..845c27ddfc 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.cpp
@@ -1,781 +1,781 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter_cpp
#define __itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter_cpp
#include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkImageRegionIterator.h"
#include "vnl/vnl_matrix.h"
#include "vnl/algo/vnl_symmetric_eigensystem.h"
#include "itkRegularizedIVIMReconstructionFilter.h"
#include <mitkLogMacros.h>
#define IVIM_FOO -100000
namespace itk {
template< class TIn, class TOut>
DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<TIn, TOut>
::DiffusionIntravoxelIncoherentMotionReconstructionImageFilter() :
m_GradientDirectionContainer(NULL),
m_Method(IVIM_DSTAR_FIX),
m_FitDStar(true),
m_Verbose(false)
{
this->SetNumberOfRequiredInputs( 1 );
this->SetNumberOfRequiredOutputs( 3 );
typename OutputImageType::Pointer outputPtr1 = OutputImageType::New();
this->SetNthOutput(0, outputPtr1.GetPointer());
typename OutputImageType::Pointer outputPtr2 = OutputImageType::New();
this->SetNthOutput(1, outputPtr2.GetPointer());
typename OutputImageType::Pointer outputPtr3 = OutputImageType::New();
this->SetNthOutput(2, outputPtr3.GetPointer());
}
template< class TIn, class TOut>
void DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<TIn, TOut>
::BeforeThreadedGenerateData()
{
// Input must be an itk::VectorImage.
std::string gradientImageClassName(
this->ProcessObject::GetInput(0)->GetNameOfClass());
if ( strcmp(gradientImageClassName.c_str(),"VectorImage") != 0 )
{
itkExceptionMacro( <<
"There is only one Gradient image. I expect that to be a VectorImage. "
<< "But its of type: " << gradientImageClassName );
}
// Compute the indicies of the baseline images and gradient images
// If no b=0 mm/s² gradients ar found, the next lowest b-value is used.
GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
double minNorm = itk::NumericTraits<double>::max();
while( gdcit != this->m_GradientDirectionContainer->End() )
{
double norm = gdcit.Value().one_norm();
if (norm<minNorm)
minNorm = norm;
++gdcit;
}
minNorm += 0.001;
gdcit = this->m_GradientDirectionContainer->Begin();
while( gdcit != this->m_GradientDirectionContainer->End() )
{
if(gdcit.Value().one_norm() <= minNorm)
{
m_Snap.baselineind.push_back(gdcit.Index());
}
else
{
m_Snap.gradientind.push_back(gdcit.Index());
double twonorm = gdcit.Value().two_norm();
m_Snap.bvals.push_back( m_BValue*twonorm*twonorm );
}
++gdcit;
}
if (m_Snap.gradientind.size()==0)
itkExceptionMacro("Only one b-value supplied. At least two needed for IVIM fit.");
// check sind die grad und base gleichlang? alle grad gerade und base ungerade? dann iterierende aufnahme!!
m_Snap.iterated_sequence = false;
if(m_Snap.baselineind.size() == m_Snap.gradientind.size())
{
int size = m_Snap.baselineind.size();
int sum_b = 0, sum_g = 0;
for(int i=0; i<size; i++)
{
sum_b += m_Snap.baselineind.at(i) % 2;
sum_g += m_Snap.gradientind.at(i) % 2;
}
if( (sum_b == size || sum_b == 0)
&& (sum_g == size || sum_g == 0) )
{
m_Snap.iterated_sequence = true;
if(m_Verbose)
{
MITK_INFO << "Iterating b0 and diffusion weighted aquisition detected. Weighting each weighted measurement with its own b0.";
}
}
}
// number of measurements
m_Snap.N = m_Snap.gradientind.size();
// bvalue array
m_Snap.bvalues.set_size(m_Snap.N);
for(int i=0; i<m_Snap.N; i++)
{
m_Snap.bvalues[i] = m_Snap.bvals.at(i);
}
if(m_Verbose)
{
std::cout << "ref bval: " << m_BValue << "; b-values: ";
for(int i=0; i<m_Snap.N; i++)
{
std::cout << m_Snap.bvalues[i] << "; ";
}
std::cout << std::endl;
}
// extract bvals higher than threshold
if(m_Method == IVIM_D_THEN_DSTAR || m_Method == IVIM_LINEAR_D_THEN_F || m_Method == IVIM_REGULARIZED)
{
for(int i=0; i<m_Snap.N; i++)
{
if(m_Snap.bvalues[i]>m_BThres)
{
m_Snap.high_indices.push_back(i);
}
}
}
m_Snap.Nhigh = m_Snap.high_indices.size();
m_Snap.high_bvalues.set_size(m_Snap.Nhigh);
m_Snap.high_meas.set_size(m_Snap.Nhigh);
for(int i=0; i<m_Snap.Nhigh; i++)
{
m_Snap.high_bvalues[i] = m_Snap.bvalues[m_Snap.high_indices.at(i)];
}
}
template< class TIn, class TOut>
MeasAndBvals DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<TIn, TOut>
::ApplyS0Threshold(vnl_vector<double> &meas, vnl_vector<double> &bvals)
{
std::vector<double> newmeas;
std::vector<double> newbvals;
int N = meas.size();
for(int i=0; i<N; i++)
{
if( meas[i] != IVIM_FOO )
{
newmeas.push_back(meas[i]);
newbvals.push_back(bvals[i]);
}
}
MeasAndBvals retval;
retval.N = newmeas.size();
retval.meas.set_size(retval.N);
- for(int i=0; i<newmeas.size(); i++)
+ for(size_t i=0; i<newmeas.size(); i++)
{
retval.meas[i] = newmeas[i];
}
retval.bvals.set_size(retval.N);
- for(int i=0; i<newbvals.size(); i++)
+ for(size_t i=0; i<newbvals.size(); i++)
{
retval.bvals[i] = newbvals[i];
}
return retval;
}
template< class TIn, class TOut>
void DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<TIn, TOut>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int )
+ ThreadIdType )
{
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
oit.GoToBegin();
typename OutputImageType::Pointer dImage =
static_cast< OutputImageType * >(this->ProcessObject::GetOutput(1));
ImageRegionIterator< OutputImageType > oit1(dImage, outputRegionForThread);
oit1.GoToBegin();
typename OutputImageType::Pointer dstarImage =
static_cast< OutputImageType * >(this->ProcessObject::GetOutput(2));
ImageRegionIterator< OutputImageType > oit2(dstarImage, outputRegionForThread);
oit2.GoToBegin();
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
typedef typename InputImageType::PixelType InputVectorType;
typename InputImageType::Pointer inputImagePointer = NULL;
// Would have liked a dynamic_cast here, but seems SGI doesn't like it
// The enum will DiffusionIntravoxelIncoherentMotionReconstructionImageFilterensure that an inappropriate cast is not done
inputImagePointer = static_cast< InputImageType * >(
this->ProcessObject::GetInput(0) );
InputIteratorType iit(inputImagePointer, outputRegionForThread );
iit.GoToBegin();
// init internal vector image for regularized fit
m_InternalVectorImage = VectorImageType::New();
m_InternalVectorImage->SetSpacing( inputImagePointer->GetSpacing() ); // Set the image spacing
m_InternalVectorImage->SetOrigin( inputImagePointer->GetOrigin() ); // Set the image origin
m_InternalVectorImage->SetDirection( inputImagePointer->GetDirection() ); // Set the image direction
m_InternalVectorImage->SetRegions( inputImagePointer->GetLargestPossibleRegion() );
m_InitialFitImage = InitialFitImageType::New();
m_InitialFitImage->SetSpacing( inputImagePointer->GetSpacing() ); // Set the image spacing
m_InitialFitImage->SetOrigin( inputImagePointer->GetOrigin() ); // Set the image origin
m_InitialFitImage->SetDirection( inputImagePointer->GetDirection() ); // Set the image direction
m_InitialFitImage->SetRegions( inputImagePointer->GetLargestPossibleRegion() );
if(m_Method == IVIM_REGULARIZED)
{
m_InternalVectorImage->SetVectorLength(m_Snap.Nhigh);
m_InternalVectorImage->Allocate();
VectorImageType::PixelType varvec(m_Snap.Nhigh);
for(int i=0; i<m_Snap.Nhigh; i++) varvec[i] = IVIM_FOO;
m_InternalVectorImage->FillBuffer(varvec);
m_InitialFitImage->Allocate();
InitialFitImageType::PixelType vec;
vec[0] = 0.5; vec[1] = 0.01; vec[2]=0.001;
m_InitialFitImage->FillBuffer(vec);
}
typedef itk::ImageRegionIterator<VectorImageType> VectorIteratorType;
VectorIteratorType vecit(m_InternalVectorImage, outputRegionForThread );
vecit.GoToBegin();
typedef itk::ImageRegionIterator<InitialFitImageType> InitIteratorType;
InitIteratorType initit(m_InitialFitImage, outputRegionForThread );
initit.GoToBegin();
while( !iit.IsAtEnd() )
{
InputVectorType measvec = iit.Get();
typename NumericTraits<InputPixelType>::AccumulateType b0 = NumericTraits<InputPixelType>::Zero;
m_Snap.meas.set_size(m_Snap.N);
m_Snap.allmeas.set_size(m_Snap.N);
if(!m_Snap.iterated_sequence)
{
// Average the baseline image pixels
for(unsigned int i = 0; i < m_Snap.baselineind.size(); ++i)
{
b0 += measvec[m_Snap.baselineind[i]];
}
if(m_Snap.baselineind.size())
b0 /= m_Snap.baselineind.size();
// measurement vector
for(int i = 0; i < m_Snap.N; ++i)
{
m_Snap.allmeas[i] = measvec[m_Snap.gradientind[i]] / (b0+.0001);
if(measvec[m_Snap.gradientind[i]] > m_S0Thres)
{
m_Snap.meas[i] = measvec[m_Snap.gradientind[i]] / (b0+.0001);
}
else
{
m_Snap.meas[i] = IVIM_FOO;
}
}
}
else
{
// measurement vector
for(int i = 0; i < m_Snap.N; ++i)
{
b0 = measvec[m_Snap.baselineind[i]];
m_Snap.allmeas[i] = measvec[m_Snap.gradientind[i]] / (b0+.0001);
if(measvec[m_Snap.gradientind[i]] > m_S0Thres)
{
m_Snap.meas[i] = measvec[m_Snap.gradientind[i]] / (b0+.0001);
}
else
{
m_Snap.meas[i] = IVIM_FOO;
}
}
}
m_Snap.currentF = 0;
m_Snap.currentD = 0;
m_Snap.currentDStar = 0;
switch(m_Method)
{
case IVIM_D_THEN_DSTAR:
{
for(int i=0; i<m_Snap.Nhigh; i++)
{
m_Snap.high_meas[i] = m_Snap.meas[m_Snap.high_indices.at(i)];
}
MeasAndBvals input = ApplyS0Threshold(m_Snap.high_meas, m_Snap.high_bvalues);
m_Snap.bvals1 = input.bvals;
m_Snap.meas1 = input.meas;
if (input.N < 2)
{
if (input.N == 1)
{
m_Snap.currentD = - log(input.meas[0]) / input.bvals[0];
m_Snap.currentF = 0;
m_Snap.currentDStar = 0;
}
break;
}
IVIM_d_and_f f_donly(input.N);
f_donly.set_bvalues(input.bvals);
f_donly.set_measurements(input.meas);
vnl_vector< double > x_donly(2);
x_donly[0] = 0.001;
x_donly[1] = 0.1;
// f 0.1 Dstar 0.01 D 0.001
vnl_levenberg_marquardt lm_donly(f_donly);
lm_donly.set_f_tolerance(0.0001);
lm_donly.minimize(x_donly);
m_Snap.currentD = x_donly[0];
m_Snap.currentF = x_donly[1];
if(m_FitDStar)
{
MeasAndBvals input2 = ApplyS0Threshold(m_Snap.meas, m_Snap.bvalues);
m_Snap.bvals2 = input2.bvals;
m_Snap.meas2 = input2.meas;
if (input2.N < 2) break;
IVIM_dstar_only f_dstar_only(input2.N,m_Snap.currentD,m_Snap.currentF);
f_dstar_only.set_bvalues(input2.bvals);
f_dstar_only.set_measurements(input2.meas);
vnl_vector< double > x_dstar_only(1);
vnl_vector< double > fx_dstar_only(input2.N);
double opt = 1111111111111111.0;
int opt_idx = -1;
int num_its = 100;
double min_val = .001;
double max_val = .15;
for(int i=0; i<num_its; i++)
{
x_dstar_only[0] = min_val + i * ((max_val-min_val) / num_its);
f_dstar_only.f(x_dstar_only, fx_dstar_only);
double err = fx_dstar_only.two_norm();
if(err<opt)
{
opt = err;
opt_idx = i;
}
}
m_Snap.currentDStar = min_val + opt_idx * ((max_val-min_val) / num_its);
// IVIM_fixd f_fixd(input2.N,m_Snap.currentD);
// f_fixd.set_bvalues(input2.bvals);
// f_fixd.set_measurements(input2.meas);
// vnl_vector< double > x_fixd(2);
// x_fixd[0] = 0.1;
// x_fixd[1] = 0.01;
// // f 0.1 Dstar 0.01 D 0.001
// vnl_levenberg_marquardt lm_fixd(f_fixd);
// lm_fixd.set_f_tolerance(0.0001);
// lm_fixd.minimize(x_fixd);
// m_Snap.currentF = x_fixd[0];
// m_Snap.currentDStar = x_fixd[1];
}
break;
}
case IVIM_DSTAR_FIX:
{
MeasAndBvals input = ApplyS0Threshold(m_Snap.meas, m_Snap.bvalues);
m_Snap.bvals1 = input.bvals;
m_Snap.meas1 = input.meas;
if (input.N < 2) break;
IVIM_fixdstar f_fixdstar(input.N,m_DStar);
f_fixdstar.set_bvalues(input.bvals);
f_fixdstar.set_measurements(input.meas);
vnl_vector< double > x(2);
x[0] = 0.1;
x[1] = 0.001;
// f 0.1 Dstar 0.01 D 0.001
vnl_levenberg_marquardt lm(f_fixdstar);
lm.set_f_tolerance(0.0001);
lm.minimize(x);
m_Snap.currentF = x[0];
m_Snap.currentD = x[1];
m_Snap.currentDStar = m_DStar;
break;
}
case IVIM_FIT_ALL:
{
MeasAndBvals input = ApplyS0Threshold(m_Snap.meas, m_Snap.bvalues);
m_Snap.bvals1 = input.bvals;
m_Snap.meas1 = input.meas;
if (input.N < 3) break;
IVIM_3param f_3param(input.N);
f_3param.set_bvalues(input.bvals);
f_3param.set_measurements(input.meas);
vnl_vector< double > x(3);
x[0] = 0.1;
x[1] = 0.001;
x[2] = 0.01;
// f 0.1 Dstar 0.01 D 0.001
vnl_levenberg_marquardt lm(f_3param);
lm.set_f_tolerance(0.0001);
lm.minimize(x);
m_Snap.currentF = x[0];
m_Snap.currentD = x[1];
m_Snap.currentDStar = x[2];
break;
}
case IVIM_LINEAR_D_THEN_F:
{
// // neglect zero-measurements
// bool zero = false;
// for(int i=0; i<Nhigh; i++)
// {
// if( meas[high_indices.at(i)] == 0 )
// {
// f=0;
// zero = true;
// break;
// }
// }
// if(zero) break;
for(int i=0; i<m_Snap.Nhigh; i++)
{
m_Snap.high_meas[i] = m_Snap.meas[m_Snap.high_indices.at(i)];
}
MeasAndBvals input = ApplyS0Threshold(m_Snap.high_meas, m_Snap.high_bvalues);
m_Snap.bvals1 = input.bvals;
m_Snap.meas1 = input.meas;
if (input.N < 2)
{
if (input.N == 1)
{
m_Snap.currentD = - log(input.meas[0]) / input.bvals[0];
m_Snap.currentF = 0;
m_Snap.currentDStar = 0;
}
break;
}
for(int i=0; i<input.N; i++)
{
input.meas[i] = log(input.meas[i]);
}
double bval_m = 0;
double meas_m = 0;
for(int i=0; i<input.N; i++)
{
bval_m += input.bvals[i];
meas_m += input.meas[i];
}
bval_m /= input.N;
meas_m /= input.N;
vnl_matrix<double> X(input.N,2);
for(int i=0; i<input.N; i++)
{
X(i,0) = input.bvals[i] - bval_m;
X(i,1) = input.meas[i] - meas_m;
}
vnl_matrix<double> XX = X.transpose() * X;
vnl_symmetric_eigensystem<double> eigs(XX);
vnl_vector<double> eig;
if(eigs.get_eigenvalue(0) > eigs.get_eigenvalue(1))
eig = eigs.get_eigenvector(0);
else
eig = eigs.get_eigenvector(1);
m_Snap.currentF = 1 - exp( meas_m - bval_m*(eig(1)/eig(0)) );
m_Snap.currentD = -eig(1)/eig(0);
if(m_FitDStar)
{
MeasAndBvals input2 = ApplyS0Threshold(m_Snap.meas, m_Snap.bvalues);
m_Snap.bvals2 = input2.bvals;
m_Snap.meas2 = input2.meas;
if (input2.N < 2) break;
IVIM_dstar_only f_dstar_only(input2.N,m_Snap.currentD,m_Snap.currentF);
f_dstar_only.set_bvalues(input2.bvals);
f_dstar_only.set_measurements(input2.meas);
vnl_vector< double > x_dstar_only(1);
vnl_vector< double > fx_dstar_only(input2.N);
double opt = 1111111111111111.0;
int opt_idx = -1;
int num_its = 100;
double min_val = .001;
double max_val = .15;
for(int i=0; i<num_its; i++)
{
x_dstar_only[0] = min_val + i * ((max_val-min_val) / num_its);
f_dstar_only.f(x_dstar_only, fx_dstar_only);
double err = fx_dstar_only.two_norm();
if(err<opt)
{
opt = err;
opt_idx = i;
}
}
m_Snap.currentDStar = min_val + opt_idx * ((max_val-min_val) / num_its);
}
// MITK_INFO << "choosing " << opt_idx << " => " << DStar;
// x_dstar_only[0] = 0.01;
// // f 0.1 Dstar 0.01 D 0.001
// vnl_levenberg_marquardt lm_dstar_only(f_dstar_only);
// lm_dstar_only.set_f_tolerance(0.0001);
// lm_dstar_only.minimize(x_dstar_only);
// DStar = x_dstar_only[0];
break;
}
case IVIM_REGULARIZED:
{
//m_Snap.high_meas, m_Snap.high_bvalues;
for(int i=0; i<m_Snap.Nhigh; i++)
{
m_Snap.high_meas[i] = m_Snap.meas[m_Snap.high_indices.at(i)];
}
MeasAndBvals input = ApplyS0Threshold(m_Snap.high_meas, m_Snap.high_bvalues);
vnl_vector< double > x_donly(2);
x_donly[0] = 0.001;
x_donly[1] = 0.1;
if(input.N >= 2)
{
IVIM_d_and_f f_donly(input.N);
f_donly.set_bvalues(input.bvals);
f_donly.set_measurements(input.meas);
//MITK_INFO << "initial fit N=" << input.N << ", min-b = " << input.bvals[0] << ", max-b = " << input.bvals[input.N-1];
vnl_levenberg_marquardt lm_donly(f_donly);
lm_donly.set_f_tolerance(0.0001);
lm_donly.minimize(x_donly);
}
typename InitialFitImageType::PixelType initvec;
initvec[0] = x_donly[1];
initvec[1] = x_donly[0];
initit.Set(initvec);
//MITK_INFO << "Init vox " << initit.GetIndex() << " with " << initvec[0] << "; " << initvec[1];
++initit;
int N = m_Snap.high_meas.size();
typename VectorImageType::PixelType vec(N);
for(int i=0; i<N; i++)
{
vec[i] = m_Snap.high_meas[i];
//MITK_INFO << "vec" << i << " = " << m_Snap.high_meas[i];
}
vecit.Set(vec);
++vecit;
if(!m_Verbose)
{
// report the middle voxel
if( vecit.GetIndex()[0] == m_CrossPosition[0]
&& vecit.GetIndex()[0] == m_CrossPosition[1]
&& vecit.GetIndex()[0] == m_CrossPosition[2] )
{
MeasAndBvals input = ApplyS0Threshold(m_Snap.high_meas, m_Snap.high_bvalues);
m_Snap.bvals1 = input.bvals;
m_Snap.meas1 = input.meas;
MeasAndBvals input2 = ApplyS0Threshold(m_Snap.meas, m_Snap.bvalues);
m_Snap.bvals2 = input2.bvals;
m_Snap.meas2 = input2.meas;
m_tmp_allmeas = m_Snap.allmeas;
}
}
break;
}
}
m_Snap.currentFunceiled = m_Snap.currentF;
IVIM_CEIL( m_Snap.currentF, 0.0, 1.0 );
oit.Set( m_Snap.currentF );
oit1.Set( m_Snap.currentD );
oit2.Set( m_Snap.currentDStar );
// std::cout << "\tf=" << x[0] << "\tD=" << x[1] << " ; "<<std::endl;
++oit;
++oit1;
++oit2;
++iit;
}
if(m_Verbose)
{
std::cout << "One Thread finished reconstruction" << std::endl;
}
}
template< class TIn, class TOut>
void DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<TIn, TOut>
::AfterThreadedGenerateData()
{
if(m_Method == IVIM_REGULARIZED)
{
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
ImageRegionIterator< OutputImageType > oit0(outputImage, outputImage->GetLargestPossibleRegion());
oit0.GoToBegin();
typename OutputImageType::Pointer dImage =
static_cast< OutputImageType * >(this->ProcessObject::GetOutput(1));
ImageRegionIterator< OutputImageType > oit1(dImage, dImage->GetLargestPossibleRegion());
oit1.GoToBegin();
typename OutputImageType::Pointer dstarImage =
static_cast< OutputImageType * >(this->ProcessObject::GetOutput(2));
ImageRegionIterator< OutputImageType > oit2(dstarImage, dstarImage->GetLargestPossibleRegion());
oit2.GoToBegin();
typedef itk::RegularizedIVIMReconstructionFilter
<double,double,float> RegFitType;
RegFitType::Pointer filter = RegFitType::New();
filter->SetInput(m_InitialFitImage);
filter->SetReferenceImage(m_InternalVectorImage);
filter->SetBValues(m_Snap.high_bvalues);
filter->SetNumberIterations(m_NumberIterations);
filter->SetNumberOfThreads(1);
filter->SetLambda(m_Lambda);
filter->Update();
typename RegFitType::OutputImageType::Pointer outimg = filter->GetOutput();
ImageRegionConstIterator< RegFitType::OutputImageType > iit(outimg, outimg->GetLargestPossibleRegion());
iit.GoToBegin();
while( !iit.IsAtEnd() )
{
double f = iit.Get()[0];
IVIM_CEIL( f, 0.0, 1.0 );
oit0.Set( myround(f * 100.0) );
oit1.Set( myround(iit.Get()[1] * 10000.0) );
oit2.Set( myround(iit.Get()[2] * 1000.0) );
if(!m_Verbose)
{
// report the middle voxel
if( iit.GetIndex()[0] == m_CrossPosition[0]
&& iit.GetIndex()[1] == m_CrossPosition[1]
&& iit.GetIndex()[2] == m_CrossPosition[2] )
{
m_Snap.currentF = f;
m_Snap.currentD = iit.Get()[1];
m_Snap.currentDStar = iit.Get()[2];
m_Snap.allmeas = m_tmp_allmeas;
MITK_INFO << "setting " << f << ";" << iit.Get()[1] << ";" << iit.Get()[2];
}
}
++oit0;
++oit1;
++oit2;
++iit;
}
}
}
template< class TIn, class TOut>
double DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<TIn, TOut>
::myround(double number)
{
return number < 0.0 ? ceil(number - 0.5) : floor(number + 0.5);
}
template< class TIn, class TOut>
void DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<TIn, TOut>
::SetGradientDirections( GradientDirectionContainerType *gradientDirection )
{
this->m_GradientDirectionContainer = gradientDirection;
this->m_NumberOfGradientDirections = gradientDirection->Size();
}
template< class TIn, class TOut>
void DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<TIn, TOut>
::PrintSelf(std::ostream& os, Indent indent) const
{
Superclass::PrintSelf(os,indent);
if ( m_GradientDirectionContainer )
{
os << indent << "GradientDirectionContainer: "
<< m_GradientDirectionContainer << std::endl;
}
else
{
os << indent <<
"GradientDirectionContainer: (Gradient directions not set)" << std::endl;
}
}
}
#endif // __itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h
index cd6f77e29a..00f8c40cea 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h
@@ -1,380 +1,380 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter_h
#define __itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter_h
#include "itkImageToImageFilter.h"
//#include "vnl/vnl_matrix.h"
#include "vnl/vnl_vector_fixed.h"
#include "vnl/vnl_matrix.h"
#include "vnl/algo/vnl_svd.h"
#include "itkVectorContainer.h"
#include "itkVectorImage.h"
//#include "QuadProg.h"
#include "itkVectorImage.h"
#include "vnl/vnl_least_squares_function.h"
#include "vnl/algo/vnl_levenberg_marquardt.h"
#include "vnl/vnl_math.h"
#define IVIM_CEIL(val,u,o) (val) = \
( (val) < (u) ) ? ( (u) ) : ( ( (val)>(o) ) ? ( (o) ) : ( (val) ) );
namespace itk{
/** baseclass for IVIM fitting algorithms */
struct IVIM_base
{
void set_measurements(const vnl_vector<double>& x)
{
measurements.set_size(x.size());
measurements.copy_in(x.data_block());
}
void set_bvalues(const vnl_vector<double>& x)
{
bvalues.set_size(x.size());
bvalues.copy_in(x.data_block());
}
vnl_vector<double> measurements;
vnl_vector<double> bvalues;
int N;
};
/** Fitt all three parameters */
struct IVIM_3param : public IVIM_base, vnl_least_squares_function
{
IVIM_3param(unsigned int number_of_measurements) :
vnl_least_squares_function(3, number_of_measurements, no_gradient)
{
N = get_number_of_residuals();
}
void f(const vnl_vector<double>& x, vnl_vector<double>& fx) {
double ef = x[0];
double D = x[1];
double Dstar = x[2];
for(int s=0; s<N; s++)
{
double approx = (1-ef)*exp(-bvalues[s]*D)+ef*exp(-bvalues[s]*(D+Dstar));
fx[s] = vnl_math_abs( measurements[s] - approx );
}
}
};
/** fit by setting DStar to a fix value */
struct IVIM_fixdstar : public IVIM_base, vnl_least_squares_function
{
IVIM_fixdstar(unsigned int number_of_measurements, double DStar) :
vnl_least_squares_function(2, number_of_measurements, no_gradient)
{
N = get_number_of_residuals();
fixDStar = DStar;
}
void f(const vnl_vector<double>& x, vnl_vector<double>& fx) {
double ef = x[0];
double D = x[1];
for(int s=0; s<N; s++)
{
double approx = (1-ef)*exp(-bvalues[s]*D)+ef*exp(-bvalues[s]*(D+fixDStar));
fx[s] = vnl_math_abs( measurements[s] - approx );
}
}
double fixDStar;
};
/** fit a monoexponential curve only estimating D */
struct IVIM_d_and_f : public IVIM_base, vnl_least_squares_function
{
IVIM_d_and_f(unsigned int number_of_measurements) :
vnl_least_squares_function(2, number_of_measurements, no_gradient)
{
N = get_number_of_residuals();
}
void f(const vnl_vector<double>& x, vnl_vector<double>& fx) {
double D = x[0];
double f = x[1];
for(int s=0; s<N; s++)
{
double approx = (1-f) * exp(-bvalues[s]*D);
fx[s] = vnl_math_abs( measurements[s] - approx );
}
}
};
/** fiting DStar and f with fix value of D */
struct IVIM_fixd : public IVIM_base, vnl_least_squares_function
{
IVIM_fixd(unsigned int number_of_measurements, double D) :
vnl_least_squares_function(2, number_of_measurements, no_gradient)
{
N = get_number_of_residuals();
fixD = D;
}
void f(const vnl_vector<double>& x, vnl_vector<double>& fx) {
double ef = x[0];
double Dstar = x[1];
for(int s=0; s<N; s++)
{
double approx = (1-ef)*exp(-bvalues[s]*fixD)+ef*exp(-bvalues[s]*(fixD+Dstar));
fx[s] = vnl_math_abs( measurements[s] - approx );
}
}
double fixD;
};
/** fiting DStar with given f and D */
struct IVIM_dstar_only : public IVIM_base, vnl_least_squares_function
{
IVIM_dstar_only(unsigned int number_of_measurements, double D, double f) :
vnl_least_squares_function(1, number_of_measurements, no_gradient)
{
N = get_number_of_residuals();
fixD = D;
fixF = f;
}
void f(const vnl_vector<double>& x, vnl_vector<double>& fx) {
double Dstar = x[0];
for(int s=0; s<N; s++)
{
double approx = (1-fixF)*exp(-bvalues[s]*fixD)+fixF*exp(-bvalues[s]*(fixD+Dstar));
fx[s] = vnl_math_abs( measurements[s] - approx );
}
}
double fixD;
double fixF;
};
struct MeasAndBvals
{
vnl_vector<double> meas;
vnl_vector<double> bvals;
int N;
};
/** \class DiffusionIntravoxelIncoherentMotionReconstructionImageFilter */
template< class TInputPixelType,
class TOutputPixelType>
class DiffusionIntravoxelIncoherentMotionReconstructionImageFilter :
public ImageToImageFilter< VectorImage< TInputPixelType, 3 >,
Image< TOutputPixelType, 3 > >
{
public:
struct IVIMSnapshot
{
double currentF;
double currentFunceiled;
double currentD;
double currentDStar;
bool iterated_sequence; // wether each measurement has its own b0-acqu.
std::vector<unsigned int> baselineind; // baseline image indicies
int N; // total number of measurements
std::vector<unsigned int> gradientind; // gradient image indicies
std::vector<double> bvals; // b-values != 0
vnl_vector<double> bvalues; // copy of bvalues != 0
vnl_vector<double> meas; // all measurements, thresholded blanked out
vnl_vector<double> allmeas; // all measurements
int Nhigh; // number of used measurements
std::vector<int> high_indices; // indices of used measurements
vnl_vector<double> high_bvalues; // bvals of used measurements
vnl_vector<double> high_meas; // used measurements
vnl_vector<double> meas1;
vnl_vector<double> bvals1;
vnl_vector<double> meas2;
vnl_vector<double> bvals2;
};
enum IVIM_Method
{
IVIM_FIT_ALL,
IVIM_DSTAR_FIX,
IVIM_D_THEN_DSTAR,
IVIM_LINEAR_D_THEN_F,
IVIM_REGULARIZED
};
typedef DiffusionIntravoxelIncoherentMotionReconstructionImageFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< VectorImage< TInputPixelType, 3>,
Image< TOutputPixelType,3 > > Superclass;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Runtime information support. */
itkTypeMacro(DiffusionIntravoxelIncoherentMotionReconstructionImageFilter,
ImageToImageFilter);
typedef TOutputPixelType OutputPixelType;
typedef TInputPixelType InputPixelType;
/** Reference image data, This image is aquired in the absence
* of a diffusion sensitizing field gradient */
typedef typename Superclass::InputImageType InputImageType;
typedef Image< OutputPixelType, 3 > OutputImageType;
typedef typename Superclass::OutputImageRegionType
OutputImageRegionType;
/** Holds each magnetic field gradient used to acquire one DWImage */
typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
/** Container to hold gradient directions of the 'n' DW measurements */
typedef VectorContainer< unsigned int,
GradientDirectionType > GradientDirectionContainerType;
// vector image typedefs for regularized fit
typedef itk::VectorImage<float,3> VectorImageType;
typedef itk::Image<itk::Vector<double, 3>, 3> InitialFitImageType;
/** set method to add gradient directions and its corresponding
* image. The image here is a VectorImage. The user is expected to pass the
* gradient directions in a container. The ith element of the container
* corresponds to the gradient direction of the ith component image the
* VectorImage. For the baseline image, a vector of all zeros
* should be set.*/
void SetGradientDirections( GradientDirectionContainerType * );
void SetBValue(double bval){m_BValue = bval;}
void SetBThres(double bval){m_BThres = bval;}
void SetS0Thres(double val){m_S0Thres = val;}
void SetDStar(double dstar){m_DStar = dstar;}
void SetFitDStar(bool fit){m_FitDStar = fit;}
void SetVerbose(bool verbose){m_Verbose = verbose;}
void SetNumberIterations(int num){m_NumberIterations = num;}
void SetLambda(double lambda){m_Lambda = lambda;}
void SetCrossPosition(typename InputImageType::IndexType crosspos){this->m_CrossPosition = crosspos;}
void SetMethod(IVIM_Method method){m_Method = method;}
IVIMSnapshot GetSnapshot(){return m_Snap;}
/** Return the gradient direction. idx is 0 based */
virtual GradientDirectionType GetGradientDirection( unsigned int idx) const
{
if( idx >= m_NumberOfGradientDirections )
{
itkExceptionMacro( << "Gradient direction " << idx << "does not exist" );
}
return m_GradientDirectionContainer->ElementAt( idx+1 );
}
protected:
DiffusionIntravoxelIncoherentMotionReconstructionImageFilter();
~DiffusionIntravoxelIncoherentMotionReconstructionImageFilter() {};
void PrintSelf(std::ostream& os, Indent indent) const;
void BeforeThreadedGenerateData();
- void ThreadedGenerateData( const
- OutputImageRegionType &outputRegionForThread, int);
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread,
+ ThreadIdType);
void AfterThreadedGenerateData();
MeasAndBvals ApplyS0Threshold(vnl_vector<double> &meas, vnl_vector<double> &bvals);
private:
double myround(double number);
/** container to hold gradient directions */
GradientDirectionContainerType::Pointer m_GradientDirectionContainer;
/** Number of gradient measurements */
unsigned int m_NumberOfGradientDirections;
double m_BValue;
double m_BThres;
double m_S0Thres;
double m_DStar;
IVIM_Method m_Method;
typename OutputImageType::Pointer m_DMap;
typename OutputImageType::Pointer m_DStarMap;
bool m_FitDStar;
IVIMSnapshot m_Snap;
bool m_Verbose;
typename VectorImageType::Pointer m_InternalVectorImage;
typename InitialFitImageType::Pointer m_InitialFitImage;
int m_NumberIterations; // for total variation
vnl_vector<double> m_tmp_allmeas;
double m_Lambda;
typename InputImageType::IndexType m_CrossPosition;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.cpp"
#endif
#endif //__itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter_h
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.cpp
index 5b360286c4..0d26c6bb83 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.cpp
@@ -1,1255 +1,1255 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkDiffusionMultiShellQballReconstructionImageFilter_cpp
#define __itkDiffusionMultiShellQballReconstructionImageFilter_cpp
#include <itkDiffusionMultiShellQballReconstructionImageFilter.h>
#include <itkTimeProbe.h>
#include <itkPointShell.h>
#include <mitkDiffusionFunctionCollection.h>
namespace itk {
template< class T, class TG, class TO, int L, int NODF>
DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::DiffusionMultiShellQballReconstructionImageFilter() :
m_ReconstructionType(Mode_Standard1Shell),
m_Interpolation_Flag(false),
m_Interpolation_SHT1_inv(NULL),
m_Interpolation_SHT2_inv(NULL),
m_Interpolation_SHT3_inv(NULL),
m_TARGET_SH_shell1(NULL),
m_TARGET_SH_shell2(NULL),
m_TARGET_SH_shell3(NULL),
m_MaxDirections(0),
m_CoeffReconstructionMatrix(NULL),
m_ODFSphericalHarmonicBasisMatrix(NULL),
m_GradientDirectionContainer(NULL),
m_NumberOfGradientDirections(0),
m_NumberOfBaselineImages(0),
m_Threshold(0),
m_BZeroImage(NULL),
m_CoefficientImage(NULL),
m_BValue(1.0),
m_Lambda(0.0),
m_IsHemisphericalArrangementOfGradientDirections(false),
m_IsArithmeticProgession(false)
{
// At least 1 inputs is necessary for a vector image.
// For images added one at a time we need at least six
this->SetNumberOfRequiredInputs( 1 );
}
template< class T, class TG, class TO, int L, int NODF>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::SetGradientImage( GradientDirectionContainerType *gradientDirection
, const GradientImagesType *gradientImage
, float bvalue)
{
m_BValue = bvalue;
m_GradientDirectionContainer = gradientDirection;
m_NumberOfBaselineImages = 0;
if(m_BValueMap.size() == 0){
itkWarningMacro(<< "DiffusionMultiShellQballReconstructionImageFilter.cpp : no GradientIndexMapAvalible");
GradientDirectionContainerType::ConstIterator gdcit;
for( gdcit = m_GradientDirectionContainer->Begin(); gdcit != m_GradientDirectionContainer->End(); ++gdcit)
{
double bValueKey = int(((m_BValue * gdcit.Value().two_norm() * gdcit.Value().two_norm())+7.5)/10)*10;
m_BValueMap[bValueKey].push_back(gdcit.Index());
}
}
if(m_BValueMap.find(0) == m_BValueMap.end())
{
itkExceptionMacro(<< "DiffusionMultiShellQballReconstructionImageFilter.cpp : GradientIndxMap with no b-Zero indecies found: check input BValueMap");
}
m_NumberOfBaselineImages = m_BValueMap[0].size();
m_NumberOfGradientDirections = gradientDirection->Size() - m_NumberOfBaselineImages;
// ensure that the gradient image we received has as many components as
// the number of gradient directions
if( gradientImage->GetVectorLength() != m_NumberOfBaselineImages + m_NumberOfGradientDirections )
{
itkExceptionMacro( << m_NumberOfGradientDirections << " gradients + " << m_NumberOfBaselineImages
<< "baselines = " << m_NumberOfGradientDirections + m_NumberOfBaselineImages
<< " directions specified but image has " << gradientImage->GetVectorLength()
<< " components.");
}
ProcessObject::SetNthInput( 0, const_cast< GradientImagesType* >(gradientImage) );
std::string gradientImageClassName(ProcessObject::GetInput(0)->GetNameOfClass());
if ( strcmp(gradientImageClassName.c_str(),"VectorImage") != 0 )
itkExceptionMacro( << "There is only one Gradient image. I expect that to be a VectorImage. But its of type: " << gradientImageClassName );
m_BZeroImage = BZeroImageType::New();
typename GradientImagesType::Pointer img = static_cast< GradientImagesType * >( ProcessObject::GetInput(0) );
m_BZeroImage->SetSpacing( img->GetSpacing() ); // Set the image spacing
m_BZeroImage->SetOrigin( img->GetOrigin() ); // Set the image origin
m_BZeroImage->SetDirection( img->GetDirection() ); // Set the image direction
m_BZeroImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
m_BZeroImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
m_BZeroImage->Allocate();
m_CoefficientImage = CoefficientImageType::New();
m_CoefficientImage->SetSpacing( img->GetSpacing() ); // Set the image spacing
m_CoefficientImage->SetOrigin( img->GetOrigin() ); // Set the image origin
m_CoefficientImage->SetDirection( img->GetDirection() ); // Set the image direction
m_CoefficientImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
m_CoefficientImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
m_CoefficientImage->Allocate();
}
template<class TReferenceImagePixelType, class TGradientImagePixelType, class TOdfPixelType, int NOrderL, int NrOdfDirections>
void DiffusionMultiShellQballReconstructionImageFilter<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,NOrderL, NrOdfDirections>
::Normalize( OdfPixelType & out)
{
for(int i=0; i<NrOdfDirections; i++)
{
out[i] = out[i] < 0 ? 0 : out[i];
out[i] *= M_PI * 4 / NrOdfDirections;
}
}
template<class TReferenceImagePixelType, class TGradientImagePixelType, class TOdfPixelType, int NOrderL, int NrOdfDirections>
void DiffusionMultiShellQballReconstructionImageFilter<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,NOrderL, NrOdfDirections>
::Projection1(vnl_vector<double> & vec, double delta)
{
if (delta==0){ //Clip attenuation values. If att<0 => att=0, if att>1 => att=1
for (unsigned int i=0; i<vec.size(); i++)
vec[i]=(vec[i]>=0 && vec[i]<=1)*vec[i]+(vec[i]>1);
}
else{ //Use function from Aganj et al, MRM, 2010
for (unsigned int i=0; i< vec.size(); i++)
vec[i]=CalculateThreashold(vec[i], delta);
}
}
template<class TReferenceImagePixelType, class TGradientImagePixelType, class TOdfPixelType, int NOrderL, int NrOdfDirections>
double DiffusionMultiShellQballReconstructionImageFilter<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,NOrderL, NrOdfDirections>
::CalculateThreashold(const double value, const double delta)
{
return (value<0)*(0.5*delta) + (value>=0 && value<delta)*(0.5*delta+0.5*(value*value)/delta)
+ (value>=delta && value<1-delta)*value+(value>=1-delta && value<1)*(1-0.5*delta-0.5*((1-value)*(1-value))/delta)
+ (value>=1)*(1-0.5*delta);
}
template<class TReferenceImagePixelType, class TGradientImagePixelType, class TOdfPixelType, int NOrderL, int NrOdfDirections>
void DiffusionMultiShellQballReconstructionImageFilter<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,NOrderL, NrOdfDirections>
::Projection2( vnl_vector<double> & E1,vnl_vector<double> & E2, vnl_vector<double> & E3, double delta )
{
const double sF = sqrt(5.0);
vnl_vector<double> vOnes(m_MaxDirections);
vOnes.fill(1.0);
vnl_matrix<double> T0(m_MaxDirections, 3);
vnl_matrix<unsigned char> C(m_MaxDirections, 7);
vnl_matrix<double> A(m_MaxDirections, 7);
vnl_matrix<double> B(m_MaxDirections, 7);
vnl_vector<double> s0(m_MaxDirections);
vnl_vector<double> a0(m_MaxDirections);
vnl_vector<double> b0(m_MaxDirections);
vnl_vector<double> ta(m_MaxDirections);
vnl_vector<double> tb(m_MaxDirections);
vnl_vector<double> e(m_MaxDirections);
vnl_vector<double> m(m_MaxDirections);
vnl_vector<double> a(m_MaxDirections);
vnl_vector<double> b(m_MaxDirections);
// logarithmierung aller werte in E
for(unsigned int i = 0 ; i < m_MaxDirections; i++)
{
T0(i,0) = -log(E1(i));
T0(i,1) = -log(E2(i));
T0(i,2) = -log(E3(i));
}
//T0 = -T0.apply(std::log);
// Summeiere Zeilenweise über alle Shells sum = E1+E2+E3
for(unsigned int i = 0 ; i < m_MaxDirections; i++)
{
s0[i] = T0(i,0) + T0(i,1) + T0(i,2);
}
for(unsigned int i = 0; i < m_MaxDirections; i ++)
{
// Alle Signal-Werte auf der Ersten shell E(N,0) normiert auf s0
a0[i] = T0(i,0) / s0[i];
// Alle Signal-Werte auf der Zweiten shell E(N,1) normiert auf s0
b0[i] = T0(i,1) / s0[i];
}
ta = a0 * 3.0;
tb = b0 * 3.0;
e = tb - (ta * 2.0);
m = (tb * 2.0 ) + ta;
for(unsigned int i = 0; i <m_MaxDirections; i++)
{
C(i,0) = (tb[i] < 1+3*delta && 0.5+1.5*(sF+1)*delta < ta[i] && ta[i] < 1-3* (sF+2) *delta);
C(i,1) = (e[i] <= -1+3*(2*sF+5)*delta) && (ta[i]>=1-3*(sF+2)*delta);
C(i,2) = (m[i] > 3-3*sF*delta) && (-1+3*(2*sF+5)*delta<e[i]) && (e[i]<-3*sF*delta);
C(i,3) = (m[i] >= 3-3*sF*delta && e[i] >= -3 *sF * delta);
C(i,4) = (2.5 + 1.5*(5+sF)*delta < m[i] && m[i] < 3-3*sF*delta && e[i] > -3*sF*delta);
C(i,5) = (ta[i] <= 0.5+1.5 *(sF+1)*delta && m[i] <= 2.5 + 1.5 *(5+sF) * delta);
C(i,6) = !((bool) C(i,0) ||(bool) C(i,1) ||(bool) C(i,2) ||(bool) C(i,3) ||(bool) C(i,4) ||(bool) C(i,5) ); // ~ANY(C(i,[0-5] ),2)
A(i,0)=(bool)C(i,0) * a0(i);
A(i,1)=(bool)C(i,1) * (1.0/3.0-(sF+2)*delta);
A(i,2)=(bool)C(i,2) * (0.2+0.8*a0(i)-0.4*b0(i)-delta/sF);
A(i,3)=(bool)C(i,3) * (0.2+delta/sF);
A(i,4)=(bool)C(i,4) * (0.2*a0(i)+0.4*b0(i)+2*delta/sF);
A(i,5)=(bool)C(i,5) * (1.0/6.0+0.5*(sF+1)*delta);
A(i,6)=(bool)C(i,6) * a0(i);
B(i,0)=(bool)C(i,0) * (1.0/3.0+delta);
B(i,1)=(bool)C(i,1) * (1.0/3.0+delta);
B(i,2)=(bool)C(i,2) * (0.4-0.4*a0(i)+0.2*b0(i)-2*delta/sF);
B(i,3)=(bool)C(i,3) * (0.4-3*delta/sF);
B(i,4)=(bool)C(i,4) * (0.4*a0(i)+0.8*b0(i)-delta/sF);
B(i,5)=(bool)C(i,5) * (1.0/3.0+delta);
B(i,6)=(bool)C(i,6) * b0(i);
}
for(unsigned int i = 0 ; i < m_MaxDirections; i++)
{
double sumA = 0;
double sumB = 0;
for(int j = 0 ; j < 7; j++)
{
sumA += A(i,j);
sumB += B(i,j);
}
a[i] = sumA;
b[i] = sumB;
}
for(unsigned int i = 0; i < m_MaxDirections; i++)
{
E1(i) = exp(-(a[i]*s0[i]));
E2(i) = exp(-(b[i]*s0[i]));
E3(i) = exp(-((1-a[i]-b[i])*s0[i]));
}
}
template<class TReferenceImagePixelType, class TGradientImagePixelType, class TOdfPixelType, int NOrderL, int NrOdfDirections>
void DiffusionMultiShellQballReconstructionImageFilter<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,NOrderL, NrOdfDirections>
::Projection3( vnl_vector<double> & A, vnl_vector<double> & a, vnl_vector<double> & b, double delta0)
{
const double s6 = sqrt(6.0);
const double s15 = s6/2.0;
vnl_vector<double> delta(a.size());
delta.fill(delta0);
vnl_matrix<double> AM(a.size(), 15);
vnl_matrix<double> aM(a.size(), 15);
vnl_matrix<double> bM(a.size(), 15);
vnl_matrix<unsigned char> B(a.size(), 15);
AM.set_column(0, A);
AM.set_column(1, A);
AM.set_column(2, A);
AM.set_column(3, delta);
AM.set_column(4, (A+a-b - (delta*s6))/3.0);
AM.set_column(5, delta);
AM.set_column(6, delta);
AM.set_column(7, delta);
AM.set_column(8, A);
AM.set_column(9, 0.2*(a*2+A-2*(s6+1)*delta));
AM.set_column(10,0.2*(b*(-2)+A+2-2*(s6+1)*delta));
AM.set_column(11, delta);
AM.set_column(12, delta);
AM.set_column(13, delta);
AM.set_column(14, 0.5-(1+s15)*delta);
aM.set_column(0, a);
aM.set_column(1, a);
aM.set_column(2, -delta + 1);
aM.set_column(3, a);
aM.set_column(4, (A*2+a*5+b+s6*delta)/6.0);
aM.set_column(5, a);
aM.set_column(6, -delta + 1);
aM.set_column(7, 0.5*(a+b)+(1+s15)*delta);
aM.set_column(8, -delta + 1);
aM.set_column(9, 0.2*(a*4+A*2+(s6+1)*delta));
aM.set_column(10, -delta + 1);
aM.set_column(11, (s6+3)*delta);
aM.set_column(12, -delta + 1);
aM.set_column(13, -delta + 1);
aM.set_column(14, -delta + 1);
bM.set_column(0, b);
bM.set_column(1, delta);
bM.set_column(2, b);
bM.set_column(3, b);
bM.set_column(4, (A*(-2)+a+b*5-s6*delta)/6.0);
bM.set_column(5, delta);
bM.set_column(6, b);
bM.set_column(7, 0.5*(a+b)-(1+s15)*delta);
bM.set_column(8, delta);
bM.set_column(9, delta);
bM.set_column(10, 0.2*(b*4-A*2+1-(s6+1)*delta));
bM.set_column(11, delta);
bM.set_column(12, delta);
bM.set_column(13, -delta*(s6+3) + 1);
bM.set_column(14, delta);
delta0 *= 0.99;
vnl_matrix<double> R2(a.size(), 15);
std::vector<unsigned int> I(a.size());
for (unsigned int i=0; i<AM.rows(); i++){
for (unsigned int j=0; j<AM.cols(); j++){
if (delta0 < AM(i,j) && 2*(AM(i,j)+delta0*s15)<aM(i,j)-bM(i,j) && bM(i,j)>delta0 && aM(i,j)<1-delta0)
R2(i,j) = (AM(i,j)-A(i))*(AM(i,j)-A(i))+ (aM(i,j)-a(i))*(aM(i,j)-a(i))+(bM(i,j)-b(i))*(bM(i,j)-b(i));
else
R2(i,j) = 1e20;
}
unsigned int index = 0;
double minvalue = 999;
for(int j = 0 ; j < 15 ; j++)
{
if(R2(i,j) < minvalue){
minvalue = R2(i,j);
index = j;
}
}
I[i] = index;
}
for (unsigned int i=0; i < A.size(); i++){
A(i) = AM(i,(int)I[i]);
a(i) = aM(i,(int)I[i]);
b(i) = bM(i,(int)I[i]);
}
}
template<class TReferenceImagePixelType, class TGradientImagePixelType, class TOdfPixelType, int NOrderL, int NrOdfDirections>
void DiffusionMultiShellQballReconstructionImageFilter<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,NOrderL, NrOdfDirections>
::S_S0Normalization( vnl_vector<double> & vec, double S0 )
{
for(unsigned int i = 0; i < vec.size(); i++)
{
if (S0==0)
S0 = 0.01;
vec[i] /= S0;
}
}
template< class T, class TG, class TO, int L, int NODF>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::DoubleLogarithm(vnl_vector<double> & vec)
{
for(unsigned int i = 0; i < vec.size(); i++)
{
vec[i] = log(-log(vec[i]));
}
}
template< class T, class TG, class TO, int L, int NODF>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::BeforeThreadedGenerateData()
{
m_ReconstructionType = Mode_Standard1Shell;
if(m_BValueMap.size() == 4 ){
BValueMapIteraotr it = m_BValueMap.begin();
it++; // skip b0 entry
const unsigned int bValue_shell1 = it->first;
const unsigned int size_shell1 = it->second.size();
IndiciesVector shell1 = it->second;
it++;
const unsigned int bValue_shell2 = it->first;
const unsigned int size_shell2 = it->second.size();
IndiciesVector shell2 = it->second;
it++;
const unsigned int bValue_shell3 = it->first;
const unsigned int size_shell3 = it->second.size();
IndiciesVector shell3 = it->second;
// arithmetic progrssion
if(bValue_shell2 - bValue_shell1 == bValue_shell1 && bValue_shell3 - bValue_shell2 == bValue_shell1 )
{
// check if Interpolation is needed
// if shells with different numbers of directions exist
m_Interpolation_Flag = false;
if(size_shell1 != size_shell2 || size_shell2 != size_shell3 || size_shell1 != size_shell3)
{
m_Interpolation_Flag = true;
MITK_INFO << "Shell interpolation: shells with different numbers of directions";
}
else
{
// else if each shell holds same numbers of directions, but the gradient direction differ more than one 1 degree
m_Interpolation_Flag = CheckForDifferingShellDirections();
if(m_Interpolation_Flag) MITK_INFO << "Shell interpolation: gradient direction differ more than one 1 degree";
}
m_ReconstructionType = Mode_Analytical3Shells;
if(m_Interpolation_Flag)
{
unsigned int interp_SHOrder_shell1 = 12;
while( ((interp_SHOrder_shell1+1)*(interp_SHOrder_shell1+2)/2) > size_shell1 && interp_SHOrder_shell1 > L )
interp_SHOrder_shell1 -= 2 ;
const int number_coeffs_shell1 = (int)(interp_SHOrder_shell1*interp_SHOrder_shell1 + interp_SHOrder_shell1 + 2.0)/2.0 + interp_SHOrder_shell1;
unsigned int interp_SHOrder_shell2 = 12;
while( ((interp_SHOrder_shell2+1)*(interp_SHOrder_shell2+2)/2) > size_shell2 && interp_SHOrder_shell2 > L )
interp_SHOrder_shell2 -= 2 ;
const int number_coeffs_shell2 = (int)(interp_SHOrder_shell2*interp_SHOrder_shell2 + interp_SHOrder_shell2 + 2.0)/2.0 + interp_SHOrder_shell2;
unsigned int interp_SHOrder_shell3 = 12;
while( ((interp_SHOrder_shell3+1)*(interp_SHOrder_shell3+2)/2) > size_shell3 && interp_SHOrder_shell3 > L )
interp_SHOrder_shell3 -= 2 ;
const int number_coeffs_shell3 = (int)(interp_SHOrder_shell3*interp_SHOrder_shell3 + interp_SHOrder_shell3 + 2.0)/2.0 + interp_SHOrder_shell3;
// Create direction container for all directions (no duplicates, different directions from all shells)
IndiciesVector all_directions_container = GetAllDirections();
m_MaxDirections = all_directions_container.size();
// create target SH-Basis
// initialize empty target matrix and set the wanted directions
vnl_matrix<double> * Q = new vnl_matrix<double>(3, m_MaxDirections);
ComputeSphericalFromCartesian(Q, all_directions_container);
// initialize a SH Basis, neede to interpolate from oldDirs -> newDirs
m_TARGET_SH_shell1 = new vnl_matrix<double>(m_MaxDirections, number_coeffs_shell1);
ComputeSphericalHarmonicsBasis(Q, m_TARGET_SH_shell1, interp_SHOrder_shell1);
delete Q;
Q = new vnl_matrix<double>(3, m_MaxDirections);
ComputeSphericalFromCartesian(Q, all_directions_container);
m_TARGET_SH_shell2 = new vnl_matrix<double>(m_MaxDirections, number_coeffs_shell2);
ComputeSphericalHarmonicsBasis(Q, m_TARGET_SH_shell2, interp_SHOrder_shell2);
delete Q;
Q = new vnl_matrix<double>(3, m_MaxDirections);
ComputeSphericalFromCartesian(Q, all_directions_container);
m_TARGET_SH_shell3 = new vnl_matrix<double>(m_MaxDirections, number_coeffs_shell3);
ComputeSphericalHarmonicsBasis(Q, m_TARGET_SH_shell3, interp_SHOrder_shell3);
delete Q;
// end creat target SH-Basis
// create measured-SHBasis
// Shell 1
vnl_matrix<double> * tempSHBasis;
vnl_matrix_inverse<double> * temp;
// initialize empty matrix and set the measured directions of shell1
Q = new vnl_matrix<double>(3, shell1.size());
ComputeSphericalFromCartesian(Q, shell1);
// initialize a SH Basis, need to get the coeffs from measuredShell
tempSHBasis = new vnl_matrix<double>(shell1.size(), number_coeffs_shell1);
ComputeSphericalHarmonicsBasis(Q, tempSHBasis, interp_SHOrder_shell1);
// inversion of the SH=Basis
// c_s1 = B^-1 * shell1
// interp_Values = targetSHBasis * c_s1
// Values = m_TARGET_SH_shell1 * Interpolation_SHT1_inv * DataShell1;
temp = new vnl_matrix_inverse<double>((*tempSHBasis));
m_Interpolation_SHT1_inv = new vnl_matrix<double>(temp->inverse());
delete Q;
delete temp;
delete tempSHBasis;
// Shell 2
Q = new vnl_matrix<double>(3, shell2.size());
ComputeSphericalFromCartesian(Q, shell2);
tempSHBasis = new vnl_matrix<double>(shell2.size(), number_coeffs_shell2);
ComputeSphericalHarmonicsBasis(Q, tempSHBasis, interp_SHOrder_shell2);
temp = new vnl_matrix_inverse<double>((*tempSHBasis));
m_Interpolation_SHT2_inv = new vnl_matrix<double>(temp->inverse());
delete Q;
delete temp;
delete tempSHBasis;
// Shell 3
Q = new vnl_matrix<double>(3, shell3.size());
ComputeSphericalFromCartesian(Q, shell3);
tempSHBasis = new vnl_matrix<double>(shell3.size(), number_coeffs_shell3);
ComputeSphericalHarmonicsBasis(Q, tempSHBasis, interp_SHOrder_shell3);
temp = new vnl_matrix_inverse<double>((*tempSHBasis));
m_Interpolation_SHT3_inv = new vnl_matrix<double>(temp->inverse());
delete Q;
delete temp;
delete tempSHBasis;
ComputeReconstructionMatrix(all_directions_container);
MITK_INFO << "Reconstruction information: Multishell Reconstruction filter - Interpolation";
MITK_INFO << "Shell 1";
MITK_INFO << " SHOrder: " << interp_SHOrder_shell1;
MITK_INFO << " Number of Coeffs: " << number_coeffs_shell1;
MITK_INFO << " Number of Gradientdirections: " << size_shell1;
MITK_INFO << "Shell 2";
MITK_INFO << " SHOrder: " << interp_SHOrder_shell2;
MITK_INFO << " Number of Coeffs: " << number_coeffs_shell2;
MITK_INFO << " Number of Gradientdirections: " << size_shell2;
MITK_INFO << "Shell 3";
MITK_INFO << " SHOrder: " << interp_SHOrder_shell3;
MITK_INFO << " Number of Coeffs: " << number_coeffs_shell3;
MITK_INFO << " Number of Gradientdirections: " << size_shell3;
MITK_INFO << "Overall";
MITK_INFO << " SHOrder: " << L;
MITK_INFO << " Number of Coeffs: " << (L+1)*(L+2)*0.5;
MITK_INFO << " Number of Gradientdirections: " << m_MaxDirections;
return;
}else
{
ComputeReconstructionMatrix(shell1);
}
}
}
if(m_BValueMap.size() > 2 && m_ReconstructionType != Mode_Analytical3Shells)
{
m_ReconstructionType = Mode_NumericalNShells;
}
if(m_BValueMap.size() == 2){
BValueMapIteraotr it = m_BValueMap.begin();
it++; // skip b0 entry
IndiciesVector shell = it->second;
ComputeReconstructionMatrix(shell);
}
}
template< class T, class TG, class TO, int L, int NODF>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
-::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int /*NumberOfThreads*/)
+::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType /*NumberOfThreads*/)
{
itk::TimeProbe clock;
clock.Start();
switch(m_ReconstructionType)
{
case Mode_Standard1Shell:
StandardOneShellReconstruction(outputRegionForThread);
break;
case Mode_Analytical3Shells:
AnalyticalThreeShellReconstruction(outputRegionForThread);
break;
case Mode_NumericalNShells:
break;
}
clock.Stop();
MITK_INFO << "Reconstruction in : " << clock.GetTotal() << " s";
}
template< class T, class TG, class TO, int L, int NODF>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::StandardOneShellReconstruction(const OutputImageRegionType& outputRegionForThread)
{
// Get output image pointer
- typename OdfImageType::Pointer outputImage = static_cast< OdfImageType * >(ProcessObject::GetOutput(0));
+ typename OdfImageType::Pointer outputImage = static_cast< OdfImageType * >(ProcessObject::GetPrimaryOutput());
// Get input gradient image pointer
typename GradientImagesType::Pointer gradientImagePointer = static_cast< GradientImagesType * >( ProcessObject::GetInput(0) );
// ImageRegionIterator for the output image
ImageRegionIterator< OdfImageType > oit(outputImage, outputRegionForThread);
oit.GoToBegin();
// ImageRegionIterator for the BZero (output) image
ImageRegionIterator< BZeroImageType > bzeroIterator(m_BZeroImage, outputRegionForThread);
bzeroIterator.GoToBegin();
// Const ImageRegionIterator for input gradient image
typedef ImageRegionConstIterator< GradientImagesType > GradientIteratorType;
GradientIteratorType git(gradientImagePointer, outputRegionForThread );
git.GoToBegin();
BValueMapIteraotr it = m_BValueMap.begin();
it++; // skip b0 entry
IndiciesVector SignalIndicies = it->second;
IndiciesVector BZeroIndicies = m_BValueMap[0];
unsigned int NumbersOfGradientIndicies = SignalIndicies.size();
typedef typename GradientImagesType::PixelType GradientVectorType;
// iterate overall voxels of the gradient image region
while( ! git.IsAtEnd() )
{
GradientVectorType b = git.Get();
// ODF Vector
OdfPixelType odf(0.0);
double b0average = 0;
const unsigned int b0size = BZeroIndicies.size();
for(unsigned int i = 0; i < b0size ; ++i)
{
b0average += b[BZeroIndicies[i]];
}
b0average /= b0size;
bzeroIterator.Set(b0average);
++bzeroIterator;
// Create the Signal Vector
vnl_vector<double> SignalVector(NumbersOfGradientIndicies);
if( (b0average != 0) && (b0average >= m_Threshold) )
{
for( unsigned int i = 0; i< SignalIndicies.size(); i++ )
{
SignalVector[i] = static_cast<double>(b[SignalIndicies[i]]);
}
// apply threashold an generate ln(-ln(E)) signal
// Replace SignalVector with PreNormalized SignalVector
S_S0Normalization(SignalVector, b0average);
Projection1(SignalVector);
DoubleLogarithm(SignalVector);
// approximate ODF coeffs
vnl_vector<double> coeffs = ( (*m_CoeffReconstructionMatrix) * SignalVector );
coeffs[0] = 1.0/(2.0*sqrt(M_PI));
odf = element_cast<double, TO>(( (*m_ODFSphericalHarmonicBasisMatrix) * coeffs )).data_block();
odf *= (M_PI*4/NODF);
}
// set ODF to ODF-Image
oit.Set( odf );
++oit;
++git;
}
MITK_INFO << "One Thread finished reconstruction";
}
//#include "itkLevenbergMarquardtOptimizer.h"
template< class T, class TG, class TO, int L, int NODF>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::NumericalNShellReconstruction(const OutputImageRegionType& outputRegionForThread)
{
/* itk::LevenbergMarquardtOptimizer::Pointer optimizer = itk::LevenbergMarquardtOptimizer::New();
optimizer->SetUseCostFunctionGradient(false);
// Scale the translation components of the Transform in the Optimizer
itk::LevenbergMarquardtOptimizer::ScalesType scales(transform->GetNumberOfParameters());
scales.Fill(0.01);
unsigned long numberOfIterations = 80000;
double gradientTolerance = 1e-10; // convergence criterion
double valueTolerance = 1e-10; // convergence criterion
double epsilonFunction = 1e-10; // convergence criterion
optimizer->SetScales( scales );
optimizer->SetNumberOfIterations( numberOfIterations );
optimizer->SetValueTolerance( valueTolerance );
optimizer->SetGradientTolerance( gradientTolerance );
optimizer->SetEpsilonFunction( epsilonFunction );*/
}
template< class T, class TG, class TO, int L, int NODF>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::AnalyticalThreeShellReconstruction(const OutputImageRegionType& outputRegionForThread)
{
// Input Gradient Image and Output ODF Image
typedef typename GradientImagesType::PixelType GradientVectorType;
- typename OdfImageType::Pointer outputImage = static_cast< OdfImageType * >(ProcessObject::GetOutput(0));
+ typename OdfImageType::Pointer outputImage = static_cast< OdfImageType * >(ProcessObject::GetPrimaryOutput());
typename GradientImagesType::Pointer gradientImagePointer = static_cast< GradientImagesType * >( ProcessObject::GetInput(0) );
// Define Image iterators
ImageRegionIterator< OdfImageType > odfOutputImageIterator(outputImage, outputRegionForThread);
ImageRegionConstIterator< GradientImagesType > gradientInputImageIterator(gradientImagePointer, outputRegionForThread );
ImageRegionIterator< BZeroImageType > bzeroIterator(m_BZeroImage, outputRegionForThread);
ImageRegionIterator< CoefficientImageType > coefficientImageIterator(m_CoefficientImage, outputRegionForThread);
// All iterators seht to Begin of the specific OutputRegion
coefficientImageIterator.GoToBegin();
bzeroIterator.GoToBegin();
odfOutputImageIterator.GoToBegin();
gradientInputImageIterator.GoToBegin();
// Get Shell Indicies for all non-BZero Gradients
// it MUST be a arithmetic progression eg.: 1000, 2000, 3000
BValueMapIteraotr it = m_BValueMap.begin();
it++;
// it = b-value = 1000
IndiciesVector Shell1Indiecies = it->second;
it++;
// it = b-value = 2000
IndiciesVector Shell2Indiecies = it->second;
it++;
// it = b-value = 3000
IndiciesVector Shell3Indiecies = it->second;
IndiciesVector BZeroIndicies = m_BValueMap[0];
if(!m_Interpolation_Flag)
{
m_MaxDirections = Shell1Indiecies.size();
}// else: m_MaxDirection is set in BeforeThreadedGenerateData
// Nx3 Signal Matrix with E(0) = Shell 1, E(1) = Shell 2, E(2) = Shell 3
vnl_vector< double > E1(m_MaxDirections);
vnl_vector< double > E2(m_MaxDirections);
vnl_vector< double > E3(m_MaxDirections);
vnl_vector<double> AlphaValues(m_MaxDirections);
vnl_vector<double> BetaValues(m_MaxDirections);
vnl_vector<double> LAValues(m_MaxDirections);
vnl_vector<double> PValues(m_MaxDirections);
vnl_vector<double> DataShell1(Shell1Indiecies.size());
vnl_vector<double> DataShell2(Shell2Indiecies.size());
vnl_vector<double> DataShell3(Shell3Indiecies.size());
vnl_matrix<double> tempInterpolationMatrixShell1,tempInterpolationMatrixShell2,tempInterpolationMatrixShell3;
if(m_Interpolation_Flag)
{
tempInterpolationMatrixShell1 = (*m_TARGET_SH_shell1) * (*m_Interpolation_SHT1_inv);
tempInterpolationMatrixShell2 = (*m_TARGET_SH_shell2) * (*m_Interpolation_SHT2_inv);
tempInterpolationMatrixShell3 = (*m_TARGET_SH_shell3) * (*m_Interpolation_SHT3_inv);
}
OdfPixelType odf(0.0);
typename CoefficientImageType::PixelType coeffPixel(0.0);
double P2,A,B2,B,P,alpha,beta,lambda, ER1, ER2;
// iterate overall voxels of the gradient image region
while( ! gradientInputImageIterator.IsAtEnd() )
{
odf = 0.0;
coeffPixel = 0.0;
GradientVectorType b = gradientInputImageIterator.Get();
// calculate for each shell the corresponding b0-averages
double shell1b0Norm =0;
double shell2b0Norm =0;
double shell3b0Norm =0;
double b0average = 0;
const unsigned int b0size = BZeroIndicies.size();
if(b0size == 1)
{
shell1b0Norm = b[BZeroIndicies[0]];
shell2b0Norm = b[BZeroIndicies[0]];
shell3b0Norm = b[BZeroIndicies[0]];
b0average = b[BZeroIndicies[0]];
}else if(b0size % 3 ==0)
{
for(unsigned int i = 0; i < b0size ; ++i)
{
if(i < b0size / 3) shell1b0Norm += b[BZeroIndicies[i]];
if(i >= b0size / 3 && i < (b0size / 3)*2) shell2b0Norm += b[BZeroIndicies[i]];
if(i >= (b0size / 3) * 2) shell3b0Norm += b[BZeroIndicies[i]];
}
shell1b0Norm /= (b0size/3);
shell2b0Norm /= (b0size/3);
shell3b0Norm /= (b0size/3);
b0average = (shell1b0Norm + shell2b0Norm+ shell3b0Norm)/3;
}else
{
for(unsigned int i = 0; i <b0size ; ++i)
{
shell1b0Norm += b[BZeroIndicies[i]];
}
shell1b0Norm /= b0size;
shell2b0Norm = shell1b0Norm;
shell3b0Norm = shell1b0Norm;
b0average = shell1b0Norm;
}
bzeroIterator.Set(b0average);
++bzeroIterator;
if( (b0average != 0) && ( b0average >= m_Threshold) )
{
// Get the Signal-Value for each Shell at each direction (specified in the ShellIndicies Vector .. this direction corresponse to this shell...)
/*//fsl fix ---------------------------------------------------
for(int i = 0 ; i < Shell1Indiecies.size(); i++)
DataShell1[i] = static_cast<double>(b[Shell1Indiecies[i]]);
for(int i = 0 ; i < Shell2Indiecies.size(); i++)
DataShell2[i] = static_cast<double>(b[Shell2Indiecies[i]]);
for(int i = 0 ; i < Shell3Indiecies.size(); i++)
DataShell3[i] = static_cast<double>(b[Shell2Indiecies[i]]);
// Normalize the Signal: Si/S0
S_S0Normalization(DataShell1, shell1b0Norm);
S_S0Normalization(DataShell2, shell2b0Norm);
S_S0Normalization(DataShell3, shell2b0Norm);
*///fsl fix -------------------------------------------ende--
///correct version
for(unsigned int i = 0 ; i < Shell1Indiecies.size(); i++)
DataShell1[i] = static_cast<double>(b[Shell1Indiecies[i]]);
for(unsigned int i = 0 ; i < Shell2Indiecies.size(); i++)
DataShell2[i] = static_cast<double>(b[Shell2Indiecies[i]]);
for(unsigned int i = 0 ; i < Shell3Indiecies.size(); i++)
DataShell3[i] = static_cast<double>(b[Shell3Indiecies[i]]);
// Normalize the Signal: Si/S0
S_S0Normalization(DataShell1, shell1b0Norm);
S_S0Normalization(DataShell2, shell2b0Norm);
S_S0Normalization(DataShell3, shell3b0Norm);
if(m_Interpolation_Flag)
{
E1 = tempInterpolationMatrixShell1 * DataShell1;
E2 = tempInterpolationMatrixShell2 * DataShell2;
E3 = tempInterpolationMatrixShell3 * DataShell3;
}else{
E1 = (DataShell1);
E2 = (DataShell2);
E3 = (DataShell3);
}
//Implements Eq. [19] and Fig. 4.
Projection1(E1);
Projection1(E2);
Projection1(E3);
//inqualities [31]. Taking the lograithm of th first tree inqualities
//convert the quadratic inqualities to linear ones.
Projection2(E1,E2,E3);
for( unsigned int i = 0; i< m_MaxDirections; i++ )
{
double e1 = E1.get(i);
double e2 = E2.get(i);
double e3 = E3.get(i);
P2 = e2-e1*e1;
A = (e3 -e1*e2) / ( 2* P2);
B2 = A * A -(e1 * e3 - e2 * e2) /P2;
B = 0;
if(B2 > 0) B = sqrt(B2);
P = 0;
if(P2 > 0) P = sqrt(P2);
alpha = A + B;
beta = A - B;
PValues.put(i, P);
AlphaValues.put(i, alpha);
BetaValues.put(i, beta);
}
Projection3(PValues, AlphaValues, BetaValues);
for(unsigned int i = 0 ; i < m_MaxDirections; i++)
{
const double fac = (PValues[i] * 2 ) / (AlphaValues[i] - BetaValues[i]);
lambda = 0.5 + 0.5 * std::sqrt(1 - fac * fac);;
ER1 = std::fabs(lambda * (AlphaValues[i] - BetaValues[i]) + (BetaValues[i] - E1.get(i) ))
+ std::fabs(lambda * (AlphaValues[i] * AlphaValues[i] - BetaValues[i] * BetaValues[i]) + (BetaValues[i] * BetaValues[i] - E2.get(i) ))
+ std::fabs(lambda * (AlphaValues[i] * AlphaValues[i] * AlphaValues[i] - BetaValues[i] * BetaValues[i] * BetaValues[i]) + (BetaValues[i] * BetaValues[i] * BetaValues[i] - E3.get(i) ));
ER2 = std::fabs((1-lambda) * (AlphaValues[i] - BetaValues[i]) + (BetaValues[i] - E1.get(i) ))
+ std::fabs((1-lambda) * (AlphaValues[i] * AlphaValues[i] - BetaValues[i] * BetaValues[i]) + (BetaValues[i] * BetaValues[i] - E2.get(i) ))
+ std::fabs((1-lambda) * (AlphaValues[i] * AlphaValues[i] * AlphaValues[i] - BetaValues[i] * BetaValues[i] * BetaValues[i]) + (BetaValues[i] * BetaValues[i] * BetaValues[i] - E3.get(i)));
if(ER1 < ER2)
LAValues.put(i, lambda);
else
LAValues.put(i, 1-lambda);
}
DoubleLogarithm(AlphaValues);
DoubleLogarithm(BetaValues);
vnl_vector<double> SignalVector(element_product((LAValues) , (AlphaValues)-(BetaValues)) + (BetaValues));
vnl_vector<double> coeffs((*m_CoeffReconstructionMatrix) *SignalVector );
// the first coeff is a fix value
coeffs[0] = 1.0/(2.0*sqrt(M_PI));
coeffPixel = element_cast<double, TO>(coeffs).data_block();
// Cast the Signal-Type from double to float for the ODF-Image
odf = element_cast<double, TO>( (*m_ODFSphericalHarmonicBasisMatrix) * coeffs ).data_block();
odf *= ((M_PI*4)/NODF);
}
// set ODF to ODF-Image
coefficientImageIterator.Set(coeffPixel);
odfOutputImageIterator.Set( odf );
++odfOutputImageIterator;
++coefficientImageIterator;
++gradientInputImageIterator;
}
}
template< class T, class TG, class TO, int L, int NODF>
void DiffusionMultiShellQballReconstructionImageFilter<T, TG, TO, L, NODF>::
ComputeSphericalHarmonicsBasis(vnl_matrix<double> * QBallReference, vnl_matrix<double> *SHBasisOutput, int LOrder , vnl_matrix<double>* LaplaciaBaltramiOutput, vnl_vector<int>* SHOrderAssociation, vnl_matrix<double>* SHEigenvalues)
{
// MITK_INFO << *QBallReference;
for(unsigned int i=0; i< (*SHBasisOutput).rows(); i++)
{
for(int k = 0; k <= LOrder; k += 2)
{
for(int m =- k; m <= k; m++)
{
int j = ( k * k + k + 2 ) / 2 + m - 1;
// Compute SHBasisFunctions
if(QBallReference){
double phi = (*QBallReference)(0,i);
double th = (*QBallReference)(1,i);
(*SHBasisOutput)(i,j) = mitk::sh::Yj(m,k,th,phi);
}
// Laplacian Baltrami Order Association
if(LaplaciaBaltramiOutput)
(*LaplaciaBaltramiOutput)(j,j) = k*k*(k + 1)*(k+1);
// SHEigenvalues with order Accosiation kj
if(SHEigenvalues)
(*SHEigenvalues)(j,j) = -k* (k+1);
// Order Association
if(SHOrderAssociation)
(*SHOrderAssociation)[j] = k;
}
}
}
}
template< class T, class TG, class TO, int L, int NOdfDirections>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NOdfDirections>
::ComputeReconstructionMatrix(IndiciesVector const & refVector)
{
typedef std::auto_ptr< vnl_matrix< double> > MatrixDoublePtr;
typedef std::auto_ptr< vnl_vector< int > > VectorIntPtr;
typedef std::auto_ptr< vnl_matrix_inverse< double > > InverseMatrixDoublePtr;
int numberOfGradientDirections = refVector.size();
if( numberOfGradientDirections <= (((L+1)*(L+2))/2) || numberOfGradientDirections < 6 )
{
itkExceptionMacro( << "At least (L+1)(L+2)/2 gradient directions for each shell are required; current : " << numberOfGradientDirections );
}
CheckDuplicateDiffusionGradients();
const int LOrder = L;
int NumberOfCoeffs = (int)(LOrder*LOrder + LOrder + 2.0)/2.0 + LOrder;
MatrixDoublePtr SHBasisMatrix(new vnl_matrix<double>(numberOfGradientDirections,NumberOfCoeffs));
SHBasisMatrix->fill(0.0);
VectorIntPtr SHOrderAssociation(new vnl_vector<int>(NumberOfCoeffs));
SHOrderAssociation->fill(0.0);
MatrixDoublePtr LaplacianBaltrami(new vnl_matrix<double>(NumberOfCoeffs,NumberOfCoeffs));
LaplacianBaltrami->fill(0.0);
MatrixDoublePtr FRTMatrix(new vnl_matrix<double>(NumberOfCoeffs,NumberOfCoeffs));
FRTMatrix->fill(0.0);
MatrixDoublePtr SHEigenvalues(new vnl_matrix<double>(NumberOfCoeffs,NumberOfCoeffs));
SHEigenvalues->fill(0.0);
MatrixDoublePtr Q(new vnl_matrix<double>(3, numberOfGradientDirections));
// Convert Cartesian to Spherical Coordinates refVector -> Q
ComputeSphericalFromCartesian(Q.get(), refVector);
// SHBasis-Matrix + LaplacianBaltrami-Matrix + SHOrderAssociationVector
ComputeSphericalHarmonicsBasis(Q.get() ,SHBasisMatrix.get() , LOrder , LaplacianBaltrami.get(), SHOrderAssociation.get(), SHEigenvalues.get());
// Compute FunkRadon Transformation Matrix Associated to SHBasis Order lj
for(int i=0; i<NumberOfCoeffs; i++)
{
(*FRTMatrix)(i,i) = 2.0 * M_PI * mitk::sh::legendre0((*SHOrderAssociation)[i]);
}
MatrixDoublePtr temp(new vnl_matrix<double>(((SHBasisMatrix->transpose()) * (*SHBasisMatrix)) + (m_Lambda * (*LaplacianBaltrami))));
InverseMatrixDoublePtr pseudo_inv(new vnl_matrix_inverse<double>((*temp)));
MatrixDoublePtr inverse(new vnl_matrix<double>(NumberOfCoeffs,NumberOfCoeffs));
(*inverse) = pseudo_inv->inverse();
const double factor = (1.0/(16.0*M_PI*M_PI));
MatrixDoublePtr SignalReonstructionMatrix (new vnl_matrix<double>((*inverse) * (SHBasisMatrix->transpose())));
m_CoeffReconstructionMatrix = new vnl_matrix<double>(( factor * ((*FRTMatrix) * ((*SHEigenvalues) * (*SignalReonstructionMatrix))) ));
// SH Basis for ODF-reconstruction
vnl_matrix_fixed<double, 3, NOdfDirections>* U = PointShell<NOdfDirections, vnl_matrix_fixed<double, 3, NOdfDirections> >::DistributePointShell();
for(int i=0; i<NOdfDirections; i++)
{
double x = (*U)(0,i);
double y = (*U)(1,i);
double z = (*U)(2,i);
double cart[3];
mitk::sh::Cart2Sph(x,y,z,cart);
(*U)(0,i) = cart[0];
(*U)(1,i) = cart[1];
(*U)(2,i) = cart[2];
}
MatrixDoublePtr tempPtr (new vnl_matrix<double>( U->as_matrix() ));
m_ODFSphericalHarmonicBasisMatrix = new vnl_matrix<double>(NOdfDirections,NumberOfCoeffs);
ComputeSphericalHarmonicsBasis(tempPtr.get(), m_ODFSphericalHarmonicBasisMatrix, LOrder);
}
template< class T, class TG, class TO, int L, int NOdfDirections>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NOdfDirections>
::ComputeSphericalFromCartesian(vnl_matrix<double> * Q, IndiciesVector const & refShell)
{
for(unsigned int i = 0; i < refShell.size(); i++)
{
double x = m_GradientDirectionContainer->ElementAt(refShell[i]).normalize().get(0);
double y = m_GradientDirectionContainer->ElementAt(refShell[i]).normalize().get(1);
double z = m_GradientDirectionContainer->ElementAt(refShell[i]).normalize().get(2);
double cart[3];
mitk::sh::Cart2Sph(x,y,z,cart);
(*Q)(0,i) = cart[0];
(*Q)(1,i) = cart[1];
(*Q)(2,i) = cart[2];
}
}
template< class T, class TG, class TO, int L, int NODF>
bool DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::CheckDuplicateDiffusionGradients()
{
bool value = false;
BValueMapIteraotr mapIterator = m_BValueMap.begin();
mapIterator++;
while(mapIterator != m_BValueMap.end())
{
std::vector<unsigned int>::const_iterator it1 = mapIterator->second.begin();
std::vector<unsigned int>::const_iterator it2 = mapIterator->second.begin();
for(; it1 != mapIterator->second.end(); ++it1)
{
for(; it2 != mapIterator->second.end(); ++it2)
{
if(m_GradientDirectionContainer->ElementAt(*it1) == m_GradientDirectionContainer->ElementAt(*it2) && it1 != it2)
{
itkWarningMacro( << "Some of the Diffusion Gradients equal each other. Corresponding image data should be averaged before calling this filter." );
value = true;
}
}
}
++mapIterator;
}
return value;
}
template< class T, class TG, class TO, int L, int NODF>
std::vector<unsigned int> DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::GetAllDirections()
{
IndiciesVector directioncontainer;
BValueMapIteraotr mapIterator = m_BValueMap.begin();
mapIterator++;
IndiciesVector shell1 = mapIterator->second;
mapIterator++;
IndiciesVector shell2 = mapIterator->second;
mapIterator++;
IndiciesVector shell3 = mapIterator->second;
while(shell1.size()>0)
{
unsigned int wntIndex = shell1.back();
shell1.pop_back();
IndiciesVector::iterator containerIt = directioncontainer.begin();
bool directionExist = false;
while(containerIt != directioncontainer.end())
{
if (fabs(dot(m_GradientDirectionContainer->ElementAt(*containerIt), m_GradientDirectionContainer->ElementAt(wntIndex))) > 0.9998)
{
directionExist = true;
break;
}
containerIt++;
}
if(!directionExist)
{
directioncontainer.push_back(wntIndex);
}
}
while(shell2.size()>0)
{
unsigned int wntIndex = shell2.back();
shell2.pop_back();
IndiciesVector::iterator containerIt = directioncontainer.begin();
bool directionExist = false;
while(containerIt != directioncontainer.end())
{
if (fabs(dot(m_GradientDirectionContainer->ElementAt(*containerIt), m_GradientDirectionContainer->ElementAt(wntIndex))) > 0.9998)
{
directionExist = true;
break;
}
containerIt++;
}
if(!directionExist)
{
directioncontainer.push_back(wntIndex);
}
}
while(shell3.size()>0)
{
unsigned int wntIndex = shell3.back();
shell3.pop_back();
IndiciesVector::iterator containerIt = directioncontainer.begin();
bool directionExist = false;
while(containerIt != directioncontainer.end())
{
if (fabs(dot(m_GradientDirectionContainer->ElementAt(*containerIt), m_GradientDirectionContainer->ElementAt(wntIndex))) > 0.9998)
{
directionExist = true;
break;
}
containerIt++;
}
if(!directionExist)
{
directioncontainer.push_back(wntIndex);
}
}
return directioncontainer;
}
// corresponding directions between shells (e.g. dir1_shell1 vs dir1_shell2) differ more than 1 degree.
template< class T, class TG, class TO, int L, int NODF>
bool DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::CheckForDifferingShellDirections()
{
bool interp_flag = false;
BValueMapIteraotr mapIterator = m_BValueMap.begin();
mapIterator++;
IndiciesVector shell1 = mapIterator->second;
mapIterator++;
IndiciesVector shell2 = mapIterator->second;
mapIterator++;
IndiciesVector shell3 = mapIterator->second;
for (unsigned int i=0; i< shell1.size(); i++)
if (fabs(dot(m_GradientDirectionContainer->ElementAt(shell1[i]), m_GradientDirectionContainer->ElementAt(shell2[i]))) <= 0.9998) {interp_flag=true; break;}
for (unsigned int i=0; i< shell1.size(); i++)
if (fabs(dot(m_GradientDirectionContainer->ElementAt(shell1[i]), m_GradientDirectionContainer->ElementAt(shell3[i]))) <= 0.9998) {interp_flag=true; break;}
for (unsigned int i=0; i< shell1.size(); i++)
if (fabs(dot(m_GradientDirectionContainer->ElementAt(shell2[i]), m_GradientDirectionContainer->ElementAt(shell3[i]))) <= 0.9998) {interp_flag=true; break;}
return interp_flag;
}
template< class T, class TG, class TO, int L, int NODF>
void DiffusionMultiShellQballReconstructionImageFilter<T,TG,TO,L,NODF>
::PrintSelf(std::ostream& os, Indent indent) const
{
std::locale C("C");
std::locale originalLocale = os.getloc();
os.imbue(C);
Superclass::PrintSelf(os,indent);
//os << indent << "OdfReconstructionMatrix: " << m_ReconstructionMatrix << std::endl;
if ( m_GradientDirectionContainer )
{
os << indent << "GradientDirectionContainer: "
<< m_GradientDirectionContainer << std::endl;
}
else
{
os << indent <<
"GradientDirectionContainer: (Gradient directions not set)" << std::endl;
}
os << indent << "NumberOfGradientDirections: " <<
m_NumberOfGradientDirections << std::endl;
os << indent << "NumberOfBaselineImages: " <<
m_NumberOfBaselineImages << std::endl;
os << indent << "Threshold for reference B0 image: " << m_Threshold << std::endl;
os << indent << "BValue: " << m_BValue << std::endl;
os.imbue( originalLocale );
}
}
#endif // __itkDiffusionMultiShellQballReconstructionImageFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
index 22cba4bfe8..25e644ddd4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
@@ -1,219 +1,219 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkDiffusionMultiShellQballReconstructionImageFilter_h_
#define __itkDiffusionMultiShellQballReconstructionImageFilter_h_
#include <itkImageToImageFilter.h>
namespace itk{
/** \class DiffusionMultiShellQballReconstructionImageFilter
I. Aganj, C. Lenglet, G. Sapiro, E. Yacoub, K. Ugurbil, and N. Harel, “Reconstruction of the orientation distribution function in single and multiple shell q-ball imaging within constant solid angle,” Magnetic Resonance in Medicine, vol. 64, no. 2, pp. 554–566, 2010.
*/
template< class TReferenceImagePixelType, class TGradientImagePixelType, class TOdfPixelType, int NOrderL, int NrOdfDirections>
class DiffusionMultiShellQballReconstructionImageFilter : public ImageToImageFilter< Image< TReferenceImagePixelType, 3 >, Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > >
{
public:
typedef DiffusionMultiShellQballReconstructionImageFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< TReferenceImagePixelType, 3>, Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > > Superclass;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef TReferenceImagePixelType ReferencePixelType;
/** GradientImageType
* (e.g. type short)*/
typedef TGradientImagePixelType GradientPixelType;
/** GradientImageType
* 3D VectorImage containing GradientPixelTypes */
typedef VectorImage< GradientPixelType, 3 > GradientImagesType;
/** ODF PixelType */
typedef Vector< TOdfPixelType, NrOdfDirections > OdfPixelType;
/** ODF ImageType */
typedef Image< OdfPixelType, 3 > OdfImageType;
/** BzeroImageType */
typedef Image< TOdfPixelType, 3 > BZeroImageType;
/** Container to hold gradient directions of the 'n' DW measurements */
typedef VectorContainer< unsigned int, vnl_vector_fixed< double, 3 > > GradientDirectionContainerType;
typedef Image< Vector< TOdfPixelType, (NOrderL*NOrderL + NOrderL + 2)/2 + NOrderL >, 3 > CoefficientImageType;
typedef std::map<double, std::vector<unsigned int> > BValueMap;
typedef std::map<double, std::vector<unsigned int> >::iterator BValueMapIteraotr;
typedef std::vector<unsigned int> IndiciesVector;
// --------------------------------------------------------------------------------------------//
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(DiffusionMultiShellQballReconstructionImageFilter, ImageToImageFilter)
/** Get reference image */
virtual typename Superclass::InputImageType * GetInputImage()
{ return ( static_cast< typename Superclass::InputImageType *>(this->ProcessObject::GetInput(0)) ); }
/** Replaces the Input method.
* Var vols = mitk::DiffusionImage<type>
* -----------------------------------------------------
* GradientDirectionContainerType-Input gradientDirectionContainer (e.g. vols->GetDirections)
* GradientImagesType-Input gradientImage (e.g. vols->GetVectorImage)
* float-Input bvalue (e.g. vols->GetB_Value) */
void SetGradientImage( GradientDirectionContainerType * gradientDirectionContainer, const GradientImagesType *gradientImage , float bvalue);//, std::vector<bool> listOfUserSelctedBValues );
/** Set a BValue Map (key = bvalue, value = indicies splittet for each shell)
* If the input image containes more than three q-shells
* (e.g. b-Values of 0, 1000, 2000, 3000, 4000, ...).
* For the Analytical-Reconstruction it is needed to set a
* BValue Map containing three shells in an arithmetic series
* (e.g. 0, 1000, 2000, 3000).
*/
inline void SetBValueMap(BValueMap map){this->m_BValueMap = map;}
/** Threshold on the reference image data. The output ODF will be a null
* pdf for pixels in the reference image that have a value less than this
* threshold. */
itkSetMacro( Threshold, ReferencePixelType )
itkGetMacro( Threshold, ReferencePixelType )
itkGetMacro( CoefficientImage, typename CoefficientImageType::Pointer )
/** Return non-diffusion weighted images */
itkGetMacro( BZeroImage, typename BZeroImageType::Pointer)
/** Factor for Laplacian-Baltrami smoothing of the SH-coefficients*/
itkSetMacro( Lambda, double )
itkGetMacro( Lambda, double )
protected:
DiffusionMultiShellQballReconstructionImageFilter();
~DiffusionMultiShellQballReconstructionImageFilter() { }
void PrintSelf(std::ostream& os, Indent indent) const;
void BeforeThreadedGenerateData();
- void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, int NumberOfThreads );
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType NumberOfThreads );
private:
enum ReconstructionType
{
Mode_Analytical3Shells,
Mode_NumericalNShells,
Mode_Standard1Shell
};
ReconstructionType m_ReconstructionType;
// Interpolation
bool m_Interpolation_Flag;
vnl_matrix< double > * m_Interpolation_SHT1_inv;
vnl_matrix< double > * m_Interpolation_SHT2_inv;
vnl_matrix< double > * m_Interpolation_SHT3_inv;
vnl_matrix< double > * m_TARGET_SH_shell1;
vnl_matrix< double > * m_TARGET_SH_shell2;
vnl_matrix< double > * m_TARGET_SH_shell3;
unsigned int m_MaxDirections;
vnl_matrix< double > * m_CoeffReconstructionMatrix;
vnl_matrix< double > * m_ODFSphericalHarmonicBasisMatrix;
/** container to hold gradient directions */
GradientDirectionContainerType::Pointer m_GradientDirectionContainer;
/** Number of gradient measurements */
unsigned int m_NumberOfGradientDirections;
/** Number of baseline images */
unsigned int m_NumberOfBaselineImages;
/** Threshold on the reference image data */
ReferencePixelType m_Threshold;
typename BZeroImageType::Pointer m_BZeroImage;
typename CoefficientImageType::Pointer m_CoefficientImage;
float m_BValue;
BValueMap m_BValueMap;
double m_Lambda;
bool m_IsHemisphericalArrangementOfGradientDirections;
bool m_IsArithmeticProgession;
void ComputeReconstructionMatrix(IndiciesVector const & refVector);
void ComputeODFSHBasis();
bool CheckDuplicateDiffusionGradients();
bool CheckForDifferingShellDirections();
IndiciesVector GetAllDirections();
void ComputeSphericalHarmonicsBasis(vnl_matrix<double>* QBallReference, vnl_matrix<double>* SHBasisOutput, int Lorder , vnl_matrix<double>* LaplaciaBaltramiOutput =0 , vnl_vector<int>* SHOrderAssociation =0 , vnl_matrix<double> * SHEigenvalues =0);
void Normalize(OdfPixelType & odf );
void S_S0Normalization( vnl_vector<double> & vec, double b0 = 0 );
void DoubleLogarithm(vnl_vector<double> & vec);
double CalculateThreashold(const double value, const double delta);
void Projection1(vnl_vector<double> & vec, double delta = 0.01);
void Projection2( vnl_vector<double> & E1, vnl_vector<double> & E2, vnl_vector<double> & E3, double delta = 0.01);
void Projection3( vnl_vector<double> & A, vnl_vector<double> & alpha, vnl_vector<double> & beta, double delta = 0.01);
void StandardOneShellReconstruction(const OutputImageRegionType& outputRegionForThread);
void AnalyticalThreeShellReconstruction(const OutputImageRegionType& outputRegionForThread);
void NumericalNShellReconstruction(const OutputImageRegionType& outputRegionForThread);
void GenerateAveragedBZeroImage(const OutputImageRegionType& outputRegionForThread);
void ComputeSphericalFromCartesian(vnl_matrix<double> * Q, const IndiciesVector & refShell);
//------------------------- VNL-function ------------------------------------
template<typename CurrentValue, typename WntValue>
vnl_vector< WntValue> element_cast (vnl_vector< CurrentValue> const& v1)
{
vnl_vector<WntValue> result(v1.size());
for(unsigned int i = 0 ; i < v1.size(); i++)
result[i] = static_cast< WntValue>(v1[i]);
return result;
}
template<typename type>
double dot (vnl_vector_fixed< type ,3> const& v1, vnl_vector_fixed< type ,3 > const& v2 )
{
double result = (v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) / (v1.two_norm() * v2.two_norm());
return result ;
}
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDiffusionMultiShellQballReconstructionImageFilter.cpp"
#endif
#endif //__itkDiffusionMultiShellQballReconstructionImageFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.h
index 9c9eb7dec3..2ddfab5d93 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.h
@@ -1,340 +1,340 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkDiffusionQballReconstructionImageFilter_h_
#define __itkDiffusionQballReconstructionImageFilter_h_
#include "itkImageToImageFilter.h"
//#include "vnl/vnl_matrix.h"
#include "vnl/vnl_vector_fixed.h"
#include "vnl/vnl_matrix.h"
#include "vnl/algo/vnl_svd.h"
#include "itkVectorContainer.h"
#include "itkVectorImage.h"
namespace itk{
/** \class DiffusionQballReconstructionImageFilter
* \brief This class takes as input one or more reference images (acquired in the
* absence of diffusion sensitizing gradients) and 'n' diffusion
* weighted images and their gradient directions and computes an image of
* orientation distribution functions (ODFs).
*
* \par Inputs and Usage
* There are two ways to use this class. When you have one reference image and \c n
* gradient images, you would use the class as
* \code
* filter->SetReferenceImage( image0 );
* filter->AddGradientImage( direction1, image1 );
* filter->AddGradientImage( direction2, image2 );
* ...
* \endcode
*
* \par
* When you have the 'n' gradient and one or more reference images in a single
* multi-component image (VectorImage), you can specify the images simply as
* \code
* filter->SetGradientImage( directionsContainer, vectorImage );
* \endcode
* Note that this method is used to specify both the reference and gradient images.
* This is convenient when the DWI images are read in using the
* <a href="http://wiki.na-mic.org/Wiki/index.php/NAMIC_Wiki:DTI:Nrrd_format">NRRD</a>
* format. Like the Nrrd format, the reference images are those components of the
* vectorImage whose gradient direction is (0,0,0). If more than one reference image
* is present, they are averaged prior to the reconstruction.
*
* \par Outputs
* The output image is an image of vectors that must be understood as ODFs:
* \code
* Image< Vector< TPixelType, OdfNrDirections >, 3 >
* \endcode
*
* \par Parameters
* \li Threshold - Threshold on the reference image data. The output ODF will
* be a null pdf for pixels in the reference image that have a value less
* than this.
* \li BValue - See the documentation of SetBValue().
* \li At least 6 gradient images must be specified for the filter to be able
* to run. If the input gradient directions g_i are majorly sampled on one half
* of the sqhere, then each input image I_i will be duplicated and assign -g_i
* in order to guarantee stability of the Tuch-Algorithm.
* \li OdfDirections - directions of resulting orientation distribution function
* \li EquatorNrSamplingPoints - number of sampling points on equator when
* performing Funk Radeon Transform (FRT)
* \li BasisFunctionCenters - the centers of the basis functions are used for
* the sRBF (spherical radial basis functions interpolation). If not set, they
* will be defaulted to equal m_EquatorNrSamplingPoints
*
* \par Template parameters
* The class is templated over
* \li the pixel type of the reference and gradient images
* (expected to be scalar data types)
* \li the internal representation of the ODF pixels (double, float etc).
* \li the number of OdfDirections
* \li the number of basis function centers for the sRBF
*
* \par References:
* \li<a href="http://www3.interscience.wiley.com/cgi-bin/fulltext/109800293/PDFSTART">[1]</a>
* <em>Tuch DS,
* "Q-ball imaging", Magn Reson Med. 2004 Dec;52(6):1358-72.</em>
*
*/
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters = NrOdfDirections>
class DiffusionQballReconstructionImageFilter :
public ImageToImageFilter< Image< TReferenceImagePixelType, 3 >,
Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > >
{
public:
/** \class DiffusionQballReconstructionImageFilter
* \brief This enum defines the normalization of the ODFs.
* \par
* Standard normalization simply divides by sum of ODF-values
* to ensure properties of a probability density function.
* \par
* B-zero/b-value normalization is ADC-style log of ratio
* between b-zero and b_i normalized by b-value.
* \par
* B-zero normalization simply divides by b-zero reference value
*/
enum Normalization {
QBR_STANDARD,
QBR_B_ZERO_B_VALUE,
QBR_B_ZERO,
QBR_NONE
};
typedef DiffusionQballReconstructionImageFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< TReferenceImagePixelType, 3>,
Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > >
Superclass;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Runtime information support. */
itkTypeMacro(DiffusionQballReconstructionImageFilter,
ImageToImageFilter);
typedef TReferenceImagePixelType ReferencePixelType;
typedef TGradientImagePixelType GradientPixelType;
typedef Vector< TOdfPixelType, NrOdfDirections >
OdfPixelType;
/** Reference image data, This image is aquired in the absence
* of a diffusion sensitizing field gradient */
typedef typename Superclass::InputImageType ReferenceImageType;
typedef Image< OdfPixelType, 3 > OdfImageType;
typedef OdfImageType OutputImageType;
typedef TOdfPixelType BZeroPixelType;
typedef Image< BZeroPixelType, 3 > BZeroImageType;
typedef typename Superclass::OutputImageRegionType
OutputImageRegionType;
/** Typedef defining one (of the many) gradient images. */
typedef Image< GradientPixelType, 3 > GradientImageType;
/** An alternative typedef defining one (of the many) gradient images.
* It will be assumed that the vectorImage has the same dimension as the
* Reference image and a vector length parameter of \c n (number of
* gradient directions)*/
typedef VectorImage< GradientPixelType, 3 > GradientImagesType;
/** Holds the ODF reconstruction matrix */
typedef vnl_matrix< TOdfPixelType >*
OdfReconstructionMatrixType;
/** Holds each magnetic field gradient used to acquire one DWImage */
typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
/** Container to hold gradient directions of the 'n' DW measurements */
typedef VectorContainer< unsigned int,
GradientDirectionType > GradientDirectionContainerType;
itkStaticConstMacro(NOdfDirections,int,NrOdfDirections);
itkStaticConstMacro(NBasisFunctionCenters,int,NrBasisFunctionCenters);
/** Set method to add a gradient direction and its corresponding image. */
void AddGradientImage( const GradientDirectionType &, const GradientImageType *image);
/** Another set method to add a gradient directions and its corresponding
* image. The image here is a VectorImage. The user is expected to pass the
* gradient directions in a container. The ith element of the container
* corresponds to the gradient direction of the ith component image the
* VectorImage. For the baseline image, a vector of all zeros
* should be set.*/
void SetGradientImage( GradientDirectionContainerType *,
const GradientImagesType *image);
/** Set method to set the reference image. */
void SetReferenceImage( ReferenceImageType *referenceImage )
{
if( m_GradientImageTypeEnumeration == GradientIsInASingleImage)
{
itkExceptionMacro( << "Cannot call both methods:"
<< "AddGradientImage and SetGradientImage. Please call only one of them.");
}
this->ProcessObject::SetNthInput( 0, referenceImage );
m_GradientImageTypeEnumeration = GradientIsInManyImages;
}
/** Get reference image */
virtual ReferenceImageType * GetReferenceImage()
{ return ( static_cast< ReferenceImageType *>(this->ProcessObject::GetInput(0)) ); }
/** Return the gradient direction. idx is 0 based */
virtual GradientDirectionType GetGradientDirection( unsigned int idx) const
{
if( idx >= m_NumberOfGradientDirections )
{
itkExceptionMacro( << "Gradient direction " << idx << "does not exist" );
}
return m_GradientDirectionContainer->ElementAt( idx+1 );
}
/** Normalization performed on the reconstructed ODF according
* to method set in m_NormalizationMethod
*/
OdfPixelType Normalize(OdfPixelType odf, typename NumericTraits<ReferencePixelType>::AccumulateType b0 );
/** Normalization performed on diffusion signal vector according
* to method set in m_NormalizationMethod
*/
vnl_vector<TOdfPixelType> PreNormalize( vnl_vector<TOdfPixelType> vec );
/** Threshold on the reference image data. The output ODF will be a null
* pdf for pixels in the reference image that have a value less than this
* threshold. */
itkSetMacro( Threshold, ReferencePixelType );
itkGetMacro( Threshold, ReferencePixelType );
/** Normalization applied to ODFs */
itkSetMacro( NormalizationMethod, Normalization);
itkGetMacro( NormalizationMethod, Normalization );
/** Output image with b-zero weighted images */
itkGetMacro( BZeroImage, typename BZeroImageType::Pointer);
/** B-value used to acquire the diffusion signal */
itkSetMacro( BValue, TOdfPixelType);
#ifdef GetBValue
#undef GetBValue
#endif
itkGetConstReferenceMacro( BValue, TOdfPixelType);
#ifdef ITK_USE_CONCEPT_CHECKING
/** Begin concept checking */
itkConceptMacro(ReferenceEqualityComparableCheck,
(Concept::EqualityComparable<ReferencePixelType>));
itkConceptMacro(TensorEqualityComparableCheck,
(Concept::EqualityComparable<OdfPixelType>));
itkConceptMacro(GradientConvertibleToDoubleCheck,
(Concept::Convertible<GradientPixelType, double>));
itkConceptMacro(DoubleConvertibleToTensorCheck,
(Concept::Convertible<double, OdfPixelType>));
itkConceptMacro(GradientReferenceAdditiveOperatorsCheck,
(Concept::AdditiveOperators<GradientPixelType, GradientPixelType,
ReferencePixelType>));
itkConceptMacro(ReferenceOStreamWritableCheck,
(Concept::OStreamWritable<ReferencePixelType>));
itkConceptMacro(TensorOStreamWritableCheck,
(Concept::OStreamWritable<OdfPixelType>));
/** End concept checking */
#endif
protected:
DiffusionQballReconstructionImageFilter();
~DiffusionQballReconstructionImageFilter() {};
void PrintSelf(std::ostream& os, Indent indent) const;
/** constructs reconstrion matrix according to Tuch's algorithm */
void ComputeReconstructionMatrix();
void BeforeThreadedGenerateData();
void ThreadedGenerateData( const
- OutputImageRegionType &outputRegionForThread, int);
+ OutputImageRegionType &outputRegionForThread, ThreadIdType);
/** enum to indicate if the gradient image is specified as a single multi-
* component image or as several separate images */
typedef enum
{
GradientIsInASingleImage = 1,
GradientIsInManyImages,
Else
} GradientImageTypeEnumeration;
private:
/* Tensor basis coeffs */
OdfReconstructionMatrixType m_ReconstructionMatrix;
/** container to hold gradient directions */
GradientDirectionContainerType::Pointer m_GradientDirectionContainer;
/** Number of gradient measurements */
unsigned int m_NumberOfGradientDirections;
/** Number of Equator Sampling Points (StdValue sqrt(8*pi*NGradDirs)) */
unsigned int m_NumberOfEquatorSamplingPoints;
/** Number of baseline images */
unsigned int m_NumberOfBaselineImages;
/** Threshold on the reference image data */
ReferencePixelType m_Threshold;
/** LeBihan's b-value for normalizing tensors */
TOdfPixelType m_BValue;
/** Gradient image was specified in a single image or in multiple images */
GradientImageTypeEnumeration m_GradientImageTypeEnumeration;
/** Output of b-zero reference image */
typename BZeroImageType::Pointer m_BZeroImage;
/** Flag wether half shell was duplicated to ensure evenly
* distributed directions on the sphere
*/
bool m_DirectionsDuplicated;
/** Normalization method to be applied */
Normalization m_NormalizationMethod;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDiffusionQballReconstructionImageFilter.txx"
#endif
#endif //__itkDiffusionQballReconstructionImageFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.txx
index 6555237575..3b0c9bb7eb 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.txx
@@ -1,850 +1,850 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkDiffusionQballReconstructionImageFilter_txx
#define __itkDiffusionQballReconstructionImageFilter_txx
#include "itkDiffusionQballReconstructionImageFilter.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkImageRegionIterator.h"
#include "itkArray.h"
#include "vnl/vnl_vector.h"
#include "itkPointShell.h"
#define _USE_MATH_DEFINES
#include <math.h>
namespace itk {
#define QBALL_RECON_PI M_PI
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters>
DiffusionQballReconstructionImageFilter< TReferenceImagePixelType,
TGradientImagePixelType, TOdfPixelType, NrOdfDirections,
NrBasisFunctionCenters>
::DiffusionQballReconstructionImageFilter() :
m_GradientDirectionContainer(NULL),
m_NumberOfGradientDirections(0),
m_NumberOfEquatorSamplingPoints(0),
m_NumberOfBaselineImages(1),
m_Threshold(NumericTraits< ReferencePixelType >::NonpositiveMin()),
m_BValue(1.0),
m_GradientImageTypeEnumeration(Else),
m_DirectionsDuplicated(false)
{
// At least 1 inputs is necessary for a vector image.
// For images added one at a time we need at least six
this->SetNumberOfRequiredInputs( 1 );
}
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters>
void DiffusionQballReconstructionImageFilter< TReferenceImagePixelType,
TGradientImagePixelType, TOdfPixelType, NrOdfDirections,
NrBasisFunctionCenters>
::BeforeThreadedGenerateData()
{
// If we have more than 2 inputs, then each input, except the first is a
// gradient image. The number of gradient images must match the number of
// gradient directions.
const unsigned int numberOfInputs = this->GetNumberOfInputs();
// There need to be at least 6 gradient directions to be able to compute the
// tensor basis
if( m_NumberOfGradientDirections < 1 )
{
itkExceptionMacro( << "Your image contains no diffusion gradients!" );
}
// If there is only 1 gradient image, it must be an itk::VectorImage. Otherwise
// we must have a container of (numberOfInputs-1) itk::Image. Check to make sure
if ( numberOfInputs == 1
&& m_GradientImageTypeEnumeration != GradientIsInASingleImage )
{
std::string gradientImageClassName(
this->ProcessObject::GetInput(0)->GetNameOfClass());
if ( strcmp(gradientImageClassName.c_str(),"VectorImage") != 0 )
{
itkExceptionMacro( <<
"There is only one Gradient image. I expect that to be a VectorImage. "
<< "But its of type: " << gradientImageClassName );
}
}
// Compute reconstruction matrix that is multiplied to the data-vector
// each voxel in order to reconstruct the ODFs
this->ComputeReconstructionMatrix();
// Allocate the b-zero image
m_BZeroImage = BZeroImageType::New();
if( m_GradientImageTypeEnumeration == GradientIsInManyImages )
{
typename ReferenceImageType::Pointer img = static_cast< ReferenceImageType * >(this->ProcessObject::GetInput(0));
m_BZeroImage->SetSpacing( img->GetSpacing() ); // Set the image spacing
m_BZeroImage->SetOrigin( img->GetOrigin() ); // Set the image origin
m_BZeroImage->SetDirection( img->GetDirection() ); // Set the image direction
m_BZeroImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
m_BZeroImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
}
// The gradients are specified in a single multi-component image
else if( m_GradientImageTypeEnumeration == GradientIsInASingleImage )
{
typename GradientImagesType::Pointer img = static_cast< GradientImagesType * >(
this->ProcessObject::GetInput(0) );
m_BZeroImage->SetSpacing( img->GetSpacing() ); // Set the image spacing
m_BZeroImage->SetOrigin( img->GetOrigin() ); // Set the image origin
m_BZeroImage->SetDirection( img->GetDirection() ); // Set the image direction
m_BZeroImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
m_BZeroImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
}
m_BZeroImage->Allocate();
}
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters>
typename itk::DiffusionQballReconstructionImageFilter<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType, NrOdfDirections, NrBasisFunctionCenters>::OdfPixelType
itk::DiffusionQballReconstructionImageFilter<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType, NrOdfDirections, NrBasisFunctionCenters>::Normalize( OdfPixelType odf, typename NumericTraits<ReferencePixelType>::AccumulateType b0 )
{
switch( m_NormalizationMethod )
{
// divide by sum to retreive a PDF
case QBR_STANDARD:
{
odf.Normalize();
return odf;
break;
}
// ADC style
case QBR_B_ZERO_B_VALUE:
{
for(int i=0; i<NrOdfDirections; i++)
{
odf[i] = ((TOdfPixelType)log((TOdfPixelType)b0)-odf[i])/m_BValue;
}
return odf;
break;
}
// divide by b-zero value of voxel
case QBR_B_ZERO:
{
odf *= 1.0/b0;
return odf;
break;
}
// no normalization of ODF
case QBR_NONE:
{
return odf;
break;
}
}
return odf;
}
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters >
vnl_vector<TOdfPixelType> itk::DiffusionQballReconstructionImageFilter<TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType, NrOdfDirections, NrBasisFunctionCenters>::PreNormalize( vnl_vector<TOdfPixelType> vec )
{
switch( m_NormalizationMethod )
{
// standard: no normalization before reconstruction
case QBR_STANDARD:
{
return vec;
break;
}
// log of signal
case QBR_B_ZERO_B_VALUE:
{
int n = vec.size();
for(int i=0; i<n; i++)
{
vec[i] = log(vec[i]);
}
return vec;
break;
}
// no normalization before reconstruction here
case QBR_B_ZERO:
{
return vec;
break;
}
// no normalization before reconstruction here
case QBR_NONE:
{
return vec;
break;
}
}
return vec;
}
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters>
void DiffusionQballReconstructionImageFilter< TReferenceImagePixelType,
TGradientImagePixelType, TOdfPixelType, NrOdfDirections,
NrBasisFunctionCenters>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int )
+ ThreadIdType )
{
// init output and b-zero iterators
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
oit.GoToBegin();
ImageRegionIterator< BZeroImageType > oit2(m_BZeroImage, outputRegionForThread);
oit2.GoToBegin();
vnl_vector<TOdfPixelType> B(m_NumberOfGradientDirections);
// Two cases here:
// 1. Gradients specified in multiple images
// 'n' iterators for each of the gradient images
// 2. Gradients specified in a single multi-component image
// one iterator for all gradient directions
if( m_GradientImageTypeEnumeration == GradientIsInManyImages )
{
// b-zero reference image iterator
ImageRegionConstIterator< ReferenceImageType >
it(static_cast< ReferenceImageType * >(this->ProcessObject::GetInput(0)),
outputRegionForThread);
it.GoToBegin();
// fill vector with gradient iterators
typedef ImageRegionConstIterator< GradientImageType > GradientIteratorType;
std::vector< GradientIteratorType * > gradientItContainer;
for( unsigned int i = 1; i<= m_NumberOfGradientDirections; i++ )
{
// adapt index in case we have a duplicated shell
int index = i;
if(m_DirectionsDuplicated)
index = i % (m_NumberOfGradientDirections/2);
// init and pushback current input image iterator
typename GradientImageType::Pointer gradientImagePointer = NULL;
// dynamic_cast would be nice, static because of SGI
gradientImagePointer = static_cast< GradientImageType * >(
this->ProcessObject::GetInput(index) );
GradientIteratorType *git = new GradientIteratorType(
gradientImagePointer, outputRegionForThread );
git->GoToBegin();
gradientItContainer.push_back(git);
}
// Following loop does the actual reconstruction work in each voxel
// (Tuch, Q-Ball Reconstruction [1])
while( !it.IsAtEnd() )
{
// b-zero reference value
ReferencePixelType b0 = it.Get();
// init ODF
OdfPixelType odf(0.0);
// threshold on reference value to suppress noisy regions
if( (b0 != 0) && (b0 >= m_Threshold) )
{
// fill array of diffusion measurements
for( unsigned int i = 0; i< m_NumberOfGradientDirections; i++ )
{
GradientPixelType b = gradientItContainer[i]->Get();
B[i] = static_cast<TOdfPixelType>(b);
++(*gradientItContainer[i]);
}
// pre-normalization according to m_NormalizationMethod
B = PreNormalize(B);
// actual reconstruction
odf = ( (*m_ReconstructionMatrix) * B ).data_block();
// post-normalization according to m_NormalizationMethod
odf.Normalize();
}
else
{
// in case we fall below threshold, we just increment to next voxel
for( unsigned int i = 0; i< m_NumberOfGradientDirections; i++ )
{
++(*gradientItContainer[i]);
}
}
for (int i=0; i<odf.Size(); i++)
if (odf.GetElement(i)!=odf.GetElement(i))
odf.Fill(0.0);
// set and increment output iterators
oit.Set( odf );
++oit;
oit2.Set( b0 );
++oit2;
++it;
}
// clean up
for( unsigned int i = 0; i< gradientItContainer.size(); i++ )
{
delete gradientItContainer[i];
}
}
// The gradients are specified in a single multi-component image
else if( m_GradientImageTypeEnumeration == GradientIsInASingleImage )
{
// init input iterator
typedef ImageRegionConstIterator< GradientImagesType > GradientIteratorType;
typedef typename GradientImagesType::PixelType GradientVectorType;
typename GradientImagesType::Pointer gradientImagePointer = NULL;
// dynamic_cast would be nice, static because of SGI
gradientImagePointer = static_cast< GradientImagesType * >(
this->ProcessObject::GetInput(0) );
GradientIteratorType git(gradientImagePointer, outputRegionForThread );
git.GoToBegin();
// set of indicies each for the baseline images and gradient images
std::vector<unsigned int> baselineind; // contains baseline indicies
std::vector<unsigned int> gradientind; // contains gradient indicies
for(GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
gdcit != this->m_GradientDirectionContainer->End(); ++gdcit)
{
if(gdcit.Value().one_norm() <= 0.0)
{
baselineind.push_back(gdcit.Index());
}
else
{
gradientind.push_back(gdcit.Index());
}
}
// in case we have a duplicated shell, we also duplicate or indices
if( m_DirectionsDuplicated )
{
int gradIndSize = gradientind.size();
for(int i=0; i<gradIndSize; i++)
gradientind.push_back(gradientind[i]);
}
// Following loop does the actual reconstruction work in each voxel
// (Tuch, Q-Ball Reconstruction [1])
while( !git.IsAtEnd() )
{
// current vector of diffusion measurements
GradientVectorType b = git.Get();
// average of current b-zero reference values
typename NumericTraits<ReferencePixelType>::AccumulateType b0 = NumericTraits<ReferencePixelType>::Zero;
for(unsigned int i = 0; i < baselineind.size(); ++i)
{
b0 += b[baselineind[i]];
}
b0 /= this->m_NumberOfBaselineImages;
// init resulting ODF
OdfPixelType odf(0.0);
// threshold on reference value to suppress noisy regions
if( (b0 != 0) && (b0 >= m_Threshold) )
{
for( unsigned int i = 0; i< m_NumberOfGradientDirections; i++ )
{
B[i] = static_cast<TOdfPixelType>(b[gradientind[i]]);
}
// pre-normalization according to m_NormalizationMethod
B = PreNormalize(B);
// actual reconstruction
odf = ( (*m_ReconstructionMatrix) * B ).data_block();
// post-normalization according to m_NormalizationMethod
odf = Normalize(odf, b0);
}
for (int i=0; i<odf.Size(); i++)
if (odf.GetElement(i)!=odf.GetElement(i))
odf.Fill(0.0);
// set and increment output iterators
oit.Set( odf );
++oit;
oit2.Set( b0 );
++oit2;
++git; // Gradient image iterator
}
}
std::cout << "One Thread finished reconstruction" << std::endl;
}
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters>
void DiffusionQballReconstructionImageFilter< TReferenceImagePixelType,
TGradientImagePixelType, TOdfPixelType, NrOdfDirections,
NrBasisFunctionCenters>
::ComputeReconstructionMatrix()
{
if( m_NumberOfGradientDirections < 1 )
{
itkExceptionMacro( << "Your image contains no diffusion gradients!" );
}
{
// check for duplicate diffusion gradients
bool warning = false;
for(GradientDirectionContainerType::ConstIterator gdcit1 = this->m_GradientDirectionContainer->Begin();
gdcit1 != this->m_GradientDirectionContainer->End(); ++gdcit1)
{
for(GradientDirectionContainerType::ConstIterator gdcit2 = this->m_GradientDirectionContainer->Begin();
gdcit2 != this->m_GradientDirectionContainer->End(); ++gdcit2)
{
if(gdcit1.Value() == gdcit2.Value() && gdcit1.Index() != gdcit2.Index())
{
itkWarningMacro( << "Some of the Diffusion Gradients equal each other. Corresponding image data should be averaged before calling this filter." );
warning = true;
break;
}
}
if (warning) break;
}
// handle acquisition schemes where only half of the spherical
// shell is sampled by the gradient directions. In this case,
// each gradient direction is duplicated in negative direction.
vnl_vector<double> centerMass(3);
centerMass.fill(0.0);
int count = 0;
for(GradientDirectionContainerType::ConstIterator gdcit1 = this->m_GradientDirectionContainer->Begin();
gdcit1 != this->m_GradientDirectionContainer->End(); ++gdcit1)
{
if(gdcit1.Value().one_norm() > 0.0)
{
centerMass += gdcit1.Value();
count ++;
}
}
centerMass /= count;
if(centerMass.two_norm() > 0.1)
{
m_DirectionsDuplicated = true;
m_NumberOfGradientDirections *= 2;
}
}
// set default number of equator sampling points if needed
if(!this->m_NumberOfEquatorSamplingPoints)
this->m_NumberOfEquatorSamplingPoints
= (int) ceil((double)sqrt(8*QBALL_RECON_PI*this->m_NumberOfGradientDirections));
vnl_matrix<double>* Q =
new vnl_matrix<double>(3, m_NumberOfGradientDirections);
{
// Fill matrix Q with gradient directions
int i = 0;
for(GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
gdcit != this->m_GradientDirectionContainer->End(); ++gdcit)
{
if(gdcit.Value().one_norm() > 0.0)
{
(*Q)(0,i) = gdcit.Value().get(0);
(*Q)(1,i) = gdcit.Value().get(1);
(*Q)(2,i++) = gdcit.Value().get(2);
}
}
if(m_DirectionsDuplicated)
{
for(GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
gdcit != this->m_GradientDirectionContainer->End(); ++gdcit)
{
if(gdcit.Value().one_norm() > 0.0)
{
(*Q)(0,i) = -gdcit.Value().get(0);
(*Q)(1,i) = -gdcit.Value().get(1);
(*Q)(2,i++) = -gdcit.Value().get(2);
}
}
}
}
vnl_matrix_fixed<double, 3, NOdfDirections>* U =
itk::PointShell<NOdfDirections, vnl_matrix_fixed<double, 3, NOdfDirections> >::DistributePointShell();
vnl_matrix_fixed<double, 3, NBasisFunctionCenters>* V =
itk::PointShell<NBasisFunctionCenters, vnl_matrix_fixed<double, 3, NBasisFunctionCenters> >::DistributePointShell();
// calculate sampling points on the equator perpendicular to z-axis
vnl_matrix<double> *C
= new vnl_matrix<double>(3, m_NumberOfEquatorSamplingPoints);
for(unsigned int i=0; i<m_NumberOfEquatorSamplingPoints; i++)
{
double theta = i * (2*QBALL_RECON_PI / m_NumberOfEquatorSamplingPoints);
(*C)(0,i) = cos(theta);
(*C)(1,i) = sin(theta);
(*C)(2,i) = NumericTraits<double>::Zero;
}
// rotate the sampling points to each directions of interest
vnl_matrix<double> *S
= new vnl_matrix<double>(3,m_NumberOfEquatorSamplingPoints*NOdfDirections);
{
vnl_vector_fixed<double,3> z(NumericTraits<double>::Zero);
z.put(2,NumericTraits<double>::One);
vnl_matrix_fixed<double,3,3> eye(NumericTraits<double>::Zero);
eye.fill_diagonal(NumericTraits<double>::One);
for(int i=0; i<NOdfDirections; i++)
{
vnl_vector_fixed<double,3> ui = (*U).get_column(i);
vnl_matrix<double> *RC
= new vnl_matrix<double>(3,m_NumberOfEquatorSamplingPoints);
if( (z(0)*ui(0)+z(1)*ui(1)+z(2)*ui(2)+1) != 0 )
{
vnl_matrix_fixed<double,3,3> R;
R.set_column(0, (z+ui)*(z(0)+ui(0)));
R.set_column(1, (z+ui)*(z(1)+ui(1)));
R.set_column(2, (z+ui)*(z(2)+ui(2)));
R /= (z(0)*ui(0)+z(1)*ui(1)+z(2)*ui(2)+1);
R -= eye;
(*RC) = R*(*C);
}
else
{
RC = C;
}
(*S).set_columns(i*m_NumberOfEquatorSamplingPoints, *RC);
}
}
// determine interpolation kernel width first
// use to determine diffusion measurement contribution to each of the kernels
vnl_matrix<double> *H_plus
= new vnl_matrix<double>(NBasisFunctionCenters,m_NumberOfGradientDirections);
double maxSigma = QBALL_RECON_PI/6;
double bestSigma = maxSigma;
{
double stepsize = 0.01;
double start = 0.01;
double minCondition = NumericTraits<double>::max();
vnl_matrix<double> *H
= new vnl_matrix<double>(m_NumberOfGradientDirections,NBasisFunctionCenters,(double)0);
{
int increasing = 0;
for( double sigma=start; sigma<maxSigma; sigma+=stepsize)
{
vnl_matrix<double> *tmpH
= new vnl_matrix<double>(m_NumberOfGradientDirections,NBasisFunctionCenters);
for(unsigned int r=0; r<m_NumberOfGradientDirections; r++)
{
for(int c=0; c<NBasisFunctionCenters; c++)
{
double qtv = (*Q)(0,r)*(*V)(0,c)
+ (*Q)(1,r)*(*V)(1,c)
+ (*Q)(2,r)*(*V)(2,c);
qtv = (qtv<-1.0) ? -1.0 : ( (qtv>1.0) ? 1.0 : qtv);
double x = acos(qtv);
(*tmpH)(r,c) = (1.0/(sigma*sqrt(2.0*QBALL_RECON_PI)))
*exp((-x*x)/(2*sigma*sigma));
}
}
vnl_svd<double> *solver;
if(m_NumberOfGradientDirections>NBasisFunctionCenters)
{
solver = new vnl_svd<double>(*tmpH);
}
else
{
solver = new vnl_svd<double>(tmpH->transpose());
}
double condition = solver->sigma_max() / solver->sigma_min();
std::cout << sigma << ": " << condition << std::endl;
if( condition < minCondition )
{
minCondition = condition;
bestSigma = sigma;
H->update(*tmpH);
}
else
{
// optimum assumed to be hit after condition increased 3 times
if (++increasing>3) break;
}
}
}
vnl_matrix_inverse<double> *pseudoInverse
= new vnl_matrix_inverse<double>(*H);
(*H_plus) = pseudoInverse->pinverse();
std::cout << "choosing sigma = " << bestSigma << std::endl;
}
// this is the contribution of each kernel to each sampling point on the
// equator
vnl_matrix<double> *G
= new vnl_matrix<double>(m_NumberOfEquatorSamplingPoints*NOdfDirections,NBasisFunctionCenters);
{
for(unsigned int r=0; r<m_NumberOfEquatorSamplingPoints*NOdfDirections; r++)
{
for(int c=0; c<NBasisFunctionCenters; c++)
{
double stv = (*S)(0,r)*(*V)(0,c)
+ (*S)(1,r)*(*V)(1,c)
+ (*S)(2,r)*(*V)(2,c);
stv = (stv<-1.0) ? -1.0 : ( (stv>1.0) ? 1.0 : stv);
double x = acos(stv);
(*G)(r,c) = (1.0/(bestSigma*sqrt(2.0*QBALL_RECON_PI)))
*exp((-x*x)/(2*bestSigma*bestSigma));
}
}
}
vnl_matrix<double> *GH_plus =
new vnl_matrix<double>(m_NumberOfEquatorSamplingPoints*NOdfDirections,m_NumberOfGradientDirections);
// simple matrix multiplication, manual cause of stack overflow using operator
for (unsigned i = 0; i < m_NumberOfEquatorSamplingPoints*NOdfDirections; ++i)
for (unsigned j = 0; j < m_NumberOfGradientDirections; ++j)
{
double accum = (*G)(i,0) * (*H_plus)(0,j);
for (unsigned k = 1; k < NOdfDirections; ++k)
accum += (*G)(i,k) * (*H_plus)(k,j);
(*GH_plus)(i,j) = accum;
}
typename vnl_matrix<double>::iterator it3;
for( it3 = (*GH_plus).begin(); it3 != (*GH_plus).end(); it3++)
{
if(*it3<0.0)
*it3 = 0;
}
// this is an addition to the original tuch algorithm
for(unsigned int i=0; i<NOdfDirections*m_NumberOfEquatorSamplingPoints; i++)
{
vnl_vector< double > r = GH_plus->get_row(i);
r /= r.sum();
GH_plus->set_row(i,r);
}
m_ReconstructionMatrix
= new vnl_matrix<TOdfPixelType>(NOdfDirections,m_NumberOfGradientDirections,0.0);
for(int i=0; i<NOdfDirections; i++)
{
for(unsigned int j=0; j<m_NumberOfGradientDirections; j++)
{
for(unsigned int k=0; k<m_NumberOfEquatorSamplingPoints; k++)
{
(*m_ReconstructionMatrix)(i,j) += (TOdfPixelType)(*GH_plus)(m_NumberOfEquatorSamplingPoints*i+k,j);
}
}
}
// this is also an addition to the original tuch algorithm
for(int i=0; i<NOdfDirections; i++)
{
vnl_vector< TOdfPixelType > r = m_ReconstructionMatrix->get_row(i);
r /= r.sum();
m_ReconstructionMatrix->set_row(i,r);
}
std::cout << "Reconstruction Matrix computed." << std::endl;
}
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters>
void DiffusionQballReconstructionImageFilter< TReferenceImagePixelType,
TGradientImagePixelType, TOdfPixelType, NrOdfDirections,
NrBasisFunctionCenters>
::AddGradientImage( const GradientDirectionType &gradientDirection,
const GradientImageType *gradientImage )
{
// Make sure crazy users did not call both AddGradientImage and
// SetGradientImage
if( m_GradientImageTypeEnumeration == GradientIsInASingleImage)
{
itkExceptionMacro( << "Cannot call both methods:"
<< "AddGradientImage and SetGradientImage. Please call only one of them.");
}
// If the container to hold the gradient directions hasn't been allocated
// yet, allocate it.
if( !this->m_GradientDirectionContainer )
{
this->m_GradientDirectionContainer = GradientDirectionContainerType::New();
}
this->m_NumberOfGradientDirections = m_GradientDirectionContainer->Size();
m_GradientDirectionContainer->InsertElement( this->m_NumberOfGradientDirections,
gradientDirection / gradientDirection.two_norm() );
this->ProcessObject::SetNthInput( this->m_NumberOfGradientDirections,
const_cast< GradientImageType* >(gradientImage) );
m_GradientImageTypeEnumeration = GradientIsInManyImages;
}
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters>
void DiffusionQballReconstructionImageFilter< TReferenceImagePixelType,
TGradientImagePixelType, TOdfPixelType, NrOdfDirections,
NrBasisFunctionCenters>
::SetGradientImage( GradientDirectionContainerType *gradientDirection,
const GradientImagesType *gradientImage )
{
// Make sure crazy users did not call both AddGradientImage and
// SetGradientImage
if( m_GradientImageTypeEnumeration == GradientIsInManyImages )
{
itkExceptionMacro( << "Cannot call both methods:"
<< "AddGradientImage and SetGradientImage. Please call only one of them.");
}
this->m_GradientDirectionContainer = gradientDirection;
unsigned int numImages = gradientDirection->Size();
this->m_NumberOfBaselineImages = 0;
for(GradientDirectionContainerType::Iterator it = this->m_GradientDirectionContainer->Begin();
it != this->m_GradientDirectionContainer->End(); it++)
{
if(it.Value().one_norm() <= 0.0)
{
this->m_NumberOfBaselineImages++;
}
else // Normalize non-zero gradient directions
{
it.Value() = it.Value() / it.Value().two_norm();
}
}
this->m_NumberOfGradientDirections = numImages - this->m_NumberOfBaselineImages;
// ensure that the gradient image we received has as many components as
// the number of gradient directions
if( gradientImage->GetVectorLength() != this->m_NumberOfBaselineImages + m_NumberOfGradientDirections )
{
itkExceptionMacro( << m_NumberOfGradientDirections << " gradients + " << this->m_NumberOfBaselineImages
<< "baselines = " << m_NumberOfGradientDirections + this->m_NumberOfBaselineImages
<< " directions specified but image has " << gradientImage->GetVectorLength()
<< " components.");
}
this->ProcessObject::SetNthInput( 0,
const_cast< GradientImagesType* >(gradientImage) );
m_GradientImageTypeEnumeration = GradientIsInASingleImage;
}
template< class TReferenceImagePixelType,
class TGradientImagePixelType,
class TOdfPixelType,
int NrOdfDirections,
int NrBasisFunctionCenters>
void DiffusionQballReconstructionImageFilter< TReferenceImagePixelType,
TGradientImagePixelType, TOdfPixelType, NrOdfDirections,
NrBasisFunctionCenters>
::PrintSelf(std::ostream& os, Indent indent) const
{
std::locale C("C");
std::locale originalLocale = os.getloc();
os.imbue(C);
Superclass::PrintSelf(os,indent);
os << indent << "OdfReconstructionMatrix: " << m_ReconstructionMatrix << std::endl;
if ( m_GradientDirectionContainer )
{
os << indent << "GradientDirectionContainer: "
<< m_GradientDirectionContainer << std::endl;
}
else
{
os << indent <<
"GradientDirectionContainer: (Gradient directions not set)" << std::endl;
}
os << indent << "NumberOfGradientDirections: " <<
m_NumberOfGradientDirections << std::endl;
os << indent << "NumberOfBaselineImages: " <<
m_NumberOfBaselineImages << std::endl;
os << indent << "Threshold for reference B0 image: " << m_Threshold << std::endl;
os << indent << "BValue: " << m_BValue << std::endl;
if ( this->m_GradientImageTypeEnumeration == GradientIsInManyImages )
{
os << indent << "Gradient images haven been supplied " << std::endl;
}
else if ( this->m_GradientImageTypeEnumeration == GradientIsInManyImages )
{
os << indent << "A multicomponent gradient image has been supplied" << std::endl;
}
os.imbue( originalLocale );
}
}
#endif // __itkDiffusionQballReconstructionImageFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkMultiShellAdcAverageReconstructionImageFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkMultiShellAdcAverageReconstructionImageFilter.cpp
new file mode 100644
index 0000000000..5b5ec38819
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkMultiShellAdcAverageReconstructionImageFilter.cpp
@@ -0,0 +1,325 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+/*=========================================================================
+
+Program: Tensor ToolKit - TTK
+Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx $
+Language: C++
+Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
+Version: $Revision: 68 $
+
+Copyright (c) INRIA 2010. All rights reserved.
+See LICENSE.txt 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 _itk_MultiShellAdcAverageReconstructionImageFilter_cpp_
+#define _itk_MultiShellAdcAverageReconstructionImageFilter_cpp_
+#endif
+
+#define _USE_MATH_DEFINES
+
+#include "itkMultiShellAdcAverageReconstructionImageFilter.h"
+#include <itkImageRegionIterator.h>
+#include <itkImageRegion.h>
+#include "mitkDiffusionFunctionCollection.h"
+
+namespace itk
+{
+
+template <class TInputScalarType, class TOutputScalarType>
+MultiShellAdcAverageReconstructionImageFilter<TInputScalarType, TOutputScalarType>
+::MultiShellAdcAverageReconstructionImageFilter()
+{
+ this->SetNumberOfRequiredInputs( 1 );
+ // this->SetNumberOfThreads(1);
+}
+
+template <class TInputScalarType, class TOutputScalarType>
+void MultiShellAdcAverageReconstructionImageFilter<TInputScalarType, TOutputScalarType>
+::BeforeThreadedGenerateData()
+{
+
+ // test whether BvalueMap contains all necessary information
+ if(m_B_ValueMap.size() == 0)
+ {
+ itkWarningMacro(<< "No BValueMap given: create one using GradientDirectionContainer");
+
+ GradientDirectionContainerType::ConstIterator gdcit;
+ for( gdcit = m_OriginalGradientDirections->Begin(); gdcit != m_OriginalGradientDirections->End(); ++gdcit)
+ {
+ double bValueKey = int(((m_B_Value * gdcit.Value().two_norm() * gdcit.Value().two_norm())+7.5)/10)*10;
+ m_B_ValueMap[bValueKey].push_back(gdcit.Index());
+ }
+ }
+
+ //# BValueMap contains no bZero --> itkException
+ if(m_B_ValueMap.find(0.0) == m_B_ValueMap.end())
+ {
+ MITK_INFO << "No ReferenceSignal (BZeroImages) found!";
+ itkExceptionMacro(<< "No ReferenceSignal (BZeroImages) found!");
+ }
+
+ // [allDirectionsContainer] Gradient DirectionContainer containing all unique directions
+ m_allDirectionsIndicies = mitk::gradients::GetAllUniqueDirections(m_B_ValueMap, m_OriginalGradientDirections);
+ // [sizeAllDirections] size of GradientContainer cointaining all unique directions
+ m_allDirectionsSize = m_allDirectionsIndicies.size();
+
+ m_TargetGradientDirections = mitk::gradients::CreateNormalizedUniqueGradientDirectionContainer(m_B_ValueMap,m_OriginalGradientDirections);
+
+
+ for(BValueMap::const_iterator it = m_B_ValueMap.begin();it != m_B_ValueMap.end(); it++)
+ {
+ if((*it).first == 0.0) continue;
+ // if any #ShellDirection < 6 --> itkException (No interpolation possible)
+ if((*it).second.size() < 6){
+ MITK_INFO << "Abort: No interpolation possible Shell-" << (*it).first << " has less than 6 directions.";
+ itkExceptionMacro(<<"No interpolation possible");
+ }
+ }
+ m_ShellInterpolationMatrixVector.reserve(m_B_ValueMap.size()-1);
+
+ // for each shell
+ BValueMap::const_iterator it = m_B_ValueMap.begin();
+
+ it++; //skip bZeroIndices
+
+ for(;it != m_B_ValueMap.end();it++)
+ {
+ //- calculate maxShOrder
+ const IndicesVector currentShell = it->second;
+ unsigned int SHMaxOrder = 12;
+ while( ((SHMaxOrder+1)*(SHMaxOrder+2)/2) > currentShell.size() && ((SHMaxOrder+1)*(SHMaxOrder+2)/2) >= 4 )
+ {
+ SHMaxOrder -= 2 ;
+ }
+ //- get TragetSHBasis using allDirectionsContainer
+ vnl_matrix<double> sphericalCoordinates;
+ sphericalCoordinates = mitk::gradients::ComputeSphericalFromCartesian(m_allDirectionsIndicies, m_OriginalGradientDirections);
+ vnl_matrix<double> TargetSHBasis = mitk::gradients::ComputeSphericalHarmonicsBasis(sphericalCoordinates, SHMaxOrder);
+ //MITK_INFO << "TargetSHBasis " << TargetSHBasis.rows() << " x " << TargetSHBasis.cols();
+ //- get ShellSHBasis using currentShellDirections
+ sphericalCoordinates = mitk::gradients::ComputeSphericalFromCartesian(currentShell, m_OriginalGradientDirections);
+ vnl_matrix<double> ShellSHBasis = mitk::gradients::ComputeSphericalHarmonicsBasis(sphericalCoordinates, SHMaxOrder);
+ //MITK_INFO << "ShellSHBasis " << ShellSHBasis.rows() << " x " << ShellSHBasis.cols();
+ //- calculate interpolationSHBasis [TargetSHBasis * ShellSHBasis^-1]
+ vnl_matrix_inverse<double> invShellSHBasis(ShellSHBasis);
+ vnl_matrix<double> shellInterpolationMatrix = TargetSHBasis * invShellSHBasis.pinverse();
+ //MITK_INFO << "shellInterpolationMatrix " << shellInterpolationMatrix.rows() << " x " << shellInterpolationMatrix.cols();
+ //- save interpolationSHBasis
+ m_ShellInterpolationMatrixVector.push_back(shellInterpolationMatrix);
+
+ }
+
+ m_WeightsVector.reserve(m_B_ValueMap.size()-1);
+ BValueMap::const_iterator itt = m_B_ValueMap.begin();
+ itt++; // skip ReferenceImages
+ //- calculate Weights [Weigthing = shell_size / max_shell_size]
+ unsigned int maxShellSize = 0;
+ for(;itt != m_B_ValueMap.end(); itt++){
+ if(itt->second.size() > maxShellSize)
+ maxShellSize = itt->second.size();
+ }
+ itt = m_B_ValueMap.begin();
+ itt++; // skip ReferenceImages
+ for(;itt != m_B_ValueMap.end(); itt++){
+ m_WeightsVector.push_back(itt->second.size() / (double)maxShellSize);
+ MITK_INFO << m_WeightsVector.back();
+ }
+
+
+ // initialize output image
+ typename OutputImageType::Pointer outImage = static_cast<OutputImageType * >(ProcessObject::GetOutput(0));
+ //outImage = OutputImageType::New();
+ outImage->SetSpacing( this->GetInput()->GetSpacing() );
+ outImage->SetOrigin( this->GetInput()->GetOrigin() );
+ outImage->SetDirection( this->GetInput()->GetDirection() ); // Set the image direction using bZeroDirection+AllDirectionsContainer
+ outImage->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion());
+ outImage->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
+ outImage->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
+ outImage->SetVectorLength( 1+m_allDirectionsSize ); // size of 1(bzeroValue) + AllDirectionsContainer
+ outImage->Allocate();
+
+ BValueMap::iterator ittt = m_B_ValueMap.begin();
+ ittt++; // skip bZeroImages corresponding to 0-bValue
+ m_TargetB_Value = 0;
+ while(ittt!=m_B_ValueMap.end())
+ {
+ m_TargetB_Value += ittt->first;
+ ittt++;
+ }
+ m_TargetB_Value /= (double)(m_B_ValueMap.size()-1);
+
+
+ MITK_INFO << "Input:" << std::endl << std::endl
+ << " GradientDirections: " << m_OriginalGradientDirections->Size() << std::endl
+ << " Shells: " << (m_B_ValueMap.size() - 1) << std::endl
+ << " ReferenceImages: " << m_B_ValueMap[0.0].size() << std::endl;
+
+ MITK_INFO << "Output:" << std::endl << std::endl
+ << " OutImageVectorLength: " << outImage->GetVectorLength() << std::endl
+ << " TargetDirections: " << m_allDirectionsSize << std::endl
+ << " TargetBValue: " << m_TargetB_Value << std::endl
+ << std::endl;
+
+}
+
+template <class TInputScalarType, class TOutputScalarType>
+void
+MultiShellAdcAverageReconstructionImageFilter<TInputScalarType, TOutputScalarType>
+::ThreadedGenerateData(const OutputImageRegionType &outputRegionForThread, ThreadIdType /*threadId*/)
+{
+
+ // Get input gradient image pointer
+ typename InputImageType::Pointer inputImage = static_cast< InputImageType * >(ProcessObject::GetInput(0));
+ // ImageRegionIterator for the input image
+ ImageRegionIterator< InputImageType > iit(inputImage, outputRegionForThread);
+ iit.GoToBegin();
+
+ // Get output gradient image pointer
+ typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(ProcessObject::GetOutput(0));
+ // ImageRegionIterator for the output image
+ ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
+ oit.GoToBegin();
+
+ // calculate target bZero-Value [b0_t]
+ const IndicesVector BZeroIndices = m_B_ValueMap[0.0];
+ double BZeroAverage = 0.0;
+
+ // create empty nxm SignalMatrix containing n->signals/directions (in case of interpolation ~ sizeAllDirections otherwise the size of any shell) for m->shells
+ vnl_matrix<double> SignalMatrix(m_allDirectionsSize, m_B_ValueMap.size()-1);
+ // create nx1 targetSignalVector
+ vnl_vector<double> SignalVector(m_allDirectionsSize);
+
+
+ // ** walking over each Voxel
+ while(!iit.IsAtEnd())
+ {
+ InputPixelType b = iit.Get();
+ BZeroAverage=0.0;
+ for(unsigned int i = 0 ; i < BZeroIndices.size(); i++){
+ //MITK_INFO << "BValues("<<i<<")"<< b[BZeroIndices[i]];
+ BZeroAverage += b[BZeroIndices[i]];
+ }
+ BZeroAverage /= (double)BZeroIndices.size();
+ //MITK_INFO << "BValues(average)"<< BZeroAverage ;
+
+ OutputPixelType out = oit.Get();
+ out.Fill(0.0);
+ out.SetElement(0,BZeroAverage);
+
+ BValueMap::const_iterator shellIterator = m_B_ValueMap.begin();
+ shellIterator++; //skip bZeroImages
+ unsigned int shellIndex = 0;
+
+ while(shellIterator != m_B_ValueMap.end())
+ {
+ // reset Data
+ SignalVector.fill(0.0);
+
+ // - get the RawSignal
+ const IndicesVector currentShell = shellIterator->second;
+ vnl_vector<double> InterpVector(currentShell.size());
+
+ // - get raw Signal for currente shell
+ for(unsigned int i = 0 ; i < currentShell.size(); i++)
+ InterpVector.put(i,b[currentShell[i]]);
+ //MITK_INFO << "InputVector(RAWSIGNAL:"<< shellIndex <<")";
+ //MITK_INFO << InterpVector ;
+ //- normalization of the raw Signal divided by Reference Signal
+ S_S0Normalization(InterpVector, BZeroAverage);
+
+ //MITK_INFO << "InputVector(NORMALIZED:"<< shellIndex <<")";
+ //MITK_INFO << InterpVector ;
+ //- interpolate the Signal if necessary using corresponding interpolationSHBasis
+
+ SignalVector = m_ShellInterpolationMatrixVector.at(shellIndex) * InterpVector;
+
+ //MITK_INFO << "SignalVector(NORMALIZED:"<< shellIndex <<")";
+ //MITK_INFO << SignalVector ;
+
+ // - ADC calculation for the signalVector
+ calculateAdcFromSignal(SignalVector, shellIterator->first);
+ //MITK_INFO << "SignalVector(SIGNaL->ADC:"<< shellIndex <<")";
+ //MITK_INFO << SignalVector ;
+
+ //- weight the signal
+ SignalVector *= m_WeightsVector.at(shellIndex);
+
+ //- save the (interpolated) ShellSignalVector as the ith column in the SignalMatrix
+ SignalMatrix.set_column(shellIndex, SignalVector);
+
+ shellIterator++;
+ shellIndex++;
+
+ }
+ // ADC averaging Sum(ADC)/n
+ for(unsigned int i = 0 ; i < SignalMatrix.rows(); i++)
+ SignalVector.put(i,SignalMatrix.get_row(i).sum());
+ SignalVector/= (double)(m_B_ValueMap.size()-1);
+ //MITK_INFO << "SignalVector(AVERAGEDADC)";
+ //MITK_INFO << SignalVector ;
+
+ // recalculate signal from ADC
+ calculateSignalFromAdc(SignalVector, m_TargetB_Value, BZeroAverage);
+ //MITK_INFO << "SignalVector(ADC->SIGNAL)";
+ //MITK_INFO << SignalVector ;
+
+ for(unsigned int i = 1 ; i < out.Size(); i ++)
+ out.SetElement(i,SignalVector.get(i-1));
+
+ //MITK_INFO << "NewSignal: " << out;
+ //MITK_INFO << "-------------";
+ oit.Set(out);
+ ++oit;
+ ++iit;
+ }
+}
+template <class TInputScalarType, class TOutputScalarType>
+void MultiShellAdcAverageReconstructionImageFilter<TInputScalarType, TOutputScalarType>
+::S_S0Normalization( vnl_vector<double> & vec, const double & S0 )
+{
+ for(unsigned int i = 0; i < vec.size(); i++){
+ vec[i] /= S0;
+ if(vec[i]>1.0) vec[i] = 1;
+ if(vec[i]<0.0) vec[i] = 0;
+ }
+}
+
+template <class TInputScalarType, class TOutputScalarType>
+void MultiShellAdcAverageReconstructionImageFilter<TInputScalarType, TOutputScalarType>
+::calculateAdcFromSignal( vnl_vector<double> & vec, const double & bValue)
+{
+ for(unsigned int i = 0; i < vec.size(); i++)
+ vec[i] = log(vec[i])/-bValue;
+}
+
+template <class TInputScalarType, class TOutputScalarType>
+void MultiShellAdcAverageReconstructionImageFilter<TInputScalarType, TOutputScalarType>
+::calculateSignalFromAdc(vnl_vector<double> & vec, const double & bValue, const double & referenceSignal)
+{
+ for(unsigned int i = 0 ; i < vec.size(); i++){
+ //MITK_INFO << vec[i];
+ //MITK_INFO << bValue;
+ //MITK_INFO << referenceSignal;
+ vec[i] = referenceSignal * exp((-bValue) * vec[i]);
+ }
+}
+
+} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkMultiShellAdcAverageReconstructionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkMultiShellAdcAverageReconstructionImageFilter.h
new file mode 100644
index 0000000000..fc641277ef
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkMultiShellAdcAverageReconstructionImageFilter.h
@@ -0,0 +1,119 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef _itk_MultiShellAdcAverageReconstructionImageFilter_h_
+#define _itk_MultiShellAdcAverageReconstructionImageFilter_h_
+
+#include <itkImageToImageFilter.h>
+#include <itkVectorImage.h>
+#include <itkPointShell.h>
+
+namespace itk
+{
+
+/**
+* \brief Select subset of the input vectors equally distributed over the sphere using an iterative electrostatic repulsion strategy. */
+
+ template <class TInputScalarType, class TOutputScalarType>
+ class MultiShellAdcAverageReconstructionImageFilter
+ : public ImageToImageFilter<itk::VectorImage<TInputScalarType,3>, itk::VectorImage<TOutputScalarType,3> >
+ {
+
+ public:
+
+ typedef MultiShellAdcAverageReconstructionImageFilter Self;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+ typedef ImageToImageFilter< itk::VectorImage<TInputScalarType,3>, itk::VectorImage<TOutputScalarType,3> > Superclass;
+ typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self)
+
+ /** Runtime information support. */
+ itkTypeMacro(MultiShellAdcAverageReconstructionImageFilter, ImageToImageFilter)
+
+ typedef TInputScalarType InputScalarType;
+ typedef itk::VectorImage<InputScalarType,3> InputImageType;
+ typedef typename InputImageType::PixelType InputPixelType;
+
+ typedef TOutputScalarType OutputScalarType;
+ typedef itk::VectorImage<OutputScalarType,3> OutputImageType;
+ typedef typename OutputImageType::PixelType OutputPixelType;
+
+ typedef OutputScalarType BaselineScalarType;
+ typedef BaselineScalarType BaselinePixelType;
+ typedef typename itk::Image<BaselinePixelType,3> BaselineImageType;
+
+ typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
+ typedef itk::VectorContainer< unsigned int, GradientDirectionType > GradientDirectionContainerType;
+
+ typedef std::vector<unsigned int> IndicesVector;
+ typedef std::map<double, IndicesVector> BValueMap;
+
+ GradientDirectionContainerType::Pointer GetOriginalGradientDirections(){return m_OriginalGradientDirections;}
+ void SetOriginalGradientDirections(GradientDirectionContainerType::Pointer ptr){m_OriginalGradientDirections = ptr;}
+
+ GradientDirectionContainerType::Pointer GetTargetGradientDirections(){return m_TargetGradientDirections;}
+
+ double GetTargetB_Value(){return m_TargetB_Value;}
+
+ double GetB_Value(){return m_B_Value;}
+ void SetB_Value(double val){m_B_Value = val;}
+
+ void SetOriginalBValueMap(BValueMap inp){m_B_ValueMap = inp;}
+
+ protected:
+ MultiShellAdcAverageReconstructionImageFilter();
+ ~MultiShellAdcAverageReconstructionImageFilter() {}
+
+ void BeforeThreadedGenerateData();
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType NumberOfThreads );
+ void S_S0Normalization( vnl_vector<double> & vec, const double & S0 );
+ void calculateAdcFromSignal( vnl_vector<double> & vec, const double & bValue);
+ void calculateSignalFromAdc( vnl_vector<double> & vec, const double & bValue, const double & referenceSignal);
+
+
+
+ GradientDirectionContainerType::Pointer m_TargetGradientDirections; ///< container for the subsampled output gradient directions
+ GradientDirectionContainerType::Pointer m_OriginalGradientDirections; ///< input gradient directions
+
+ BValueMap m_B_ValueMap;
+ double m_B_Value;
+
+ double m_TargetB_Value;
+
+ std::vector<double> m_WeightsVector;
+
+ std::vector<vnl_matrix< double > > m_ShellInterpolationMatrixVector;
+ std::vector<IndicesVector> m_bZeroIndicesSplitVectors;
+
+ IndicesVector m_allDirectionsIndicies;
+
+ unsigned int m_allDirectionsSize;
+
+ };
+
+
+} // end of namespace
+
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkMultiShellAdcAverageReconstructionImageFilter.cpp"
+#endif
+
+
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h
new file mode 100644
index 0000000000..cfcc797652
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h
@@ -0,0 +1,79 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+/*===================================================================
+
+This file is based heavily on a corresponding ITK filter.
+
+===================================================================*/
+#ifndef __itkAdcImageFilter_h_
+#define __itkAdcImageFilter_h_
+
+#include "itkImageToImageFilter.h"
+#include "itkVectorImage.h"
+#include <mitkDiffusionImage.h>
+
+namespace itk{
+/** \class AdcImageFilter
+ */
+
+template< class TInPixelType, class TOutPixelType >
+class AdcImageFilter :
+ public ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TOutPixelType, 3 > >
+{
+
+public:
+
+ typedef AdcImageFilter Self;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+ typedef ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TOutPixelType, 3 > > Superclass;
+ typedef mitk::DiffusionImage< short >::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionImage< short >::GradientDirectionContainerType::Pointer GradientContainerType;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self)
+
+ /** Runtime information support. */
+ itkTypeMacro(AdcImageFilter, ImageToImageFilter)
+
+ typedef typename Superclass::InputImageType InputImageType;
+ typedef typename Superclass::OutputImageType OutputImageType;
+ typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
+
+ itkSetMacro( B_value, double )
+ itkSetMacro( GradientDirections, GradientContainerType )
+
+ protected:
+ AdcImageFilter();
+ ~AdcImageFilter() {}
+ void PrintSelf(std::ostream& os, Indent indent) const;
+
+ void BeforeThreadedGenerateData();
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType);
+
+ double m_B_value;
+ GradientContainerType m_GradientDirections;
+};
+
+}
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkAdcImageFilter.txx"
+#endif
+
+#endif //__itkAdcImageFilter_h_
+
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.txx
new file mode 100644
index 0000000000..9b205df5ad
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.txx
@@ -0,0 +1,130 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __itkAdcImageFilter_txx
+#define __itkAdcImageFilter_txx
+
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "itkImageRegionConstIterator.h"
+#include "itkImageRegionConstIteratorWithIndex.h"
+#include "itkImageRegionIterator.h"
+
+namespace itk {
+
+
+template< class TInPixelType, class TOutPixelType >
+AdcImageFilter< TInPixelType, TOutPixelType>
+::AdcImageFilter()
+{
+ this->SetNumberOfRequiredInputs( 1 );
+}
+
+template< class TInPixelType, class TOutPixelType >
+void
+AdcImageFilter< TInPixelType, TOutPixelType>
+::BeforeThreadedGenerateData()
+{
+ typename OutputImageType::Pointer outputImage =
+ static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ outputImage->FillBuffer(0.0);
+}
+
+template< class TInPixelType, class TOutPixelType >
+void
+AdcImageFilter< TInPixelType, TOutPixelType>
+::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType )
+{
+ typename OutputImageType::Pointer outputImage =
+ static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+
+ ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
+ oit.GoToBegin();
+
+ typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
+ typename InputImageType::Pointer inputImagePointer = NULL;
+ inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
+
+ InputIteratorType git( inputImagePointer, outputRegionForThread );
+ git.GoToBegin();
+ while( !git.IsAtEnd() )
+ {
+ typename InputImageType::PixelType pix = git.Get();
+ TOutPixelType outval = 0;
+
+ double S0 = 0;
+ int c = 0;
+ for (int i=0; i<inputImagePointer->GetVectorLength(); i++)
+ {
+ GradientDirectionType g = m_GradientDirections->GetElement(i);
+ if (g.magnitude()<0.001)
+ {
+ S0 += pix[i];
+ c++;
+ }
+ }
+ if (c>0)
+ S0 /= c;
+
+ if (S0>0)
+ {
+ c = 0;
+ for (int i=0; i<inputImagePointer->GetVectorLength(); i++)
+ {
+ GradientDirectionType g = m_GradientDirections->GetElement(i);
+ if (g.magnitude()>0.001)
+ {
+ double twonorm = g.two_norm();
+ double b = m_B_value*twonorm*twonorm;
+ if (b>0)
+ {
+ double S = pix[i];
+ outval += -std::log(S/S0)/b;
+ c++;
+ }
+ }
+ }
+
+ if (c>0)
+ outval /= c;
+ }
+
+ if (outval==outval && outval<10000)
+ oit.Set( outval );
+
+ ++oit;
+ ++git;
+ }
+
+ std::cout << "One Thread finished calculation" << std::endl;
+}
+
+template< class TInPixelType, class TOutPixelType >
+void
+AdcImageFilter< TInPixelType, TOutPixelType>
+::PrintSelf(std::ostream& os, Indent indent) const
+{
+ Superclass::PrintSelf(os,indent);
+}
+
+}
+
+#endif // __itkAdcImageFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkB0ImageExtractionImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkB0ImageExtractionImageFilter.txx
index 62fa4365f4..7f4c1befe6 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkB0ImageExtractionImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkB0ImageExtractionImageFilter.txx
@@ -1,125 +1,125 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkB0ImageExtractionImageFilter_txx
#define __itkB0ImageExtractionImageFilter_txx
#include "itkB0ImageExtractionImageFilter.h"
namespace itk {
template< class TInputImagePixelType,
class TOutputImagePixelType >
B0ImageExtractionImageFilter< TInputImagePixelType,
TOutputImagePixelType >
::B0ImageExtractionImageFilter()
{
// At least 1 inputs is necessary for a vector image.
// For images added one at a time we need at least six
this->SetNumberOfRequiredInputs( 1 );
}
template< class TInputImagePixelType,
class TOutputImagePixelType >
void B0ImageExtractionImageFilter< TInputImagePixelType,
TOutputImagePixelType >
::GenerateData()
{
typename GradientDirectionContainerType::Iterator begin = m_Directions->Begin();
typename GradientDirectionContainerType::Iterator end = m_Directions->End();
// Find the index of the b0 image
std::vector<int> indices;
int index = 0;
while(begin!=end)
{
GradientDirectionType grad = begin->Value();
if(grad[0] == 0 && grad[1] == 0 && grad[2] == 0)
{
indices.push_back(index);
}
++index;
++begin;
}
typedef itk::Image<float,3> TempImageType;
TempImageType::Pointer tmp = TempImageType::New();
typename TempImageType::RegionType region = this->GetInput()->GetLargestPossibleRegion();
tmp->SetSpacing(this->GetInput()->GetSpacing());
tmp->SetOrigin(this->GetInput()->GetOrigin());
tmp->SetDirection(this->GetInput()->GetDirection());
tmp->SetRegions(region);
tmp->Allocate();
itk::ImageRegionIterator<TempImageType> it(tmp.GetPointer(), tmp->GetLargestPossibleRegion() );
itk::ImageRegionConstIterator<InputImageType> vectorIt(this->GetInput(), this->GetInput()->GetLargestPossibleRegion() );
it.GoToBegin();
while(!it.IsAtEnd())
{
it.Set(0);
++it;
}
//Sum all images that have zero diffusion weighting (indices stored in vector index)
for(std::vector<int>::iterator indexIt = indices.begin();
indexIt != indices.end();
indexIt++)
{
it.GoToBegin();
vectorIt.GoToBegin();
while(!it.IsAtEnd() && !vectorIt.IsAtEnd())
{
typename InputImageType::PixelType vec = vectorIt.Get();
it.Set((1.0 * it.Get()) + (1.0 * vec[*indexIt]) / (1.0 * indices.size()));
++it;
++vectorIt;
}
}
typename OutputImageType::Pointer b0Image =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
typename OutputImageType::RegionType outregion = this->GetInput()->GetLargestPossibleRegion();
b0Image->SetSpacing(this->GetInput()->GetSpacing());
b0Image->SetOrigin(this->GetInput()->GetOrigin());
b0Image->SetDirection(this->GetInput()->GetDirection());
b0Image->SetRegions(outregion);
b0Image->Allocate();
itk::ImageRegionIterator<TempImageType> itIn(tmp, tmp->GetLargestPossibleRegion() );
itk::ImageRegionIterator<OutputImageType> itOut(b0Image, b0Image->GetLargestPossibleRegion() );
itIn.GoToBegin();
itOut.GoToBegin();
while(!itIn.IsAtEnd())
{
itOut.Set(itIn.Get());
++itIn;
++itOut;
}
}
}
#endif // __itkB0ImageExtractionImageFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkBrainMaskExtractionImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkBrainMaskExtractionImageFilter.txx
index ed41c65f13..8a3061d02d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkBrainMaskExtractionImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkBrainMaskExtractionImageFilter.txx
@@ -1,443 +1,443 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkBrainMaskExtractionImageFilter_txx
#define __itkBrainMaskExtractionImageFilter_txx
#include "itkBrainMaskExtractionImageFilter.h"
#include <itkBinaryThresholdImageFilter.h>
#include <itkBinaryErodeImageFilter.h>
#include <itkBinaryDilateImageFilter.h>
#include <itkVotingBinaryHoleFillingImageFilter.h>
#include <itkVotingBinaryIterativeHoleFillingImageFilter.h>
#include <itkBinaryBallStructuringElement.h>
#include <itkBinaryCrossStructuringElement.h>
#include <itkAndImageFilter.h>
#include <itkRecursiveGaussianImageFilter.h>
#include <itkMaskImageFilter.h>
namespace itk {
template< class TOutputImagePixelType >
BrainMaskExtractionImageFilter< TOutputImagePixelType >
::BrainMaskExtractionImageFilter()
{
// At least 1 inputs is necessary for a vector image.
// For images added one at a time we need at least six
this->SetNumberOfRequiredInputs( 1 );
}
template< class TOutputImagePixelType >
void BrainMaskExtractionImageFilter< TOutputImagePixelType >
::GenerateData()
{
// gaussian filter
typename itk::RecursiveGaussianImageFilter<InputImageType,InputImageType>::Pointer gaussian
= itk::RecursiveGaussianImageFilter<InputImageType,InputImageType>::New();
gaussian->SetInput( this->GetInput(0) );
gaussian->SetSigma( 1.0 );
try
{
gaussian->Update();
}
catch( itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
// threshold the image
typename itk::BinaryThresholdImageFilter<InputImageType,OutputImageType>::Pointer threshold =
itk::BinaryThresholdImageFilter<InputImageType,OutputImageType>::New();
threshold->SetInput( gaussian->GetOutput() );
int seuil = static_cast<int>( ComputeHistogram( gaussian->GetOutput() ) );
threshold->SetLowerThreshold( seuil );
std::cout << "Thresholding..." << std::flush;
try
{
threshold->Update();
}
catch( itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
std::cout << "Done." << std::endl;
#ifdef DEBUG_ME
{
WriterType::Pointer writer = WriterType::New();
writer->SetInput( threshold->GetOutput() );
writer->SetFileName( "AfterThreshold.hdr" );
writer->Update();
}
#endif
// erode to remove background noise
typedef itk::BinaryBallStructuringElement<int, 3> StructuralElementType;
StructuralElementType ball;
typename itk::BinaryErodeImageFilter<OutputImageType,OutputImageType,StructuralElementType>::Pointer erode =
itk::BinaryErodeImageFilter<OutputImageType,OutputImageType,StructuralElementType>::New();
ball.SetRadius( 3 );
erode->SetInput( threshold->GetOutput() );
erode->SetKernel( ball );
std::cout << "Eroding..." << std::flush;
try
{
erode->Update();
}
catch( itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
std::cout << "Done." << std::endl;
#ifdef DEBUG_ME
{
WriterType::Pointer writer = WriterType::New();
writer->SetInput( erode->GetOutput() );
writer->SetFileName( "AfterErode.hdr" );
writer->Update();
}
#endif
typedef BinaryCrossStructuringElement<int, 3> CrossType;
typedef BinaryDilateImageFilter<OutputImageType,OutputImageType,CrossType> DilateFilterType;
typedef AndImageFilter<OutputImageType,OutputImageType,OutputImageType> AndFilterType;
typename OutputImageType::Pointer M0 = threshold->GetOutput();
typename OutputImageType::Pointer Mn = OutputImageType::New();
Mn->SetRegions( M0->GetLargestPossibleRegion() );
Mn->SetSpacing( M0->GetSpacing() );
Mn->SetOrigin( M0->GetOrigin() );
Mn->SetDirection( M0->GetDirection() );
Mn->Allocate();
typename OutputImageType::Pointer Mnplus1 = erode->GetOutput();
CrossType cross;
cross.SetRadius( 1 );
//unsigned long rad[3]={3,3,3};
//ball2.SetRadius( rad );
std::cout << "Conditional reconstruction..." << std::flush;
int iter = 0;
do
{
std::cout << "Iteration: " << iter++ << std::endl;
CopyImage( Mn, Mnplus1);
typename DilateFilterType::Pointer dilater = DilateFilterType::New();
dilater->SetInput( Mn );
dilater->SetKernel( cross );
try
{
dilater->Update();
}
catch( itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
typename AndFilterType::Pointer andfilter = AndFilterType::New();
andfilter->SetInput(0, M0);
andfilter->SetInput(1, dilater->GetOutput() );
try
{
andfilter->Update();
}
catch( itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
Mnplus1 = andfilter->GetOutput();
/*
#ifdef DEBUG_ME
{
WriterType::Pointer writer = WriterType::New();
writer->SetInput( andfilter->GetOutput() );
char filename[512];
sprintf( filename, "CondReconstruction_iter_%d.hdr", iter);
writer->SetFileName( filename );
writer->Update();
}
#endif*/
} while( !CompareImages( Mn, Mnplus1) );
std::cout << "Done." << std::endl;
#ifdef DEBUG_ME
{
WriterType::Pointer writer = WriterType::New();
writer->SetInput( Mn );
writer->SetFileName( "AfterCondReconstruction.hdr" );
writer->Update();
}
#endif
// now fill the holes
typename itk::VotingBinaryIterativeHoleFillingImageFilter< OutputImageType >::Pointer filler =
itk::VotingBinaryIterativeHoleFillingImageFilter< OutputImageType >::New();
filler->SetInput( Mn );
filler->SetMaximumNumberOfIterations (1000);
std::cout << "Filling the holes..." << std::flush;
try
{
filler->Update();
}
catch( itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
std::cout << "Done." << std::endl;
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
outputImage->SetSpacing( filler->GetOutput()->GetSpacing() ); // Set the image spacing
outputImage->SetOrigin( filler->GetOutput()->GetOrigin() ); // Set the image origin
outputImage->SetLargestPossibleRegion( filler->GetOutput()->GetLargestPossibleRegion());
outputImage->SetBufferedRegion( filler->GetOutput()->GetLargestPossibleRegion() );
outputImage->SetDirection( filler->GetOutput()->GetDirection() );
outputImage->Allocate();
itk::ImageRegionIterator<OutputImageType> itIn( filler->GetOutput(), filler->GetOutput()->GetLargestPossibleRegion() );
itk::ImageRegionIterator<OutputImageType> itOut( outputImage, outputImage->GetLargestPossibleRegion() );
while( !itIn.IsAtEnd() )
{
itOut.Set(itIn.Get());
++itIn;
++itOut;
}
}
template< class TOutputImagePixelType >
void BrainMaskExtractionImageFilter< TOutputImagePixelType >
::CopyImage( typename OutputImageType::Pointer target, typename OutputImageType::Pointer source)
{
itk::ImageRegionConstIterator<OutputImageType> itIn( source, source->GetLargestPossibleRegion() );
itk::ImageRegionIterator<OutputImageType> itOut( target, target->GetLargestPossibleRegion() );
while( !itOut.IsAtEnd() )
{
itOut.Set( itIn.Get() );
++itIn;
++itOut;
}
}
template< class TOutputImagePixelType >
bool BrainMaskExtractionImageFilter< TOutputImagePixelType >
::CompareImages( typename OutputImageType::Pointer im1, typename OutputImageType::Pointer im2)
{
itk::ImageRegionConstIterator<OutputImageType> itIn( im1, im1->GetLargestPossibleRegion() );
itk::ImageRegionConstIterator<OutputImageType> itOut( im2, im2->GetLargestPossibleRegion() );
while( !itOut.IsAtEnd() )
{
if( itOut.Value() != itIn.Value() )
{
return false;
}
++itOut;
++itIn;
}
return true;
}
template< class TOutputImagePixelType >
int BrainMaskExtractionImageFilter< TOutputImagePixelType >
::ComputeHistogram( typename InputImageType::Pointer image)
{
// IMPORTANT: IMAGE MUST BE UNSIGNED SHORT
int N=65535;
int* histogram = new int[N];
for( int i=0; i<N; i++)
{
histogram[i] = 0;
}
itk::ImageRegionConstIterator<InputImageType> itIn( image, image->GetLargestPossibleRegion() );
long totVoxels = 0;
int max = -1;
int min = 9999999;
while( !itIn.IsAtEnd() )
{
histogram[ (int)(itIn.Value()) ]++;
if( itIn.Value()>max )
{
max = itIn.Value();
}
if( itIn.Value()<min )
{
min = itIn.Value();
}
++itIn;
++totVoxels;
}
//int EPS = 1;
int seuil = 0;
//int newseuil = (max + min)/2;
N = max;
double V = 0.0;
int S = 0;
double mean = 0.0;
for( int i=min; i<=max; i++)
{
mean += (double)(i) * (double)histogram[i];
}
mean /= (double)totVoxels;
//std::cout << "Min/Max/Mean: " << min << "/" << max << "/" << mean << std::endl;
//while( abs(newseuil - seuil)>EPS )
for( seuil = min; seuil<=max; seuil++)
{
//seuil = newseuil;
// compute the classes:
double mean0 = 0.0;
double mean1 = 0.0;
//double std0 = 0.0;
//double std1 = 0.0;
double num0 = 0.0;
double num1 = 0.0;
for( int i=min; i<seuil; i++)
{
//mean0 += (double)(histogram[i])/(double)(totVoxels) * (double)(i);
mean0 += (double)histogram[i] * (double)i;
num0 += (double)histogram[i];
}
for( int i=seuil; i<max; i++)
{
//mean1 += (double)(histogram[i])/(double)(totVoxels) * (double)(i);
mean1 += (double)histogram[i] * (double)i;
num1 += (double)histogram[i];
}
if( num0 )
{
mean0/=num0;
}
if( num1 )
{
mean1/=num1;
}
/*
for( int i=0; i<seuil; i++)
{
std0 += (double)histogram[i]/(double)totVoxels* ((double)i - mean0)*((double)i - mean0);
//std0 += (double)histogram[i]/num0* ((double)i - mean0)*((double)i - mean0);
}
for( int i=seuil; i<65536; i++)
{
std1 += (double)histogram[i]/(double)totVoxels* ((double)i - mean1)* ((double)i - mean1);
//std1 += (double)histogram[i]/num1* ((double)i - mean1)* ((double)i - mean1);
}
*/
//std0 = sqrt(std0);
//std1 = sqrt(std1);
//std::cout << "Classe 0: " << mean0 << " " << std0 << std::endl;
//std::cout << "Classe 1: " << mean1 << " " << std1 << std::endl;
//std::cout << "Classe 0: " << mean0 << std::endl;
//std::cout << "Classe 1: " << mean1 << std::endl;
//double alpha = std0*std1/(std0+std1);
//std::cout << "alpha: " << alpha << " " << std0 << " " << std1 << std::endl;
//newseuil = (int) (alpha*(mean0/std0 + mean1/std1));
//std::cout << "New threshold: " << newseuil << std::endl;
/*
if( newseuil > 65535 || newseuil<0)
{
std::cerr << "Error: threshold is too low or high, exiting" << std::endl;
return -1;
}*/
double Vm = num0 * (mean0 - mean)*(mean0 - mean) + num1*(mean1 - mean)*(mean1 - mean);
if( Vm > V )
{
V = Vm;
S = seuil;
//std::cout << "New seuil: " << S << std::endl;
//getchar();
}
}
delete [] histogram;
std::cout << "Seuil: " << S << std::endl;
return S;
}
}
#endif // __itkBrainMaskExtractionImageFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionQballGeneralizedFaImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionQballGeneralizedFaImageFilter.txx
index aa20151289..8b7356a1bb 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionQballGeneralizedFaImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionQballGeneralizedFaImageFilter.txx
@@ -1,222 +1,222 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkDiffusionQballGeneralizedFaImageFilter_txx
#define __itkDiffusionQballGeneralizedFaImageFilter_txx
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkImageRegionIterator.h"
#include "itkArray.h"
#include "vnl/vnl_vector.h"
#include "itkOrientationDistributionFunction.h"
namespace itk {
//#define QBALL_RECON_PI M_PI
template< class TOdfPixelType,
class TGfaPixelType,
int NrOdfDirections>
DiffusionQballGeneralizedFaImageFilter< TOdfPixelType,
TGfaPixelType, NrOdfDirections>
::DiffusionQballGeneralizedFaImageFilter() :
m_ComputationMethod(GFA_STANDARD)
{
// At least 1 inputs is necessary for a vector image.
// For images added one at a time we need at least six
this->SetNumberOfRequiredInputs( 1 );
}
template< class TOdfPixelType,
class TGfaPixelType,
int NrOdfDirections>
void DiffusionQballGeneralizedFaImageFilter< TOdfPixelType,
TGfaPixelType, NrOdfDirections>
::BeforeThreadedGenerateData()
{
}
template< class TOdfPixelType,
class TGfaPixelType,
int NrOdfDirections>
void DiffusionQballGeneralizedFaImageFilter< TOdfPixelType,
TGfaPixelType, NrOdfDirections>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
int )
{
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetOutput());
ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
oit.GoToBegin();
typedef itk::OrientationDistributionFunction<TOdfPixelType,NrOdfDirections> OdfType;
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
typedef typename InputImageType::PixelType OdfVectorType;
typename InputImageType::Pointer inputImagePointer = NULL;
inputImagePointer = static_cast< InputImageType * >(
this->ProcessObject::GetInput(0) );
InputIteratorType git(inputImagePointer, outputRegionForThread );
git.GoToBegin();
while( !git.IsAtEnd() )
{
OdfVectorType b = git.Get();
TGfaPixelType outval = -1;
switch( m_ComputationMethod )
{
case GFA_STANDARD:
{
OdfType odf = b.GetDataPointer();
outval = odf.GetGeneralizedFractionalAnisotropy();
break;
}
case GFA_QUANTILES_HIGH_LOW:
{
vnl_vector_fixed<TOdfPixelType,NrOdfDirections> sorted;
for(int i=0; i<NrOdfDirections; i++)
{
sorted[i] = b[i];
}
std::sort( sorted.begin(), sorted.end() );
double q60 = sorted[floor(0.6*(double)NrOdfDirections+0.5)];
double q95 = sorted[floor(0.95*(double)NrOdfDirections+0.5)];
outval = q95/q60 - 1.0;
break;
}
case GFA_QUANTILE_HIGH:
{
vnl_vector_fixed<TOdfPixelType,NrOdfDirections> sorted;
for(int i=0; i<NrOdfDirections; i++)
{
sorted[i] = b[i];
}
std::sort( sorted.begin(), sorted.end() );
//double q40 = sorted[floor(0.4*(double)NrOdfDirections+0.5)];
double q95 = sorted[floor(0.95*(double)NrOdfDirections+0.5)];
outval = q95;
break;
}
case GFA_MAX_ODF_VALUE:
{
outval = b.GetVnlVector().max_value();
break;
}
case GFA_DECONVOLUTION_COEFFS:
{
break;
}
case GFA_MIN_MAX_NORMALIZED_STANDARD:
{
OdfType odf = b.GetDataPointer();
odf = odf.MinMaxNormalize();
outval = odf.GetGeneralizedFractionalAnisotropy();
break;
}
case GFA_NORMALIZED_ENTROPY:
{
OdfType odf = b.GetDataPointer();
outval = odf.GetNormalizedEntropy();
break;
}
case GFA_NEMATIC_ORDER_PARAMETER:
{
OdfType odf = b.GetDataPointer();
outval = odf.GetNematicOrderParameter();
break;
}
case GFA_QUANTILE_LOW:
{
vnl_vector_fixed<TOdfPixelType,NrOdfDirections> sorted;
for(int i=0; i<NrOdfDirections; i++)
{
sorted[i] = b[i];
}
std::sort( sorted.begin(), sorted.end() );
//double q40 = sorted[floor(0.4*(double)NrOdfDirections+0.5)];
double q05 = sorted[floor(0.05*(double)NrOdfDirections+0.5)];
outval = q05;
break;
}
case GFA_MIN_ODF_VALUE:
{
outval = b.GetVnlVector().min_value();
break;
}
case GFA_QUANTILES_LOW_HIGH:
{
vnl_vector_fixed<TOdfPixelType,NrOdfDirections> sorted;
for(int i=0; i<NrOdfDirections; i++)
{
sorted[i] = b[i];
}
std::sort( sorted.begin(), sorted.end() );
double q05 = sorted[floor(0.05*(double)NrOdfDirections+0.5)];
double q40 = sorted[floor(0.4*(double)NrOdfDirections+0.5)];
outval = q40/q05 - 1.0;
break;
}
case GFA_STD_BY_MAX:
{
OdfType odf = b.GetDataPointer();
outval = odf.GetStdDevByMaxValue();
break;
}
case GFA_PRINCIPLE_CURVATURE:
{
OdfType odf = b.GetDataPointer();
outval = odf.GetPrincipleCurvature(m_Param1, m_Param2, 0);
break;
}
case GFA_GENERALIZED_GFA:
{
OdfType odf = b.GetDataPointer();
outval = odf.GetGeneralizedGFA(m_Param1, m_Param2);
break;
}
}
oit.Set( outval );
++oit;
++git; // Gradient image iterator
}
std::cout << "One Thread finished calculation" << std::endl;
}
template< class TOdfPixelType,
class TGfaPixelType,
int NrOdfDirections>
void DiffusionQballGeneralizedFaImageFilter< TOdfPixelType,
TGfaPixelType, NrOdfDirections>
::PrintSelf(std::ostream& os, Indent indent) const
{
Superclass::PrintSelf(os,indent);
}
}
#endif // __itkDiffusionQballGeneralizedFaImageFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.cpp
index b9c6ba519d..d6f73117d7 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.cpp
@@ -1,186 +1,186 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkDiffusionQballPrepareVisualizationImageFilter_cpp
#define __itkDiffusionQballPrepareVisualizationImageFilter_cpp
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkDiffusionQballPrepareVisualizationImageFilter.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkImageRegionIterator.h"
#include "itkArray.h"
#include "vnl/vnl_vector.h"
#include "itkOrientationDistributionFunction.h"
#define _USE_MATH_DEFINES
#include <math.h>
namespace itk {
//#define QBALL_RECON_PI M_PI
template< class TOdfPixelType, int NrOdfDirections>
DiffusionQballPrepareVisualizationImageFilter< TOdfPixelType, NrOdfDirections>
::DiffusionQballPrepareVisualizationImageFilter() :
m_Threshold(0),
m_ScaleByGfaType(GfaFilterType::GFA_STANDARD),
m_DoScaleGfa(false),
m_GfaParam1(2),
m_GfaParam2(1)
{
// At least 1 inputs is necessary for a vector image.
// For images added one at a time we need at least six
this->SetNumberOfRequiredInputs( 1 );
}
template< class TOdfPixelType,
int NrOdfDirections>
void DiffusionQballPrepareVisualizationImageFilter< TOdfPixelType,
NrOdfDirections>
::BeforeThreadedGenerateData()
{
if( m_NormalizationMethod == PV_GLOBAL_MAX )
{
typename InputImageType::Pointer inputImagePointer = NULL;
inputImagePointer = static_cast< InputImageType * >(
this->ProcessObject::GetInput(0) );
typename GfaFilterType::Pointer filter = GfaFilterType::New();
filter->SetInput(inputImagePointer);
filter->SetNumberOfThreads(4);
filter->SetComputationMethod(GfaFilterType::GFA_MAX_ODF_VALUE);
filter->Update();
typedef typename itk::MinimumMaximumImageCalculator< typename GfaFilterType::OutputImageType >
MaxFilterType;
typename MaxFilterType::Pointer maxFilter = MaxFilterType::New();
maxFilter->SetImage(filter->GetOutput());
maxFilter->ComputeMaximum();
m_GlobalInputMaximum = maxFilter->GetMaximum();
}
//if(m_DoScaleGfa)
{
typename InputImageType::Pointer inputImagePointer = NULL;
inputImagePointer = static_cast< InputImageType * >(
this->ProcessObject::GetInput(0) );
typename GfaFilterType::Pointer filter = GfaFilterType::New();
filter->SetInput(inputImagePointer);
filter->SetNumberOfThreads(4);
filter->SetComputationMethod(m_ScaleByGfaType);
filter->SetParam1(m_GfaParam1);
filter->SetParam2(m_GfaParam2);
filter->Update();
m_GfaImage = filter->GetOutput();
}
}
template< class TOdfPixelType,
int NrOdfDirections>
void DiffusionQballPrepareVisualizationImageFilter< TOdfPixelType,
NrOdfDirections>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
int )
{
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetOutput());
ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
oit.GoToBegin();
typedef itk::OrientationDistributionFunction<TOdfPixelType,NrOdfDirections> OdfType;
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
typedef typename InputImageType::PixelType OdfVectorType;
typename InputImageType::Pointer inputImagePointer = NULL;
inputImagePointer = static_cast< InputImageType * >(
this->ProcessObject::GetInput(0) );
InputIteratorType git(inputImagePointer, outputRegionForThread );
git.GoToBegin();
typedef ImageRegionConstIterator< GfaImageType > GfaIteratorType;
GfaIteratorType gfaIt(m_GfaImage, outputRegionForThread);
while( !git.IsAtEnd() )
{
OdfVectorType b = git.Get();
OdfType odf = b.GetDataPointer();
switch( m_NormalizationMethod )
{
case PV_NONE:
{
break;
}
case PV_MAX:
{
odf = odf.MaxNormalize();
break;
}
case PV_MIN_MAX:
{
odf = odf.MinMaxNormalize();
break;
}
case PV_GLOBAL_MAX:
{
odf *= 1.0/m_GlobalInputMaximum;
break;
}
case PV_MIN_MAX_INVERT:
{
odf = odf.MinMaxNormalize();
for(int i=0; i<NrOdfDirections; i++)
{
odf[i] = 1.0 - odf[i];
}
break;
}
}
if(m_DoScaleGfa)
{
odf *= gfaIt.Get();
++gfaIt;
}
odf *= 0.5;
oit.Set( odf.GetDataPointer() );
++oit;
++git; // Gradient image iterator
}
std::cout << "One Thread finished extraction" << std::endl;
}
template< class TOdfPixelType,
int NrOdfDirections>
void DiffusionQballPrepareVisualizationImageFilter< TOdfPixelType,
NrOdfDirections>
::PrintSelf(std::ostream& os, Indent indent) const
{
Superclass::PrintSelf(os,indent);
os << indent << "m_Threshold: " <<
m_Threshold << std::endl;
}
}
#endif // __itkDiffusionQballPrepareVisualizationImageFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
index 14ffcc9abf..6cd65d2296 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
@@ -1,102 +1,101 @@
/*===================================================================
-/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkDiffusionTensorPrincipalDirectionImageFilter_h_
#define __itkDiffusionTensorPrincipalDirectionImageFilter_h_
#include "DiffusionCoreExports.h"
#include <itkImageToImageFilter.h>
#include <vnl/vnl_vector_fixed.h>
#include <vnl/vnl_matrix.h>
#include <vnl/algo/vnl_svd.h>
#include <itkVectorContainer.h>
#include <itkVectorImage.h>
#include <itkDiffusionTensor3D.h>
#include <mitkFiberBundleX.h>
namespace itk{
/** \brief Extracts principal eigenvectors of the input tensors
*/
template< class TTensorPixelType, class TPDPixelType=float>
class DiffusionTensorPrincipalDirectionImageFilter :
public ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >, Image< Vector< TPDPixelType, 3 >, 3 > >
{
public:
typedef DiffusionTensorPrincipalDirectionImageFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >, Image< Vector< TPDPixelType, 3 >, 3 > >
Superclass;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(DiffusionTensorPrincipalDirectionImageFilter, ImageToImageFilter)
typedef TTensorPixelType TensorComponentType;
typedef TPDPixelType DirectionPixelType;
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef vnl_vector_fixed< double, 3 > DirectionType;
void SetImage( const InputImageType *image );
// input
itkSetMacro( MaskImage, ItkUcharImgType::Pointer)
itkSetMacro( NormalizeVectors, bool)
// output
itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer)
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)
protected:
DiffusionTensorPrincipalDirectionImageFilter();
~DiffusionTensorPrincipalDirectionImageFilter() {}
void PrintSelf(std::ostream& os, Indent indent) const;
void BeforeThreadedGenerateData();
- void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, int );
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType );
void AfterThreadedGenerateData();
private:
bool m_NormalizeVectors; ///< Normalizes the output vector to length 1
mitk::FiberBundleX::Pointer m_OutputFiberBundle; ///< Vector field representation of the output vectors
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< Image containing the number of fiber directions per voxel
ItkUcharImgType::Pointer m_MaskImage; ///< Extraction is only performed inside of the binary mask
float m_MaxEigenvalue;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDiffusionTensorPrincipalDirectionImageFilter.txx"
#endif
#endif //__itkDiffusionTensorPrincipalDirectionImageFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx
index 5e1718ef7c..ee854f5c8d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx
@@ -1,236 +1,236 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkDiffusionTensorPrincipalDirectionImageFilter_txx
#define __itkDiffusionTensorPrincipalDirectionImageFilter_txx
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkDiffusionTensorPrincipalDirectionImageFilter.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkImageRegionIterator.h"
#include "itkArray.h"
#include "vnl/vnl_vector.h"
#include <boost/progress.hpp>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#define _USE_MATH_DEFINES
#include <math.h>
namespace itk {
//#define QBALL_RECON_PI M_PI
template< class TTensorPixelType, class TPDPixelType>
DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
::DiffusionTensorPrincipalDirectionImageFilter()
: m_NormalizeVectors(true)
, m_MaxEigenvalue(0.0)
{
this->SetNumberOfRequiredInputs( 1 );
this->SetNumberOfOutputs(1);
}
template< class TTensorPixelType,
class TPDPixelType>
void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
::BeforeThreadedGenerateData()
{
typename InputImageType::Pointer inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
- mitk::Vector3D spacing = inputImagePointer->GetSpacing();
+ Vector<double,3> spacing = inputImagePointer->GetSpacing();
mitk::Point3D origin = inputImagePointer->GetOrigin();
itk::Matrix<double, 3, 3> direction = inputImagePointer->GetDirection();
ImageRegion<3> imageRegion = inputImagePointer->GetLargestPossibleRegion();
if (m_MaskImage.IsNull())
{
m_MaskImage = ItkUcharImgType::New();
m_MaskImage->SetSpacing( spacing );
m_MaskImage->SetOrigin( origin );
m_MaskImage->SetDirection( direction );
m_MaskImage->SetRegions( imageRegion );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1);
}
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing );
m_NumDirectionsImage->SetOrigin( origin );
m_NumDirectionsImage->SetDirection( direction );
m_NumDirectionsImage->SetRegions( imageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
itk::Vector< TPDPixelType, 3 > nullVec; nullVec.Fill(0.0);
typename OutputImageType::Pointer outputImage = OutputImageType::New();
outputImage->SetSpacing( spacing );
outputImage->SetOrigin( origin );
outputImage->SetDirection( direction );
outputImage->SetRegions( imageRegion );
outputImage->Allocate();
outputImage->FillBuffer(nullVec);
this->SetNthOutput(0, outputImage);
}
template< class TTensorPixelType,
class TPDPixelType>
void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
::AfterThreadedGenerateData()
{
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
- typename OutputImageType::Pointer directionImage = static_cast< OutputImageType* >( this->ProcessObject::GetOutput(0) );
+ typename OutputImageType::Pointer directionImage = static_cast< OutputImageType* >( this->ProcessObject::GetPrimaryOutput() );
ImageRegionConstIterator< OutputImageType > it(directionImage, directionImage->GetLargestPossibleRegion() );
mitk::Vector3D spacing = directionImage->GetSpacing();
double minSpacing = spacing[0];
if (spacing[1]<minSpacing)
minSpacing = spacing[1];
if (spacing[2]<minSpacing)
minSpacing = spacing[2];
while( !it.IsAtEnd() )
{
typename OutputImageType::IndexType index = it.GetIndex();
if (m_MaskImage->GetPixel(index)==0)
{
++it;
continue;
}
itk::Vector< float, 3 > pixel = directionImage->GetPixel(index);
DirectionType dir; dir[0] = pixel[0]; dir[1] = pixel[1]; dir[2] = pixel[2];
if (!m_NormalizeVectors && m_MaxEigenvalue>0)
dir /= m_MaxEigenvalue;
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
directionImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
++it;
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
}
template< class TTensorPixelType,
class TPDPixelType>
void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
-::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int )
+::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType )
{
typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
typename InputImageType::Pointer inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
- typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
ImageRegionIterator< OutputImageType > outIt(outputImage, outputRegionForThread);
InputIteratorType inIt(inputImagePointer, outputRegionForThread );
ImageRegionIterator< ItkUcharImgType > nIt(m_NumDirectionsImage, outputRegionForThread );
while( !inIt.IsAtEnd() )
{
typename InputImageType::IndexType index = inIt.GetIndex();
if (m_MaskImage->GetPixel(index)==0)
{
++inIt;
++nIt;
++outIt;
continue;
}
typename InputImageType::PixelType b = inIt.Get();
TensorType tensor = b.GetDataPointer();
typename OutputImageType::PixelType dir;
typename TensorType::EigenValuesArrayType eigenvalues;
typename TensorType::EigenVectorsMatrixType eigenvectors;
if(tensor.GetTrace()!=0)
{
tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
vnl_vector_fixed<double,3> vec;
vec[0] = eigenvectors(2,0);
vec[1] = eigenvectors(2,1);
vec[2] = eigenvectors(2,2);
if (!m_NormalizeVectors)
vec *= eigenvalues[2];
if (eigenvalues[2]>m_MaxEigenvalue)
m_MaxEigenvalue = eigenvalues[2];
dir[0] = (TPDPixelType)vec[0];
dir[1] = (TPDPixelType)vec[1];
dir[2] = (TPDPixelType)vec[2];
outIt.Set( dir );
m_NumDirectionsImage->SetPixel(index, 1);
}
++outIt;
++inIt;
++nIt;
}
std::cout << "One Thread finished extraction" << std::endl;
}
template< class TTensorPixelType,
class TPDPixelType>
void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
::PrintSelf(std::ostream& os, Indent indent) const
{
}
}
#endif // __itkDiffusionQballPrincipleDirectionsImageFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.h
index 62d0a1ca83..0537068569 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.h
@@ -1,101 +1,93 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef ITKDISTANCEMAPFILTER_H_
#define ITKDISTANCEMAPFILTER_H_
#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "mitkImage.h"
namespace itk
{
template < class TInputImage, class TOutputImage >
class DistanceMapFilter : public ImageToImageFilter<TInputImage, TOutputImage>
{
- /*!
- \brief itkDistanceMapFilter
-
- \brief Creates a distance map from a FA skeleton image.
-
- \sa itkImageToImageFilter
-
-
- \verbatim
- Last contributor: $Author: vanbrugg $
- \endverbatim
- */
+ /**
+ * \brief This filter creates a map of the distance to the nearest point on a binary mask.
+ *
+ */
public:
/** Typedef for input ImageType. */
typedef TInputImage InputImageType;
/** Typedef for input imageType Pointer. */
typedef typename InputImageType::Pointer InputImagePointer;
/** Typedef for output ImageType. */
typedef TOutputImage OutputImageType;
/** Typedef for input imageType Pointer. */
typedef typename OutputImageType::Pointer OutputImagePointer;
public:
/** */
typedef DistanceMapFilter Self;
/** Superclass */
typedef ImageToImageFilter<InputImageType, OutputImageType> Superclass;
/** Smart Pointer */
typedef SmartPointer<Self> Pointer;
/** Smart Pointer */
typedef SmartPointer<const Self> ConstPointer;
/** */
- itkNewMacro( Self);
+ itkNewMacro( Self)
/** Generate Data. The image will be divided into a number of pieces, a number of threads
will be spawned and Threaded GenerateData() will be called in each thread. */
virtual void GenerateData();
protected:
/** Constructor */
DistanceMapFilter();
/** Destructor */
virtual ~DistanceMapFilter();
protected:
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDistanceMapFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.txx
index 446a3be133..f80ce05286 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.txx
@@ -1,85 +1,79 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _itkDistanceMapFilter_txx
#define _itkDistanceMapFilter_txx
#include "itkDistanceMapFilter.h"
-#include "mitkProgressBar.h"
#include <itkSignedMaurerDistanceMapImageFilter.h>
namespace itk
{
template< class TInputImage, class TOutputImage >
DistanceMapFilter<TInputImage, TOutputImage>::DistanceMapFilter()
{
}
template< class TInputImage, class TOutputImage >
DistanceMapFilter<TInputImage, TOutputImage>::~DistanceMapFilter()
{
}
template< class TInputImage, class TOutputImage >
void DistanceMapFilter<TInputImage, TOutputImage>::GenerateData()
{
- //----------------------------------------------------------------------//
- // Progress bar //
- //----------------------------------------------------------------------//
- //mitk::ProgressBar::GetInstance()->AddStepsToDo( 3 );
-
typedef itk::SignedMaurerDistanceMapImageFilter<InputImageType, OutputImageType> DistanceFilterType;
typename DistanceFilterType::Pointer dFilter = DistanceFilterType::New();
dFilter->SetInput(this->GetInput());
dFilter->SetUseImageSpacing(true);
dFilter->SetSquaredDistance(false);
dFilter->SetInsideIsPositive(true);
dFilter->Update();
typename OutputImageType::Pointer outputImg = dFilter->GetOutput();
typedef itk::ImageRegionIterator<OutputImageType> ImageIteratorType;
ImageIteratorType outIt(outputImg, outputImg->GetRequestedRegion());
outIt.GoToBegin();
while(!outIt.IsAtEnd())
{
typename OutputImageType::PixelType p = outIt.Get();
p *= -1;
outIt.Set(p);
++outIt;
}
Superclass::SetNthOutput( 0, outputImg );
}
}
#endif // _itkDistanceMapFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiGradientLengthCorrectionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiGradientLengthCorrectionFilter.cpp
new file mode 100644
index 0000000000..1e34d32cea
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiGradientLengthCorrectionFilter.cpp
@@ -0,0 +1,86 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+/*=========================================================================
+
+Program: Tensor ToolKit - TTK
+Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx $
+Language: C++
+Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
+Version: $Revision: 68 $
+
+Copyright (c) INRIA 2010. All rights reserved.
+See LICENSE.txt 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 "itkDwiGradientLengthCorrectionFilter.h"
+
+itk::DwiGradientLengthCorrectionFilter::DwiGradientLengthCorrectionFilter()
+ : m_ReferenceBValue(0)
+ , m_RoundingValue(0)
+ , m_ReferenceGradientDirectionContainer(0)
+ , m_OutputGradientDirectionContainer(0)
+{
+}
+
+itk::DwiGradientLengthCorrectionFilter::~DwiGradientLengthCorrectionFilter()
+{
+}
+
+void itk::DwiGradientLengthCorrectionFilter::GenerateData()
+{
+
+ if(m_ReferenceBValue == 0 || m_RoundingValue == 0 || m_ReferenceGradientDirectionContainer.IsNull())
+ itkExceptionMacro("Wrong initialization");
+
+ m_OutputGradientDirectionContainer = GradientDirectionContainerType::New();
+
+ m_NewBValue = itk::NumericTraits<double>::max();
+ GradientDirectionContainerType::ConstIterator it = m_ReferenceGradientDirectionContainer->Begin();
+ for(; it != m_ReferenceGradientDirectionContainer->End(); ++it)
+ {
+ const double twonorm = it.Value().two_norm();
+ const double currentBValue = m_ReferenceBValue*twonorm*twonorm ;
+ const double roundedBValue = int((currentBValue + 0.5 * m_RoundingValue)/m_RoundingValue)*m_RoundingValue;
+
+ if (roundedBValue<m_NewBValue && roundedBValue>1)
+ m_NewBValue = roundedBValue;
+ }
+
+ it = m_ReferenceGradientDirectionContainer->Begin();
+ for(; it != m_ReferenceGradientDirectionContainer->End(); ++it)
+ {
+ const double twonorm = it.Value().two_norm();
+ const double currentBValue = m_ReferenceBValue*twonorm*twonorm ;
+ const double roundedBValue = int((currentBValue + 0.5 * m_RoundingValue)/m_RoundingValue)*m_RoundingValue;
+
+ if (roundedBValue>1)
+ {
+ const double f = std::sqrt(roundedBValue/m_NewBValue);
+ GradientDirectionType grad = it.Value();
+ m_OutputGradientDirectionContainer->push_back( grad.normalize() * f );
+ }
+ else
+ {
+ GradientDirectionType grad; grad.fill(0.0);
+ m_OutputGradientDirectionContainer->push_back( grad );
+ }
+ }
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiGradientLengthCorrectionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiGradientLengthCorrectionFilter.h
new file mode 100644
index 0000000000..4b62156cd1
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiGradientLengthCorrectionFilter.h
@@ -0,0 +1,74 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef _itk_DwiGradientLengthCorrectionFilter_h_
+#define _itk_DwiGradientLengthCorrectionFilter_h_
+
+#include <itkProcessObject.h>
+#include <vnl/vnl_vector_fixed.h>
+#include <itkVectorContainer.h>
+#include "DiffusionCoreExports.h"
+
+namespace itk
+{
+
+class DiffusionCore_EXPORT DwiGradientLengthCorrectionFilter : public ProcessObject
+{
+
+public:
+ typedef DwiGradientLengthCorrectionFilter Self;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+ typedef ProcessObject Superclass;
+
+ typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
+ typedef itk::VectorContainer< unsigned int, GradientDirectionType > GradientDirectionContainerType;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self)
+ itkTypeMacro(DwiGradientLengthCorrectionFilter,ProcessObject)
+
+ void GenerateData();
+
+ virtual void Update(){
+ this->GenerateData();
+ }
+
+ // input
+ itkSetMacro(RoundingValue, int)
+ itkSetMacro(ReferenceBValue, double)
+ itkSetMacro(ReferenceGradientDirectionContainer, GradientDirectionContainerType::Pointer)
+
+ // output
+ itkGetMacro(OutputGradientDirectionContainer, GradientDirectionContainerType::Pointer)
+ itkGetMacro(NewBValue, double)
+
+ protected:
+ DwiGradientLengthCorrectionFilter();
+ ~DwiGradientLengthCorrectionFilter();
+
+ double m_NewBValue;
+ double m_ReferenceBValue;
+ int m_RoundingValue;
+
+ GradientDirectionContainerType::Pointer m_ReferenceGradientDirectionContainer;
+ GradientDirectionContainerType::Pointer m_OutputGradientDirectionContainer;
+};
+
+
+} // end of namespace
+
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
index 067342660a..65e1842d1e 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
@@ -1,371 +1,388 @@
+/*===================================================================
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
#ifndef __itkDwiPhantomGenerationFilter_cpp
#define __itkDwiPhantomGenerationFilter_cpp
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkDwiPhantomGenerationFilter.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#include <itkOrientationDistributionFunction.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <boost/progress.hpp>
namespace itk {
//#define QBALL_RECON_PI 3.14159265358979323846
template< class TOutputScalarType >
DwiPhantomGenerationFilter< TOutputScalarType >
::DwiPhantomGenerationFilter()
: m_BValue(1000)
, m_SignalScale(1000)
, m_BaselineImages(0)
, m_MaxBaseline(0)
, m_MeanBaseline(0)
, m_NoiseVariance(0.004)
, m_GreyMatterAdc(0.01)
, m_SimulateBaseline(true)
, m_DefaultBaseline(1000)
{
this->SetNumberOfRequiredOutputs (1);
m_Spacing.Fill(2.5); m_Origin.Fill(0.0);
m_DirectionMatrix.SetIdentity();
m_ImageRegion.SetSize(0, 10);
m_ImageRegion.SetSize(1, 10);
m_ImageRegion.SetSize(2, 10);
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( m_Spacing ); // Set the image spacing
outImage->SetOrigin( m_Origin ); // Set the image origin
outImage->SetDirection( m_DirectionMatrix ); // Set the image direction
outImage->SetLargestPossibleRegion( m_ImageRegion );
outImage->SetBufferedRegion( m_ImageRegion );
outImage->SetRequestedRegion( m_ImageRegion );
outImage->SetVectorLength(QBALL_ODFSIZE);
outImage->Allocate();
- outImage->FillBuffer(0);
+ // ITKv4 migration fix : removing OutputImageType::PixelType(0.0)
+ // the conversion is handled internally by the itk::Image
+ typename OutputImageType::PixelType fillValue(0.0);
+ outImage->FillBuffer( fillValue );
this->SetNthOutput (0, outImage);
}
template< class TOutputScalarType >
void DwiPhantomGenerationFilter< TOutputScalarType >
::GenerateTensors()
{
MITK_INFO << "Generating tensors";
for (int i=0; i<m_SignalRegions.size(); i++)
{
float ADC = m_TensorADC.at(i);
float FA = m_TensorFA.at(i);
itk::DiffusionTensor3D<float> kernel;
kernel.Fill(0);
float e1=ADC*(1+2*FA/sqrt(3-2*FA*FA));
float e2=ADC*(1-FA/sqrt(3-2*FA*FA));
float e3=e2;
kernel.SetElement(0,e1);
kernel.SetElement(3,e2);
kernel.SetElement(5,e3);
if (m_SimulateBaseline)
{
double l2 = GetTensorL2Norm(kernel);
if (l2>m_MaxBaseline)
m_MaxBaseline = l2;
}
MITK_INFO << "Kernel FA: " << kernel.GetFractionalAnisotropy();
vnl_vector_fixed<double, 3> kernelDir; kernelDir[0]=1; kernelDir[1]=0; kernelDir[2]=0;
itk::DiffusionTensor3D<float> tensor;
vnl_vector_fixed<double, 3> dir = m_TensorDirection.at(i);
MITK_INFO << "Tensor direction: " << dir;
dir.normalize();
vnl_vector_fixed<double, 3> axis = vnl_cross_3d(kernelDir, dir); axis.normalize();
vnl_quaternion<double> rotation(axis, acos(dot_product(kernelDir, dir)));
rotation.normalize();
vnl_matrix_fixed<double, 3, 3> matrix = rotation.rotation_matrix_transpose();
vnl_matrix_fixed<double, 3, 3> tensorMatrix;
tensorMatrix[0][0] = kernel[0]; tensorMatrix[0][1] = kernel[1]; tensorMatrix[0][2] = kernel[2];
tensorMatrix[1][0] = kernel[1]; tensorMatrix[1][1] = kernel[3]; tensorMatrix[1][2] = kernel[4];
tensorMatrix[2][0] = kernel[2]; tensorMatrix[2][1] = kernel[4]; tensorMatrix[2][2] = kernel[5];
tensorMatrix = matrix.transpose()*tensorMatrix*matrix;
tensor[0] = tensorMatrix[0][0]; tensor[1] = tensorMatrix[0][1]; tensor[2] = tensorMatrix[0][2];
tensor[3] = tensorMatrix[1][1]; tensor[4] = tensorMatrix[1][2]; tensor[5] = tensorMatrix[2][2];
m_TensorList.push_back(tensor);
}
}
template< class TOutputScalarType >
void DwiPhantomGenerationFilter< TOutputScalarType >::AddNoise(typename OutputImageType::PixelType& pix)
{
for( unsigned int i=0; i<m_GradientList.size(); i++)
{
float signal = pix[i];
float val = sqrt(pow(signal + m_SignalScale*m_RandGen->GetNormalVariate(0.0, m_NoiseVariance), 2) + pow(m_SignalScale*m_RandGen->GetNormalVariate(0.0, m_NoiseVariance),2));
pix[i] += val;
}
}
template< class TOutputScalarType >
typename DwiPhantomGenerationFilter< TOutputScalarType >::OutputImageType::PixelType
DwiPhantomGenerationFilter< TOutputScalarType >::SimulateMeasurement(itk::DiffusionTensor3D<float>& T, float weight)
{
typename OutputImageType::PixelType out;
out.SetSize(m_GradientList.size());
out.Fill(0);
TOutputScalarType s0 = m_DefaultBaseline;
if (m_SimulateBaseline)
s0 = (GetTensorL2Norm(T)/m_MaxBaseline)*m_SignalScale;
for( unsigned int i=0; i<m_GradientList.size(); i++)
{
GradientType g = m_GradientList[i];
if (g.GetNorm()>0.0001)
{
itk::DiffusionTensor3D<float> S;
S[0] = g[0]*g[0];
S[1] = g[1]*g[0];
S[2] = g[2]*g[0];
S[3] = g[1]*g[1];
S[4] = g[2]*g[1];
S[5] = g[2]*g[2];
double D = T[0]*S[0] + T[1]*S[1] + T[2]*S[2] +
T[1]*S[1] + T[3]*S[3] + T[4]*S[4] +
T[2]*S[2] + T[4]*S[4] + T[5]*S[5];
// check for corrupted tensor and generate signal
if (D>=0)
{
D = weight*s0*exp ( -m_BValue * D );
out[i] = static_cast<TOutputScalarType>( D );
}
}
else
out[i] = s0;
}
return out;
}
template< class TOutputScalarType >
void DwiPhantomGenerationFilter< TOutputScalarType >
::GenerateData()
{
if (m_NoiseVariance < 0)
m_NoiseVariance = 0.001;
if (!m_SimulateBaseline)
{
MITK_INFO << "Baseline image values are set to default. Noise variance value is treated as SNR!";
if (m_NoiseVariance <= 0)
m_NoiseVariance = 0.0001;
if (m_NoiseVariance>99)
m_NoiseVariance = 0;
else
{
m_NoiseVariance = m_DefaultBaseline/(m_NoiseVariance*m_SignalScale);
m_NoiseVariance *= m_NoiseVariance;
}
}
m_RandGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
m_RandGen->SetSeed();
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( m_Spacing );
outImage->SetOrigin( m_Origin );
outImage->SetDirection( m_DirectionMatrix );
outImage->SetLargestPossibleRegion( m_ImageRegion );
outImage->SetBufferedRegion( m_ImageRegion );
outImage->SetRequestedRegion( m_ImageRegion );
outImage->SetVectorLength(m_GradientList.size());
outImage->Allocate();
typename OutputImageType::PixelType pix;
pix.SetSize(m_GradientList.size());
pix.Fill(0.0);
outImage->FillBuffer(pix);
this->SetNthOutput (0, outImage);
double minSpacing = m_Spacing[0];
if (m_Spacing[1]<minSpacing)
minSpacing = m_Spacing[1];
if (m_Spacing[2]<minSpacing)
minSpacing = m_Spacing[2];
m_DirectionImageContainer = ItkDirectionImageContainer::New();
for (int i=0; i<m_SignalRegions.size(); i++)
{
itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
ItkDirectionImage::Pointer img = ItkDirectionImage::New();
img->SetSpacing( m_Spacing );
img->SetOrigin( m_Origin );
img->SetDirection( m_DirectionMatrix );
img->SetRegions( m_ImageRegion );
img->Allocate();
img->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
}
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( m_Spacing );
m_NumDirectionsImage->SetOrigin( m_Origin );
m_NumDirectionsImage->SetDirection( m_DirectionMatrix );
m_NumDirectionsImage->SetRegions( m_ImageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
m_SNRImage = ItkFloatImgType::New();
m_SNRImage->SetSpacing( m_Spacing );
m_SNRImage->SetOrigin( m_Origin );
m_SNRImage->SetDirection( m_DirectionMatrix );
m_SNRImage->SetRegions( m_ImageRegion );
m_SNRImage->Allocate();
m_SNRImage->FillBuffer(0);
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
m_BaselineImages = 0;
for( unsigned int i=0; i<m_GradientList.size(); i++)
if (m_GradientList[i].GetNorm()<=0.0001)
m_BaselineImages++;
typedef ImageRegionIterator<OutputImageType> IteratorOutputType;
IteratorOutputType it (outImage, m_ImageRegion);
// isotropic tensor
itk::DiffusionTensor3D<float> isoTensor;
isoTensor.Fill(0);
float e1 = m_GreyMatterAdc;
float e2 = m_GreyMatterAdc;
float e3 = m_GreyMatterAdc;
isoTensor.SetElement(0,e1);
isoTensor.SetElement(3,e2);
isoTensor.SetElement(5,e3);
m_MaxBaseline = GetTensorL2Norm(isoTensor);
GenerateTensors();
// simulate measurement
m_MeanBaseline = 0;
double noiseStdev = sqrt(m_NoiseVariance);
while(!it.IsAtEnd())
{
pix = it.Get();
typename OutputImageType::IndexType index = it.GetIndex();
int numDirs = 0;
for (int i=0; i<m_SignalRegions.size(); i++)
{
ItkUcharImgType::Pointer region = m_SignalRegions.at(i);
if (region->GetPixel(index)!=0)
{
numDirs++;
pix += SimulateMeasurement(m_TensorList[i], m_TensorWeight[i]);
// set direction image pixel
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
itk::Vector< float, 3 > pixel = img->GetPixel(index);
vnl_vector_fixed<double, 3> dir = m_TensorDirection.at(i);
dir.normalize();
dir *= m_TensorWeight.at(i);
pixel.SetElement(0, dir[0]);
pixel.SetElement(1, dir[1]);
pixel.SetElement(2, dir[2]);
img->SetPixel(index, pixel);
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
outImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
}
}
if (numDirs>1)
{
for (int i=0; i<m_GradientList.size(); i++)
pix[i] /= numDirs;
}
else if (numDirs==0)
{
if (m_SimulateBaseline)
pix = SimulateMeasurement(isoTensor, 1.0);
else
pix.Fill(0.0);
}
m_MeanBaseline += pix[0];
it.Set(pix);
m_NumDirectionsImage->SetPixel(index, numDirs);
if (m_NoiseVariance>0)
m_SNRImage->SetPixel(index, pix[0]/(noiseStdev*m_SignalScale));
++it;
}
m_MeanBaseline /= m_ImageRegion.GetNumberOfPixels();
if (m_NoiseVariance>0)
MITK_INFO << "Mean SNR: " << m_MeanBaseline/(noiseStdev*m_SignalScale);
else
MITK_INFO << "No noise added";
// add rician noise
it.GoToBegin();
while(!it.IsAtEnd())
{
pix = it.Get();
AddNoise(pix);
it.Set(pix);
++it;
}
// generate fiber bundle
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
}
template< class TOutputScalarType >
double DwiPhantomGenerationFilter< TOutputScalarType >::GetTensorL2Norm(itk::DiffusionTensor3D<float>& T)
{
return sqrt(T[0]*T[0] + T[3]*T[3] + T[5]*T[5] + T[1]*T[2]*2.0 + T[2]*T[4]*2.0 + T[1]*T[4]*2.0);
}
}
#endif // __itkDwiPhantomGenerationFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h
index deea92dcbe..f0d344e568 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h
@@ -1,136 +1,151 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
Language: C++
Date: $Date: 2006-03-27 17:01:06 $
Version: $Revision: 1.12 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkDwiPhantomGenerationFilter_h_
#define __itkDwiPhantomGenerationFilter_h_
#include <itkImageSource.h>
#include <itkVectorImage.h>
#include <itkDiffusionTensor3D.h>
#include <itkMersenneTwisterRandomVariateGenerator.h>
#include <mitkFiberBundleX.h>
namespace itk{
/**
* \brief Generation of synthetic diffusion weighted images using a second rank tensor model. */
template< class TOutputScalarType >
class DwiPhantomGenerationFilter : public ImageSource< itk::VectorImage<TOutputScalarType,3> >
{
public:
typedef DwiPhantomGenerationFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageSource< itk::VectorImage<TOutputScalarType,3> > Superclass;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(DwiPhantomGenerationFilter, ImageSource)
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef itk::VectorContainer< int, double > AnglesContainerType;
typedef Vector<double,3> GradientType;
typedef std::vector<GradientType> GradientListType;
typedef itk::Matrix<double, 3, 3> MatrixType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image<float, 3> ItkFloatImgType;
typedef Image< Vector< float, 3 >, 3> ItkDirectionImage;
typedef VectorContainer< unsigned int, ItkDirectionImage::Pointer > ItkDirectionImageContainer;
void SetGradientList(GradientListType gradientList){m_GradientList = gradientList;}
void SetSignalRegions(std::vector< ItkUcharImgType::Pointer > signalRegions){m_SignalRegions = signalRegions;}
void SetTensorFA(std::vector< float > faList){m_TensorFA = faList;}
void SetTensorADC(std::vector< float > adcList){m_TensorADC = adcList;}
void SetTensorWeight(std::vector< float > weightList){m_TensorWeight = weightList;}
void SetTensorDirection(std::vector< vnl_vector_fixed<double, 3> > directionList){m_TensorDirection = directionList;}
// input parameters
itkSetMacro( BValue, float ) ///< signal parameter
itkSetMacro( SignalScale, float ) ///< scaling factor for signal
itkSetMacro( NoiseVariance, double ) ///< variance of rician noise
itkSetMacro( GreyMatterAdc, float ) ///< ADC of isotropic diffusion tensor
itkSetMacro( Spacing, mitk::Vector3D ) ///< parameter of output image
itkSetMacro( Origin, mitk::Point3D ) ///< parameter of output image
itkSetMacro( DirectionMatrix, MatrixType ) ///< parameter of output image
itkSetMacro( ImageRegion, ImageRegion<3> ) ///< parameter of output image
itkSetMacro( SimulateBaseline, bool ) ///< generate baseline image values as the l2 norm of the corresponding tensor used for the diffusion signal generation
// output
itkGetMacro( DirectionImageContainer, ItkDirectionImageContainer::Pointer) ///< contains one vectorimage for each input ROI
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer) ///< contains number of directions per voxel
itkGetMacro( SNRImage, ItkFloatImgType::Pointer) ///< contains local SNR values
itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer) ///< output vector field
protected:
DwiPhantomGenerationFilter();
~DwiPhantomGenerationFilter(){}
void GenerateData();
private:
// image variables
- mitk::Vector3D m_Spacing;
+ itk::Vector<double> m_Spacing;
mitk::Point3D m_Origin;
itk::Matrix<double, 3, 3> m_DirectionMatrix;
ImageRegion<3> m_ImageRegion;
ItkDirectionImageContainer::Pointer m_DirectionImageContainer; ///< contains one vectorimage for each input ROI
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< contains number of directions per voxel
ItkFloatImgType::Pointer m_SNRImage; ///< contains local SNR values
mitk::FiberBundleX::Pointer m_OutputFiberBundle; ///< output vector field
// signal regions
std::vector< ItkUcharImgType::Pointer > m_SignalRegions; ///< binary images defining the regions for the signal generation
std::vector< float > m_TensorFA; ///< kernel tensor parameter
std::vector< float > m_TensorADC; ///< kernel tensor parameter
std::vector< float > m_TensorWeight; ///< weight factor of the signal
std::vector< vnl_vector_fixed<double, 3> > m_TensorDirection; ///< principal direction of the kernel tensor in the different ROIs
// signal related variable
GradientListType m_GradientList; ///< list of used diffusion gradient directions
std::vector< itk::DiffusionTensor3D<float> > m_TensorList; ///< kernel tensor rotated in the different directions
float m_BValue; ///< signal parameter
float m_SignalScale; ///< scaling factor for signal
Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_RandGen;
int m_BaselineImages; ///< number of simulated baseline images
double m_MaxBaseline; ///< maximum value of the baseline image
double m_MeanBaseline; ///< mean value of the baseline image
double m_NoiseVariance; ///< variance of rician noise
float m_GreyMatterAdc; ///< ADC of isotropic diffusion tensor
bool m_SimulateBaseline; ///< generate baseline image values as the l2 norm of the corresponding tensor used for the diffusion signal generation
TOutputScalarType m_DefaultBaseline; ///< default value for baseline image
double GetTensorL2Norm(itk::DiffusionTensor3D<float>& T);
void GenerateTensors(); ///< rotates kernel tensor in the direction of the input direction vectors
typename OutputImageType::PixelType SimulateMeasurement(itk::DiffusionTensor3D<float>& tensor, float weight);
void AddNoise(typename OutputImageType::PixelType& pix); ///< Adds rician noise to the input pixel
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDwiPhantomGenerationFilter.cpp"
#endif
#endif //__itkDwiPhantomGenerationFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractChannelFromRgbaImageFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractChannelFromRgbaImageFilter.cpp
index 44e572055b..3e03bb2de8 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractChannelFromRgbaImageFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractChannelFromRgbaImageFilter.cpp
@@ -1,171 +1,171 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "itkExtractChannelFromRgbaImageFilter.h"
// VTK
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
// misc
#include <math.h>
namespace itk{
template< class ReferenceImageType, class OutputImageType >
ExtractChannelFromRgbaImageFilter< ReferenceImageType, OutputImageType >::ExtractChannelFromRgbaImageFilter():
m_Channel(RED)
{
}
template< class ReferenceImageType, class OutputImageType >
ExtractChannelFromRgbaImageFilter< ReferenceImageType, OutputImageType >::~ExtractChannelFromRgbaImageFilter()
{
}
template< class ReferenceImageType, class OutputImageType >
void ExtractChannelFromRgbaImageFilter< ReferenceImageType, OutputImageType >::GenerateData()
{
typename InputImageType::Pointer rgbaImage = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
typename InputImageType::RegionType region = rgbaImage->GetLargestPossibleRegion();
outputImage->SetSpacing( m_ReferenceImage->GetSpacing() ); // Set the image spacing
outputImage->SetOrigin( m_ReferenceImage->GetOrigin() ); // Set the image origin
outputImage->SetDirection( m_ReferenceImage->GetDirection() ); // Set the image direction
outputImage->SetRegions( m_ReferenceImage->GetLargestPossibleRegion());
outputImage->Allocate();
outputImage->FillBuffer(0);
float* outImageBufferPointer = outputImage->GetBufferPointer();
itk::Image< short, 3 >::Pointer counterImage = itk::Image< short, 3 >::New();
counterImage->SetSpacing( m_ReferenceImage->GetSpacing() ); // Set the image spacing
counterImage->SetOrigin( m_ReferenceImage->GetOrigin() ); // Set the image origin
counterImage->SetDirection( m_ReferenceImage->GetDirection() ); // Set the image direction
counterImage->SetRegions( m_ReferenceImage->GetLargestPossibleRegion());
counterImage->Allocate();
counterImage->FillBuffer(0);
short* counterImageBufferPointer = counterImage->GetBufferPointer();
int w = m_ReferenceImage->GetLargestPossibleRegion().GetSize().GetElement(0);
int h = m_ReferenceImage->GetLargestPossibleRegion().GetSize().GetElement(1);
int d = m_ReferenceImage->GetLargestPossibleRegion().GetSize().GetElement(2);
typedef ImageRegionConstIterator< InputImageType > InImageIteratorType;
InImageIteratorType rgbaIt(rgbaImage, region);
rgbaIt.GoToBegin();
while(!rgbaIt.IsAtEnd()){
InPixelType x = rgbaIt.Get();
++rgbaIt;
itk::Point<float, 3> vertex;
itk::Index<3> index = rgbaIt.GetIndex();
rgbaImage->TransformIndexToPhysicalPoint(index, vertex);
outputImage->TransformPhysicalPointToIndex(vertex, index);
itk::ContinuousIndex<float, 3> contIndex;
outputImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
float frac_x = contIndex[0] - index[0];
float frac_y = contIndex[1] - index[1];
float frac_z = contIndex[2] - index[2];
int px = index[0];
if (frac_x<0)
{
px -= 1;
frac_x += 1;
}
int py = index[1];
if (frac_y<0)
{
py -= 1;
frac_y += 1;
}
int pz = index[2];
if (frac_z<0)
{
pz -= 1;
frac_z += 1;
}
frac_x = 1-frac_x;
frac_y = 1-frac_y;
frac_z = 1-frac_z;
// int coordinates inside image?
if (px < 0 || px >= w-1)
continue;
if (py < 0 || py >= h-1)
continue;
if (pz < 0 || pz >= d-1)
continue;
OutPixelType out;
switch (m_Channel)
{
case RED:
out = (float)x.GetRed()/255;
break;
case GREEN:
out = (float)x.GetGreen()/255;
break;
case BLUE:
out = (float)x.GetBlue()/255;
break;
case ALPHA:
out = (float)x.GetAlpha()/255;
}
outImageBufferPointer[( px + w*(py + h*pz ))] += out*( frac_x)*( frac_y)*( frac_z);
outImageBufferPointer[( px + w*(py+1+ h*pz ))] += out*( frac_x)*(1-frac_y)*( frac_z);
outImageBufferPointer[( px + w*(py + h*pz+h))] += out*( frac_x)*( frac_y)*(1-frac_z);
outImageBufferPointer[( px + w*(py+1+ h*pz+h))] += out*( frac_x)*(1-frac_y)*(1-frac_z);
outImageBufferPointer[( px+1 + w*(py + h*pz ))] += out*(1-frac_x)*( frac_y)*( frac_z);
outImageBufferPointer[( px+1 + w*(py + h*pz+h))] += out*(1-frac_x)*( frac_y)*(1-frac_z);
outImageBufferPointer[( px+1 + w*(py+1+ h*pz ))] += out*(1-frac_x)*(1-frac_y)*( frac_z);
outImageBufferPointer[( px+1 + w*(py+1+ h*pz+h))] += out*(1-frac_x)*(1-frac_y)*(1-frac_z);
counterImageBufferPointer[( px + w*(py + h*pz ))] += 1;
counterImageBufferPointer[( px + w*(py+1+ h*pz ))] += 1;
counterImageBufferPointer[( px + w*(py + h*pz+h))] += 1;
counterImageBufferPointer[( px + w*(py+1+ h*pz+h))] += 1;
counterImageBufferPointer[( px+1 + w*(py + h*pz ))] += 1;
counterImageBufferPointer[( px+1 + w*(py + h*pz+h))] += 1;
counterImageBufferPointer[( px+1 + w*(py+1+ h*pz ))] += 1;
counterImageBufferPointer[( px+1 + w*(py+1+ h*pz+h))] += 1;
}
typedef ImageRegionIterator< OutputImageType > OutImageIteratorType;
OutImageIteratorType outIt(outputImage, outputImage->GetLargestPossibleRegion());
outIt.GoToBegin();
typedef ImageRegionConstIterator< itk::Image< short, 3 > > CountImageIteratorType;
CountImageIteratorType counterIt(counterImage, counterImage->GetLargestPossibleRegion());
counterIt.GoToBegin();
while(!outIt.IsAtEnd() && !counterIt.IsAtEnd()){
if (counterIt.Value()>0)
outIt.Set(outIt.Value()/counterIt.Value());
++outIt;
++counterIt;
}
}
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
index 579a772c7e..d92204518a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
@@ -1,498 +1,522 @@
+/*===================================================================
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
#ifndef __itkFiniteDiffOdfMaximaExtractionFilter_cpp
#define __itkFiniteDiffOdfMaximaExtractionFilter_cpp
#include "itkFiniteDiffOdfMaximaExtractionFilter.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#include <vnl/vnl_vector.h>
#include <itkOrientationDistributionFunction.h>
#include <itkContinuousIndex.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <boost/math/special_functions.hpp>
#include <boost/progress.hpp>
using namespace boost::math;
namespace itk {
static bool CompareVectors(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
{
return (v1.magnitude()>v2.magnitude());
}
template< class PixelType, int ShOrder, int NrOdfDirections >
FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::FiniteDiffOdfMaximaExtractionFilter()
: m_Toolkit(FSL)
, m_MaxNumPeaks(2)
, m_PeakThreshold(0.4)
, m_ClusteringThreshold(0.9)
, m_AngularThreshold(0.7)
, m_NumCoeffs((ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder)
, m_NormalizationMethod(MAX_VEC_NORM)
, m_AbsolutePeakThreshold(0)
{
this->SetNumberOfRequiredInputs(1);
}
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::FindCandidatePeaks(OdfType& odf, double thr, std::vector< DirectionType >& container)
{
double gfa = odf.GetGeneralizedFractionalAnisotropy();
//Find the peaks using a finite difference method
bool flag = true;
vnl_vector_fixed< bool, NrOdfDirections > used; used.fill(false);
//Find the peaks
for (int i=0; i<NrOdfDirections; i++)
{
if (used[i])
continue;
double val = odf.GetElement(i);
if (val>thr && val*gfa>m_AbsolutePeakThreshold) // limit to one hemisphere ???
{
flag = true;
std::vector< int > neighbours = odf.GetNeighbors(i);
for (int j=0; j<neighbours.size(); j++)
if (val<=odf.GetElement(neighbours.at(j)))
{
flag = false;
break;
}
if (flag) // point is a peak
{
container.push_back(odf.GetDirection(i).normalize());
used[i] = true;
for (int j=0; j<neighbours.size(); j++)
used[neighbours.at(j)] = true;
}
}
}
}
template< class PixelType, int ShOrder, int NrOdfDirections >
std::vector< vnl_vector_fixed< double, 3 > > FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>::MeanShiftClustering(std::vector< vnl_vector_fixed< double, 3 > >& inDirs)
{
std::vector< DirectionType > outDirs;
if (inDirs.empty())
return inDirs;
DirectionType oldMean, currentMean, workingMean;
std::vector< int > touched;
// initialize
touched.resize(inDirs.size(), 0);
bool free = true;
currentMean = inDirs[0]; // initialize first seed
while (free)
{
oldMean.fill(0.0);
// start mean-shift clustering
float angle = 0.0;
int counter = 0;
while ((currentMean-oldMean).magnitude()>0.0001)
{
counter = 0;
oldMean = currentMean;
workingMean = oldMean;
workingMean.normalize();
currentMean.fill(0.0);
for (int i=0; i<inDirs.size(); i++)
{
angle = dot_product(workingMean, inDirs[i]);
if (angle>=m_ClusteringThreshold)
{
currentMean += inDirs[i];
touched[i] = 1;
counter++;
}
else if (-angle>=m_ClusteringThreshold)
{
currentMean -= inDirs[i];
touched[i] = 1;
counter++;
}
}
}
// found stable mean
if (counter>0)
{
float mag = currentMean.magnitude();
if (mag>0)
{
currentMean /= mag;
outDirs.push_back(currentMean);
}
}
// find next unused seed
free = false;
for (int i=0; i<touched.size(); i++)
if (touched[i]==0)
{
currentMean = inDirs[i];
free = true;
}
}
if (inDirs.size()==outDirs.size())
{
return outDirs;
}
else
return MeanShiftClustering(outDirs);
}
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::BeforeThreadedGenerateData()
{
typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
- mitk::Vector3D spacing = ShCoeffImage->GetSpacing();
+ itk::Vector<double,3> spacing = ShCoeffImage->GetSpacing();
double minSpacing = spacing[0];
if (spacing[1]<minSpacing)
minSpacing = spacing[1];
if (spacing[2]<minSpacing)
minSpacing = spacing[2];
mitk::Point3D origin = ShCoeffImage->GetOrigin();
itk::Matrix<double, 3, 3> direction = ShCoeffImage->GetDirection();
ImageRegion<3> imageRegion = ShCoeffImage->GetLargestPossibleRegion();
+ if (m_MaskImage.IsNotNull())
+ {
+ origin = m_MaskImage->GetOrigin();
+ direction = m_MaskImage->GetDirection();
+ imageRegion = m_MaskImage->GetLargestPossibleRegion();
+ }
+
m_DirectionImageContainer = ItkDirectionImageContainer::New();
for (int i=0; i<m_MaxNumPeaks; i++)
{
itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
ItkDirectionImage::Pointer img = ItkDirectionImage::New();
img->SetSpacing( spacing );
img->SetOrigin( origin );
img->SetDirection( direction );
img->SetRegions( imageRegion );
img->Allocate();
img->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
}
if (m_MaskImage.IsNull())
{
m_MaskImage = ItkUcharImgType::New();
m_MaskImage->SetSpacing( spacing );
m_MaskImage->SetOrigin( origin );
m_MaskImage->SetDirection( direction );
m_MaskImage->SetRegions( imageRegion );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1);
}
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing );
m_NumDirectionsImage->SetOrigin( origin );
m_NumDirectionsImage->SetDirection( direction );
m_NumDirectionsImage->SetRegions( imageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
this->SetNumberOfOutputs(m_MaxNumPeaks);
// calculate SH basis
OdfType odf;
vnl_matrix_fixed<double, 3, NrOdfDirections>* directions = odf.GetDirections();
vnl_matrix< double > sphCoords;
std::vector< DirectionType > dirs;
for (int i=0; i<NrOdfDirections; i++)
dirs.push_back(directions->get_column(i));
Cart2Sph(dirs, sphCoords); // convert candidate peaks to spherical angles
m_ShBasis = CalcShBasis(sphCoords); // evaluate spherical harmonics at each peak
MITK_INFO << "Starting finite differences maximum extraction";
MITK_INFO << "ODF sampling points: " << NrOdfDirections;
MITK_INFO << "SH order: " << ShOrder;
MITK_INFO << "Maximum peaks: " << m_MaxNumPeaks;
MITK_INFO << "Relative threshold: " << m_PeakThreshold;
MITK_INFO << "Absolute threshold: " << m_AbsolutePeakThreshold;
MITK_INFO << "Clustering threshold: " << m_ClusteringThreshold;
MITK_INFO << "Angular threshold: " << m_AngularThreshold;
}
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::AfterThreadedGenerateData()
{
MITK_INFO << "Generating vector field";
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
ImageRegionConstIterator< CoefficientImageType > cit(ShCoeffImage, ShCoeffImage->GetLargestPossibleRegion() );
mitk::Vector3D spacing = ShCoeffImage->GetSpacing();
double minSpacing = spacing[0];
if (spacing[1]<minSpacing)
minSpacing = spacing[1];
if (spacing[2]<minSpacing)
minSpacing = spacing[2];
int maxProgress = ShCoeffImage->GetLargestPossibleRegion().GetSize()[0]*ShCoeffImage->GetLargestPossibleRegion().GetSize()[1]*ShCoeffImage->GetLargestPossibleRegion().GetSize()[2];
boost::progress_display disp(maxProgress);
while( !cit.IsAtEnd() )
{
++disp;
typename CoefficientImageType::IndexType index = cit.GetIndex();
if (m_MaskImage->GetPixel(index)==0)
{
++cit;
continue;
}
for (int i=0; i<m_DirectionImageContainer->Size(); i++)
{
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
itk::Vector< float, 3 > pixel = img->GetPixel(index);
DirectionType dir; dir[0] = pixel[0]; dir[1] = pixel[1]; dir[2] = pixel[2];
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
- ShCoeffImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
+ m_MaskImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
}
++cit;
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
for (int i=0; i<m_DirectionImageContainer->Size(); i++)
{
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
this->SetNthOutput(i, img);
}
}
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
-::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, int threadID )
+::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, ThreadIdType threadID )
{
typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
ImageRegionConstIterator< CoefficientImageType > cit(ShCoeffImage, outputRegionForThread );
OdfType odf;
while( !cit.IsAtEnd() )
{
typename CoefficientImageType::IndexType index = cit.GetIndex();
if (m_MaskImage->GetPixel(index)==0)
{
++cit;
continue;
}
CoefficientPixelType c = cit.Get();
// calculate ODF
double max = 0;
odf.Fill(0.0);
for (int i=0; i<NrOdfDirections; i++)
{
for (int j=0; j<m_NumCoeffs; j++)
odf[i] += c[j]*m_ShBasis(i,j);
if (odf[i]>max)
max = odf[i];
}
if (max<0.0001)
{
++cit;
continue;
}
std::vector< DirectionType > candidates, peaks, temp;
peaks.clear();
max *= m_PeakThreshold; // relative threshold
FindCandidatePeaks(odf, max, candidates); // find all local maxima
candidates = MeanShiftClustering(candidates); // cluster maxima
vnl_matrix< double > shBasis, sphCoords;
Cart2Sph(candidates, sphCoords); // convert candidate peaks to spherical angles
shBasis = CalcShBasis(sphCoords); // evaluate spherical harmonics at each peak
max = 0.0;
for (int i=0; i<candidates.size(); i++) // scale peaks according to ODF value
{
double val = 0;
for (int j=0; j<m_NumCoeffs; j++)
val += c[j]*shBasis(i,j);
if (val>max)
max = val;
peaks.push_back(candidates[i]*val);
}
std::sort( peaks.begin(), peaks.end(), CompareVectors ); // sort peaks
// kick out directions to close to a larger direction (too far away to cluster but too close to keep)
int m = peaks.size();
if ( m>m_DirectionImageContainer->Size() )
m = m_DirectionImageContainer->Size();
for (int i=0; i<m; i++)
{
DirectionType v1 = peaks.at(i);
double val = v1.magnitude();
if (val<max*m_PeakThreshold || val<m_AbsolutePeakThreshold)
break;
bool flag = true;
for (int j=0; j<peaks.size(); j++)
if (i!=j)
{
DirectionType v2 = peaks.at(j);
double val2 = v2.magnitude();
double angle = fabs(dot_product(v1,v2)/(val*val2));
if (angle>m_AngularThreshold && val<val2)
{
flag = false;
break;
}
}
if (flag)
temp.push_back(v1);
}
peaks = temp;
// fill output image
int num = peaks.size();
if ( num>m_DirectionImageContainer->Size() )
num = m_DirectionImageContainer->Size();
for (int i=0; i<num; i++)
{
vnl_vector<double> dir = peaks.at(i);
+
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
switch (m_NormalizationMethod)
{
case NO_NORM:
break;
case SINGLE_VEC_NORM:
dir.normalize();
break;
case MAX_VEC_NORM:
dir /= max;
break;
}
+// dir[0] = -dir[0];
+// dir[2] = -dir[2];
- dir = ShCoeffImage->GetDirection()*dir;
+ dir = m_MaskImage->GetDirection()*dir;
itk::Vector< float, 3 > pixel;
pixel.SetElement(0, dir[0]);
pixel.SetElement(1, dir[1]);
pixel.SetElement(2, dir[2]);
img->SetPixel(index, pixel);
}
m_NumDirectionsImage->SetPixel(index, num);
++cit;
}
MITK_INFO << "Thread " << threadID << " finished extraction";
}
// convert cartesian to spherical coordinates
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::Cart2Sph(const std::vector< DirectionType >& dir, vnl_matrix<double>& sphCoords)
{
sphCoords.set_size(dir.size(), 2);
for (int i=0; i<dir.size(); i++)
{
double mag = dir[i].magnitude();
if( mag<0.0001 )
{
sphCoords(i,0) = M_PI/2; // theta
sphCoords(i,1) = M_PI/2; // phi
}
else
{
sphCoords(i,0) = acos(dir[i](2)/mag); // theta
sphCoords(i,1) = atan2(dir[i](1), dir[i](0)); // phi
}
}
}
// generate spherical harmonic values of the desired order for each input direction
template< class PixelType, int ShOrder, int NrOdfDirections >
vnl_matrix<double> FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::CalcShBasis(vnl_matrix<double>& sphCoords)
{
int M = sphCoords.rows();
int j, m; double mag, plm;
vnl_matrix<double> shBasis;
shBasis.set_size(M, m_NumCoeffs);
for (int p=0; p<M; p++)
{
j=0;
for (int l=0; l<=ShOrder; l=l+2)
for (m=-l; m<=l; m++)
{
switch (m_Toolkit)
{
case FSL:
plm = legendre_p<double>(l,abs(m),cos(sphCoords(p,0)));
mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
if (m<0)
shBasis(p,j) = sqrt(2.0)*mag*cos(fabs((double)m)*sphCoords(p,1));
else if (m==0)
shBasis(p,j) = mag;
else
shBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*sphCoords(p,1));
break;
case MRTRIX:
plm = legendre_p<double>(l,abs(m),-cos(sphCoords(p,0)));
mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
if (m>0)
shBasis(p,j) = mag*cos(m*sphCoords(p,1));
else if (m==0)
shBasis(p,j) = mag;
else
shBasis(p,j) = mag*sin(-m*sphCoords(p,1));
break;
}
j++;
}
}
return shBasis;
}
}
#endif // __itkFiniteDiffOdfMaximaExtractionFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
index 948bff45ad..4af2f1c909 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
@@ -1,144 +1,144 @@
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
Language: C++
Date: $Date: 2006-03-27 17:01:06 $
Version: $Revision: 1.12 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkFiniteDiffOdfMaximaExtractionFilter_h_
#define __itkFiniteDiffOdfMaximaExtractionFilter_h_
#include "itkImageToImageFilter.h"
#include "vnl/vnl_vector_fixed.h"
#include "vnl/vnl_matrix.h"
#include "vnl/algo/vnl_svd.h"
#include "itkVectorContainer.h"
#include "itkVectorImage.h"
#include <mitkFiberBundleX.h>
#include <itkOrientationDistributionFunction.h>
namespace itk{
/**
* \brief Extract ODF peaks by searching all local maxima on a densely sampled ODF und clustering these maxima to get the underlying fiber direction.
* NrOdfDirections: number of sampling points on the ODF surface (about 20000 is a good value)
*/
template< class PixelType, int ShOrder, int NrOdfDirections >
class FiniteDiffOdfMaximaExtractionFilter :
public ImageToImageFilter< Image< Vector< PixelType, (ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder >, 3 >,
Image< Vector< PixelType, 3 >, 3 > >
{
public:
enum Toolkit { ///< SH coefficient convention (depends on toolkit)
FSL,
MRTRIX
};
enum NormalizationMethods {
NO_NORM, ///< no length normalization of the output peaks
SINGLE_VEC_NORM, ///< normalize the single peaks to length 1
MAX_VEC_NORM ///< normalize all peaks according to their length in comparison to the largest peak (0-1)
};
typedef FiniteDiffOdfMaximaExtractionFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< Vector< PixelType, (ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder >, 3 >,
Image< Vector< PixelType, 3 >, 3 > > Superclass;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(FiniteDiffOdfMaximaExtractionFilter, ImageToImageFilter)
typedef typename Superclass::InputImageType CoefficientImageType;
typedef typename CoefficientImageType::RegionType CoefficientImageRegionType;
typedef typename CoefficientImageType::PixelType CoefficientPixelType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef OrientationDistributionFunction<PixelType, NrOdfDirections> OdfType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef vnl_vector_fixed< double, 3 > DirectionType;
typedef Image< Vector< float, 3 >, 3> ItkDirectionImage;
typedef VectorContainer< unsigned int, ItkDirectionImage::Pointer > ItkDirectionImageContainer;
// input
itkSetMacro( MaxNumPeaks, unsigned int) ///< maximum number of peaks per voxel. if more peaks are detected, only the largest are kept.
itkSetMacro( PeakThreshold, double) ///< threshold on the peak length relative to the largest peak inside the current voxel
itkSetMacro( AbsolutePeakThreshold, double) ///< hard threshold on the peak length of all local maxima
itkSetMacro( ClusteringThreshold, double) ///< directions closer together than the specified angular threshold will be clustered (in rad)
itkSetMacro( AngularThreshold, double) ///< directions closer together than the specified threshold that remain after clustering are discarded (largest is kept) (in rad)
itkSetMacro( MaskImage, ItkUcharImgType::Pointer) ///< only voxels inside the binary mask are processed
itkSetMacro( NormalizationMethod, NormalizationMethods) ///< normalization method of ODF peaks
// output
itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer) ///< vector field (peak sizes rescaled for visualization purposes)
itkGetMacro( DirectionImageContainer, ItkDirectionImageContainer::Pointer) ///< container for output peaks
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer) ///< number of peaks per voxel
itkSetMacro( Toolkit, Toolkit) ///< define SH coefficient convention (depends on toolkit)
itkGetMacro( Toolkit, Toolkit) ///< SH coefficient convention (depends on toolkit)
protected:
FiniteDiffOdfMaximaExtractionFilter();
~FiniteDiffOdfMaximaExtractionFilter(){}
void BeforeThreadedGenerateData();
- void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, int threadID );
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadID );
void AfterThreadedGenerateData();
/** Extract all local maxima from the densely sampled ODF surface. Thresholding possible. **/
void FindCandidatePeaks(OdfType& odf, double odfMax, std::vector< DirectionType >& inDirs);
/** Cluster input directions within a certain angular threshold **/
std::vector< DirectionType > MeanShiftClustering(std::vector< DirectionType >& inDirs);
/** Convert cartesian to spherical coordinates **/
void Cart2Sph(const std::vector< DirectionType >& dir, vnl_matrix<double>& sphCoords);
/** Calculate spherical harmonic basis of the defined order **/
vnl_matrix<double> CalcShBasis(vnl_matrix<double>& sphCoords);
private:
NormalizationMethods m_NormalizationMethod; ///< normalization method of ODF peaks
unsigned int m_MaxNumPeaks; ///< maximum number of peaks per voxel. if more peaks are detected, only the largest are kept.
double m_PeakThreshold; ///< threshold on the peak length relative to the largest peak inside the current voxel
double m_AbsolutePeakThreshold;///< hard threshold on the peak length of all local maxima
vnl_matrix< double > m_ShBasis; ///< container for evaluated SH base functions
double m_ClusteringThreshold; ///< directions closer together than the specified angular threshold will be clustered (in rad)
double m_AngularThreshold; ///< directions closer together than the specified threshold that remain after clustering are discarded (largest is kept) (in rad)
const int m_NumCoeffs; ///< number of spherical harmonics coefficients
mitk::FiberBundleX::Pointer m_OutputFiberBundle; ///< vector field (peak sizes rescaled for visualization purposes)
ItkDirectionImageContainer::Pointer m_DirectionImageContainer;///< container for output peaks
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< number of peaks per voxel
ItkUcharImgType::Pointer m_MaskImage; ///< only voxels inside the binary mask are processed
Toolkit m_Toolkit;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkFiniteDiffOdfMaximaExtractionFilter.cpp"
#endif
#endif //__itkFiniteDiffOdfMaximaExtractionFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp
index cc033214ef..357ed381e4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp
@@ -1,157 +1,171 @@
+/*===================================================================
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
#ifndef __itkFslPeakImageConverter_cpp
#define __itkFslPeakImageConverter_cpp
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkFslPeakImageConverter.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#include <itkContinuousIndex.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
namespace itk {
template< class PixelType >
FslPeakImageConverter< PixelType >::FslPeakImageConverter():
m_NormalizationMethod(NO_NORM)
{
}
template< class PixelType >
void FslPeakImageConverter< PixelType >
::GenerateData()
{
// output vector field
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
Vector<float, 4> spacing4 = m_InputImages->GetElement(0)->GetSpacing();
Point<float, 4> origin4 = m_InputImages->GetElement(0)->GetOrigin();
Matrix<double, 4, 4> direction4 = m_InputImages->GetElement(0)->GetDirection();
ImageRegion<4> imageRegion4 = m_InputImages->GetElement(0)->GetLargestPossibleRegion();
- Vector<float, 3> spacing3;
+ itk::Vector<double,3> spacing3;
Point<float, 3> origin3;
Matrix<double, 3, 3> direction3;
ImageRegion<3> imageRegion3;
spacing3[0] = spacing4[0]; spacing3[1] = spacing4[1]; spacing3[2] = spacing4[2];
origin3[0] = origin4[0]; origin3[1] = origin4[1]; origin3[2] = origin4[2];
for (int r=0; r<3; r++)
for (int c=0; c<3; c++)
direction3[r][c] = direction4[r][c];
imageRegion3.SetSize(0, imageRegion4.GetSize()[0]);
imageRegion3.SetSize(1, imageRegion4.GetSize()[1]);
imageRegion3.SetSize(2, imageRegion4.GetSize()[2]);
double minSpacing = spacing3[0];
if (spacing3[1]<minSpacing)
minSpacing = spacing3[1];
if (spacing3[2]<minSpacing)
minSpacing = spacing3[2];
m_DirectionImageContainer = DirectionImageContainerType::New();
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
for (int i=0; i<m_InputImages->Size(); i++)
{
InputImageType::Pointer img = m_InputImages->GetElement(i);
int x = img->GetLargestPossibleRegion().GetSize(0);
int y = img->GetLargestPossibleRegion().GetSize(1);
int z = img->GetLargestPossibleRegion().GetSize(2);
ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
directionImage->SetSpacing( spacing3 );
directionImage->SetOrigin( origin3 );
directionImage->SetDirection( direction3 );
directionImage->SetRegions( imageRegion3 );
directionImage->Allocate();
Vector< PixelType, 3 > nullVec; nullVec.Fill(0.0);
directionImage->FillBuffer(nullVec);
for (int a=0; a<x; a++)
for (int b=0; b<y; b++)
for (int c=0; c<z; c++)
{
// generate vector field
typename InputImageType::IndexType index;
index.SetElement(0,a);
index.SetElement(1,b);
index.SetElement(2,c);
vnl_vector<double> dirVec; dirVec.set_size(4);
for (int k=0; k<3; k++)
{
index.SetElement(3,k);
dirVec[k] = img->GetPixel(index);
}
dirVec[3] = 0;
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 4> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
center[3] = 0;
itk::Point<double, 4> worldCenter;
img->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
switch (m_NormalizationMethod)
{
case NO_NORM:
break;
case SINGLE_VEC_NORM:
dirVec.normalize();
break;
}
dirVec.normalize();
dirVec = img->GetDirection()*dirVec;
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dirVec[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dirVec[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dirVec[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dirVec[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dirVec[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dirVec[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
// generate direction image
typename ItkDirectionImageType::IndexType index2;
index2[0] = index[0]; index2[1] = index[1]; index2[2] = index[2];
Vector< PixelType, 3 > pixel;
pixel.SetElement(0, dirVec[0]);
pixel.SetElement(1, dirVec[1]);
pixel.SetElement(2, dirVec[2]);
directionImage->SetPixel(index2, pixel);
}
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), directionImage);
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
}
}
#endif // __itkFslPeakImageConverter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMergeDiffusionImagesFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMergeDiffusionImagesFilter.txx
index a67828ea84..2c4d9b8e6b 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMergeDiffusionImagesFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMergeDiffusionImagesFilter.txx
@@ -1,176 +1,176 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*=========================================================================
2
3 Program: Tensor ToolKit - TTK
4 Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkMergeDiffusionImagesFilter.txx $
5 Language: C++
6 Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
7 Version: $Revision: 68 $
8
9 Copyright (c) INRIA 2010. All rights reserved.
10 See LICENSE.txt for details.
11
12 This software is distributed WITHOUT ANY WARRANTY; without even
13 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
14 PURPOSE. See the above copyright notices for more information.
15
16 =========================================================================*/
#ifndef _itk_MergeDiffusionImagesFilter_txx_
#define _itk_MergeDiffusionImagesFilter_txx_
#endif
#include "itkMergeDiffusionImagesFilter.h"
#include "itkTensorToL2NormImageFilter.h"
#include "itkRescaleIntensityImageFilter.h"
#include <itkImageRegionIterator.h>
#include <itkImageRegionConstIterator.h>
#include <boost/progress.hpp>
namespace itk
{
template <class TScalarType>
MergeDiffusionImagesFilter<TScalarType>::MergeDiffusionImagesFilter()
{
}
template <class TScalarType>
MergeDiffusionImagesFilter<TScalarType>::~MergeDiffusionImagesFilter()
{
}
template <class TScalarType>
void MergeDiffusionImagesFilter<TScalarType>
::SetImageVolumes(DwiImageContainerType cont)
{
m_ImageVolumes=cont;
}
template <class TScalarType>
void MergeDiffusionImagesFilter<TScalarType>
::SetGradientLists(GradientListContainerType cont)
{
m_GradientLists=cont;
}
template <class TScalarType>
void MergeDiffusionImagesFilter<TScalarType>
::SetBValues(std::vector< double > bvals)
{
m_BValues=bvals;
}
template <class TScalarType>
MergeDiffusionImagesFilter<TScalarType>::GradientListType::Pointer MergeDiffusionImagesFilter<TScalarType>
::GetOutputGradients()
{
return m_OutputGradients;
}
template <class TScalarType>
double MergeDiffusionImagesFilter<TScalarType>
::GetB_Value()
{
return m_BValue;
}
template <class TScalarType>
void
MergeDiffusionImagesFilter<TScalarType>
::GenerateData ()
{
if( m_ImageVolumes.size()<2 )
throw itk::ExceptionObject (__FILE__,__LINE__,"Error: cannot combine less than two DWIs.");
if( m_GradientLists.size()!=m_ImageVolumes.size() || m_ImageVolumes.size()!=m_BValues.size() || m_BValues.size()!=m_GradientLists.size() )
throw itk::ExceptionObject (__FILE__,__LINE__,"Error: need same number of b-values, image volumes and gradient containers.");
typename DwiImageType::Pointer img = m_ImageVolumes.at(0);
m_NumGradients = 0;
for (int i=0; i<m_GradientLists.size(); i++)
{
m_NumGradients += m_GradientLists.at(i)->Size();
typename DwiImageType::Pointer tmp = m_ImageVolumes.at(i);
if ( img->GetLargestPossibleRegion()!=tmp->GetLargestPossibleRegion() )
throw itk::ExceptionObject (__FILE__,__LINE__,"Error: images are not of same size.");
}
m_BValue = m_BValues.at(0);
m_OutputGradients = GradientListType::New();
typename DwiImageType::Pointer outImage = DwiImageType::New();
outImage->SetSpacing( img->GetSpacing() ); // Set the image spacing
outImage->SetOrigin( img->GetOrigin() ); // Set the image origin
outImage->SetDirection( img->GetDirection() ); // Set the image direction
outImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
outImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
outImage->SetRequestedRegion( img->GetLargestPossibleRegion() );
outImage->SetVectorLength(m_NumGradients);
outImage->Allocate();
this->SetNumberOfRequiredOutputs(1);
this->SetNthOutput (0, outImage);
typedef ImageRegionIterator<DwiImageType> IteratorOutputType;
- IteratorOutputType itOut (this->GetOutput(0), this->GetOutput(0)->GetLargestPossibleRegion());
+ IteratorOutputType itOut (this->GetOutput(), this->GetOutput()->GetLargestPossibleRegion());
MITK_INFO << "MergeDiffusionImagesFilter: merging images";
GradientType zeroG; zeroG.fill(0.0);
- boost::progress_display disp(this->GetOutput(0)->GetLargestPossibleRegion().GetNumberOfPixels());
+ boost::progress_display disp(this->GetOutput()->GetLargestPossibleRegion().GetNumberOfPixels());
while(!itOut.IsAtEnd())
{
++disp;
DwiPixelType out;
out.SetSize(m_NumGradients);
out.Fill(0);
int c=0;
for (int i=0; i<m_GradientLists.size(); i++)
{
GradientListType::Pointer gradients = m_GradientLists.at(i);
typename DwiImageType::Pointer img = m_ImageVolumes.at(i);
for (int j=0; j<gradients->Size(); j++)
{
GradientType g = gradients->GetElement(j);
double mag = g.two_norm();
if (mag>0.0001)
{
double frac = m_BValues.at(i)*mag*mag/m_BValue;
g.normalize();
g *= sqrt(frac);
}
else
g = zeroG;
m_OutputGradients->InsertElement(c, g);
out[c] = static_cast<TScalarType>(img->GetPixel(itOut.GetIndex())[j]);
c++;
}
}
itOut.Set(out);
++itOut;
}
}
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp
index 4580f4f34c..07bb728490 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp
@@ -1,168 +1,184 @@
+/*===================================================================
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
#ifndef __itkMrtrixPeakImageConverter_cpp
#define __itkMrtrixPeakImageConverter_cpp
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkMrtrixPeakImageConverter.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#include <itkContinuousIndex.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
namespace itk {
template< class PixelType >
MrtrixPeakImageConverter< PixelType >::MrtrixPeakImageConverter():
m_NormalizationMethod(NO_NORM)
{
}
template< class PixelType >
void MrtrixPeakImageConverter< PixelType >
::GenerateData()
{
// output vector field
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
Vector<float, 4> spacing4 = m_InputImage->GetSpacing();
Point<float, 4> origin4 = m_InputImage->GetOrigin();
Matrix<double, 4, 4> direction4 = m_InputImage->GetDirection();
ImageRegion<4> imageRegion4 = m_InputImage->GetLargestPossibleRegion();
- Vector<float, 3> spacing3;
+ Vector<double, 3> spacing3;
Point<float, 3> origin3;
Matrix<double, 3, 3> direction3;
ImageRegion<3> imageRegion3;
spacing3[0] = spacing4[0]; spacing3[1] = spacing4[1]; spacing3[2] = spacing4[2];
origin3[0] = origin4[0]; origin3[1] = origin4[1]; origin3[2] = origin4[2];
for (int r=0; r<3; r++)
for (int c=0; c<3; c++)
direction3[r][c] = direction4[r][c];
imageRegion3.SetSize(0, imageRegion4.GetSize()[0]);
imageRegion3.SetSize(1, imageRegion4.GetSize()[1]);
imageRegion3.SetSize(2, imageRegion4.GetSize()[2]);
double minSpacing = spacing3[0];
if (spacing3[1]<minSpacing)
minSpacing = spacing3[1];
if (spacing3[2]<minSpacing)
minSpacing = spacing3[2];
m_DirectionImageContainer = DirectionImageContainerType::New();
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
int x = m_InputImage->GetLargestPossibleRegion().GetSize(0);
int y = m_InputImage->GetLargestPossibleRegion().GetSize(1);
int z = m_InputImage->GetLargestPossibleRegion().GetSize(2);
int numDirs = m_InputImage->GetLargestPossibleRegion().GetSize(3)/3;
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing3 );
m_NumDirectionsImage->SetOrigin( origin3 );
m_NumDirectionsImage->SetDirection( direction3 );
m_NumDirectionsImage->SetRegions( imageRegion3 );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
for (int i=0; i<numDirs; i++)
{
ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
directionImage->SetSpacing( spacing3 );
directionImage->SetOrigin( origin3 );
directionImage->SetDirection( direction3 );
directionImage->SetRegions( imageRegion3 );
directionImage->Allocate();
Vector< PixelType, 3 > nullVec; nullVec.Fill(0.0);
directionImage->FillBuffer(nullVec);
for (int a=0; a<x; a++)
for (int b=0; b<y; b++)
for (int c=0; c<z; c++)
{
// generate vector field
typename InputImageType::IndexType index;
index.SetElement(0,a);
index.SetElement(1,b);
index.SetElement(2,c);
vnl_vector<double> dirVec; dirVec.set_size(4);
for (int k=0; k<3; k++)
{
index.SetElement(3,k+i*3);
dirVec[k] = m_InputImage->GetPixel(index);
}
dirVec[3] = 0;
+ if (dirVec.magnitude()<0.0001)
+ continue;
+
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 4> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
center[3] = 0;
itk::Point<double, 4> worldCenter;
m_InputImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
switch (m_NormalizationMethod)
{
case NO_NORM:
break;
case SINGLE_VEC_NORM:
dirVec.normalize();
break;
}
dirVec.normalize();
dirVec = m_InputImage->GetDirection()*dirVec;
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dirVec[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dirVec[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dirVec[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dirVec[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dirVec[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dirVec[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
// generate direction image
typename ItkDirectionImageType::IndexType index2;
index2[0] = a; index2[1] = b; index2[2] = c;
Vector< PixelType, 3 > pixel;
pixel.SetElement(0, dirVec[0]);
pixel.SetElement(1, dirVec[1]);
pixel.SetElement(2, dirVec[2]);
directionImage->SetPixel(index2, pixel);
- if (dirVec.magnitude()>0.0001)
- m_NumDirectionsImage->SetPixel(index2, m_NumDirectionsImage->GetPixel(index2)+1);
+ m_NumDirectionsImage->SetPixel(index2, m_NumDirectionsImage->GetPixel(index2)+1);
}
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), directionImage);
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
}
}
#endif // __itkMrtrixPeakImageConverter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
index f85bbc0c27..23a79eb8cf 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
@@ -1,615 +1,629 @@
+/*===================================================================
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
#ifndef __itkOdfMaximaExtractionFilter_cpp
#define __itkOdfMaximaExtractionFilter_cpp
#include "itkOdfMaximaExtractionFilter.h"
#include <itkImageRegionIterator.h>
#include <itkContinuousIndex.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <boost/progress.hpp>
#include <boost/math/special_functions.hpp>
#include <vnl/vnl_det.h>
#include <vnl/vnl_trace.h>
using namespace boost::math;
using namespace std;
namespace itk {
template< class TOdfPixelType >
OdfMaximaExtractionFilter< TOdfPixelType >::OdfMaximaExtractionFilter():
m_NormalizationMethod(MAX_VEC_NORM),
m_PeakThreshold(0.2),
m_MaxNumPeaks(10),
m_ShCoeffImage(NULL),
m_OutputFiberBundle(NULL),
m_NumDirectionsImage(NULL),
m_DirectionImageContainer(NULL)
{
}
// solve ax? + bx? + cx + d = 0 using cardanos method
template< class TOdfPixelType >
bool OdfMaximaExtractionFilter<TOdfPixelType>::ReconstructQballImage()
{
if (m_ShCoeffImage.IsNotNull())
{
cout << "Using preset coefficient image\n";
return true;
}
cout << "Starting qball reconstruction\n";
try {
QballReconstructionFilterType::Pointer filter = QballReconstructionFilterType::New();
filter->SetGradientImage( m_DiffusionGradients, m_DiffusionImage );
filter->SetBValue(m_Bvalue);
filter->SetLambda(0.006);
filter->SetNormalizationMethod(QballReconstructionFilterType::QBAR_SOLID_ANGLE);
filter->Update();
m_ShCoeffImage = filter->GetCoefficientImage();
if (m_ShCoeffImage.IsNull())
return false;
return true;
}
catch (...)
{
return false;
}
}
// solve ax³ + bx² + cx + d = 0 using cardanos method
template< class TOdfPixelType >
std::vector<double> OdfMaximaExtractionFilter< TOdfPixelType >
::SolveCubic(const double& a, const double& b, const double& c, const double& d)
{
double A, B, p, q, r, D, offset, ee, tmp, root;
vector<double> roots;
double inv3 = 1.0/3.0;
if (a!=0) // solve ax³ + bx² + cx + d = 0
{
p = b/a; q = c/a; r = d/a; // x³ + px² + qx + r = 0
A = q-p*p*inv3;
B = (2.0*p*p*p-9.0*p*q+27.0*r)/27.0;
A = A*inv3;
B = B*0.5;
D = B*B+A*A*A;
offset = p*inv3;
if (D>0.0) // one real root
{
ee = sqrt(D);
tmp = -B+ee; root = cbrt(tmp);
tmp = -B-ee; root += cbrt(tmp);
root -= offset; roots.push_back(root);
}
else if (D<0.0) // three real roots
{
ee = sqrt(-D);
double tmp2 = -B;
double angle = 2.0*inv3*atan(ee/(sqrt(tmp2*tmp2+ee*ee)+tmp2));
double sqrt3 = sqrt(3.0);
tmp = cos(angle);
tmp2 = sin(angle);
ee = sqrt(-A);
root = 2*ee*tmp-offset; roots.push_back(root);
root = -ee*(tmp+sqrt3*tmp2)-offset; roots.push_back(root);
root = -ee*(tmp-sqrt3*tmp2)-offset; roots.push_back(root);
}
else // one or two real roots
{
tmp=-B;
tmp=cbrt(tmp);
root=2*tmp-offset; roots.push_back(root);
if (A!=0 || B!=0)
root=-tmp-offset; roots.push_back(root);
}
}
else if (b!=0) // solve bx² + cx + d = 0
{
D = c*c-4*b*d;
if (D>0)
{
tmp = sqrt(D);
root = (-c+tmp)/(2.0*b); roots.push_back(root);
root = (-c-tmp)/(2.0*b); roots.push_back(root);
}
else if (D==0)
root = -c/(2.0*b); roots.push_back(root);
}
else if (c!=0) // solve cx + d = 0
root = -d/c; roots.push_back(root);
return roots;
}
template< class TOdfPixelType >
double OdfMaximaExtractionFilter< TOdfPixelType >
::ODF_dtheta(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
{
double dtheta=(G-7*E)*sn*sn + (7*F-35*D-H)*sn*cs + (H+C-F-3*A-5*D)*sn + (0.5*E+B+0.5*G)*cs -0.5*G+3.5*E;
return dtheta;
}
template< class TOdfPixelType >
double OdfMaximaExtractionFilter< TOdfPixelType >
::ODF_dtheta2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
{
double dtheta2=4*(G-7*E)*sn*cs + 2*(7*F-35*D-H)*(2*cs*cs-1) + 2*(H+C-F-3*A-5*D)*cs -(E+2*B+G)*sn;
return dtheta2;
}
template< class TOdfPixelType >
double OdfMaximaExtractionFilter< TOdfPixelType >
::ODF_dphi2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
{
double dphi2=35*D*((1+cs)*(1+cs)/4)+(3*A-30*D)*(1+cs)/2.0+3*D-A + 0.5*(7*E*(1+cs)/2.0-3*E+B)*sn + (7*F*(1+cs)/2+C-F)*(1-cs)/2.0 + G*sn*(1-cs)/4.0 + H*((1-cs)*(1-cs)/4);
return dphi2;
}
template< class TOdfPixelType >
void OdfMaximaExtractionFilter< TOdfPixelType >
::FindCandidatePeaks(const CoefficientPixelType& SHcoeff)
{
const double thr = 0.03; // threshold on the derivative of the ODF with respect to theta
const double phi_step = 0.005; // step size for 1D exhaustive search on phi
bool highRes; // when close to maxima increase resolution
double mag, Y, Yp, sn, cs;
double phi, dPhi;
double A, B, C, D, E, F, G, H, Bp, Cp, Ep, Fp, Gp, Hp, Bs, Cs, Es, Fs, Gs, Hs;
CoefficientPixelType a, ap;
a = SHcoeff; ap = SHcoeff;
m_CandidatePeaks.clear(); // clear peaks of last voxel
for (int adaptiveStepwidth=0; adaptiveStepwidth<=1; adaptiveStepwidth++)
{
phi=0;
while (phi<(2*M_PI)) // phi exhaustive search 0..pi
{
// calculate 4th order SH representtaion of ODF and according derivative
for (int l=0; l<=4; l=l+2)
{
for (int m=-l; m<=l; m++)
{
int j=l*(l+1)/2+m;
if (m<0)
{
mag = sqrt(((2*l+1)/(2*M_PI))*factorial<double>(l+m)/factorial<double>(l-m));
Y = mag*cos(m*phi);
Yp = -m*mag*sin(m*phi);
}
else if (m==0)
{
Y = sqrt((2*l+1)/(4*M_PI));
Yp = 0;
}
else
{
mag = pow(-1.0,m)*sqrt(((2*l+1)/(2*M_PI))*factorial<double>(l-m)/factorial<double>(l+m));
Y = mag*sin(m*phi);
Yp = m*mag*cos(m*phi);
}
a[j] = SHcoeff[j]*Y;
ap[j] = SHcoeff[j]*Yp;
}
}
// ODF
A=0.5*a[3]; B=-3*(a[2]+a[4]); C=3*(a[1]+a[5]); D=0.125*a[10]; E=-2.5*(a[9]+a[11]);
F=7.5*(a[8]+a[12]); G=-105*(a[7]+a[13]); H=105*(a[6]+a[14]);
// phi derivative
Bp=-3*(ap[2]+ap[4]); Cp=3*(ap[1]+ap[5]); Ep=-2.5*(ap[9]+ap[11]);
Fp=7.5*(ap[8]+ap[12]); Gp=-105*(ap[7]+ap[13]); Hp=105*(ap[6]+ap[14]);
// 2phi derivative
Bs=-B; Cs=-4*C; Es=-E;
Fs=-4*F; Gs=-9*G; Hs=-16*H;
// solve cubic for tan(theta)
std::vector<double> tanTheta = SolveCubic(Hp+Cp-Fp, Gp+Bp-3*Ep, 6*Fp+Cp, Bp+4*Ep);
highRes = false;
dPhi = phi_step;
//for each real cubic solution for tan(theta)
for (int n=0; n<tanTheta.size(); n++)
{
double tmp = atan(tanTheta[n]); // arcus tangens of root (theta -pi/2..pi/2)
double theta = floor(tmp/M_PI); // project theta to 0..pi ...
theta = tmp - theta*M_PI; // ... as the modulo of the division atan(tth[n])/M_PI
sn = sin(2*theta); cs = cos(2*theta);
tmp = ODF_dtheta(sn, cs, A, B, C, D, E, F, G, H);
if (fabs(tmp) < thr) // second condition for maximum is true (theta derivative < eps)
{
//Compute the Hessian
vnl_matrix_fixed< double, 2, 2 > hessian;
hessian(0,0) = ODF_dtheta2(sn, cs, A, B, C, D, E, F, G, H);
hessian(0,1) = ODF_dtheta(sn, cs, 0, Bp, Cp, 0, Ep, Fp, Gp, Hp);
hessian(1,0) = hessian(0,1);
hessian(1,1) = ODF_dphi2(sn, cs, 0, Bs, Cs, 0, Es, Fs, Gs, Hs);
double det = vnl_det(hessian); // determinant
double tr = vnl_trace(hessian); // trace
highRes = true; // we are close to a maximum, so turn on high resolution 1D exhaustive search
if (det>=0 && tr<=0) // check if we really have a local maximum
{
vnl_vector_fixed< double, 2 > peak;
peak[0] = theta;
peak[1] = phi;
m_CandidatePeaks.push_back(peak);
}
}
if (adaptiveStepwidth) // calculate adaptive step width
{
double t2=tanTheta[n]*tanTheta[n]; double t3=t2*tanTheta[n]; double t4=t3*tanTheta[n];
double const_step=phi_step*(1+t2)/sqrt(t2+t4+pow((((Hs+Cs-Fs)*t3+(Gs+Bs-3*Es)*t2+(6*Fs+Cs)*tanTheta[n]+(Bs+4*Es))/(3*(Hp+Cp-Fp)*t2+2*(Gp+Bp-3*Ep)*tanTheta[n]+(6*Fp+Cp))),2.0));
if (const_step<dPhi)
dPhi=const_step;
}
}
// update phi
if (highRes)
phi=phi+dPhi*0.5;
else
phi=phi+dPhi;
}
}
}
template< class TOdfPixelType >
std::vector< vnl_vector_fixed< double, 3 > > OdfMaximaExtractionFilter< TOdfPixelType >
::ClusterPeaks(const CoefficientPixelType& shCoeff)
{
const double distThres = 0.4;
int npeaks = 0, nMin = 0;
double dMin, dPos, dNeg, d;
Vector3D u;
vector< Vector3D > v;
// initialize container for vector clusters
std::vector < std::vector< Vector3D > > clusters;
clusters.resize(m_CandidatePeaks.size());
for (int i=0; i<m_CandidatePeaks.size(); i++)
{
// calculate cartesian representation of peak
u[0] = sin(m_CandidatePeaks[i](0))*cos(m_CandidatePeaks[i](1));
u[1] = sin(m_CandidatePeaks[i](0))*sin(m_CandidatePeaks[i](1));
u[2] = cos(m_CandidatePeaks[i](0));
dMin = itk::NumericTraits<double>::max();
for (int n=0; n<npeaks; n++) //for each other maximum v already visited
{
// euclidean distance from u/-u to other clusters
dPos = vnl_vector_ssd(v[n],u);
dNeg = vnl_vector_ssd(v[n],-u);
d = std::min(dPos,dNeg);
if ( d<dMin )
{
dMin = d; // adjust minimum
nMin = n; // store its index
if ( dNeg<dPos ) // flip u if neccesary
u=-u;
}
}
if ( dMin<distThres ) // if u is very close to any other maximum v
{
clusters[nMin].push_back(u); //store it with all other vectors that are close to v vector (with index nMin)
}
else // otherwise store u as output peak
{
v.push_back(u);
npeaks++;
}
}
// calculate mean vector of each cluster
for (int i=0; i<m_CandidatePeaks.size(); i++)
if ( !clusters[i].empty() )
{
v[i].fill(0.0);
for (int vc=0; vc<clusters[i].size(); vc++)
v[i]=v[i]+clusters[i][vc];
v[i].normalize();
}
if (npeaks!=0)
{
// check the ODF amplitudes at each candidate peak
vnl_matrix< double > shBasis, sphCoords;
Cart2Sph(v, sphCoords); // convert candidate peaks to spherical angles
shBasis = CalcShBasis(sphCoords, 4); // evaluate spherical harmonics at each peak
vnl_vector<double> odfVals(npeaks);
odfVals.fill(0.0);
double maxVal = itk::NumericTraits<double>::NonpositiveMin();
int maxPos;
for (int i=0; i<npeaks; i++) //compute the ODF value at each peak
{
for (int j=0; j<15; j++)
odfVals(i) += shCoeff[j]*shBasis(i,j);
if ( odfVals(i)>maxVal )
{
maxVal = odfVals(i);
maxPos = i;
}
}
v.clear();
vector< double > restVals;
for (int i=0; i<npeaks; i++) // keep only peaks with high enough amplitude and convert back to cartesian coordinates
if ( odfVals(i)>=m_PeakThreshold*maxVal )
{
u[0] = odfVals(i)*cos(sphCoords(i,1))*sin(sphCoords(i,0));
u[1] = odfVals(i)*sin(sphCoords(i,1))*sin(sphCoords(i,0));
u[2] = odfVals(i)*cos(sphCoords(i,0));
restVals.push_back(odfVals(i));
v.push_back(u);
}
npeaks = v.size();
if (npeaks>m_MaxNumPeaks) // if still too many peaks, keep only the m_MaxNumPeaks with maximum value
{
vector< Vector3D > v2;
for (int i=0; i<m_MaxNumPeaks; i++)
{
maxVal = itk::NumericTraits<double>::NonpositiveMin(); //Get the maximum ODF peak value and the corresponding peak index
for (int i=0; i<npeaks; i++)
if ( restVals[i]>maxVal )
{
maxVal = restVals[i];
maxPos = i;
}
v2.push_back(v[maxPos]);
restVals[maxPos] = 0; //zero that entry in order to find the next maximum
}
return v2;
}
}
return v;
}
// convert cartesian to spherical coordinates
template< class TOdfPixelType >
void OdfMaximaExtractionFilter< TOdfPixelType >
::Cart2Sph(const std::vector< Vector3D >& dir, vnl_matrix<double>& sphCoords)
{
sphCoords.set_size(dir.size(), 2);
for (int i=0; i<dir.size(); i++)
{
double mag = dir[i].magnitude();
if( mag<mitk::eps )
{
sphCoords(i,0) = M_PI/2; // theta
sphCoords(i,1) = M_PI/2; // phi
}
else
{
sphCoords(i,0) = acos(dir[i](2)/mag); // theta
sphCoords(i,1) = atan2(dir[i](1), dir[i](0)); // phi
}
}
}
// generate spherical harmonic values of the desired order for each input direction
template< class TOdfPixelType >
vnl_matrix<double> OdfMaximaExtractionFilter< TOdfPixelType >
::CalcShBasis(vnl_matrix<double>& sphCoords, const int& shOrder)
{
int R = (shOrder+1)*(shOrder+2)/2;
int M = sphCoords.rows();
int j, m; double mag, plm;
vnl_matrix<double> shBasis;
shBasis.set_size(M,R);
for (int p=0; p<M; p++)
{
j=0;
for (int l=0; l<=shOrder; l=l+2)
for (m=-l; m<=l; m++)
{
plm = legendre_p<double>(l,abs(m),cos(sphCoords(p,0)));
mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
if (m<0)
shBasis(p,j) = sqrt(2.0)*mag*cos(fabs((double)m)*sphCoords(p,1));
else if (m==0)
shBasis(p,j) = mag;
else
shBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*sphCoords(p,1));
j++;
}
}
return shBasis;
}
template< class TOdfPixelType >
void OdfMaximaExtractionFilter< TOdfPixelType >
::GenerateData()
{
if (!ReconstructQballImage())
return;
std::cout << "Starting maxima extraction\n";
switch (m_NormalizationMethod)
{
case NO_NORM:
std::cout << "NO_NORM\n";
break;
case SINGLE_VEC_NORM:
std::cout << "SINGLE_VEC_NORM\n";
break;
case MAX_VEC_NORM:
std::cout << "MAX_VEC_NORM\n";
break;
}
typedef ImageRegionConstIterator< CoefficientImageType > InputIteratorType;
InputIteratorType git(m_ShCoeffImage, m_ShCoeffImage->GetLargestPossibleRegion() );
- mitk::Vector3D spacing = m_ShCoeffImage->GetSpacing();
+ itk::Vector<double,3> spacing = m_ShCoeffImage->GetSpacing();
double minSpacing = spacing[0];
if (spacing[1]<minSpacing)
minSpacing = spacing[1];
if (spacing[2]<minSpacing)
minSpacing = spacing[2];
mitk::Point3D origin = m_ShCoeffImage->GetOrigin();
itk::Matrix<double, 3, 3> direction = m_ShCoeffImage->GetDirection();
ImageRegion<3> imageRegion = m_ShCoeffImage->GetLargestPossibleRegion();
// initialize num directions image
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing );
m_NumDirectionsImage->SetOrigin( origin );
m_NumDirectionsImage->SetDirection( direction );
m_NumDirectionsImage->SetRegions( imageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
m_DirectionImageContainer = ItkDirectionImageContainer::New();
for (int i=0; i<m_MaxNumPeaks; i++)
{
itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
ItkDirectionImage::Pointer img = ItkDirectionImage::New();
img->SetSpacing( spacing );
img->SetOrigin( origin );
img->SetDirection( direction );
img->SetRegions( imageRegion );
img->Allocate();
img->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
}
if (m_MaskImage.IsNull())
{
m_MaskImage = ItkUcharImgType::New();
m_MaskImage->SetSpacing( spacing );
m_MaskImage->SetOrigin( origin );
m_MaskImage->SetDirection( direction );
m_MaskImage->SetRegions( imageRegion );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1);
}
itk::ImageRegionIterator<ItkUcharImgType> dirIt(m_NumDirectionsImage, m_NumDirectionsImage->GetLargestPossibleRegion());
itk::ImageRegionIterator<ItkUcharImgType> maskIt(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
int maxProgress = m_MaskImage->GetLargestPossibleRegion().GetSize()[0]*m_MaskImage->GetLargestPossibleRegion().GetSize()[1]*m_MaskImage->GetLargestPossibleRegion().GetSize()[2];
boost::progress_display disp(maxProgress);
git.GoToBegin();
while( !git.IsAtEnd() )
{
++disp;
if (maskIt.Value()<=0)
{
++git;
++dirIt;
++maskIt;
continue;
}
CoefficientPixelType c = git.Get();
FindCandidatePeaks(c);
std::vector< Vector3D > directions = ClusterPeaks(c);
typename CoefficientImageType::IndexType index = git.GetIndex();
float max = 0.0;
for (int i=0; i<directions.size(); i++)
if (directions.at(i).magnitude()>max)
max = directions.at(i).magnitude();
if (max<0.0001)
max = 1.0;
for (int i=0; i<directions.size(); i++)
{
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
itk::Vector< float, 3 > pixel;
vnl_vector<double> dir = directions.at(i);
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
m_ShCoeffImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
switch (m_NormalizationMethod)
{
case NO_NORM:
break;
case SINGLE_VEC_NORM:
dir.normalize();
break;
case MAX_VEC_NORM:
dir /= max;
break;
}
dir = m_MaskImage->GetDirection()*dir;
pixel.SetElement(0, dir[0]);
pixel.SetElement(1, dir[1]);
pixel.SetElement(2, dir[2]);
img->SetPixel(index, pixel);
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
}
dirIt.Set(directions.size());
++git;
++dirIt;
++maskIt;
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
std::cout << "Maxima extraction finished\n";
}
}
#endif // __itkOdfMaximaExtractionFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkProjectionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkProjectionFilter.h
index 25293a3381..163bf99444 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkProjectionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkProjectionFilter.h
@@ -1,130 +1,155 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef ITKPROJECTIONFILTER_H_
#define ITKPROJECTIONFILTER_H_
#include "itkObject.h"
#include "itkImage.h"
#include "mitkImage.h"
#include "mitkTbssImage.h"
namespace itk
{
-class ProjectionFilter : public Object
-{
- /*!
- \brief itkProjectionFilter
-
- \brief Performs the Projection Step of the TBSS algorithm from Smith et al. 2006.
+/**
+ * \brief Projection part of the TBSS pipeline
+ *
+ * This class performs the projection step of the TBSS pipeline
+ * (see Smith et al., 2009. http://dx.doi.org/10.1016/j.neuroimage.2006.02.024 )
+ * As input it takes a binary skeleton, a distance map, and a vector image containing the image gradients
+ * that are typically provided by the itkSkeletonizationFilter and the itkDistanceMapFilter.
*/
+
+class ProjectionFilter : public Object
+{
+
public:
typedef itk::Image<float, 3> RealImageType;
typedef itk::CovariantVector<int,3> VectorType;
typedef itk::Image<VectorType, 3> VectorImageType;
typedef itk::Image<char,3> CharImageType;
typedef itk::Image<float, 4> Float4DImageType;
typedef itk::Image<float, 3> FloatImageType;
- // typedef itk::VectorImageType<float, 3> SubjectVolumesType;
public:
/** */
typedef ProjectionFilter Self;
/** Superclass */
typedef Object Superclass;
/** Smart Pointer */
typedef SmartPointer<Self> Pointer;
/** Smart Pointer */
typedef SmartPointer<const Self> ConstPointer;
/** */
- itkNewMacro( Self);
+ itkNewMacro( Self)
- /** Generate Data. The image will be divided into a number of pieces, a number of threads
- will be spawned and Threaded GenerateData() will be called in each thread. */
+
+ /** \brief Does the actual projection */
void Project();
- itkSetMacro(DistanceMap, RealImageType::Pointer);
- itkSetMacro(Directions, VectorImageType::Pointer);
+ /** \brief Set the distance map
+ *
+ * Sets the distance map that decodes for every voxel the distance to the nearest point on the skeleton.
+ */
+ itkSetMacro(DistanceMap, RealImageType::Pointer)
+
+
+ /** \brief Set the directions
+ *
+ * Sets the direction calculated by the TBSS skeletonization algorithm in itkSkeletonizationFilter.
+ */
+ itkSetMacro(Directions, VectorImageType::Pointer)
- itkSetMacro(Skeleton, CharImageType::Pointer);
- itkSetMacro(Tube, CharImageType::Pointer);
+ /** \brief Set the binary skeleton
+ *
+ * Sets the binary skeleton that defines on which voxels must be projected.
+ */
+ itkSetMacro(Skeleton, CharImageType::Pointer)
- itkSetMacro(AllFA, Float4DImageType::Pointer);
- itkGetMacro(Projections, Float4DImageType::Pointer);
+ /** \brief Set the mask defining tubular structures on the skeleton
+ *
+ * Sets a binary mask that defines wich part of the white matter skeleton are tubular instead of sheet like.
+ * This is important because the a different projection method is used for sheet like structues and
+ * tubular structures.
+ */
+ itkSetMacro(Tube, CharImageType::Pointer)
- itkGetMacro(Projected, RealImageType::Pointer);
+ /** \brief Set a 4D image containing the 3D registered FA maps of all study subjects. */
+ itkSetMacro(AllFA, Float4DImageType::Pointer)
+
+
+ /** \brief Returns a 4D image containing the skeleton projections of all subjects */
+ itkGetMacro(Projections, Float4DImageType::Pointer)
protected:
/** Constructor */
ProjectionFilter();
/** Destructor */
virtual ~ProjectionFilter();
RealImageType::Pointer m_DistanceMap;
VectorImageType::Pointer m_Directions;
CharImageType::Pointer m_Skeleton;
CharImageType::Pointer m_Tube;
Float4DImageType::Pointer m_Projections;
Float4DImageType::Pointer m_AllFA;
- RealImageType::Pointer m_Projected;
-
int round(float x)
{
if (x>0.0) return ((int) (x+0.5));
else return ((int) (x-0.5));
}
protected:
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkProjectionFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkProjectionFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkProjectionFilter.txx
index 3d4ad7ca27..15a6e2417d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkProjectionFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkProjectionFilter.txx
@@ -1,202 +1,201 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _itkProjectionFilter_txx
#define _itkProjectionFilter_txx
#include "itkProjectionFilter.h"
#include "mitkProgressBar.h"
#include <itkSignedMaurerDistanceMapImageFilter.h>
#define SEARCHSIGMA 10 /* length in linear voxel dimensions */
#define MAXSEARCHLENGTH (3*SEARCHSIGMA)
namespace itk
{
ProjectionFilter::ProjectionFilter()
{
}
ProjectionFilter::~ProjectionFilter()
{
}
void ProjectionFilter::Project()
{
// Contains only code for the projection of FA data. The original FSL code contains some extra lines
// For projection of other measurements than FA
mitk::ProgressBar::GetInstance()->AddStepsToDo( 3 );
Float4DImageType::Pointer data_4d_projected = Float4DImageType::New();
data_4d_projected->SetRegions(m_AllFA->GetRequestedRegion());
data_4d_projected->SetDirection(m_AllFA->GetDirection());
data_4d_projected->SetSpacing(m_AllFA->GetSpacing());
data_4d_projected->SetOrigin(m_AllFA->GetOrigin());
data_4d_projected->Allocate();
data_4d_projected->FillBuffer(0.0);
Float4DImageType::SizeType size = m_AllFA->GetRequestedRegion().GetSize();
for(int t=0; t<size[3]; t++)
{
for(int z=1; z<size[2]-1; z++)
{
for(int y=1; y<size[1]-1; y++)
{
std::cout << "x";
for(int x=1; x<size[0]-1; x++)
{
VectorImageType::IndexType ix;
ix[0] = x; ix[1] = y; ix[2] = z;
if(m_Skeleton->GetPixel(ix) != 0)
{
VectorImageType::PixelType dir = m_Directions->GetPixel(ix);
short maxvalX=0, maxvalY=0, maxvalZ=0;
Float4DImageType::IndexType ix4d;
ix4d[0]=x; ix4d[1]=y; ix4d[2]=z; ix4d[3]=t;
float maxval = m_AllFA->GetPixel(ix4d), maxval_weighted = maxval,
exponentfactor = -0.5 * (dir[0]*dir[0]+dir[1]*dir[1]+dir[2]*dir[2]) / (float)(SEARCHSIGMA*SEARCHSIGMA);
- // No cingulum here
+ // No tubular structure here
if(m_Tube->GetPixel(ix) == 0)
{
for(int iters=0;iters<2;iters++)
{
float distance=0;
for(int d=1;d<MAXSEARCHLENGTH;d++)
{
int D=d;
if (iters==1) D=-d;
FloatImageType::IndexType ix3d;
int dx = x+dir[0]*D, dy = y+dir[1]*D, dz = z+dir[2]*D;
ix3d[0] = dx; ix3d[1] = dy; ix3d[2] = dz;
if(dx<0 || dy<0 || dz<0
|| dx>=size[0] && dy<=size[1] && dz<=size[2])
{
d=MAXSEARCHLENGTH;
}
else if(m_DistanceMap->GetPixel(ix3d)>=distance)
{
float distanceweight = exp(d * d * exponentfactor);
distance = m_DistanceMap->GetPixel(ix3d);
ix4d[0]=x+dir[0]*D; ix4d[1]=y+dir[1]*D; ix4d[2]=z+dir[2]*D; ix4d[3]=t;
if(distanceweight*m_AllFA->GetPixel(ix4d)>maxval_weighted)
{
maxval = m_AllFA->GetPixel(ix4d);
maxval_weighted = maxval*distanceweight;
maxvalX = dir[0]*D;
maxvalY = dir[1]*D;
maxvalZ = dir[2]*D;
}
}
else{
d=MAXSEARCHLENGTH;
}
- } // endfor(int d=1;d<MAXSEARCHLENGTH;d++)
+ }
- } // endfor(int iters=0;iters<2;iters++)
- } // endif (m_Tube->GetPixel(ix) == 0)
+ }
+ }
-
- // Cingulum here
+ // Tubular structure
else
{
for(int dy=-MAXSEARCHLENGTH; dy<=MAXSEARCHLENGTH;dy++) {
for(int dx=-MAXSEARCHLENGTH; dx<=MAXSEARCHLENGTH; dx++) {
float distanceweight = exp(-0.5 * (dx*dx+dy*dy) / (float)(SEARCHSIGMA*SEARCHSIGMA) );
float r=sqrt((float)(dx*dx+dy*dy));
if (r>0)
{
int allok=1;
for(float rr=1; rr<=r+0.1; rr++) /* search outwards from centre to current voxel - test that distancemap always increasing */
{
int dx1=round(rr*dx/r);
int dy1=round(rr*dy/r);
int dx2=round((rr+1)*dx/r);
int dy2=round((rr+1)*dy/r);
RealImageType::IndexType ix1, ix2;
ix1[0]=x+dx1; ix1[1]=y+dy1; ix1[2]=z;
ix2[0]=x+dx2; ix2[1]=y+dy2; ix2[2]=z;
if(m_DistanceMap->GetPixel(ix1) > m_DistanceMap->GetPixel(ix2) )
{
allok=0;
}
}
ix4d[0]=x+dx; ix4d[1]=y+dy, ix4d[2]=z; ix4d[3]=t;
if( allok && (distanceweight * m_AllFA->GetPixel(ix4d) > maxval_weighted) )
{
maxval = m_AllFA->GetPixel(ix4d);
maxval_weighted = maxval * distanceweight;
maxvalX=dx;
maxvalY=dy;
maxvalZ=0;
}
- } //endif(r>0)
+ }
- } //endfor(int xxx=-MAXSEARCHLENGTH; xxx<=MAXSEARCHLENGTH; xxx++)
- } // endfor(int dy=-MAXSEARCHLENGTH; dy<=MAXSEARCHLENGTH;y++)
- } // endelse
+ }
+ }
+ }
ix4d[0]=x; ix4d[1]=y; ix4d[2]=z; ix4d[3]=t;
data_4d_projected->SetPixel(ix4d, maxval);
- } // endif(m_Skeleton->GetPixel(x) != 0)
- } // endfor(int x=1; x<size[0]-1; x++)
- } // endfor(int y=1; y<size[1]-1; y++)
- } // endfor(int z=1; z<size[2]-1; z++)
- } // endfor(int t=0; t<size[3]; t++)
+ }
+ }
+ }
+ }
+ }
m_Projections = data_4d_projected;
- } // GenerateData()
+ }
}
#endif // _itkProjectionFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkQBallToRgbImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkQBallToRgbImageFilter.h
index 6a5efc3d54..5ca62e57e7 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkQBallToRgbImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkQBallToRgbImageFilter.h
@@ -1,144 +1,144 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkQBallToRgbImageFilter_h
#define __itkQBallToRgbImageFilter_h
#include "itkUnaryFunctorImageFilter.h"
#include "itkOrientationDistributionFunction.h"
#include "itkRGBAPixel.h"
namespace itk
{
#define __IMG_DAT_ITEM__CEIL_ZERO_ONE__(val) (val) = \
( (val) < 0 ) ? ( 0 ) : ( ( (val)>1 ) ? ( 1 ) : ( (val) ) );
/** \class QBallToRgbImageFilter
*
*/
template <typename TInputImage,
typename TOutputImage=itk::Image<itk::RGBAPixel<unsigned char>,3> >
class QBallToRgbImageFilter :
public ImageToImageFilter<TInputImage,TOutputImage>
{
public:
/** Standard class typedefs. */
typedef QBallToRgbImageFilter Self;
typedef ImageToImageFilter<TInputImage,TOutputImage>
Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef typename TInputImage::PixelType InputPixelType;
typedef typename InputPixelType::ValueType InputValueType;
/** Run-time type information (and related methods). */
itkTypeMacro( QBallToRgbImageFilter, ImageToImageFilter )
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Print internal ivars */
void PrintSelf(std::ostream& os, Indent indent) const
{ this->Superclass::PrintSelf( os, indent ); }
#ifdef ITK_USE_CONCEPT_CHECKING
/** Begin concept checking */
itkConceptMacro(InputHasNumericTraitsCheck,
(Concept::HasNumericTraits<InputValueType>));
/** End concept checking */
#endif
protected:
QBallToRgbImageFilter(){}
virtual ~QBallToRgbImageFilter(){}
void GenerateData()
{
typename InputImageType::Pointer qballImage = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
typename InputImageType::RegionType region = qballImage->GetLargestPossibleRegion();
outputImage->SetSpacing( qballImage->GetSpacing() ); // Set the image spacing
outputImage->SetOrigin( qballImage->GetOrigin() ); // Set the image origin
outputImage->SetDirection( qballImage->GetDirection() ); // Set the image direction
outputImage->SetRegions( qballImage->GetLargestPossibleRegion());
outputImage->Allocate();
typedef ImageRegionConstIterator< InputImageType > QBallImageIteratorType;
QBallImageIteratorType qballIt(qballImage, qballImage->GetLargestPossibleRegion());
typedef ImageRegionIterator< OutputImageType > OutputImageIteratorType;
OutputImageIteratorType outputIt(outputImage, outputImage->GetLargestPossibleRegion());
qballIt.GoToBegin();
outputIt.GoToBegin();
while(!qballIt.IsAtEnd() && !outputIt.IsAtEnd()){
InputPixelType x = qballIt.Get();
typedef itk::OrientationDistributionFunction<float,QBALL_ODFSIZE> OdfType;
OdfType odf(x.GetDataPointer());
int pd = odf.GetPrincipleDiffusionDirection();
if (pd==-1)
MITK_ERROR << "ODF corrupted: GetPrincipleDiffusionDirection returned -1";
vnl_vector_fixed<double,3> dir = OdfType::GetDirection(pd);
const float fa = odf.GetGeneralizedFractionalAnisotropy();
float r = fabs(dir[0]) * fa;
float g = fabs(dir[1]) * fa;
float b = fabs(dir[2]) * fa;
// float a = (fa-(m_OpacLevel-m_OpacWindow/2.0f))/m_OpacWindow;
float a = fa;
__IMG_DAT_ITEM__CEIL_ZERO_ONE__(r);
__IMG_DAT_ITEM__CEIL_ZERO_ONE__(g);
__IMG_DAT_ITEM__CEIL_ZERO_ONE__(b);
__IMG_DAT_ITEM__CEIL_ZERO_ONE__(a);
OutputPixelType out;
out.SetRed( r * 255.0f);
out.SetGreen( g * 255.0f);
out.SetBlue( b * 255.0f);
out.SetAlpha( a * 255.0f);
outputIt.Set(out);
++qballIt;
++outputIt;
}
}
private:
QBallToRgbImageFilter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
} // end namespace itk
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx
index 1e361b6db2..d50bb126d6 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx
@@ -1,289 +1,289 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.txx $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt 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 _itk_ResidualImageFilter_txx_
#define _itk_ResidualImageFilter_txx_
#endif
#include "itkResidualImageFilter.h"
#include <mitkCommon.h>
#include <cmath>
namespace itk
{
template <class TInputScalarType, class TOutputScalarType>
void
ResidualImageFilter<TInputScalarType, TOutputScalarType>
::GenerateData()
{
typename InputImageType::SizeType size = this->GetInput()->GetLargestPossibleRegion().GetSize();
typename InputImageType::SizeType size2 = m_SecondDiffusionImage->GetLargestPossibleRegion().GetSize();
if(size != size2)
{
MITK_ERROR << "Sizes do not match";
return;
}
// Initialize output image
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
outputImage->SetSpacing( this->GetInput()->GetSpacing() ); // Set the image spacing
outputImage->SetOrigin( this->GetInput()->GetOrigin() ); // Set the image origin
outputImage->SetDirection( this->GetInput()->GetDirection() ); // Set the image direction
outputImage->SetRegions( this->GetInput()->GetLargestPossibleRegion() );
outputImage->Allocate();
outputImage->FillBuffer(0.0);
std::vector< std::vector<double> > residuals;
// per slice, per volume
std::vector< std::vector <std::vector<double> > > residualsPerSlice;
// Detrmine number of B0 images
int numberB0=0;
for(int i=0; i<m_Gradients->Size(); i++)
{
GradientDirectionType grad = m_Gradients->ElementAt(i);
if(fabs(grad[0]) < 0.001 && fabs(grad[1]) < 0.001 && fabs(grad[2]) < 0.001)
{
numberB0++;
}
}
residuals.resize(this->GetInput()->GetVectorLength()-numberB0);
// Calculate the standard residual image and for each volume put all residuals in a vector
for(int z=0; z<size[2]; z++)
{
std::vector< std::vector<double> > sliceResiduals; // residuals per volume for this slice
sliceResiduals.resize(this->GetInput()->GetVectorLength()-numberB0);
for(int y=0; y<size[1]; y++)
{
for(int x=0; x<size[0]; x++)
{
// Check if b0 exceeds threshold
itk::Index<3> ix;
ix[0] = x;
ix[1] = y;
ix[2] = z;
typename InputImageType::PixelType p1 = this->GetInput()->GetPixel(ix);
typename InputImageType::PixelType p2 = m_SecondDiffusionImage->GetPixel(ix);
int s1 = p1.GetSize();
int s2 = p2.GetSize();
if(p1.GetSize() != p2.GetSize())
{
MITK_ERROR << "Vector sizes do not match";
return;
}
if(p1.GetElement(m_B0Index) <= m_B0Threshold)
{
continue;
}
double res = 0;
int shift = 0; // correction for the skipped B0 images
for(int i = 0; i<p1.GetSize(); i++)
{
GradientDirectionType grad = m_Gradients->ElementAt(i);
if(!(fabs(grad[0]) < 0.001 && fabs(grad[1]) < 0.001 && fabs(grad[2]) < 0.001))
{
double val1 = (double)p1.GetElement(i);
double val2 = (double)p2.GetElement(i);
res += abs(val1-val2);
residuals[i-shift].push_back(val1-val2);
sliceResiduals[i-shift].push_back(val1-val2);
}
else
{
shift++;
}
}
res = res/p1.GetSize();
outputImage->SetPixel(ix, res);
}
}
residualsPerSlice.push_back(sliceResiduals);
}
// for each dw volume: sort the the measured residuals (for each voxel) to enable determining Q1 and Q3; calculate means
// determine percentage of errors as described in QUALITY ASSESSMENT THROUGH ANALYSIS OF RESIDUALS OF DIFFUSION IMAGE FITTING
// Leemans et al 2008
double q1,q3, median;
std::vector< std::vector<double> >::iterator it = residuals.begin();
while(it != residuals.end())
{
std::vector<double> res = *it;
// sort
std::sort(res.begin(), res.end());
q1 = res[0.25*res.size()];
m_Q1.push_back(q1);
q3 = res[0.75*res.size()];
m_Q3.push_back(q3);
median = res[0.5*res.size()];
double iqr = q3-q1;
double outlierThreshold = median + 1.5*iqr;
double numberOfOutliers = 0.0;
std::vector<double>::iterator resIt = res.begin();
double mean = 0;
while(resIt != res.end())
{
double f = *resIt;
if(f>outlierThreshold)
{
numberOfOutliers++;
}
mean += f;
++resIt;
}
double percOfOutliers = 100 * numberOfOutliers / res.size();
m_PercentagesOfOutliers.push_back(percOfOutliers);
mean /= res.size();
m_Means.push_back(mean);
++it;
}
// Calculate for each slice the number of outliers per volume(dw volume)
std::vector< std::vector <std::vector<double> > >::iterator sliceIt = residualsPerSlice.begin();
while(sliceIt != residualsPerSlice.end())
{
std::vector< std::vector<double> > currentSlice = *sliceIt;
std::vector<double> percentages;
std::vector< std::vector<double> >::iterator volIt = currentSlice.begin();
while(volIt != currentSlice.end())
{
std::vector<double> currentVolume = *volIt;
//sort
std::sort(currentVolume.begin(), currentVolume.end());
q1 = currentVolume[0.25*currentVolume.size()];
q3 = currentVolume[0.75*currentVolume.size()];
median = currentVolume[0.5*currentVolume.size()];
double iqr = q3-q1;
double outlierThreshold = median + 1.5*iqr;
double numberOfOutliers = 0.0;
std::vector<double>::iterator resIt = currentVolume.begin();
double mean;
while(resIt != currentVolume.end())
{
double f = *resIt;
if(f>outlierThreshold)
{
numberOfOutliers++;
}
mean += f;
++resIt;
}
double percOfOutliers = 100 * numberOfOutliers / currentVolume.size();
percentages.push_back(percOfOutliers);
++volIt;
}
m_OutliersPerSlice.push_back(percentages);
++sliceIt;
}
}
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkShCoefficientImageImporter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkShCoefficientImageImporter.cpp
index 6a21735284..84599b9167 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkShCoefficientImageImporter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkShCoefficientImageImporter.cpp
@@ -1,179 +1,193 @@
+/*===================================================================
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
#ifndef __itkShCoefficientImageImporter_cpp
#define __itkShCoefficientImageImporter_cpp
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkShCoefficientImageImporter.h"
#include <itkImageRegionIterator.h>
#include <boost/math/special_functions.hpp>
using namespace boost::math;
namespace itk {
template< class PixelType, int ShOrder >
ShCoefficientImageImporter< PixelType, ShOrder >::ShCoefficientImageImporter()
: m_Toolkit(FSL)
{
m_ShBasis.set_size(QBALL_ODFSIZE, (ShOrder+1)*(ShOrder+2)/2);
}
template< class PixelType, int ShOrder >
void ShCoefficientImageImporter< PixelType, ShOrder >
::GenerateData()
{
CalcShBasis();
if (m_InputImage.IsNull())
return;
Vector<float, 4> spacing4 = m_InputImage->GetSpacing();
Point<float, 4> origin4 = m_InputImage->GetOrigin();
Matrix<double, 4, 4> direction4 = m_InputImage->GetDirection();
ImageRegion<4> imageRegion4 = m_InputImage->GetLargestPossibleRegion();
- Vector<float, 3> spacing3;
+ Vector<double, 3> spacing3;
Point<float, 3> origin3;
Matrix<double, 3, 3> direction3;
ImageRegion<3> imageRegion3;
spacing3[0] = spacing4[0]; spacing3[1] = spacing4[1]; spacing3[2] = spacing4[2];
origin3[0] = origin4[0]; origin3[1] = origin4[1]; origin3[2] = origin4[2];
for (int r=0; r<3; r++)
for (int c=0; c<3; c++)
direction3[r][c] = direction4[r][c];
imageRegion3.SetSize(0, imageRegion4.GetSize()[0]);
imageRegion3.SetSize(1, imageRegion4.GetSize()[1]);
imageRegion3.SetSize(2, imageRegion4.GetSize()[2]);
m_QballImage = QballImageType::New();
m_QballImage->SetSpacing( spacing3 );
m_QballImage->SetOrigin( origin3 );
m_QballImage->SetDirection( direction3 );
m_QballImage->SetRegions( imageRegion3 );
m_QballImage->Allocate();
Vector< PixelType, QBALL_ODFSIZE > nullVec1; nullVec1.Fill(0.0);
m_QballImage->FillBuffer(nullVec1);
m_CoefficientImage = CoefficientImageType::New();
m_CoefficientImage->SetSpacing( spacing3 );
m_CoefficientImage->SetOrigin( origin3 );
m_CoefficientImage->SetDirection( direction3 );
m_CoefficientImage->SetRegions( imageRegion3 );
m_CoefficientImage->Allocate();
Vector< PixelType, (ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder > nullVec2; nullVec2.Fill(0.0);
m_CoefficientImage->FillBuffer(nullVec2);
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
int x = imageRegion4.GetSize(0);
int y = imageRegion4.GetSize(1);
int z = imageRegion4.GetSize(2);
int numCoeffs = imageRegion4.GetSize(3);
for (int a=0; a<x; a++)
for (int b=0; b<y; b++)
for (int c=0; c<z; c++)
{
vnl_matrix<double> coeffs((ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder,1);
typename InputImageType::IndexType index;
index.SetElement(0,a);
index.SetElement(1,b);
index.SetElement(2,c);
typename CoefficientImageType::PixelType pix;
for (int d=0; d<numCoeffs; d++)
{
index.SetElement(3,d);
pix[d] = m_InputImage->GetPixel(index);
coeffs[d][0] = pix[d];
}
typename CoefficientImageType::IndexType index2;
index2.SetElement(0,a);
index2.SetElement(1,b);
index2.SetElement(2,c);
m_CoefficientImage->SetPixel(index2, pix);
typename QballImageType::PixelType pix2;
vnl_matrix<double> odf = m_ShBasis*coeffs;
for (int d=0; d<QBALL_ODFSIZE; d++)
pix2[d] = odf(d,0)*M_PI*4/QBALL_ODFSIZE;
m_QballImage->SetPixel(index2,pix2);
}
}
// generate spherical harmonic values of the desired order for each input direction
template< class PixelType, int ShOrder >
void ShCoefficientImageImporter< PixelType, ShOrder >
::CalcShBasis()
{
vnl_matrix_fixed<double, 2, QBALL_ODFSIZE> sphCoords = GetSphericalOdfDirections();
int j, m; double mag, plm;
for (int p=0; p<QBALL_ODFSIZE; p++)
{
j=0;
for (int l=0; l<=ShOrder; l=l+2)
for (m=-l; m<=l; m++)
{
switch (m_Toolkit)
{
case FSL:
plm = legendre_p<double>(l,abs(m),cos(sphCoords(0,p)));
mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
if (m<0)
m_ShBasis(p,j) = sqrt(2.0)*mag*cos(-m*sphCoords(1,p));
else if (m==0)
m_ShBasis(p,j) = mag;
else
m_ShBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*sphCoords(1,p));
break;
case MRTRIX:
plm = legendre_p<double>(l,abs(m),-cos(sphCoords(0,p)));
mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
if (m>0)
m_ShBasis(p,j) = mag*cos(m*sphCoords(1,p));
else if (m==0)
m_ShBasis(p,j) = mag;
else
m_ShBasis(p,j) = mag*sin(-m*sphCoords(1,p));
break;
}
j++;
}
}
}
// convert cartesian to spherical coordinates
template< class PixelType, int ShOrder >
vnl_matrix_fixed<double, 2, QBALL_ODFSIZE> ShCoefficientImageImporter< PixelType, ShOrder >
::GetSphericalOdfDirections()
{
itk::OrientationDistributionFunction< PixelType, QBALL_ODFSIZE > odf;
vnl_matrix_fixed<double, 3, QBALL_ODFSIZE>* dir = odf.GetDirections();
vnl_matrix_fixed<double, 2, QBALL_ODFSIZE> sphCoords;
for (int i=0; i<QBALL_ODFSIZE; i++)
{
double mag = dir->get_column(i).magnitude();
if( mag<mitk::eps )
{
sphCoords(0,i) = M_PI/2; // theta
sphCoords(1,i) = M_PI/2; // phi
}
else
{
sphCoords(0,i) = acos(dir->get(2,i)/mag); // theta
sphCoords(1,i) = atan2(dir->get(1,i), dir->get(0,i)); // phi
}
}
return sphCoords;
}
}
#endif // __itkShCoefficientImageImporter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx
index 44516823db..66b02ee83f 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx
@@ -1,145 +1,145 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkTensorDerivedMeasurementsFilter_txx
#define __itkTensorDerivedMeasurementsFilter_txx
namespace itk {
template <class TPixel>
TensorDerivedMeasurementsFilter<TPixel>::TensorDerivedMeasurementsFilter() : m_Measure(AD)
{
}
template <class TPixel>
void TensorDerivedMeasurementsFilter<TPixel>::GenerateData()
{
typename TensorImageType::Pointer tensorImage = static_cast< TensorImageType * >( this->ProcessObject::GetInput(0) );
typedef ImageRegionConstIterator< TensorImageType > TensorImageIteratorType;
typedef ImageRegionIterator< OutputImageType > OutputImageIteratorType;
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
typename TensorImageType::RegionType region = tensorImage->GetLargestPossibleRegion();
outputImage->SetSpacing( tensorImage->GetSpacing() ); // Set the image spacing
outputImage->SetOrigin( tensorImage->GetOrigin() ); // Set the image origin
outputImage->SetDirection( tensorImage->GetDirection() ); // Set the image direction
outputImage->SetRegions( tensorImage->GetLargestPossibleRegion());
outputImage->Allocate();
TensorImageIteratorType tensorIt(tensorImage, tensorImage->GetLargestPossibleRegion());
OutputImageIteratorType outputIt(outputImage, outputImage->GetLargestPossibleRegion());
tensorIt.GoToBegin();
outputIt.GoToBegin();
while(!tensorIt.IsAtEnd() && !outputIt.IsAtEnd()){
TensorType tensor = tensorIt.Get();
switch(m_Measure)
{
case FA:
{
TPixel diffusionIndex = tensor.GetFractionalAnisotropy();
outputIt.Set(diffusionIndex);
break;
}
case RA:
{
TPixel diffusionIndex = tensor.GetRelativeAnisotropy();
outputIt.Set(diffusionIndex);
break;
}
case AD:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set(evs[2]);
break;
}
case RD:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set((evs[0]+evs[1])/2.0);
break;
}
case CA:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
if (evs[2] == 0)
{
outputIt.Set(0);
break;
}
outputIt.Set(1.0-(evs[0]+evs[1])/(2.0*evs[2]));
break;
}
case L2:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set(evs[1]);
break;
}
case L3:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set(evs[0]);
break;
}
case MD:
{
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set((evs[0]+evs[0]+evs[0])/3.0);
break;
}
}
++tensorIt;
++outputIt;
}
}
}
#endif // __itkTensorDerivedMeasurements_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h
index 77ee68a9ef..3a6b34f27d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h
@@ -1,143 +1,143 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.h $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt 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 _itk_TensorImageToDiffusionImageFilter_h_
#define _itk_TensorImageToDiffusionImageFilter_h_
#include "itkImageToImageFilter.h"
#include <itkDiffusionTensor3D.h>
namespace itk
{
template <class TInputScalarType, class TOutputScalarType>
class TensorImageToDiffusionImageFilter
: public ImageToImageFilter<itk::Image<itk::DiffusionTensor3D<TInputScalarType>,3>, itk::VectorImage<TOutputScalarType,3> >
{
public:
typedef TInputScalarType InputScalarType;
typedef itk::DiffusionTensor3D<InputScalarType> InputPixelType;
typedef itk::Image<InputPixelType,3> InputImageType;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef TOutputScalarType OutputScalarType;
typedef itk::VectorImage<OutputScalarType,3> OutputImageType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef typename OutputImageType::RegionType OutputImageRegionType;
typedef OutputScalarType BaselineScalarType;
typedef BaselineScalarType BaselinePixelType;
typedef typename itk::Image<BaselinePixelType,3> BaselineImageType;
typedef typename BaselineImageType::RegionType BaselineImageRegionType;
typedef TensorImageToDiffusionImageFilter Self;
typedef ImageToImageFilter<InputImageType, OutputImageType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
itkTypeMacro (TensorImageToDiffusionImageFilter, ImageToImageFilter);
itkStaticConstMacro (ImageDimension, unsigned int,
OutputImageType::ImageDimension);
itkNewMacro (Self);
typedef Vector<double,3> GradientType;
typedef std::vector<GradientType> GradientListType;
/** Manually Set/Get a list of gradients */
void SetGradientList(const GradientListType list)
{
m_GradientList = list;
this->Modified();
}
GradientListType GetGradientList(void) const
{return m_GradientList;}
void SetBValue( const double& bval)
{ m_BValue = bval; }
itkSetMacro(Min, OutputScalarType);
itkSetMacro(Max, OutputScalarType);
protected:
TensorImageToDiffusionImageFilter()
{
m_BValue = 1.0;
m_BaselineImage = 0;
m_Min = 0.0;
m_Max = 10000.0;
};
~TensorImageToDiffusionImageFilter(){};
void PrintSelf (std::ostream& os, Indent indent) const
{
Superclass::PrintSelf (os, indent);
}
void BeforeThreadedGenerateData( void );
void ThreadedGenerateData( const
- OutputImageRegionType &outputRegionForThread, int);
+ OutputImageRegionType &outputRegionForThread, ThreadIdType);
//void GenerateData();
private:
TensorImageToDiffusionImageFilter (const Self&);
void operator=(const Self&);
GradientListType m_GradientList;
double m_BValue;
typename BaselineImageType::Pointer m_BaselineImage;
OutputScalarType m_Min;
OutputScalarType m_Max;
};
} // end of namespace
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTensorImageToDiffusionImageFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx
index 5be8812f3d..f8427db3aa 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx
@@ -1,229 +1,229 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*=========================================================================
2
3 Program: Tensor ToolKit - TTK
4 Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.txx $
5 Language: C++
6 Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
7 Version: $Revision: 68 $
8
9 Copyright (c) INRIA 2010. All rights reserved.
10 See LICENSE.txt for details.
11
12 This software is distributed WITHOUT ANY WARRANTY; without even
13 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
14 PURPOSE. See the above copyright notices for more information.
15
16 =========================================================================*/
#ifndef _itk_TensorImageToDiffusionImageFilter_txx_
#define _itk_TensorImageToDiffusionImageFilter_txx_
#endif
#include "itkTensorImageToDiffusionImageFilter.h"
#include "itkTensorToL2NormImageFilter.h"
#include "itkRescaleIntensityImageFilter.h"
#include <itkImageRegionIterator.h>
#include <itkImageRegionConstIterator.h>
namespace itk
{
//template <class TInputScalarType, class TOutputScalarType>
//void
// TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
// ::GenerateData()
//{
// // Call a method that can be overriden by a subclass to allocate
// // memory for the filter's outputs
// this->AllocateOutputs();
// // Call a method that can be overridden by a subclass to perform
// // some calculations prior to splitting the main computations into
// // separate threads
// this->BeforeThreadedGenerateData();
// // Set up the multithreaded processing
// ThreadStruct str;
// str.Filter = this;
// this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads());
// this->GetMultiThreader()->SetSingleMethod(this->ThreaderCallback, &str);
// // multithread the execution
// this->GetMultiThreader()->SingleMethodExecute();
// // Call a method that can be overridden by a subclass to perform
// // some calculations after all the threads have completed
// this->AfterThreadedGenerateData();
//}
template <class TInputScalarType, class TOutputScalarType>
void
TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
::BeforeThreadedGenerateData()
{
if( m_GradientList.size()==0 )
{
throw itk::ExceptionObject (__FILE__,__LINE__,"Error: gradient list is empty, cannot generate DWI.");
}
// create a B0 image by taking the norm of the tensor field * scale:
typedef itk::TensorToL2NormImageFilter<InputImageType, itk::Image<InputScalarType,3> >
TensorToL2NormFilterType;
typename TensorToL2NormFilterType::Pointer myFilter1 = TensorToL2NormFilterType::New();
myFilter1->SetInput (this->GetInput());
try
{
myFilter1->Update();
}
catch (itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
typename itk::RescaleIntensityImageFilter< itk::Image<InputScalarType,3>, BaselineImageType>::Pointer rescaler=
itk::RescaleIntensityImageFilter<itk::Image<InputScalarType,3>, BaselineImageType>::New();
rescaler->SetOutputMinimum ( m_Min );
rescaler->SetOutputMaximum ( m_Max );
rescaler->SetInput ( myFilter1->GetOutput() );
try
{
rescaler->Update();
}
catch (itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
m_BaselineImage = rescaler->GetOutput();
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( this->GetInput()->GetSpacing() ); // Set the image spacing
outImage->SetOrigin( this->GetInput()->GetOrigin() ); // Set the image origin
outImage->SetDirection( this->GetInput()->GetDirection() ); // Set the image direction
outImage->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion());
outImage->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
outImage->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
outImage->SetVectorLength(m_GradientList.size());
outImage->Allocate();
this->SetNumberOfRequiredOutputs (1);
this->SetNthOutput (0, outImage);
}
template <class TInputScalarType, class TOutputScalarType>
void
TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
- ::ThreadedGenerateData ( const OutputImageRegionType &outputRegionForThread, int threadId )
+ ::ThreadedGenerateData (const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId )
{
typedef ImageRegionIterator<OutputImageType> IteratorOutputType;
typedef ImageRegionConstIterator<InputImageType> IteratorInputType;
typedef ImageRegionConstIterator<BaselineImageType> IteratorBaselineType;
unsigned long numPixels = outputRegionForThread.GetNumberOfPixels();
unsigned long step = numPixels/100;
unsigned long progress = 0;
- IteratorOutputType itOut (this->GetOutput(0), outputRegionForThread);
+ IteratorOutputType itOut (this->GetOutput(), outputRegionForThread);
IteratorInputType itIn (this->GetInput(), outputRegionForThread);
IteratorBaselineType itB0 (m_BaselineImage, outputRegionForThread);
if( threadId==0 )
{
this->UpdateProgress (0.0);
}
while(!itIn.IsAtEnd())
{
if( this->GetAbortGenerateData() )
{
throw itk::ProcessAborted(__FILE__,__LINE__);
}
InputPixelType T = itIn.Get();
BaselinePixelType b0 = itB0.Get();
OutputPixelType out;
out.SetSize(m_GradientList.size());
out.Fill(0);
if( b0 > 0)
{
for( unsigned int i=0; i<m_GradientList.size()-1; i++)
{
GradientType g = m_GradientList[i];
InputPixelType S;
S[0] = g[0]*g[0];
S[1] = g[1]*g[0];
S[2] = g[2]*g[0];
S[3] = g[1]*g[1];
S[4] = g[2]*g[1];
S[5] = g[2]*g[2];
double res =
T[0]*S[0] + T[1]*S[1] + T[2]*S[2] +
T[1]*S[1] + T[3]*S[3] + T[4]*S[4] +
T[2]*S[2] + T[4]*S[4] + T[5]*S[5];
// check for corrupted tensor
if (res>=0)
out[i] = static_cast<OutputScalarType>( 1.0*b0*exp ( -1.0 * m_BValue * res ) );
}
}
out[m_GradientList.size()-1] = b0;
itOut.Set(out);
if( threadId==0 && step>0)
{
if( (progress%step)==0 )
{
this->UpdateProgress ( double(progress)/double(numPixels) );
}
}
++progress;
++itB0;
++itIn;
++itOut;
}
if( threadId==0 )
{
this->UpdateProgress (1.0);
}
}
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToQBallImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToQBallImageFilter.h
index 2f1429f5d6..b0cb2a2aa4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToQBallImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToQBallImageFilter.h
@@ -1,107 +1,107 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToQBallImageFilter.h $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt 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 _itk_TensorImageToQBallImageFilter_h_
#define _itk_TensorImageToQBallImageFilter_h_
#include "itkImageToImageFilter.h"
#include <mitkQBallImage.h>
#include <itkDiffusionTensor3D.h>
namespace itk
{
template <class TInputScalarType, class TOutputScalarType>
class TensorImageToQBallImageFilter
: public ImageToImageFilter<itk::Image<itk::DiffusionTensor3D<TInputScalarType>,3>, itk::Image<itk::Vector<TOutputScalarType,QBALL_ODFSIZE>,3> >
{
public:
typedef TInputScalarType InputScalarType;
typedef itk::DiffusionTensor3D<InputScalarType> InputPixelType;
typedef itk::Image<InputPixelType,3> InputImageType;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef TOutputScalarType OutputScalarType;
typedef itk::Vector<OutputScalarType,QBALL_ODFSIZE> OutputPixelType;
typedef itk::Image<OutputPixelType,3> OutputImageType;
typedef typename OutputImageType::RegionType OutputImageRegionType;
typedef TensorImageToQBallImageFilter Self;
typedef ImageToImageFilter<InputImageType, OutputImageType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
itkTypeMacro (TensorImageToQBallImageFilter, ImageToImageFilter);
itkStaticConstMacro (ImageDimension, unsigned int,
OutputImageType::ImageDimension);
itkNewMacro (Self);
protected:
TensorImageToQBallImageFilter(){};
~TensorImageToQBallImageFilter(){};
void PrintSelf (std::ostream& os, Indent indent) const
{
Superclass::PrintSelf (os, indent);
}
void BeforeThreadedGenerateData( void );
void ThreadedGenerateData( const
- OutputImageRegionType &outputRegionForThread, int);
+ OutputImageRegionType &outputRegionForThread, ThreadIdType);
//void GenerateData();
private:
TensorImageToQBallImageFilter (const Self&);
void operator=(const Self&);
typename InputImageType::Pointer m_ItkTensorImage;
typename OutputImageType::Pointer m_ItkQBallImage;
};
} // end of namespace
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTensorImageToQBallImageFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToQBallImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToQBallImageFilter.txx
index a98499f152..1a0bac3dda 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToQBallImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToQBallImageFilter.txx
@@ -1,131 +1,131 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToQBallImageFilter.txx $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt 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 _itk_TensorImageToQBallImageFilter_txx_
#define _itk_TensorImageToQBallImageFilter_txx_
#endif
#include "itkTensorImageToQBallImageFilter.h"
#include <itkImageRegionIterator.h>
#include <itkImageRegionConstIterator.h>
#include <itkOrientationDistributionFunction.h>
namespace itk
{
template <class TInputScalarType, class TOutputScalarType>
void
TensorImageToQBallImageFilter<TInputScalarType, TOutputScalarType>
::BeforeThreadedGenerateData()
{
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( this->GetInput()->GetSpacing() ); // Set the image spacing
outImage->SetOrigin( this->GetInput()->GetOrigin() ); // Set the image origin
outImage->SetDirection( this->GetInput()->GetDirection() ); // Set the image direction
outImage->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion());
outImage->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
outImage->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
outImage->Allocate();
outImage->FillBuffer(0.0);
this->SetNumberOfRequiredOutputs (1);
this->SetNthOutput (0, outImage);
}
template <class TInputScalarType, class TOutputScalarType>
void
TensorImageToQBallImageFilter<TInputScalarType, TOutputScalarType>
- ::ThreadedGenerateData ( const OutputImageRegionType &outputRegionForThread, int threadId )
+ ::ThreadedGenerateData (const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId )
{
typedef ImageRegionIterator<OutputImageType> IteratorOutputType;
typedef ImageRegionConstIterator<InputImageType> IteratorInputType;
unsigned long numPixels = outputRegionForThread.GetNumberOfPixels();
unsigned long step = numPixels/100;
unsigned long progress = 0;
- IteratorOutputType itOut (this->GetOutput(0), outputRegionForThread);
+ IteratorOutputType itOut (this->GetOutput(), outputRegionForThread);
IteratorInputType itIn (this->GetInput(), outputRegionForThread);
if( threadId==0 )
this->UpdateProgress (0.0);
while(!itIn.IsAtEnd())
{
if( this->GetAbortGenerateData() )
{
throw itk::ProcessAborted(__FILE__,__LINE__);
}
InputPixelType T = itIn.Get();
OutputPixelType out;
float tensorelems[6] = {
(float)T[0],
(float)T[1],
(float)T[2],
(float)T[3],
(float)T[4],
(float)T[5],
};
itk::DiffusionTensor3D<float> tensor(tensorelems);
itk::OrientationDistributionFunction<TOutputScalarType, QBALL_ODFSIZE> odf;
odf.InitFromTensor(tensor);
odf.Normalize();
for( unsigned int i=0; i<QBALL_ODFSIZE; i++)
out[i] = odf.GetElement(i);
itOut.Set(out);
if( threadId==0 && step>0)
{
if( (progress%step)==0 )
{
this->UpdateProgress ( double(progress)/double(numPixels) );
}
}
++progress;
++itIn;
++itOut;
}
if( threadId==0 )
{
this->UpdateProgress (1.0);
}
MITK_INFO << "one thread finished Q-Ball estimation";
}
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.h
index 9fd7134aa7..0136a7bd16 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.h
@@ -1,253 +1,255 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.h $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt 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 _itk_TensorReconstructionWithEigenvalueCorrectionFilter_h_
#define _itk_TensorReconstructionWithEigenvalueCorrectionFilter_h_
#include "itkImageToImageFilter.h"
#include <itkDiffusionTensor3D.h>
#include <itkVectorImage.h>
#include <vnl/algo/vnl_symmetric_eigensystem.h>
#include <math.h>
#include <mitkDiffusionImage.h>
typedef itk::VectorImage<short, 3> ImageType;
namespace itk
{
template <class TDiffusionPixelType, class TTensorPixelType>
class TensorReconstructionWithEigenvalueCorrectionFilter
: public ImageToImageFilter< itk::Image< TDiffusionPixelType, 3 >, itk::Image<itk::DiffusionTensor3D<TTensorPixelType>,3> >
{
public:
typedef TensorReconstructionWithEigenvalueCorrectionFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< TDiffusionPixelType, 3>,
Image< DiffusionTensor3D< TTensorPixelType >, 3 > >
Superclass;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Runtime information support. */
itkTypeMacro(TensorReconstructionWithEigenvalueCorrectionFilter, ImageToImageFilter);
typedef TDiffusionPixelType ReferencePixelType;
typedef TDiffusionPixelType GradientPixelType;
typedef DiffusionTensor3D< TTensorPixelType > TensorPixelType;
/** Reference image data, This image is aquired in the absence
* of a diffusion sensitizing field gradient */
typedef typename Superclass::InputImageType ReferenceImageType;
typedef Image< TensorPixelType, 3 > TensorImageType;
typedef TensorImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType
OutputImageRegionType;
/** Typedef defining one (of the many) gradient images. */
typedef Image< GradientPixelType, 3 > GradientImageType;
/** An alternative typedef defining one (of the many) gradient images.
* It will be assumed that the vectorImage has the same dimension as the
* Reference image and a vector length parameter of \c n (number of
* gradient directions) */
typedef VectorImage< GradientPixelType, 3 > GradientImagesType;
typedef typename GradientImagesType::PixelType GradientVectorType;
/*
/** Holds the tensor basis coefficients G_k
typedef vnl_matrix_fixed< double, 6, 6 > TensorBasisMatrixType;
typedef vnl_matrix< double > CoefficientMatrixType;
*/
/** Holds each magnetic field gradient used to acquire one DWImage */
typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
/** Container to hold gradient directions of the 'n' DW measurements */
typedef VectorContainer< unsigned int,
GradientDirectionType > GradientDirectionContainerType;
/** Another set method to add a gradient directions and its corresponding
* image. The image here is a VectorImage. The user is expected to pass the
* gradient directions in a container. The ith element of the container
* corresponds to the gradient direction of the ith component image the
* VectorImage. For the baseline image, a vector of all zeros
* should be set. */
void SetGradientImage( GradientDirectionContainerType *,
const GradientImagesType *image);
/** Set method to set the reference image. */
void SetReferenceImage( ReferenceImageType *referenceImage )
{
if( m_GradientImageTypeEnumeration == GradientIsInASingleImage)
{
itkExceptionMacro( << "Cannot call both methods:"
<< "AddGradientImage and SetGradientImage. Please call only one of them.");
}
this->ProcessObject::SetNthInput( 0, referenceImage );
m_GradientImageTypeEnumeration = GradientIsInManyImages;
}
/** Get reference image */
virtual ReferenceImageType * GetReferenceImage()
{ return ( static_cast< ReferenceImageType *>(this->ProcessObject::GetInput(0)) ); }
/** Return the gradient direction. idx is 0 based */
virtual GradientDirectionType GetGradientDirection( unsigned int idx) const
{
if( idx >= m_NumberOfGradientDirections )
{
itkExceptionMacro( << "Gradient direction " << idx << "does not exist" );
}
return m_GradientDirectionContainer->ElementAt( idx+1 );
}
itkSetMacro( BValue, TTensorPixelType);
itkSetMacro( B0Threshold, float);
+ itkSetMacro (Flagstatus, int);
itkGetMacro(PseudoInverse, vnl_matrix<double>);
itkGetMacro(H, vnl_matrix<double>);
itkGetMacro(BVec, vnl_vector<double>);
itkGetMacro(B0Mask, vnl_vector<short>);
itkGetMacro(Voxdim, vnl_vector<double>);
mitk::DiffusionImage<short>::Pointer GetOutputDiffusionImage()
{
return m_OutputDiffusionImage;
}
ImageType::Pointer GetVectorImage()
{
return m_VectorImage;
}
itk::Image<short, 3>::Pointer GetMask()
{
return m_MaskImage;
}
//itkGetMacro(OutputDiffusionImage, mitk::DiffusionImage<double>)
//itkGetMacro( GradientDirectionContainer, GradientDirectionContainerType::Pointer);
protected:
TensorReconstructionWithEigenvalueCorrectionFilter();
~TensorReconstructionWithEigenvalueCorrectionFilter() {};
void GenerateData();
typedef enum
{
GradientIsInASingleImage = 1,
GradientIsInManyImages,
Else
} GradientImageTypeEnumeration;
private:
short CheckNeighbours(int x, int y, int z,int f, itk::Size<3> size);
void CalculateAttenuation(vnl_vector<double> org_data, vnl_vector<double> &atten,int nof,int numberb0);
void CalculateTensor(vnl_matrix<double> pseudoInverse,vnl_vector<double> atten, vnl_vector<double> &tensor,int nof,int numberb0);
/** Gradient image was specified in a single image or in multiple images */
GradientImageTypeEnumeration m_GradientImageTypeEnumeration;
/** Number of gradient measurements */
unsigned int m_NumberOfGradientDirections;
/** container to hold gradient directions */
GradientDirectionContainerType::Pointer m_GradientDirectionContainer;
/** b-value */
TTensorPixelType m_BValue;
/** Number of baseline images */
unsigned int m_NumberOfBaselineImages;
mitk::DiffusionImage<short>::Pointer m_OutputDiffusionImage;
ImageType::Pointer m_VectorImage;
float m_B0Threshold;
itk::Image<short, 3>::Pointer m_MaskImage;
vnl_matrix<double> m_PseudoInverse;
vnl_matrix<double> m_H;
vnl_vector<double> m_BVec;
vnl_vector<short> m_B0Mask;
vnl_vector<double> m_Voxdim;
+ int m_Flagstatus;
typename GradientImagesType::Pointer m_GradientImagePointer;
};
} // end of namespace
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTensorReconstructionWithEigenvalueCorrectionFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.txx
index 88d1f7e0ad..7a48b554e8 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.txx
@@ -1,594 +1,605 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.txx $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt 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 _itk_TensorReconstructionWithEigenvalueCorrectionFilter_txx_
#define _itk_TensorReconstructionWithEigenvalueCorrectioFiltern_txx_
#endif
#include "itkImageRegionConstIterator.h"
#include <math.h>
#include <mitkImageWriter.h>
namespace itk
{
template <class TDiffusionPixelType, class TTensorPixelType>
TensorReconstructionWithEigenvalueCorrectionFilter<TDiffusionPixelType, TTensorPixelType>
::TensorReconstructionWithEigenvalueCorrectionFilter()
{
m_B0Threshold = 50.0;
+ m_Flagstatus = 0;
}
template <class TDiffusionPixelType, class TTensorPixelType>
void
TensorReconstructionWithEigenvalueCorrectionFilter<TDiffusionPixelType, TTensorPixelType>
- ::GenerateData ( )
+ ::GenerateData ()
{
+
m_GradientImagePointer = static_cast< GradientImagesType * >(
this->ProcessObject::GetInput(0) );
typename GradientImagesType::SizeType size = m_GradientImagePointer->GetLargestPossibleRegion().GetSize();
int nof = m_GradientDirectionContainer->Size();
int numberb0=0;
int cnt=0;
for(int i=0; i<nof; i++)
{
vnl_vector_fixed <double, 3 > vec = m_GradientDirectionContainer->ElementAt(i);
if(vec[0]<0.0001 && vec[1]<0.0001 && vec[2]<0.0001 && vec[0]>-0.0001&& vec[1]>-0.0001 && vec[2]>-0.0001)
{
numberb0++;
}
}
itk::Vector<double,3u> spacing_term = m_GradientImagePointer->GetSpacing();
itk::Matrix<double,3u,3u> direction_term = m_GradientImagePointer->GetDirection();
vnl_vector <double> spacing_vnl(3);
vnl_matrix <double> dir_vnl (3,3);
for (int i=0;i<3;i++)
{
spacing_vnl[i]=spacing_term[i];
for(int j=0;j<3;j++)
{
dir_vnl[i][j]=direction_term[i][j];
}
}
vnl_matrix <double> vox_dim_step (3,3);
for (int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
vox_dim_step[i][j]=spacing_vnl[i]*dir_vnl[i][j];
}
}
vnl_symmetric_eigensystem <double> eigen_spacing(vox_dim_step);
vnl_vector <double> vox_dim (3);
vox_dim[0]=eigen_spacing.get_eigenvalue(0);
vox_dim[1]=eigen_spacing.get_eigenvalue(1);
vox_dim[2]=eigen_spacing.get_eigenvalue(2);
vox_dim=vox_dim/(vox_dim.min_value());
vnl_matrix<double> directions(nof-numberb0,3);
m_B0Mask.set_size(nof);
for(int i=0; i<nof; i++)
{
vnl_vector_fixed <double, 3 > vec = m_GradientDirectionContainer->ElementAt(i);
if(vec[0]<0.0001 && vec[1]<0.0001 && vec[2]<0.0001 && vec[0]>-0.001&& vec[1]>-0.001 && vec[2]>-0.001)
{
m_B0Mask[i]=1;
}
else
{
m_B0Mask[i]=0;
directions[cnt][0] = vec[0];
directions[cnt][1] = vec[1];
directions[cnt][2] = vec[2];
cnt++;
}
}
vnl_matrix<double> dirsTimesDirsTrans = directions*directions.transpose();
vnl_vector< double> diagonal(nof-numberb0);
vnl_vector< double> b_vec(nof-numberb0);
vnl_vector< double> temporary(3);
for (int i=0;i<nof-numberb0;i++)
{
diagonal[i]=dirsTimesDirsTrans[i][i];
}
double max_diagonal = diagonal.max_value();
- directions=directions*sqrt(m_BValue/1000.0)*(1.0/sqrt(max_diagonal));
+
+ if (m_Flagstatus == 1)
+ {
+ directions=directions*sqrt(m_BValue/1000.0)*(1.0/sqrt(max_diagonal));
+ }
+ else
+ {
+ directions=directions*sqrt(m_BValue)*(1.0/sqrt(max_diagonal));
+ }
+
dirsTimesDirsTrans = directions*directions.transpose();
for (int i=0;i<nof-numberb0;i++)
{
b_vec[i]= dirsTimesDirsTrans[i][i];
}
vnl_matrix<double> H(nof-numberb0, 6);
vnl_matrix<double> H_org(nof-numberb0, 6);
vnl_vector<double> pre_tensor(9);
int etbt[6] = { 0, 4, 8, 1, 5, 2 };
for (int i = 0; i < nof-numberb0; i++)
{
for (int j = 0; j < 3; j++)
{
temporary[j] = -directions[i][j];
}
for (int j = 0; j < 3; j++)
{
for (int k = 0; k < 3; k++)
{
pre_tensor[k + 3 * j] = temporary[k] * directions[i][j];
}
}
for (int j = 0; j < 6; j++)
{
H[i][j] = pre_tensor[etbt[j]];
}
for (int j = 0; j < 3; j++)
{
H[i][3 + j] *= 2.0;
}
}
H_org=H;
vnl_matrix<double> inputtopseudoinverse=H.transpose()*H;
vnl_symmetric_eigensystem<double> eig( inputtopseudoinverse);
vnl_matrix<double> pseudoInverse = eig.pinverse()*H.transpose();
itk::Index<3> ix;
ImageType::Pointer corrected_diffusion = ImageType::New();
corrected_diffusion->SetRegions(size);
corrected_diffusion->SetSpacing(m_GradientImagePointer->GetSpacing());
corrected_diffusion->SetOrigin(m_GradientImagePointer->GetOrigin());
corrected_diffusion->SetVectorLength(nof);
corrected_diffusion->Allocate();
typedef itk::VariableLengthVector<short> VariableVectorType;
VariableVectorType variableLengthVector;
variableLengthVector.SetSize(nof);
// removing negative values
for ( int x=0;x<size[0];x++)
{
for ( int y=0;y<size[1];y++)
{
for ( int z=0;z<size[2];z++)
{
ix[0] = x;
ix[1] = y;
ix[2] = z;
GradientVectorType pixel2 = m_GradientImagePointer->GetPixel(ix);
for( int f=0;f<nof;f++)
{
if(pixel2[f]<0.0) //frank: pixel2[f]<=0.0
{
variableLengthVector[f] = CheckNeighbours(x,y,z,f,size);
}
else
{
variableLengthVector[f] = pixel2[f];
}
}
corrected_diffusion->SetPixel(ix, variableLengthVector);
}
}
}
vnl_vector<double> org_data(nof);
vnl_vector<double> atten(nof-numberb0);
double mean_b=0.0;
double pixel=0.0;
vnl_vector<double> tensor (6);
typedef itk::Image<short, 3> MaskImageType;
MaskImageType::Pointer mask = MaskImageType::New();
mask->SetRegions(m_GradientImagePointer->GetLargestPossibleRegion().GetSize());
mask->SetSpacing(m_GradientImagePointer->GetSpacing());
mask->SetOrigin(m_GradientImagePointer->GetOrigin());
mask->Allocate();
int mask_cnt=0;
for(int x=0;x<size[0];x++)
{
for(int y=0;y<size[1];y++)
{
for(int z=0;z<size[2];z++)
{
mean_b=0.0;
ix[0] = x;
ix[1] = y;
ix[2] = z;
GradientVectorType pixel = m_GradientImagePointer->GetPixel(ix);
for (int i=0;i<nof;i++)
{
if(m_B0Mask[i]==1)
{
mean_b = mean_b + pixel[i];
}
}
mean_b=mean_b/numberb0;
if(mean_b>m_B0Threshold)
{
mask->SetPixel(ix, 1);
mask_cnt++;
}
else
{
mask->SetPixel(ix, 0);
}
}
}
}
std::cout << "Number of voxels in mask: " << mask_cnt << std::endl;
typedef itk::Image< itk::DiffusionTensor3D<float>, 3 > TensorImageType;
TensorImageType::Pointer tensorImg = TensorImageType::New();
tensorImg->SetRegions(m_GradientImagePointer->GetLargestPossibleRegion().GetSize());
tensorImg->SetSpacing(m_GradientImagePointer->GetSpacing());
tensorImg->SetOrigin(m_GradientImagePointer->GetOrigin());
tensorImg->Allocate();
vnl_matrix<double> temp_tensor(3,3);
vnl_vector<double> eigen_vals(3);
int number_of_bads=0;
int old_number_of_bads=10000000000000000;
int diff=1;
vnl_vector< double> pixel_max(nof);
vnl_vector< double> pixel_min(nof);
for (int i=1;i<nof;i++)
{
pixel_max[i]=exp(-b_vec[i]*0.01);// here some values for low and high diffusivity were pre define as 0.01 for low and 5 for high
pixel_min[i]= exp(-b_vec[i]*5);
}
// Correct voxels with negative eigenvalues
while(diff>0)
{
for (int x=0;x<size[0];x++)
{
for (int y=0;y<size[1];y++)
{
for (int z=0;z<size[2];z++)
{
ix[0] = x;
ix[1] = y;
ix[2] = z;
pixel = mask->GetPixel(ix);
itk::DiffusionTensor3D<float> ten;
if(mask->GetPixel(ix) == 1)
{
ix[0] = x;
ix[1] = y;
ix[2] = z;
GradientVectorType pt = corrected_diffusion->GetPixel(ix);
for (int i=0;i<nof;i++)
{
org_data[i]=pt[i];
}
CalculateAttenuation(org_data,atten,nof,numberb0);
CalculateTensor(pseudoInverse,atten,tensor,nof,numberb0);
bool tensor_invalid = false;
// verify tensor, check for -nan values
for( unsigned int j=0; j<tensor.size(); j++)
{
if( tensor[j] != tensor[j])
{
tensor[j] = 0;
tensor_invalid = true;
continue;
}
}
// process only for valid tensors
if(!tensor_invalid)
{
///////////////testing
ten(0,0) = tensor[0];
ten(0,1) = tensor[3];
ten(0,2) = tensor[5];
ten(1,1) = tensor[1];
ten(1,2) = tensor[4];
ten(2,2) = tensor[2];
typename TensorPixelType::EigenValuesArrayType eigenvalues;
ten.ComputeEigenValues(eigenvalues);
temp_tensor[0][0]= tensor[0]; temp_tensor[1][0]= tensor[3]; temp_tensor[2][0]= tensor[5];
temp_tensor[0][1]= tensor[3]; temp_tensor[1][1]= tensor[1]; temp_tensor[2][1]= tensor[4];
temp_tensor[0][2]= tensor[5]; temp_tensor[1][2]= tensor[4]; temp_tensor[2][2]= tensor[2];
vnl_symmetric_eigensystem<double> eigen_tensor(temp_tensor);
eigen_vals[0]=eigen_tensor.get_eigenvalue(0);
eigen_vals[1]=eigen_tensor.get_eigenvalue(1);
eigen_vals[2]=eigen_tensor.get_eigenvalue(2);
}
else
// the tensor is invalid, i.e. contains some NAN entries
{
// set the eigenvalues manually to -1 to force the idx to be marked as bad voxel
eigen_vals[0] = eigen_vals[1] = eigen_vals[2] = -1;
}
if( eigen_vals[0]>0.0 && eigen_vals[1]>0.0 && eigen_vals[2]>0.0)
{
tensorImg->SetPixel(ix, ten);
}//end of if eigenvalues
else
{
number_of_bads++;
ten.Fill(0.0);
tensorImg->SetPixel(ix, ten);
for (int f=0;f<nof;f++)
{
if(pt[f]>pixel_max[f] || pt[f]< pixel_min[f])
{
variableLengthVector[f] = CheckNeighbours(x,y,z,f,size);
}
}
corrected_diffusion->SetPixel(ix, variableLengthVector);
}
}
else
{
ten.Fill(0.0);
tensorImg->SetPixel(ix, ten);
}
}
}
}
diff=old_number_of_bads-number_of_bads;
old_number_of_bads=number_of_bads;
std::cout << "bad voxels: " << number_of_bads << std::endl;
number_of_bads=0;
}
this->SetNthOutput(0, tensorImg);
m_VectorImage = corrected_diffusion;
m_MaskImage = mask;
m_PseudoInverse = pseudoInverse;
m_H = H_org;
m_BVec=b_vec;
m_Voxdim = vox_dim;
}
template <class TDiffusionPixelType, class TTensorPixelType>
void
TensorReconstructionWithEigenvalueCorrectionFilter<TDiffusionPixelType, TTensorPixelType>
::SetGradientImage( GradientDirectionContainerType *gradientDirection,
const GradientImagesType *gradientImage )
{
// Make sure crazy users did not call both AddGradientImage and
// SetGradientImage
if( m_GradientImageTypeEnumeration == GradientIsInManyImages )
{
itkExceptionMacro( << "Cannot call both methods:"
<< "AddGradientImage and SetGradientImage. Please call only one of them.");
}
this->m_GradientDirectionContainer = gradientDirection;
unsigned int numImages = gradientDirection->Size();
this->m_NumberOfBaselineImages = 0;
this->m_NumberOfGradientDirections = numImages - this->m_NumberOfBaselineImages;
// ensure that the gradient image we received has as many components as
// the number of gradient directions
if( gradientImage->GetVectorLength() != this->m_NumberOfBaselineImages + this->m_NumberOfGradientDirections )
{
itkExceptionMacro( << this->m_NumberOfGradientDirections << " gradients + " << this->m_NumberOfBaselineImages
<< "baselines = " << this->m_NumberOfGradientDirections + this->m_NumberOfBaselineImages
<< " directions specified but image has " << gradientImage->GetVectorLength()
<< " components.");
}
this->ProcessObject::SetNthInput( 0,
const_cast< GradientImagesType* >(gradientImage) );
m_GradientImageTypeEnumeration = GradientIsInASingleImage;
}
template <class TDiffusionPixelType, class TTensorPixelType>
short
TensorReconstructionWithEigenvalueCorrectionFilter<TDiffusionPixelType, TTensorPixelType>
::CheckNeighbours(int x, int y, int z,int f, itk::Size<3> size)
{
int init_i, init_j, init_c, limit_i, limit_j, limit_c;
double tempsum=0.0;
double temp_number=0.0;
init_i=x-1;
limit_i=x+2;
if(x==0)
init_i=x;
else if(x==size[0]-1)
limit_i=x+1;
init_j=y-1;
limit_j=y+2;
if(y==0)
init_j=y;
else if(y==size[1]-1)
limit_j=y+1;
init_c=z-1;
limit_c=z+2;
if(z==0)
init_c=z;
else if(z==size[2]-1)
limit_c=z+1;
for(int i=init_i; i<limit_i; i+=2)
{
for (int j=init_j; j<limit_j; j+=2)
{
for (int c=init_c; c<limit_c ;c+=2)
{
itk::Index<3> ix;
ix[0] = i;
ix[1] = j;
ix[2] = c;
GradientVectorType p = m_GradientImagePointer->GetPixel(ix);
if(p[f]>=0.0)
{
tempsum=tempsum+p[f];
temp_number++;
}
}
}
}
if (temp_number==0.0)
{
tempsum=0.0;
}
else
{
tempsum=tempsum/temp_number;
}
short ret = (short)tempsum;
return ret;
}
template <class TDiffusionPixelType, class TTensorPixelType>
void
TensorReconstructionWithEigenvalueCorrectionFilter<TDiffusionPixelType, TTensorPixelType>
::CalculateAttenuation(vnl_vector<double> org_data,vnl_vector<double> &atten,int nof, int numberb0)
{
double mean_b=0.0;
for (int i=0;i<nof;i++)
{
if(m_B0Mask[i]==1)
{
mean_b=mean_b+org_data[i];
}
}
mean_b=mean_b/numberb0;
int cnt=0;
for (int i=0;i<nof;i++)
{
if(m_B0Mask[i]==0)
{
if(org_data[i]<0.001){org_data[i]=0.01;}
atten[cnt]=org_data[i]/mean_b;
cnt++;
}
}
}
template <class TDiffusionPixelType, class TTensorPixelType>
void
TensorReconstructionWithEigenvalueCorrectionFilter<TDiffusionPixelType, TTensorPixelType>
::CalculateTensor(vnl_matrix<double> pseudoInverse,vnl_vector<double> atten,vnl_vector<double> &tensor, int nof,int numberb0)
{
for (int i=0;i<nof-numberb0;i++)
{
atten[i]=log((double)atten[i]);
}
tensor = pseudoInverse*atten;
}// end of void calculate tensor
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToL2NormImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToL2NormImageFilter.h
index c6768e14a4..3c9cbf1ccd 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToL2NormImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToL2NormImageFilter.h
@@ -1,78 +1,78 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _itk_TensorToL2NormImageFilter_h_
#define _itk_TensorToL2NormImageFilter_h_
#include "itkImageToImageFilter.h"
namespace itk
{
template <class TInputImage, class TOutputImage>
class ITK_EXPORT TensorToL2NormImageFilter
: public ImageToImageFilter<TInputImage, TOutputImage>
{
public:
typedef TensorToL2NormImageFilter Self;
typedef ImageToImageFilter<TInputImage, TOutputImage> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
itkTypeMacro (TensorToL2NormImageFilter, ImageToImageFilter);
itkStaticConstMacro (ImageDimension, unsigned int,
TOutputImage::ImageDimension);
itkNewMacro (Self);
typedef TInputImage InputImageType;
typedef typename InputImageType::PixelType InputPixelType;
typedef TOutputImage OutputImageType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef typename OutputImageType::RegionType OutputImageRegionType;
protected:
TensorToL2NormImageFilter(){};
~TensorToL2NormImageFilter(){};
void PrintSelf (std::ostream& os, Indent indent) const
{
Superclass::PrintSelf (os, indent);
}
- void ThreadedGenerateData(const OutputImageRegionType &outputRegionForThread, int threadId);
+ void ThreadedGenerateData(const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId);
private:
TensorToL2NormImageFilter (const Self&);
void operator=(const Self&);
};
} // end of namespace
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTensorToL2NormImageFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToL2NormImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToL2NormImageFilter.txx
index 0a920d23d7..4be0eb3dc8 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToL2NormImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToL2NormImageFilter.txx
@@ -1,99 +1,97 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorToL2NormImageFilter.txx $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt 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 _itk_TensorToL2NormImageFilter_txx_
#define _itk_TensorToL2NormImageFilter_txx_
#endif
#include "itkTensorToL2NormImageFilter.h"
#include <itkImageRegionIterator.h>
#include <itkImageRegionConstIterator.h>
namespace itk
{
template <class TInputImage, class TOutputImage>
- void
- TensorToL2NormImageFilter<TInputImage, TOutputImage>
- ::ThreadedGenerateData ( const OutputImageRegionType &outputRegionForThread, int threadId )
+ void TensorToL2NormImageFilter<TInputImage, TOutputImage>::ThreadedGenerateData(const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId )
{
typedef ImageRegionIterator<OutputImageType> IteratorOutputType;
typedef ImageRegionConstIterator<InputImageType> IteratorInputType;
unsigned long numPixels = outputRegionForThread.GetNumberOfPixels();
unsigned long step = numPixels/100;
unsigned long progress = 0;
IteratorOutputType itOut(this->GetOutput(), outputRegionForThread);
IteratorInputType itIn(this->GetInput(), outputRegionForThread);
if( threadId==0 )
this->UpdateProgress (0.0);
while(!itOut.IsAtEnd())
{
if( this->GetAbortGenerateData() )
throw itk::ProcessAborted(__FILE__,__LINE__);
OutputPixelType out = static_cast<OutputPixelType>( 0.0 ); // be careful, overload in MedINRIA
InputPixelType T = itIn.Get();
if ( !(T[0]==0 && T[1]==0 && T[2]==0 && T[3]==0 && T[4]==0 && T[5]==0) )
{
double sum = T[0]*T[0] + T[3]*T[3] + T[5]*T[5]
+ T[1]*T[2]*2.0 + T[2]*T[4]*2.0 + T[1]*T[4]*2.0;
out = static_cast<OutputPixelType>( vcl_sqrt( sum ));
}
if( threadId==0 && step>0)
{
if( (progress%step)==0 )
this->UpdateProgress ( double(progress)/double(numPixels) );
}
itOut.Set (out);
++progress;
++itOut;
++itIn;
}
if( threadId==0 )
this->UpdateProgress (1.0);
}
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToRgbImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToRgbImageFilter.h
index 76f1415e4b..de19d15f0e 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToRgbImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorToRgbImageFilter.h
@@ -1,150 +1,150 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkTensorToRgbImageFilter_h
#define __itkTensorToRgbImageFilter_h
#include "itkUnaryFunctorImageFilter.h"
#include "itkRGBAPixel.h"
namespace itk
{
#define __IMG_DAT_ITEM__CEIL_ZERO_ONE__(val) (val) = \
( (val) < 0 ) ? ( 0 ) : ( ( (val)>1 ) ? ( 1 ) : ( (val) ) );
/** \class TensorToRgbImageFilter
*
*/
template <typename TInputImage,
typename TOutputImage=itk::Image<itk::RGBAPixel<unsigned char>,3> >
class TensorToRgbImageFilter :
public ImageToImageFilter<TInputImage,TOutputImage>
{
public:
/** Standard class typedefs. */
typedef TensorToRgbImageFilter Self;
typedef ImageToImageFilter<TInputImage,TOutputImage>
Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef typename TInputImage::PixelType InputPixelType;
typedef typename InputPixelType::ValueType InputValueType;
/** Run-time type information (and related methods). */
itkTypeMacro( TensorToRgbImageFilter, ImageToImageFilter );
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Print internal ivars */
void PrintSelf(std::ostream& os, Indent indent) const
{ this->Superclass::PrintSelf( os, indent ); }
#ifdef ITK_USE_CONCEPT_CHECKING
/** Begin concept checking */
itkConceptMacro(InputHasNumericTraitsCheck,
(Concept::HasNumericTraits<InputValueType>));
/** End concept checking */
#endif
protected:
TensorToRgbImageFilter() {};
virtual ~TensorToRgbImageFilter() {};
void GenerateData()
{
typename InputImageType::Pointer tensorImage = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
typename OutputImageType::Pointer outputImage =
- static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
typename InputImageType::RegionType region = tensorImage->GetLargestPossibleRegion();
outputImage->SetSpacing( tensorImage->GetSpacing() ); // Set the image spacing
outputImage->SetOrigin( tensorImage->GetOrigin() ); // Set the image origin
outputImage->SetDirection( tensorImage->GetDirection() ); // Set the image direction
outputImage->SetRegions( tensorImage->GetLargestPossibleRegion());
outputImage->Allocate();
typedef ImageRegionConstIterator< InputImageType > TensorImageIteratorType;
TensorImageIteratorType tensorIt(tensorImage, tensorImage->GetLargestPossibleRegion());
typedef ImageRegionIterator< OutputImageType > OutputImageIteratorType;
OutputImageIteratorType outputIt(outputImage, outputImage->GetLargestPossibleRegion());
tensorIt.GoToBegin();
outputIt.GoToBegin();
while(!tensorIt.IsAtEnd() && !outputIt.IsAtEnd()){
InputPixelType x = tensorIt.Get();
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename InputPixelType::EigenValuesArrayType eigenvalues;
typename InputPixelType::EigenVectorsMatrixType eigenvectors;
x.ComputeEigenAnalysis(eigenvalues, eigenvectors);
// int index = 2;
// if( (eigenvalues[0] >= eigenvalues[1])
// && (eigenvalues[0] >= eigenvalues[2]) )
// index = 0;
// else if(eigenvalues[1] >= eigenvalues[2])
// index = 1;
const float fa = x.GetFractionalAnisotropy();
float r = fabs(eigenvectors(2/*index*/,0)) * fa;
float g = fabs(eigenvectors(2/*index*/,1)) * fa;
float b = fabs(eigenvectors(2/*index*/,2)) * fa;
// float a = (fa-(m_OpacLevel-m_OpacWindow/2.0f))/m_OpacWindow;
float a = fa;
__IMG_DAT_ITEM__CEIL_ZERO_ONE__(r);
__IMG_DAT_ITEM__CEIL_ZERO_ONE__(g);
__IMG_DAT_ITEM__CEIL_ZERO_ONE__(b);
__IMG_DAT_ITEM__CEIL_ZERO_ONE__(a);
OutputPixelType out;
out.SetRed( r * 255.0f);
out.SetGreen( g * 255.0f);
out.SetBlue( b * 255.0f);
out.SetAlpha( a * 255.0f);
outputIt.Set(out);
++tensorIt;
++outputIt;
}
}
private:
TensorToRgbImageFilter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
} // end namespace itk
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
index b8c0261efa..406d1f73a4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
@@ -1,1004 +1,994 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPartialVolumeAnalysisClusteringCalculator.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageToItk.h"
#include "itkScalarImageToHistogramGenerator.h"
#include "itkListSample.h"
#define _USE_MATH_DEFINES
#include <math.h>
#define PVA_PI M_PI
namespace mitk
{
PartialVolumeAnalysisClusteringCalculator::PartialVolumeAnalysisClusteringCalculator()
: m_MaxIt(100), m_StepsNumIntegration(100)
{
}
PartialVolumeAnalysisClusteringCalculator::~PartialVolumeAnalysisClusteringCalculator()
{
}
PartialVolumeAnalysisClusteringCalculator::ParamsType*
PartialVolumeAnalysisClusteringCalculator::InitialGuess(HistType h) const
{
int s = h.xVals.size();
int s30 = 0.3 * s;
int s70 = 0.7 * s;
ParamsType* params = new ParamsType();
params->means[0] = h.xVals(s30);
params->means[1] = h.xVals(s70);
params->sigmas[0] = (h.xVals(s-1) - h.xVals(0)) / 5.0;
params->sigmas[1] = (h.xVals(s-1) - h.xVals(0)) / 5.0;
params->ps[0] = 0.4;
params->ps[1] = 0.4;
return params;
}
PartialVolumeAnalysisClusteringCalculator::ParamsType*
PartialVolumeAnalysisClusteringCalculator::Cluster(HistType h, ParamsType *initialGuess) const
{
ParamsType *params = new ParamsType();
params->Initialize(initialGuess);
double ll = 9999999999999999999.9;
double oll;
double sml = (h.xVals[1] - h.xVals[0]) / 1000;
int arraysz = h.xVals.size();
for (unsigned int it = 0; it < m_MaxIt; it++)
{
// wie sehen basisfunktionen zu aktuellen params aus?
ClusterResultType curves = CalculateCurves(*params,h.xVals);
// summe der basisfunktionen
for(int i=0; i<arraysz; i++)
{
if(curves.combiVals(i) == 0)
{
curves.combiVals(i) = 0.00000000000000000001;
}
}
// alte log likelihood
oll = ll;
ll = 0;
// neue likelihood
for(int i=0; i<arraysz; i++)
{
ll -= h.hVals(i) * log(curves.combiVals(i));
}
if( it>2 && oll-ll < arraysz/2*1e-15 )
{
break;
}
for(int j=0; j<2; j++)
{
VecType array, p(arraysz);
array = curves.vals[j];
for(int i=0; i<arraysz; i++)
{
p(i) = h.hVals(i)*array(i)/curves.combiVals(i);
}
params->ps[j] = 0;
params->means[j] = 0;
for(int i=0; i<arraysz; i++)
{
params->ps[j] += p(i);
params->means[j] += h.xVals(i)*p(i);
}
params->means[j] /= params->ps[j];
VecType vr = h.xVals;
for(int i=0; i<arraysz; i++)
{
vr(i) -= params->means[j];
}
params->sigmas[j] = 0;
for(int i=0; i<arraysz; i++)
{
params->sigmas[j] += vr(i)*vr(i)*p(i);
}
params->sigmas[j] /= params->ps[j];
params->sigmas[j] += sml;
}
double p3 = 0;
for(int i=0; i<arraysz; i++)
{
p3 += h.hVals(i)*curves.mixedVals[0](i)/curves.combiVals(i);
}
p3 += 1e-3;
double sum = 0;
for(int j=0; j<2; j++)
{
params->ps[j] = params->ps[j] + 1e-3;
sum += params->ps[j];
}
sum += p3;
for(int j=0; j<2; j++)
{
params->ps[j] = params->ps[j] / sum;
}
p3 /= sum;
}
return params;
}
void PartialVolumeAnalysisClusteringCalculator::Normalize(ParamsType params, ClusterResultType* curves) const
{
double sum1=0, sum2=0, sum3=0;
int arraysz = curves->vals[0].size();
for(int i=0; i<arraysz; i++)
{
sum1 += curves->vals[0](i);
sum2 += curves->vals[1](i);
sum3 += curves->mixedVals[0](i);
}
sum1 /= params.ps[0];
sum2 /= params.ps[1];
sum3 /= 1.0 -params.ps[0] -params.ps[1];
for(int i=0; i<arraysz; i++)
{
curves->vals[0](i) /= sum1;
curves->vals[1](i) /= sum2;
curves->mixedVals[0](i) /= sum3;
}
for(int i=0; i<arraysz; i++)
{
curves->combiVals(i) = curves->mixedVals[0](i) + curves->vals[0](i) + curves->vals[1](i);
}
}
PartialVolumeAnalysisClusteringCalculator::ClusterResultType
PartialVolumeAnalysisClusteringCalculator::CalculateCurves(ParamsType params, VecType xVals) const
{
int arraysz = xVals.size();
ClusterResultType result(arraysz);
for( int j=0; j<2; j++)
{
for(int i=0; i<arraysz; i++)
{
double d = xVals(i)-params.means[j];
double amp = params.ps[j]/sqrt(2*PVA_PI*params.sigmas[j]);
result.vals[j](i) = amp*exp(-0.5 * (d*d)/params.sigmas[j]);
}
}
for(int i=0; i<arraysz; i++)
{
result.mixedVals[0](i) = 0;
}
for(double t=0; t<=1; t = t + 1.0/(m_StepsNumIntegration-1.0))
{
for(int i=0; i<arraysz; i++)
{
double d = xVals(i)-(t*params.means[0]+(1-t)*params.means[1]);
double v = t*params.sigmas[0]+(1-t)*params.sigmas[1];
double p = 1.0 - params.ps[0] - params.ps[1];
double amp = (1.0/m_StepsNumIntegration) * p / sqrt(2.0*PVA_PI*v);
result.mixedVals[0](i) = result.mixedVals[0](i) + amp*exp(-0.5 * (d*d)/v);
// MITK_INFO << "d=" << d << "v=" <<v << "p=" << p << "amp=" << amp << "result=" << amp*exp(-0.5 * (d*d)/v) << std::endl;
}
// MITK_INFO << "t=" << t << std::endl;
// params.Print();
// result.Print();
}
for(int i=0; i<arraysz; i++)
{
result.combiVals(i) = result.mixedVals[0](i) + result.vals[0](i) + result.vals[1](i);
}
return result;
}
PartialVolumeAnalysisClusteringCalculator::HelperStructPerformRGBClusteringRetval*
PartialVolumeAnalysisClusteringCalculator::PerformRGBClustering(mitk::Image::ConstPointer image, const MitkHistType *histogram) const
{
HelperStructRGBChannels *rgbChannels = new HelperStructRGBChannels();
HelperStructPerformClusteringRetval *resultr = PerformClustering(image, histogram, 2);
rgbChannels->r = resultr->clusteredImage;
HelperStructPerformClusteringRetval *resultg = PerformClustering(image, histogram, 0, resultr);
rgbChannels->g = resultg->clusteredImage;
HelperStructPerformClusteringRetval *resultb = PerformClustering(image, histogram, 1, resultr);
rgbChannels->b = resultb->clusteredImage;
mitk::Image::Pointer outImage = mitk::Image::New();
switch(rgbChannels->r->GetDimension())
{
case 2:
InternalGenerateRGB<2>(rgbChannels, outImage);
break;
case 3:
InternalGenerateRGB<3>(rgbChannels, outImage);
break;
case 4:
InternalGenerateRGB<4>(rgbChannels, outImage);
break;
default:
InternalGenerateRGB<3>(rgbChannels, outImage);
}
HelperStructPerformRGBClusteringRetval *retval
= new HelperStructPerformRGBClusteringRetval();
retval->rgbChannels = rgbChannels;
retval->rgb = outImage;
retval->params = resultr->params;
retval->result = resultr->result;
retval->hist = resultr->hist;
delete resultr;
delete resultg;
return retval;
}
template < unsigned int VImageDimension >
void PartialVolumeAnalysisClusteringCalculator::InternalGenerateRGB( HelperStructRGBChannels *rgbin, mitk::Image::Pointer retval ) const
{
typedef itk::Image< float, VImageDimension > ProbImageType;
typedef itk::Image< typename itk::RGBAPixel<unsigned char>, VImageDimension > RGBImageType;
typedef mitk::ImageToItk<ProbImageType> CastFilterType;
typename CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput( rgbin->r );
castFilter->Update();
typename ProbImageType::Pointer r = castFilter->GetOutput();
castFilter = CastFilterType::New();
castFilter->SetInput( rgbin->g );
castFilter->Update();
typename ProbImageType::Pointer g = castFilter->GetOutput();
typename RGBImageType::Pointer rgb = RGBImageType::New();
rgb->SetSpacing( g->GetSpacing() ); // Set the image spacing
rgb->SetOrigin( g->GetOrigin() ); // Set the image origin
rgb->SetDirection( g->GetDirection() ); // Set the image direction
rgb->SetRegions( g->GetLargestPossibleRegion() );
rgb->Allocate();
itk::ImageRegionConstIterator<ProbImageType>
itr(r, r->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<ProbImageType>
itg(g, g->GetLargestPossibleRegion());
itk::ImageRegionIterator<RGBImageType>
itrgb(rgb, rgb->GetLargestPossibleRegion());
itr = itr.Begin();
itg = itg.Begin();
float maxr = 0;
float maxg = 0;
while( !itr.IsAtEnd() )
{
typename ProbImageType::PixelType pr = itr.Get();
typename ProbImageType::PixelType pg = itg.Get();
if(pr > maxr)
{
maxr = pr;
}
if(pg > maxg)
{
maxg = pg;
}
++itr;
++itg;
}
itr = itr.Begin();
itg = itg.Begin();
itrgb = itrgb.Begin();
while( !itr.IsAtEnd() )
{
typename ProbImageType::PixelType pr = itr.Get();
typename ProbImageType::PixelType pg = itg.Get();
typename RGBImageType::PixelType prgb;
float valr = (pr/maxr)*255.0f;
float valg = (pg/maxg)*255.0f;
float alpha = valr>valg ? valr : valg;
prgb.Set(valr, valg, 0.0f, alpha);
itrgb.Set(prgb);
++itr;
++itg;
++itrgb;
}
retval->InitializeByItk(rgb.GetPointer());
retval->SetVolume(rgb->GetBufferPointer());
}
PartialVolumeAnalysisClusteringCalculator::HelperStructPerformClusteringRetval*
PartialVolumeAnalysisClusteringCalculator::PerformClustering(mitk::Image::ConstPointer image, const MitkHistType *histogram, int classIdent, HelperStructPerformClusteringRetval* precResult) const
{
HelperStructPerformClusteringRetval *retval =
new HelperStructPerformClusteringRetval();
if(precResult == 0)
{
retval->hist = new HistType();
retval->hist->InitByMitkHistogram(histogram);
ParamsType params;
params.Initialize( Cluster(*(retval->hist)) );
ClusterResultType result = CalculateCurves(params,retval->hist->xVals);
Normalize(params, &result);
retval->params = new ParamsType();
retval->params->Initialize(&params);
retval->result = new ClusterResultType(10);
retval->result->Initialize(&result);
}
else
{
retval->params = new ParamsType();
retval->params->Initialize(precResult->params);
retval->result = new ClusterResultType(10);
retval->result->Initialize(precResult->result);
}
VecType totalProbs = retval->result->combiVals;
VecType pvProbs = retval->result->mixedVals[0];
VecType fiberProbs;
VecType nonFiberProbs;
VecType interestingProbs;
double p_fiber;
double p_nonFiber;
double p_interesting;
// if(retval->params->means[0]<retval->params->means[1])
// {
fiberProbs = retval->result->vals[1];
nonFiberProbs = retval->result->vals[0];
p_fiber = retval->params->ps[1];
p_nonFiber = retval->params->ps[0];
// }
// else
// {
// fiberProbs = retval->result->vals[0];
// nonFiberProbs = retval->result->vals[1];
// p_fiber = retval->params->ps[0];
// p_nonFiber = retval->params->ps[1];
// }
switch(classIdent)
{
case 0:
interestingProbs = nonFiberProbs;
p_interesting = p_nonFiber;
break;
case 1:
interestingProbs = pvProbs;
p_interesting = 1 - p_fiber - p_nonFiber;
break;
case 2:
default:
interestingProbs = fiberProbs;
p_interesting = p_fiber;
break;
}
double sum = histogram->GetTotalFrequency();
// initialize two histograms for class and total probabilities
- MitkHistType::MeasurementVectorType min;
- MitkHistType::MeasurementVectorType max;
+ MitkHistType::MeasurementVectorType min(1);
+ MitkHistType::MeasurementVectorType max(1);
min.Fill(histogram->GetDimensionMins(0)[0]);
max.Fill(histogram->GetDimensionMaxs(0)[histogram->GetDimensionMaxs(0).size()-1]);
MitkHistType::Pointer interestingHist = MitkHistType::New();
+ interestingHist->SetMeasurementVectorSize(1);
interestingHist->Initialize(histogram->GetSize(),min,max);
MitkHistType::Iterator newIt = interestingHist->Begin();
MitkHistType::Iterator newEnd = interestingHist->End();
MitkHistType::Pointer totalHist = MitkHistType::New();
+ totalHist->SetMeasurementVectorSize(1);
totalHist->Initialize(histogram->GetSize(),min,max);
MitkHistType::Iterator totalIt = totalHist->Begin();
MitkHistType::Iterator totalEnd = totalHist->End();
int i=0;
while (newIt != newEnd)
{
newIt.SetFrequency(interestingProbs(i)*sum);
totalIt.SetFrequency(totalProbs(i)*sum);
++newIt;
++totalIt;
++i;
}
mitk::Image::Pointer outImage1 = mitk::Image::New();
mitk::Image::Pointer outImage2 = mitk::Image::New();
HelperStructClusteringResults clusterResults;
clusterResults.interestingHist = interestingHist;
clusterResults.totalHist = totalHist;
clusterResults.p_interesting = p_interesting;
AccessFixedDimensionByItk_3(
image.GetPointer(),
InternalGenerateProbabilityImage,
3,
clusterResults,
outImage1, outImage2);
retval->clusteredImage = outImage1;
retval->displayImage = outImage2;
return retval;
}
template < typename TPixel, unsigned int VImageDimension >
void PartialVolumeAnalysisClusteringCalculator::InternalGenerateProbabilityImage(
const itk::Image< TPixel, VImageDimension > *image,
const HelperStructClusteringResults clusterResults,
mitk::Image::Pointer outImage1, mitk::Image::Pointer outImage2 ) const
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< itk::RGBAPixel<unsigned char>, VImageDimension > DisplayImageType;
typedef itk::Image< float, VImageDimension > ProbImageType;
typename ProbImageType::Pointer probimage = ProbImageType::New();
probimage->SetSpacing( image->GetSpacing() ); // Set the image spacing
probimage->SetOrigin( image->GetOrigin() ); // Set the image origin
probimage->SetDirection( image->GetDirection() ); // Set the image direction
probimage->SetRegions( image->GetLargestPossibleRegion() );
probimage->Allocate();
probimage->FillBuffer(0);
typename DisplayImageType::Pointer displayimage = DisplayImageType::New();
displayimage->SetSpacing( image->GetSpacing() ); // Set the image spacing
displayimage->SetOrigin( image->GetOrigin() ); // Set the image origin
displayimage->SetDirection( image->GetDirection() ); // Set the image direction
displayimage->SetRegions( image->GetLargestPossibleRegion() );
displayimage->Allocate();
typename DisplayImageType::PixelType rgba;
rgba.Set(0.0f, 0.0f, 0.0f, 0.0f);
displayimage->FillBuffer(rgba);
itk::ImageRegionConstIterator<ImageType>
itimage(image, image->GetLargestPossibleRegion());
itk::ImageRegionIterator<ProbImageType>
itprob(probimage, probimage->GetLargestPossibleRegion());
itk::ImageRegionIterator<DisplayImageType>
itdisp(displayimage, displayimage->GetLargestPossibleRegion());
itimage = itimage.Begin();
itprob = itprob.Begin();
- MitkHistType::IndexType index;
+ MitkHistType::IndexType index(1);
float maxp = 0;
while( !itimage.IsAtEnd() )
{
if(itimage.Get())
{
- MitkHistType::MeasurementVectorType meas;
+ MitkHistType::MeasurementVectorType meas(1);
meas.Fill(itimage.Get());
double aposteriori = 0;
bool success = clusterResults.interestingHist->GetIndex(meas, index );
if(success)
{
double aprioriProb = clusterResults.interestingHist->GetFrequency(index);
double intensityProb = clusterResults.totalHist->GetFrequency(index);
double p_interesting = clusterResults.p_interesting;
aposteriori = p_interesting * aprioriProb / intensityProb;
}
else
{
MITK_ERROR << "index not found in histogram";
}
if(aposteriori > 0.0000000000000001)
{
itprob.Set( aposteriori );
maxp = aposteriori > maxp ? aposteriori : maxp;
}
else
{
itprob.Set(0.0f);
}
}
++itimage;
++itprob;
}
itprob = itprob.Begin();
itdisp = itdisp.Begin();
while( !itprob.IsAtEnd() )
{
if(itprob.Get())
{
typename DisplayImageType::PixelType rgba;
rgba.Set(255.0f, 0.0f, 0.0f, 255.0f*(itprob.Get()/maxp));
itdisp.Set( rgba );
}
++itprob;
++itdisp;
}
outImage1->InitializeByItk(probimage.GetPointer());
outImage1->SetVolume(probimage->GetBufferPointer());
outImage2->InitializeByItk(displayimage.GetPointer());
outImage2->SetVolume(displayimage->GetBufferPointer());
}
double* PartialVolumeAnalysisClusteringCalculator::PerformQuantification(
mitk::Image::ConstPointer image, mitk::Image::Pointer clusteredImage, mitk::Image::Pointer mask) const
{
double *retval = new double[2];
AccessFixedDimensionByItk_3(
image.GetPointer(),
InternalQuantify,
3,
clusteredImage.GetPointer(),
retval, mask );
return retval;
}
template < typename TPixel, unsigned int VImageDimension >
void PartialVolumeAnalysisClusteringCalculator::InternalQuantify(
const itk::Image< TPixel, VImageDimension > *image,
mitk::Image::Pointer clusteredImage, double* retval, mitk::Image::Pointer mask ) const
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< float, VImageDimension > ProbImageType;
typedef itk::Image< unsigned char, VImageDimension > MaskImageType;
typedef mitk::ImageToItk<ProbImageType> CastFilterType;
typename CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput( clusteredImage );
castFilter->Update();
typename ProbImageType::Pointer clusterImage = castFilter->GetOutput();
typename MaskImageType::Pointer itkmask = 0;
if(mask.IsNotNull())
{
typedef mitk::ImageToItk<MaskImageType> CastFilterType2;
typename CastFilterType2::Pointer castFilter2 = CastFilterType2::New();
castFilter2->SetInput( mask );
castFilter2->Update();
itkmask = castFilter2->GetOutput();
}
else
{
itkmask = MaskImageType::New();
itkmask->SetSpacing( clusterImage->GetSpacing() ); // Set the image spacing
itkmask->SetOrigin( clusterImage->GetOrigin() ); // Set the image origin
itkmask->SetDirection( clusterImage->GetDirection() ); // Set the image direction
itkmask->SetRegions( clusterImage->GetLargestPossibleRegion() );
itkmask->Allocate();
itkmask->FillBuffer(1);
}
itk::ImageRegionConstIterator<ImageType>
itimage(image, image->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<ProbImageType>
itprob(clusterImage, clusterImage->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<MaskImageType>
itmask(itkmask, itkmask->GetLargestPossibleRegion());
itimage = itimage.Begin();
itprob = itprob.Begin();
itmask = itmask.Begin();
double totalProb = 0;
double measurement = 0;
double error = 0;
while( !itimage.IsAtEnd() && !itprob.IsAtEnd() && !itmask.IsAtEnd() )
{
double valImag = itimage.Get();
double valProb = itprob.Get();
double valMask = itmask.Get();
typename ProbImageType::PixelType prop = valProb * valMask;
totalProb += prop;
measurement += valImag * prop;
error += valImag * valImag * prop;
++itimage;
++itprob;
++itmask;
}
measurement = measurement / totalProb;
error = error / totalProb;
retval[0] = measurement;
retval[1] = sqrt( error - measurement*measurement );
}
mitk::Image::Pointer PartialVolumeAnalysisClusteringCalculator::CaculateAngularErrorImage(
mitk::Image::Pointer comp1, mitk::Image::Pointer comp2, mitk::Image::Pointer probImg) const
{
// cast input images to itk
typedef itk::Image<float, 3> ImageType;
typedef mitk::ImageToItk<ImageType> CastType;
CastType::Pointer caster = CastType::New();
caster->SetInput(comp1);
caster->Update();
ImageType::Pointer comp1Image = caster->GetOutput();
caster = CastType::New();
caster->SetInput(comp2);
caster->Update();
ImageType::Pointer comp2Image = caster->GetOutput();
caster = CastType::New();
caster->SetInput(probImg);
caster->Update();
ImageType::Pointer probImage = caster->GetOutput();
// figure out maximum probability for fiber class
float maxProb = 0;
itk::ImageRegionConstIterator<ImageType>
itprob(probImage, probImage->GetLargestPossibleRegion());
itprob = itprob.Begin();
while( !itprob.IsAtEnd() )
{
maxProb = itprob.Get() > maxProb ? itprob.Get() : maxProb;
++itprob;
}
// generate a list sample of angles at positions
// where the fiber-prob is higher than .2*maxprob
typedef float MeasurementType;
const unsigned int MeasurementVectorLength = 2;
typedef itk::Vector< MeasurementType , MeasurementVectorLength >
MeasurementVectorType;
typedef itk::Statistics::ListSample< MeasurementVectorType > ListSampleType;
ListSampleType::Pointer listSample = ListSampleType::New();
listSample->SetMeasurementVectorSize( MeasurementVectorLength );
itk::ImageRegionIterator<ImageType>
it1(comp1Image, comp1Image->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType>
it2(comp2Image, comp2Image->GetLargestPossibleRegion());
it1 = it1.Begin();
it2 = it2.Begin();
itprob = itprob.Begin();
while( !itprob.IsAtEnd() )
{
if(itprob.Get() > 0.2 * maxProb)
{
MeasurementVectorType mv;
mv[0] = ( MeasurementType ) it1.Get();
mv[1] = ( MeasurementType ) it2.Get();
listSample->PushBack(mv);
}
++it1;
++it2;
++itprob;
}
// generate a histogram from the list sample
typedef float HistogramMeasurementType;
- typedef itk::Statistics::ListSampleToHistogramGenerator
- < ListSampleType, HistogramMeasurementType,
- itk::Statistics::DenseFrequencyContainer,
- MeasurementVectorLength > GeneratorType;
+ typedef itk::Statistics::Histogram< HistogramMeasurementType, itk::Statistics::DenseFrequencyContainer2 > HistogramType;
+ typedef itk::Statistics::SampleToHistogramFilter< ListSampleType, HistogramType > GeneratorType;
GeneratorType::Pointer generator = GeneratorType::New();
- GeneratorType::HistogramType::SizeType size;
+ GeneratorType::HistogramType::SizeType size(2);
size.Fill(30);
- generator->SetNumberOfBins( size );
+ generator->SetHistogramSize( size );
- generator->SetListSample( listSample );
+ generator->SetInput( listSample );
generator->SetMarginalScale( 10.0 );
- MeasurementVectorType min;
- min[0] = ( MeasurementType ) 0;
- min[1] = ( MeasurementType ) 0;
- generator->SetHistogramMin(min);
-
- MeasurementVectorType max;
- max[0] = ( MeasurementType ) PVA_PI;
- max[1] = ( MeasurementType ) PVA_PI;
- generator->SetHistogramMax(max);
-
generator->Update();
// look for frequency mode in the histogram
GeneratorType::HistogramType::ConstPointer histogram = generator->GetOutput();
GeneratorType::HistogramType::ConstIterator iter = histogram->Begin();
float maxFreq = 0;
MeasurementVectorType maxValue;
while ( iter != histogram->End() )
{
if(iter.GetFrequency() > maxFreq)
{
maxFreq = iter.GetFrequency();
maxValue[0] = iter.GetMeasurementVector()[0];
maxValue[1] = iter.GetMeasurementVector()[1];
}
++iter;
}
// generate return image that contains the angular
// error of the voxels to the histogram max measurement
ImageType::Pointer returnImage = ImageType::New();
returnImage->SetSpacing( comp1Image->GetSpacing() ); // Set the image spacing
returnImage->SetOrigin( comp1Image->GetOrigin() ); // Set the image origin
returnImage->SetDirection( comp1Image->GetDirection() ); // Set the image direction
returnImage->SetRegions( comp1Image->GetLargestPossibleRegion() );
returnImage->Allocate();
itk::ImageRegionConstIterator<ImageType>
cit1(comp1Image, comp1Image->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<ImageType>
cit2(comp2Image, comp2Image->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType>
itout(returnImage, returnImage->GetLargestPossibleRegion());
cit1 = cit1.Begin();
cit2 = cit2.Begin();
itout = itout.Begin();
vnl_vector<float> v(3);
v[0] = cos( maxValue[0] ) * sin( maxValue[1] );
v[1] = sin( maxValue[0] ) * sin( maxValue[1] );
v[2] = cos( maxValue[1] );
// MITK_INFO << "max vector: " << v;
while( !cit1.IsAtEnd() )
{
vnl_vector<float> v1(3);
v1[0] = cos( cit1.Get() ) * sin( cit2.Get() );
v1[1] = sin( cit1.Get() ) * sin( cit2.Get() );
v1[2] = cos( cit2.Get() );
itout.Set(fabs(angle(v,v1)));
// MITK_INFO << "ang_error " << v1 << ": " << fabs(angle(v,v1));
++cit1;
++cit2;
++itout;
}
mitk::Image::Pointer retval = mitk::Image::New();
retval->InitializeByItk(returnImage.GetPointer());
retval->SetVolume(returnImage->GetBufferPointer());
return retval;
}
PartialVolumeAnalysisClusteringCalculator::HelperStructPerformRGBClusteringRetval*
PartialVolumeAnalysisClusteringCalculator::PerformRGBQuantiles(mitk::Image::ConstPointer image, const MitkHistType *histogram, double p1, double p2) const
{
HelperStructRGBChannels *rgbChannels = new HelperStructRGBChannels();
HelperStructPerformClusteringRetval *resultr = PerformQuantiles(image, histogram, p2, 999999999.0 );
rgbChannels->r = resultr->clusteredImage;
HelperStructPerformClusteringRetval *resultg = PerformQuantiles(image, histogram, -999999999.0, p1 );
rgbChannels->g = resultg->clusteredImage;
HelperStructPerformClusteringRetval *resultb = PerformQuantiles(image, histogram, p1, p2 );
rgbChannels->b = resultb->clusteredImage;
mitk::Image::Pointer outImage = mitk::Image::New();
switch(rgbChannels->r->GetDimension())
{
case 2:
InternalGenerateRGB<2>(rgbChannels, outImage);
break;
case 3:
InternalGenerateRGB<3>(rgbChannels, outImage);
break;
case 4:
InternalGenerateRGB<4>(rgbChannels, outImage);
break;
default:
InternalGenerateRGB<3>(rgbChannels, outImage);
}
HelperStructPerformRGBClusteringRetval *retval
= new HelperStructPerformRGBClusteringRetval();
retval->rgbChannels = rgbChannels;
retval->rgb = outImage;
retval->params = resultr->params;
retval->result = resultr->result;
retval->hist = resultr->hist;
delete resultr;
delete resultg;
return retval;
}
PartialVolumeAnalysisClusteringCalculator::HelperStructPerformClusteringRetval*
PartialVolumeAnalysisClusteringCalculator::PerformQuantiles(mitk::Image::ConstPointer image, const MitkHistType *histogram, double p1, double p2 ) const
{
HelperStructPerformClusteringRetval *retval =
new HelperStructPerformClusteringRetval();
retval->hist = new HistType();
retval->hist->InitByMitkHistogram(histogram);
double sum = histogram->GetTotalFrequency();
double* q = new double[2];
q[0] = histogram->Quantile(0, p1);
q[1] = histogram->Quantile(0, p2);
mitk::Image::Pointer outImage1 = mitk::Image::New();
mitk::Image::Pointer outImage2 = mitk::Image::New();
AccessFixedDimensionByItk_3(
image.GetPointer(),
InternalGenerateQuantileImage,
3, q,
outImage1, outImage2);
retval->clusteredImage = outImage1;
retval->displayImage = outImage2;
delete[] q;
return retval;
}
template < typename TPixel, unsigned int VImageDimension >
void PartialVolumeAnalysisClusteringCalculator::InternalGenerateQuantileImage(
const itk::Image< TPixel, VImageDimension > *image, double* q,
mitk::Image::Pointer outImage1, mitk::Image::Pointer outImage2 ) const
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< itk::RGBAPixel<unsigned char>, VImageDimension > DisplayImageType;
typedef itk::Image< float, VImageDimension > ProbImageType;
typename ProbImageType::Pointer probimage = ProbImageType::New();
probimage->SetSpacing( image->GetSpacing() ); // Set the image spacing
probimage->SetOrigin( image->GetOrigin() ); // Set the image origin
probimage->SetDirection( image->GetDirection() ); // Set the image direction
probimage->SetRegions( image->GetLargestPossibleRegion() );
probimage->Allocate();
probimage->FillBuffer(0);
typename DisplayImageType::Pointer displayimage = DisplayImageType::New();
displayimage->SetSpacing( image->GetSpacing() ); // Set the image spacing
displayimage->SetOrigin( image->GetOrigin() ); // Set the image origin
displayimage->SetDirection( image->GetDirection() ); // Set the image direction
displayimage->SetRegions( image->GetLargestPossibleRegion() );
displayimage->Allocate();
typename DisplayImageType::PixelType rgba;
rgba.Set(0.0f, 0.0f, 0.0f, 0.0f);
displayimage->FillBuffer(rgba);
itk::ImageRegionConstIterator<ImageType>
itimage(image, image->GetLargestPossibleRegion());
itk::ImageRegionIterator<ProbImageType>
itprob(probimage, probimage->GetLargestPossibleRegion());
itk::ImageRegionIterator<DisplayImageType>
itdisp(displayimage, displayimage->GetLargestPossibleRegion());
itimage = itimage.Begin();
itprob = itprob.Begin();
while( !itimage.IsAtEnd() )
{
if(itimage.Get() > q[0] && itimage.Get() < q[1])
{
itprob.Set(1.0f);
}
++itimage;
++itprob;
}
itprob = itprob.Begin();
itdisp = itdisp.Begin();
while( !itprob.IsAtEnd() )
{
if(itprob.Get())
{
typename DisplayImageType::PixelType rgba;
rgba.Set(255.0f, 0.0f, 0.0f, 255.0f);
itdisp.Set( rgba );
}
++itprob;
++itdisp;
}
outImage1->InitializeByItk(probimage.GetPointer());
outImage1->SetVolume(probimage->GetBufferPointer());
outImage2->InitializeByItk(displayimage.GetPointer());
outImage2->SetVolume(displayimage->GetBufferPointer());
}
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
index 841a808819..81860b8129 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
@@ -1,511 +1,510 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_PartialVolumeAnalysisClusteringCalculator_H
#define _MITK_PartialVolumeAnalysisClusteringCalculator_H
#include "DiffusionCoreExports.h"
#include "mitkCommon.h"
#include "mitkImage.h"
#include <itkObject.h>
#include <itkObjectFactory.h>
#include <itkImage.h>
#include <itkRGBAPixel.h>
#include <vnl/vnl_vector.h>
namespace mitk
{
class DiffusionCore_EXPORT PartialVolumeAnalysisClusteringCalculator : public itk::Object
{
public:
typedef vnl_vector<double> VecType;
typedef mitk::Image::HistogramType MitkHistType;
class HistType
{
public:
HistType()
{
}
HistType(const HistType& p)
{
this->xVals = p.xVals;
this->hVals = p.hVals;
}
~HistType()
{
}
HistType operator= (const HistType& p)
{
if (this != &p) // protect against invalid self-assignment
{
this->xVals = p.xVals;
this->hVals = p.hVals;
}
return *this;
}
void InitByMitkHistogram(const MitkHistType* histogram)
{
xVals.set_size(histogram->GetSize()[0]);
hVals.set_size(histogram->GetSize()[0]);
double sum = histogram->GetTotalFrequency();
MitkHistType::ConstIterator endIt = histogram->End();
- MitkHistType::ConstIterator it;
+ MitkHistType::ConstIterator it = histogram->Begin();
bool firstNonEmptyBinFound = false;
- it = histogram->Begin();
//++it;
int i=0;
while (it != endIt)
{
if(it.GetFrequency() || firstNonEmptyBinFound)
{
firstNonEmptyBinFound = true;
xVals(i) = it.GetMeasurementVector().GetElement(0);
hVals(i) = it.GetFrequency()/sum;
}
++i;
++it;
}
}
void SetXVals(VecType x)
{xVals = x;}
void SetHVals(VecType h)
{hVals = h;}
void SetXVals(std::vector<double> x)
{
int s = x.size();
xVals.set_size(s);
for(int i=0; i<s; i++)
{
xVals(i) = x[i];
}
}
void SetHVals(std::vector<double> h)
{
int s = h.size();
hVals.set_size(s);
for(int i=0; i<s; i++)
{
hVals(i) = h[i];
}
}
std::vector<double>* GetXVals()
{
int s = xVals.size();
std::vector<double>* retval = new std::vector<double>(s);
for(int i=0; i<s; i++)
{
(*retval)[i] = xVals(i);
}
return retval;
}
std::vector<double>* GetHVals()
{
int s = hVals.size();
std::vector<double>* retval = new std::vector<double>(s);
for(int i=0; i<s; i++)
{
(*retval)[i] = hVals(i);
}
return retval;
}
void Print(int nr=10)
{
int sz = xVals.size();
int incr = (int)((1.0*sz)/(1.0*nr));
}
VecType xVals;
VecType hVals;
};
class ClusterResultType
{
public:
// ClusterResultType()
// {
// vals.push_back(VecType());
// vals.push_back(VecType());
// mixedVals.push_back(VecType());
// }
ClusterResultType(int sz)
{
vals.push_back(VecType(sz));
vals.push_back(VecType(sz));
mixedVals.push_back(VecType(sz));
combiVals.set_size(sz);
}
~ClusterResultType()
{
}
// ClusterResultType operator= (const ClusterResultType *p)
// {
// MITK_DEBUG << "AOJHIFAHFOF";
// if (this != &p) // protect against invalid self-assignment
// {
// MITK_DEBUG << "HRRRHRHRR";
// this->vals.clear();
// this->mixedVals.clear();
// int s = p.vals.size();
// for(int i=0; i<s;i++)
// {
// VecType v = p.vals[i];
// this->vals.push_back(v);
// }
// s = p.mixedVals.size();
// for(int i=0; i<s;i++)
// {
// VecType v = p.mixedVals[i];
// this->mixedVals.push_back(v);
// }
// this->combiVals = p.combiVals;
// }
// return *this;
// }
void Initialize (const ClusterResultType *p)
{
if (this != p) // protect against invalid self-assignment
{
this->vals.clear();
this->mixedVals.clear();
int s = p->vals.size();
for(int i=0; i<s;i++)
{
VecType v = p->vals[i];
this->vals.push_back(v);
}
s = p->mixedVals.size();
for(int i=0; i<s;i++)
{
VecType v = p->mixedVals[i];
this->mixedVals.push_back(v);
}
this->combiVals = p->combiVals;
}
}
std::vector<double> GetFiberVals()
{
if(vals.size()==2 && vals[1].data_block())
{
int s = vals[1].size();
std::vector<double> retval(s);
for(int i=0; i<s; i++)
{
retval[i] = vals[1](i);
}
return retval;
}
else
{
MITK_ERROR << "GetFiberVals() struct not initialized!!";
return std::vector<double>(0);
}
}
std::vector<double> GetNonFiberVals()
{
if(vals.size()==2 && vals[0].data_block())
{
int s = vals[0].size();
std::vector<double> retval(s);
for(int i=0; i<s; i++)
{
retval[i] = vals[0](i);
}
return retval;
}
else
{
MITK_ERROR << "GetNonFiberVals() struct not initialized!!";
return std::vector<double>(0);
}
}
std::vector<double> GetMixedVals()
{
if(mixedVals.size()==1 && mixedVals[0].data_block())
{
int s = mixedVals[0].size();
std::vector<double> retval(s);
for(int i=0; i<s; i++)
{
retval[i] = mixedVals[0](i);
}
return retval;
}
else
{
MITK_ERROR << "GetMixedVals() struct not initialized!!";
return std::vector<double>(0);
}
}
std::vector<double> GetCombiVals()
{
if(combiVals.data_block())
{
int s = combiVals.size();
std::vector<double> retval(s);
for(int i=0; i<s; i++)
{
retval[i] = combiVals(i);
}
return retval;
}
else
{
MITK_ERROR << "GetCombiVals() struct not initialized!!";
return std::vector<double>(0);
}
}
// void Print(VecType vec, int nr=10)
// {
// int sz = vec.size();
// int incr = (int)((1.0*sz)/(1.0*nr));
// for(int i=0; i<sz; i = i+incr)
// {
// std::cout << vec(i) << " ";
// }
// std::cout << std::endl;
// }
// void Print(int nr=10)
// {
// MITK_DEBUG << "CURVES" << std::endl;
// MITK_DEBUG << "Fiber Vals: ";
// Print(vals[0],nr);
// MITK_DEBUG << "Non-Fiber Vals: ";
// Print(vals[1],nr);
// MITK_DEBUG << "Mixed Vals: ";
// Print(mixedVals[0],nr);
// MITK_DEBUG << "Combined Vals: ";
// Print(combiVals,nr);
// }
std::vector<VecType> vals;
std::vector<VecType> mixedVals;
VecType combiVals;
};
class ParamsType
{
public:
ParamsType()
{
}
~ParamsType()
{
}
void Initialize(const ParamsType *p)
{
if (this != p) // protect against invalid self-assignment
{
means[0] = p->means[0];
means[1] = p->means[1];
sigmas[0] = p->sigmas[0];
sigmas[1] = p->sigmas[1];
ps[0] = p->ps[0];
ps[1] = p->ps[1];
}
}
// void Print()
// {
// MITK_DEBUG << "PARAMS" << std::endl;
// MITK_DEBUG << "Class 1: " << means[0] << " +- " << sqrt(sigmas[0]) << " (p=" << ps[0] << ")" << std::endl;
// MITK_DEBUG << "Class 2: " << means[1] << " +- " << sqrt(sigmas[1]) << " (p=" << ps[1] << ")" << std::endl;
// MITK_DEBUG << "Partial V: p=" << 1.0-ps[0]-ps[1] << std::endl;
// }
double means[2];
double sigmas[2];
double ps[2];
};
struct HelperStructClusteringResults
{
MitkHistType *interestingHist;
MitkHistType *totalHist;
double p_interesting;
};
struct HelperStructRGBChannels
{
mitk::Image::Pointer r;
mitk::Image::Pointer g;
mitk::Image::Pointer b;
~HelperStructRGBChannels()
{
r = 0;
g = 0;
b = 0;
}
};
struct HelperStructPerformRGBClusteringRetval
{
HelperStructRGBChannels *rgbChannels;
mitk::Image::Pointer rgb;
ParamsType *params;
ClusterResultType *result;
HistType *hist;
HelperStructPerformRGBClusteringRetval() :
rgbChannels(0), params(0), result(0), hist(0)
{
}
~HelperStructPerformRGBClusteringRetval()
{
rgb = 0;
delete rgbChannels;
}
};
struct HelperStructPerformClusteringRetval
{
mitk::Image::Pointer clusteredImage;
mitk::Image::Pointer displayImage;
ParamsType *params;
ClusterResultType *result;
HistType *hist;
HelperStructPerformClusteringRetval() :
clusteredImage(0), displayImage(0),
params(0), result(0), hist(0)
{
}
~HelperStructPerformClusteringRetval()
{
clusteredImage = 0;
displayImage = 0;
}
};
mitkClassMacro( PartialVolumeAnalysisClusteringCalculator, itk::Object )
itkNewMacro( PartialVolumeAnalysisClusteringCalculator )
ParamsType *InitialGuess(HistType h) const;
ParamsType *Cluster(const HistType h, ParamsType* initialGuess) const;
ClusterResultType CalculateCurves(ParamsType params, VecType xVals) const;
void Normalize(ParamsType params, ClusterResultType* curves) const;
HelperStructPerformClusteringRetval* PerformClustering(mitk::Image::ConstPointer image, const MitkHistType *histogram, int classIdent, HelperStructPerformClusteringRetval* precResult = 0) const;
HelperStructPerformRGBClusteringRetval* PerformRGBClustering(mitk::Image::ConstPointer image, const MitkHistType *histogram) const;
HelperStructPerformClusteringRetval* PerformQuantiles(mitk::Image::ConstPointer image, const MitkHistType *histogram, double p1, double p2) const;
HelperStructPerformRGBClusteringRetval* PerformRGBQuantiles(mitk::Image::ConstPointer image, const MitkHistType *histogram, double p1, double p2 ) const;
double* PerformQuantification(mitk::Image::ConstPointer image, mitk::Image::Pointer clusteredImage, mitk::Image::Pointer mask = 0) const;
mitk::Image::Pointer CaculateAngularErrorImage(
mitk::Image::Pointer comp1, mitk::Image::Pointer comp2, mitk::Image::Pointer probImg) const;
template < unsigned int VImageDimension >
void InternalGenerateRGB( HelperStructRGBChannels *rgb, mitk::Image::Pointer retval ) const;
template < typename TPixel, unsigned int VImageDimension >
void InternalGenerateProbabilityImage(
const itk::Image< TPixel, VImageDimension > *image,
const HelperStructClusteringResults clusterResults,
mitk::Image::Pointer outImage1, mitk::Image::Pointer outImage2 ) const;
template < typename TPixel, unsigned int VImageDimension >
void InternalQuantify(
const itk::Image< TPixel, VImageDimension > *image,
mitk::Image::Pointer clusteredImage, double* retval, mitk::Image::Pointer mask ) const;
template < typename TPixel, unsigned int VImageDimension >
void InternalGenerateQuantileImage(
const itk::Image< TPixel, VImageDimension > *image,
double* q,
mitk::Image::Pointer outImage1, mitk::Image::Pointer outImage2 ) const;
ParamsType* Cluster(const HistType h) const
{return Cluster(h, InitialGuess(h));}
void SetMaxIt(unsigned int it)
{ m_MaxIt = it; }
unsigned int GetMaxIt()
{ return m_MaxIt; }
void SetStepsNumIntegration(unsigned int n)
{ m_StepsNumIntegration = n; }
unsigned int GetStepsNumIntegration()
{ return m_StepsNumIntegration; }
protected:
PartialVolumeAnalysisClusteringCalculator();
virtual ~PartialVolumeAnalysisClusteringCalculator();
unsigned int m_MaxIt;
unsigned int m_StepsNumIntegration;
};
}
#endif // #define _MITK_PartialVolumeAnalysisClusteringCalculator_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
index 67dcac7620..9a3a5925c3 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
@@ -1,1247 +1,1246 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPartialVolumeAnalysisHistogramCalculator.h"
#include "mitkImageAccessByItk.h"
#include "mitkExtractImageFilter.h"
#include <itkScalarImageToHistogramGenerator.h>
#include <itkStatisticsImageFilter.h>
#include <itkLabelStatisticsImageFilter.h>
#include <itkBSplineUpsampleImageFilter.h>
#include <itkBSplineResampleImageFilterBase.h>
#include "itkResampleImageFilter.h"
#include "itkGaussianInterpolateImageFunction.h"
#include <itkCastImageFilter.h>
#include <itkImageFileWriter.h>
#include <itkVTKImageImport.h>
#include <itkVTKImageExport.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkPolyData.h>
#include <vtkLinearExtrusionFilter.h>
#include <vtkPolyDataToImageStencil.h>
#include <vtkImageStencil.h>
#include <vtkImageImport.h>
#include <vtkImageExport.h>
#include <vtkImageData.h>
#include <vtkMetaImageWriter.h>
#include <exception>
#include "itkGaussianInterpolateImageFunction.h"
#include "itkBSplineInterpolateImageFunction.h"
#include "itkNearestNeighborInterpolateImageFunction.h"
#include "itkImageMaskSpatialObject.h"
#include "itkRegionOfInterestImageFilter.h"
#include "itkListSample.h"
#include <iostream>
#include <sstream>
namespace mitk
{
PartialVolumeAnalysisHistogramCalculator::PartialVolumeAnalysisHistogramCalculator()
: m_MaskingMode( MASKING_MODE_NONE ),
m_MaskingModeChanged( false ),
m_NumberOfBins(256),
m_UpsamplingFactor(1),
m_GaussianSigma(0),
m_ForceUpdate(false),
m_PlanarFigureThickness(0)
{
m_EmptyHistogram = HistogramType::New();
- HistogramType::SizeType histogramSize;
+ m_EmptyHistogram->SetMeasurementVectorSize(1);
+ HistogramType::SizeType histogramSize(1);
histogramSize.Fill( 256 );
m_EmptyHistogram->Initialize( histogramSize );
m_EmptyStatistics.Reset();
}
PartialVolumeAnalysisHistogramCalculator::~PartialVolumeAnalysisHistogramCalculator()
{
}
void PartialVolumeAnalysisHistogramCalculator::SetImage( const mitk::Image *image )
{
if ( m_Image != image )
{
m_Image = image;
this->Modified();
m_ImageStatisticsTimeStamp.Modified();
m_ImageStatisticsCalculationTriggerBool = true;
}
}
void PartialVolumeAnalysisHistogramCalculator::AddAdditionalResamplingImage( const mitk::Image *image )
{
m_AdditionalResamplingImages.push_back(image);
this->Modified();
m_ImageStatisticsTimeStamp.Modified();
m_ImageStatisticsCalculationTriggerBool = true;
}
void PartialVolumeAnalysisHistogramCalculator::SetModified( )
{
this->Modified();
m_ImageStatisticsTimeStamp.Modified();
m_ImageStatisticsCalculationTriggerBool = true;
m_MaskedImageStatisticsTimeStamp.Modified();
m_MaskedImageStatisticsCalculationTriggerBool = true;
m_PlanarFigureStatisticsTimeStamp.Modified();
m_PlanarFigureStatisticsCalculationTriggerBool = true;
}
void PartialVolumeAnalysisHistogramCalculator::SetImageMask( const mitk::Image *imageMask )
{
if ( m_Image.IsNull() )
{
itkExceptionMacro( << "Image needs to be set first!" );
}
if ( m_Image->GetTimeSteps() != imageMask->GetTimeSteps() )
{
itkExceptionMacro( << "Image and image mask need to have equal number of time steps!" );
}
if ( m_ImageMask != imageMask )
{
m_ImageMask = imageMask;
this->Modified();
m_MaskedImageStatisticsTimeStamp.Modified();
m_MaskedImageStatisticsCalculationTriggerBool = true;
}
}
void PartialVolumeAnalysisHistogramCalculator::SetPlanarFigure( const mitk::PlanarFigure *planarFigure )
{
if ( m_Image.IsNull() )
{
itkExceptionMacro( << "Image needs to be set first!" );
}
if ( m_PlanarFigure != planarFigure )
{
m_PlanarFigure = planarFigure;
this->Modified();
m_PlanarFigureStatisticsTimeStamp.Modified();
m_PlanarFigureStatisticsCalculationTriggerBool = true;
}
}
void PartialVolumeAnalysisHistogramCalculator::SetMaskingMode( unsigned int mode )
{
if ( m_MaskingMode != mode )
{
m_MaskingMode = mode;
m_MaskingModeChanged = true;
this->Modified();
}
}
void PartialVolumeAnalysisHistogramCalculator::SetMaskingModeToNone()
{
if ( m_MaskingMode != MASKING_MODE_NONE )
{
m_MaskingMode = MASKING_MODE_NONE;
m_MaskingModeChanged = true;
this->Modified();
}
}
void PartialVolumeAnalysisHistogramCalculator::SetMaskingModeToImage()
{
if ( m_MaskingMode != MASKING_MODE_IMAGE )
{
m_MaskingMode = MASKING_MODE_IMAGE;
m_MaskingModeChanged = true;
this->Modified();
}
}
void PartialVolumeAnalysisHistogramCalculator::SetMaskingModeToPlanarFigure()
{
if ( m_MaskingMode != MASKING_MODE_PLANARFIGURE )
{
m_MaskingMode = MASKING_MODE_PLANARFIGURE;
m_MaskingModeChanged = true;
this->Modified();
}
}
bool PartialVolumeAnalysisHistogramCalculator::ComputeStatistics()
{
MITK_DEBUG << "ComputeStatistics() start";
if ( m_Image.IsNull() )
{
itkExceptionMacro( << "Image not set!" );
}
if ( m_Image->GetReferenceCount() == 1 )
{
MITK_DEBUG << "No Stats calculated; no one else holds a reference on it";
return false;
}
// If a mask was set but we are the only ones to still hold a reference on
// it, delete it.
if ( m_ImageMask.IsNotNull() && (m_ImageMask->GetReferenceCount() == 1) )
{
m_ImageMask = NULL;
}
// Check if statistics is already up-to-date
unsigned long imageMTime = m_ImageStatisticsTimeStamp.GetMTime();
unsigned long maskedImageMTime = m_MaskedImageStatisticsTimeStamp.GetMTime();
unsigned long planarFigureMTime = m_PlanarFigureStatisticsTimeStamp.GetMTime();
bool imageStatisticsCalculationTrigger = m_ImageStatisticsCalculationTriggerBool;
bool maskedImageStatisticsCalculationTrigger = m_MaskedImageStatisticsCalculationTriggerBool;
bool planarFigureStatisticsCalculationTrigger = m_PlanarFigureStatisticsCalculationTriggerBool;
if ( /*prevent calculation without mask*/!m_ForceUpdate &&( m_MaskingMode == MASKING_MODE_NONE || (
((m_MaskingMode != MASKING_MODE_NONE) || (imageMTime > m_Image->GetMTime() && !imageStatisticsCalculationTrigger))
&& ((m_MaskingMode != MASKING_MODE_IMAGE) || (m_ImageMask.IsNotNull() && maskedImageMTime > m_ImageMask->GetMTime() && !maskedImageStatisticsCalculationTrigger))
&& ((m_MaskingMode != MASKING_MODE_PLANARFIGURE) || (m_PlanarFigure.IsNotNull() && planarFigureMTime > m_PlanarFigure->GetMTime() && !planarFigureStatisticsCalculationTrigger)) ) ) )
{
MITK_DEBUG << "Returning, statistics already up to date!";
if ( m_MaskingModeChanged )
{
m_MaskingModeChanged = false;
return true;
}
else
{
return false;
}
}
// Reset state changed flag
m_MaskingModeChanged = false;
// Depending on masking mode, extract and/or generate the required image
// and mask data from the user input
this->ExtractImageAndMask( );
Statistics *statistics;
HistogramType::ConstPointer *histogram;
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
default:
statistics = &m_ImageStatistics;
histogram = &m_ImageHistogram;
m_ImageStatisticsTimeStamp.Modified();
m_ImageStatisticsCalculationTriggerBool = false;
break;
case MASKING_MODE_IMAGE:
statistics = &m_MaskedImageStatistics;
histogram = &m_MaskedImageHistogram;
m_MaskedImageStatisticsTimeStamp.Modified();
m_MaskedImageStatisticsCalculationTriggerBool = false;
break;
case MASKING_MODE_PLANARFIGURE:
statistics = &m_PlanarFigureStatistics;
histogram = &m_PlanarFigureHistogram;
m_PlanarFigureStatisticsTimeStamp.Modified();
m_PlanarFigureStatisticsCalculationTriggerBool = false;
break;
}
// Calculate statistics and histogram(s)
if ( m_InternalImage->GetDimension() == 3 )
{
if ( m_MaskingMode == MASKING_MODE_NONE )
{
// Reset state changed flag
AccessFixedDimensionByItk_2(
m_InternalImage,
InternalCalculateStatisticsUnmasked,
3,
*statistics,
histogram );
}
else
{
AccessFixedDimensionByItk_3(
m_InternalImage,
InternalCalculateStatisticsMasked,
3,
m_InternalImageMask3D.GetPointer(),
*statistics,
histogram );
}
}
else if ( m_InternalImage->GetDimension() == 2 )
{
if ( m_MaskingMode == MASKING_MODE_NONE )
{
AccessFixedDimensionByItk_2(
m_InternalImage,
InternalCalculateStatisticsUnmasked,
2,
*statistics,
histogram );
}
else
{
AccessFixedDimensionByItk_3(
m_InternalImage,
InternalCalculateStatisticsMasked,
2,
m_InternalImageMask2D.GetPointer(),
*statistics,
histogram );
}
}
else
{
MITK_ERROR << "ImageStatistics: Image dimension not supported!";
}
// Release unused image smart pointers to free memory
// m_InternalImage = mitk::Image::Pointer();
m_InternalImageMask3D = MaskImage3DType::Pointer();
m_InternalImageMask2D = MaskImage2DType::Pointer();
return true;
}
const PartialVolumeAnalysisHistogramCalculator::HistogramType *
PartialVolumeAnalysisHistogramCalculator::GetHistogram( ) const
{
if ( m_Image.IsNull() )
{
return NULL;
}
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
default:
return m_ImageHistogram;
case MASKING_MODE_IMAGE:
return m_MaskedImageHistogram;
case MASKING_MODE_PLANARFIGURE:
return m_PlanarFigureHistogram;
}
}
const PartialVolumeAnalysisHistogramCalculator::Statistics &
PartialVolumeAnalysisHistogramCalculator::GetStatistics( ) const
{
if ( m_Image.IsNull() )
{
return m_EmptyStatistics;
}
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
default:
return m_ImageStatistics;
case MASKING_MODE_IMAGE:
return m_MaskedImageStatistics;
case MASKING_MODE_PLANARFIGURE:
return m_PlanarFigureStatistics;
}
}
void PartialVolumeAnalysisHistogramCalculator::ExtractImageAndMask( )
{
MITK_DEBUG << "ExtractImageAndMask( ) start";
if ( m_Image.IsNull() )
{
throw std::runtime_error( "Error: image empty!" );
}
mitk::Image *timeSliceImage = const_cast<mitk::Image*>(m_Image.GetPointer());//imageTimeSelector->GetOutput();
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
{
m_InternalImage = timeSliceImage;
int s = m_AdditionalResamplingImages.size();
m_InternalAdditionalResamplingImages.resize(s);
for(int i=0; i<s; i++)
{
m_InternalAdditionalResamplingImages[i] = const_cast<mitk::Image*>(m_AdditionalResamplingImages[i].GetPointer());
}
m_InternalImageMask2D = NULL;
m_InternalImageMask3D = NULL;
break;
}
case MASKING_MODE_IMAGE:
{
if ( m_ImageMask.IsNotNull() && (m_ImageMask->GetReferenceCount() > 1) )
{
ImageTimeSelector::Pointer maskedImageTimeSelector = ImageTimeSelector::New();
maskedImageTimeSelector->SetInput( m_ImageMask );
maskedImageTimeSelector->SetTimeNr( 0 );
maskedImageTimeSelector->UpdateLargestPossibleRegion();
mitk::Image *timeSliceMaskedImage = maskedImageTimeSelector->GetOutput();
InternalMaskImage(timeSliceMaskedImage);
if(m_UpsamplingFactor != 1)
{
InternalResampleImage(m_InternalImageMask3D);
}
AccessFixedDimensionByItk_1(
timeSliceImage,
InternalResampleImageFromMask, 3, -1 );
int s = m_AdditionalResamplingImages.size();
m_InternalAdditionalResamplingImages.resize(s);
for(int i=0; i<s; i++)
{
AccessFixedDimensionByItk_1(
m_AdditionalResamplingImages[i],
InternalResampleImageFromMask, 3, i );
}
}
else
{
throw std::runtime_error( "Error: image mask empty!" );
}
break;
}
case MASKING_MODE_PLANARFIGURE:
{
m_InternalImageMask2D = NULL;
if ( m_PlanarFigure.IsNull() )
{
throw std::runtime_error( "Error: planar figure empty!" );
}
if ( !m_PlanarFigure->IsClosed() )
{
throw std::runtime_error( "Masking not possible for non-closed figures" );
}
const Geometry3D *imageGeometry = timeSliceImage->GetUpdatedGeometry();
if ( imageGeometry == NULL )
{
throw std::runtime_error( "Image geometry invalid!" );
}
const Geometry2D *planarFigureGeometry2D = m_PlanarFigure->GetGeometry2D();
if ( planarFigureGeometry2D == NULL )
{
throw std::runtime_error( "Planar-Figure not yet initialized!" );
}
const PlaneGeometry *planarFigureGeometry =
dynamic_cast< const PlaneGeometry * >( planarFigureGeometry2D );
if ( planarFigureGeometry == NULL )
{
throw std::runtime_error( "Non-planar planar figures not supported!" );
}
// unsigned int axis = 2;
// unsigned int slice = 0;
AccessFixedDimensionByItk_3(
timeSliceImage,
InternalReorientImagePlane, 3,
timeSliceImage->GetGeometry(),
m_PlanarFigure->GetGeometry(), -1 );
AccessFixedDimensionByItk_1(
m_InternalImage,
InternalCalculateMaskFromPlanarFigure,
3, 2 );
int s = m_AdditionalResamplingImages.size();
for(int i=0; i<s; i++)
{
AccessFixedDimensionByItk_3(
m_AdditionalResamplingImages[i],
InternalReorientImagePlane, 3,
timeSliceImage->GetGeometry(),
m_PlanarFigure->GetGeometry(), i );
AccessFixedDimensionByItk_1(
m_InternalAdditionalResamplingImages[i],
InternalCropAdditionalImage, 3, i );
}
}
}
}
bool PartialVolumeAnalysisHistogramCalculator::GetPrincipalAxis(
const Geometry3D *geometry, Vector3D vector,
unsigned int &axis )
{
vector.Normalize();
for ( unsigned int i = 0; i < 3; ++i )
{
Vector3D axisVector = geometry->GetAxisVector( i );
axisVector.Normalize();
if ( fabs( fabs( axisVector * vector ) - 1.0) < mitk::eps )
{
axis = i;
return true;
}
}
return false;
}
void PartialVolumeAnalysisHistogramCalculator::InternalMaskImage(
mitk::Image *image )
{
typedef itk::ImageMaskSpatialObject<3> ImageMaskSpatialObject;
typedef itk::Image< unsigned char, 3 > ImageType;
typedef itk::ImageRegion<3> RegionType;
typedef mitk::ImageToItk<ImageType> CastType;
CastType::Pointer caster = CastType::New();
caster->SetInput(image);
caster->Update();
ImageMaskSpatialObject::Pointer maskSO = ImageMaskSpatialObject::New();
maskSO->SetImage ( caster->GetOutput() );
m_InternalMask3D =
maskSO->GetAxisAlignedBoundingBoxRegion();
MITK_DEBUG << "Bounding Box Region: " << m_InternalMask3D;
typedef itk::RegionOfInterestImageFilter< ImageType, MaskImage3DType > ROIFilterType;
ROIFilterType::Pointer roi = ROIFilterType::New();
roi->SetRegionOfInterest(m_InternalMask3D);
roi->SetInput(caster->GetOutput());
roi->Update();
m_InternalImageMask3D = roi->GetOutput();
MITK_DEBUG << "Created m_InternalImageMask3D";
}
template < typename TPixel, unsigned int VImageDimension >
void PartialVolumeAnalysisHistogramCalculator::InternalReorientImagePlane(
const itk::Image< TPixel, VImageDimension > *image,
mitk::Geometry3D* imggeo, mitk::Geometry3D* planegeo3D, int additionalIndex )
{
MITK_DEBUG << "InternalReorientImagePlane() start";
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< float, VImageDimension > FloatImageType;
typedef itk::ResampleImageFilter<ImageType, FloatImageType, double> ResamplerType;
typename ResamplerType::Pointer resampler = ResamplerType::New();
mitk::PlaneGeometry* planegeo = dynamic_cast<mitk::PlaneGeometry*>(planegeo3D);
float upsamp = m_UpsamplingFactor;
float gausssigma = m_GaussianSigma;
// Spacing
typename ResamplerType::SpacingType spacing = planegeo->GetSpacing();
spacing[0] = image->GetSpacing()[0] / upsamp;
spacing[1] = image->GetSpacing()[1] / upsamp;
spacing[2] = image->GetSpacing()[2];
if(m_PlanarFigureThickness)
{
spacing[2] = image->GetSpacing()[2] / upsamp;
}
resampler->SetOutputSpacing( spacing );
// Size
typename ResamplerType::SizeType size;
size[0] = planegeo->GetParametricExtentInMM(0) / spacing[0];
size[1] = planegeo->GetParametricExtentInMM(1) / spacing[1];
size[2] = 1+2*m_PlanarFigureThickness; // klaus add +2*m_PlanarFigureThickness
MITK_DEBUG << "setting size2:="<<size[2] << " (before " << 1 << ")";
resampler->SetSize( size );
// Origin
typename mitk::Point3D orig = planegeo->GetOrigin();
typename mitk::Point3D corrorig;
planegeo3D->WorldToIndex(orig,corrorig);
corrorig[0] += 0.5/upsamp;
corrorig[1] += 0.5/upsamp;
if(m_PlanarFigureThickness)
{
float thickyyy = m_PlanarFigureThickness;
thickyyy/=upsamp;
corrorig[2] -= thickyyy; // klaus add -= (float)m_PlanarFigureThickness/upsamp statt += 0
}
planegeo3D->IndexToWorld(corrorig,corrorig);
resampler->SetOutputOrigin(corrorig );
// Direction
typename ResamplerType::DirectionType direction;
typename mitk::AffineTransform3D::MatrixType matrix = planegeo->GetIndexToWorldTransform()->GetMatrix();
for(int c=0; c<matrix.ColumnDimensions; c++)
{
double sum = 0;
for(int r=0; r<matrix.RowDimensions; r++)
{
sum += matrix(r,c)*matrix(r,c);
}
for(int r=0; r<matrix.RowDimensions; r++)
{
direction(r,c) = matrix(r,c)/sqrt(sum);
}
}
resampler->SetOutputDirection( direction );
// Gaussian interpolation
if(gausssigma != 0)
{
double sigma[3];
for( unsigned int d = 0; d < 3; d++ )
{
sigma[d] = gausssigma * image->GetSpacing()[d];
}
double alpha = 2.0;
typedef itk::GaussianInterpolateImageFunction<ImageType, double>
GaussianInterpolatorType;
typename GaussianInterpolatorType::Pointer interpolator
= GaussianInterpolatorType::New();
interpolator->SetInputImage( image );
interpolator->SetParameters( sigma, alpha );
resampler->SetInterpolator( interpolator );
}
else
{
// typedef typename itk::BSplineInterpolateImageFunction<ImageType, double>
// InterpolatorType;
typedef typename itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
typename InterpolatorType::Pointer interpolator
= InterpolatorType::New();
interpolator->SetInputImage( image );
resampler->SetInterpolator( interpolator );
}
// Other resampling options
resampler->SetInput( image );
resampler->SetDefaultPixelValue(0);
MITK_DEBUG << "Resampling requested image plane ... ";
resampler->Update();
MITK_DEBUG << " ... done";
if(additionalIndex < 0)
{
this->m_InternalImage = mitk::Image::New();
this->m_InternalImage->InitializeByItk( resampler->GetOutput() );
this->m_InternalImage->SetVolume( resampler->GetOutput()->GetBufferPointer() );
}
else
{
unsigned int myIndex = additionalIndex;
this->m_InternalAdditionalResamplingImages.push_back(mitk::Image::New());
this->m_InternalAdditionalResamplingImages[myIndex]->InitializeByItk( resampler->GetOutput() );
this->m_InternalAdditionalResamplingImages[myIndex]->SetVolume( resampler->GetOutput()->GetBufferPointer() );
}
}
template < typename TPixel, unsigned int VImageDimension >
void PartialVolumeAnalysisHistogramCalculator::InternalResampleImageFromMask(
const itk::Image< TPixel, VImageDimension > *image, int additionalIndex )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typename ImageType::Pointer outImage = ImageType::New();
outImage->SetSpacing( m_InternalImageMask3D->GetSpacing() ); // Set the image spacing
outImage->SetOrigin( m_InternalImageMask3D->GetOrigin() ); // Set the image origin
outImage->SetDirection( m_InternalImageMask3D->GetDirection() ); // Set the image direction
outImage->SetRegions( m_InternalImageMask3D->GetLargestPossibleRegion() );
outImage->Allocate();
outImage->FillBuffer(0);
typedef itk::InterpolateImageFunction<ImageType, double>
BaseInterpType;
typedef itk::GaussianInterpolateImageFunction<ImageType, double>
GaussianInterpolatorType;
typedef itk::LinearInterpolateImageFunction<ImageType, double>
LinearInterpolatorType;
typename BaseInterpType::Pointer interpolator;
if(m_GaussianSigma != 0)
{
double sigma[3];
for( unsigned int d = 0; d < 3; d++ )
{
sigma[d] = m_GaussianSigma * image->GetSpacing()[d];
}
double alpha = 2.0;
interpolator = GaussianInterpolatorType::New();
dynamic_cast<GaussianInterpolatorType*>(interpolator.GetPointer())->SetParameters( sigma, alpha );
}
else
{
interpolator = LinearInterpolatorType::New();
}
interpolator->SetInputImage( image );
itk::ImageRegionConstIterator<MaskImage3DType>
itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType>
itimage(outImage, outImage->GetLargestPossibleRegion());
itmask = itmask.Begin();
itimage = itimage.Begin();
itk::Point< double, 3 > point;
itk::ContinuousIndex< double, 3 > index;
while( !itmask.IsAtEnd() )
{
if(itmask.Get() != 0)
{
outImage->TransformIndexToPhysicalPoint (itimage.GetIndex(), point);
image->TransformPhysicalPointToContinuousIndex(point, index);
itimage.Set(interpolator->EvaluateAtContinuousIndex(index));
}
++itmask;
++itimage;
}
if(additionalIndex < 0)
{
this->m_InternalImage = mitk::Image::New();
this->m_InternalImage->InitializeByItk( outImage.GetPointer() );
this->m_InternalImage->SetVolume( outImage->GetBufferPointer() );
}
else
{
this->m_InternalAdditionalResamplingImages[additionalIndex] = mitk::Image::New();
this->m_InternalAdditionalResamplingImages[additionalIndex]->InitializeByItk( outImage.GetPointer() );
this->m_InternalAdditionalResamplingImages[additionalIndex]->SetVolume( outImage->GetBufferPointer() );
}
}
void PartialVolumeAnalysisHistogramCalculator::InternalResampleImage(
const MaskImage3DType *image )
{
typedef itk::ResampleImageFilter<MaskImage3DType, MaskImage3DType, double> ResamplerType;
ResamplerType::Pointer resampler = ResamplerType::New();
// Size
ResamplerType::SizeType size;
size[0] = m_UpsamplingFactor * image->GetLargestPossibleRegion().GetSize()[0];
size[1] = m_UpsamplingFactor * image->GetLargestPossibleRegion().GetSize()[1];
size[2] = m_UpsamplingFactor * image->GetLargestPossibleRegion().GetSize()[2];;
resampler->SetSize( size );
// Origin
mitk::Point3D orig = image->GetOrigin();
resampler->SetOutputOrigin(orig );
// Spacing
ResamplerType::SpacingType spacing;
spacing[0] = image->GetSpacing()[0] / m_UpsamplingFactor;
spacing[1] = image->GetSpacing()[1] / m_UpsamplingFactor;
spacing[2] = image->GetSpacing()[2] / m_UpsamplingFactor;
resampler->SetOutputSpacing( spacing );
resampler->SetOutputDirection( image->GetDirection() );
typedef itk::NearestNeighborInterpolateImageFunction<MaskImage3DType, double>
InterpolatorType;
InterpolatorType::Pointer interpolator
= InterpolatorType::New();
interpolator->SetInputImage( image );
resampler->SetInterpolator( interpolator );
// Other resampling options
resampler->SetInput( image );
resampler->SetDefaultPixelValue(0);
resampler->Update();
m_InternalImageMask3D = resampler->GetOutput();
}
template < typename TPixel, unsigned int VImageDimension >
void PartialVolumeAnalysisHistogramCalculator::InternalCalculateStatisticsUnmasked(
const itk::Image< TPixel, VImageDimension > *image,
Statistics &statistics,
typename HistogramType::ConstPointer *histogram )
{
MITK_DEBUG << "InternalCalculateStatisticsUnmasked()";
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< unsigned char, VImageDimension > MaskImageType;
typedef typename ImageType::IndexType IndexType;
// Progress listening...
typedef itk::SimpleMemberCommand< PartialVolumeAnalysisHistogramCalculator > ITKCommandType;
ITKCommandType::Pointer progressListener;
progressListener = ITKCommandType::New();
progressListener->SetCallbackFunction( this,
&PartialVolumeAnalysisHistogramCalculator::UnmaskedStatisticsProgressUpdate );
// Issue 100 artificial progress events since ScalarIMageToHistogramGenerator
// does not (yet?) support progress reporting
this->InvokeEvent( itk::StartEvent() );
for ( unsigned int i = 0; i < 100; ++i )
{
this->UnmaskedStatisticsProgressUpdate();
}
// Calculate statistics (separate filter)
typedef itk::StatisticsImageFilter< ImageType > StatisticsFilterType;
typename StatisticsFilterType::Pointer statisticsFilter = StatisticsFilterType::New();
statisticsFilter->SetInput( image );
unsigned long observerTag = statisticsFilter->AddObserver(
itk::ProgressEvent(), progressListener );
statisticsFilter->Update();
statisticsFilter->RemoveObserver( observerTag );
this->InvokeEvent( itk::EndEvent() );
statistics.N = image->GetBufferedRegion().GetNumberOfPixels();
statistics.Min = statisticsFilter->GetMinimum();
statistics.Max = statisticsFilter->GetMaximum();
statistics.Mean = statisticsFilter->GetMean();
statistics.Median = 0.0;
statistics.Sigma = statisticsFilter->GetSigma();
statistics.RMS = sqrt( statistics.Mean * statistics.Mean
+ statistics.Sigma * statistics.Sigma );
typename ImageType::Pointer inImage = const_cast<ImageType*>(image);
// Calculate histogram
typedef itk::Statistics::ScalarImageToHistogramGenerator< ImageType >
HistogramGeneratorType;
typename HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New();
histogramGenerator->SetInput( inImage );
histogramGenerator->SetMarginalScale( 10 ); // Defines y-margin width of histogram
histogramGenerator->SetNumberOfBins( m_NumberOfBins ); // CT range [-1024, +2048] --> bin size 4 values
histogramGenerator->SetHistogramMin( statistics.Min );
histogramGenerator->SetHistogramMax( statistics.Max );
histogramGenerator->Compute();
*histogram = histogramGenerator->GetOutput();
}
template < typename TPixel, unsigned int VImageDimension >
void PartialVolumeAnalysisHistogramCalculator::InternalCalculateStatisticsMasked(
const itk::Image< TPixel, VImageDimension > *image,
itk::Image< unsigned char, VImageDimension > *maskImage,
Statistics &statistics,
typename HistogramType::ConstPointer *histogram )
{
MITK_DEBUG << "InternalCalculateStatisticsMasked() start";
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< unsigned char, VImageDimension > MaskImageType;
typedef typename ImageType::IndexType IndexType;
// generate a list sample of angles at positions
// where the fiber-prob is higher than .2*maxprob
typedef TPixel MeasurementType;
const unsigned int MeasurementVectorLength = 1;
typedef itk::Vector< MeasurementType , MeasurementVectorLength >
MeasurementVectorType;
typedef itk::Statistics::ListSample< MeasurementVectorType > ListSampleType;
typename ListSampleType::Pointer listSample = ListSampleType::New();
listSample->SetMeasurementVectorSize( MeasurementVectorLength );
itk::ImageRegionConstIterator<MaskImageType>
itmask(maskImage, maskImage->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<ImageType>
itimage(image, image->GetLargestPossibleRegion());
itmask = itmask.Begin();
itimage = itimage.Begin();
while( !itmask.IsAtEnd() )
{
if(itmask.Get() != 0)
{
// apend to list
MeasurementVectorType mv;
mv[0] = ( MeasurementType ) itimage.Get();
listSample->PushBack(mv);
}
++itmask;
++itimage;
}
// generate a histogram from the list sample
- typedef float HistogramMeasurementType;
- typedef itk::Statistics::ListSampleToHistogramGenerator
- < ListSampleType, HistogramMeasurementType,
- itk::Statistics::DenseFrequencyContainer,
- MeasurementVectorLength > GeneratorType;
+ typedef double HistogramMeasurementType;
+ typedef itk::Statistics::Histogram< HistogramMeasurementType, itk::Statistics::DenseFrequencyContainer2 > HistogramType;
+ typedef itk::Statistics::SampleToHistogramFilter< ListSampleType, HistogramType > GeneratorType;
typename GeneratorType::Pointer generator = GeneratorType::New();
- typename GeneratorType::HistogramType::SizeType size;
+ typename GeneratorType::HistogramType::SizeType size(MeasurementVectorLength);
size.Fill(m_NumberOfBins);
- generator->SetNumberOfBins( size );
- generator->SetListSample( listSample );
+ generator->SetHistogramSize( size );
+ generator->SetInput( listSample );
generator->SetMarginalScale( 10.0 );
generator->Update();
*histogram = generator->GetOutput();
}
template < typename TPixel, unsigned int VImageDimension >
void PartialVolumeAnalysisHistogramCalculator::InternalCropAdditionalImage(
itk::Image< TPixel, VImageDimension > *image, int additionalIndex )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::RegionOfInterestImageFilter< ImageType, ImageType > ROIFilterType;
typename ROIFilterType::Pointer roi = ROIFilterType::New();
roi->SetRegionOfInterest(m_CropRegion);
roi->SetInput(image);
roi->Update();
m_InternalAdditionalResamplingImages[additionalIndex] = mitk::Image::New();
m_InternalAdditionalResamplingImages[additionalIndex]->InitializeByItk(roi->GetOutput());
m_InternalAdditionalResamplingImages[additionalIndex]->SetVolume(roi->GetOutput()->GetBufferPointer());
}
template < typename TPixel, unsigned int VImageDimension >
void PartialVolumeAnalysisHistogramCalculator::InternalCalculateMaskFromPlanarFigure(
itk::Image< TPixel, VImageDimension > *image, unsigned int axis )
{
MITK_DEBUG << "InternalCalculateMaskFromPlanarFigure() start";
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::CastImageFilter< ImageType, MaskImage3DType > CastFilterType;
// Generate mask image as new image with same header as input image and
// initialize with "1".
MaskImage3DType::Pointer newMaskImage = MaskImage3DType::New();
newMaskImage->SetSpacing( image->GetSpacing() ); // Set the image spacing
newMaskImage->SetOrigin( image->GetOrigin() ); // Set the image origin
newMaskImage->SetDirection( image->GetDirection() ); // Set the image direction
newMaskImage->SetRegions( image->GetLargestPossibleRegion() );
newMaskImage->Allocate();
newMaskImage->FillBuffer( 1 );
// Generate VTK polygon from (closed) PlanarFigure polyline
// (The polyline points are shifted by -0.5 in z-direction to make sure
// that the extrusion filter, which afterwards elevates all points by +0.5
// in z-direction, creates a 3D object which is cut by the the plane z=0)
const mitk::Geometry2D *planarFigureGeometry2D = m_PlanarFigure->GetGeometry2D();
const typename PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
const mitk::Geometry3D *imageGeometry3D = m_InternalImage->GetGeometry( 0 );
vtkPolyData *polyline = vtkPolyData::New();
polyline->Allocate( 1, 1 );
// Determine x- and y-dimensions depending on principal axis
int i0, i1;
switch ( axis )
{
case 0:
i0 = 1;
i1 = 2;
break;
case 1:
i0 = 0;
i1 = 2;
break;
case 2:
default:
i0 = 0;
i1 = 1;
break;
}
// Create VTK polydata object of polyline contour
bool outOfBounds = false;
vtkPoints *points = vtkPoints::New();
typename PlanarFigure::PolyLineType::const_iterator it;
for ( it = planarFigurePolyline.begin();
it != planarFigurePolyline.end();
++it )
{
Point3D point3D;
// Convert 2D point back to the local index coordinates of the selected
// image
mitk::Point2D point2D = it->Point;
planarFigureGeometry2D->WorldToIndex(point2D, point2D);
point2D[0] -= 0.5/m_UpsamplingFactor;
point2D[1] -= 0.5/m_UpsamplingFactor;
planarFigureGeometry2D->IndexToWorld(point2D, point2D);
planarFigureGeometry2D->Map( point2D, point3D );
// Polygons (partially) outside of the image bounds can not be processed
// further due to a bug in vtkPolyDataToImageStencil
if ( !imageGeometry3D->IsInside( point3D ) )
{
outOfBounds = true;
}
imageGeometry3D->WorldToIndex( point3D, point3D );
point3D[i0] += 0.5;
point3D[i1] += 0.5;
// Add point to polyline array
points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
}
polyline->SetPoints( points );
points->Delete();
if ( outOfBounds )
{
polyline->Delete();
throw std::runtime_error( "Figure at least partially outside of image bounds!" );
}
unsigned int numberOfPoints = planarFigurePolyline.size();
vtkIdType *ptIds = new vtkIdType[numberOfPoints];
for ( vtkIdType i = 0; i < numberOfPoints; ++i )
{
ptIds[i] = i;
}
polyline->InsertNextCell( VTK_POLY_LINE, numberOfPoints, ptIds );
// Extrude the generated contour polygon
vtkLinearExtrusionFilter *extrudeFilter = vtkLinearExtrusionFilter::New();
extrudeFilter->SetInput( polyline );
extrudeFilter->SetScaleFactor( 1 );
extrudeFilter->SetExtrusionTypeToNormalExtrusion();
extrudeFilter->SetVector( 0.0, 0.0, 1.0 );
// Make a stencil from the extruded polygon
vtkPolyDataToImageStencil *polyDataToImageStencil = vtkPolyDataToImageStencil::New();
polyDataToImageStencil->SetInput( extrudeFilter->GetOutput() );
// Export from ITK to VTK (to use a VTK filter)
typedef itk::VTKImageImport< MaskImage3DType > ImageImportType;
typedef itk::VTKImageExport< MaskImage3DType > ImageExportType;
typename ImageExportType::Pointer itkExporter = ImageExportType::New();
itkExporter->SetInput( newMaskImage );
vtkImageImport *vtkImporter = vtkImageImport::New();
this->ConnectPipelines( itkExporter, vtkImporter );
vtkImporter->Update();
// Apply the generated image stencil to the input image
vtkImageStencil *imageStencilFilter = vtkImageStencil::New();
imageStencilFilter->SetInput( vtkImporter->GetOutput() );
imageStencilFilter->SetStencil( polyDataToImageStencil->GetOutput() );
imageStencilFilter->ReverseStencilOff();
imageStencilFilter->SetBackgroundValue( 0 );
imageStencilFilter->Update();
// Export from VTK back to ITK
vtkImageExport *vtkExporter = vtkImageExport::New();
vtkExporter->SetInput( imageStencilFilter->GetOutput() );
vtkExporter->Update();
typename ImageImportType::Pointer itkImporter = ImageImportType::New();
this->ConnectPipelines( vtkExporter, itkImporter );
itkImporter->Update();
// calculate cropping bounding box
m_InternalImageMask3D = itkImporter->GetOutput();
m_InternalImageMask3D->SetDirection(image->GetDirection());
itk::ImageRegionIterator<MaskImage3DType>
itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
itmask = itmask.Begin();
while( !itmask.IsAtEnd() )
{
if(itmask.Get() != 0)
{
typename ImageType::IndexType index = itmask.GetIndex();
for(int thick=0; thick<2*m_PlanarFigureThickness+1; thick++)
{
index[axis] = thick;
m_InternalImageMask3D->SetPixel(index, itmask.Get());
}
}
++itmask;
}
itmask = itmask.Begin();
itk::ImageRegionIterator<ImageType>
itimage(image, image->GetLargestPossibleRegion());
itimage = itimage.Begin();
typename ImageType::SizeType lowersize = {{9999999999.0,9999999999.0,9999999999.0}};
typename ImageType::SizeType uppersize = {{0,0,0}};
while( !itmask.IsAtEnd() )
{
if(itmask.Get() == 0)
{
itimage.Set(0);
}
else
{
typename ImageType::IndexType index = itimage.GetIndex();
typename ImageType::SizeType signedindex;
signedindex[0] = index[0];
signedindex[1] = index[1];
signedindex[2] = index[2];
lowersize[0] = signedindex[0] < lowersize[0] ? signedindex[0] : lowersize[0];
lowersize[1] = signedindex[1] < lowersize[1] ? signedindex[1] : lowersize[1];
lowersize[2] = signedindex[2] < lowersize[2] ? signedindex[2] : lowersize[2];
uppersize[0] = signedindex[0] > uppersize[0] ? signedindex[0] : uppersize[0];
uppersize[1] = signedindex[1] > uppersize[1] ? signedindex[1] : uppersize[1];
uppersize[2] = signedindex[2] > uppersize[2] ? signedindex[2] : uppersize[2];
}
++itmask;
++itimage;
}
typename ImageType::IndexType index;
index[0] = lowersize[0];
index[1] = lowersize[1];
index[2] = lowersize[2];
typename ImageType::SizeType size;
size[0] = uppersize[0] - lowersize[0] + 1;
size[1] = uppersize[1] - lowersize[1] + 1;
size[2] = uppersize[2] - lowersize[2] + 1;
m_CropRegion = itk::ImageRegion<3>(index, size);
// crop internal image
typedef itk::RegionOfInterestImageFilter< ImageType, ImageType > ROIFilterType;
typename ROIFilterType::Pointer roi = ROIFilterType::New();
roi->SetRegionOfInterest(m_CropRegion);
roi->SetInput(image);
roi->Update();
m_InternalImage = mitk::Image::New();
m_InternalImage->InitializeByItk(roi->GetOutput());
m_InternalImage->SetVolume(roi->GetOutput()->GetBufferPointer());
// crop internal mask
typedef itk::RegionOfInterestImageFilter< MaskImage3DType, MaskImage3DType > ROIMaskFilterType;
typename ROIMaskFilterType::Pointer roi2 = ROIMaskFilterType::New();
roi2->SetRegionOfInterest(m_CropRegion);
roi2->SetInput(m_InternalImageMask3D);
roi2->Update();
m_InternalImageMask3D = roi2->GetOutput();
// Clean up VTK objects
polyline->Delete();
extrudeFilter->Delete();
polyDataToImageStencil->Delete();
vtkImporter->Delete();
imageStencilFilter->Delete();
//vtkExporter->Delete(); // TODO: crashes when outcommented; memory leak??
delete[] ptIds;
}
void PartialVolumeAnalysisHistogramCalculator::UnmaskedStatisticsProgressUpdate()
{
// Need to throw away every second progress event to reach a final count of
// 100 since two consecutive filters are used in this case
static int updateCounter = 0;
if ( updateCounter++ % 2 == 0 )
{
this->InvokeEvent( itk::ProgressEvent() );
}
}
void PartialVolumeAnalysisHistogramCalculator::MaskedStatisticsProgressUpdate()
{
this->InvokeEvent( itk::ProgressEvent() );
}
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDicomDiffusionImageHeaderReader.h b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDicomDiffusionImageHeaderReader.h
index 0b35b2c9ae..e777abf46d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDicomDiffusionImageHeaderReader.h
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDicomDiffusionImageHeaderReader.h
@@ -1,114 +1,114 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkDicomDiffusionImageHeaderReader_h__
#define __mitkDicomDiffusionImageHeaderReader_h__
#include "DiffusionCoreExports.h"
#include <mitkFileReader.h>
#include "itkImageSeriesReader.h"
#include "itkImageFileReader.h"
-#include "itkOrientedImage.h"
+#include "itkImage.h"
#include "itkGDCMImageIO.h"
#include "mitkDiffusionImageHeaderInformation.h"
namespace mitk
{
/**
@brief Reads the header information from a DICOM series and stores it into an output object of type
DiffusionImageHeaderInformation
*/
class DiffusionCore_EXPORT DicomDiffusionImageHeaderReader : public itk::Object
{
public:
mitkClassMacro( DicomDiffusionImageHeaderReader, itk::Object );
itkNewMacro(Self);
/** En enum to distinguish in processing between the different vendoors */
enum SupportedVendors{
SV_SIEMENS,
SV_SIEMENS_MOSAIC,
SV_PHILIPS,
SV_GE,
SV_UNKNOWN_VENDOR
};
typedef std::vector< std::string > FileNamesContainer;
typedef short PixelValueType;
- typedef itk::OrientedImage< PixelValueType, 2 > SliceType;
- typedef itk::OrientedImage< PixelValueType, 3 > VolumeType;
+ typedef itk::Image< PixelValueType, 2 > SliceType;
+ typedef itk::Image< PixelValueType, 3 > VolumeType;
typedef itk::ImageSeriesReader< VolumeType > VolumeReaderType;
typedef itk::ImageFileReader< SliceType > SliceReaderType;
typedef itk::GDCMImageIO ImageIOType;
/** Set the dicom file names to be considered */
void SetSeriesDicomFilenames(FileNamesContainer dicomFilenames)
{ this->m_DicomFilenames = dicomFilenames; }
void SetGdcmIO(ImageIOType::Pointer gdcmIO)
{ this->m_GdcmIO = gdcmIO; }
/** Set the volume reader in case the default volume reader shouldn't be used */
void SetVolumeReader(VolumeReaderType::Pointer volumeReader)
{ this->m_VolumeReader = volumeReader; }
/** Set the output object that will contain the read-in information after update */
void SetOutputPointer(DiffusionImageHeaderInformation::Pointer output)
{ this->m_Output = output; }
/** do the work */
virtual void Update();
/** return output */
DiffusionImageHeaderInformation::Pointer GetOutput();
/** identify vendor */
SupportedVendors GetVendorID();
protected:
/** Default c'tor */
DicomDiffusionImageHeaderReader();
/** Default d'tor */
virtual ~DicomDiffusionImageHeaderReader();
void ReadPublicTags();
void ReadPublicTags2();
void TransformGradients();
FileNamesContainer m_DicomFilenames;
DiffusionImageHeaderInformation::Pointer m_Output;
ImageIOType::Pointer m_GdcmIO;
VolumeReaderType::Pointer m_VolumeReader;
bool m_SliceOrderIS;
bool m_SingleSeries;
int m_nSlice;
std::vector<float> m_sliceLocations;
};
}
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkGroupDiffusionHeadersFilter.h b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkGroupDiffusionHeadersFilter.h
index a4f37682bb..4c629cf3f8 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkGroupDiffusionHeadersFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkGroupDiffusionHeadersFilter.h
@@ -1,105 +1,109 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _mitkGroupDiffusionHeadersFilter_h
#define _mitkGroupDiffusionHeadersFilter_h
#include "DiffusionCoreExports.h"
#include "mitkBaseProcess.h"
#include "mitkDiffusionImageHeaderInformation.h"
namespace mitk
{
/**
* @brief Groups Headers containing Diffusion Information
* @ingroup Process
*/
class DiffusionCore_EXPORT GroupDiffusionHeadersFilter : public BaseProcess
{
public:
mitkClassMacro( GroupDiffusionHeadersFilter, BaseProcess );
itkNewMacro( Self );
typedef mitk::DiffusionImageHeaderInformation HeaderType;
typedef HeaderType::Pointer HeaderPointer;
typedef std::vector<HeaderPointer> InputType;
typedef std::vector<InputType> OutputType;
/**
* Sets the input of this process object
* @param input the input
*/
virtual void SetInput( InputType input );
/**
* Sets the input n'th of this process object
* @param idx the number associated with the given input
*/
virtual void SetInput( const unsigned int& idx, InputType input );
/**
* Sets the input n'th of this process object
* @param idx the number associated with the given input
*/
virtual void SetNthOutput( const unsigned int& idx, InputType output );
/**
* @returns the input tree of the process object
*/
InputType GetInput( void );
/**
* @param idx the index of the input to return
* @returns the input object with the given index
*/
InputType GetInput( const unsigned int& idx );
OutputType GetOutput();
+ virtual DataObjectPointer MakeOutput ( DataObjectPointerArraySizeType ){}
+
+ virtual DataObjectPointer MakeOutput(const DataObjectIdentifierType& ) {}
+
virtual void GenerateOutputInformation();
virtual void Update();
protected:
/**
* A default constructor
*/
GroupDiffusionHeadersFilter();
/**
* The destructor
*/
virtual ~GroupDiffusionHeadersFilter();
OutputType m_Output;
InputType m_Input;
private:
void operator=( const Self& ); //purposely not implemented
}
;
} //end of namespace mitk
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
index 42506c0386..ea1bc9b0eb 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
@@ -1,126 +1,123 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkDiffusionImage__h
#define __mitkDiffusionImage__h
#include "mitkImage.h"
#include "itkVectorImage.h"
#include "itkVectorImageToImageAdaptor.h"
#include <iomanip>
#include <itkCommand.h>
namespace mitk
{
/**
* \brief this class encapsulates diffusion volumes (vectorimages not
* yet supported by mitkImage)
*/
template<class TPixelType>
class DiffusionImage : public Image
{
public:
typedef TPixelType PixelType;
typedef typename itk::VectorImage<TPixelType, 3>
ImageType;
typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
typedef itk::VectorContainer< unsigned int,
GradientDirectionType > GradientDirectionContainerType;
typedef itk::VectorImageToImageAdaptor< TPixelType, 3 >
AdaptorType;
typedef vnl_matrix_fixed< double, 3, 3 > MeasurementFrameType;
// BValue Map
// key := b-Value
// value := indicesVector (containing corresponding gradient directions for a b-Value-Shell
typedef std::vector< unsigned int > IndicesVector;
typedef std::map< double , IndicesVector > BValueMap;
mitkClassMacro( DiffusionImage, Image )
itkNewMacro(Self)
void AverageRedundantGradients(double precision);
GradientDirectionContainerType::Pointer CalcAveragedDirectionSet(double precision, GradientDirectionContainerType::Pointer directions);
void CorrectDKFZBrokenGradientScheme(double precision);
typename ImageType::Pointer GetVectorImage() { return m_VectorImage; }
void SetVectorImage(typename ImageType::Pointer image ) { this->m_VectorImage = image; }
void InitializeFromVectorImage();
void SetDisplayIndexForRendering(int displayIndex);
GradientDirectionContainerType::Pointer GetDirectionsWithoutMeasurementFrame() { return m_OriginalDirections; }
GradientDirectionContainerType::Pointer GetDirections() { return m_Directions; }
void SetDirections( GradientDirectionContainerType::Pointer directions )
{
this->m_OriginalDirections = directions;
ApplyMeasurementFrame();
}
void SetDirections(const std::vector<itk::Vector<double,3> > directions);
MeasurementFrameType GetMeasurementFrame() { return m_MeasurementFrame; }
void SetMeasurementFrame( MeasurementFrameType mFrame ) { this->m_MeasurementFrame = mFrame; this->ApplyMeasurementFrame(); }
bool AreAlike(GradientDirectionType g1, GradientDirectionType g2, double precision);
int GetNumDirections();
int GetNumB0();
float GetB_Value(int i);
bool IsMultiBval();
- void UpdateBValueList();
+ void UpdateBValueMap();
IndicesVector GetB0Indices();
itkGetMacro(B_Value, float)
itkSetMacro(B_Value, float)
BValueMap GetB_ValueMap(){ return m_B_ValueMap; }
void AddDirectionsContainerObserver();
void RemoveDirectionsContainerObserver();
protected:
DiffusionImage();
virtual ~DiffusionImage();
void ApplyMeasurementFrame();
typename ImageType::Pointer m_VectorImage;
GradientDirectionContainerType::Pointer m_Directions;
GradientDirectionContainerType::Pointer m_OriginalDirections;
float m_B_Value;
typename AdaptorType::Pointer m_VectorImageAdaptor;
int m_DisplayIndex;
MeasurementFrameType m_MeasurementFrame;
BValueMap m_B_ValueMap;
-
-
-
unsigned long m_DirectionsObserverTag;
};
} // namespace mitk
#include "mitkDiffusionImage.txx"
#endif /* __mitkDiffusionImage__h */
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx
index afb1972fad..006e59d3ba 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx
@@ -1,430 +1,424 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIterator.h"
#include "mitkImageCast.h"
template<typename TPixelType>
mitk::DiffusionImage<TPixelType>::DiffusionImage()
: m_VectorImage(0), m_Directions(0), m_OriginalDirections(0), m_B_Value(-1.0), m_VectorImageAdaptor(0)
{
MeasurementFrameType mf;
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
mf[i][j] = 0;
for(int i=0; i<3; i++)
mf[i][i] = 1;
m_MeasurementFrame = mf;
}
template<typename TPixelType>
mitk::DiffusionImage<TPixelType>::~DiffusionImage()
{
// Remove Observer for m_Directions
RemoveDirectionsContainerObserver();
}
template<typename TPixelType>
void mitk::DiffusionImage<TPixelType>
::InitializeFromVectorImage()
{
if(!m_VectorImage || !m_Directions || m_B_Value==-1.0)
{
MITK_INFO << "DiffusionImage could not be initialized. Set all members first!" << std::endl;
return;
}
// find bzero index
int firstZeroIndex = -1;
for(GradientDirectionContainerType::ConstIterator it = m_Directions->Begin();
it != m_Directions->End(); ++it)
{
firstZeroIndex++;
GradientDirectionType g = it.Value();
if(g[0] == 0 && g[1] == 0 && g[2] == 0 )
break;
}
typedef itk::Image<TPixelType,3> ImgType;
typename ImgType::Pointer img = ImgType::New();
img->SetSpacing( m_VectorImage->GetSpacing() ); // Set the image spacing
img->SetOrigin( m_VectorImage->GetOrigin() ); // Set the image origin
img->SetDirection( m_VectorImage->GetDirection() ); // Set the image direction
img->SetLargestPossibleRegion( m_VectorImage->GetLargestPossibleRegion());
img->SetBufferedRegion( m_VectorImage->GetLargestPossibleRegion() );
img->Allocate();
int vecLength = m_VectorImage->GetVectorLength();
InitializeByItk( img.GetPointer(), 1, vecLength );
itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
itw = itw.Begin();
itk::ImageRegionConstIterator<ImageType> itr (m_VectorImage, m_VectorImage->GetLargestPossibleRegion() );
itr = itr.Begin();
while(!itr.IsAtEnd())
{
itw.Set(itr.Get().GetElement(firstZeroIndex));
++itr;
++itw;
}
// init
SetImportVolume(img->GetBufferPointer());
m_DisplayIndex = firstZeroIndex;
MITK_INFO << "Diffusion-Image successfully initialized.";
}
template<typename TPixelType>
void mitk::DiffusionImage<TPixelType>
::SetDisplayIndexForRendering(int displayIndex)
{
int index = displayIndex;
int vecLength = m_VectorImage->GetVectorLength();
index = index > vecLength-1 ? vecLength-1 : index;
if( m_DisplayIndex != index )
{
typedef itk::Image<TPixelType,3> ImgType;
typename ImgType::Pointer img = ImgType::New();
CastToItkImage<ImgType>(this, img);
itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
itw = itw.Begin();
itk::ImageRegionConstIterator<ImageType> itr (m_VectorImage, m_VectorImage->GetLargestPossibleRegion() );
itr = itr.Begin();
while(!itr.IsAtEnd())
{
itw.Set(itr.Get().GetElement(index));
++itr;
++itw;
}
}
m_DisplayIndex = index;
}
template<typename TPixelType>
bool mitk::DiffusionImage<TPixelType>::AreAlike(GradientDirectionType g1,
GradientDirectionType g2,
double precision)
{
GradientDirectionType diff = g1 - g2;
GradientDirectionType diff2 = g1 + g2;
return diff.two_norm() < precision || diff2.two_norm() < precision;
}
template<typename TPixelType>
void mitk::DiffusionImage<TPixelType>::CorrectDKFZBrokenGradientScheme(double precision)
{
GradientDirectionContainerType::Pointer directionSet = CalcAveragedDirectionSet(precision, m_Directions);
if(directionSet->size() < 7)
{
MITK_INFO << "Too few directions, assuming and correcting DKFZ-bogus sequence details.";
double v [7][3] =
{{ 0, 0, 0 },
{-0.707057, 0, 0.707057 },
{ 0.707057, 0, 0.707057 },
{ 0, 0.707057, 0.707057 },
{ 0, 0.707057, -0.707057 },
{-0.707057, 0.707057, 0 },
{ 0.707057, 0.707057, 0 } };
int i=0;
for(GradientDirectionContainerType::Iterator it = m_OriginalDirections->Begin();
it != m_OriginalDirections->End(); ++it)
{
it.Value().set(v[i++%7]);
}
ApplyMeasurementFrame();
}
}
template<typename TPixelType>
mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Pointer
mitk::DiffusionImage<TPixelType>::CalcAveragedDirectionSet(double precision, GradientDirectionContainerType::Pointer directions)
{
// save old and construct new direction container
GradientDirectionContainerType::Pointer newDirections = GradientDirectionContainerType::New();
// fill new direction container
for(GradientDirectionContainerType::ConstIterator gdcitOld = directions->Begin();
gdcitOld != directions->End(); ++gdcitOld)
{
// already exists?
bool found = false;
for(GradientDirectionContainerType::ConstIterator gdcitNew = newDirections->Begin();
gdcitNew != newDirections->End(); ++gdcitNew)
{
if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
{
found = true;
break;
}
}
// if not found, add it to new container
if(!found)
{
newDirections->push_back(gdcitOld.Value());
}
}
return newDirections;
}
template<typename TPixelType>
void mitk::DiffusionImage<TPixelType>::AverageRedundantGradients(double precision)
{
GradientDirectionContainerType::Pointer newDirs =
CalcAveragedDirectionSet(precision, m_Directions);
GradientDirectionContainerType::Pointer newOriginalDirs =
CalcAveragedDirectionSet(precision, m_OriginalDirections);
// if sizes equal, we do not need to do anything in this function
if(m_Directions->size() == newDirs->size() || m_OriginalDirections->size() == newOriginalDirs->size())
return;
GradientDirectionContainerType::Pointer oldDirections = m_OriginalDirections;
m_Directions = newDirs;
m_OriginalDirections = newOriginalDirs;
// new image
typename ImageType::Pointer oldImage = m_VectorImage;
m_VectorImage = ImageType::New();
m_VectorImage->SetSpacing( oldImage->GetSpacing() ); // Set the image spacing
m_VectorImage->SetOrigin( oldImage->GetOrigin() ); // Set the image origin
m_VectorImage->SetDirection( oldImage->GetDirection() ); // Set the image direction
m_VectorImage->SetLargestPossibleRegion( oldImage->GetLargestPossibleRegion() );
m_VectorImage->SetVectorLength( m_Directions->size() );
m_VectorImage->SetBufferedRegion( oldImage->GetLargestPossibleRegion() );
m_VectorImage->Allocate();
// average image data that corresponds to identical directions
itk::ImageRegionIterator< ImageType > newIt(m_VectorImage, m_VectorImage->GetLargestPossibleRegion());
newIt.GoToBegin();
itk::ImageRegionIterator< ImageType > oldIt(oldImage, oldImage->GetLargestPossibleRegion());
oldIt.GoToBegin();
// initial new value of voxel
typename ImageType::PixelType newVec;
newVec.SetSize(m_Directions->size());
newVec.AllocateElements(m_Directions->size());
std::vector<std::vector<int> > dirIndices;
for(GradientDirectionContainerType::ConstIterator gdcitNew = m_Directions->Begin();
gdcitNew != m_Directions->End(); ++gdcitNew)
{
dirIndices.push_back(std::vector<int>(0));
for(GradientDirectionContainerType::ConstIterator gdcitOld = oldDirections->Begin();
gdcitOld != oldDirections->End(); ++gdcitOld)
{
if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
{
//MITK_INFO << gdcitNew.Value() << " " << gdcitOld.Value();
dirIndices[gdcitNew.Index()].push_back(gdcitOld.Index());
}
}
}
//int ind1 = -1;
while(!newIt.IsAtEnd())
{
// progress
//typename ImageType::IndexType ind = newIt.GetIndex();
//ind1 = ind.m_Index[2];
// init new vector with zeros
newVec.Fill(0.0);
// the old voxel value with duplicates
typename ImageType::PixelType oldVec = oldIt.Get();
for(unsigned int i=0; i<dirIndices.size(); i++)
{
// do the averaging
const unsigned int numavg = dirIndices[i].size();
unsigned int sum = 0;
for(int j=0; j<numavg; j++)
{
//MITK_INFO << newVec[i] << " << " << oldVec[dirIndices[i].at(j)];
sum += oldVec[dirIndices[i].at(j)];
}
if(numavg == 0)
{
MITK_ERROR << "mitkDiffusionImage: Error on averaging. Possibly due to corrupted data";
return;
}
newVec[i] = sum / numavg;
}
newIt.Set(newVec);
++newIt;
++oldIt;
}
ApplyMeasurementFrame();
std::cout << std::endl;
}
template<typename TPixelType>
void mitk::DiffusionImage<TPixelType>::ApplyMeasurementFrame()
{
RemoveDirectionsContainerObserver();
m_Directions = GradientDirectionContainerType::New();
int c = 0;
for(GradientDirectionContainerType::ConstIterator gdcit = m_OriginalDirections->Begin();
gdcit != m_OriginalDirections->End(); ++gdcit)
{
vnl_vector<double> vec = gdcit.Value();
vec = vec.pre_multiply(m_MeasurementFrame);
m_Directions->InsertElement(c, vec);
c++;
}
- UpdateBValueList();
+ UpdateBValueMap();
AddDirectionsContainerObserver();
}
// returns number of gradients
template<typename TPixelType>
int mitk::DiffusionImage<TPixelType>::GetNumDirections()
{
int gradients = m_OriginalDirections->Size();
for (int i=0; i<m_OriginalDirections->Size(); i++)
if (GetB_Value(i)<=0)
{
gradients--;
}
return gradients;
}
// returns number of not diffusion weighted images
template<typename TPixelType>
int mitk::DiffusionImage<TPixelType>::GetNumB0()
{
int b0 = 0;
for (int i=0; i<m_OriginalDirections->Size(); i++)
if (GetB_Value(i)<=0)
{
b0++;
}
return b0;
}
// returns a list of indices belonging to the not diffusion weighted images
template<typename TPixelType>
typename mitk::DiffusionImage<TPixelType>::IndicesVector mitk::DiffusionImage<TPixelType>::GetB0Indices()
{
IndicesVector indices;
for (int i=0; i<m_OriginalDirections->Size(); i++)
if (GetB_Value(i)<=0)
{
indices.push_back(i);
}
return indices;
}
template<typename TPixelType>
bool mitk::DiffusionImage<TPixelType>::IsMultiBval()
{
int gradients = m_OriginalDirections->Size();
for (int i=0; i<gradients; i++)
if (GetB_Value(i)>0 && std::fabs(m_B_Value-GetB_Value(i))>50)
return true;
return false;
}
template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::UpdateBValueList()
+void mitk::DiffusionImage<TPixelType>::UpdateBValueMap()
{
m_B_ValueMap.clear();
GradientDirectionContainerType::ConstIterator gdcit;
for( gdcit = this->m_Directions->Begin(); gdcit != this->m_Directions->End(); ++gdcit)
- {
- float currentBvalue = std::floor(GetB_Value(gdcit.Index()));
- double rounded = int((currentBvalue+7.5)/10)*10;
- m_B_ValueMap[rounded].push_back(gdcit.Index());
- }
-
- /*
- BValueMap::iterator it = m_B_ValueMap.begin();
- for(;it != m_B_ValueMap.end(); it++)
- {
- MITK_INFO << it->first << " : " << it->second.size();
- }
- */
-
+ m_B_ValueMap[GetB_Value(gdcit.Index())].push_back(gdcit.Index());
}
template<typename TPixelType>
float mitk::DiffusionImage<TPixelType>::GetB_Value(int i)
{
if(i > m_Directions->Size()-1)
return -1;
if(m_Directions->ElementAt(i).one_norm() <= 0.0)
{
return 0;
}
else
{
double twonorm = m_Directions->ElementAt(i).two_norm();
- return m_B_Value*twonorm*twonorm ;
+ double bval = m_B_Value*twonorm*twonorm;
+
+ if (bval<0)
+ bval = ceil(bval - 0.5);
+ else
+ bval = floor(bval + 0.5);
+
+ return bval;
}
}
template<typename TPixelType>
void mitk::DiffusionImage<TPixelType>::SetDirections(const std::vector<itk::Vector<double,3> > directions)
{
m_OriginalDirections = GradientDirectionContainerType::New();
for(unsigned int i=0; i<directions.size(); i++)
{
m_OriginalDirections->InsertElement( i, directions[i].Get_vnl_vector() );
}
this->ApplyMeasurementFrame();
}
template<typename TPixelType>
void mitk::DiffusionImage<TPixelType>::AddDirectionsContainerObserver()
{
// Add Modified Observer to invoke an UpdateBValueList by modifieng the DirectionsContainer (m_Directions)
typedef DiffusionImage< TPixelType > Self;
typedef itk::SimpleMemberCommand< Self > DCCommand ;
typename DCCommand::Pointer command = DCCommand::New();
- command->SetCallbackFunction(this, &Self::UpdateBValueList);
+ command->SetCallbackFunction(this, &Self::UpdateBValueMap);
}
template<typename TPixelType>
void mitk::DiffusionImage<TPixelType>::RemoveDirectionsContainerObserver()
{
if(m_Directions){
m_Directions->RemoveAllObservers();
}
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
index ea7c9ffb8b..b09793c9be 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
@@ -1,103 +1,101 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __MITK_NRRD_DIFFUSION_VOULMES_IO_FACTORY_CPP__
#define __MITK_NRRD_DIFFUSION_VOULMES_IO_FACTORY_CPP__
#include "mitkDiffusionImageSource.h"
#include "mitkDiffusionImage.h"
template<typename TPixelType>
mitk::DiffusionImageSource<TPixelType>::DiffusionImageSource()
{
// Create the output. We use static_cast<> here because we know the default
// output must be of type DiffusionImage
typename mitk::DiffusionImage<TPixelType>::Pointer output
= static_cast<typename mitk::DiffusionImage<TPixelType>*>(this->MakeOutput(0).GetPointer());
Superclass::SetNumberOfRequiredOutputs(1);
Superclass::SetNthOutput(0, output.GetPointer());
}
template<typename TPixelType>
mitk::DiffusionImageSource<TPixelType>::~DiffusionImageSource()
{
}
+template<typename TPixelType>
+itk::DataObject::Pointer mitk::DiffusionImageSource<TPixelType>::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
+{
+ return OutputType::New().GetPointer();
+}
+
template<typename TPixelType>
-itk::DataObject::Pointer mitk::DiffusionImageSource<TPixelType>::MakeOutput( unsigned int /*idx*/ )
+itk::DataObject::Pointer mitk::DiffusionImageSource<TPixelType>::MakeOutput( const DataObjectIdentifierType & name )
{
- return static_cast<itk::DataObject*>(mitk::DiffusionImage<TPixelType>::New().GetPointer());
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
+ {
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
+ }
+ return static_cast<itk::DataObject *>(OutputType::New().GetPointer());
}
//template<typename TPixelType>
//mitk::DiffusionImage<TPixelType>* mitk::DiffusionImageSource<TPixelType>::GetOutput()
//{
// if (this->GetNumberOfOutputs() < 1)
// {
// return 0;
// }
//
// return static_cast<mitk::DiffusionImage<TPixelType>*>
-// (this->BaseProcess::GetOutput(0));
-//}
-//
-//template<typename TPixelType>
-//mitk::DiffusionImage<TPixelType>* mitk::DiffusionImageSource<TPixelType>::GetOutput(unsigned int idx)
-//{
-// return static_cast<mitk::DiffusionImage<TPixelType>*>
-// (this->ProcessObject::GetOutput(idx));
+// (this->BaseProcess::GetOutput());
//}
//
-//template<typename TPixelType>
-//void mitk::DiffusionImageSource<TPixelType>::SetOutput(mitk::DiffusionImage<TPixelType>* output)
-//{
-// itkWarningMacro(<< "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead." );
-// BaseProcess::SetNthOutput(0, output);
-//}
//
//template<typename TPixelType>
//void mitk::DiffusionImageSource<TPixelType>::GraftOutput(mitk::DiffusionImage<TPixelType>* graft)
//{
// this->GraftNthOutput(0, graft);
//}
//
//template<typename TPixelType>
//void mitk::DiffusionImageSource<TPixelType>::GraftNthOutput(unsigned int idx, mitk::DiffusionImage<TPixelType> *graft)
//{
// if (idx < this->GetNumberOfOutputs())
// {
// mitk::DiffusionImage<TPixelType> * output = this->GetOutput(idx);
//
// if (output && graft)
// {
// // grab a handle to the bulk data of the specified data object
// // output->SetPixelContainer( graft->GetPixelContainer() ); @FIXME!!!!
//
// // copy the region ivars of the specified data object
// output->SetRequestedRegion( graft );//graft->GetRequestedRegion() );
// // output->SetLargestPossibleRegion( graft->GetLargestPossibleRegion() ); @FIXME!!!!
// // output->SetBufferedRegion( graft->GetBufferedRegion() ); @FIXME!!!!
//
// // copy the meta-information
// output->CopyInformation( graft );
// }
// }
//}
#endif //__MITK_NRRD_DIFFUSION_VOULMES_IO_FACTORY_CPP__
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
index fcbaf663d8..50e1b9f1f1 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
@@ -1,77 +1,91 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_
#define _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_
#include "mitkImageSource.h"
namespace mitk {
template<typename TPixelType>
class DiffusionImage;
/*class DiffusionImage<double>;
class DiffusionImage<int>;
class DiffusionImage<unsigned int>;
class DiffusionImage<short>;
class DiffusionImage<unsigned short>;
class DiffusionImage<char>;
class DiffusionImage<unsigned char>;
class DiffusionImage<long>;
class DiffusionImage<unsigned long>;*/
//##Documentation
//## @brief Superclass of all classes generating diffusion volumes (instances
//## of class DiffusionImage) as output.
//##
//## @ingroup Process
template<typename TPixelType>
class DiffusionImageSource : public ImageSource
{
public:
mitkClassMacro(DiffusionImageSource, BaseProcess);
itkNewMacro(Self);
typedef DiffusionImage<TPixelType> OutputType;
typedef itk::DataObject::Pointer DataObjectPointer;
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ /**
+ * Allocates a new output object and returns it. Currently the
+ * index idx is not evaluated.
+ * @param idx the index of the output for which an object should be created
+ * @returns the new object
+ */
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
+
+ /**
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
+ */
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
//void SetOutput(OutputType* output);
//OutputType* GetOutput()
//{return Superclass::GetOutput();}
//OutputType* GetOutput(unsigned int idx);
//virtual void GraftOutput(OutputType* graft);
//virtual void GraftNthOutput(unsigned int idx, OutputType *graft);
protected:
DiffusionImageSource();
virtual ~DiffusionImageSource();
};
} // namespace mitk
#include "mitkDiffusionImageSource.cpp"
#endif /* _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_ */
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/QBallImages/mitkQBallImageSource.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/QBallImages/mitkQBallImageSource.cpp
index 52c59664d8..e0cbf8acb2 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/QBallImages/mitkQBallImageSource.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/QBallImages/mitkQBallImageSource.cpp
@@ -1,34 +1,34 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkQBallImageSource.h"
mitk::QBallImageSource::QBallImageSource()
{
// Create the output. We use static_cast<> here because we know the default
// output must be of type TOutputImage
OutputImageType::Pointer output
= static_cast<OutputImageType*>(this->MakeOutput(0).GetPointer());
Superclass::SetNumberOfRequiredOutputs(1);
Superclass::SetNthOutput(0, output.GetPointer());
}
-mitk::QBallImageSource::DataObjectPointer mitk::QBallImageSource::MakeOutput( unsigned int /*idx*/ )
+mitk::QBallImageSource::DataObjectPointer mitk::QBallImageSource::MakeOutput( DataObjectPointerArraySizeType /*idx*/ )
{
return static_cast<itk::DataObject*>(OutputImageType::New().GetPointer());
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/QBallImages/mitkQBallImageSource.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/QBallImages/mitkQBallImageSource.h
index b30cf8bc27..6b30edbb93 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/QBallImages/mitkQBallImageSource.h
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/QBallImages/mitkQBallImageSource.h
@@ -1,49 +1,49 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QBallImageSource_H_HEADER_INCLUDED_C1E7D6EC
#define QBallImageSource_H_HEADER_INCLUDED_C1E7D6EC
#include "mitkImageSource.h"
#include "mitkQBallImage.h"
#include <DiffusionCoreExports.h>
namespace mitk {
class DiffusionCore_EXPORT QBallImageSource : public ImageSource
{
public:
typedef mitk::QBallImage OutputImageType;
typedef OutputImageType::Pointer OutputImagePointer;
typedef SlicedData::RegionType OutputImageRegionType;
typedef itk::DataObject::Pointer DataObjectPointer;
mitkClassMacro(QBallImageSource,ImageSource);
itkNewMacro(Self);
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx);
protected:
QBallImageSource();
virtual ~QBallImageSource() {}
};
} // namespace mitk
#endif /* QBallImageSource_H_HEADER_INCLUDED_C1E7D6EC */
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
index ebf6b8fce2..d0ec59a1ac 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
@@ -1,274 +1,291 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNrrdTensorImageReader.h"
#include "itkImageFileReader.h"
#include "itkImageRegionIterator.h"
#include "itkMetaDataObject.h"
#include "itkNrrdImageIO.h"
-#include "itkDiffusionTensor3D.h"
+
#include "mitkITKImageImport.h"
#include "mitkImageDataItem.h"
namespace mitk
{
void NrrdTensorImageReader
::GenerateData()
{
if ( m_FileName == "")
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!");
}
else
{
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
typedef itk::VectorImage<float,3> ImageType;
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(this->m_FileName);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType;
VecImgType::Pointer vecImg = VecImgType::New();
vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing
vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin
vecImg->SetDirection( img->GetDirection() ); // Set the image direction
vecImg->SetRegions( img->GetLargestPossibleRegion());
vecImg->Allocate();
itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
ot = ot.Begin();
itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
it = it.Begin();
typedef ImageType::PixelType VarPixType;
typedef VecImgType::PixelType FixPixType;
int numComponents = img->GetNumberOfComponentsPerPixel();
itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
std::string metaString;
bool readFrame = false;
double xx, xy, xz, yx, yy, yz, zx, zy, zz;
MeasurementFrameType measFrame;
measFrame.SetIdentity();
MeasurementFrameType measFrameTransp;
measFrameTransp.SetIdentity();
for (; itKey != imgMetaKeys.end(); itKey ++)
{
itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
if (itKey->find("measurement frame") != std::string::npos)
{
sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
yx>10e-10 || yy>10e-10 || yz>10e-10 ||
zx>10e-10 || zy>10e-10 || zz>10e-10 )
{
readFrame = true;
measFrame(0,0) = xx;
measFrame(0,1) = xy;
measFrame(0,2) = xz;
measFrame(1,0) = yx;
measFrame(1,1) = yy;
measFrame(1,2) = yz;
measFrame(2,0) = zx;
measFrame(2,1) = zy;
measFrame(2,2) = zz;
measFrameTransp = measFrame.GetTranspose();
}
}
}
if (numComponents==6)
{
while (!it.IsAtEnd())
{
// T'=RTR'
VarPixType vec = it.Get();
FixPixType fixVec(vec.GetDataPointer());
if(readFrame)
{
itk::DiffusionTensor3D<float> tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(3));
tensor.SetElement(4, vec.GetElement(4));
tensor.SetElement(5, vec.GetElement(5));
- tensor = tensor.PreMultiply(measFrame);
- tensor = tensor.PostMultiply(measFrameTransp);
+ tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
+ tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
fixVec = tensor;
}
ot.Set(fixVec);
++ot;
++it;
}
}
else if(numComponents==9)
{
while (!it.IsAtEnd())
{
VarPixType vec = it.Get();
itk::DiffusionTensor3D<float> tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(4));
tensor.SetElement(4, vec.GetElement(5));
tensor.SetElement(5, vec.GetElement(8));
if(readFrame)
{
- tensor = tensor.PreMultiply(measFrame);
- tensor = tensor.PostMultiply(measFrameTransp);
+ tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
+ tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
}
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
++it;
}
}
else
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!");
}
this->GetOutput()->InitializeByItk(vecImg.GetPointer());
this->GetOutput()->SetVolume(vecImg->GetBufferPointer());
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
catch(std::exception& e)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
}
catch(...)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!");
}
}
}
void NrrdTensorImageReader::GenerateOutputInformation()
{
}
const char* NrrdTensorImageReader
::GetFileName() const
{
return m_FileName.c_str();
}
void NrrdTensorImageReader
::SetFileName(const char* aFileName)
{
m_FileName = aFileName;
}
const char* NrrdTensorImageReader
::GetFilePrefix() const
{
return m_FilePrefix.c_str();
}
void NrrdTensorImageReader
::SetFilePrefix(const char* aFilePrefix)
{
m_FilePrefix = aFilePrefix;
}
const char* NrrdTensorImageReader
::GetFilePattern() const
{
return m_FilePattern.c_str();
}
void NrrdTensorImageReader
::SetFilePattern(const char* aFilePattern)
{
m_FilePattern = aFilePattern;
}
bool NrrdTensorImageReader
::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
{
// First check the extension
if( filename == "" )
{
return false;
}
std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
ext = itksys::SystemTools::LowerCase(ext);
if (ext == ".hdti" || ext == ".dti")
{
return true;
}
return false;
}
+ itk::DiffusionTensor3D<float> NrrdTensorImageReader
+ ::ConvertMatrixTypeToFixedArrayType(const itk::DiffusionTensor3D<float>::Superclass::MatrixType & matrix)
+ {
+ /* | 0 1 2 |
+ * | X 3 4 |
+ * | X X 5 |
+ */
+ itk::DiffusionTensor3D<float> arr;
+ arr.SetElement(0,matrix(0,0));
+ arr.SetElement(1,matrix(0,1));
+ arr.SetElement(2,matrix(0,2));
+ arr.SetElement(3,matrix(1,3));
+ arr.SetElement(4,matrix(1,4));
+ arr.SetElement(5,matrix(2,5));
+ return arr;
+ }
+
} //namespace MITK
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.h
index fb7b9bbe6f..51f2d6767d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.h
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.h
@@ -1,70 +1,72 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkNrrdTensorImageReader_h
#define __mitkNrrdTensorImageReader_h
#include "mitkCommon.h"
#include "itkVectorContainer.h"
#include "mitkFileReader.h"
#include "vnl/vnl_vector_fixed.h"
#include "mitkTensorImage.h"
#include "mitkTensorImageSource.h"
#include "itkVectorImage.h"
+#include "itkDiffusionTensor3D.h"
namespace mitk
{
/** \brief
*/
class NrrdTensorImageReader : public mitk::TensorImageSource, public FileReader
{
public:
typedef mitk::TensorImage OutputType;
typedef mitk::TensorImageSource DTImgSourceType;
typedef itk::Matrix< float, 3, 3 > MeasurementFrameType;
mitkClassMacro( NrrdTensorImageReader, DTImgSourceType );
itkNewMacro(Self);
const char* GetFileName() const;
void SetFileName(const char* aFileName);
const char* GetFilePrefix() const;
void SetFilePrefix(const char* aFilePrefix);
const char* GetFilePattern() const;
void SetFilePattern(const char* aFilePattern);
static bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern);
protected:
/** Does the real work. */
virtual void GenerateData();
virtual void GenerateOutputInformation();
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
private:
void operator=(const Self&); //purposely not implemented
+ itk::DiffusionTensor3D<float> ConvertMatrixTypeToFixedArrayType(const itk::DiffusionTensor3D<float>::Superclass::MatrixType & matrix);
};
} //namespace MITK
#endif // __mitkNrrdTensorImageReader_h
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkTensorImageSource.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkTensorImageSource.cpp
index f718e4a883..1042aaf5b8 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkTensorImageSource.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkTensorImageSource.cpp
@@ -1,34 +1,34 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTensorImageSource.h"
mitk::TensorImageSource::TensorImageSource()
{
// Create the output. We use static_cast<> here because we know the default
// output must be of type TOutputImage
OutputImageType::Pointer output
= static_cast<OutputImageType*>(this->MakeOutput(0).GetPointer());
Superclass::SetNumberOfRequiredOutputs(1);
Superclass::SetNthOutput(0, output.GetPointer());
}
-mitk::TensorImageSource::DataObjectPointer mitk::TensorImageSource::MakeOutput( unsigned int /*idx*/ )
+mitk::TensorImageSource::DataObjectPointer mitk::TensorImageSource::MakeOutput(DataObjectPointerArraySizeType /*idx*/ )
{
return static_cast<itk::DataObject*>(OutputImageType::New().GetPointer());
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkTensorImageSource.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkTensorImageSource.h
index 43ba683894..596ce7c1bf 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkTensorImageSource.h
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkTensorImageSource.h
@@ -1,48 +1,48 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef TensorImageSource_H_HEADER_INCLUDED_C1E7D6EC
#define TensorImageSource_H_HEADER_INCLUDED_C1E7D6EC
#include "mitkImageSource.h"
#include "mitkTensorImage.h"
namespace mitk {
class TensorImageSource : public ImageSource
{
public:
typedef mitk::TensorImage OutputImageType;
typedef OutputImageType::Pointer OutputImagePointer;
typedef SlicedData::RegionType OutputImageRegionType;
typedef itk::DataObject::Pointer DataObjectPointer;
mitkClassMacro(TensorImageSource,ImageSource);
itkNewMacro(Self);
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx);
protected:
TensorImageSource();
virtual ~TensorImageSource() {}
};
} // namespace mitk
#endif /* TensorImageSource_H_HEADER_INCLUDED_C1E7D6EC */
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.h b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.h
index ebb39a1a04..374a018ef2 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.h
@@ -1,145 +1,145 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef ODFVTKMAPPER2D_H_HEADER_INCLUDED
#define ODFVTKMAPPER2D_H_HEADER_INCLUDED
#include "mitkVtkMapper.h"
#include "vtkPropAssembly.h"
#include "vtkAppendPolyData.h"
#include "vtkActor.h"
#include "vtkPolyDataMapper.h"
#include "vtkPlane.h"
#include "vtkCutter.h"
#include "vtkClipPolyData.h"
#include "vtkTransform.h"
#include "vtkDataArrayTemplate.h"
#include "vtkSmartPointer.h"
#include "vtkOdfSource.h"
#include "vtkThickPlane.h"
namespace mitk {
//##Documentation
//## @brief Mapper for spherical object densitiy function representations
//##
template<class TPixelType, int NrOdfDirections>
class OdfVtkMapper2D : public VtkMapper
{
struct OdfDisplayGeometry {
vtkFloatingPointType vp[ 3 ], vnormal[ 3 ];
Vector3D normal;
double d, d1, d2;
mitk::Point3D M3D, L3D, O3D;
vtkFloatingPointType vp_original[ 3 ], vnormal_original[ 3 ];
mitk::Vector2D size, origin;
bool Equals(OdfDisplayGeometry other)
{
return other.vp_original[0] == vp[0] &&
other.vp_original[1] == vp[1] &&
other.vp_original[2] == vp[2] &&
other.vnormal_original[0] == vnormal[0] &&
other.vnormal_original[1] == vnormal[1] &&
other.vnormal_original[2] == vnormal[2] &&
other.size[0] == size[0] &&
other.size[1] == size[1] &&
other.origin[0] == origin[0] &&
other.origin[1] == origin[1];
}
};
public:
mitkClassMacro(OdfVtkMapper2D,VtkMapper)
itkNewMacro(Self)
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
bool IsVisibleOdfs(mitk::BaseRenderer* renderer);
virtual void MitkRenderOverlay(mitk::BaseRenderer* renderer);
virtual void MitkRenderOpaqueGeometry(mitk::BaseRenderer* renderer);
virtual void MitkRenderTranslucentGeometry(mitk::BaseRenderer* renderer);
virtual void MitkRenderVolumetricGeometry(mitk::BaseRenderer* /*renderer*/){}
OdfDisplayGeometry MeasureDisplayedGeometry(mitk::BaseRenderer* renderer);
double GetMinImageSpacing( int index );
void ApplyPropertySettings();
virtual void Slice(mitk::BaseRenderer* renderer, OdfDisplayGeometry dispGeo);
virtual int GetIndex(mitk::BaseRenderer* renderer);
static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false);
virtual void Update(mitk::BaseRenderer * renderer);
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
virtual bool IsLODEnabled( BaseRenderer * /*renderer*/ ) const { return true; }
class LocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
std::vector< vtkSmartPointer<vtkPropAssembly> > m_PropAssemblies;
std::vector< vtkSmartPointer<vtkAppendPolyData> > m_OdfsPlanes;
std::vector< vtkSmartPointer<vtkActor> > m_OdfsActors;
std::vector< vtkSmartPointer<vtkPolyDataMapper> > m_OdfsMappers;
vtkSmartPointer< vtkPolyData > m_TemplateOdf;
itk::TimeStamp m_LastUpdateTime;
/** \brief Default constructor of the local storage. */
LocalStorage();
/** \brief Default deconstructor of the local storage. */
~LocalStorage()
{
}
};
protected:
OdfVtkMapper2D();
virtual ~OdfVtkMapper2D();
static void GlyphMethod(void *arg);
bool IsPlaneRotated(mitk::BaseRenderer* renderer);
private:
mitk::Image* GetInput();
static vtkSmartPointer<vtkTransform> m_OdfTransform;
static vtkSmartPointer<vtkOdfSource> m_OdfSource;
static float m_Scaling;
static int m_Normalization;
static int m_ScaleBy;
static float m_IndexParam1;
static float m_IndexParam2;
int m_ShowMaxNumber;
std::vector< vtkSmartPointer<vtkPlane> > m_Planes;
std::vector< vtkSmartPointer<vtkCutter> > m_Cutters;
std::vector< vtkSmartPointer<vtkThickPlane> > m_ThickPlanes1;
std::vector< vtkSmartPointer<vtkClipPolyData> > m_Clippers1;
std::vector< vtkSmartPointer<vtkThickPlane> > m_ThickPlanes2;
std::vector< vtkSmartPointer<vtkClipPolyData> > m_Clippers2;
vtkImageData* m_VtkImage ;
OdfDisplayGeometry m_LastDisplayGeometry;
- mitk::Mapper::LocalStorageHandler<LocalStorage> m_LSH;
+ mitk::LocalStorageHandler<LocalStorage> m_LSH;
};
} // namespace mitk
#include "mitkOdfVtkMapper2D.txx"
#endif /* ODFVTKMAPPER2D_H_HEADER_INCLUDED */
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkVectorImageVtkGlyphMapper3D.cpp b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
index 1e45c857ac..1391c0aabf 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
@@ -1,207 +1,219 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkVectorImageVtkGlyphMapper3D.h"
#include <vtkMaskedGlyph3D.h>
#include <vtkActor.h>
#include <vtkPolyDataMapper.h>
#include <vtkArrowSource.h>
#include <vtkLineSource.h>
#include <vtkImageData.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <vtkLookupTable.h>
#include <mitkLookupTable.h>
#include <mitkLookupTableProperty.h>
/*
* Constructor. Doesn't do anything...
*/
mitk::VectorImageVtkGlyphMapper3D::VectorImageVtkGlyphMapper3D()
{
m_RandomMode = true;
m_UseMaskPoints = true;
m_MaximumNumberOfPoints = 5000;
m_GlyphType = ArrowGlyph;
m_Glyph3DGenerator = vtkMaskedGlyph3D::New();
m_Glyph3DMapper = vtkPolyDataMapper::New();
m_Glyph3DActor = vtkActor::New();
}
vtkProp* mitk::VectorImageVtkGlyphMapper3D::GetVtkProp(mitk::BaseRenderer* /*renderer*/)
{
return m_Glyph3DActor;
}
/*
* Destructor
*/
mitk::VectorImageVtkGlyphMapper3D::~VectorImageVtkGlyphMapper3D()
{
if ( m_Glyph3DMapper != NULL )
m_Glyph3DMapper->Delete();
if ( m_Glyph3DGenerator != NULL )
m_Glyph3DGenerator->Delete();
}
/*
* Generate a vtkPolyData by creating vectors as glyphs
* This method is called, each time a specific renderer is updated.
*/
void mitk::VectorImageVtkGlyphMapper3D::GenerateDataForRenderer( mitk::BaseRenderer* renderer )
{
+
+ bool visible = true;
+ GetDataNode()->GetVisibility(visible, renderer, "visible");
+
+ if ( !visible )
+ {
+ if ( m_Glyph3DActor != NULL )
+ m_Glyph3DActor->VisibilityOff();
+ return ;
+ }
+ else
+ {
+ if ( m_Glyph3DActor != NULL )
+ m_Glyph3DActor->VisibilityOn();
+ }
+
+ BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+ bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
+
+ if(!needGenerateData)
+ {
+ return;
+ }
+
+ ls->UpdateGenerateDataTime();
+
//
// get the input image...
//
mitk::Image::Pointer mitkImage = this->GetInput();
if ( mitkImage.GetPointer() == NULL )
{
itkWarningMacro( << "VectorImage is null !" );
- return ;
+ return;
}
//
// make sure, that the input image is an vector image
//
if ( mitkImage->GetPixelType().GetNumberOfComponents() <= 1 )
{
itkWarningMacro( << "VectorImage has only one scalar component!" );
return ;
}
vtkImageData* vtkImage = mitkImage->GetVtkImageData();
//
// make sure, that we have point data with more than 1 component (as vectors)
//
vtkPointData* pointData = vtkImage->GetPointData();
if ( pointData == NULL )
{
itkWarningMacro( << "vtkImage->GetPointData() returns NULL!" );
return ;
}
if ( pointData->GetNumberOfArrays() == 0 )
{
itkWarningMacro( << "vtkImage->GetPointData()->GetNumberOfArrays() is 0!" );
return ;
}
else if ( pointData->GetArrayName( 0 ) == NULL )
{
vtkImage->GetPointData() ->GetArray( 0 ) ->SetName( "vector" );
}
if ( vtkImage->GetNumberOfPoints() != 0 )
{
//
// create the glyph, which has to be shown at each point
// of the masked image
//
vtkPolyData* glyph;
if ( m_GlyphType == LineGlyph )
{
vtkLineSource * lineSource = vtkLineSource::New();
lineSource->Update();
glyph = lineSource->GetOutput();
}
else if ( m_GlyphType == ArrowGlyph )
{
vtkArrowSource * arrowSource = vtkArrowSource::New();
arrowSource->Update();
glyph = arrowSource->GetOutput();
}
else
{
// Use a vtkLineSource as default, if the GlyphType is
// unknown
itkWarningMacro( << "unknown glyph type!" );
vtkLineSource * lineSource = vtkLineSource::New();
lineSource->Update();
glyph = lineSource->GetOutput();
}
m_RandomMode = false;
m_UseMaskPoints = false;
m_MaximumNumberOfPoints = 80*80*80;
//
// set up the actual glyphing filter
//
m_Glyph3DGenerator->SetSource( glyph );
m_Glyph3DGenerator->SetInput( vtkImage );
//m_Glyph3DGenerator->SetInputConnection(m_Cutter->GetOutputPort());
m_Glyph3DGenerator->SetInputArrayToProcess (1, 0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector");
//m_Glyph3DGenerator->SelectInputVectors( vtkImage->GetPointData() ->GetArray( 0 ) ->GetName() );
m_Glyph3DGenerator->OrientOn();
m_Glyph3DGenerator->SetVectorModeToUseVector();
m_Glyph3DGenerator->SetScaleFactor( 0.00392156862745 );
m_Glyph3DGenerator->SetScaleModeToScaleByVector();
m_Glyph3DGenerator->SetUseMaskPoints( m_UseMaskPoints );
m_Glyph3DGenerator->SetRandomMode( m_RandomMode );
m_Glyph3DGenerator->SetMaximumNumberOfPoints( m_MaximumNumberOfPoints );
m_Glyph3DGenerator->Update();
m_Glyph3DMapper->SetInput( m_Glyph3DGenerator->GetOutput() );
m_Glyph3DActor->SetMapper( m_Glyph3DMapper );
if (GetDataNode()->GetProperty("LookupTable"))
{
mitk::LookupTable::Pointer mitkLookupTable = mitk::LookupTable::New();
m_Glyph3DMapper->Update();
mitkLookupTable->SetVtkLookupTable(dynamic_cast<vtkLookupTable*>(m_Glyph3DMapper->GetLookupTable()));
mitk::LookupTableProperty::Pointer LookupTableProp = mitk::LookupTableProperty::New( mitkLookupTable );
GetDataNode()->SetProperty( "LookupTable", LookupTableProp );
}
else
{
mitk::LookupTableProperty::Pointer mitkLutProp = dynamic_cast<mitk::LookupTableProperty*>(GetDataNode()->GetProperty("LookupTable"));
if (mitkLutProp.IsNotNull())
m_Glyph3DMapper->SetLookupTable( mitkLutProp->GetLookupTable()->GetVtkLookupTable() );
}
//vtkDataSetWriter* writer = vtkDataSetWriter::New();
//writer->SetInput( vtkImage );
//writer->SetFileName( "out.vtk" );
//writer->Update();
}
- bool visible = true;
- GetDataNode()->GetVisibility(visible, renderer, "visible");
-
- if ( !visible )
- {
- if ( m_Glyph3DActor != NULL )
- m_Glyph3DActor->VisibilityOff();
- return ;
- }
- else
- {
- if ( m_Glyph3DActor != NULL )
- m_Glyph3DActor->VisibilityOn();
- }
}
/*
* Returns the input data object of the given filter. In this
* case, a mitk::Image is returned.
*/
mitk::Image* mitk::VectorImageVtkGlyphMapper3D::GetInput()
{
return const_cast<mitk::Image*>( dynamic_cast<mitk::Image*>( GetDataNode()->GetData() ) );
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkVectorImageVtkGlyphMapper3D.h b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkVectorImageVtkGlyphMapper3D.h
index 3c96509165..4d611ca743 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkVectorImageVtkGlyphMapper3D.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkVectorImageVtkGlyphMapper3D.h
@@ -1,96 +1,98 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_VECTOR_IMAGE_VTK_MAPPER_3D__H
#define _MITK_VECTOR_IMAGE_VTK_MAPPER_3D__H
#include "DiffusionCoreExports.h"
#include "mitkVtkMapper.h"
#include "mitkImage.h"
class vtkMaskedGlyph3D;
class vtkActor;
class vtkPolyDataMapper;
class vtkMaskPoints;
namespace mitk
{
class DiffusionCore_EXPORT VectorImageVtkGlyphMapper3D : public VtkMapper
{
public:
mitkClassMacro( VectorImageVtkGlyphMapper3D, VtkMapper );
itkNewMacro( Self );
enum GlyphType {LineGlyph, ArrowGlyph};
itkSetMacro(MaximumNumberOfPoints, unsigned int);
itkGetMacro(MaximumNumberOfPoints, unsigned int);
itkSetMacro(UseMaskPoints, bool);
itkGetMacro(UseMaskPoints, bool);
itkBooleanMacro(UseMaskPoints);
itkSetMacro(RandomMode, bool);
itkGetMacro(RandomMode, bool);
itkBooleanMacro(RandomMode);
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
+ LocalStorageHandler<BaseLocalStorage> m_LSH;
+
protected:
/**
* Constructor. Doesn't do anything...
*/
VectorImageVtkGlyphMapper3D();
/**
* Destructor
*/
virtual ~VectorImageVtkGlyphMapper3D();
/**
* Generate a vtkPolyData by creating vectors as glyphs
* This method is called, each time a specific renderer is updated.
*/
virtual void GenerateDataForRenderer( mitk::BaseRenderer* renderer );
/**
* Returns the input data object of the given filter. In this
* case, a mitk::Image is returned.
*/
Image* GetInput();
vtkMaskedGlyph3D* m_Glyph3DGenerator;
vtkActor* m_Glyph3DActor;
vtkPolyDataMapper* m_Glyph3DMapper;
GlyphType m_GlyphType;
unsigned int m_MaximumNumberOfPoints;
bool m_UseMaskPoints;
bool m_RandomMode;
};
} //end of namespace mitk
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/files.cmake b/Modules/DiffusionImaging/DiffusionCore/files.cmake
index 5c047608b9..0965a55ebc 100644
--- a/Modules/DiffusionImaging/DiffusionCore/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionCore/files.cmake
@@ -1,116 +1,120 @@
set(CPP_FILES
# DicomImport
DicomImport/mitkDicomDiffusionImageReader.cpp
- DicomImport/mitkGroupDiffusionHeadersFilter.cpp
+ # DicomImport/mitkGroupDiffusionHeadersFilter.cpp
DicomImport/mitkDicomDiffusionImageHeaderReader.cpp
DicomImport/mitkGEDicomDiffusionImageHeaderReader.cpp
DicomImport/mitkPhilipsDicomDiffusionImageHeaderReader.cpp
DicomImport/mitkSiemensDicomDiffusionImageHeaderReader.cpp
DicomImport/mitkSiemensMosaicDicomDiffusionImageHeaderReader.cpp
# DataStructures
IODataStructures/mitkDiffusionCoreObjectFactory.cpp
# DataStructures -> DWI
IODataStructures/DiffusionWeightedImages/mitkDiffusionImageHeaderInformation.cpp
IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageReader.cpp
IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageWriter.cpp
IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageIOFactory.cpp
IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageWriterFactory.cpp
IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSerializer.cpp
# DataStructures -> QBall
IODataStructures/QBallImages/mitkQBallImageSource.cpp
IODataStructures/QBallImages/mitkNrrdQBallImageReader.cpp
IODataStructures/QBallImages/mitkNrrdQBallImageWriter.cpp
IODataStructures/QBallImages/mitkNrrdQBallImageIOFactory.cpp
IODataStructures/QBallImages/mitkNrrdQBallImageWriterFactory.cpp
IODataStructures/QBallImages/mitkQBallImage.cpp
IODataStructures/QBallImages/mitkQBallImageSerializer.cpp
# DataStructures -> Tensor
IODataStructures/TensorImages/mitkTensorImageSource.cpp
IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
IODataStructures/TensorImages/mitkNrrdTensorImageWriter.cpp
IODataStructures/TensorImages/mitkNrrdTensorImageIOFactory.cpp
IODataStructures/TensorImages/mitkNrrdTensorImageWriterFactory.cpp
IODataStructures/TensorImages/mitkTensorImage.cpp
IODataStructures/TensorImages/mitkTensorImageSerializer.cpp
# Rendering
Rendering/vtkMaskedProgrammableGlyphFilter.cpp
Rendering/mitkCompositeMapper.cpp
Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
Rendering/vtkOdfSource.cxx
Rendering/vtkThickPlane.cxx
Rendering/mitkOdfNormalizationMethodProperty.cpp
Rendering/mitkOdfScaleByProperty.cpp
Rendering/mitkPlanarFigureMapper3D.cpp
# Algorithms
Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
+ Algorithms/itkDwiGradientLengthCorrectionFilter.cpp
# Function Collection
mitkDiffusionFunctionCollection.cpp
)
set(H_FILES
# function Collection
mitkDiffusionFunctionCollection.h
# Rendering
Rendering/mitkDiffusionImageMapper.h
Rendering/mitkOdfVtkMapper2D.h
Rendering/mitkPlanarFigureMapper3D.h
# Reconstruction
Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.h
Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
Algorithms/Reconstruction/itkPointShell.h
Algorithms/Reconstruction/itkOrientationDistributionFunction.h
Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h
+ Algorithms/Reconstruction/itkMultiShellAdcAverageReconstructionImageFilter.h
# IO Datastructures
IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
# Algorithms
Algorithms/itkDiffusionQballGeneralizedFaImageFilter.h
Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.h
Algorithms/itkTensorDerivedMeasurementsFilter.h
Algorithms/itkBrainMaskExtractionImageFilter.h
Algorithms/itkB0ImageExtractionImageFilter.h
Algorithms/itkB0ImageExtractionToSeparateImageFilter.h
Algorithms/itkTensorImageToDiffusionImageFilter.h
Algorithms/itkTensorToL2NormImageFilter.h
Algorithms/itkGaussianInterpolateImageFunction.h
Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.h
Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
Algorithms/itkCartesianToPolarVectorImageFilter.h
Algorithms/itkPolarToCartesianVectorImageFilter.h
Algorithms/itkDistanceMapFilter.h
Algorithms/itkProjectionFilter.h
Algorithms/itkResidualImageFilter.h
Algorithms/itkExtractChannelFromRgbaImageFilter.h
Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.h
Algorithms/itkMergeDiffusionImagesFilter.h
Algorithms/itkDwiPhantomGenerationFilter.h
Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
Algorithms/itkMrtrixPeakImageConverter.h
Algorithms/itkFslPeakImageConverter.h
Algorithms/itkShCoefficientImageImporter.h
Algorithms/itkOdfMaximaExtractionFilter.h
Algorithms/itkResampleDwiImageFilter.h
+ Algorithms/itkDwiGradientLengthCorrectionFilter.h
+ Algorithms/itkAdcImageFilter.h
)
set( TOOL_FILES
)
diff --git a/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.cpp b/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.cpp
index 9e9ba9054f..2e0f65c932 100644
--- a/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.cpp
@@ -1,93 +1,250 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkDiffusionFunctionCollection.h"
#include <math.h>
#include "mitkVector.h"
// for Windows
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
// Namespace ::SH
#include <boost/math/special_functions/legendre.hpp>
#include <boost/math/special_functions/spherical_harmonic.hpp>
#include <boost/version.hpp>
-// Namespace ::vnl_function
+
+// Namespace ::Gradients
+#include "itkVectorContainer.h"
#include "vnl/vnl_vector.h"
//------------------------- SH-function ------------------------------------
double mitk::sh::factorial(int number) {
- if(number <= 1) return 1;
- double result = 1.0;
- for(int i=1; i<=number; i++)
- result *= i;
- return result;
+ if(number <= 1) return 1;
+ double result = 1.0;
+ for(int i=1; i<=number; i++)
+ result *= i;
+ return result;
}
void mitk::sh::Cart2Sph(double x, double y, double z, double *cart)
{
- double phi, th, rad;
- rad = sqrt(x*x+y*y+z*z);
- if( rad < mitk::eps )
- {
- th = M_PI/2;
- phi = M_PI/2;
- }
- else
- {
- th = acos(z/rad);
- phi = atan2(y, x);
- }
- cart[0] = phi;
- cart[1] = th;
- cart[2] = rad;
+ double phi, th, rad;
+ rad = sqrt(x*x+y*y+z*z);
+ if( rad < mitk::eps )
+ {
+ th = M_PI/2;
+ phi = M_PI/2;
+ }
+ else
+ {
+ th = acos(z/rad);
+ phi = atan2(y, x);
+ }
+ cart[0] = phi;
+ cart[1] = th;
+ cart[2] = rad;
}
double mitk::sh::legendre0(int l)
{
- if( l%2 != 0 )
- {
- return 0;
- }
- else
- {
- double prod1 = 1.0;
- for(int i=1;i<l;i+=2) prod1 *= i;
- double prod2 = 1.0;
- for(int i=2;i<=l;i+=2) prod2 *= i;
- return pow(-1.0,l/2.0)*(prod1/prod2);
- }
+ if( l%2 != 0 )
+ {
+ return 0;
+ }
+ else
+ {
+ double prod1 = 1.0;
+ for(int i=1;i<l;i+=2) prod1 *= i;
+ double prod2 = 1.0;
+ for(int i=2;i<=l;i+=2) prod2 *= i;
+ return pow(-1.0,l/2.0)*(prod1/prod2);
+ }
}
double mitk::sh::Yj(int m, int l, double theta, double phi)
{
if (m<0)
- return sqrt(2.0)*::boost::math::spherical_harmonic_r(l, -m, theta, phi);
+ return sqrt(2.0)*::boost::math::spherical_harmonic_r(l, -m, theta, phi);
else if (m==0)
- return ::boost::math::spherical_harmonic_r(l, m, theta, phi);
+ return ::boost::math::spherical_harmonic_r(l, m, theta, phi);
else
- return pow(-1.0,m)*sqrt(2.0)*::boost::math::spherical_harmonic_i(l, m, theta, phi);
+ return pow(-1.0,m)*sqrt(2.0)*::boost::math::spherical_harmonic_i(l, m, theta, phi);
return 0;
}
+//------------------------- gradients-function ------------------------------------
+
+std::vector<unsigned int> mitk::gradients::GetAllUniqueDirections(const std::map<double , std::vector<unsigned int> > & refBValueMap, const GradientDirectionContainerType * refGradientsContainer )
+{
+
+ IndiciesVector directioncontainer;
+ BValueMap::const_iterator mapIterator = refBValueMap.begin();
+
+ if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)
+ mapIterator++; //skip bzero Values
+
+ for( ; mapIterator != refBValueMap.end(); mapIterator++){
+
+ IndiciesVector currentShell = mapIterator->second;
+
+ while(currentShell.size()>0)
+ {
+ unsigned int wntIndex = currentShell.back();
+ currentShell.pop_back();
+
+ IndiciesVector::iterator containerIt = directioncontainer.begin();
+ bool directionExist = false;
+ while(containerIt != directioncontainer.end())
+ {
+ if (fabs(dot(refGradientsContainer->ElementAt(*containerIt), refGradientsContainer->ElementAt(wntIndex))) > 0.9998)
+ {
+ directionExist = true;
+ break;
+ }
+ containerIt++;
+ }
+ if(!directionExist)
+ {
+ directioncontainer.push_back(wntIndex);
+ }
+ }
+ }
+
+ return directioncontainer;
+}
+
+
+bool mitk::gradients::CheckForDifferingShellDirections(const std::map<double , std::vector<unsigned int> > & refBValueMap, const GradientDirectionContainerType * refGradientsContainer)
+{
+ BValueMap::const_iterator mapIterator = refBValueMap.begin();
+
+ if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)
+ mapIterator++; //skip bzero Values
+
+ for( ; mapIterator != refBValueMap.end(); mapIterator++){
+
+ BValueMap::const_iterator mapIterator_2 = refBValueMap.begin();
+ if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)
+ mapIterator_2++; //skip bzero Values
+
+ for( ; mapIterator_2 != refBValueMap.end(); mapIterator_2++){
+
+ if(mapIterator_2 == mapIterator) continue;
+
+ IndiciesVector currentShell = mapIterator->second;
+ IndiciesVector testShell = mapIterator_2->second;
+ for (unsigned int i = 0; i< currentShell.size(); i++)
+ if (fabs(dot(refGradientsContainer->ElementAt(currentShell[i]), refGradientsContainer->ElementAt(testShell[i]))) <= 0.9998) { return true; }
+
+ }
+ }
+ return false;
+}
+
+
+template<typename type>
+double mitk::gradients::dot (vnl_vector_fixed< type ,3> const& v1, vnl_vector_fixed< type ,3 > const& v2 )
+{
+ double result = (v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) / (v1.two_norm() * v2.two_norm());
+ return result ;
+}
+
+vnl_matrix<double> mitk::gradients::ComputeSphericalFromCartesian(const IndiciesVector & refShell, const GradientDirectionContainerType * refGradientsContainer)
+{
+
+ vnl_matrix<double> Q(3, refShell.size());
+
+ for(unsigned int i = 0; i < refShell.size(); i++)
+ {
+ GradientDirectionType dir = refGradientsContainer->ElementAt(refShell[i]);
+ double x = dir.normalize().get(0);
+ double y = dir.normalize().get(1);
+ double z = dir.normalize().get(2);
+ double cart[3];
+ mitk::sh::Cart2Sph(x,y,z,cart);
+ Q(0,i) = cart[0];
+ Q(1,i) = cart[1];
+ Q(2,i) = cart[2];
+ }
+ return Q;
+}
+
+vnl_matrix<double> mitk::gradients::ComputeSphericalHarmonicsBasis(const vnl_matrix<double> & QBallReference, const unsigned int & LOrder)
+{
+ vnl_matrix<double> SHBasisOutput(QBallReference.cols(), (LOrder+1)*(LOrder+2)*0.5);
+ for(unsigned int i=0; i< SHBasisOutput.rows(); i++)
+ for(int k = 0; k <= LOrder; k += 2)
+ for(int m =- k; m <= k; m++)
+ {
+ int j = ( k * k + k + 2 ) / 2 + m - 1;
+ double phi = QBallReference(0,i);
+ double th = QBallReference(1,i);
+ SHBasisOutput(i,j) = mitk::sh::Yj(m,k,th,phi);
+ }
+ return SHBasisOutput;
+}
+
+mitk::gradients::GradientDirectionContainerType::Pointer mitk::gradients::CreateNormalizedUniqueGradientDirectionContainer(const mitk::gradients::BValueMap & bValueMap,
+ const GradientDirectionContainerType *origninalGradentcontainer)
+{
+ mitk::gradients::GradientDirectionContainerType::Pointer directioncontainer = mitk::gradients::GradientDirectionContainerType::New();
+ BValueMap::const_iterator mapIterator = bValueMap.begin();
+
+ if(bValueMap.find(0) != bValueMap.end() && bValueMap.size() > 1){
+ mapIterator++; //skip bzero Values
+ vnl_vector_fixed<double, 3> vec;
+ vec.fill(0.0);
+ directioncontainer->push_back(vec);
+ }
+
+ for( ; mapIterator != bValueMap.end(); mapIterator++){
+
+ IndiciesVector currentShell = mapIterator->second;
+
+ while(currentShell.size()>0)
+ {
+ unsigned int wntIndex = currentShell.back();
+ currentShell.pop_back();
+
+ mitk::gradients::GradientDirectionContainerType::Iterator containerIt = directioncontainer->Begin();
+ bool directionExist = false;
+ while(containerIt != directioncontainer->End())
+ {
+ if (fabs(dot(containerIt.Value(), origninalGradentcontainer->ElementAt(wntIndex))) > 0.9998)
+ {
+ directionExist = true;
+ break;
+ }
+ containerIt++;
+ }
+ if(!directionExist)
+ {
+ GradientDirectionType dir(origninalGradentcontainer->ElementAt(wntIndex));
+ directioncontainer->push_back(dir.normalize());
+ }
+ }
+ }
+
+ return directioncontainer;
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.h b/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.h
index 8267c5cc9b..dcfedfd980 100644
--- a/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.h
+++ b/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.h
@@ -1,39 +1,62 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkDiffusionFunctionCollection_h_
#define __mitkDiffusionFunctionCollection_h_
#include "DiffusionCoreExports.h"
-
+#include "vnl/vnl_vector.h"
+#include "vnl/vnl_vector_fixed.h"
+#include "itkVectorContainer.h"
namespace mitk{
class DiffusionCore_EXPORT sh
{
public:
-static double factorial(int number);
-static void Cart2Sph(double x, double y, double z, double* cart);
-static double legendre0(int l);
-static double spherical_harmonic(int m,int l,double theta,double phi, bool complexPart);
-static double Yj(int m, int k, double theta, double phi);
+ static double factorial(int number);
+ static void Cart2Sph(double x, double y, double z, double* cart);
+ static double legendre0(int l);
+ static double spherical_harmonic(int m,int l,double theta,double phi, bool complexPart);
+ static double Yj(int m, int k, double theta, double phi);
+};
+
+class DiffusionCore_EXPORT gradients
+{
+private:
+ typedef std::vector<unsigned int> IndiciesVector;
+ typedef std::map<double, IndiciesVector > BValueMap;
+ typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
+ typedef itk::VectorContainer< unsigned int, GradientDirectionType > GradientDirectionContainerType;
+
+public:
+ static std::vector<unsigned int> GetAllUniqueDirections(const std::map<double , std::vector<unsigned int> > & refBValueMap, const GradientDirectionContainerType *refGradientsContainer );
+ static bool CheckForDifferingShellDirections(const std::map<double , std::vector<unsigned int> > & refBValueMap, const GradientDirectionContainerType * refGradientsContainer);
+ static vnl_matrix<double> ComputeSphericalHarmonicsBasis(const vnl_matrix<double> & QBallReference, const unsigned int & LOrder);
+ static vnl_matrix<double> ComputeSphericalFromCartesian(const IndiciesVector & refShell, const GradientDirectionContainerType * refGradientsContainer);
+ static mitk::gradients::GradientDirectionContainerType::Pointer CreateNormalizedUniqueGradientDirectionContainer(const BValueMap &bValueMap, const GradientDirectionContainerType * origninalGradentcontainer);
+
+
+ template<typename type>
+ static double dot (vnl_vector_fixed< type ,3> const& v1, vnl_vector_fixed< type ,3 > const& v2 );
};
+
}
#endif //__mitkDiffusionFunctionCollection_h_
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/GibbsTracking/mitkParticleGrid.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/GibbsTracking/mitkParticleGrid.cpp
index 4f2333d592..49a67a5f82 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/GibbsTracking/mitkParticleGrid.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/GibbsTracking/mitkParticleGrid.cpp
@@ -1,418 +1,417 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkParticleGrid.h"
#include <stdlib.h>
#include <stdio.h>
using namespace mitk;
ParticleGrid::ParticleGrid(ItkFloatImageType* image, float particleLength, int cellCapacity)
{
// initialize counters
m_NumParticles = 0;
m_NumConnections = 0;
m_NumCellOverflows = 0;
m_ParticleLength = particleLength;
// define isotropic grid from voxel spacing and particle length
float cellSize = 2*m_ParticleLength;
m_GridSize[0] = image->GetLargestPossibleRegion().GetSize()[0]*image->GetSpacing()[0]/cellSize +1;
m_GridSize[1] = image->GetLargestPossibleRegion().GetSize()[1]*image->GetSpacing()[1]/cellSize +1;
m_GridSize[2] = image->GetLargestPossibleRegion().GetSize()[2]*image->GetSpacing()[2]/cellSize +1;
m_GridScale[0] = 1/cellSize;
m_GridScale[1] = 1/cellSize;
m_GridScale[2] = 1/cellSize;
m_CellCapacity = cellCapacity; // maximum number of particles per grid cell
m_ContainerCapacity = 100000; // initial particle container capacity
unsigned long numCells = m_GridSize[0]*m_GridSize[1]*m_GridSize[2]; // number of grid cells
unsigned long gridSize = numCells*m_CellCapacity;
if ( itk::NumericTraits<int>::max()<gridSize )
throw std::bad_alloc();
m_Particles.resize(m_ContainerCapacity); // allocate and initialize particles
m_Grid.resize(gridSize, NULL); // allocate and initialize particle grid
m_OccupationCount.resize(numCells, 0); // allocate and initialize occupation counter array
m_NeighbourTracker.cellidx.resize(8, 0); // allocate and initialize neighbour tracker
m_NeighbourTracker.cellidx_c.resize(8, 0);
for (int i = 0;i < m_ContainerCapacity;i++) // initialize particle IDs
m_Particles[i].ID = i;
std::cout << "ParticleGrid: allocated " << (sizeof(Particle)*m_ContainerCapacity + sizeof(Particle*)*m_GridSize[0]*m_GridSize[1]*m_GridSize[2])/1048576 << "mb for " << m_ContainerCapacity/1000 << "k particles." << std::endl;
}
ParticleGrid::~ParticleGrid()
{
}
// remove all particles
void ParticleGrid::ResetGrid()
{
// initialize counters
m_NumParticles = 0;
m_NumConnections = 0;
m_NumCellOverflows = 0;
m_Particles.clear();
m_Grid.clear();
m_OccupationCount.clear();
m_NeighbourTracker.cellidx.clear();
m_NeighbourTracker.cellidx_c.clear();
int numCells = m_GridSize[0]*m_GridSize[1]*m_GridSize[2]; // number of grid cells
m_Particles.resize(m_ContainerCapacity); // allocate and initialize particles
m_Grid.resize(numCells*m_CellCapacity, NULL); // allocate and initialize particle grid
m_OccupationCount.resize(numCells, 0); // allocate and initialize occupation counter array
m_NeighbourTracker.cellidx.resize(8, 0); // allocate and initialize neighbour tracker
m_NeighbourTracker.cellidx_c.resize(8, 0);
for (int i = 0;i < m_ContainerCapacity;i++) // initialize particle IDs
m_Particles[i].ID = i;
}
bool ParticleGrid::ReallocateGrid()
{
- std::cout << "ParticleGrid: reallocating ..." << std::endl;
int new_capacity = m_ContainerCapacity + 100000; // increase container capacity by 100k particles
try
{
m_Particles.resize(new_capacity); // reallocate particles
for (int i = 0; i<m_ContainerCapacity; i++) // update particle addresses (changed during reallocation)
m_Grid[m_Particles[i].gridindex] = &m_Particles[i];
for (int i = m_ContainerCapacity; i < new_capacity; i++) // initialize IDs of ne particles
m_Particles[i].ID = i;
m_ContainerCapacity = new_capacity; // update member variable
- std::cout << "ParticleGrid: allocated " << (sizeof(Particle)*m_ContainerCapacity + sizeof(Particle*)*m_GridSize[0]*m_GridSize[1]*m_GridSize[2])/1048576 << "mb for " << m_ContainerCapacity/1000 << "k particles." << std::endl;
+ //std::cout << "ParticleGrid: allocated " << (sizeof(Particle)*m_ContainerCapacity + sizeof(Particle*)*m_GridSize[0]*m_GridSize[1]*m_GridSize[2])/1048576 << "mb for " << m_ContainerCapacity/1000 << "k particles." << std::endl;
}
catch(...)
{
std::cout << "ParticleGrid: allocation of " << (sizeof(Particle)*new_capacity + sizeof(Particle*)*m_GridSize[0]*m_GridSize[1]*m_GridSize[2])/1048576 << "mb for " << new_capacity/1000 << "k particles failed!" << std::endl;
return false;
}
return true;
}
Particle* ParticleGrid::GetParticle(int ID)
{
if (ID!=-1)
return &m_Particles[ID];
return NULL;
}
Particle* ParticleGrid::NewParticle(vnl_vector_fixed<float, 3> R)
{
if (m_NumParticles >= m_ContainerCapacity)
{
if (!ReallocateGrid())
return NULL;
}
int xint = int(R[0]*m_GridScale[0]);
if (xint < 0)
return NULL;
if (xint >= m_GridSize[0])
return NULL;
int yint = int(R[1]*m_GridScale[1]);
if (yint < 0)
return NULL;
if (yint >= m_GridSize[1])
return NULL;
int zint = int(R[2]*m_GridScale[2]);
if (zint < 0)
return NULL;
if (zint >= m_GridSize[2])
return NULL;
int idx = xint + m_GridSize[0]*(yint + m_GridSize[1]*zint);
if (m_OccupationCount[idx] < m_CellCapacity)
{
Particle *p = &(m_Particles[m_NumParticles]);
p->pos = R;
p->mID = -1;
p->pID = -1;
m_NumParticles++;
p->gridindex = m_CellCapacity*idx + m_OccupationCount[idx];
m_Grid[p->gridindex] = p;
m_OccupationCount[idx]++;
return p;
}
else
{
m_NumCellOverflows++;
return NULL;
}
}
bool ParticleGrid::TryUpdateGrid(int k)
{
Particle* p = &(m_Particles[k]);
int xint = int(p->pos[0]*m_GridScale[0]);
if (xint < 0)
return false;
if (xint >= m_GridSize[0])
return false;
int yint = int(p->pos[1]*m_GridScale[1]);
if (yint < 0)
return false;
if (yint >= m_GridSize[1])
return false;
int zint = int(p->pos[2]*m_GridScale[2]);
if (zint < 0)
return false;
if (zint >= m_GridSize[2])
return false;
int idx = xint + m_GridSize[0]*(yint+ zint*m_GridSize[1]);
int cellidx = p->gridindex/m_CellCapacity;
if (idx != cellidx) // cell has changed
{
if (m_OccupationCount[idx] < m_CellCapacity)
{
// remove from old position in grid;
int grdindex = p->gridindex;
m_Grid[grdindex] = m_Grid[cellidx*m_CellCapacity + m_OccupationCount[cellidx]-1];
m_Grid[grdindex]->gridindex = grdindex;
m_OccupationCount[cellidx]--;
// insert at new position in grid
p->gridindex = idx*m_CellCapacity + m_OccupationCount[idx];
m_Grid[p->gridindex] = p;
m_OccupationCount[idx]++;
return true;
}
else
{
m_NumCellOverflows++;
return false;
}
}
return true;
}
void ParticleGrid::RemoveParticle(int k)
{
Particle* p = &(m_Particles[k]);
int gridIndex = p->gridindex;
int cellIdx = gridIndex/m_CellCapacity;
int idx = gridIndex%m_CellCapacity;
// remove pending connections
if (p->mID != -1)
DestroyConnection(p,-1);
if (p->pID != -1)
DestroyConnection(p,+1);
// remove from grid
if (idx < m_OccupationCount[cellIdx]-1)
{
m_Grid[gridIndex] = m_Grid[cellIdx*m_CellCapacity+m_OccupationCount[cellIdx]-1];
m_Grid[cellIdx*m_CellCapacity+m_OccupationCount[cellIdx]-1] = NULL;
m_Grid[gridIndex]->gridindex = gridIndex;
}
m_OccupationCount[cellIdx]--;
// remove from container
if (k < m_NumParticles-1)
{
Particle* last = &m_Particles[m_NumParticles-1]; // last particle
// update connections of last particle because its index is changing
if (last->mID!=-1)
{
if ( m_Particles[last->mID].mID == m_NumParticles-1 )
m_Particles[last->mID].mID = k;
else if ( m_Particles[last->mID].pID == m_NumParticles-1 )
m_Particles[last->mID].pID = k;
}
if (last->pID!=-1)
{
if ( m_Particles[last->pID].mID == m_NumParticles-1 )
m_Particles[last->pID].mID = k;
else if ( m_Particles[last->pID].pID == m_NumParticles-1 )
m_Particles[last->pID].pID = k;
}
m_Particles[k] = m_Particles[m_NumParticles-1]; // move very last particle to empty slot
m_Particles[m_NumParticles-1].ID = m_NumParticles-1; // update ID of removed particle to match the index
m_Particles[k].ID = k; // update ID of moved particle
m_Grid[m_Particles[k].gridindex] = &m_Particles[k]; // update address of moved particle
}
m_NumParticles--;
}
void ParticleGrid::ComputeNeighbors(vnl_vector_fixed<float, 3> &R)
{
float xfrac = R[0]*m_GridScale[0];
float yfrac = R[1]*m_GridScale[1];
float zfrac = R[2]*m_GridScale[2];
int xint = int(xfrac);
int yint = int(yfrac);
int zint = int(zfrac);
int dx = -1;
if (xfrac-xint > 0.5) dx = 1;
if (xint <= 0) { xint = 0; dx = 1; }
if (xint >= m_GridSize[0]-1) { xint = m_GridSize[0]-1; dx = -1; }
int dy = -1;
if (yfrac-yint > 0.5) dy = 1;
if (yint <= 0) {yint = 0; dy = 1; }
if (yint >= m_GridSize[1]-1) {yint = m_GridSize[1]-1; dy = -1;}
int dz = -1;
if (zfrac-zint > 0.5) dz = 1;
if (zint <= 0) {zint = 0; dz = 1; }
if (zint >= m_GridSize[2]-1) {zint = m_GridSize[2]-1; dz = -1;}
m_NeighbourTracker.cellidx[0] = xint + m_GridSize[0]*(yint+zint*m_GridSize[1]);
m_NeighbourTracker.cellidx[1] = m_NeighbourTracker.cellidx[0] + dx;
m_NeighbourTracker.cellidx[2] = m_NeighbourTracker.cellidx[1] + dy*m_GridSize[0];
m_NeighbourTracker.cellidx[3] = m_NeighbourTracker.cellidx[2] - dx;
m_NeighbourTracker.cellidx[4] = m_NeighbourTracker.cellidx[0] + dz*m_GridSize[0]*m_GridSize[1];
m_NeighbourTracker.cellidx[5] = m_NeighbourTracker.cellidx[4] + dx;
m_NeighbourTracker.cellidx[6] = m_NeighbourTracker.cellidx[5] + dy*m_GridSize[0];
m_NeighbourTracker.cellidx[7] = m_NeighbourTracker.cellidx[6] - dx;
m_NeighbourTracker.cellidx_c[0] = m_CellCapacity*m_NeighbourTracker.cellidx[0];
m_NeighbourTracker.cellidx_c[1] = m_CellCapacity*m_NeighbourTracker.cellidx[1];
m_NeighbourTracker.cellidx_c[2] = m_CellCapacity*m_NeighbourTracker.cellidx[2];
m_NeighbourTracker.cellidx_c[3] = m_CellCapacity*m_NeighbourTracker.cellidx[3];
m_NeighbourTracker.cellidx_c[4] = m_CellCapacity*m_NeighbourTracker.cellidx[4];
m_NeighbourTracker.cellidx_c[5] = m_CellCapacity*m_NeighbourTracker.cellidx[5];
m_NeighbourTracker.cellidx_c[6] = m_CellCapacity*m_NeighbourTracker.cellidx[6];
m_NeighbourTracker.cellidx_c[7] = m_CellCapacity*m_NeighbourTracker.cellidx[7];
m_NeighbourTracker.cellcnt = 0;
m_NeighbourTracker.pcnt = 0;
}
Particle* ParticleGrid::GetNextNeighbor()
{
if (m_NeighbourTracker.pcnt < m_OccupationCount[m_NeighbourTracker.cellidx[m_NeighbourTracker.cellcnt]])
{
return m_Grid[m_NeighbourTracker.cellidx_c[m_NeighbourTracker.cellcnt] + (m_NeighbourTracker.pcnt++)];
}
else
{
for(;;)
{
m_NeighbourTracker.cellcnt++;
if (m_NeighbourTracker.cellcnt >= 8)
return 0;
if (m_OccupationCount[m_NeighbourTracker.cellidx[m_NeighbourTracker.cellcnt]] > 0)
break;
}
m_NeighbourTracker.pcnt = 1;
return m_Grid[m_NeighbourTracker.cellidx_c[m_NeighbourTracker.cellcnt]];
}
}
void ParticleGrid::CreateConnection(Particle *P1,int ep1, Particle *P2, int ep2)
{
if (ep1 == -1)
P1->mID = P2->ID;
else
P1->pID = P2->ID;
if (ep2 == -1)
P2->mID = P1->ID;
else
P2->pID = P1->ID;
m_NumConnections++;
}
void ParticleGrid::DestroyConnection(Particle *P1,int ep1, Particle *P2, int ep2)
{
if (ep1 == -1)
P1->mID = -1;
else
P1->pID = -1;
if (ep2 == -1)
P2->mID = -1;
else
P2->pID = -1;
m_NumConnections--;
}
void ParticleGrid::DestroyConnection(Particle *P1,int ep1)
{
Particle *P2 = 0;
if (ep1 == 1)
{
P2 = &m_Particles[P1->pID];
P1->pID = -1;
}
else
{
P2 = &m_Particles[P1->mID];
P1->mID = -1;
}
if (P2->mID == P1->ID)
P2->mID = -1;
else
P2->pID = -1;
m_NumConnections--;
}
bool ParticleGrid::CheckConsistency()
{
for (int i=0; i<m_NumParticles; i++)
{
Particle* p = &m_Particles[i];
if (p->ID != i)
{
std::cout << "Particle ID error!" << std::endl;
return false;
}
if (p->mID!=-1)
{
Particle* p2 = &m_Particles[p->mID];
if (p2->mID!=p->ID && p2->pID!=p->ID)
{
std::cout << "Connection inconsistent!" << std::endl;
return false;
}
}
if (p->pID!=-1)
{
Particle* p2 = &m_Particles[p->pID];
if (p2->mID!=p->ID && p2->pID!=p->ID)
{
std::cout << "Connection inconsistent!" << std::endl;
return false;
}
}
}
return true;
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.cpp
new file mode 100644
index 0000000000..8ad4dee7c7
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.cpp
@@ -0,0 +1,266 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __itkAddArtifactsToDwiImageFilter_txx
+#define __itkAddArtifactsToDwiImageFilter_txx
+
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "itkAddArtifactsToDwiImageFilter.h"
+#include <itkImageRegionConstIterator.h>
+#include <itkImageRegionConstIteratorWithIndex.h>
+#include <itkImageRegionIterator.h>
+#include <boost/progress.hpp>
+#include <itkImageDuplicator.h>
+#include <itkResampleDwiImageFilter.h>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+namespace itk {
+
+template< class TPixelType >
+AddArtifactsToDwiImageFilter< TPixelType >
+::AddArtifactsToDwiImageFilter()
+ : m_NoiseModel(NULL)
+ , m_FrequencyMap(NULL)
+ , m_kOffset(0)
+ , m_tLine(1)
+ , m_EddyGradientStrength(0.001)
+ , m_SimulateEddyCurrents(false)
+ , m_TE(100)
+ , m_Upsampling(1)
+{
+ this->SetNumberOfRequiredInputs( 1 );
+}
+
+
+template< class TPixelType >
+AddArtifactsToDwiImageFilter< TPixelType >::ComplexSliceType::Pointer AddArtifactsToDwiImageFilter< TPixelType >::RearrangeSlice(ComplexSliceType::Pointer slice)
+{
+ ImageRegion<2> region = slice->GetLargestPossibleRegion();
+ typename ComplexSliceType::Pointer rearrangedSlice = ComplexSliceType::New();
+ rearrangedSlice->SetLargestPossibleRegion( region );
+ rearrangedSlice->SetBufferedRegion( region );
+ rearrangedSlice->SetRequestedRegion( region );
+ rearrangedSlice->Allocate();
+
+ int xHalf = region.GetSize(0)/2;
+ int yHalf = region.GetSize(1)/2;
+
+ for (int y=0; y<region.GetSize(1); y++)
+ for (int x=0; x<region.GetSize(0); x++)
+ {
+ typename SliceType::IndexType idx;
+ idx[0]=x; idx[1]=y;
+ vcl_complex< SliceType::PixelType > pix = slice->GetPixel(idx);
+
+ if( idx[0] < xHalf )
+ idx[0] = idx[0] + xHalf;
+ else
+ idx[0] = idx[0] - xHalf;
+
+ if( idx[1] < yHalf )
+ idx[1] = idx[1] + yHalf;
+ else
+ idx[1] = idx[1] - yHalf;
+
+ rearrangedSlice->SetPixel(idx, pix);
+ }
+
+ return rearrangedSlice;
+}
+
+template< class TPixelType >
+void AddArtifactsToDwiImageFilter< TPixelType >
+::GenerateData()
+{
+ typename DiffusionImageType::Pointer inputImage = static_cast< DiffusionImageType * >( this->ProcessObject::GetInput(0) );
+ itk::ImageRegion<3> inputRegion = inputImage->GetLargestPossibleRegion();
+
+ typename itk::ImageDuplicator<DiffusionImageType>::Pointer duplicator = itk::ImageDuplicator<DiffusionImageType>::New();
+ duplicator->SetInputImage( inputImage );
+ duplicator->Update();
+ typename DiffusionImageType::Pointer outputImage = duplicator->GetOutput();
+
+ // is input slize size even?
+ int x=inputRegion.GetSize(0); int y=inputRegion.GetSize(1);
+ if ( x%2 == 1 )
+ x += 1;
+ if ( y%2 == 1 )
+ y += 1;
+
+ // create slice object
+ typename SliceType::Pointer slice = SliceType::New();
+ ImageRegion<2> sliceRegion;
+ sliceRegion.SetSize(0, x);
+ sliceRegion.SetSize(1, y);
+ slice->SetLargestPossibleRegion( sliceRegion );
+ slice->SetBufferedRegion( sliceRegion );
+ slice->SetRequestedRegion( sliceRegion );
+ slice->Allocate();
+ slice->FillBuffer(0.0);
+
+ ImageRegion<2> upsampledSliceRegion;
+ if (m_Upsampling>1.00001)
+ {
+ upsampledSliceRegion.SetSize(0, x*m_Upsampling);
+ upsampledSliceRegion.SetSize(1, y*m_Upsampling);
+ }
+
+ // frequency map slice
+ typename SliceType::Pointer fMap = NULL;
+ if (m_FrequencyMap.IsNotNull())
+ {
+ fMap = SliceType::New();
+ fMap->SetLargestPossibleRegion( sliceRegion );
+ fMap->SetBufferedRegion( sliceRegion );
+ fMap->SetRequestedRegion( sliceRegion );
+ fMap->Allocate();
+ fMap->FillBuffer(0.0);
+ }
+
+ if ( m_FrequencyMap.IsNotNull() || m_kOffset>0.0 || m_Upsampling>1.00001 || m_SimulateEddyCurrents)
+ {
+ MatrixType transform = inputImage->GetDirection();
+ for (int i=0; i<3; i++)
+ for (int j=0; j<3; j++)
+ transform[i][j] *= inputImage->GetSpacing()[j];
+
+ MITK_INFO << "Adjusting complex signal";
+ MITK_INFO << "line readout time: " << m_tLine;
+ MITK_INFO << "line offset: " << m_kOffset;
+ if (m_FrequencyMap.IsNotNull())
+ MITK_INFO << "frequency map is set";
+ else
+ MITK_INFO << "no frequency map set";
+ if (m_Upsampling>1.00001)
+ MITK_INFO << "Gibbs ringing enabled";
+ else
+ MITK_INFO << "Gibbs ringing disabled";
+
+ if (m_SimulateEddyCurrents)
+ MITK_INFO << "Simulating eddy currents";
+
+ boost::progress_display disp(inputImage->GetVectorLength()*inputRegion.GetSize(2));
+ for (int g=0; g<inputImage->GetVectorLength(); g++)
+ for (int z=0; z<inputRegion.GetSize(2); z++)
+ {
+ std::vector< SliceType::Pointer > compartmentSlices;
+ // extract slice from channel g
+ for (int y=0; y<sliceRegion.GetSize(1); y++)
+ for (int x=0; x<sliceRegion.GetSize(0); x++)
+ {
+ typename SliceType::IndexType index2D;
+ index2D[0]=x; index2D[1]=y;
+ typename DiffusionImageType::IndexType index3D;
+ index3D[0]=x; index3D[1]=y; index3D[2]=z;
+
+ SliceType::PixelType pix2D = (SliceType::PixelType)inputImage->GetPixel(index3D)[g];
+ slice->SetPixel(index2D, pix2D);
+
+ if (fMap.IsNotNull())
+ fMap->SetPixel(index2D, m_FrequencyMap->GetPixel(index3D));
+ }
+
+ if (m_Upsampling>1.00001)
+ {
+ itk::ResampleImageFilter<SliceType, SliceType>::Pointer resampler = itk::ResampleImageFilter<SliceType, SliceType>::New();
+ resampler->SetInput(slice);
+ resampler->SetOutputParametersFromImage(slice);
+ resampler->SetSize(upsampledSliceRegion.GetSize());
+ resampler->SetOutputSpacing(slice->GetSpacing()/m_Upsampling);
+ resampler->Update();
+ typename SliceType::Pointer upslice = resampler->GetOutput();
+ compartmentSlices.push_back(upslice);
+ }
+ else
+ compartmentSlices.push_back(slice);
+
+ // fourier transform slice
+ typename ComplexSliceType::Pointer fSlice;
+
+ itk::Size<2> outSize; outSize.SetElement(0, x); outSize.SetElement(1, y);
+ typename itk::KspaceImageFilter< SliceType::PixelType >::Pointer idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
+ idft->SetCompartmentImages(compartmentSlices);
+ idft->SetkOffset(m_kOffset);
+ idft->SettLine(m_tLine);
+ idft->SetSimulateRelaxation(false);
+ idft->SetFrequencyMap(fMap);
+ idft->SetDiffusionGradientDirection(m_GradientList.at(g));
+ idft->SetSimulateEddyCurrents(m_SimulateEddyCurrents);
+ idft->SetEddyGradientMagnitude(m_EddyGradientStrength);
+ idft->SetTE(m_TE);
+ idft->SetZ((double)z-(double)inputRegion.GetSize(2)/2.0);
+ idft->SetDirectionMatrix(transform);
+ idft->SetOutSize(outSize);
+ idft->Update();
+ fSlice = idft->GetOutput();
+
+ // inverse fourier transform slice
+ typename SliceType::Pointer newSlice;
+ typename itk::DftImageFilter< SliceType::PixelType >::Pointer dft = itk::DftImageFilter< SliceType::PixelType >::New();
+ dft->SetInput(fSlice);
+ dft->Update();
+ newSlice = dft->GetOutput();
+
+ // put slice back into channel g
+ for (int y=0; y<inputRegion.GetSize(1); y++)
+ for (int x=0; x<inputRegion.GetSize(0); x++)
+ {
+ typename DiffusionImageType::IndexType index3D;
+ index3D[0]=x; index3D[1]=y; index3D[2]=z;
+ typename DiffusionImageType::PixelType pix3D = outputImage->GetPixel(index3D);
+ typename SliceType::IndexType index2D;
+ index2D[0]=x; index2D[1]=y;
+
+ double signal = newSlice->GetPixel(index2D);
+ if (signal>0)
+ signal = floor(signal+0.5);
+ else
+ signal = ceil(signal-0.5);
+
+ pix3D[g] = signal;
+ outputImage->SetPixel(index3D, pix3D);
+ }
+
+ ++disp;
+ }
+ }
+
+ if (m_NoiseModel!=NULL)
+ {
+ ImageRegionIterator<DiffusionImageType> it1 (outputImage, inputRegion);
+ boost::progress_display disp2(inputRegion.GetNumberOfPixels());
+ while(!it1.IsAtEnd())
+ {
+ ++disp2;
+
+ typename DiffusionImageType::PixelType signal = it1.Get();
+ m_NoiseModel->AddNoise(signal);
+ it1.Set(signal);
+
+ ++it1;
+ }
+ }
+
+ this->SetNthOutput(0, outputImage);
+}
+
+}
+#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.h
new file mode 100644
index 0000000000..7a467447ba
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.h
@@ -0,0 +1,97 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __itkAddArtifactsToDwiImageFilter_h_
+#define __itkAddArtifactsToDwiImageFilter_h_
+
+#include "FiberTrackingExports.h"
+#include <itkImageToImageFilter.h>
+#include <itkVectorImage.h>
+#include <itkKspaceImageFilter.h>
+#include <itkDftImageFilter.h>
+#include <mitkDiffusionNoiseModel.h>
+#include <mitkDiffusionSignalModel.h>
+
+namespace itk{
+
+/**
+* \brief Adds several artifacts to the input DWI. */
+
+ template< class TPixelType >
+ class AddArtifactsToDwiImageFilter :
+ public ImageToImageFilter< VectorImage< TPixelType, 3 >, VectorImage< TPixelType, 3 > >
+ {
+
+ public:
+
+ typedef AddArtifactsToDwiImageFilter Self;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+ typedef ImageToImageFilter< VectorImage< TPixelType, 3 >, VectorImage< TPixelType, 3 > > Superclass;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self)
+
+ /** Runtime information support. */
+ itkTypeMacro(AddArtifactsToDwiImageFilter, ImageToImageFilter)
+
+ typedef typename Superclass::InputImageType DiffusionImageType;
+ typedef mitk::DiffusionNoiseModel<TPixelType> NoiseModelType;
+ typedef itk::Image< double, 2 > SliceType;
+ typedef typename itk::KspaceImageFilter< double >::OutputImageType ComplexSliceType;
+ typedef itk::Image<double, 3> ItkDoubleImgType;
+ typedef itk::Matrix<double, 3, 3> MatrixType;
+
+ void SetNoiseModel(NoiseModelType* noiseModel){ m_NoiseModel = noiseModel; }
+ itkSetMacro( FrequencyMap, ItkDoubleImgType::Pointer )
+ itkSetMacro( kOffset, double )
+ itkSetMacro( tLine, double )
+ itkSetMacro( SimulateEddyCurrents, bool )
+ itkSetMacro( EddyGradientStrength, double )
+ void SetGradientList(mitk::DiffusionSignalModel<double>::GradientListType list) { m_GradientList=list; }
+ itkSetMacro( TE, double )
+ itkSetMacro( Upsampling, double )
+
+ protected:
+ AddArtifactsToDwiImageFilter();
+ ~AddArtifactsToDwiImageFilter() {}
+
+ typename ComplexSliceType::Pointer RearrangeSlice(typename ComplexSliceType::Pointer slice);
+
+ void GenerateData();
+
+ NoiseModelType* m_NoiseModel;
+ ItkDoubleImgType::Pointer m_FrequencyMap;
+ double m_kOffset;
+ double m_tLine;
+ bool m_SimulateEddyCurrents;
+ double m_EddyGradientStrength;
+ mitk::DiffusionSignalModel<double>::GradientListType m_GradientList;
+ double m_TE;
+ double m_Upsampling; ///< causes ringing artifacts
+
+ private:
+
+ };
+
+}
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkAddArtifactsToDwiImageFilter.cpp"
+#endif
+
+#endif //__itkAddArtifactsToDwiImageFilter_h_
+
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkDftImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkDftImageFilter.cpp
new file mode 100644
index 0000000000..7d1e74bb7b
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkDftImageFilter.cpp
@@ -0,0 +1,80 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __itkDftImageFilter_txx
+#define __itkDftImageFilter_txx
+
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "itkDftImageFilter.h"
+#include <itkImageRegionConstIterator.h>
+#include <itkImageRegionConstIteratorWithIndex.h>
+#include <itkImageRegionIterator.h>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+namespace itk {
+
+template< class TPixelType >
+DftImageFilter< TPixelType >
+::DftImageFilter()
+{
+ this->SetNumberOfRequiredInputs( 1 );
+}
+
+template< class TPixelType >
+void DftImageFilter< TPixelType >
+::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType threadId)
+{
+ typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+
+ ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
+
+ typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
+ typename InputImageType::Pointer inputImage = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
+
+ int szx = outputImage->GetLargestPossibleRegion().GetSize(0);
+ int szy = outputImage->GetLargestPossibleRegion().GetSize(1);
+
+ while( !oit.IsAtEnd() )
+ {
+ int kx = oit.GetIndex()[0];
+ int ky = oit.GetIndex()[1];
+
+ vcl_complex<double> s(0,0);
+ InputIteratorType it(inputImage, inputImage->GetLargestPossibleRegion() );
+ while( !it.IsAtEnd() )
+ {
+ int x = it.GetIndex()[0];
+ int y = it.GetIndex()[1];
+
+ vcl_complex<double> f(it.Get().real(), it.Get().imag());
+ s += f * exp( std::complex<double>(0, -2 * M_PI * (kx*(double)x/szx + ky*(double)y/szy) ) );
+
+ ++it;
+ }
+ double magn = sqrt(s.real()*s.real()+s.imag()*s.imag());
+ oit.Set(magn);
+
+ ++oit;
+ }
+}
+
+}
+#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkDftImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkDftImageFilter.h
new file mode 100644
index 0000000000..ee2235cee4
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkDftImageFilter.h
@@ -0,0 +1,74 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+/*===================================================================
+
+This file is based heavily on a corresponding ITK filter.
+
+===================================================================*/
+#ifndef __itkDftImageFilter_h_
+#define __itkDftImageFilter_h_
+
+#include "FiberTrackingExports.h"
+#include <itkImageToImageFilter.h>
+#include <itkDiffusionTensor3D.h>
+#include <vcl_complex.h>
+
+namespace itk{
+
+/**
+* \brief 2D Discrete Fourier Transform Filter (complex to real) */
+
+ template< class TPixelType >
+ class DftImageFilter :
+ public ImageToImageFilter< Image< vcl_complex< TPixelType > >, Image< TPixelType > >
+ {
+
+ public:
+
+ typedef DftImageFilter Self;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+ typedef ImageToImageFilter< Image< vcl_complex< TPixelType > >, Image< TPixelType > > Superclass;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self)
+
+ /** Runtime information support. */
+ itkTypeMacro(DftImageFilter, ImageToImageFilter)
+
+ typedef typename Superclass::InputImageType InputImageType;
+ typedef typename Superclass::OutputImageType OutputImageType;
+ typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
+
+ protected:
+ DftImageFilter();
+ ~DftImageFilter() {}
+
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId);
+
+ private:
+
+ };
+
+}
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkDftImageFilter.cpp"
+#endif
+
+#endif //__itkDftImageFilter_h_
+
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.cpp
new file mode 100755
index 0000000000..5fc4b37e71
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.cpp
@@ -0,0 +1,377 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __itkEvaluateDirectionImagesFilter_cpp
+#define __itkEvaluateDirectionImagesFilter_cpp
+
+#include "itkEvaluateDirectionImagesFilter.h"
+#include <itkImageRegionConstIterator.h>
+#include <itkImageRegionIterator.h>
+#include <itkImageDuplicator.h>
+#include <boost/progress.hpp>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+namespace itk {
+
+template< class PixelType >
+EvaluateDirectionImagesFilter< PixelType >
+::EvaluateDirectionImagesFilter():
+ m_ImageSet(NULL),
+ m_ReferenceImageSet(NULL),
+ m_IgnoreMissingDirections(false),
+ m_Eps(0.0001)
+{
+ this->SetNumberOfOutputs(2);
+}
+
+template< class PixelType >
+void EvaluateDirectionImagesFilter< PixelType >::GenerateData()
+{
+ if (m_ImageSet.IsNull() || m_ReferenceImageSet.IsNull())
+ return;
+
+ DirectionImageContainerType::Pointer set1 = DirectionImageContainerType::New();
+ DirectionImageContainerType::Pointer set2 = DirectionImageContainerType::New();
+
+ for (int i=0; i<m_ImageSet->Size(); i++)
+ {
+ typename itk::ImageDuplicator< DirectionImageType >::Pointer duplicator = itk::ImageDuplicator< DirectionImageType >::New();
+ duplicator->SetInputImage( m_ImageSet->GetElement(i) );
+ duplicator->Update();
+ set1->InsertElement(i, dynamic_cast<DirectionImageType*>(duplicator->GetOutput()));
+ }
+ for (int i=0; i<m_ReferenceImageSet->Size(); i++)
+ {
+ typename itk::ImageDuplicator< DirectionImageType >::Pointer duplicator = itk::ImageDuplicator< DirectionImageType >::New();
+ duplicator->SetInputImage( m_ReferenceImageSet->GetElement(i) );
+ duplicator->Update();
+ set2->InsertElement(i, dynamic_cast<DirectionImageType*>(duplicator->GetOutput()));
+ }
+
+ m_ImageSet = set1;
+ m_ReferenceImageSet = set2;
+
+ // angular error image
+ typename OutputImageType::Pointer outputImage = OutputImageType::New();
+ outputImage->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
+ outputImage->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
+ outputImage->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
+ outputImage->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
+ outputImage->Allocate();
+ outputImage->FillBuffer(0.0);
+ this->SetNthOutput(0, outputImage);
+
+ // length error image
+ outputImage = OutputImageType::New();
+ outputImage->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
+ outputImage->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
+ outputImage->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
+ outputImage->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
+ outputImage->Allocate();
+ outputImage->FillBuffer(0.0);
+ this->SetNthOutput(1, outputImage);
+
+ if (m_MaskImage.IsNull())
+ {
+ m_MaskImage = UCharImageType::New();
+ m_MaskImage->SetOrigin( outputImage->GetOrigin() );
+ m_MaskImage->SetRegions( outputImage->GetLargestPossibleRegion() );
+ m_MaskImage->SetSpacing( outputImage->GetSpacing() );
+ m_MaskImage->SetDirection( outputImage->GetDirection() );
+ m_MaskImage->Allocate();
+ m_MaskImage->FillBuffer(1);
+ }
+
+ m_MeanAngularError = 0.0;
+ m_MedianAngularError = 0;
+ m_MaxAngularError = 0.0;
+ m_MinAngularError = itk::NumericTraits<float>::max();
+ m_VarAngularError = 0.0;
+ m_AngularErrorVector.clear();
+
+ m_MeanLengthError = 0.0;
+ m_MedianLengthError = 0;
+ m_MaxLengthError = 0.0;
+ m_MinLengthError = itk::NumericTraits<float>::max();
+ m_VarLengthError = 0.0;
+ m_LengthErrorVector.clear();
+
+ if (m_ImageSet.IsNull() || m_ReferenceImageSet.IsNull())
+ return;
+
+ outputImage = static_cast< OutputImageType* >(this->ProcessObject::GetOutput(0));
+ typename OutputImageType::Pointer outputImage2 = static_cast< OutputImageType* >(this->ProcessObject::GetOutput(1));
+
+ ImageRegionIterator< OutputImageType > oit(outputImage, outputImage->GetLargestPossibleRegion());
+ ImageRegionIterator< OutputImageType > oit2(outputImage2, outputImage2->GetLargestPossibleRegion());
+ ImageRegionIterator< UCharImageType > mit(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
+
+ int numImages = m_ImageSet->Size();
+ int numReferenceImages = m_ReferenceImageSet->Size();
+
+ // fill missing directions with zeros
+ if (numImages>numReferenceImages)
+ {
+ DirectionType zeroDir; zeroDir.Fill(0.0);
+ for (int i=0; i<numImages-numReferenceImages; i++)
+ {
+ DirectionImageType::Pointer img = DirectionImageType::New();
+ img->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
+ img->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
+ img->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
+ img->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
+ img->Allocate();
+ img->FillBuffer(zeroDir);
+ m_ReferenceImageSet->InsertElement(m_ReferenceImageSet->Size(), img);
+ }
+ numReferenceImages = numImages;
+ }
+ else if (numReferenceImages>numImages)
+ {
+ DirectionType zeroDir; zeroDir.Fill(0.0);
+ for (int i=0; i<numReferenceImages-numImages; i++)
+ {
+ DirectionImageType::Pointer img = DirectionImageType::New();
+ img->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
+ img->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
+ img->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
+ img->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
+ img->Allocate();
+ img->FillBuffer(zeroDir);
+ m_ImageSet->InsertElement(m_ImageSet->Size(), img);
+ }
+ numImages = numReferenceImages;
+ }
+ int numDirections = numReferenceImages;
+
+ // matrix containing the angular error between the directions
+ vnl_matrix< float > diffM; diffM.set_size(numDirections, numDirections);
+
+ boost::progress_display disp(outputImage->GetLargestPossibleRegion().GetSize()[0]*outputImage->GetLargestPossibleRegion().GetSize()[1]*outputImage->GetLargestPossibleRegion().GetSize()[2]);
+ while( !oit.IsAtEnd() )
+ {
+ ++disp;
+ if( mit.Get()!=1 )
+ {
+ ++oit;
+ ++oit2;
+ ++mit;
+ continue;
+ }
+ typename OutputImageType::IndexType index = oit.GetIndex();
+
+ float maxAngularError = 1.0;
+
+ diffM.fill(10); // initialize with invalid error value
+
+ // get number of valid directions (length > 0)
+ int numRefDirs = 0;
+ int numTestDirs = 0;
+ for (int i=0; i<numDirections; i++)
+ {
+ if (m_ReferenceImageSet->GetElement(i)->GetPixel(index).GetVnlVector().magnitude() > m_Eps )
+ numRefDirs++;
+ if (m_ImageSet->GetElement(i)->GetPixel(index).GetVnlVector().magnitude() > m_Eps )
+ numTestDirs++;
+ }
+
+ // i: index of reference direction
+ // j: index of test direction
+ for (int i=0; i<numDirections; i++) // for each reference direction
+ {
+ bool missingDir = false;
+ vnl_vector_fixed< PixelType, 3 > refDir = m_ReferenceImageSet->GetElement(i)->GetPixel(index).GetVnlVector();
+
+ if (i<numRefDirs) // normalize if not null
+ refDir.normalize();
+ else if (m_IgnoreMissingDirections)
+ continue;
+ else
+ missingDir = true;
+
+ for (int j=0; j<numDirections; j++) // and each test direction
+ {
+ vnl_vector_fixed< PixelType, 3 > testDir = m_ImageSet->GetElement(j)->GetPixel(index).GetVnlVector();
+ if (j<numTestDirs) // normalize if not null
+ testDir.normalize();
+ else if (m_IgnoreMissingDirections || missingDir)
+ continue;
+ else
+ missingDir = true;
+
+ // found missing direction
+ if (missingDir)
+ {
+ diffM[i][j] = -1;
+ continue;
+ }
+
+ // calculate angle between directions
+ diffM[i][j] = fabs(dot_product(refDir, testDir));
+
+ if (diffM[i][j] < maxAngularError)
+ maxAngularError = diffM[i][j];
+
+ if (diffM[i][j]>1.0)
+ diffM[i][j] = 1.0;
+ }
+ }
+
+ float angularError = 0.0;
+ float lengthError = 0.0;
+ int counter = 0;
+ vnl_matrix< float > diffM_copy = diffM;
+ for (int k=0; k<numDirections; k++)
+ {
+ float error = -1;
+ int a,b; a=-1; b=-1;
+ bool missingDir = false;
+
+ // i: index of reference direction
+ // j: index of test direction
+ // find smalles error between two directions (large value -> small error)
+ for (int i=0; i<numDirections; i++)
+ for (int j=0; j<numDirections; j++)
+ {
+ if (diffM[i][j]>error && diffM[i][j]<2) // found valid error entry
+ {
+ error = diffM[i][j];
+ a = i;
+ b = j;
+ missingDir = false;
+ }
+ else if (diffM[i][j]<0 && error<0) // found missing direction
+ {
+ a = i;
+ b = j;
+ missingDir = true;
+ }
+ }
+
+ if (a<0 || b<0 || m_IgnoreMissingDirections && missingDir)
+ continue; // no more directions found
+
+ if (a>=numRefDirs && b>=numTestDirs)
+ {
+ MITK_INFO << "ERROR: missing test and reference direction. should not be possible. check code.";
+ continue;
+ }
+
+ // remove processed directions from error matrix
+ diffM.set_row(a, 10.0);
+ diffM.set_column(b, 10.0);
+
+ if (a>=numRefDirs) // missing reference direction (find next closest)
+ {
+ for (int i=0; i<numRefDirs; i++)
+ if (diffM_copy[i][b]>error)
+ {
+ error = diffM_copy[i][b];
+ a = i;
+ }
+ }
+ else if (b>=numTestDirs) // missing test direction (find next closest)
+ {
+ for (int i=0; i<numTestDirs; i++)
+ if (diffM_copy[a][i]>error)
+ {
+ error = diffM_copy[a][i];
+ b = i;
+ }
+ }
+
+ float refLength = m_ReferenceImageSet->GetElement(a)->GetPixel(index).GetVnlVector().magnitude();
+ float testLength = m_ImageSet->GetElement(b)->GetPixel(index).GetVnlVector().magnitude();
+
+ if (a>=numRefDirs || b>=numTestDirs || error<0)
+ error = 0;
+
+ m_LengthErrorVector.push_back( fabs(refLength-testLength) );
+ m_AngularErrorVector.push_back( acos(error)*180.0/M_PI );
+
+ m_MeanAngularError += m_AngularErrorVector.back();
+ m_MeanLengthError += m_LengthErrorVector.back();
+
+ angularError += m_AngularErrorVector.back();
+ lengthError += m_LengthErrorVector.back();
+ counter++;
+ }
+
+ if (counter>0)
+ {
+ lengthError /= counter;
+ angularError /= counter;
+ }
+ oit2.Set(lengthError);
+ oit.Set(angularError);
+
+ ++oit;
+ ++oit2;
+ ++mit;
+ }
+
+ std::sort( m_AngularErrorVector.begin(), m_AngularErrorVector.end() );
+ m_MeanAngularError /= m_AngularErrorVector.size(); // mean
+ for (int i=0; i<m_AngularErrorVector.size(); i++)
+ {
+ float temp = m_AngularErrorVector.at(i) - m_MeanAngularError;
+ m_VarAngularError += temp*temp;
+
+ if ( m_AngularErrorVector.at(i)>m_MaxAngularError )
+ m_MaxAngularError = m_AngularErrorVector.at(i);
+ if ( m_AngularErrorVector.at(i)<m_MinAngularError )
+ m_MinAngularError = m_AngularErrorVector.at(i);
+ }
+ if (m_AngularErrorVector.size()>1)
+ {
+ m_VarAngularError /= (m_AngularErrorVector.size()-1); // variance
+
+ // median
+ if (m_AngularErrorVector.size()%2 == 0)
+ m_MedianAngularError = 0.5*( m_AngularErrorVector.at( m_AngularErrorVector.size()/2 ) + m_AngularErrorVector.at( m_AngularErrorVector.size()/2+1 ) );
+ else
+ m_MedianAngularError = m_AngularErrorVector.at( (m_AngularErrorVector.size()+1)/2 ) ;
+ }
+
+ std::sort( m_LengthErrorVector.begin(), m_LengthErrorVector.end() );
+ m_MeanLengthError /= m_LengthErrorVector.size(); // mean
+ for (int i=0; i<m_LengthErrorVector.size(); i++)
+ {
+ float temp = m_LengthErrorVector.at(i) - m_MeanLengthError;
+ m_VarLengthError += temp*temp;
+
+ if ( m_LengthErrorVector.at(i)>m_MaxLengthError )
+ m_MaxLengthError = m_LengthErrorVector.at(i);
+ if ( m_LengthErrorVector.at(i)<m_MinLengthError )
+ m_MinLengthError = m_LengthErrorVector.at(i);
+ }
+ if (m_LengthErrorVector.size()>1)
+ {
+ m_VarLengthError /= (m_LengthErrorVector.size()-1); // variance
+
+ // median
+ if (m_LengthErrorVector.size()%2 == 0)
+ m_MedianLengthError = 0.5*( m_LengthErrorVector.at( m_LengthErrorVector.size()/2 ) + m_LengthErrorVector.at( m_LengthErrorVector.size()/2+1 ) );
+ else
+ m_MedianLengthError = m_LengthErrorVector.at( (m_LengthErrorVector.size()+1)/2 ) ;
+ }
+}
+
+}
+
+#endif // __itkEvaluateDirectionImagesFilter_cpp
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.h
new file mode 100755
index 0000000000..964c17e5fc
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.h
@@ -0,0 +1,110 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+/*===================================================================
+
+This file is based heavily on a corresponding ITK filter.
+
+===================================================================*/
+#ifndef __itkEvaluateDirectionImagesFilter_h_
+#define __itkEvaluateDirectionImagesFilter_h_
+
+#include <itkProcessObject.h>
+#include <itkVectorContainer.h>
+#include <itkImageSource.h>
+
+namespace itk{
+/** \class EvaluateDirectionImagesFilter
+ */
+
+template< class PixelType >
+class EvaluateDirectionImagesFilter : public ImageSource< Image< PixelType, 3 > >
+{
+
+public:
+
+ typedef EvaluateDirectionImagesFilter Self;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+ typedef ImageSource< Image< PixelType, 3 > > Superclass;
+ typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
+ typedef typename Superclass::OutputImageType OutputImageType;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self)
+
+ /** Runtime information support. */
+ itkTypeMacro(EvaluateDirectionImagesFilter, ImageToImageFilter)
+
+ typedef Vector< float, 3 > DirectionType;
+ typedef Image< DirectionType, 3 > DirectionImageType;
+ typedef VectorContainer< int, DirectionImageType::Pointer > DirectionImageContainerType;
+ typedef Image< float, 3 > FloatImageType;
+ typedef Image< bool, 3 > BoolImageType;
+ typedef Image< unsigned char, 3 > UCharImageType;
+
+ itkSetMacro( ImageSet , DirectionImageContainerType::Pointer)
+ itkSetMacro( ReferenceImageSet , DirectionImageContainerType::Pointer)
+ itkSetMacro( MaskImage , UCharImageType::Pointer)
+ itkSetMacro( IgnoreMissingDirections , bool)
+
+ itkGetMacro( MeanAngularError, float)
+ itkGetMacro( MinAngularError, float)
+ itkGetMacro( MaxAngularError, float)
+ itkGetMacro( VarAngularError, float)
+ itkGetMacro( MedianAngularError, float)
+
+ itkGetMacro( MeanLengthError, float)
+ itkGetMacro( MinLengthError, float)
+ itkGetMacro( MaxLengthError, float)
+ itkGetMacro( VarLengthError, float)
+ itkGetMacro( MedianLengthError, float)
+
+protected:
+ EvaluateDirectionImagesFilter();
+ ~EvaluateDirectionImagesFilter() {}
+
+ void GenerateData();
+
+ UCharImageType::Pointer m_MaskImage;
+ DirectionImageContainerType::Pointer m_ImageSet;
+ DirectionImageContainerType::Pointer m_ReferenceImageSet;
+ bool m_IgnoreMissingDirections;
+ double m_MeanAngularError;
+ double m_MedianAngularError;
+ double m_MaxAngularError;
+ double m_MinAngularError;
+ double m_VarAngularError;
+ std::vector< double > m_AngularErrorVector;
+
+ double m_MeanLengthError;
+ double m_MedianLengthError;
+ double m_MaxLengthError;
+ double m_MinLengthError;
+ double m_VarLengthError;
+ std::vector< double > m_LengthErrorVector;
+
+ double m_Eps;
+};
+
+}
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkEvaluateDirectionImagesFilter.cpp"
+#endif
+
+#endif //__itkEvaluateDirectionImagesFilter_h_
+
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFieldmapGeneratorFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFieldmapGeneratorFilter.cpp
new file mode 100644
index 0000000000..f6f7516e67
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFieldmapGeneratorFilter.cpp
@@ -0,0 +1,79 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Coindex[1]right (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+#include "itkFieldmapGeneratorFilter.h"
+
+#include <itkImageRegionIterator.h>
+#include <math.h>
+#include <itkPoint.h>
+
+namespace itk{
+
+template< class OutputImageType >
+FieldmapGeneratorFilter< OutputImageType >::FieldmapGeneratorFilter()
+{
+ m_Gradient.fill(0.0);
+ m_Offset.fill(0.0);
+}
+
+template< class OutputImageType >
+FieldmapGeneratorFilter< OutputImageType >::~FieldmapGeneratorFilter()
+{
+}
+
+template< class OutputImageType >
+void FieldmapGeneratorFilter< OutputImageType >::BeforeThreadedGenerateData()
+{
+ typename OutputImageType::Pointer outImage = OutputImageType::New();
+ outImage->SetSpacing( m_Spacing );
+ outImage->SetOrigin( m_Origin );
+ outImage->SetDirection( m_DirectionMatrix );
+ outImage->SetLargestPossibleRegion( m_ImageRegion );
+ outImage->SetBufferedRegion( m_ImageRegion );
+ outImage->SetRequestedRegion( m_ImageRegion );
+ outImage->Allocate();
+ outImage->FillBuffer(0);
+ this->SetNthOutput(0, outImage);
+}
+
+template< class OutputImageType >
+void FieldmapGeneratorFilter< OutputImageType >::ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId)
+{
+ typename OutputImageType::Pointer outImage = static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+ ImageRegionIterator< OutputImageType > oit(outImage, outputRegionForThread);
+
+ while( !oit.IsAtEnd() )
+ {
+ double value = 0;
+ IndexType idx = oit.GetIndex();
+ for (int i=0; i<3; i++)
+ value += idx[i]*m_Gradient[i] + m_Offset[i];
+
+ for (int i=0; i<m_WorldPositions.size(); i++)
+ {
+ mitk::Point3D c = m_WorldPositions.at(i);
+ itk::Point<double, 3> vertex;
+ outImage->TransformIndexToPhysicalPoint(idx, vertex);
+ double dist = c.EuclideanDistanceTo(vertex);
+ value += m_Heights.at(i)*exp(-dist*dist/(2*m_Variances.at(i)));
+ }
+ oit.Set(value);
+ ++oit;
+ }
+
+ MITK_INFO << "Thread " << threadId << "finished processing";
+}
+
+}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFieldmapGeneratorFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFieldmapGeneratorFilter.h
new file mode 100644
index 0000000000..73030eef3c
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFieldmapGeneratorFilter.h
@@ -0,0 +1,85 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+#ifndef __itkFieldmapGeneratorFilter_h__
+#define __itkFieldmapGeneratorFilter_h__
+
+#include <itkImageSource.h>
+#include <itkImage.h>
+#include <itkImageRegion.h>
+#include <itkVector.h>
+#include <mitkVector.h>
+#include <itkMatrix.h>
+#include <vector>
+
+namespace itk{
+
+/**
+* \brief Generates tract density images from input fiberbundles (Calamante 2010). */
+
+template< class OutputImageType >
+class FieldmapGeneratorFilter : public ImageSource< OutputImageType >
+{
+
+public:
+ typedef FieldmapGeneratorFilter Self;
+ typedef ProcessObject Superclass;
+ typedef SmartPointer< Self > Pointer;
+ typedef SmartPointer< const Self > ConstPointer;
+
+ typedef typename OutputImageType::PixelType PixelType;
+ typedef typename OutputImageType::IndexType IndexType;
+ typedef itk::ImageRegion<3> OutputImageRegionType;
+ typedef itk::Matrix<double, 3, 3> MatrixType;
+
+ itkNewMacro(Self)
+ itkTypeMacro( FieldmapGeneratorFilter, ImageSource )
+
+ itkSetMacro( Spacing, itk::Vector<double> )
+ itkSetMacro( Origin, mitk::Point3D )
+ itkSetMacro( DirectionMatrix, MatrixType )
+ itkSetMacro( ImageRegion, OutputImageRegionType )
+ void SetGradient( vnl_vector_fixed< double, 3 > gradient ) { m_Gradient=gradient; }
+ void SetOffset( vnl_vector_fixed< double, 3 > offset ) { m_Offset=offset; }
+ void SetVariances( std::vector< double > variances ) { m_Variances=variances; }
+ void SetHeights( std::vector< double > heights ) { m_Heights=heights; }
+ void SetWorldPositions( std::vector< mitk::Point3D > worldPositions ) { m_WorldPositions=worldPositions; }
+
+protected:
+
+ void BeforeThreadedGenerateData();
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId);
+
+ FieldmapGeneratorFilter();
+ virtual ~FieldmapGeneratorFilter();
+
+ itk::Vector<double> m_Spacing; ///< output image spacing
+ mitk::Point3D m_Origin; ///< output image origin
+ MatrixType m_DirectionMatrix; ///< output image rotation
+ OutputImageRegionType m_ImageRegion; ///< output image size
+ std::vector< double > m_Variances;
+ std::vector< double > m_Heights;
+ std::vector< mitk::Point3D > m_WorldPositions;
+ vnl_vector_fixed< double, 3 > m_Gradient;
+ vnl_vector_fixed< double, 3 > m_Offset;
+};
+
+}
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkFieldmapGeneratorFilter.cpp"
+#endif
+
+#endif // __itkFieldmapGeneratorFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp
index 42c816e097..ed4dedef0b 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp
@@ -1,512 +1,509 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "itkGibbsTrackingFilter.h"
// MITK
#include <itkOrientationDistributionFunction.h>
#include <itkDiffusionQballGeneralizedFaImageFilter.h>
#include <mitkStandardFileLocations.h>
#include <mitkFiberBuilder.h>
#include <mitkMetropolisHastingsSampler.h>
//#include <mitkEnergyComputer.h>
#include <itkTensorImageToQBallImageFilter.h>
#include <mitkGibbsEnergyComputer.h>
// ITK
#include <itkImageDuplicator.h>
#include <itkResampleImageFilter.h>
#include <itkTimeProbe.h>
// MISC
#include <fstream>
#include <QFile>
#include <tinyxml.h>
#include <math.h>
+#include <boost/progress.hpp>
namespace itk{
template< class ItkQBallImageType >
GibbsTrackingFilter< ItkQBallImageType >::GibbsTrackingFilter():
m_StartTemperature(0.1),
m_EndTemperature(0.001),
m_Iterations(500000),
m_ParticleWeight(0),
m_ParticleWidth(0),
m_ParticleLength(0),
m_ConnectionPotential(10),
m_InexBalance(0),
m_ParticlePotential(0.2),
m_MinFiberLength(10),
m_AbortTracking(false),
m_NumConnections(0),
m_NumParticles(0),
m_NumAcceptedFibers(0),
m_CurrentStep(0),
m_BuildFibers(false),
m_Steps(10),
m_ProposalAcceptance(0),
m_CurvatureThreshold(0.7),
m_DuplicateImage(true),
m_RandomSeed(-1),
m_LoadParameterFile(""),
m_LutPath(""),
m_IsInValidState(true)
{
}
template< class ItkQBallImageType >
GibbsTrackingFilter< ItkQBallImageType >::~GibbsTrackingFilter()
{
}
// fill output fiber bundle datastructure
template< class ItkQBallImageType >
typename GibbsTrackingFilter< ItkQBallImageType >::FiberPolyDataType GibbsTrackingFilter< ItkQBallImageType >::GetFiberBundle()
{
if (!m_AbortTracking)
{
m_BuildFibers = true;
while (m_BuildFibers){}
}
return m_FiberPolyData;
}
template< class ItkQBallImageType >
void
GibbsTrackingFilter< ItkQBallImageType >
::EstimateParticleWeight()
{
MITK_INFO << "GibbsTrackingFilter: estimating particle weight";
float minSpacing;
if(m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[1] && m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[2])
minSpacing = m_QBallImage->GetSpacing()[0];
else if (m_QBallImage->GetSpacing()[1] < m_QBallImage->GetSpacing()[2])
minSpacing = m_QBallImage->GetSpacing()[1];
else
minSpacing = m_QBallImage->GetSpacing()[2];
float m_ParticleLength = 1.5*minSpacing;
float m_ParticleWidth = 0.5*minSpacing;
// seed random generators
Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
if (m_RandomSeed>-1)
randGen->SetSeed(m_RandomSeed);
else
randGen->SetSeed();
// instantiate all necessary components
SphereInterpolator* interpolator = new SphereInterpolator(m_LutPath);
// handle lookup table not found cases
if( !interpolator->IsInValidState() )
{
m_IsInValidState = false;
m_AbortTracking = true;
m_BuildFibers = false;
mitkThrow() << "Unable to load lookup tables.";
}
ParticleGrid* particleGrid = new ParticleGrid(m_MaskImage, m_ParticleLength, m_ParticleGridCellCapacity);
GibbsEnergyComputer* encomp = new GibbsEnergyComputer(m_QBallImage, m_MaskImage, particleGrid, interpolator, randGen);
// EnergyComputer* encomp = new EnergyComputer(m_QBallImage, m_MaskImage, particleGrid, interpolator, randGen);
MetropolisHastingsSampler* sampler = new MetropolisHastingsSampler(particleGrid, encomp, randGen, m_CurvatureThreshold);
float alpha = log(m_EndTemperature/m_StartTemperature);
m_ParticleWeight = 0.01;
int ppv = 0;
// main loop
int neededParts = 3000;
while (ppv<neededParts)
{
if (ppv<1000)
m_ParticleWeight /= 2;
else
m_ParticleWeight = ppv*m_ParticleWeight/neededParts;
encomp->SetParameters(m_ParticleWeight,m_ParticleWidth,m_ConnectionPotential*m_ParticleLength*m_ParticleLength,m_CurvatureThreshold,m_InexBalance,m_ParticlePotential);
for( int step = 0; step < 10; step++ )
{
// update temperatur for simulated annealing process
float temperature = m_StartTemperature * exp(alpha*(((1.0)*step)/((1.0)*10)));
sampler->SetTemperature(temperature);
for (unsigned long i=0; i<10000; i++)
sampler->MakeProposal();
}
ppv = particleGrid->m_NumParticles;
particleGrid->ResetGrid();
}
delete sampler;
delete encomp;
delete particleGrid;
delete interpolator;
MITK_INFO << "GibbsTrackingFilter: finished estimating particle weight";
}
// perform global tracking
template< class ItkQBallImageType >
void GibbsTrackingFilter< ItkQBallImageType >::GenerateData()
{
TimeProbe preClock; preClock.Start();
// check if input is qball or tensor image and generate qball if necessary
if (m_QBallImage.IsNull() && m_TensorImage.IsNotNull())
{
TensorImageToQBallImageFilter<float,float>::Pointer filter = TensorImageToQBallImageFilter<float,float>::New();
filter->SetInput( m_TensorImage );
filter->Update();
m_QBallImage = filter->GetOutput();
}
else if (m_DuplicateImage) // generate local working copy of QBall image (if not disabled)
{
typedef itk::ImageDuplicator< ItkQBallImageType > DuplicateFilterType;
typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
duplicator->SetInputImage( m_QBallImage );
duplicator->Update();
m_QBallImage = duplicator->GetOutput();
}
// perform mean subtraction on odfs
typedef ImageRegionIterator< ItkQBallImageType > InputIteratorType;
InputIteratorType it(m_QBallImage, m_QBallImage->GetLargestPossibleRegion() );
it.GoToBegin();
while (!it.IsAtEnd())
{
itk::OrientationDistributionFunction<float, QBALL_ODFSIZE> odf(it.Get().GetDataPointer());
float mean = odf.GetMeanValue();
odf -= mean;
it.Set(odf.GetDataPointer());
++it;
}
// check if mask image is given if it needs resampling
PrepareMaskImage();
// load parameter file
LoadParameters();
// prepare parameters
float minSpacing;
if(m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[1] && m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[2])
minSpacing = m_QBallImage->GetSpacing()[0];
else if (m_QBallImage->GetSpacing()[1] < m_QBallImage->GetSpacing()[2])
minSpacing = m_QBallImage->GetSpacing()[1];
else
minSpacing = m_QBallImage->GetSpacing()[2];
if(m_ParticleLength == 0)
m_ParticleLength = 1.5*minSpacing;
if(m_ParticleWidth == 0)
m_ParticleWidth = 0.5*minSpacing;
if(m_ParticleWeight == 0)
EstimateParticleWeight();
float alpha = log(m_EndTemperature/m_StartTemperature);
m_Steps = m_Iterations/10000;
if (m_Steps<10)
m_Steps = 10;
if (m_Steps>m_Iterations)
{
MITK_INFO << "GibbsTrackingFilter: not enough iterations!";
m_AbortTracking = true;
}
if (m_CurvatureThreshold < mitk::eps)
m_CurvatureThreshold = 0;
unsigned long singleIts = (unsigned long)((1.0*m_Iterations) / (1.0*m_Steps));
// seed random generators
Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
if (m_RandomSeed>-1)
randGen->SetSeed(m_RandomSeed);
else
randGen->SetSeed();
// load sphere interpolator to evaluate the ODFs
SphereInterpolator* interpolator = new SphereInterpolator(m_LutPath);
// handle lookup table not found cases
if( !interpolator->IsInValidState() )
{
m_IsInValidState = false;
m_AbortTracking = true;
m_BuildFibers = false;
mitkThrow() << "Unable to load lookup tables.";
}
// initialize the actual tracking components (ParticleGrid, Metropolis Hastings Sampler and Energy Computer)
ParticleGrid* particleGrid;
GibbsEnergyComputer* encomp;
MetropolisHastingsSampler* sampler;
try{
particleGrid = new ParticleGrid(m_MaskImage, m_ParticleLength, m_ParticleGridCellCapacity);
encomp = new GibbsEnergyComputer(m_QBallImage, m_MaskImage, particleGrid, interpolator, randGen);
encomp->SetParameters(m_ParticleWeight,m_ParticleWidth,m_ConnectionPotential*m_ParticleLength*m_ParticleLength,m_CurvatureThreshold,m_InexBalance,m_ParticlePotential);
sampler = new MetropolisHastingsSampler(particleGrid, encomp, randGen, m_CurvatureThreshold);
}
catch(...)
{
MITK_ERROR << "Particle grid allocation failed. Not enough memory? Try to increase the particle length.";
m_IsInValidState = false;
m_AbortTracking = true;
m_BuildFibers = false;
return;
}
MITK_INFO << "----------------------------------------";
MITK_INFO << "Iterations: " << m_Iterations;
MITK_INFO << "Steps: " << m_Steps;
MITK_INFO << "Particle length: " << m_ParticleLength;
MITK_INFO << "Particle width: " << m_ParticleWidth;
MITK_INFO << "Particle weight: " << m_ParticleWeight;
MITK_INFO << "Start temperature: " << m_StartTemperature;
MITK_INFO << "End temperature: " << m_EndTemperature;
MITK_INFO << "In/Ex balance: " << m_InexBalance;
MITK_INFO << "Min. fiber length: " << m_MinFiberLength;
MITK_INFO << "Curvature threshold: " << m_CurvatureThreshold;
MITK_INFO << "Random seed: " << m_RandomSeed;
MITK_INFO << "----------------------------------------";
// main loop
preClock.Stop();
TimeProbe clock; clock.Start();
m_NumAcceptedFibers = 0;
unsigned long counter = 1;
+
+ boost::progress_display disp(m_Steps*singleIts);
if (!m_AbortTracking)
for( m_CurrentStep = 1; m_CurrentStep <= m_Steps; m_CurrentStep++ )
{
// update temperatur for simulated annealing process
float temperature = m_StartTemperature * exp(alpha*(((1.0)*m_CurrentStep)/((1.0)*m_Steps)));
sampler->SetTemperature(temperature);
for (unsigned long i=0; i<singleIts; i++)
{
+ ++disp;
if (m_AbortTracking)
break;
sampler->MakeProposal();
if (m_BuildFibers || (i==singleIts-1 && m_CurrentStep==m_Steps))
{
m_ProposalAcceptance = (float)sampler->GetNumAcceptedProposals()/counter;
m_NumParticles = particleGrid->m_NumParticles;
m_NumConnections = particleGrid->m_NumConnections;
FiberBuilder fiberBuilder(particleGrid, m_MaskImage);
m_FiberPolyData = fiberBuilder.iterate(m_MinFiberLength);
m_NumAcceptedFibers = m_FiberPolyData->GetNumberOfLines();
m_BuildFibers = false;
}
counter++;
}
m_ProposalAcceptance = (float)sampler->GetNumAcceptedProposals()/counter;
m_NumParticles = particleGrid->m_NumParticles;
m_NumConnections = particleGrid->m_NumConnections;
- MITK_INFO << "GibbsTrackingFilter: proposal acceptance: " << 100*m_ProposalAcceptance << "%";
- MITK_INFO << "GibbsTrackingFilter: particles: " << m_NumParticles;
- MITK_INFO << "GibbsTrackingFilter: connections: " << m_NumConnections;
- MITK_INFO << "GibbsTrackingFilter: progress: " << 100*(float)m_CurrentStep/m_Steps << "%";
- MITK_INFO << "GibbsTrackingFilter: cell overflows: " << particleGrid->m_NumCellOverflows;
- MITK_INFO << "----------------------------------------";
-
if (m_AbortTracking)
break;
}
if (m_AbortTracking)
{
FiberBuilder fiberBuilder(particleGrid, m_MaskImage);
m_FiberPolyData = fiberBuilder.iterate(m_MinFiberLength);
m_NumAcceptedFibers = m_FiberPolyData->GetNumberOfLines();
}
clock.Stop();
delete sampler;
delete encomp;
delete interpolator;
delete particleGrid;
m_AbortTracking = true;
m_BuildFibers = false;
int h = clock.GetTotal()/3600;
int m = ((int)clock.GetTotal()%3600)/60;
int s = (int)clock.GetTotal()%60;
MITK_INFO << "GibbsTrackingFilter: finished gibbs tracking in " << h << "h, " << m << "m and " << s << "s";
m = (int)preClock.GetTotal()/60;
s = (int)preClock.GetTotal()%60;
MITK_INFO << "GibbsTrackingFilter: preparation of the data took " << m << "m and " << s << "s";
MITK_INFO << "GibbsTrackingFilter: " << m_NumAcceptedFibers << " fibers accepted";
SaveParameters();
}
template< class ItkQBallImageType >
void GibbsTrackingFilter< ItkQBallImageType >::PrepareMaskImage()
{
if(m_MaskImage.IsNull())
{
MITK_INFO << "GibbsTrackingFilter: generating default mask image";
m_MaskImage = ItkFloatImageType::New();
m_MaskImage->SetSpacing( m_QBallImage->GetSpacing() );
m_MaskImage->SetOrigin( m_QBallImage->GetOrigin() );
m_MaskImage->SetDirection( m_QBallImage->GetDirection() );
m_MaskImage->SetRegions( m_QBallImage->GetLargestPossibleRegion() );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1.0);
}
else if ( m_MaskImage->GetLargestPossibleRegion().GetSize()[0]!=m_QBallImage->GetLargestPossibleRegion().GetSize()[0] ||
m_MaskImage->GetLargestPossibleRegion().GetSize()[1]!=m_QBallImage->GetLargestPossibleRegion().GetSize()[1] ||
m_MaskImage->GetLargestPossibleRegion().GetSize()[2]!=m_QBallImage->GetLargestPossibleRegion().GetSize()[2] ||
m_MaskImage->GetSpacing()[0]!=m_QBallImage->GetSpacing()[0] ||
m_MaskImage->GetSpacing()[1]!=m_QBallImage->GetSpacing()[1] ||
m_MaskImage->GetSpacing()[2]!=m_QBallImage->GetSpacing()[2] )
{
MITK_INFO << "GibbsTrackingFilter: resampling mask image";
typedef itk::ResampleImageFilter< ItkFloatImageType, ItkFloatImageType, float > ResamplerType;
ResamplerType::Pointer resampler = ResamplerType::New();
resampler->SetOutputSpacing( m_QBallImage->GetSpacing() );
resampler->SetOutputOrigin( m_QBallImage->GetOrigin() );
resampler->SetOutputDirection( m_QBallImage->GetDirection() );
resampler->SetSize( m_QBallImage->GetLargestPossibleRegion().GetSize() );
resampler->SetInput( m_MaskImage );
resampler->SetDefaultPixelValue(0.0);
resampler->Update();
m_MaskImage = resampler->GetOutput();
MITK_INFO << "GibbsTrackingFilter: resampling finished";
}
}
// load tracking paramters from xml file (.gtp)
template< class ItkQBallImageType >
bool GibbsTrackingFilter< ItkQBallImageType >::LoadParameters()
{
m_AbortTracking = true;
try
{
if( m_LoadParameterFile.length()==0 )
{
m_AbortTracking = false;
return true;
}
MITK_INFO << "GibbsTrackingFilter: loading parameter file " << m_LoadParameterFile;
TiXmlDocument doc( m_LoadParameterFile );
doc.LoadFile();
TiXmlHandle hDoc(&doc);
TiXmlElement* pElem;
TiXmlHandle hRoot(0);
pElem = hDoc.FirstChildElement().Element();
hRoot = TiXmlHandle(pElem);
pElem = hRoot.FirstChildElement("parameter_set").Element();
QString iterations(pElem->Attribute("iterations"));
m_Iterations = iterations.toULong();
QString particleLength(pElem->Attribute("particle_length"));
m_ParticleLength = particleLength.toFloat();
QString particleWidth(pElem->Attribute("particle_width"));
m_ParticleWidth = particleWidth.toFloat();
QString partWeight(pElem->Attribute("particle_weight"));
m_ParticleWeight = partWeight.toFloat();
QString startTemp(pElem->Attribute("temp_start"));
m_StartTemperature = startTemp.toFloat();
QString endTemp(pElem->Attribute("temp_end"));
m_EndTemperature = endTemp.toFloat();
QString inExBalance(pElem->Attribute("inexbalance"));
m_InexBalance = inExBalance.toFloat();
QString fiberLength(pElem->Attribute("fiber_length"));
m_MinFiberLength = fiberLength.toFloat();
QString curvThres(pElem->Attribute("curvature_threshold"));
m_CurvatureThreshold = cos(curvThres.toFloat()*M_PI/180);
m_AbortTracking = false;
MITK_INFO << "GibbsTrackingFilter: parameter file loaded successfully";
return true;
}
catch(...)
{
MITK_INFO << "GibbsTrackingFilter: could not load parameter file";
return false;
}
}
// save current tracking paramters to xml file (.gtp)
template< class ItkQBallImageType >
bool GibbsTrackingFilter< ItkQBallImageType >::SaveParameters()
{
try
{
if( m_SaveParameterFile.length()==0 )
{
MITK_INFO << "GibbsTrackingFilter: no filename specified to save parameters";
return true;
}
MITK_INFO << "GibbsTrackingFilter: saving parameter file " << m_SaveParameterFile;
TiXmlDocument documentXML;
TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" );
documentXML.LinkEndChild( declXML );
TiXmlElement* mainXML = new TiXmlElement("global_tracking_parameter_file");
mainXML->SetAttribute("file_version", "0.1");
documentXML.LinkEndChild(mainXML);
TiXmlElement* paramXML = new TiXmlElement("parameter_set");
paramXML->SetAttribute("iterations", QString::number(m_Iterations).toStdString());
paramXML->SetAttribute("particle_length", QString::number(m_ParticleLength).toStdString());
paramXML->SetAttribute("particle_width", QString::number(m_ParticleWidth).toStdString());
paramXML->SetAttribute("particle_weight", QString::number(m_ParticleWeight).toStdString());
paramXML->SetAttribute("temp_start", QString::number(m_StartTemperature).toStdString());
paramXML->SetAttribute("temp_end", QString::number(m_EndTemperature).toStdString());
paramXML->SetAttribute("inexbalance", QString::number(m_InexBalance).toStdString());
paramXML->SetAttribute("fiber_length", QString::number(m_MinFiberLength).toStdString());
paramXML->SetAttribute("curvature_threshold", QString::number(m_CurvatureThreshold).toStdString());
mainXML->LinkEndChild(paramXML);
QString filename(m_SaveParameterFile.c_str());
if(!filename.endsWith(".gtp"))
filename += ".gtp";
documentXML.SaveFile( filename.toStdString() );
MITK_INFO << "GibbsTrackingFilter: parameter file saved successfully";
return true;
}
catch(...)
{
MITK_INFO << "GibbsTrackingFilter: could not save parameter file";
return false;
}
}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.h
index c792454cfc..831e995140 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.h
@@ -1,153 +1,153 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef itkGibbsTrackingFilter_h
#define itkGibbsTrackingFilter_h
// MITK
#include <mitkSphereInterpolator.h>
// ITK
#include <itkProcessObject.h>
#include <itkImage.h>
#include <itkDiffusionTensor3D.h>
#include <itkMersenneTwisterRandomVariateGenerator.h>
// VTK
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
namespace itk{
/**
* \brief Performes global fiber tractography on the input Q-Ball or tensor image (Gibbs tracking, Reisert 2010). */
template< class ItkQBallImageType >
class GibbsTrackingFilter : public ProcessObject
{
public:
typedef GibbsTrackingFilter Self;
typedef ProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
itkNewMacro(Self)
itkTypeMacro( GibbsTrackingFilter, ProcessObject )
typedef Image< DiffusionTensor3D<float>, 3 > ItkTensorImage;
typedef typename ItkQBallImageType::Pointer ItkQBallImageTypePointer;
typedef Image< float, 3 > ItkFloatImageType;
typedef vtkSmartPointer< vtkPolyData > FiberPolyDataType;
// parameter setter
itkSetMacro( StartTemperature, float )
itkSetMacro( EndTemperature, float )
itkSetMacro( Iterations, unsigned long )
itkSetMacro( ParticleWeight, float )
itkSetMacro( ParticleWidth, float )
itkSetMacro( ParticleLength, float )
itkSetMacro( ConnectionPotential, float )
itkSetMacro( InexBalance, float )
itkSetMacro( ParticlePotential, float )
itkSetMacro( MinFiberLength, int )
itkSetMacro( AbortTracking, bool )
itkSetMacro( CurvatureThreshold, float)
itkSetMacro( DuplicateImage, bool )
itkSetMacro( RandomSeed, int )
itkSetMacro( LoadParameterFile, std::string )
itkSetMacro( SaveParameterFile, std::string )
itkSetMacro( LutPath, std::string )
// getter
itkGetMacro( ParticleWeight, float )
itkGetMacro( ParticleWidth, float )
itkGetMacro( ParticleLength, float )
itkGetMacro( CurrentStep, unsigned long )
itkGetMacro( NumParticles, int )
itkGetMacro( NumConnections, int )
itkGetMacro( NumAcceptedFibers, int )
itkGetMacro( ProposalAcceptance, float )
itkGetMacro( Steps, unsigned int)
itkGetMacro( IsInValidState, bool)
// input data
itkSetMacro(QBallImage, typename ItkQBallImageType::Pointer)
itkSetMacro(MaskImage, ItkFloatImageType::Pointer)
itkSetMacro(TensorImage, ItkTensorImage::Pointer)
void GenerateData();
virtual void Update(){
this->GenerateData();
}
FiberPolyDataType GetFiberBundle();
protected:
GibbsTrackingFilter();
virtual ~GibbsTrackingFilter();
void EstimateParticleWeight();
void PrepareMaskImage();
bool LoadParameters();
bool SaveParameters();
// Input Images
typename ItkQBallImageType::Pointer m_QBallImage;
typename ItkFloatImageType::Pointer m_MaskImage;
typename ItkTensorImage::Pointer m_TensorImage;
// Tracking parameters
- float m_StartTemperature; // Start temperature
- float m_EndTemperature; // End temperature
- unsigned long m_Iterations; // Total number of iterations
- unsigned long m_CurrentStep; // current tracking step
- float m_ParticleWeight; // w (unitless)
- float m_ParticleWidth; // sigma (mm)
- float m_ParticleLength; // l (mm)
- float m_ConnectionPotential; // gross L (chemisches potential, default 10)
- float m_InexBalance; // gewichtung zwischen den lambdas; -5 ... 5 -> nur intern ... nur extern,default 0
- float m_ParticlePotential; // default 0.2
- int m_MinFiberLength; // discard all fibers shortan than the specified length in mm
- bool m_AbortTracking; // set flag to abort tracking
- int m_NumAcceptedFibers; // number of reconstructed fibers generated by the FiberBuilder
- volatile bool m_BuildFibers; // set flag to generate fibers from particle grid
- unsigned int m_Steps; // number of temperature decrease steps
- float m_ProposalAcceptance; // proposal acceptance rate (0-1)
- float m_CurvatureThreshold; // curvature threshold in radians (1 -> no curvature is accepted, -1 all curvature angles are accepted)
- bool m_DuplicateImage; // generates a working copy of the qball image so that the original image won't be changed by the mean subtraction
- int m_NumParticles; // current number of particles in grid
- int m_NumConnections; // current number of connections between particles in grid
- int m_RandomSeed; // seed value for random generator (-1 for standard seeding)
- std::string m_LoadParameterFile; // filename of parameter file (reader)
- std::string m_SaveParameterFile; // filename of parameter file (writer)
- std::string m_LutPath; // path to lookuptables used by the sphere interpolator
- bool m_IsInValidState; // Whether the filter is in a valid state, false if error occured
-
- FiberPolyDataType m_FiberPolyData; // container for reconstructed fibers
+ float m_StartTemperature; ///< Start temperature
+ float m_EndTemperature; ///< End temperature
+ unsigned long m_Iterations; ///< Total number of iterations
+ unsigned long m_CurrentStep; ///< current tracking step
+ float m_ParticleWeight; ///< w (unitless)
+ float m_ParticleWidth; ///< sigma (mm)
+ float m_ParticleLength; ///< l (mm)
+ float m_ConnectionPotential; ///< gross L (chemisches potential, default 10)
+ float m_InexBalance; ///< gewichtung zwischen den lambdas; -5 ... 5 -> nur intern ... nur extern,default 0
+ float m_ParticlePotential; ///< default 0.2
+ int m_MinFiberLength; ///< discard all fibers shortan than the specified length in mm
+ bool m_AbortTracking; ///< set flag to abort tracking
+ int m_NumAcceptedFibers; ///< number of reconstructed fibers generated by the FiberBuilder
+ volatile bool m_BuildFibers; ///< set flag to generate fibers from particle grid
+ unsigned int m_Steps; ///< number of temperature decrease steps
+ float m_ProposalAcceptance; ///< proposal acceptance rate (0-1)
+ float m_CurvatureThreshold; ///< curvature threshold in radians (1 -> no curvature is accepted, -1 all curvature angles are accepted)
+ bool m_DuplicateImage; ///< generates a working copy of the qball image so that the original image won't be changed by the mean subtraction
+ int m_NumParticles; ///< current number of particles in grid
+ int m_NumConnections; ///< current number of connections between particles in grid
+ int m_RandomSeed; ///< seed value for random generator (-1 for standard seeding)
+ std::string m_LoadParameterFile; ///< filename of parameter file (reader)
+ std::string m_SaveParameterFile; ///< filename of parameter file (writer)
+ std::string m_LutPath; ///< path to lookuptables used by the sphere interpolator
+ bool m_IsInValidState; ///< Whether the filter is in a valid state, false if error occured
+
+ FiberPolyDataType m_FiberPolyData; ///< container for reconstructed fibers
//Constant values
static const int m_ParticleGridCellCapacity = 1024;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkGibbsTrackingFilter.cpp"
#endif
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkKspaceImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkKspaceImageFilter.cpp
new file mode 100644
index 0000000000..80faef1148
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkKspaceImageFilter.cpp
@@ -0,0 +1,236 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __itkKspaceImageFilter_txx
+#define __itkKspaceImageFilter_txx
+
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "itkKspaceImageFilter.h"
+#include <itkImageRegionConstIterator.h>
+#include <itkImageRegionConstIteratorWithIndex.h>
+#include <itkImageRegionIterator.h>
+#include <itkImageFileWriter.h>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+namespace itk {
+
+template< class TPixelType >
+KspaceImageFilter< TPixelType >
+::KspaceImageFilter()
+ : m_tLine(1)
+ , m_kOffset(0)
+ , m_FrequencyMap(NULL)
+ , m_SimulateRelaxation(true)
+ , m_SimulateEddyCurrents(false)
+ , m_Tau(70)
+ , m_EddyGradientMagnitude(30)
+ , m_IsBaseline(true)
+ , m_SignalScale(1)
+{
+ m_DiffusionGradientDirection.Fill(0.0);
+}
+
+template< class TPixelType >
+void KspaceImageFilter< TPixelType >
+::BeforeThreadedGenerateData()
+{
+ typename OutputImageType::Pointer outputImage = OutputImageType::New();
+ outputImage->SetSpacing( m_CompartmentImages.at(0)->GetSpacing() );
+ outputImage->SetOrigin( m_CompartmentImages.at(0)->GetOrigin() );
+ outputImage->SetDirection( m_CompartmentImages.at(0)->GetDirection() );
+ itk::ImageRegion<2> region; region.SetSize(0, m_OutSize[0]); region.SetSize(1, m_OutSize[1]);
+ outputImage->SetLargestPossibleRegion( region );
+ outputImage->SetBufferedRegion( region );
+ outputImage->SetRequestedRegion( region );
+ outputImage->Allocate();
+
+ m_TEMPIMAGE = InputImageType::New();
+ m_TEMPIMAGE->SetSpacing( m_CompartmentImages.at(0)->GetSpacing() );
+ m_TEMPIMAGE->SetOrigin( m_CompartmentImages.at(0)->GetOrigin() );
+ m_TEMPIMAGE->SetDirection( m_CompartmentImages.at(0)->GetDirection() );
+ m_TEMPIMAGE->SetLargestPossibleRegion( region );
+ m_TEMPIMAGE->SetBufferedRegion( region );
+ m_TEMPIMAGE->SetRequestedRegion( region );
+ m_TEMPIMAGE->Allocate();
+
+ m_SimulateDistortions = true;
+ if (m_FrequencyMap.IsNull())
+ {
+ m_SimulateDistortions = false;
+ m_FrequencyMap = InputImageType::New();
+ m_FrequencyMap->SetSpacing( m_CompartmentImages.at(0)->GetSpacing() );
+ m_FrequencyMap->SetOrigin( m_CompartmentImages.at(0)->GetOrigin() );
+ m_FrequencyMap->SetDirection( m_CompartmentImages.at(0)->GetDirection() );
+ m_FrequencyMap->SetLargestPossibleRegion( m_CompartmentImages.at(0)->GetLargestPossibleRegion() );
+ m_FrequencyMap->SetBufferedRegion( m_CompartmentImages.at(0)->GetLargestPossibleRegion() );
+ m_FrequencyMap->SetRequestedRegion( m_CompartmentImages.at(0)->GetLargestPossibleRegion() );
+ m_FrequencyMap->Allocate();
+ m_FrequencyMap->FillBuffer(0);
+ }
+
+ double gamma = 42576000; // Gyromagnetic ratio in Hz/T
+ if (m_DiffusionGradientDirection.GetNorm()>0.001)
+ {
+ m_DiffusionGradientDirection.Normalize();
+ m_EddyGradientMagnitude /= 1000; // eddy gradient magnitude in T/m
+ m_DiffusionGradientDirection = m_DiffusionGradientDirection * m_EddyGradientMagnitude * gamma;
+ m_IsBaseline = false;
+ }
+ else
+ m_EddyGradientMagnitude = gamma*m_EddyGradientMagnitude/1000;
+
+ this->SetNthOutput(0, outputImage);
+}
+
+template< class TPixelType >
+void KspaceImageFilter< TPixelType >
+::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType threadId)
+{
+ typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+
+ ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
+
+ typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
+
+ double szx = outputImage->GetLargestPossibleRegion().GetSize(0);
+ double szy = outputImage->GetLargestPossibleRegion().GetSize(1);
+ double numPix = szx*szy;
+ double dt = m_tLine/szx;
+
+ double fromMaxEcho = - m_tLine*szy/2;
+
+ double in_szx = m_CompartmentImages.at(0)->GetLargestPossibleRegion().GetSize(0);
+ double in_szy = m_CompartmentImages.at(0)->GetLargestPossibleRegion().GetSize(1);
+ int xOffset = in_szx-szx;
+ int yOffset = in_szy-szy;
+
+ while( !oit.IsAtEnd() )
+ {
+ itk::Index< 2 > kIdx;
+ kIdx[0] = oit.GetIndex()[0];
+ kIdx[1] = oit.GetIndex()[1];
+
+ double t = fromMaxEcho + ((double)kIdx[1]*szx+(double)kIdx[0])*dt; // dephasing time
+
+ // calculate eddy current decay factors
+ double eddyDecay = 0;
+ if (m_SimulateEddyCurrents)
+ eddyDecay = exp(-(m_TE/2 + t)/m_Tau) * t/1000;
+
+ // calcualte signal relaxation factors
+ std::vector< double > relaxFactor;
+ if (m_SimulateRelaxation)
+ {
+ for (int i=0; i<m_CompartmentImages.size(); i++)
+ relaxFactor.push_back(exp(-(m_TE+t)/m_T2.at(i) -fabs(t)/m_Tinhom));
+ }
+
+ double temp_kx = kIdx[0];
+ if (oit.GetIndex()[1]%2 == 1) // reverse readout direction and add ghosting
+ {
+ kIdx[0] = szx-kIdx[0]-1; // reverse readout direction
+ temp_kx = (double)kIdx[0]-m_kOffset; // add gradient delay induced offset
+ }
+ else
+ temp_kx += m_kOffset; // add gradient delay induced offset
+
+ vcl_complex<double> s(0,0);
+ InputIteratorType it(m_CompartmentImages.at(0), m_CompartmentImages.at(0)->GetLargestPossibleRegion() );
+ while( !it.IsAtEnd() )
+ {
+ double x = it.GetIndex()[0];
+ double y = it.GetIndex()[1];
+
+ vcl_complex<double> f(0, 0);
+
+ // sum compartment signals and simulate relaxation
+ for (int i=0; i<m_CompartmentImages.size(); i++)
+ if (m_SimulateRelaxation)
+ f += std::complex<double>( m_CompartmentImages.at(i)->GetPixel(it.GetIndex()) * relaxFactor.at(i) * m_SignalScale, 0);
+ else
+ f += std::complex<double>( m_CompartmentImages.at(i)->GetPixel(it.GetIndex()) * m_SignalScale );
+
+ // simulate eddy currents and other distortions
+ double omega_t = 0;
+ if ( m_SimulateEddyCurrents )
+ {
+ if (!m_IsBaseline)
+ {
+ itk::Vector< double, 3 > pos; pos[0] = x-szx/2; pos[1] = y-szy/2; pos[2] = m_Z;
+ pos = m_DirectionMatrix*pos/1000; // vector from image center to current position (in meter)
+
+ omega_t += (m_DiffusionGradientDirection[0]*pos[0]+m_DiffusionGradientDirection[1]*pos[1]+m_DiffusionGradientDirection[2]*pos[2])*eddyDecay;
+
+ }
+ else
+ omega_t += m_EddyGradientMagnitude*eddyDecay;
+ }
+ if (m_SimulateDistortions)
+ omega_t += m_FrequencyMap->GetPixel(it.GetIndex())*t/1000;
+
+ // add gibbs ringing offset (cropps k-space)
+ double tempOffsetX = 0;
+ if (temp_kx>=szx/2)
+ tempOffsetX = xOffset;
+ double temp_ky = kIdx[1];
+ if (temp_ky>=szy/2)
+ temp_ky += yOffset;
+
+ // actual DFT term
+ s += f * exp( std::complex<double>(0, 2 * M_PI * ((temp_kx+tempOffsetX)*x/in_szx + temp_ky*y/in_szy) + omega_t ) );
+
+ ++it;
+ }
+
+ s /= numPix;
+
+ /* rearrange slice not needed
+ if( kIdx[0] < szx/2 )
+ kIdx[0] = kIdx[0] + szx/2;
+ else
+ kIdx[0] = kIdx[0] - szx/2;
+
+ if( kIdx[1] < szx/2 )
+ kIdx[1] = kIdx[1] + szy/2;
+ else
+ kIdx[1] = kIdx[1] - szy/2;*/
+
+ m_TEMPIMAGE->SetPixel(kIdx, sqrt(s.real()*s.real()+s.imag()*s.imag()));
+ outputImage->SetPixel(kIdx, s);
+ ++oit;
+ }
+
+// typedef itk::ImageFileWriter< InputImageType > WriterType;
+// typename WriterType::Pointer writer = WriterType::New();
+// writer->SetFileName("/local/kspace.nrrd");
+// writer->SetInput(m_TEMPIMAGE);
+// writer->Update();
+}
+
+template< class TPixelType >
+void KspaceImageFilter< TPixelType >
+::AfterThreadedGenerateData()
+{
+
+}
+
+}
+#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkKspaceImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkKspaceImageFilter.h
new file mode 100644
index 0000000000..01bdb7d9bb
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkKspaceImageFilter.h
@@ -0,0 +1,118 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+/*===================================================================
+
+This file is based heavily on a corresponding ITK filter.
+
+===================================================================*/
+#ifndef __itkKspaceImageFilter_h_
+#define __itkKspaceImageFilter_h_
+
+#include "FiberTrackingExports.h"
+#include <itkImageSource.h>
+#include <vcl_complex.h>
+#include <vector>
+
+namespace itk{
+
+/**
+* \brief Performes deterministic streamline tracking on the input tensor image. */
+
+ template< class TPixelType >
+ class KspaceImageFilter :
+ public ImageSource< Image< vcl_complex< TPixelType >, 2 > >
+ {
+
+ public:
+
+ typedef KspaceImageFilter Self;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+ typedef ImageSource< Image< vcl_complex< TPixelType >, 2 > > Superclass;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self)
+
+ /** Runtime information support. */
+ itkTypeMacro(KspaceImageFilter, ImageToImageFilter)
+
+ typedef typename itk::Image< double, 2 > InputImageType;
+ typedef typename InputImageType::Pointer InputImagePointerType;
+ typedef typename Superclass::OutputImageType OutputImageType;
+ typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
+ typedef itk::Matrix<double, 3, 3> MatrixType;
+
+ itkSetMacro( FrequencyMap, typename InputImageType::Pointer )
+ itkSetMacro( tLine, double )
+ itkSetMacro( kOffset, double )
+ itkSetMacro( TE, double)
+ itkSetMacro( Tinhom, double)
+ itkSetMacro( Tau, double)
+ itkSetMacro( SimulateRelaxation, bool )
+ itkSetMacro( SimulateEddyCurrents, bool )
+ itkSetMacro( Z, double )
+ itkSetMacro( DirectionMatrix, MatrixType )
+ itkSetMacro( SignalScale, double )
+ itkSetMacro( OutSize, itk::Size<2> )
+
+ void SetT2( std::vector< double > t2Vector ) { m_T2=t2Vector; }
+ void SetCompartmentImages( std::vector< InputImagePointerType > cImgs ) { m_CompartmentImages=cImgs; }
+ void SetDiffusionGradientDirection(itk::Vector<double,3> g) { m_DiffusionGradientDirection=g; }
+ void SetEddyGradientMagnitude(double g_mag) { m_EddyGradientMagnitude=g_mag; } ///< in T/m
+
+ protected:
+ KspaceImageFilter();
+ ~KspaceImageFilter() {}
+
+ void BeforeThreadedGenerateData();
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId);
+ void AfterThreadedGenerateData();
+
+ bool m_SimulateRelaxation;
+ bool m_SimulateDistortions;
+ bool m_SimulateEddyCurrents;
+
+ typename InputImageType::Pointer m_TEMPIMAGE;
+ typename InputImageType::Pointer m_FrequencyMap;
+ double m_tLine;
+ double m_kOffset;
+
+ double m_Tinhom;
+ double m_TE;
+ std::vector< double > m_T2;
+ std::vector< InputImagePointerType > m_CompartmentImages;
+ itk::Vector<double,3> m_DiffusionGradientDirection;
+ double m_Tau; ///< eddy current decay constant
+ double m_EddyGradientMagnitude; ///< in T/m
+ double m_Z;
+ MatrixType m_DirectionMatrix;
+ bool m_IsBaseline;
+ double m_SignalScale;
+ itk::Size<2> m_OutSize;
+
+ private:
+
+ };
+
+}
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkKspaceImageFilter.cpp"
+#endif
+
+#endif //__itkKspaceImageFilter_h_
+
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStochasticTractographyFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStochasticTractographyFilter.h
index def7b833a2..d9f5378022 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStochasticTractographyFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStochasticTractographyFilter.h
@@ -1,304 +1,315 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkStochasticTractographyFilter_h__
#define __itkStochasticTractographyFilter_h__
#include "itkImageToImageFilter.h"
#include "vnl/vnl_random.h"
#include "vnl/vnl_vector_fixed.h"
#include "vnl/vnl_matrix.h"
#include "itkArray.h"
#include "itkVectorContainer.h"
#include "vnl/algo/vnl_qr.h"
#include "itkVariableLengthVector.h"
#include "StochasticTracking/itkSlowPolyLineParametricPath.h"
#include "itkSimpleFastMutexLock.h"
#include "itkRealTimeClock.h"
#include "itkDiffusionTensor3D.h"
#include <vector>
namespace itk{
/**
* \brief Performs probabilistic streamline tracking on the input dwi. */
/**Types for Probability Distribution **/
typedef Image< Array< double >, 3 > ProbabilityDistributionImageType;
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage,
class TOutputConnectivityImage >
class ITK_EXPORT StochasticTractographyFilter :
public ImageToImageFilter< TInputDWIImage,
TOutputConnectivityImage >{
public:
typedef StochasticTractographyFilter Self;
typedef ImageToImageFilter< TInputDWIImage,
TOutputConnectivityImage > Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
- itkNewMacro(Self);
+ itkNewMacro(Self)
itkTypeMacro( StochasticTractographyFilter,
- ImageToImageFilter );
+ ImageToImageFilter )
/** Types for the DWI Input Image **/
typedef TInputDWIImage InputDWIImageType;
/** Types for the Connectivity Output Image**/
typedef TOutputConnectivityImage OutputConnectivityImageType;
/** Types for the Mask Image **/
typedef TInputWhiteMatterProbabilityImage InputWhiteMatterProbabilityImageType;
/** Tract Types **/
typedef SlowPolyLineParametricPath< 3 > TractType;
/** Types for the TractContainer **/
typedef VectorContainer< unsigned int, typename TractType::Pointer >
TractContainerType;
/** Types for Tensor Output Image **/
typedef Image< DiffusionTensor3D< double >, 3 > OutputTensorImageType;
/** Types for the Image-wide Magnetic Field Gradient Directions **/
typedef VectorContainer< unsigned int, vnl_vector_fixed< double, 3 > >
GradientDirectionContainerType;
/** Types for the Image-wide bValues **/
typedef double bValueType;
typedef VectorContainer< unsigned int, bValueType > bValueContainerType;
/** Types for the Measurement Frame of the Gradients **/
typedef vnl_matrix_fixed< double, 3, 3 > MeasurementFrameType;
/** Type for the sample directions **/
typedef VectorContainer< unsigned int, vnl_vector_fixed< double, 3 > >
TractOrientationContainerType;
/** the number of Tracts to generate **/
- itkSetMacro( TotalTracts, unsigned int);
- itkGetMacro( TotalTracts, unsigned int);
+ itkSetMacro( TotalTracts, unsigned int)
+ itkGetMacro( TotalTracts, unsigned int)
/** the maximum length of Tract **/
- itkSetMacro( MaxTractLength, unsigned int );
- itkGetMacro( MaxTractLength, unsigned int );
+ itkSetMacro( MaxTractLength, unsigned int )
+ itkGetMacro( MaxTractLength, unsigned int )
/** Set/Get bvalues **/
- itkSetConstObjectMacro( bValues, bValueContainerType );
- itkGetConstObjectMacro( bValues, bValueContainerType );
+ itkSetConstObjectMacro( bValues, bValueContainerType )
+ itkGetConstObjectMacro( bValues, bValueContainerType )
/** Set/Get of gradient directions **/
- itkSetConstObjectMacro( Gradients, GradientDirectionContainerType );
- itkGetConstObjectMacro( Gradients, GradientDirectionContainerType );
+ itkSetConstObjectMacro( Gradients, GradientDirectionContainerType )
+ itkGetConstObjectMacro( Gradients, GradientDirectionContainerType )
/** Set/Get the White Matter Probability Input image **/
/* At each voxel specifies the probability of a mylinated fiber existing
at that location. This probability is interpreted to be the probability
that a fiber tract passes through that region.
*/
- itkSetInputMacro(WhiteMatterProbabilityImage, InputWhiteMatterProbabilityImageType, 1);
- itkGetInputMacro(WhiteMatterProbabilityImage, InputWhiteMatterProbabilityImageType, 1);
+ itkSetInputMacro(WhiteMatterProbabilityImage, InputWhiteMatterProbabilityImageType)
+ itkGetInputMacro(WhiteMatterProbabilityImage, InputWhiteMatterProbabilityImageType)
//overide the built in set input function
//we need to create a new cache everytime we change the input image
//but we need to preserve it when the input image is the same
- void SetInput( typename InputDWIImageType::Pointer dwiimagePtr ){
- Superclass::SetInput( dwiimagePtr );
+ void SetPrimaryInput(DataObject *input)
+ {
+ typename InputDWIImageType::Pointer dwiimagePtr;
+ try
+ {
+ dwiimagePtr = dynamic_cast<InputDWIImageType*>( input );
+ }
+ catch(itk::ExceptionObject &e)
+ {
+ MITK_INFO << "wrong image type: " << e.what();
+ throw;
+ }
+ Superclass::SetPrimaryInput( input );
//update the likelihood cache
this->m_LikelihoodCachePtr = ProbabilityDistributionImageType::New();
this->m_LikelihoodCachePtr->CopyInformation( this->GetInput() );
this->m_LikelihoodCachePtr->SetBufferedRegion( this->GetInput()->GetBufferedRegion() );
this->m_LikelihoodCachePtr->SetRequestedRegion( this->GetInput()->GetRequestedRegion() );
this->m_LikelihoodCachePtr->Allocate();
this->m_CurrentLikelihoodCacheElements = 0;
//update the likelihoodcache mutex image
this->m_LikelihoodCacheMutexImagePtr = LikelihoodCacheMutexImageType::New();
this->m_LikelihoodCacheMutexImagePtr->CopyInformation( this->GetInput() );
this->m_LikelihoodCacheMutexImagePtr->SetBufferedRegion( this->GetInput()->GetBufferedRegion() );
this->m_LikelihoodCacheMutexImagePtr->SetRequestedRegion( this->GetInput()->GetRequestedRegion() );
this->m_LikelihoodCacheMutexImagePtr->Allocate();
}
/** Set/Get the seed index **/
- itkSetMacro( SeedIndex, typename InputDWIImageType::IndexType );
- itkGetMacro( SeedIndex, typename InputDWIImageType::IndexType );
+ itkSetMacro( SeedIndex, typename InputDWIImageType::IndexType )
+ itkGetMacro( SeedIndex, typename InputDWIImageType::IndexType )
/** Set/Get the list of directions to sample **/
- itkSetConstObjectMacro( SampleDirections, TractOrientationContainerType );
- itkGetConstObjectMacro( SampleDirections, TractOrientationContainerType );
+ itkSetConstObjectMacro( SampleDirections, TractOrientationContainerType )
+ itkGetConstObjectMacro( SampleDirections, TractOrientationContainerType )
/** Set/Get the Measurement Frame **/
- itkSetMacro( MeasurementFrame, MeasurementFrameType );
- itkGetMacro( MeasurementFrame, MeasurementFrameType );
+ itkSetMacro( MeasurementFrame, MeasurementFrameType )
+ itkGetMacro( MeasurementFrame, MeasurementFrameType )
/** Set/Get the Maximum Likelihood Cache Size, the max num. of cached voxels **/
- itkSetMacro( MaxLikelihoodCacheSize, unsigned int );
- itkGetMacro( MaxLikelihoodCacheSize, unsigned int );
+ itkSetMacro( MaxLikelihoodCacheSize, unsigned int )
+ itkGetMacro( MaxLikelihoodCacheSize, unsigned int )
/** Get the Tracts that are generated **/
- itkGetObjectMacro( OutputTractContainer, TractContainerType );
+ itkGetObjectMacro( OutputTractContainer, TractContainerType )
/** Get TensorImage **/
- itkGetObjectMacro( OutputTensorImage, OutputTensorImageType );
+ itkGetObjectMacro( OutputTensorImage, OutputTensorImageType )
void GenerateData();
void GenerateTractContainerOutput( void );
void GenerateTensorImageOutput( void );
protected:
/** Convenience Types used only inside the filter **/
/**Types for the parameters of the Tensor Model **/
typedef vnl_vector_fixed< double, 7 > TensorModelParamType;
/**Types for the parameters of the Constrained Model **/
typedef vnl_vector_fixed< double, 6 > ConstrainedModelParamType;
/**Type to hold generated DWI values**/
typedef Image< VariableLengthVector< double >, 3 > DWIVectorImageType;
/**Types for Probability Distribution **/
typedef Image< Array< double >, 3 > ProbabilityDistributionImageType;
/** Types for the Image of Mutexes of the Likelihood distribution **/
typedef Image< SimpleFastMutexLock, 3 > LikelihoodCacheMutexImageType;
StochasticTractographyFilter();
virtual ~StochasticTractographyFilter();
/** Load the default Sample Directions**/
void LoadDefaultSampleDirections( void );
/** Randomly chose a neighboring pixel weighted on distance **/
void ProbabilisticallyInterpolate( vnl_random& randomgenerator,
const TractType::ContinuousIndexType& cindex,
typename InputDWIImageType::IndexType& index);
/** Functions and data related to fitting the tensor model at each pixel **/
void UpdateGradientDirections(void);
void UpdateTensorModelFittingMatrices( void );
void CalculateTensorModelParameters( const DWIVectorImageType::PixelType& dwivalues,
vnl_diag_matrix<double>& W,
TensorModelParamType& tensormodelparams);
void CalculateConstrainedModelParameters( const TensorModelParamType& tensormodelparams,
ConstrainedModelParamType& constrainedmodelparams);
void CalculateNoiseFreeDWIFromConstrainedModel( const ConstrainedModelParamType& constrainedmodelparams,
DWIVectorImageType::PixelType& noisefreedwi);
void CalculateResidualVariance( const DWIVectorImageType::PixelType& noisydwi,
const DWIVectorImageType::PixelType& noisefreedwi,
const vnl_diag_matrix< double >& W,
const unsigned int numberofparameters,
double& residualvariance);
void CalculateLikelihood( const DWIVectorImageType::PixelType &dwipixel,
TractOrientationContainerType::ConstPointer orientations,
ProbabilityDistributionImageType::PixelType& likelihood);
void CalculatePrior( TractOrientationContainerType::Element v_prev,
TractOrientationContainerType::ConstPointer orientations,
ProbabilityDistributionImageType::PixelType& prior );
void CalculatePosterior( const ProbabilityDistributionImageType::PixelType& likelihood,
const ProbabilityDistributionImageType::PixelType& prior,
ProbabilityDistributionImageType::PixelType& posterior);
void SampleTractOrientation( vnl_random& randomgenerator,
const ProbabilityDistributionImageType::PixelType& posterior,
TractOrientationContainerType::ConstPointer orientations,
TractOrientationContainerType::Element& choosendirection );
void StochasticTractGeneration( typename InputDWIImageType::ConstPointer dwiimagePtr,
typename InputWhiteMatterProbabilityImageType::ConstPointer maskimagePtr,
typename InputDWIImageType::IndexType seedindex,
unsigned long randomseed,
TractType::Pointer tract );
/** Callback routine used by the threading library. This routine just calls
the ThreadedGenerateData method after setting the correct region for this
thread. **/
static ITK_THREAD_RETURN_TYPE StochasticTractGenerationCallback( void *arg );
struct StochasticTractGenerationCallbackStruct{
Pointer Filter;
};
/** Thread Safe Function to check/update an entry in the likelihood cache **/
ProbabilityDistributionImageType::PixelType&
AccessLikelihoodCache( typename InputDWIImageType::IndexType index );
/** Thread Safe Function to delegate a tract and obtain a randomseed to start tracking **/
bool DelegateTract(unsigned long& randomseed);
/** Function to write a tract to the connectivity map **/
void TractContainerToConnectivityMap(TractContainerType::Pointer tractcontainer);
/** Thread Safe Function to store a tract to a TractContainer **/
void StoreTract(TractType::Pointer tract);
/** Randomly samples the existence of a fiber tract in the current voxel **/
bool FiberExistenceTest( vnl_random& randomgenerator,
typename InputWhiteMatterProbabilityImageType::ConstPointer wmpimage,
typename InputWhiteMatterProbabilityImageType::IndexType index );
MeasurementFrameType m_MeasurementFrame;
LikelihoodCacheMutexImageType::Pointer m_LikelihoodCacheMutexImagePtr;
unsigned int m_TotalTracts;
unsigned int m_MaxTractLength;
GradientDirectionContainerType::ConstPointer m_Gradients;
GradientDirectionContainerType::Pointer m_TransformedGradients;
bValueContainerType::ConstPointer m_bValues;
typename InputDWIImageType::IndexType m_SeedIndex;
TractOrientationContainerType::ConstPointer m_SampleDirections;
//these will be the same for every pixel in the image so
//go ahead and do a QR decomposition to optimize the
//LS fitting process for estimating the weighing matrix W
//in this case we solve instead:
//R*Beta = Q'logPhi
vnl_matrix< double >* m_A;
vnl_qr< double >* m_Aqr;
ProbabilityDistributionImageType::Pointer m_LikelihoodCachePtr;
unsigned long m_MaxLikelihoodCacheSize; //in Megabytes
unsigned long m_MaxLikelihoodCacheElements; //in Elements (Voxels)
unsigned long m_CurrentLikelihoodCacheElements;
SimpleFastMutexLock m_LikelihoodCacheMutex;
RealTimeClock::Pointer m_ClockPtr;
unsigned int m_TotalDelegatedTracts;
SimpleFastMutexLock m_TotalDelegatedTractsMutex;
//unsigned long m_RandomSeed;
SimpleFastMutexLock m_OutputImageMutex;
TractContainerType::Pointer m_OutputTractContainer;
SimpleFastMutexLock m_OutputTractContainerMutex;
OutputTensorImageType::Pointer m_OutputTensorImage;
vnl_random m_RandomGenerator;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkStochasticTractographyFilter.txx"
#include "StochasticTracking/itkStochasticTractographyFilter_SD.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStochasticTractographyFilter.txx b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStochasticTractographyFilter.txx
index ce708f98c4..fd2b9670a9 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStochasticTractographyFilter.txx
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStochasticTractographyFilter.txx
@@ -1,700 +1,700 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "itkStochasticTractographyFilter.h"
#include "vnl/vnl_math.h"
#include "vnl/vnl_matrix_fixed.h"
#include "vnl/vnl_vector_fixed.h"
#include "vnl/vnl_matrix.h"
#include "vnl/vnl_sym_matrix.h"
#include "vnl/vnl_vector.h"
#include "vnl/vnl_diag_matrix.h"
#include "vnl/algo/vnl_qr.h"
//#include "vnl/algo/vnl_svd.h"
#include "vnl/algo/vnl_matrix_inverse.h"
//#include "vnl/algo/vnl_symmetric_eigensystem.h"
#include "itkSymmetricEigenAnalysis.h"
#include "vnl/vnl_transpose.h"
#include "itkVariableSizeMatrix.h"
#include "itkPathIterator.h"
#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionConstIteratorWithIndex.h"
namespace itk{
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::StochasticTractographyFilter():
m_TotalTracts(0),m_MaxTractLength(0),m_Gradients(NULL), m_TransformedGradients(NULL),m_bValues(NULL),
m_SampleDirections(NULL), m_A(NULL), m_Aqr(NULL), m_LikelihoodCachePtr(NULL),
m_MaxLikelihoodCacheSize(0), m_CurrentLikelihoodCacheElements(0),
m_ClockPtr(NULL), m_TotalDelegatedTracts(0), m_OutputTractContainer(NULL){
this->m_SeedIndex[0]=0;
this->m_SeedIndex[1]=0;
this->m_SeedIndex[2]=0;
this->m_MeasurementFrame.set_identity();
- this->SetNumberOfRequiredInputs(2); //Filter needs a DWI image and a Mask Image
+ this->SetNumberOfRequiredInputs(1); //Filter needs a DWI image and a Mask Image, but check will be outside itkProcessObject and inside GenerateData()
m_ClockPtr = RealTimeClock::New();
- this->m_RandomGenerator.reseed( ((unsigned long) this->m_ClockPtr->GetTimeStamp()) );
+ this->m_RandomGenerator.reseed( ((unsigned long) this->m_ClockPtr->GetTimeInSeconds()) );
//load in default sample directions
this->LoadDefaultSampleDirections();
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::~StochasticTractographyFilter(){
delete this->m_A;
delete this->m_Aqr;
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::ProbabilisticallyInterpolate( vnl_random& randomgenerator,
const TractType::ContinuousIndexType& cindex,
typename InputDWIImageType::IndexType& index){
for(int i=0; i<3; i++){
if ((vcl_ceil(cindex[i]+vnl_math::eps)-cindex[i]) < randomgenerator.drand64())
index[i]=(int)vcl_ceil(cindex[i]);
else index[i]=(int)vcl_floor(cindex[i]);
}
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::UpdateGradientDirections(void){
//the gradient direction is transformed into IJK space
//by moving into the image space and then to IJK space
this->m_TransformedGradients = GradientDirectionContainerType::New();
unsigned int N = this->m_Gradients->Size();
for(unsigned int i=0; i<N; i++){
GradientDirectionContainerType::Element g_i =
this->m_MeasurementFrame *
this->m_Gradients->GetElement(i);
/** The correction to LPS space is not neccessary as of itk 3.2 **/
//g_i[0] = -g_i[0];
//g_i[1] = -g_i[1];
g_i = this->GetInput()->GetDirection().GetInverse() * g_i;
this->m_TransformedGradients->InsertElement(i, g_i);
}
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::UpdateTensorModelFittingMatrices( void ){
//std::cout<<"UpdateTensorFittingMatrix\n";
//estimate the parameters using linear LS estimation
//using convention specified by Salvador
//solve for Beta in: logPhi=X*Beta
//number of rows of the matrix depends on the number of inputs,
//i.e. the number of measurements of the voxel (n)
unsigned int N = this->m_TransformedGradients->Size();
if(this->m_A!=NULL)
delete this->m_A;
this->m_A = new vnl_matrix< double >(N, 7); //potential memory leak here
vnl_matrix< double >& A = *(this->m_A);
for(unsigned int j=0; j< N ; j++){
GradientDirectionContainerType::Element g = m_TransformedGradients->GetElement(j);
const bValueType& b_i = m_bValues->GetElement(j);
A(j,0)=1.0;
A(j,1)=-1*b_i*(g[0]*g[0]);
A(j,2)=-1*b_i*(g[1]*g[1]);
A(j,3)=-1*b_i*(g[2]*g[2]);
A(j,4)=-1*b_i*(2*g[0]*g[1]);
A(j,5)=-1*b_i*(2*g[0]*g[2]);
A(j,6)=-1*b_i*(2*g[1]*g[2]);
}
//Store a QR decomposition to quickly estimate
//the weighing matrix for each voxel
if(this->m_Aqr!=NULL)
delete this->m_Aqr;
this->m_Aqr = new vnl_qr< double >(A); //potential memory leak here
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::CalculateTensorModelParameters( const DWIVectorImageType::PixelType& dwivalues,
vnl_diag_matrix<double>& W,
TensorModelParamType& tensormodelparams){
unsigned int N = this->m_TransformedGradients->Size();
//setup const references for code clarity
const vnl_matrix< double >& A = *(this->m_A);
const vnl_qr< double >& Aqr = *(this->m_Aqr);
//vnl_vector is used because the itk vector is limited in its methods and does not
//contain an internal vnl class like VariableSizematrix
//also itk_matrix has methods which are compatible with vnl_vectors
vnl_vector< double > logPhi( N );
for(unsigned int j=0; j< N ; j++){
//fill up the logPhi vector using log(dwi) values
logPhi.put(j, vcl_log(static_cast<double>(dwivalues[j]) + vnl_math::eps));
}
/** Find WLS estimate of the parameters of the Tensor model **/
// First estimate W by LS estimation of the intensities
//vnl_matrix< double > Q = Aqr.Q();
//vnl_vector< double > QtB = Aqr.Q().transpose()*logPhi;
//vnl_vector< double > QTB = Aqr.QtB(logPhi);
//vnl_matrix< double > R = Aqr.R();
W = A* vnl_qr< double >(Aqr.R()).solve(Aqr.QtB(logPhi));
//W = A * Aqr.solve(logPhi);
for(vnl_diag_matrix< double >::iterator i = W.begin();i!=W.end(); i++){
*i = vcl_exp( *i );
}
// Now solve for parameters using the estimated weighing matrix
tensormodelparams = vnl_qr< double >((W*A).transpose()*W*A).solve(
(W*A).transpose()*W*logPhi);
//int a;
//tensormodelparams = vnl_qr< double >((W*A)).solve(W*logPhi);
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::CalculateConstrainedModelParameters( const TensorModelParamType& tensormodelparams,
ConstrainedModelParamType& constrainedmodelparams){
vnl_sym_matrix< double > D( 3, 0 );
double alpha =0;
double beta=0;
//set the tensor model parameters into a Diffusion tensor
D(0,0) = tensormodelparams[1];
D(0,1) = tensormodelparams[4];
D(0,2) = tensormodelparams[5];
D(1,0) = tensormodelparams[4];
D(1,1) = tensormodelparams[2];
D(1,2) = tensormodelparams[6];
D(2,0) = tensormodelparams[5];
D(2,1) = tensormodelparams[6];
D(2,2) = tensormodelparams[3];
//pass through the no gradient intensity Z_0 and
//calculate alpha, beta and v hat (the eigenvector
//associated with the largest eigenvalue)
vnl_matrix_fixed< double, 3, 3 > S(0.0);
vnl_vector_fixed< double, 3 > Lambda(0.0);
SymmetricEigenAnalysis< vnl_sym_matrix< double >,
vnl_vector_fixed< double, 3 >, vnl_matrix_fixed< double, 3, 3 > >
eigensystem( 3 );
eigensystem.ComputeEigenValuesAndVectors( D, Lambda, S );
//need to take abs to get rid of negative eigenvalues
alpha = (vcl_abs(Lambda[0]) + vcl_abs(Lambda[1])) / 2;
beta = vcl_abs(Lambda[2]) - alpha;
constrainedmodelparams[0] = tensormodelparams[0];
constrainedmodelparams[1] = alpha;
constrainedmodelparams[2] = beta;
constrainedmodelparams[3] = S[2][0];
constrainedmodelparams[4] = S[2][1];
constrainedmodelparams[5] = S[2][2];
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::CalculateNoiseFreeDWIFromConstrainedModel( const ConstrainedModelParamType& constrainedmodelparams,
DWIVectorImageType::PixelType& noisefreedwi){
unsigned int N = this->m_TransformedGradients->Size();
const double& z_0 = constrainedmodelparams[0];
const double& alpha = constrainedmodelparams[1];
const double& beta = constrainedmodelparams[2];
TractOrientationContainerType::Element v_hat( constrainedmodelparams[3],
constrainedmodelparams[4],
constrainedmodelparams[5]);
for(unsigned int i=0; i < N ; i++ ){
const double& b_i = this->m_bValues->GetElement(i);
const GradientDirectionContainerType::Element& g_i =
this->m_TransformedGradients->GetElement(i);
noisefreedwi.SetElement(i,
vcl_exp(z_0-(alpha*b_i+beta*b_i*vnl_math_sqr(dot_product(g_i, v_hat)))));
}
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::CalculateResidualVariance( const DWIVectorImageType::PixelType& noisydwi,
const DWIVectorImageType::PixelType& noisefreedwi,
const vnl_diag_matrix< double >& W,
const unsigned int numberofparameters,
double& residualvariance){
unsigned int N = this->m_TransformedGradients->Size();
residualvariance=0;
/** Not sure if we should be taking difference of log or nonlog intensities **/
/** residual variance is too low if we take the difference of log intensities **/
/** perhaps using WLS will correct this problem **/
for(unsigned int i=0; i<N; i++)
residualvariance+=vnl_math_sqr(W(i,i) * (vcl_log(noisydwi[i]/noisefreedwi[i])));
residualvariance/=(N-numberofparameters);
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::CalculateLikelihood( const DWIVectorImageType::PixelType &dwipixel,
TractOrientationContainerType::ConstPointer orientations,
ProbabilityDistributionImageType::PixelType& likelihood){
unsigned int N = this->m_TransformedGradients->Size();
TensorModelParamType tensorparams( 0.0 );
vnl_diag_matrix< double > W(N,0);
ConstrainedModelParamType constrainedparams( 0.0 );
DWIVectorImageType::PixelType noisefreedwi(N);
double residualvariance=0;
double jointlikelihood=1;
CalculateTensorModelParameters( dwipixel, W, tensorparams );
CalculateConstrainedModelParameters( tensorparams, constrainedparams );
CalculateNoiseFreeDWIFromConstrainedModel( constrainedparams, noisefreedwi );
CalculateResidualVariance( dwipixel, noisefreedwi, W, 6, residualvariance );
for(unsigned int i=0; i < orientations->Size(); i++){
/** Vary the entry corresponding to the estimated
Tract orientation over the selected sample directions,
while preserving the best estimate for the other parameters **/
TractOrientationContainerType::Element currentdir = orientations->GetElement(i);
/** Incorporate the current sample direction into the secondary parameters **/
constrainedparams[3]=currentdir[0];
constrainedparams[4]=currentdir[1];
constrainedparams[5]=currentdir[2];
/** Obtain the estimated
intensity for this choice of Tract direction **/
CalculateNoiseFreeDWIFromConstrainedModel(constrainedparams, noisefreedwi);
jointlikelihood = 1.0;
for(unsigned int j=0; j<N; j++){
/** Calculate the likelihood given the residualvariance,
estimated intensity and the actual intensity (refer to Friman) **/
jointlikelihood *=
(noisefreedwi[j]/vcl_sqrt(2*vnl_math::pi*residualvariance))*
vcl_exp(-vnl_math_sqr(noisefreedwi[j]*vcl_log(dwipixel[j]/noisefreedwi[j]))/
(2*residualvariance));
}
likelihood[i]=jointlikelihood;
}
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::CalculatePrior( TractOrientationContainerType::Element v_prev,
TractOrientationContainerType::ConstPointer orientations,
ProbabilityDistributionImageType::PixelType& prior ){
const double gamma = 1;
for(unsigned int i=0; i < orientations->Size(); i++){
if(v_prev.squared_magnitude()==0){
prior[i]=1.0;
}
else{
prior[i] = dot_product(orientations->GetElement(i),v_prev);;
if(prior[i]<0){
prior[i]=0;
}
else{
prior[i]=vcl_pow(prior[i],gamma);
}
}
}
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::CalculatePosterior( const ProbabilityDistributionImageType::PixelType& likelihood,
const ProbabilityDistributionImageType::PixelType& prior,
ProbabilityDistributionImageType::PixelType& posterior){
double sum=0;
for(unsigned int i=0; i<likelihood.Size(); i++){
sum+=likelihood[i]*prior[i];
}
for(unsigned int i=0; i<likelihood.Size(); i++){
posterior[i] = (likelihood[i]*prior[i])/sum;
}
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::SampleTractOrientation( vnl_random& randomgenerator,
const ProbabilityDistributionImageType::PixelType& posterior,
TractOrientationContainerType::ConstPointer orientations,
TractOrientationContainerType::Element& choosendirection ){
double randomnum = randomgenerator.drand64();
int i=0;
double cumsum=0;
//will crash in the unlikely case that 0 was choosen as the randomnum
while(cumsum < randomnum){
cumsum+=posterior[i];
i++;
}
choosendirection = orientations->GetElement(i-1);
//std::cout<< "cumsum: " << cumsum<<std::endl;
//std::cout<<"selected orientation:( " << (i-1)
// <<") "<<choosendirection<< std::endl;
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
bool
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::FiberExistenceTest( vnl_random& randomgenerator,
typename InputWhiteMatterProbabilityImageType::ConstPointer wmpimage,
typename InputWhiteMatterProbabilityImageType::IndexType index ){
double randomnum = randomgenerator.drand64();
if( randomnum < wmpimage->GetPixel( index ) )
return true;
else
return false;
}
//the seedindex is in continuous IJK coordinates
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::StochasticTractGeneration( typename InputDWIImageType::ConstPointer dwiimagePtr,
typename InputWhiteMatterProbabilityImageType::ConstPointer wmpimagePtr,
typename InputDWIImageType::IndexType seedindex,
unsigned long randomseed,
TractType::Pointer tract){
TractType::ContinuousIndexType cindex_curr = seedindex;
typename InputDWIImageType::IndexType index_curr = {{0,0,0}};
ProbabilityDistributionImageType::PixelType
prior_curr(this->m_SampleDirections->Size());
ProbabilityDistributionImageType::PixelType
posterior_curr(this->m_SampleDirections->Size());
TractOrientationContainerType::Element v_curr(0,0,0);
TractOrientationContainerType::Element v_prev(0,0,0);
tract->Initialize();
vnl_random randomgenerator(randomseed);
//std::cout<<randomseed<<std::endl;
for(unsigned int j=0; j<this->m_MaxTractLength; j++){
this->ProbabilisticallyInterpolate( randomgenerator, cindex_curr, index_curr );
if(!dwiimagePtr->GetLargestPossibleRegion().IsInside(index_curr)){
break;
}
if( FiberExistenceTest( randomgenerator, wmpimagePtr, index_curr ) ){
tract->AddVertex(cindex_curr);
this->CalculatePrior( v_prev, this->m_SampleDirections, prior_curr);
const ProbabilityDistributionImageType::PixelType&
cachelikelihood_curr = this->AccessLikelihoodCache(index_curr);
if( cachelikelihood_curr.GetSize() != 0){
//use the cached direction
this->CalculatePosterior( cachelikelihood_curr, prior_curr, posterior_curr);
}
else{
//do the likelihood calculation and discard
//std::cout<<"Cache Miss!\n";
ProbabilityDistributionImageType::PixelType
likelihood_curr_temp(this->m_SampleDirections->Size());
this->CalculateLikelihood(static_cast< DWIVectorImageType::PixelType >(
dwiimagePtr->GetPixel(index_curr)),
this->m_SampleDirections,
likelihood_curr_temp);
this->CalculatePosterior( likelihood_curr_temp, prior_curr, posterior_curr);
}
this->SampleTractOrientation(randomgenerator, posterior_curr,
this->m_SampleDirections, v_curr);
//takes into account voxels of different sizes
//converts from a step length of 1 mm to the corresponding length in IJK space
const typename InputDWIImageType::SpacingType& spacing = dwiimagePtr->GetSpacing();
cindex_curr[0]+=v_curr[0]/spacing[0];
cindex_curr[1]+=v_curr[1]/spacing[1];
cindex_curr[2]+=v_curr[2]/spacing[2];
v_prev=v_curr;
}
else{
//fiber doesn't exist in this voxel
//std::cout<<"Stopped Tracking: No Fiber in this Voxel\n";
break;
}
}
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::GenerateTractContainerOutput(){
//allocate tractcontainer
this->m_OutputTractContainer = TractContainerType::New();
this->UpdateGradientDirections();
this->UpdateTensorModelFittingMatrices();
this->m_TotalDelegatedTracts = 0;
//calculate the number of voxels to cache from Megabyte memory size limit
ProbabilityDistributionImageType::PixelType
element(this->GetSampleDirections()->Size());
unsigned long elementsize = sizeof(ProbabilityDistributionImageType::PixelType) +
sizeof(double)*element.Size();
this->m_MaxLikelihoodCacheElements =
(this->m_MaxLikelihoodCacheSize*1048576)/elementsize;
std::cout << "MaxLikelhoodCacheElements: "
<< this->m_MaxLikelihoodCacheElements
<< std::endl;
//setup the multithreader
StochasticTractGenerationCallbackStruct data;
data.Filter = this;
this->GetMultiThreader()->SetSingleMethod( StochasticTractGenerationCallback,
&data );
this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads());
std::cout<<"Number of Threads: " << this->GetMultiThreader()->GetNumberOfThreads() << std::endl;
//start the multithreaded execution
this->GetMultiThreader()->SingleMethodExecute();
std::cout<< "CurrentLikelihoodCacheElements: " <<
this->m_CurrentLikelihoodCacheElements << std::endl;
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::GenerateData(){
//Generate the tracts
this->GenerateTractContainerOutput();
//allocate outputs
this->AllocateOutputs();
//write tracts to output image
this->TractContainerToConnectivityMap(this->m_OutputTractContainer);
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
ITK_THREAD_RETURN_TYPE
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::StochasticTractGenerationCallback( void *arg )
{
StochasticTractGenerationCallbackStruct* str=
(StochasticTractGenerationCallbackStruct *)
(((MultiThreader::ThreadInfoStruct *)(arg))->UserData);
typename InputDWIImageType::ConstPointer inputDWIImagePtr = str->Filter->GetInput();
typename InputWhiteMatterProbabilityImageType::ConstPointer inputWMPImage =
- str->Filter->GetWhiteMatterProbabilityImageInput();
+ str->Filter->GetWhiteMatterProbabilityImage();
unsigned long randomseed=0;
while(str->Filter->DelegateTract(randomseed)){
//std::cout<<randomseed<<std::endl;
//generate the tract
TractType::Pointer tract = TractType::New();
str->Filter->StochasticTractGeneration( inputDWIImagePtr,
inputWMPImage,
str->Filter->GetSeedIndex(),
randomseed,
tract);
//only store tract if it is of nonzero length
if( tract->GetVertexList()->Size() > 4 ){
//std::cout<<"Storing tract\n";
str->Filter->StoreTract(tract);
}
else{
//std::cout<<"Not Storing Tract\n";
}
}
return ITK_THREAD_RETURN_VALUE;
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
ProbabilityDistributionImageType::PixelType&
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::AccessLikelihoodCache( typename InputDWIImageType::IndexType index )
{
this->m_LikelihoodCacheMutexImagePtr->GetPixel(index).Lock();
ProbabilityDistributionImageType::PixelType& likelihood =
m_LikelihoodCachePtr->GetPixel( index );
typename InputDWIImageType::ConstPointer inputDWIImagePtr = this->GetInput();
if( likelihood.GetSize() !=0){
//entry found in cache
this->m_LikelihoodCacheMutexImagePtr->GetPixel(index).Unlock();
return likelihood;
}
//we need to lock m_CurrentLikelihoodCacheElements as well but not crucial right now
else if( this->m_CurrentLikelihoodCacheElements < this->m_MaxLikelihoodCacheElements ){
//entry not found in cache but we have space to store it
likelihood.SetSize(this->m_SampleDirections->Size());
this->CalculateLikelihood(static_cast< DWIVectorImageType::PixelType >(
inputDWIImagePtr->GetPixel(index)),
this->m_SampleDirections,
likelihood);
this->m_CurrentLikelihoodCacheElements++;
this->m_LikelihoodCacheMutexImagePtr->GetPixel(index).Unlock();
return likelihood;
}
else{
//entry not found in cache and no space to store it
this->m_LikelihoodCacheMutexImagePtr->GetPixel(index).Unlock();
return likelihood;
}
this->m_LikelihoodCacheMutexImagePtr->GetPixel(index).Unlock();
// dummy
return likelihood;
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
bool
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::DelegateTract(unsigned long& randomseed){
bool success = false;
this->m_TotalDelegatedTractsMutex.Lock();
if(this->m_TotalDelegatedTracts < this->m_TotalTracts){
randomseed = this->m_RandomGenerator.lrand32();
this->m_TotalDelegatedTracts++;
success = true;
//a tract was successfully delegated
}
else success = false; //all tracts have been delegated
this->m_TotalDelegatedTractsMutex.Unlock();
return success;
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::TractContainerToConnectivityMap(TractContainerType::Pointer tractcontainer){
//zero the output image
typename OutputConnectivityImageType::Pointer outputPtr = this->GetOutput();
outputPtr->FillBuffer(0);
typedef PathIterator< OutputConnectivityImageType, TractType > OutputTractIteratorType;
for(unsigned int i=0; i<tractcontainer->Size(); i++ ){
TractType::Pointer tract = tractcontainer->GetElement(i);
//std::cout<< tract->EndOfInput() <<std::endl;
OutputTractIteratorType outputtractIt( outputPtr,
tract );
for(outputtractIt.GoToBegin(); !outputtractIt.IsAtEnd(); ++outputtractIt){
/* there is an issue using outputtractIt.Value() */
// outputtractIt.Set(outputtractIt.Get()+1);
}
}
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::StoreTract(TractType::Pointer tract){
this->m_OutputTractContainerMutex.Lock();
this->m_OutputTractContainer->InsertElement(
this->m_OutputTractContainer->Size(),
tract);
this->m_OutputTractContainerMutex.Unlock();
}
template< class TInputDWIImage, class TInputWhiteMatterProbabilityImage, class TOutputConnectivityImage >
void
StochasticTractographyFilter< TInputDWIImage, TInputWhiteMatterProbabilityImage, TOutputConnectivityImage >
::GenerateTensorImageOutput(void){
this->UpdateGradientDirections();
this->UpdateTensorModelFittingMatrices();
//allocate the tensor image
this->m_OutputTensorImage = OutputTensorImageType::New();
m_OutputTensorImage->CopyInformation( this->GetInput() );
m_OutputTensorImage->SetBufferedRegion( this->GetInput()->GetBufferedRegion() );
m_OutputTensorImage->SetRequestedRegion( this->GetInput()->GetRequestedRegion() );
m_OutputTensorImage->Allocate();
//define an iterator for the input and output images
typedef itk::ImageRegionConstIterator< InputDWIImageType > DWIImageIteratorType;
typedef itk::ImageRegionIterator< OutputTensorImageType > TensorImageIteratorType;
DWIImageIteratorType
inputDWIit( this->GetInput(), m_OutputTensorImage->GetRequestedRegion() );
TensorImageIteratorType outputtensorit
( m_OutputTensorImage, m_OutputTensorImage->GetRequestedRegion() );
unsigned int N = this->m_TransformedGradients->Size();
TensorModelParamType tensormodelparams( 0.0 );
vnl_diag_matrix< double > W(N,0);
for(inputDWIit.GoToBegin(), outputtensorit.GoToBegin();
!outputtensorit.IsAtEnd(); ++inputDWIit, ++outputtensorit){
CalculateTensorModelParameters( inputDWIit.Get(),
W, tensormodelparams);
OutputTensorImageType::PixelType& D = outputtensorit.Value();
//set the tensor model parameters into a Diffusion tensor
D(0,0) = tensormodelparams[1];
D(0,1) = tensormodelparams[4];
D(0,2) = tensormodelparams[5];
D(1,0) = tensormodelparams[4];
D(1,1) = tensormodelparams[2];
D(1,2) = tensormodelparams[6];
D(2,0) = tensormodelparams[5];
D(2,1) = tensormodelparams[6];
D(2,2) = tensormodelparams[3];
//std::cout<<D;
}
}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
index 98fe69be9c..b6f405949d 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
@@ -1,720 +1,720 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkStreamlineTrackingFilter_txx
#define __itkStreamlineTrackingFilter_txx
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkStreamlineTrackingFilter.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#define _USE_MATH_DEFINES
#include <math.h>
namespace itk {
//#define QBALL_RECON_PI M_PI
template< class TTensorPixelType, class TPDPixelType>
StreamlineTrackingFilter< TTensorPixelType,
TPDPixelType>
::StreamlineTrackingFilter():
m_FaThreshold(0.2),
m_StepSize(1),
m_MaxLength(10000),
m_SeedsPerVoxel(1),
m_F(1.0),
m_G(0.0),
m_Interpolate(true),
m_MinTractLength(0.0)
{
// At least 1 inputs is necessary for a vector image.
// For images added one at a time we need at least six
this->SetNumberOfRequiredInputs( 1 );
}
template< class TTensorPixelType,
class TPDPixelType>
double StreamlineTrackingFilter< TTensorPixelType,
TPDPixelType>
::RoundToNearest(double num) {
return (num > 0.0) ? floor(num + 0.5) : ceil(num - 0.5);
}
template< class TTensorPixelType,
class TPDPixelType>
void StreamlineTrackingFilter< TTensorPixelType,
TPDPixelType>
::BeforeThreadedGenerateData()
{
m_FiberPolyData = FiberPolyDataType::New();
m_Points = vtkPoints::New();
m_Cells = vtkCellArray::New();
m_InputImage = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
m_ImageSize.resize(3);
m_ImageSize[0] = m_InputImage->GetLargestPossibleRegion().GetSize()[0];
m_ImageSize[1] = m_InputImage->GetLargestPossibleRegion().GetSize()[1];
m_ImageSize[2] = m_InputImage->GetLargestPossibleRegion().GetSize()[2];
if (m_ImageSize[0]<3 || m_ImageSize[1]<3 || m_ImageSize[2]<3)
m_Interpolate = false;
m_ImageSpacing.resize(3);
m_ImageSpacing[0] = m_InputImage->GetSpacing()[0];
m_ImageSpacing[1] = m_InputImage->GetSpacing()[1];
m_ImageSpacing[2] = m_InputImage->GetSpacing()[2];
float minSpacing;
if(m_ImageSpacing[0]<m_ImageSpacing[1] && m_ImageSpacing[0]<m_ImageSpacing[2])
minSpacing = m_ImageSpacing[0];
else if (m_ImageSpacing[1] < m_ImageSpacing[2])
minSpacing = m_ImageSpacing[1];
else
minSpacing = m_ImageSpacing[2];
if (m_StepSize<0.1*minSpacing)
{
m_StepSize = 0.1*minSpacing;
m_PointPistance = 0.5*minSpacing;
}
m_PolyDataContainer = itk::VectorContainer< int, FiberPolyDataType >::New();
for (int i=0; i<this->GetNumberOfThreads(); i++)
{
FiberPolyDataType poly = FiberPolyDataType::New();
m_PolyDataContainer->InsertElement(i, poly);
}
if (m_SeedImage.IsNull())
{
// initialize mask image
m_SeedImage = ItkUcharImgType::New();
m_SeedImage->SetSpacing( m_InputImage->GetSpacing() );
m_SeedImage->SetOrigin( m_InputImage->GetOrigin() );
m_SeedImage->SetDirection( m_InputImage->GetDirection() );
m_SeedImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
m_SeedImage->Allocate();
m_SeedImage->FillBuffer(1);
}
if (m_MaskImage.IsNull())
{
// initialize mask image
m_MaskImage = ItkUcharImgType::New();
m_MaskImage->SetSpacing( m_InputImage->GetSpacing() );
m_MaskImage->SetOrigin( m_InputImage->GetOrigin() );
m_MaskImage->SetDirection( m_InputImage->GetDirection() );
m_MaskImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1);
}
m_FaImage = ItkFloatImgType::New();
m_FaImage->SetSpacing( m_InputImage->GetSpacing() );
m_FaImage->SetOrigin( m_InputImage->GetOrigin() );
m_FaImage->SetDirection( m_InputImage->GetDirection() );
m_FaImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
m_FaImage->Allocate();
m_FaImage->FillBuffer(0.0);
m_PdImage = ItkPDImgType::New();
m_PdImage->SetSpacing( m_InputImage->GetSpacing() );
m_PdImage->SetOrigin( m_InputImage->GetOrigin() );
m_PdImage->SetDirection( m_InputImage->GetDirection() );
m_PdImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
m_PdImage->Allocate();
m_EmaxImage = ItkFloatImgType::New();
m_EmaxImage->SetSpacing( m_InputImage->GetSpacing() );
m_EmaxImage->SetOrigin( m_InputImage->GetOrigin() );
m_EmaxImage->SetDirection( m_InputImage->GetDirection() );
m_EmaxImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
m_EmaxImage->Allocate();
m_EmaxImage->FillBuffer(1.0);
typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
typename TensorType::EigenValuesArrayType eigenvalues;
typename TensorType::EigenVectorsMatrixType eigenvectors;
for (int x=0; x<m_ImageSize[0]; x++)
for (int y=0; y<m_ImageSize[1]; y++)
for (int z=0; z<m_ImageSize[2]; z++)
{
typename InputImageType::IndexType index;
index[0] = x; index[1] = y; index[2] = z;
typename InputImageType::PixelType tensor = m_InputImage->GetPixel(index);
vnl_vector_fixed<double,3> dir;
tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
dir[0] = eigenvectors(2, 0);
dir[1] = eigenvectors(2, 1);
dir[2] = eigenvectors(2, 2);
dir.normalize();
m_PdImage->SetPixel(index, dir);
m_FaImage->SetPixel(index, tensor.GetFractionalAnisotropy());
m_EmaxImage->SetPixel(index, 2/eigenvalues[2]);
}
if (m_Interpolate)
std::cout << "StreamlineTrackingFilter: using trilinear interpolation" << std::endl;
else
{
if (m_MinCurvatureRadius<0.0)
m_MinCurvatureRadius = 0.1*minSpacing;
std::cout << "StreamlineTrackingFilter: using nearest neighbor interpolation" << std::endl;
}
if (m_MinCurvatureRadius<0.0)
m_MinCurvatureRadius = 0.5*minSpacing;
std::cout << "StreamlineTrackingFilter: Min. curvature radius: " << m_MinCurvatureRadius << std::endl;
std::cout << "StreamlineTrackingFilter: FA threshold: " << m_FaThreshold << std::endl;
std::cout << "StreamlineTrackingFilter: stepsize: " << m_StepSize << " mm" << std::endl;
std::cout << "StreamlineTrackingFilter: f: " << m_F << std::endl;
std::cout << "StreamlineTrackingFilter: g: " << m_G << std::endl;
std::cout << "StreamlineTrackingFilter: starting streamline tracking" << std::endl;
}
template< class TTensorPixelType, class TPDPixelType>
void StreamlineTrackingFilter< TTensorPixelType, TPDPixelType>
::CalculateNewPosition(itk::ContinuousIndex<double, 3>& pos, vnl_vector_fixed<double,3>& dir, typename InputImageType::IndexType& index)
{
vnl_matrix_fixed< double, 3, 3 > rot = m_InputImage->GetDirection().GetTranspose();
dir = rot*dir;
if (true)
{
dir *= m_StepSize;
pos[0] += dir[0]/m_ImageSpacing[0];
pos[1] += dir[1]/m_ImageSpacing[1];
pos[2] += dir[2]/m_ImageSpacing[2];
index[0] = RoundToNearest(pos[0]);
index[1] = RoundToNearest(pos[1]);
index[2] = RoundToNearest(pos[2]);
}
else
{
dir[0] /= m_ImageSpacing[0];
dir[1] /= m_ImageSpacing[1];
dir[2] /= m_ImageSpacing[2];
int smallest = 0;
float x = 100000;
if (dir[0]>0)
{
if (fabs(fabs(RoundToNearest(pos[0])-pos[0])-0.5)>mitk::eps)
x = fabs(pos[0]-RoundToNearest(pos[0])-0.5)/dir[0];
else
x = fabs(pos[0]-std::ceil(pos[0])-0.5)/dir[0];
}
else if (dir[0]<0)
{
if (fabs(fabs(RoundToNearest(pos[0])-pos[0])-0.5)>mitk::eps)
x = -fabs(pos[0]-RoundToNearest(pos[0])+0.5)/dir[0];
else
x = -fabs(pos[0]-std::floor(pos[0])+0.5)/dir[0];
}
float s = x;
float y = 100000;
if (dir[1]>0)
{
if (fabs(fabs(RoundToNearest(pos[1])-pos[1])-0.5)>mitk::eps)
y = fabs(pos[1]-RoundToNearest(pos[1])-0.5)/dir[1];
else
y = fabs(pos[1]-std::ceil(pos[1])-0.5)/dir[1];
}
else if (dir[1]<0)
{
if (fabs(fabs(RoundToNearest(pos[1])-pos[1])-0.5)>mitk::eps)
y = -fabs(pos[1]-RoundToNearest(pos[1])+0.5)/dir[1];
else
y = -fabs(pos[1]-std::floor(pos[1])+0.5)/dir[1];
}
if (s>y)
{
s=y;
smallest = 1;
}
float z = 100000;
if (dir[2]>0)
{
if (fabs(fabs(RoundToNearest(pos[2])-pos[2])-0.5)>mitk::eps)
z = fabs(pos[2]-RoundToNearest(pos[2])-0.5)/dir[2];
else
z = fabs(pos[2]-std::ceil(pos[2])-0.5)/dir[2];
}
else if (dir[2]<0)
{
if (fabs(fabs(RoundToNearest(pos[2])-pos[2])-0.5)>mitk::eps)
z = -fabs(pos[2]-RoundToNearest(pos[2])+0.5)/dir[2];
else
z = -fabs(pos[2]-std::floor(pos[2])+0.5)/dir[2];
}
if (s>z)
{
s=z;
smallest = 2;
}
// MITK_INFO << "---------------------------------------------";
// MITK_INFO << "s: " << s;
// MITK_INFO << "dir: " << dir;
// MITK_INFO << "old: " << pos[0] << ", " << pos[1] << ", " << pos[2];
pos[0] += dir[0]*s;
pos[1] += dir[1]*s;
pos[2] += dir[2]*s;
switch (smallest)
{
case 0:
if (dir[0]<0)
index[0] = std::floor(pos[0]);
else
index[0] = std::ceil(pos[0]);
index[1] = RoundToNearest(pos[1]);
index[2] = RoundToNearest(pos[2]);
break;
case 1:
if (dir[1]<0)
index[1] = std::floor(pos[1]);
else
index[1] = std::ceil(pos[1]);
index[0] = RoundToNearest(pos[0]);
index[2] = RoundToNearest(pos[2]);
break;
case 2:
if (dir[2]<0)
index[2] = std::floor(pos[2]);
else
index[2] = std::ceil(pos[2]);
index[1] = RoundToNearest(pos[1]);
index[0] = RoundToNearest(pos[0]);
}
// float x = 100000;
// if (dir[0]>0)
// x = fabs(pos[0]-RoundToNearest(pos[0])-0.5)/dir[0];
// else if (dir[0]<0)
// x = -fabs(pos[0]-RoundToNearest(pos[0])+0.5)/dir[0];
// float s = x;
// float y = 100000;
// if (dir[1]>0)
// y = fabs(pos[1]-RoundToNearest(pos[1])-0.5)/dir[1];
// else if (dir[1]<0)
// y = -fabs(pos[1]-RoundToNearest(pos[1])+0.5)/dir[1];
// if (s>y)
// s=y;
// float z = 100000;
// if (dir[2]>0)
// z = fabs(pos[2]-RoundToNearest(pos[2])-0.5)/dir[2];
// else if (dir[2]<0)
// z = -fabs(pos[2]-RoundToNearest(pos[2])+0.5)/dir[2];
// if (s>z)
// s=z;
// s *= 1.001;
// pos[0] += dir[0]*s;
// pos[1] += dir[1]*s;
// pos[2] += dir[2]*s;
// index[0] = RoundToNearest(pos[0]);
// index[1] = RoundToNearest(pos[1]);
// index[2] = RoundToNearest(pos[2]);
// MITK_INFO << "new: " << pos[0] << ", " << pos[1] << ", " << pos[2];
}
}
template< class TTensorPixelType, class TPDPixelType>
bool StreamlineTrackingFilter< TTensorPixelType, TPDPixelType>
::IsValidPosition(itk::ContinuousIndex<double, 3>& pos, typename InputImageType::IndexType &index, vnl_vector_fixed< float, 8 >& interpWeights)
{
if (!m_InputImage->GetLargestPossibleRegion().IsInside(index) || m_MaskImage->GetPixel(index)==0)
return false;
if (m_Interpolate)
{
float frac_x = pos[0] - index[0];
float frac_y = pos[1] - index[1];
float frac_z = pos[2] - index[2];
if (frac_x<0)
{
index[0] -= 1;
frac_x += 1;
}
if (frac_y<0)
{
index[1] -= 1;
frac_y += 1;
}
if (frac_z<0)
{
index[2] -= 1;
frac_z += 1;
}
frac_x = 1-frac_x;
frac_y = 1-frac_y;
frac_z = 1-frac_z;
// int coordinates inside image?
if (index[0] < 0 || index[0] >= m_ImageSize[0]-1)
return false;
if (index[1] < 0 || index[1] >= m_ImageSize[1]-1)
return false;
if (index[2] < 0 || index[2] >= m_ImageSize[2]-1)
return false;
interpWeights[0] = ( frac_x)*( frac_y)*( frac_z);
interpWeights[1] = (1-frac_x)*( frac_y)*( frac_z);
interpWeights[2] = ( frac_x)*(1-frac_y)*( frac_z);
interpWeights[3] = ( frac_x)*( frac_y)*(1-frac_z);
interpWeights[4] = (1-frac_x)*(1-frac_y)*( frac_z);
interpWeights[5] = ( frac_x)*(1-frac_y)*(1-frac_z);
interpWeights[6] = (1-frac_x)*( frac_y)*(1-frac_z);
interpWeights[7] = (1-frac_x)*(1-frac_y)*(1-frac_z);
typename InputImageType::IndexType tmpIdx;
float FA = m_FaImage->GetPixel(index) * interpWeights[0];
tmpIdx = index; tmpIdx[0]++;
FA += m_FaImage->GetPixel(tmpIdx) * interpWeights[1];
tmpIdx = index; tmpIdx[1]++;
FA += m_FaImage->GetPixel(tmpIdx) * interpWeights[2];
tmpIdx = index; tmpIdx[2]++;
FA += m_FaImage->GetPixel(tmpIdx) * interpWeights[3];
tmpIdx = index; tmpIdx[0]++; tmpIdx[1]++;
FA += m_FaImage->GetPixel(tmpIdx) * interpWeights[4];
tmpIdx = index; tmpIdx[1]++; tmpIdx[2]++;
FA += m_FaImage->GetPixel(tmpIdx) * interpWeights[5];
tmpIdx = index; tmpIdx[2]++; tmpIdx[0]++;
FA += m_FaImage->GetPixel(tmpIdx) * interpWeights[6];
tmpIdx = index; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
FA += m_FaImage->GetPixel(tmpIdx) * interpWeights[7];
if (FA<m_FaThreshold)
return false;
}
else if (m_FaImage->GetPixel(index)<m_FaThreshold)
return false;
return true;
}
template< class TTensorPixelType, class TPDPixelType>
float StreamlineTrackingFilter< TTensorPixelType, TPDPixelType>
::FollowStreamline(itk::ContinuousIndex<double, 3> pos, int dirSign, vtkPoints* points, std::vector< vtkIdType >& ids)
{
float tractLength = 0;
typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
typename TensorType::EigenValuesArrayType eigenvalues;
typename TensorType::EigenVectorsMatrixType eigenvectors;
vnl_vector_fixed< float, 8 > interpWeights;
typename InputImageType::IndexType index, indexOld;
indexOld[0] = -1; indexOld[1] = -1; indexOld[2] = -1;
itk::Point<double> worldPos;
float distance = 0;
float distanceInVoxel = 0;
// starting index and direction
index[0] = RoundToNearest(pos[0]);
index[1] = RoundToNearest(pos[1]);
index[2] = RoundToNearest(pos[2]);
vnl_vector_fixed<double,3> dir = m_PdImage->GetPixel(index);
dir *= dirSign; // reverse direction
vnl_vector_fixed<double,3> dirOld = dir;
if (dir.magnitude()<mitk::eps)
return tractLength;
for (int step=0; step< m_MaxLength/2; step++)
{
// get new position
CalculateNewPosition(pos, dir, index);
distance += m_StepSize;
tractLength += m_StepSize;
distanceInVoxel += m_StepSize;
// is new position valid (inside image, above FA threshold etc.)
if (!IsValidPosition(pos, index, interpWeights)) // if not add last point and end streamline
{
m_InputImage->TransformContinuousIndexToPhysicalPoint( pos, worldPos );
ids.push_back(points->InsertNextPoint(worldPos.GetDataPointer()));
return tractLength;
}
else if (distance>=m_PointPistance)
{
m_InputImage->TransformContinuousIndexToPhysicalPoint( pos, worldPos );
ids.push_back(points->InsertNextPoint(worldPos.GetDataPointer()));
distance = 0;
}
if (!m_Interpolate) // use nearest neighbour interpolation
{
if (indexOld!=index) // did we enter a new voxel? if yes, calculate new direction
{
dir = m_PdImage->GetPixel(index); // get principal direction
typename InputImageType::PixelType tensor = m_InputImage->GetPixel(index);
float scale = m_EmaxImage->GetPixel(index);
dir[0] = m_F*dir[0] + (1-m_F)*( (1-m_G)*dirOld[0] + scale*m_G*(tensor[0]*dirOld[0] + tensor[1]*dirOld[1] + tensor[2]*dirOld[2]));
dir[1] = m_F*dir[1] + (1-m_F)*( (1-m_G)*dirOld[1] + scale*m_G*(tensor[1]*dirOld[0] + tensor[3]*dirOld[1] + tensor[4]*dirOld[2]));
dir[2] = m_F*dir[2] + (1-m_F)*( (1-m_G)*dirOld[2] + scale*m_G*(tensor[2]*dirOld[0] + tensor[4]*dirOld[1] + tensor[5]*dirOld[2]));
dir.normalize();
float angle = dot_product(dirOld, dir);
if (angle<0)
{
dir *= -1;
angle *= -1;
}
float r = m_StepSize/(2*std::asin(std::acos(angle)/2));
if (r<m_MinCurvatureRadius)
return tractLength;
if (dir.magnitude()<mitk::eps)
dir = dirOld;
else
dirOld = dir;
indexOld = index;
distanceInVoxel = 0;
}
else
dir = dirOld;
}
else // use trilinear interpolation (weights calculated in IsValidPosition())
{
typename InputImageType::PixelType tensor = m_InputImage->GetPixel(index) * interpWeights[0];
typename InputImageType::IndexType tmpIdx = index; tmpIdx[0]++;
tensor += m_InputImage->GetPixel(tmpIdx) * interpWeights[1];
tmpIdx = index; tmpIdx[1]++;
tensor += m_InputImage->GetPixel(tmpIdx) * interpWeights[2];
tmpIdx = index; tmpIdx[2]++;
tensor += m_InputImage->GetPixel(tmpIdx) * interpWeights[3];
tmpIdx = index; tmpIdx[0]++; tmpIdx[1]++;
tensor += m_InputImage->GetPixel(tmpIdx) * interpWeights[4];
tmpIdx = index; tmpIdx[1]++; tmpIdx[2]++;
tensor += m_InputImage->GetPixel(tmpIdx) * interpWeights[5];
tmpIdx = index; tmpIdx[2]++; tmpIdx[0]++;
tensor += m_InputImage->GetPixel(tmpIdx) * interpWeights[6];
tmpIdx = index; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
tensor += m_InputImage->GetPixel(tmpIdx) * interpWeights[7];
tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
dir[0] = eigenvectors(2, 0);
dir[1] = eigenvectors(2, 1);
dir[2] = eigenvectors(2, 2);
dir.normalize();
float scale = 2/eigenvalues[2];
dir[0] = m_F*dir[0] + (1-m_F)*( (1-m_G)*dirOld[0] + scale*m_G*(tensor[0]*dirOld[0] + tensor[1]*dirOld[1] + tensor[2]*dirOld[2]));
dir[1] = m_F*dir[1] + (1-m_F)*( (1-m_G)*dirOld[1] + scale*m_G*(tensor[1]*dirOld[0] + tensor[3]*dirOld[1] + tensor[4]*dirOld[2]));
dir[2] = m_F*dir[2] + (1-m_F)*( (1-m_G)*dirOld[2] + scale*m_G*(tensor[2]*dirOld[0] + tensor[4]*dirOld[1] + tensor[5]*dirOld[2]));
dir.normalize();
float angle = dot_product(dirOld, dir);
if (angle<0)
{
dir *= -1;
angle *= -1;
}
float r = m_StepSize/(2*std::asin(std::acos(angle)/2));
if (r<m_MinCurvatureRadius)
return tractLength;
if (dir.magnitude()<mitk::eps)
dir = dirOld;
else
dirOld = dir;
indexOld = index;
}
}
return tractLength;
}
template< class TTensorPixelType,
class TPDPixelType>
void StreamlineTrackingFilter< TTensorPixelType,
TPDPixelType>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId)
+ ThreadIdType threadId)
{
FiberPolyDataType poly = m_PolyDataContainer->GetElement(threadId);
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> Cells = vtkSmartPointer<vtkCellArray>::New();
typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
typedef ImageRegionConstIterator< ItkUcharImgType > MaskIteratorType;
typedef ImageRegionConstIterator< ItkFloatImgType > FloatIteratorType;
typedef typename InputImageType::PixelType InputTensorType;
InputIteratorType it(m_InputImage, outputRegionForThread );
MaskIteratorType mit(m_SeedImage, outputRegionForThread );
FloatIteratorType fit(m_FaImage, outputRegionForThread );
MaskIteratorType mit2(m_MaskImage, outputRegionForThread );
it.GoToBegin();
mit.GoToBegin();
mit2.GoToBegin();
fit.GoToBegin();
itk::Point<double> worldPos;
while( !it.IsAtEnd() )
{
if (mit.Value()==0 || fit.Value()<m_FaThreshold || mit2.Value()==0)
{
++mit;
++mit2;
++it;
++fit;
continue;
}
for (int s=0; s<m_SeedsPerVoxel; s++)
{
vtkSmartPointer<vtkPolyLine> line = vtkSmartPointer<vtkPolyLine>::New();
std::vector< vtkIdType > pointIDs;
typename InputImageType::IndexType index = it.GetIndex();
itk::ContinuousIndex<double, 3> start;
unsigned int counter = 0;
if (m_SeedsPerVoxel>1)
{
start[0] = index[0]+(double)(rand()%99-49)/100;
start[1] = index[1]+(double)(rand()%99-49)/100;
start[2] = index[2]+(double)(rand()%99-49)/100;
}
else
{
start[0] = index[0];
start[1] = index[1];
start[2] = index[2];
}
// forward tracking
float tractLength = FollowStreamline(start, 1, points, pointIDs);
// add ids to line
counter += pointIDs.size();
while (!pointIDs.empty())
{
line->GetPointIds()->InsertNextId(pointIDs.back());
pointIDs.pop_back();
}
// insert start point
m_InputImage->TransformContinuousIndexToPhysicalPoint( start, worldPos );
line->GetPointIds()->InsertNextId(points->InsertNextPoint(worldPos.GetDataPointer()));
// backward tracking
tractLength += FollowStreamline(start, -1, points, pointIDs);
counter += pointIDs.size();
if (tractLength<m_MinTractLength || counter<2)
continue;
// add ids to line
for (int i=0; i<pointIDs.size(); i++)
line->GetPointIds()->InsertNextId(pointIDs.at(i));
Cells->InsertNextCell(line);
}
++mit;
++mit2;
++it;
++fit;
}
poly->SetPoints(points);
poly->SetLines(Cells);
std::cout << "Thread " << threadId << " finished tracking" << std::endl;
}
template< class TTensorPixelType,
class TPDPixelType>
vtkSmartPointer< vtkPolyData > StreamlineTrackingFilter< TTensorPixelType,
TPDPixelType>
::AddPolyData(FiberPolyDataType poly1, FiberPolyDataType poly2)
{
vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> vNewLines = poly1->GetLines();
vtkSmartPointer<vtkPoints> vNewPoints = poly1->GetPoints();
vtkSmartPointer<vtkCellArray> vLines = poly2->GetLines();
vLines->InitTraversal();
for( int i=0; i<vLines->GetNumberOfCells(); i++ )
{
vtkIdType numPoints(0);
vtkIdType* points(NULL);
vLines->GetNextCell ( numPoints, points );
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for( int j=0; j<numPoints; j++)
{
vtkIdType id = vNewPoints->InsertNextPoint(poly2->GetPoint(points[j]));
container->GetPointIds()->InsertNextId(id);
}
vNewLines->InsertNextCell(container);
}
// initialize polydata
vNewPolyData->SetPoints(vNewPoints);
vNewPolyData->SetLines(vNewLines);
return vNewPolyData;
}
template< class TTensorPixelType,
class TPDPixelType>
void StreamlineTrackingFilter< TTensorPixelType,
TPDPixelType>
::AfterThreadedGenerateData()
{
MITK_INFO << "Generating polydata ";
m_FiberPolyData = m_PolyDataContainer->GetElement(0);
for (int i=1; i<this->GetNumberOfThreads(); i++)
{
m_FiberPolyData = AddPolyData(m_FiberPolyData, m_PolyDataContainer->GetElement(i));
}
MITK_INFO << "done";
}
template< class TTensorPixelType,
class TPDPixelType>
void StreamlineTrackingFilter< TTensorPixelType,
TPDPixelType>
::PrintSelf(std::ostream& os, Indent indent) const
{
}
}
#endif // __itkDiffusionQballPrincipleDirectionsImageFilter_txx
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.h
index 6a2cbd91f6..cee66c2128 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.h
@@ -1,137 +1,137 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkStreamlineTrackingFilter_h_
#define __itkStreamlineTrackingFilter_h_
#include "FiberTrackingExports.h"
#include <itkImageToImageFilter.h>
#include <itkVectorContainer.h>
#include <itkVectorImage.h>
#include <itkDiffusionTensor3D.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
namespace itk{
/**
* \brief Performes deterministic streamline tracking on the input tensor image. */
template< class TTensorPixelType, class TPDPixelType=double>
class StreamlineTrackingFilter :
public ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >,
Image< Vector< TPDPixelType, 3 >, 3 > >
{
public:
typedef StreamlineTrackingFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >, Image< Vector< TPDPixelType, 3 >, 3 > > Superclass;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(StreamlineTrackingFilter, ImageToImageFilter)
typedef TTensorPixelType TensorComponentType;
typedef TPDPixelType DirectionPixelType;
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image<float, 3> ItkFloatImgType;
typedef itk::Image< vnl_vector_fixed<double,3>, 3> ItkPDImgType;
typedef vtkSmartPointer< vtkPolyData > FiberPolyDataType;
itkGetMacro( FiberPolyData, FiberPolyDataType )
itkSetMacro( SeedImage, ItkUcharImgType::Pointer)
itkSetMacro( MaskImage, ItkUcharImgType::Pointer)
itkSetMacro( SeedsPerVoxel, int)
itkSetMacro( FaThreshold, float)
itkSetMacro( StepSize, float)
itkSetMacro( F, float )
itkSetMacro( G, float )
itkSetMacro( Interpolate, bool )
itkSetMacro( MinTractLength, float )
itkGetMacro( MinTractLength, float )
itkSetMacro( MinCurvatureRadius, float )
itkGetMacro( MinCurvatureRadius, float )
protected:
StreamlineTrackingFilter();
~StreamlineTrackingFilter() {}
void PrintSelf(std::ostream& os, Indent indent) const;
void CalculateNewPosition(itk::ContinuousIndex<double, 3>& pos, vnl_vector_fixed<double,3>& dir, typename InputImageType::IndexType& index);
float FollowStreamline(itk::ContinuousIndex<double, 3> pos, int dirSign, vtkPoints* points, std::vector< vtkIdType >& ids);
bool IsValidPosition(itk::ContinuousIndex<double, 3>& pos, typename InputImageType::IndexType& index, vnl_vector_fixed< float, 8 >& interpWeights);
double RoundToNearest(double num);
void BeforeThreadedGenerateData();
- void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, int threadId);
+ void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId);
void AfterThreadedGenerateData();
FiberPolyDataType AddPolyData(FiberPolyDataType poly1, FiberPolyDataType poly2);
FiberPolyDataType m_FiberPolyData;
vtkSmartPointer<vtkPoints> m_Points;
vtkSmartPointer<vtkCellArray> m_Cells;
ItkFloatImgType::Pointer m_EmaxImage;
ItkFloatImgType::Pointer m_FaImage;
ItkPDImgType::Pointer m_PdImage;
typename InputImageType::Pointer m_InputImage;
float m_FaThreshold;
float m_MinCurvatureRadius;
float m_StepSize;
int m_MaxLength;
float m_MinTractLength;
int m_SeedsPerVoxel;
float m_F;
float m_G;
std::vector< int > m_ImageSize;
std::vector< float > m_ImageSpacing;
ItkUcharImgType::Pointer m_SeedImage;
ItkUcharImgType::Pointer m_MaskImage;
bool m_Interpolate;
float m_PointPistance;
itk::VectorContainer< int, FiberPolyDataType >::Pointer m_PolyDataContainer;
private:
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkStreamlineTrackingFilter.cpp"
#endif
#endif //__itkStreamlineTrackingFilter_h_
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp
index 39d27bcdd2..f305bb165a 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp
@@ -1,226 +1,226 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Coindex[1]right (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "itkTractDensityImageFilter.h"
// VTK
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
// misc
#include <math.h>
#include <boost/progress.hpp>
namespace itk{
template< class OutputImageType >
TractDensityImageFilter< OutputImageType >::TractDensityImageFilter()
: m_BinaryOutput(false)
, m_InvertImage(false)
, m_UpsamplingFactor(1)
, m_InputImage(NULL)
, m_UseImageGeometry(false)
, m_OutputAbsoluteValues(false)
{
}
template< class OutputImageType >
TractDensityImageFilter< OutputImageType >::~TractDensityImageFilter()
{
}
template< class OutputImageType >
itk::Point<float, 3> TractDensityImageFilter< OutputImageType >::GetItkPoint(double point[3])
{
itk::Point<float, 3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
return itkPoint;
}
template< class OutputImageType >
void TractDensityImageFilter< OutputImageType >::GenerateData()
{
// generate upsampled image
mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
typename OutputImageType::Pointer outImage = this->GetOutput();
// calculate new image parameters
- mitk::Vector3D newSpacing;
+ itk::Vector<double,3> newSpacing;
mitk::Point3D newOrigin;
itk::Matrix<double, 3, 3> newDirection;
ImageRegion<3> upsampledRegion;
if (m_UseImageGeometry && !m_InputImage.IsNull())
{
MITK_INFO << "TractDensityImageFilter: using image geometry";
newSpacing = m_InputImage->GetSpacing()/m_UpsamplingFactor;
upsampledRegion = m_InputImage->GetLargestPossibleRegion();
newOrigin = m_InputImage->GetOrigin();
typename OutputImageType::RegionType::SizeType size = upsampledRegion.GetSize();
size[0] *= m_UpsamplingFactor;
size[1] *= m_UpsamplingFactor;
size[2] *= m_UpsamplingFactor;
upsampledRegion.SetSize(size);
newDirection = m_InputImage->GetDirection();
}
else
{
MITK_INFO << "TractDensityImageFilter: using fiber bundle geometry";
newSpacing = geometry->GetSpacing()/m_UpsamplingFactor;
newOrigin = geometry->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
newOrigin[0] += bounds.GetElement(0);
newOrigin[1] += bounds.GetElement(2);
newOrigin[2] += bounds.GetElement(4);
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
newDirection[j][i] = geometry->GetMatrixColumn(i)[j];
upsampledRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
upsampledRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
upsampledRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
}
typename OutputImageType::RegionType::SizeType upsampledSize = upsampledRegion.GetSize();
// apply new image parameters
outImage->SetSpacing( newSpacing );
outImage->SetOrigin( newOrigin );
outImage->SetDirection( newDirection );
outImage->SetRegions( upsampledRegion );
outImage->Allocate();
outImage->FillBuffer(0.0);
int w = upsampledSize[0];
int h = upsampledSize[1];
int d = upsampledSize[2];
// set/initialize output
OutPixelType* outImageBufferPointer = (OutPixelType*)outImage->GetBufferPointer();
// resample fiber bundle
float minSpacing = 1;
if(newSpacing[0]<newSpacing[1] && newSpacing[0]<newSpacing[2])
minSpacing = newSpacing[0];
else if (newSpacing[1] < newSpacing[2])
minSpacing = newSpacing[1];
else
minSpacing = newSpacing[2];
MITK_INFO << "TractDensityImageFilter: resampling fibers to ensure sufficient voxel coverage";
m_FiberBundle = m_FiberBundle->GetDeepCopy();
m_FiberBundle->ResampleFibers(minSpacing);
MITK_INFO << "TractDensityImageFilter: starting image generation";
vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
vLines->InitTraversal();
int numFibers = m_FiberBundle->GetNumFibers();
boost::progress_display disp(numFibers);
for( int i=0; i<numFibers; i++ )
{
++disp;
vtkIdType numPoints(0);
vtkIdType* points(NULL);
vLines->GetNextCell ( numPoints, points );
// fill output image
for( int j=0; j<numPoints; j++)
{
itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[j]));
itk::Index<3> index;
itk::ContinuousIndex<float, 3> contIndex;
outImage->TransformPhysicalPointToIndex(vertex, index);
outImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
float frac_x = contIndex[0] - index[0];
float frac_y = contIndex[1] - index[1];
float frac_z = contIndex[2] - index[2];
if (frac_x<0)
{
index[0] -= 1;
frac_x += 1;
}
if (frac_y<0)
{
index[1] -= 1;
frac_y += 1;
}
if (frac_z<0)
{
index[2] -= 1;
frac_z += 1;
}
frac_x = 1-frac_x;
frac_y = 1-frac_y;
frac_z = 1-frac_z;
// int coordinates inside image?
if (index[0] < 0 || index[0] >= w-1)
continue;
if (index[1] < 0 || index[1] >= h-1)
continue;
if (index[2] < 0 || index[2] >= d-1)
continue;
if (m_BinaryOutput)
{
outImageBufferPointer[( index[0] + w*(index[1] + h*index[2] ))] = 1;
outImageBufferPointer[( index[0] + w*(index[1]+1+ h*index[2] ))] = 1;
outImageBufferPointer[( index[0] + w*(index[1] + h*index[2]+h))] = 1;
outImageBufferPointer[( index[0] + w*(index[1]+1+ h*index[2]+h))] = 1;
outImageBufferPointer[( index[0]+1 + w*(index[1] + h*index[2] ))] = 1;
outImageBufferPointer[( index[0]+1 + w*(index[1] + h*index[2]+h))] = 1;
outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2] ))] = 1;
outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]+h))] = 1;
}
else
{
outImageBufferPointer[( index[0] + w*(index[1] + h*index[2] ))] += ( frac_x)*( frac_y)*( frac_z);
outImageBufferPointer[( index[0] + w*(index[1]+1+ h*index[2] ))] += ( frac_x)*(1-frac_y)*( frac_z);
outImageBufferPointer[( index[0] + w*(index[1] + h*index[2]+h))] += ( frac_x)*( frac_y)*(1-frac_z);
outImageBufferPointer[( index[0] + w*(index[1]+1+ h*index[2]+h))] += ( frac_x)*(1-frac_y)*(1-frac_z);
outImageBufferPointer[( index[0]+1 + w*(index[1] + h*index[2] ))] += (1-frac_x)*( frac_y)*( frac_z);
outImageBufferPointer[( index[0]+1 + w*(index[1] + h*index[2]+h))] += (1-frac_x)*( frac_y)*(1-frac_z);
outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2] ))] += (1-frac_x)*(1-frac_y)*( frac_z);
outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]+h))] += (1-frac_x)*(1-frac_y)*(1-frac_z);
}
}
}
if (!m_OutputAbsoluteValues && !m_BinaryOutput)
{
MITK_INFO << "TractDensityImageFilter: max-normalizing output image";
OutPixelType max = 0;
for (int i=0; i<w*h*d; i++)
if (max < outImageBufferPointer[i])
max = outImageBufferPointer[i];
if (max>0)
for (int i=0; i<w*h*d; i++)
outImageBufferPointer[i] /= max;
}
if (m_InvertImage)
{
MITK_INFO << "TractDensityImageFilter: inverting image";
for (int i=0; i<w*h*d; i++)
outImageBufferPointer[i] = 1-outImageBufferPointer[i];
}
MITK_INFO << "TractDensityImageFilter: finished processing";
}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
old mode 100644
new mode 100755
index 4a0b9e729a..9a3f838d71
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
@@ -1,613 +1,698 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "itkTractsToDWIImageFilter.h"
#include <boost/progress.hpp>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <itkImageRegionIteratorWithIndex.h>
-#include <mitkGibbsRingingArtifact.h>
#include <itkResampleImageFilter.h>
#include <itkNearestNeighborInterpolateImageFunction.h>
#include <itkBSplineInterpolateImageFunction.h>
#include <itkCastImageFilter.h>
#include <itkImageFileWriter.h>
#include <itkRescaleIntensityImageFilter.h>
#include <itkWindowedSincInterpolateImageFunction.h>
#include <itkResampleDwiImageFilter.h>
+#include <itkKspaceImageFilter.h>
+#include <itkDftImageFilter.h>
+#include <itkAddImageFilter.h>
namespace itk
{
TractsToDWIImageFilter::TractsToDWIImageFilter()
: m_CircleDummy(false)
, m_VolumeAccuracy(10)
, m_Upsampling(1)
, m_NumberOfRepetitions(1)
, m_EnforcePureFiberVoxels(false)
- , m_InterpolationShrink(10)
- , m_FiberRadius(20)
- , m_SignalScale(300)
+ , m_InterpolationShrink(1000)
+ , m_FiberRadius(0)
+ , m_SignalScale(25)
+ , m_kOffset(0)
+ , m_tLine(1)
+ , m_UseInterpolation(false)
+ , m_SimulateRelaxation(true)
+ , m_tInhom(50)
+ , m_TE(100)
+ , m_FrequencyMap(NULL)
+ , m_EddyGradientStrength(0.001)
+ , m_SimulateEddyCurrents(false)
{
m_Spacing.Fill(2.5); m_Origin.Fill(0.0);
m_DirectionMatrix.SetIdentity();
m_ImageRegion.SetSize(0, 10);
m_ImageRegion.SetSize(1, 10);
m_ImageRegion.SetSize(2, 10);
}
TractsToDWIImageFilter::~TractsToDWIImageFilter()
{
}
-std::vector< TractsToDWIImageFilter::DoubleDwiType::Pointer > TractsToDWIImageFilter::AddKspaceArtifacts( std::vector< DoubleDwiType::Pointer >& images )
+TractsToDWIImageFilter::DoubleDwiType::Pointer TractsToDWIImageFilter::DoKspaceStuff( std::vector< DoubleDwiType::Pointer >& images )
{
// create slice object
- SliceType::Pointer slice = SliceType::New();
- ImageRegion<2> region;
- region.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
- region.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
- slice->SetLargestPossibleRegion( region );
- slice->SetBufferedRegion( region );
- slice->SetRequestedRegion( region );
- slice->Allocate();
-
- boost::progress_display disp(images.size()*images[0]->GetVectorLength()*images[0]->GetLargestPossibleRegion().GetSize(2));
- std::vector< DoubleDwiType::Pointer > outImages;
- for (int i=0; i<images.size(); i++)
+ ImageRegion<2> sliceRegion;
+ sliceRegion.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
+ sliceRegion.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
+
+ // frequency map slice
+ SliceType::Pointer fMap = NULL;
+ if (m_FrequencyMap.IsNotNull())
{
- DoubleDwiType::Pointer image = images.at(i);
- DoubleDwiType::Pointer newImage = DoubleDwiType::New();
- newImage->SetSpacing( m_Spacing );
- newImage->SetOrigin( m_Origin );
- newImage->SetDirection( m_DirectionMatrix );
- newImage->SetLargestPossibleRegion( m_ImageRegion );
- newImage->SetBufferedRegion( m_ImageRegion );
- newImage->SetRequestedRegion( m_ImageRegion );
- newImage->SetVectorLength( image->GetVectorLength() );
- newImage->Allocate();
-
- DiffusionSignalModel<double>* signalModel;
- if (i<m_FiberModels.size())
- signalModel = m_FiberModels.at(i);
- else
- signalModel = m_NonFiberModels.at(i-m_FiberModels.size());
-
- for (int g=0; g<image->GetVectorLength(); g++)
- for (int z=0; z<image->GetLargestPossibleRegion().GetSize(2); z++)
+ fMap = SliceType::New();
+ ImageRegion<2> region;
+ region.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
+ region.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
+ fMap->SetLargestPossibleRegion( region );
+ fMap->SetBufferedRegion( region );
+ fMap->SetRequestedRegion( region );
+ fMap->Allocate();
+ }
+
+ DoubleDwiType::Pointer newImage = DoubleDwiType::New();
+ newImage->SetSpacing( m_Spacing );
+ newImage->SetOrigin( m_Origin );
+ newImage->SetDirection( m_DirectionMatrix );
+ newImage->SetLargestPossibleRegion( m_ImageRegion );
+ newImage->SetBufferedRegion( m_ImageRegion );
+ newImage->SetRequestedRegion( m_ImageRegion );
+ newImage->SetVectorLength( images.at(0)->GetVectorLength() );
+ newImage->Allocate();
+
+ MatrixType transform = m_DirectionMatrix;
+ for (int i=0; i<3; i++)
+ for (int j=0; j<3; j++)
+ {
+ if (j<2)
+ transform[i][j] *= m_UpsampledSpacing[j];
+ else
+ transform[i][j] *= m_Spacing[j];
+ }
+
+ boost::progress_display disp(images.at(0)->GetVectorLength()*images.at(0)->GetLargestPossibleRegion().GetSize(2));
+ for (int g=0; g<images.at(0)->GetVectorLength(); g++)
+ for (int z=0; z<images.at(0)->GetLargestPossibleRegion().GetSize(2); z++)
+ {
+ std::vector< SliceType::Pointer > compartmentSlices;
+ std::vector< double > t2Vector;
+
+ for (int i=0; i<images.size(); i++)
{
- ++disp;
+ DiffusionSignalModel<double>* signalModel;
+ if (i<m_FiberModels.size())
+ signalModel = m_FiberModels.at(i);
+ else
+ signalModel = m_NonFiberModels.at(i-m_FiberModels.size());
+
+ SliceType::Pointer slice = SliceType::New();
+ slice->SetLargestPossibleRegion( sliceRegion );
+ slice->SetBufferedRegion( sliceRegion );
+ slice->SetRequestedRegion( sliceRegion );
+ slice->Allocate();
+ slice->FillBuffer(0.0);
// extract slice from channel g
- for (int y=0; y<image->GetLargestPossibleRegion().GetSize(1); y++)
- for (int x=0; x<image->GetLargestPossibleRegion().GetSize(0); x++)
+ for (int y=0; y<images.at(0)->GetLargestPossibleRegion().GetSize(1); y++)
+ for (int x=0; x<images.at(0)->GetLargestPossibleRegion().GetSize(0); x++)
{
- SliceType::IndexType index2D;
- index2D[0]=x; index2D[1]=y;
- DoubleDwiType::IndexType index3D;
- index3D[0]=x; index3D[1]=y; index3D[2]=z;
+ SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
+ DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
+
+ slice->SetPixel(index2D, images.at(i)->GetPixel(index3D)[g]);
- SliceType::PixelType pix2D = image->GetPixel(index3D)[g];
- slice->SetPixel(index2D, pix2D);
+ if (fMap.IsNotNull() && i==0)
+ fMap->SetPixel(index2D, m_FrequencyMap->GetPixel(index3D));
}
- // fourier transform slice
- itk::FFTRealToComplexConjugateImageFilter< SliceType::PixelType, 2 >::Pointer fft = itk::FFTRealToComplexConjugateImageFilter< SliceType::PixelType, 2 >::New();
- fft->SetInput(slice);
- fft->Update();
- ComplexSliceType::Pointer fSlice = fft->GetOutput();
- fSlice = RearrangeSlice(fSlice);
+ compartmentSlices.push_back(slice);
+ t2Vector.push_back(signalModel->GetT2());
+ }
- // add artifacts
- for (int a=0; a<m_KspaceArtifacts.size(); a++)
+ // create k-sapce (inverse fourier transform slices)
+ itk::Size<2> outSize; outSize.SetElement(0, m_ImageRegion.GetSize(0)); outSize.SetElement(1, m_ImageRegion.GetSize(1));
+ itk::KspaceImageFilter< SliceType::PixelType >::Pointer idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
+ idft->SetCompartmentImages(compartmentSlices);
+ idft->SetT2(t2Vector);
+ idft->SetkOffset(m_kOffset);
+ idft->SettLine(m_tLine);
+ idft->SetTE(m_TE);
+ idft->SetTinhom(m_tInhom);
+ idft->SetSimulateRelaxation(m_SimulateRelaxation);
+ idft->SetSimulateEddyCurrents(m_SimulateEddyCurrents);
+ idft->SetEddyGradientMagnitude(m_EddyGradientStrength);
+ idft->SetZ((double)z-(double)images.at(0)->GetLargestPossibleRegion().GetSize(2)/2.0);
+ idft->SetDirectionMatrix(transform);
+ idft->SetDiffusionGradientDirection(m_FiberModels.at(0)->GetGradientDirection(g));
+ idft->SetFrequencyMap(fMap);
+ idft->SetSignalScale(m_SignalScale);
+ idft->SetOutSize(outSize);
+ idft->Update();
+
+ ComplexSliceType::Pointer fSlice;
+ fSlice = idft->GetOutput();
+
+ for (int i=0; i<m_KspaceArtifacts.size(); i++)
+ fSlice = m_KspaceArtifacts.at(i)->AddArtifact(fSlice);
+
+ // fourier transform slice
+ SliceType::Pointer newSlice;
+ itk::DftImageFilter< SliceType::PixelType >::Pointer dft = itk::DftImageFilter< SliceType::PixelType >::New();
+ dft->SetInput(fSlice);
+ dft->Update();
+ newSlice = dft->GetOutput();
+
+ // put slice back into channel g
+ for (int y=0; y<fSlice->GetLargestPossibleRegion().GetSize(1); y++)
+ for (int x=0; x<fSlice->GetLargestPossibleRegion().GetSize(0); x++)
{
- m_KspaceArtifacts.at(a)->SetT2(signalModel->GetT2());
- fSlice = m_KspaceArtifacts.at(a)->AddArtifact(fSlice);
- }
+ DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
+ SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
- // save k-space slice of s0 image
- if (g==m_FiberModels.at(0)->GetFirstBaselineIndex())
- for (int y=0; y<fSlice->GetLargestPossibleRegion().GetSize(1); y++)
- for (int x=0; x<fSlice->GetLargestPossibleRegion().GetSize(0); x++)
- {
- DoubleDwiType::IndexType index3D;
- index3D[0]=x; index3D[1]=y; index3D[2]=z;
- SliceType::IndexType index2D;
- index2D[0]=x; index2D[1]=y;
- double kpix = sqrt(fSlice->GetPixel(index2D).real()*fSlice->GetPixel(index2D).real()+fSlice->GetPixel(index2D).imag()*fSlice->GetPixel(index2D).imag());
- m_KspaceImage->SetPixel(index3D, m_KspaceImage->GetPixel(index3D)+kpix);
- }
-
- // inverse fourier transform slice
- SliceType::Pointer newSlice;
- itk::FFTComplexConjugateToRealImageFilter< SliceType::PixelType, 2 >::Pointer ifft = itk::FFTComplexConjugateToRealImageFilter< SliceType::PixelType, 2 >::New();
- ifft->SetInput(fSlice);
- ifft->Update();
- newSlice = ifft->GetOutput();
+ DoubleDwiType::PixelType pix3D = newImage->GetPixel(index3D);
+ pix3D[g] = newSlice->GetPixel(index2D);
+ newImage->SetPixel(index3D, pix3D);
+ }
- // put slice back into channel g
- for (int y=0; y<fSlice->GetLargestPossibleRegion().GetSize(1); y++)
- for (int x=0; x<fSlice->GetLargestPossibleRegion().GetSize(0); x++)
- {
- DoubleDwiType::IndexType index3D;
- index3D[0]=x; index3D[1]=y; index3D[2]=z;
- DoubleDwiType::PixelType pix3D = newImage->GetPixel(index3D);
- SliceType::IndexType index2D;
- index2D[0]=x; index2D[1]=y;
-
- pix3D[g] = newSlice->GetPixel(index2D);
- newImage->SetPixel(index3D, pix3D);
- }
- }
- outImages.push_back(newImage);
- }
- return outImages;
+ ++disp;
+ }
+ return newImage;
}
TractsToDWIImageFilter::ComplexSliceType::Pointer TractsToDWIImageFilter::RearrangeSlice(ComplexSliceType::Pointer slice)
{
ImageRegion<2> region = slice->GetLargestPossibleRegion();
ComplexSliceType::Pointer rearrangedSlice = ComplexSliceType::New();
rearrangedSlice->SetLargestPossibleRegion( region );
rearrangedSlice->SetBufferedRegion( region );
rearrangedSlice->SetRequestedRegion( region );
rearrangedSlice->Allocate();
int xHalf = region.GetSize(0)/2;
int yHalf = region.GetSize(1)/2;
for (int y=0; y<region.GetSize(1); y++)
for (int x=0; x<region.GetSize(0); x++)
{
SliceType::IndexType idx;
idx[0]=x; idx[1]=y;
vcl_complex< double > pix = slice->GetPixel(idx);
if( idx[0] < xHalf )
idx[0] = idx[0] + xHalf;
else
idx[0] = idx[0] - xHalf;
if( idx[1] < yHalf )
idx[1] = idx[1] + yHalf;
else
idx[1] = idx[1] - yHalf;
rearrangedSlice->SetPixel(idx, pix);
}
return rearrangedSlice;
}
void TractsToDWIImageFilter::GenerateData()
{
// check input data
if (m_FiberBundle.IsNull())
itkExceptionMacro("Input fiber bundle is NULL!");
int numFibers = m_FiberBundle->GetNumFibers();
if (numFibers<=0)
itkExceptionMacro("Input fiber bundle contains no fibers!");
if (m_FiberModels.empty())
itkExceptionMacro("No diffusion model for fiber compartments defined!");
if (m_NonFiberModels.empty())
itkExceptionMacro("No diffusion model for non-fiber compartments defined!");
int baselineIndex = m_FiberModels[0]->GetFirstBaselineIndex();
if (baselineIndex<0)
itkExceptionMacro("No baseline index found!");
- // determine k-space undersampling
- for (int i=0; i<m_KspaceArtifacts.size(); i++)
- if ( dynamic_cast<mitk::GibbsRingingArtifact<double>*>(m_KspaceArtifacts.at(i)) )
- m_Upsampling = dynamic_cast<mitk::GibbsRingingArtifact<double>*>(m_KspaceArtifacts.at(i))->GetKspaceCropping();
+ // check k-space undersampling
if (m_Upsampling<1)
m_Upsampling = 1;
if (m_TissueMask.IsNotNull())
{
// use input tissue mask
m_Spacing = m_TissueMask->GetSpacing();
m_Origin = m_TissueMask->GetOrigin();
m_DirectionMatrix = m_TissueMask->GetDirection();
m_ImageRegion = m_TissueMask->GetLargestPossibleRegion();
- if (m_Upsampling>1)
+ if (m_Upsampling>1.00001)
{
+ MITK_INFO << "Adding ringing artifacts. Image upsampling factor: " << m_Upsampling;
ImageRegion<3> region = m_ImageRegion;
region.SetSize(0, m_ImageRegion.GetSize(0)*m_Upsampling);
region.SetSize(1, m_ImageRegion.GetSize(1)*m_Upsampling);
- mitk::Vector3D spacing = m_Spacing;
+ itk::Vector<double> spacing = m_Spacing;
spacing[0] /= m_Upsampling;
spacing[1] /= m_Upsampling;
itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::Pointer rescaler = itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::New();
rescaler->SetInput(0,m_TissueMask);
rescaler->SetOutputMaximum(100);
rescaler->SetOutputMinimum(0);
rescaler->Update();
itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer resampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
resampler->SetInput(rescaler->GetOutput());
resampler->SetOutputParametersFromImage(m_TissueMask);
resampler->SetSize(region.GetSize());
resampler->SetOutputSpacing(spacing);
resampler->Update();
m_TissueMask = resampler->GetOutput();
}
MITK_INFO << "Using tissue mask";
}
// initialize output dwi image
OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( m_Spacing );
outImage->SetOrigin( m_Origin );
outImage->SetDirection( m_DirectionMatrix );
outImage->SetLargestPossibleRegion( m_ImageRegion );
outImage->SetBufferedRegion( m_ImageRegion );
outImage->SetRequestedRegion( m_ImageRegion );
outImage->SetVectorLength( m_FiberModels[0]->GetNumGradients() );
outImage->Allocate();
OutputImageType::PixelType temp;
temp.SetSize(m_FiberModels[0]->GetNumGradients());
temp.Fill(0.0);
outImage->FillBuffer(temp);
// is input slize size a power of two?
- int x=2; int y=2;
- while (x<m_ImageRegion.GetSize(0))
- x *= 2;
- while (y<m_ImageRegion.GetSize(1))
- y *= 2;
+ int x=m_ImageRegion.GetSize(0); int y=m_ImageRegion.GetSize(1);
+ if ( x%2 == 1 )
+ x += 1;
+ if ( y%2 == 1 )
+ y += 1;
// if not, adjust size and dimension (needed for FFT); zero-padding
if (x!=m_ImageRegion.GetSize(0))
- {
- MITK_INFO << "Adjusting image width: " << m_ImageRegion.GetSize(0) << " --> " << x << " --> " << x*m_Upsampling;
m_ImageRegion.SetSize(0, x);
- }
if (y!=m_ImageRegion.GetSize(1))
- {
- MITK_INFO << "Adjusting image height: " << m_ImageRegion.GetSize(1) << " --> " << y << " --> " << y*m_Upsampling;
m_ImageRegion.SetSize(1, y);
- }
-
- // initialize k-space image
- m_KspaceImage = ItkDoubleImgType::New();
- m_KspaceImage->SetSpacing( m_Spacing );
- m_KspaceImage->SetOrigin( m_Origin );
- m_KspaceImage->SetDirection( m_DirectionMatrix );
- m_KspaceImage->SetLargestPossibleRegion( m_ImageRegion );
- m_KspaceImage->SetBufferedRegion( m_ImageRegion );
- m_KspaceImage->SetRequestedRegion( m_ImageRegion );
- m_KspaceImage->Allocate();
- m_KspaceImage->FillBuffer(0);
// apply undersampling to image parameters
m_UpsampledSpacing = m_Spacing;
m_UpsampledImageRegion = m_ImageRegion;
m_UpsampledSpacing[0] /= m_Upsampling;
m_UpsampledSpacing[1] /= m_Upsampling;
m_UpsampledImageRegion.SetSize(0, m_ImageRegion.GetSize()[0]*m_Upsampling);
m_UpsampledImageRegion.SetSize(1, m_ImageRegion.GetSize()[1]*m_Upsampling);
// everything from here on is using the upsampled image parameters!!!
if (m_TissueMask.IsNull())
{
m_TissueMask = ItkUcharImgType::New();
m_TissueMask->SetSpacing( m_UpsampledSpacing );
m_TissueMask->SetOrigin( m_Origin );
m_TissueMask->SetDirection( m_DirectionMatrix );
m_TissueMask->SetLargestPossibleRegion( m_UpsampledImageRegion );
m_TissueMask->SetBufferedRegion( m_UpsampledImageRegion );
m_TissueMask->SetRequestedRegion( m_UpsampledImageRegion );
m_TissueMask->Allocate();
m_TissueMask->FillBuffer(1);
}
+ // resample frequency map
+ if (m_FrequencyMap.IsNotNull())
+ {
+ itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer resampler = itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
+ resampler->SetInput(m_FrequencyMap);
+ resampler->SetOutputParametersFromImage(m_FrequencyMap);
+ resampler->SetSize(m_UpsampledImageRegion.GetSize());
+ resampler->SetOutputSpacing(m_UpsampledSpacing);
+ resampler->Update();
+ m_FrequencyMap = resampler->GetOutput();
+ }
+
+ // initialize volume fraction images
+ m_VolumeFractions.clear();
+ for (int i=0; i<m_FiberModels.size()+m_NonFiberModels.size(); i++)
+ {
+ ItkDoubleImgType::Pointer tempimg = ItkDoubleImgType::New();
+ tempimg->SetSpacing( m_UpsampledSpacing );
+ tempimg->SetOrigin( m_Origin );
+ tempimg->SetDirection( m_DirectionMatrix );
+ tempimg->SetLargestPossibleRegion( m_UpsampledImageRegion );
+ tempimg->SetBufferedRegion( m_UpsampledImageRegion );
+ tempimg->SetRequestedRegion( m_UpsampledImageRegion );
+ tempimg->Allocate();
+ tempimg->FillBuffer(0);
+ m_VolumeFractions.push_back(tempimg);
+ }
+
// resample fiber bundle for sufficient voxel coverage
double segmentVolume = 0.0001;
float minSpacing = 1;
if(m_UpsampledSpacing[0]<m_UpsampledSpacing[1] && m_UpsampledSpacing[0]<m_UpsampledSpacing[2])
minSpacing = m_UpsampledSpacing[0];
else if (m_UpsampledSpacing[1] < m_UpsampledSpacing[2])
minSpacing = m_UpsampledSpacing[1];
else
minSpacing = m_UpsampledSpacing[2];
FiberBundleType fiberBundle = m_FiberBundle->GetDeepCopy();
fiberBundle->ResampleFibers(minSpacing/m_VolumeAccuracy);
double mmRadius = m_FiberRadius/1000;
if (mmRadius>0)
segmentVolume = M_PI*mmRadius*mmRadius*minSpacing/m_VolumeAccuracy;
- // generate double images to wokr with because we don't want to lose precision
+ // generate double images to work with because we don't want to lose precision
// we use a separate image for each compartment model
std::vector< DoubleDwiType::Pointer > compartments;
for (int i=0; i<m_FiberModels.size()+m_NonFiberModels.size(); i++)
{
DoubleDwiType::Pointer doubleDwi = DoubleDwiType::New();
doubleDwi->SetSpacing( m_UpsampledSpacing );
doubleDwi->SetOrigin( m_Origin );
doubleDwi->SetDirection( m_DirectionMatrix );
doubleDwi->SetLargestPossibleRegion( m_UpsampledImageRegion );
doubleDwi->SetBufferedRegion( m_UpsampledImageRegion );
doubleDwi->SetRequestedRegion( m_UpsampledImageRegion );
doubleDwi->SetVectorLength( m_FiberModels[0]->GetNumGradients() );
doubleDwi->Allocate();
DoubleDwiType::PixelType pix;
pix.SetSize(m_FiberModels[0]->GetNumGradients());
pix.Fill(0.0);
doubleDwi->FillBuffer(pix);
compartments.push_back(doubleDwi);
}
double interpFact = 2*atan(-0.5*m_InterpolationShrink);
double maxVolume = 0;
- vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
- vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
- vLines->InitTraversal();
-
MITK_INFO << "Generating signal of " << m_FiberModels.size() << " fiber compartments";
+ vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
boost::progress_display disp(numFibers);
for( int i=0; i<numFibers; i++ )
{
- ++disp;
- vtkIdType numPoints(0);
- vtkIdType* points(NULL);
- vLines->GetNextCell ( numPoints, points );
+ vtkCell* cell = fiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
+
if (numPoints<2)
continue;
for( int j=0; j<numPoints; j++)
{
- double* temp = fiberPolyData->GetPoint(points[j]);
+ double* temp = points->GetPoint(j);
itk::Point<float, 3> vertex = GetItkPoint(temp);
itk::Vector<double> v = GetItkVector(temp);
itk::Vector<double, 3> dir(3);
if (j<numPoints-1)
- dir = GetItkVector(fiberPolyData->GetPoint(points[j+1]))-v;
+ dir = GetItkVector(points->GetPoint(j+1))-v;
else
- dir = v-GetItkVector(fiberPolyData->GetPoint(points[j-1]));
+ dir = v-GetItkVector(points->GetPoint(j-1));
itk::Index<3> idx;
itk::ContinuousIndex<float, 3> contIndex;
m_TissueMask->TransformPhysicalPointToIndex(vertex, idx);
m_TissueMask->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
+ if (!m_UseInterpolation) // use nearest neighbour interpolation
+ {
+ if (!m_TissueMask->GetLargestPossibleRegion().IsInside(idx) || m_TissueMask->GetPixel(idx)<=0)
+ continue;
+
+ // generate signal for each fiber compartment
+ for (int k=0; k<m_FiberModels.size(); k++)
+ {
+ DoubleDwiType::Pointer doubleDwi = compartments.at(k);
+ m_FiberModels[k]->SetFiberDirection(dir);
+ DoubleDwiType::PixelType pix = doubleDwi->GetPixel(idx);
+ pix += segmentVolume*m_FiberModels[k]->SimulateMeasurement();
+ doubleDwi->SetPixel(idx, pix );
+ if (pix[baselineIndex]>maxVolume)
+ maxVolume = pix[baselineIndex];
+ }
+
+ continue;
+ }
+
double frac_x = contIndex[0] - idx[0];
double frac_y = contIndex[1] - idx[1];
double frac_z = contIndex[2] - idx[2];
if (frac_x<0)
{
idx[0] -= 1;
frac_x += 1;
}
if (frac_y<0)
{
idx[1] -= 1;
frac_y += 1;
}
if (frac_z<0)
{
idx[2] -= 1;
frac_z += 1;
}
frac_x = atan((0.5-frac_x)*m_InterpolationShrink)/interpFact + 0.5;
frac_y = atan((0.5-frac_y)*m_InterpolationShrink)/interpFact + 0.5;
frac_z = atan((0.5-frac_z)*m_InterpolationShrink)/interpFact + 0.5;
// use trilinear interpolation
itk::Index<3> newIdx;
for (int x=0; x<2; x++)
{
frac_x = 1-frac_x;
for (int y=0; y<2; y++)
{
frac_y = 1-frac_y;
for (int z=0; z<2; z++)
{
frac_z = 1-frac_z;
newIdx[0] = idx[0]+x;
newIdx[1] = idx[1]+y;
newIdx[2] = idx[2]+z;
double frac = frac_x*frac_y*frac_z;
// is position valid?
if (!m_TissueMask->GetLargestPossibleRegion().IsInside(newIdx) || m_TissueMask->GetPixel(newIdx)<=0)
continue;
// generate signal for each fiber compartment
for (int k=0; k<m_FiberModels.size(); k++)
{
DoubleDwiType::Pointer doubleDwi = compartments.at(k);
m_FiberModels[k]->SetFiberDirection(dir);
DoubleDwiType::PixelType pix = doubleDwi->GetPixel(newIdx);
pix += segmentVolume*frac*m_FiberModels[k]->SimulateMeasurement();
doubleDwi->SetPixel(newIdx, pix );
if (pix[baselineIndex]>maxVolume)
maxVolume = pix[baselineIndex];
}
}
}
}
}
+ ++disp;
}
MITK_INFO << "Generating signal of " << m_NonFiberModels.size() << " non-fiber compartments";
ImageRegionIterator<ItkUcharImgType> it3(m_TissueMask, m_TissueMask->GetLargestPossibleRegion());
boost::progress_display disp3(m_TissueMask->GetLargestPossibleRegion().GetNumberOfPixels());
double voxelVolume = m_UpsampledSpacing[0]*m_UpsampledSpacing[1]*m_UpsampledSpacing[2];
double fact = 1;
if (m_FiberRadius<0.0001)
fact = voxelVolume/maxVolume;
while(!it3.IsAtEnd())
{
- ++disp3;
DoubleDwiType::IndexType index = it3.GetIndex();
if (it3.Get()>0)
{
// get fiber volume fraction
DoubleDwiType::Pointer fiberDwi = compartments.at(0);
DoubleDwiType::PixelType fiberPix = fiberDwi->GetPixel(index); // intra axonal compartment
if (fact>1) // auto scale intra-axonal if no fiber radius is specified
{
fiberPix *= fact;
fiberDwi->SetPixel(index, fiberPix);
}
double f = fiberPix[baselineIndex];
if (f>voxelVolume || f>0 && m_EnforcePureFiberVoxels) // more fiber than space in voxel?
{
fiberDwi->SetPixel(index, fiberPix*voxelVolume/f);
for (int i=1; i<m_FiberModels.size(); i++)
{
DoubleDwiType::PixelType pix; pix.Fill(0.0);
compartments.at(i)->SetPixel(index, pix);
+ m_VolumeFractions.at(i)->SetPixel(index, 1);
}
}
else
{
+ m_VolumeFractions.at(0)->SetPixel(index, f);
+
double nonf = voxelVolume-f; // non-fiber volume
double inter = 0;
if (m_FiberModels.size()>1)
- inter = nonf * f; // intra-axonal fraction of non fiber compartment scales linearly with f
- double other = nonf - inter; // rest of compartment
+ inter = nonf * f/voxelVolume; // intra-axonal fraction of non fiber compartment scales linearly with f
+ double other = nonf - inter; // rest of compartment
+ double singleinter = inter/(m_FiberModels.size()-1);
// adjust non-fiber and intra-axonal signal
for (int i=1; i<m_FiberModels.size(); i++)
{
DoubleDwiType::Pointer doubleDwi = compartments.at(i);
DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
if (pix[baselineIndex]>0)
pix /= pix[baselineIndex];
- pix *= inter;
+ pix *= singleinter;
doubleDwi->SetPixel(index, pix);
+ m_VolumeFractions.at(i)->SetPixel(index, singleinter/voxelVolume);
}
for (int i=0; i<m_NonFiberModels.size(); i++)
{
DoubleDwiType::Pointer doubleDwi = compartments.at(i+m_FiberModels.size());
DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index) + m_NonFiberModels[i]->SimulateMeasurement()*other*m_NonFiberModels[i]->GetWeight();
doubleDwi->SetPixel(index, pix);
+ m_VolumeFractions.at(i+m_FiberModels.size())->SetPixel(index, other/voxelVolume*m_NonFiberModels[i]->GetWeight());
}
}
}
++it3;
+ ++disp3;
}
// do k-space stuff
- MITK_INFO << "Adjusting complex signal";
- compartments = AddKspaceArtifacts(compartments);
+ DoubleDwiType::Pointer doubleOutImage;
+ if (m_FrequencyMap.IsNotNull() || !m_KspaceArtifacts.empty() || m_kOffset>0 || m_SimulateRelaxation || m_SimulateEddyCurrents || m_Upsampling>1.00001)
+ {
+ MITK_INFO << "Adjusting complex signal";
+ doubleOutImage = DoKspaceStuff(compartments);
+ m_SignalScale = 1;
+ }
+ else
+ {
+ MITK_INFO << "Summing compartments";
+ doubleOutImage = compartments.at(0);
- MITK_INFO << "Summing compartments and adding noise";
+ for (int i=1; i<compartments.size(); i++)
+ {
+ itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::Pointer adder = itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::New();
+ adder->SetInput1(doubleOutImage);
+ adder->SetInput2(compartments.at(i));
+ adder->Update();
+ doubleOutImage = adder->GetOutput();
+ }
+ }
+
+ MITK_INFO << "Finalizing image";
unsigned int window = 0;
unsigned int min = itk::NumericTraits<unsigned int>::max();
ImageRegionIterator<DWIImageType> it4 (outImage, outImage->GetLargestPossibleRegion());
DoubleDwiType::PixelType signal; signal.SetSize(m_FiberModels[0]->GetNumGradients());
boost::progress_display disp4(outImage->GetLargestPossibleRegion().GetNumberOfPixels());
while(!it4.IsAtEnd())
{
++disp4;
DWIImageType::IndexType index = it4.GetIndex();
- signal.Fill(0.0);
-
- // adjust fiber signal
- for (int i=0; i<m_FiberModels.size(); i++)
- signal += compartments.at(i)->GetPixel(index)*m_SignalScale;
-
- // adjust non-fiber signal
- for (int i=0; i<m_NonFiberModels.size(); i++)
- signal += compartments.at(m_FiberModels.size()+i)->GetPixel(index)*m_SignalScale;
+ signal = doubleOutImage->GetPixel(index)*m_SignalScale;
- DoubleDwiType::PixelType accu = signal; accu.Fill(0.0);
- for (int i=0; i<m_NumberOfRepetitions; i++)
+ if (m_NoiseModel->GetNoiseVariance() > 0)
{
- DoubleDwiType::PixelType temp = signal;
- m_NoiseModel->AddNoise(temp);
- accu += temp;
+ DoubleDwiType::PixelType accu = signal; accu.Fill(0.0);
+ for (int i=0; i<m_NumberOfRepetitions; i++)
+ {
+ DoubleDwiType::PixelType temp = signal;
+ m_NoiseModel->AddNoise(temp);
+ accu += temp;
+ }
+ signal = accu/m_NumberOfRepetitions;
}
- signal = accu/m_NumberOfRepetitions;
+
for (int i=0; i<signal.Size(); i++)
{
if (signal[i]>0)
signal[i] = floor(signal[i]+0.5);
else
signal[i] = ceil(signal[i]-0.5);
if (!m_FiberModels.at(0)->IsBaselineIndex(i) && signal[i]>window)
window = signal[i];
if (!m_FiberModels.at(0)->IsBaselineIndex(i) && signal[i]<min)
min = signal[i];
}
it4.Set(signal);
++it4;
}
window -= min;
unsigned int level = window/2 + min;
m_LevelWindow.SetLevelWindow(level, window);
this->SetNthOutput(0, outImage);
}
itk::Point<float, 3> TractsToDWIImageFilter::GetItkPoint(double point[3])
{
itk::Point<float, 3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
return itkPoint;
}
itk::Vector<double, 3> TractsToDWIImageFilter::GetItkVector(double point[3])
{
itk::Vector<double, 3> itkVector;
itkVector[0] = point[0];
itkVector[1] = point[1];
itkVector[2] = point[2];
return itkVector;
}
vnl_vector_fixed<double, 3> TractsToDWIImageFilter::GetVnlVector(double point[3])
{
vnl_vector_fixed<double, 3> vnlVector;
vnlVector[0] = point[0];
vnlVector[1] = point[1];
vnlVector[2] = point[2];
return vnlVector;
}
vnl_vector_fixed<double, 3> TractsToDWIImageFilter::GetVnlVector(Vector<float,3>& vector)
{
vnl_vector_fixed<double, 3> vnlVector;
vnlVector[0] = vector[0];
vnlVector[1] = vector[1];
vnlVector[2] = vector[2];
return vnlVector;
}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
old mode 100644
new mode 100755
index 27044e66da..c09dfbc671
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
@@ -1,132 +1,151 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkTractsToDWIImageFilter_h__
#define __itkTractsToDWIImageFilter_h__
// MITK
#include <mitkFiberBundleX.h>
#include <mitkDiffusionSignalModel.h>
#include <mitkDiffusionNoiseModel.h>
#include <mitkKspaceArtifact.h>
-#include <mitkGibbsRingingArtifact.h>
-#include <mitkSignalDecay.h>
// ITK
#include <itkImage.h>
#include <itkVectorImage.h>
#include <itkImageSource.h>
-#include <itkFFTRealToComplexConjugateImageFilter.h>
-#include <itkFFTComplexConjugateToRealImageFilter.h>
+#include <itkVnlForwardFFTImageFilter.h>
+#include <itkVnlInverseFFTImageFilter.h>
#include <cmath>
typedef itk::VectorImage< short, 3 > DWIImageType;
namespace itk
{
/**
* \brief Generates artificial diffusion weighted image volume from the input fiberbundle using a generic multicompartment model. */
class TractsToDWIImageFilter : public ImageSource< DWIImageType >
{
public:
typedef TractsToDWIImageFilter Self;
typedef ImageSource< DWIImageType > Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
typedef itk::Image<double, 3> ItkDoubleImgType;
typedef itk::Image<float, 3> ItkFloatImgType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef mitk::FiberBundleX::Pointer FiberBundleType;
typedef itk::VectorImage< double, 3 > DoubleDwiType;
typedef std::vector< mitk::KspaceArtifact<double>* > KspaceArtifactList;
typedef std::vector< mitk::DiffusionSignalModel<double>* > DiffusionModelList;
typedef itk::Matrix<double, 3, 3> MatrixType;
typedef mitk::DiffusionNoiseModel<double> NoiseModelType;
typedef itk::Image< double, 2 > SliceType;
- typedef itk::FFTRealToComplexConjugateImageFilter< double, 2 >::OutputImageType ComplexSliceType;
+ typedef itk::VnlForwardFFTImageFilter<SliceType>::OutputImageType ComplexSliceType;
itkNewMacro(Self)
itkTypeMacro( TractsToDWIImageFilter, ImageToImageFilter )
// input
itkSetMacro( SignalScale, double )
itkSetMacro( FiberRadius, double )
itkSetMacro( InterpolationShrink, double ) ///< large values shrink (towards nearest neighbour interpolation), small values strech interpolation function (towards linear interpolation)
itkSetMacro( VolumeAccuracy, unsigned int ) ///< determines fiber sampling density and thereby the accuracy of the fiber volume fraction
itkSetMacro( FiberBundle, FiberBundleType ) ///< input fiber bundle
itkSetMacro( Spacing, mitk::Vector3D ) ///< output image spacing
itkSetMacro( Origin, mitk::Point3D ) ///< output image origin
itkSetMacro( DirectionMatrix, MatrixType ) ///< output image rotation
itkSetMacro( EnforcePureFiberVoxels, bool ) ///< treat all voxels containing at least one fiber as fiber-only (actually disable non-fiber compartments for this voxel).
itkSetMacro( ImageRegion, ImageRegion<3> ) ///< output image size
itkSetMacro( NumberOfRepetitions, unsigned int ) ///< number of acquisition repetitions to reduce noise (default is no additional repetition)
itkSetMacro( TissueMask, ItkUcharImgType::Pointer ) ///< voxels outside of this binary mask contain only noise (are treated as air)
- itkGetMacro( KspaceImage, ItkDoubleImgType::Pointer )
void SetNoiseModel(NoiseModelType* noiseModel){ m_NoiseModel = noiseModel; } ///< generates the noise added to the image values
void SetFiberModels(DiffusionModelList modelList){ m_FiberModels = modelList; } ///< generate signal of fiber compartments
void SetNonFiberModels(DiffusionModelList modelList){ m_NonFiberModels = modelList; } ///< generate signal of non-fiber compartments
void SetKspaceArtifacts(KspaceArtifactList artifactList){ m_KspaceArtifacts = artifactList; }
mitk::LevelWindow GetLevelWindow(){ return m_LevelWindow; }
+ itkSetMacro( FrequencyMap, ItkDoubleImgType::Pointer )
+ itkSetMacro( kOffset, double )
+ itkSetMacro( tLine, double )
+ itkSetMacro( tInhom, double )
+ itkSetMacro( TE, double )
+ itkSetMacro( UseInterpolation, bool )
+ itkSetMacro( SimulateEddyCurrents, bool )
+ itkSetMacro( SimulateRelaxation, bool )
+ itkSetMacro( EddyGradientStrength, double )
+ itkSetMacro( Upsampling, double )
+
+ // output
+ std::vector< ItkDoubleImgType::Pointer > GetVolumeFractions(){ return m_VolumeFractions; }
void GenerateData();
protected:
TractsToDWIImageFilter();
virtual ~TractsToDWIImageFilter();
itk::Point<float, 3> GetItkPoint(double point[3]);
itk::Vector<double, 3> GetItkVector(double point[3]);
vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
vnl_vector_fixed<double, 3> GetVnlVector(Vector< float, 3 >& vector);
/** Transform generated image compartment by compartment, channel by channel and slice by slice using FFT and add k-space artifacts. */
- std::vector< DoubleDwiType::Pointer > AddKspaceArtifacts(std::vector< DoubleDwiType::Pointer >& images);
+ DoubleDwiType::Pointer DoKspaceStuff(std::vector< DoubleDwiType::Pointer >& images);
/** Rearrange FFT output to shift low frequencies to the iamge center (correct itk). */
TractsToDWIImageFilter::ComplexSliceType::Pointer RearrangeSlice(ComplexSliceType::Pointer slice);
- mitk::Vector3D m_Spacing; ///< output image spacing
- mitk::Vector3D m_UpsampledSpacing;
+ itk::Vector<double> m_Spacing; ///< output image spacing
+ itk::Vector<double> m_UpsampledSpacing;
mitk::Point3D m_Origin; ///< output image origin
MatrixType m_DirectionMatrix; ///< output image rotation
ImageRegion<3> m_ImageRegion; ///< output image size
ImageRegion<3> m_UpsampledImageRegion;
ItkUcharImgType::Pointer m_TissueMask; ///< voxels outside of this binary mask contain only noise (are treated as air)
+ ItkDoubleImgType::Pointer m_FrequencyMap; ///< map of the B0 inhomogeneities
+ double m_kOffset;
+ double m_tLine;
+ double m_TE;
+ double m_tInhom;
FiberBundleType m_FiberBundle; ///< input fiber bundle
DiffusionModelList m_FiberModels; ///< generate signal of fiber compartments
DiffusionModelList m_NonFiberModels; ///< generate signal of non-fiber compartments
KspaceArtifactList m_KspaceArtifacts;
NoiseModelType* m_NoiseModel; ///< generates the noise added to the image values
bool m_CircleDummy;
unsigned int m_VolumeAccuracy;
- ItkDoubleImgType::Pointer m_KspaceImage;
- unsigned int m_Upsampling;
+ double m_Upsampling; ///< causes ringing artifacts
unsigned int m_NumberOfRepetitions;
bool m_EnforcePureFiberVoxels;
double m_InterpolationShrink;
double m_FiberRadius;
double m_SignalScale;
mitk::LevelWindow m_LevelWindow;
+ bool m_UseInterpolation;
+ std::vector< ItkDoubleImgType::Pointer > m_VolumeFractions; ///< one double image for each compartment containing the corresponding volume fraction per voxel
+ bool m_SimulateRelaxation;
+ bool m_SimulateEddyCurrents;
+ double m_EddyGradientStrength;
};
}
#include "itkTractsToDWIImageFilter.cpp"
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.cpp
index 9b34696508..b2dac9cf49 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.cpp
@@ -1,160 +1,160 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "itkTractsToFiberEndingsImageFilter.h"
// VTK
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <boost/progress.hpp>
namespace itk{
template< class OutputImageType >
TractsToFiberEndingsImageFilter< OutputImageType >::TractsToFiberEndingsImageFilter()
: m_InvertImage(false)
, m_UpsamplingFactor(1)
, m_InputImage(NULL)
, m_UseImageGeometry(false)
, m_BinaryOutput(false)
{
}
template< class OutputImageType >
TractsToFiberEndingsImageFilter< OutputImageType >::~TractsToFiberEndingsImageFilter()
{
}
template< class OutputImageType >
itk::Point<float, 3> TractsToFiberEndingsImageFilter< OutputImageType >::GetItkPoint(double point[3])
{
itk::Point<float, 3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
return itkPoint;
}
template< class OutputImageType >
void TractsToFiberEndingsImageFilter< OutputImageType >::GenerateData()
{
// generate upsampled image
mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
typename OutputImageType::Pointer outImage = this->GetOutput();
// calculate new image parameters
- mitk::Vector3D newSpacing;
+ itk::Vector<double, 3> newSpacing;
mitk::Point3D newOrigin;
itk::Matrix<double, 3, 3> newDirection;
ImageRegion<3> upsampledRegion;
if (m_UseImageGeometry && !m_InputImage.IsNull())
{
newSpacing = m_InputImage->GetSpacing()/m_UpsamplingFactor;
upsampledRegion = m_InputImage->GetLargestPossibleRegion();
newOrigin = m_InputImage->GetOrigin();
typename OutputImageType::RegionType::SizeType size = upsampledRegion.GetSize();
size[0] *= m_UpsamplingFactor;
size[1] *= m_UpsamplingFactor;
size[2] *= m_UpsamplingFactor;
upsampledRegion.SetSize(size);
newDirection = m_InputImage->GetDirection();
}
else
{
newSpacing = geometry->GetSpacing()/m_UpsamplingFactor;
newOrigin = geometry->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
newOrigin[0] += bounds.GetElement(0);
newOrigin[1] += bounds.GetElement(2);
newOrigin[2] += bounds.GetElement(4);
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
newDirection[j][i] = geometry->GetMatrixColumn(i)[j];
upsampledRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
upsampledRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
upsampledRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
}
typename OutputImageType::RegionType::SizeType upsampledSize = upsampledRegion.GetSize();
// apply new image parameters
outImage->SetSpacing( newSpacing );
outImage->SetOrigin( newOrigin );
outImage->SetDirection( newDirection );
outImage->SetRegions( upsampledRegion );
outImage->Allocate();
int w = upsampledSize[0];
int h = upsampledSize[1];
int d = upsampledSize[2];
// set/initialize output
OutPixelType* outImageBufferPointer = (OutPixelType*)outImage->GetBufferPointer();
for (int i=0; i<w*h*d; i++)
outImageBufferPointer[i] = 0;
// resample fiber bundle
float minSpacing = 1;
if(newSpacing[0]<newSpacing[1] && newSpacing[0]<newSpacing[2])
minSpacing = newSpacing[0];
else if (newSpacing[1] < newSpacing[2])
minSpacing = newSpacing[1];
else
minSpacing = newSpacing[2];
vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
vLines->InitTraversal();
int numFibers = m_FiberBundle->GetNumFibers();
boost::progress_display disp(numFibers);
for( int i=0; i<numFibers; i++ )
{
++disp;
vtkIdType numPoints(0);
vtkIdType* points(NULL);
vLines->GetNextCell ( numPoints, points );
// fill output image
if (numPoints>0)
{
itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[0]));
itk::Index<3> index;
outImage->TransformPhysicalPointToIndex(vertex, index);
if (m_BinaryOutput)
outImage->SetPixel(index, 1);
else
outImage->SetPixel(index, outImage->GetPixel(index)+1);
}
if (numPoints>2)
{
itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[numPoints-1]));
itk::Index<3> index;
outImage->TransformPhysicalPointToIndex(vertex, index);
if (m_BinaryOutput)
outImage->SetPixel(index, 1);
else
outImage->SetPixel(index, outImage->GetPixel(index)+1);
}
}
if (m_InvertImage)
for (int i=0; i<w*h*d; i++)
outImageBufferPointer[i] = 1-outImageBufferPointer[i];
}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.cpp
index b353e518c1..60fad63e14 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.cpp
@@ -1,286 +1,286 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "itkTractsToRgbaImageFilter.h"
// VTK
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
// misc
#include <math.h>
#include <boost/progress.hpp>
namespace itk{
template< class OutputImageType >
TractsToRgbaImageFilter< OutputImageType >::TractsToRgbaImageFilter()
: m_UpsamplingFactor(1)
, m_InputImage(NULL)
, m_UseImageGeometry(false)
{
}
template< class OutputImageType >
TractsToRgbaImageFilter< OutputImageType >::~TractsToRgbaImageFilter()
{
}
template< class OutputImageType >
itk::Point<float, 3> TractsToRgbaImageFilter< OutputImageType >::GetItkPoint(double point[3])
{
itk::Point<float, 3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
return itkPoint;
}
template< class OutputImageType >
void TractsToRgbaImageFilter< OutputImageType >::GenerateData()
{
if(&typeid(OutPixelType) != &typeid(itk::RGBAPixel<unsigned char>))
return;
// generate upsampled image
mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
typename OutputImageType::Pointer outImage = this->GetOutput();
// calculate new image parameters
- mitk::Vector3D newSpacing;
+ itk::Vector<double,3> newSpacing;
mitk::Point3D newOrigin;
itk::Matrix<double, 3, 3> newDirection;
ImageRegion<3> upsampledRegion;
if (m_UseImageGeometry && !m_InputImage.IsNull())
{
newSpacing = m_InputImage->GetSpacing()/m_UpsamplingFactor;
upsampledRegion = m_InputImage->GetLargestPossibleRegion();
newOrigin = m_InputImage->GetOrigin();
typename OutputImageType::RegionType::SizeType size = upsampledRegion.GetSize();
size[0] *= m_UpsamplingFactor;
size[1] *= m_UpsamplingFactor;
size[2] *= m_UpsamplingFactor;
upsampledRegion.SetSize(size);
newDirection = m_InputImage->GetDirection();
}
else
{
newSpacing = geometry->GetSpacing()/m_UpsamplingFactor;
newOrigin = geometry->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
newOrigin[0] += bounds.GetElement(0);
newOrigin[1] += bounds.GetElement(2);
newOrigin[2] += bounds.GetElement(4);
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
newDirection[j][i] = geometry->GetMatrixColumn(i)[j];
upsampledRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
upsampledRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
upsampledRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
}
typename OutputImageType::RegionType::SizeType upsampledSize = upsampledRegion.GetSize();
// apply new image parameters
outImage->SetSpacing( newSpacing );
outImage->SetOrigin( newOrigin );
outImage->SetDirection( newDirection );
outImage->SetRegions( upsampledRegion );
outImage->Allocate();
int w = upsampledSize[0];
int h = upsampledSize[1];
int d = upsampledSize[2];
// set/initialize output
unsigned char* outImageBufferPointer = (unsigned char*)outImage->GetBufferPointer();
float* buffer = new float[w*h*d*4];
for (int i=0; i<w*h*d*4; i++)
buffer[i] = 0;
// resample fiber bundle
float minSpacing = 1;
if(newSpacing[0]<newSpacing[1] && newSpacing[0]<newSpacing[2])
minSpacing = newSpacing[0];
else if (newSpacing[1] < newSpacing[2])
minSpacing = newSpacing[1];
else
minSpacing = newSpacing[2];
m_FiberBundle = m_FiberBundle->GetDeepCopy();
m_FiberBundle->ResampleFibers(minSpacing);
vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
vLines->InitTraversal();
int numFibers = m_FiberBundle->GetNumFibers();
boost::progress_display disp(numFibers);
for( int i=0; i<numFibers; i++ )
{
++disp;
vtkIdType numPoints(0);
vtkIdType* points(NULL);
vLines->GetNextCell ( numPoints, points );
// calc directions (which are used as weights)
std::list< itk::Point<float, 3> > rgbweights;
std::list<float> intensities;
for( int j=0; j<numPoints-1; j++)
{
itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[j]));
itk::Point<float, 3> vertexPost = GetItkPoint(fiberPolyData->GetPoint(points[j+1]));
itk::Point<float, 3> dir;
dir[0] = fabs((vertexPost[0] - vertex[0]) * outImage->GetSpacing()[0]);
dir[1] = fabs((vertexPost[1] - vertex[1]) * outImage->GetSpacing()[1]);
dir[2] = fabs((vertexPost[2] - vertex[2]) * outImage->GetSpacing()[2]);
rgbweights.push_back(dir);
float intensity = sqrt(dir[0]*dir[0]+dir[1]*dir[1]+dir[2]*dir[2]);
intensities.push_back(intensity);
// last point gets same as previous one
if(j==numPoints-2)
{
rgbweights.push_back(dir);
intensities.push_back(intensity);
}
}
// fill output image
for( int j=0; j<numPoints; j++)
{
itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[j]));
itk::Index<3> index;
itk::ContinuousIndex<float, 3> contIndex;
outImage->TransformPhysicalPointToIndex(vertex, index);
outImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
float frac_x = contIndex[0] - index[0];
float frac_y = contIndex[1] - index[1];
float frac_z = contIndex[2] - index[2];
int px = index[0];
if (frac_x<0)
{
px -= 1;
frac_x += 1;
}
int py = index[1];
if (frac_y<0)
{
py -= 1;
frac_y += 1;
}
int pz = index[2];
if (frac_z<0)
{
pz -= 1;
frac_z += 1;
}
// int coordinates inside image?
if (px < 0 || px >= w-1)
continue;
if (py < 0 || py >= h-1)
continue;
if (pz < 0 || pz >= d-1)
continue;
float scale = 100 * pow((float)m_UpsamplingFactor,3);
itk::Point<float, 3> rgbweight = rgbweights.front();
rgbweights.pop_front();
float intweight = intensities.front();
intensities.pop_front();
// add to r-channel in output image
buffer[0+4*( px + w*(py + h*pz ))] += (1-frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[0] * scale;
buffer[0+4*( px + w*(py+1+ h*pz ))] += (1-frac_x)*( frac_y)*(1-frac_z) * rgbweight[0] * scale;
buffer[0+4*( px + w*(py + h*pz+h))] += (1-frac_x)*(1-frac_y)*( frac_z) * rgbweight[0] * scale;
buffer[0+4*( px + w*(py+1+ h*pz+h))] += (1-frac_x)*( frac_y)*( frac_z) * rgbweight[0] * scale;
buffer[0+4*( px+1 + w*(py + h*pz ))] += ( frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[0] * scale;
buffer[0+4*( px+1 + w*(py + h*pz+h))] += ( frac_x)*(1-frac_y)*( frac_z) * rgbweight[0] * scale;
buffer[0+4*( px+1 + w*(py+1+ h*pz ))] += ( frac_x)*( frac_y)*(1-frac_z) * rgbweight[0] * scale;
buffer[0+4*( px+1 + w*(py+1+ h*pz+h))] += ( frac_x)*( frac_y)*( frac_z) * rgbweight[0] * scale;
// add to g-channel in output image
buffer[1+4*( px + w*(py + h*pz ))] += (1-frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[1] * scale;
buffer[1+4*( px + w*(py+1+ h*pz ))] += (1-frac_x)*( frac_y)*(1-frac_z) * rgbweight[1] * scale;
buffer[1+4*( px + w*(py + h*pz+h))] += (1-frac_x)*(1-frac_y)*( frac_z) * rgbweight[1] * scale;
buffer[1+4*( px + w*(py+1+ h*pz+h))] += (1-frac_x)*( frac_y)*( frac_z) * rgbweight[1] * scale;
buffer[1+4*( px+1 + w*(py + h*pz ))] += ( frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[1] * scale;
buffer[1+4*( px+1 + w*(py + h*pz+h))] += ( frac_x)*(1-frac_y)*( frac_z) * rgbweight[1] * scale;
buffer[1+4*( px+1 + w*(py+1+ h*pz ))] += ( frac_x)*( frac_y)*(1-frac_z) * rgbweight[1] * scale;
buffer[1+4*( px+1 + w*(py+1+ h*pz+h))] += ( frac_x)*( frac_y)*( frac_z) * rgbweight[1] * scale;
// add to b-channel in output image
buffer[2+4*( px + w*(py + h*pz ))] += (1-frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[2] * scale;
buffer[2+4*( px + w*(py+1+ h*pz ))] += (1-frac_x)*( frac_y)*(1-frac_z) * rgbweight[2] * scale;
buffer[2+4*( px + w*(py + h*pz+h))] += (1-frac_x)*(1-frac_y)*( frac_z) * rgbweight[2] * scale;
buffer[2+4*( px + w*(py+1+ h*pz+h))] += (1-frac_x)*( frac_y)*( frac_z) * rgbweight[2] * scale;
buffer[2+4*( px+1 + w*(py + h*pz ))] += ( frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[2] * scale;
buffer[2+4*( px+1 + w*(py + h*pz+h))] += ( frac_x)*(1-frac_y)*( frac_z) * rgbweight[2] * scale;
buffer[2+4*( px+1 + w*(py+1+ h*pz ))] += ( frac_x)*( frac_y)*(1-frac_z) * rgbweight[2] * scale;
buffer[2+4*( px+1 + w*(py+1+ h*pz+h))] += ( frac_x)*( frac_y)*( frac_z) * rgbweight[2] * scale;
// add to a-channel in output image
buffer[3+4*( px + w*(py + h*pz ))] += (1-frac_x)*(1-frac_y)*(1-frac_z) * intweight * scale;
buffer[3+4*( px + w*(py+1+ h*pz ))] += (1-frac_x)*( frac_y)*(1-frac_z) * intweight * scale;
buffer[3+4*( px + w*(py + h*pz+h))] += (1-frac_x)*(1-frac_y)*( frac_z) * intweight * scale;
buffer[3+4*( px + w*(py+1+ h*pz+h))] += (1-frac_x)*( frac_y)*( frac_z) * intweight * scale;
buffer[3+4*( px+1 + w*(py + h*pz ))] += ( frac_x)*(1-frac_y)*(1-frac_z) * intweight * scale;
buffer[3+4*( px+1 + w*(py + h*pz+h))] += ( frac_x)*(1-frac_y)*( frac_z) * intweight * scale;
buffer[3+4*( px+1 + w*(py+1+ h*pz ))] += ( frac_x)*( frac_y)*(1-frac_z) * intweight * scale;
buffer[3+4*( px+1 + w*(py+1+ h*pz+h))] += ( frac_x)*( frac_y)*( frac_z) * intweight * scale;
}
}
float maxRgb = 0.000000001;
float maxInt = 0.000000001;
int numPix;
numPix = w*h*d*4;
// calc maxima
for(int i=0; i<numPix; i++)
{
if((i-3)%4 != 0)
{
if(buffer[i] > maxRgb)
maxRgb = buffer[i];
}
else
{
if(buffer[i] > maxInt)
maxInt = buffer[i];
}
}
// write output, normalized uchar 0..255
for(int i=0; i<numPix; i++)
{
if((i-3)%4 != 0)
outImageBufferPointer[i] = (unsigned char) (255.0 * buffer[i] / maxRgb);
else
outImageBufferPointer[i] = (unsigned char) (255.0 * buffer[i] / maxInt);
}
}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
index b4f37f75da..0976e7b012 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
@@ -1,824 +1,824 @@
#include "itkTractsToVectorImageFilter.h"
// VTK
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
// ITK
#include <itkTimeProbe.h>
#include <itkImageRegionIterator.h>
// misc
#define _USE_MATH_DEFINES
#include <math.h>
#include <boost/progress.hpp>
namespace itk{
static bool CompareVectorLengths(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
{
return (v1.magnitude()>v2.magnitude());
}
TractsToVectorImageFilter::TractsToVectorImageFilter():
m_AngularThreshold(0.7),
m_MaskImage(NULL),
m_NumDirectionsImage(NULL),
m_NormalizeVectors(false),
m_Epsilon(0.999),
m_UseWorkingCopy(true),
m_MaxNumDirections(3),
- m_FiberSampling(5),
- m_UseTrilinearInterpolation(true),
+ m_UseTrilinearInterpolation(false),
m_Thres(0.5)
{
this->SetNumberOfRequiredOutputs(1);
}
TractsToVectorImageFilter::~TractsToVectorImageFilter()
{
}
vnl_vector_fixed<double, 3> TractsToVectorImageFilter::GetVnlVector(double point[3])
{
vnl_vector_fixed<double, 3> vnlVector;
vnlVector[0] = point[0];
vnlVector[1] = point[1];
vnlVector[2] = point[2];
return vnlVector;
}
itk::Point<float, 3> TractsToVectorImageFilter::GetItkPoint(double point[3])
{
itk::Point<float, 3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
return itkPoint;
}
void TractsToVectorImageFilter::GenerateData()
{
mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
// calculate new image parameters
mitk::Vector3D spacing;
mitk::Point3D origin;
itk::Matrix<double, 3, 3> direction;
ImageRegion<3> imageRegion;
if (!m_MaskImage.IsNull())
{
spacing = m_MaskImage->GetSpacing();
imageRegion = m_MaskImage->GetLargestPossibleRegion();
origin = m_MaskImage->GetOrigin();
direction = m_MaskImage->GetDirection();
}
else
{
spacing = geometry->GetSpacing();
origin = geometry->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
origin[0] += bounds.GetElement(0);
origin[1] += bounds.GetElement(2);
origin[2] += bounds.GetElement(4);
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
direction[j][i] = geometry->GetMatrixColumn(i)[j];
imageRegion.SetSize(0, geometry->GetExtent(0));
imageRegion.SetSize(1, geometry->GetExtent(1));
imageRegion.SetSize(2, geometry->GetExtent(2));
m_MaskImage = ItkUcharImgType::New();
m_MaskImage->SetSpacing( spacing );
m_MaskImage->SetOrigin( origin );
m_MaskImage->SetDirection( direction );
m_MaskImage->SetRegions( imageRegion );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1);
}
OutputImageType::RegionType::SizeType outImageSize = imageRegion.GetSize();
m_OutImageSpacing = m_MaskImage->GetSpacing();
m_ClusteredDirectionsContainer = ContainerType::New();
// initialize crossings image
m_CrossingsImage = ItkUcharImgType::New();
m_CrossingsImage->SetSpacing( spacing );
m_CrossingsImage->SetOrigin( origin );
m_CrossingsImage->SetDirection( direction );
m_CrossingsImage->SetRegions( imageRegion );
m_CrossingsImage->Allocate();
m_CrossingsImage->FillBuffer(0);
// initialize num directions image
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing );
m_NumDirectionsImage->SetOrigin( origin );
m_NumDirectionsImage->SetDirection( direction );
m_NumDirectionsImage->SetRegions( imageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
// resample fiber bundle
float minSpacing = 1;
if(m_OutImageSpacing[0]<m_OutImageSpacing[1] && m_OutImageSpacing[0]<m_OutImageSpacing[2])
minSpacing = m_OutImageSpacing[0];
else if (m_OutImageSpacing[1] < m_OutImageSpacing[2])
minSpacing = m_OutImageSpacing[1];
else
minSpacing = m_OutImageSpacing[2];
if (m_UseWorkingCopy)
m_FiberBundle = m_FiberBundle->GetDeepCopy();
// resample fiber bundle for sufficient voxel coverage
m_FiberBundle->ResampleFibers(minSpacing/10);
// iterate over all fibers
vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
vLines->InitTraversal();
int numFibers = m_FiberBundle->GetNumFibers();
itk::TimeProbe clock;
m_DirectionsContainer = ContainerType::New();
- MITK_INFO << "Generating fODFs (trilinear interpolation)";
+ if (m_UseTrilinearInterpolation)
+ MITK_INFO << "Generating directions from tractogram (trilinear interpolation)";
+ else
+ MITK_INFO << "Generating directions from tractogram";
+
boost::progress_display disp(numFibers);
for( int i=0; i<numFibers; i++ )
{
++disp;
clock.Start();
vtkIdType numPoints(0);
vtkIdType* points(NULL);
vLines->GetNextCell ( numPoints, points );
if (numPoints<2)
continue;
itk::Index<3> index; index.Fill(0);
itk::ContinuousIndex<float, 3> contIndex;
vnl_vector_fixed<double, 3> dir, wDir;
itk::Point<float, 3> worldPos;
vnl_vector<double> v;
for( int j=0; j<numPoints-1; j++)
{
double* temp = fiberPolyData->GetPoint(points[j]);
worldPos = GetItkPoint(temp);
v = GetVnlVector(temp);
dir = GetVnlVector(fiberPolyData->GetPoint(points[j+1]))-v;
dir.normalize();
m_MaskImage->TransformPhysicalPointToIndex(worldPos, index);
m_MaskImage->TransformPhysicalPointToContinuousIndex(worldPos, contIndex);
if (m_MaskImage->GetPixel(index)==0)
continue;
if (!m_UseTrilinearInterpolation)
{
if (index[0] < 0 || index[0] >= outImageSize[0])
continue;
if (index[1] < 0 || index[1] >= outImageSize[1])
continue;
if (index[2] < 0 || index[2] >= outImageSize[2])
continue;
int idx = index[0] + outImageSize[0]*(index[1] + outImageSize[1]*index[2]);
DirectionContainerType::Pointer dirCont = DirectionContainerType::New();
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->InsertElement(0, dir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->InsertElement(dirCont->Size(), dir);
}
else
{
dirCont->InsertElement(0, dir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
continue;
}
float frac_x = contIndex[0] - index[0];
float frac_y = contIndex[1] - index[1];
float frac_z = contIndex[2] - index[2];
if (frac_x<0)
{
index[0] -= 1;
frac_x += 1;
}
if (frac_y<0)
{
index[1] -= 1;
frac_y += 1;
}
if (frac_z<0)
{
index[2] -= 1;
frac_z += 1;
}
frac_x = 1-frac_x;
frac_y = 1-frac_y;
frac_z = 1-frac_z;
// int coordinates inside image?
if (index[0] < 0 || index[0] >= outImageSize[0]-1)
continue;
if (index[1] < 0 || index[1] >= outImageSize[1]-1)
continue;
if (index[2] < 0 || index[2] >= outImageSize[2]-1)
continue;
DirectionContainerType::Pointer dirCont;
int idx;
wDir = dir;
float weight = ( frac_x)*( frac_y)*( frac_z);
if (weight>m_Thres)
{
wDir *= weight;
idx = index[0] + outImageSize[0]*(index[1] + outImageSize[1]*index[2] );
dirCont = DirectionContainerType::New();
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->InsertElement(dirCont->Size(), wDir);
}
else
{
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
}
wDir = dir;
weight = ( frac_x)*(1-frac_y)*( frac_z);
if (weight>m_Thres)
{
wDir *= weight;
idx = index[0] + outImageSize[0]*(index[1]+1+ outImageSize[1]*index[2] );
dirCont = DirectionContainerType::New();
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->InsertElement(dirCont->Size(), wDir);
}
else
{
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
}
wDir = dir;
weight = ( frac_x)*( frac_y)*(1-frac_z);
if (weight>m_Thres)
{
wDir *= weight;
idx = index[0] + outImageSize[0]*(index[1] + outImageSize[1]*index[2]+outImageSize[1]);
dirCont = DirectionContainerType::New();
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->InsertElement(dirCont->Size(), wDir);
}
else
{
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
}
wDir = dir;
weight = ( frac_x)*(1-frac_y)*(1-frac_z);
if (weight>m_Thres)
{
wDir *= weight;
idx = index[0] + outImageSize[0]*(index[1]+1+ outImageSize[1]*index[2]+outImageSize[1]);
dirCont = DirectionContainerType::New();
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->InsertElement(dirCont->Size(), wDir);
}
else
{
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
}
wDir = dir;
weight = (1-frac_x)*( frac_y)*( frac_z);
if (weight>m_Thres)
{
wDir *= weight;
idx = index[0]+1 + outImageSize[0]*(index[1] + outImageSize[1]*index[2] );
dirCont = DirectionContainerType::New();
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->InsertElement(dirCont->Size(), wDir);
}
else
{
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
}
wDir = dir;
weight = (1-frac_x)*( frac_y)*(1-frac_z);
if (weight>m_Thres)
{
wDir *= weight;
idx = index[0]+1 + outImageSize[0]*(index[1] + outImageSize[1]*index[2]+outImageSize[1]);
dirCont = DirectionContainerType::New();
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->InsertElement(dirCont->Size(), wDir);
}
else
{
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
}
wDir = dir;
weight = (1-frac_x)*(1-frac_y)*( frac_z);
if (weight>m_Thres)
{
wDir *= weight;
idx = index[0]+1 + outImageSize[0]*(index[1]+1+ outImageSize[1]*index[2] );
dirCont = DirectionContainerType::New();
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->InsertElement(dirCont->Size(), wDir);
}
else
{
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
}
wDir = dir;
weight = (1-frac_x)*(1-frac_y)*(1-frac_z);
if (weight>m_Thres)
{
wDir *= weight;
idx = index[0]+1 + outImageSize[0]*(index[1]+1+ outImageSize[1]*index[2]+outImageSize[1]);
dirCont = DirectionContainerType::New();
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->InsertElement(dirCont->Size(), wDir);
}
else
{
dirCont->InsertElement(0, wDir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
}
}
clock.Stop();
}
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
itk::ImageRegionIterator<ItkUcharImgType> dirIt(m_NumDirectionsImage, m_NumDirectionsImage->GetLargestPossibleRegion());
itk::ImageRegionIterator<ItkUcharImgType> crossIt(m_CrossingsImage, m_CrossingsImage->GetLargestPossibleRegion());
m_DirectionImageContainer = DirectionImageContainerType::New();
int maxNumDirections = 0;
MITK_INFO << "Clustering directions";
boost::progress_display disp2(outImageSize[0]*outImageSize[1]*outImageSize[2]);
for(crossIt.GoToBegin(); !crossIt.IsAtEnd(); ++crossIt)
{
++disp2;
OutputImageType::IndexType index = crossIt.GetIndex();
int idx = index[0]+(index[1]+index[2]*outImageSize[1])*outImageSize[0];
if (!m_DirectionsContainer->IndexExists(idx))
{
++dirIt;
continue;
}
DirectionContainerType::Pointer dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull() || index[0] < 0 || index[0] >= outImageSize[0] || index[1] < 0 || index[1] >= outImageSize[1] || index[2] < 0 || index[2] >= outImageSize[2])
{
++dirIt;
continue;
}
std::vector< DirectionType > directions;
for (int i=0; i<dirCont->Size(); i++)
if (dirCont->ElementAt(i).magnitude()>0.0001)
directions.push_back(dirCont->ElementAt(i));
if (!directions.empty())
directions = FastClustering(directions);
std::sort( directions.begin(), directions.end(), CompareVectorLengths );
if ( directions.size() > maxNumDirections )
{
for (int i=maxNumDirections; i<std::min((int)directions.size(), m_MaxNumDirections); i++)
{
ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
directionImage->SetSpacing( spacing );
directionImage->SetOrigin( origin );
directionImage->SetDirection( direction );
directionImage->SetRegions( imageRegion );
directionImage->Allocate();
Vector< float, 3 > nullVec; nullVec.Fill(0.0);
directionImage->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(i, directionImage);
}
maxNumDirections = std::min((int)directions.size(), m_MaxNumDirections);
}
int numDir = directions.size();
if (numDir>m_MaxNumDirections)
numDir = m_MaxNumDirections;
for (int i=0; i<numDir; i++)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<float, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<float> worldCenter;
m_MaskImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
DirectionType dir = m_MaskImage->GetDirection()*directions.at(i);
// set direction image pixel
ItkDirectionImageType::Pointer directionImage = m_DirectionImageContainer->GetElement(i);
Vector< float, 3 > pixel;
pixel.SetElement(0, dir[0]);
pixel.SetElement(1, dir[1]);
pixel.SetElement(2, dir[2]);
directionImage->SetPixel(index, pixel);
// add direction to vector field (with spacing compensation)
itk::Point<float> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2*minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2*minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2*minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<float> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2*minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2*minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2*minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
}
dirIt.Set(numDir);
++dirIt;
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
-
- MITK_INFO << "mean time per fiber: " << clock.GetMean() << "s";
- MITK_INFO << "absolute time: " << clock.GetTotal()/60 << "min";
}
std::vector< vnl_vector_fixed< double, 3 > > TractsToVectorImageFilter::FastClustering(std::vector< vnl_vector_fixed< double, 3 > >& inDirs)
{
std::vector< vnl_vector_fixed< double, 3 > > outDirs;
if (inDirs.empty())
return outDirs;
vnl_vector_fixed< double, 3 > oldMean, currentMean, workingMean;
std::vector< vnl_vector_fixed< double, 3 > > normalizedDirs;
std::vector< int > touched;
for (int i=0; i<inDirs.size(); i++)
{
normalizedDirs.push_back(inDirs[i]);
normalizedDirs.back().normalize();
}
// initialize
float max = 0.0;
touched.resize(inDirs.size(), 0);
bool free = true;
currentMean = inDirs[0]; // initialize first seed
while (free)
{
oldMean.fill(0.0);
// start mean-shift clustering
float angle = 0.0;
int counter = 0;
while ((currentMean-oldMean).magnitude()>0.0001)
{
counter = 0;
oldMean = currentMean;
workingMean = oldMean;
workingMean.normalize();
currentMean.fill(0.0);
for (int i=0; i<normalizedDirs.size(); i++)
{
angle = dot_product(workingMean, normalizedDirs[i]);
if (angle>=m_AngularThreshold)
{
currentMean += inDirs[i];
touched[i] = 1;
counter++;
}
else if (-angle>=m_AngularThreshold)
{
currentMean -= inDirs[i];
touched[i] = 1;
counter++;
}
}
}
// found stable mean
if (counter>0)
{
currentMean /= counter;
float mag = currentMean.magnitude();
if (mag>0)
{
if (mag>max)
max = mag;
outDirs.push_back(currentMean);
}
}
// find next unused seed
free = false;
for (int i=0; i<touched.size(); i++)
if (touched[i]==0)
{
currentMean = inDirs[i];
free = true;
}
}
if (m_NormalizeVectors)
for (int i=0; i<outDirs.size(); i++)
outDirs[i].normalize();
else if (max>0)
for (int i=0; i<outDirs.size(); i++)
outDirs[i] /= max;
if (inDirs.size()==outDirs.size())
return outDirs;
else
return FastClustering(outDirs);
}
std::vector< vnl_vector_fixed< double, 3 > > TractsToVectorImageFilter::Clustering(std::vector< vnl_vector_fixed< double, 3 > >& inDirs)
{
std::vector< vnl_vector_fixed< double, 3 > > outDirs;
if (inDirs.empty())
return outDirs;
vnl_vector_fixed< double, 3 > oldMean, currentMean, workingMean;
std::vector< vnl_vector_fixed< double, 3 > > normalizedDirs;
std::vector< int > touched;
for (int i=0; i<inDirs.size(); i++)
{
normalizedDirs.push_back(inDirs[i]);
normalizedDirs.back().normalize();
}
// initialize
float max = 0.0;
touched.resize(inDirs.size(), 0);
for (int j=0; j<inDirs.size(); j++)
{
currentMean = inDirs[j];
oldMean.fill(0.0);
// start mean-shift clustering
float angle = 0.0;
int counter = 0;
while ((currentMean-oldMean).magnitude()>0.0001)
{
counter = 0;
oldMean = currentMean;
workingMean = oldMean;
workingMean.normalize();
currentMean.fill(0.0);
for (int i=0; i<normalizedDirs.size(); i++)
{
angle = dot_product(workingMean, normalizedDirs[i]);
if (angle>=m_AngularThreshold)
{
currentMean += inDirs[i];
counter++;
}
else if (-angle>=m_AngularThreshold)
{
currentMean -= inDirs[i];
counter++;
}
}
}
// found stable mean
if (counter>0)
{
bool add = true;
vnl_vector_fixed< double, 3 > normMean = currentMean;
normMean.normalize();
for (int i=0; i<outDirs.size(); i++)
{
vnl_vector_fixed< double, 3 > dir = outDirs[i];
dir.normalize();
if ((normMean-dir).magnitude()<=0.0001)
{
add = false;
break;
}
}
currentMean /= counter;
if (add)
{
float mag = currentMean.magnitude();
if (mag>0)
{
if (mag>max)
max = mag;
outDirs.push_back(currentMean);
}
}
}
}
if (m_NormalizeVectors)
for (int i=0; i<outDirs.size(); i++)
outDirs[i].normalize();
else if (max>0)
for (int i=0; i<outDirs.size(); i++)
outDirs[i] /= max;
if (inDirs.size()==outDirs.size())
return outDirs;
else
return FastClustering(outDirs);
}
TractsToVectorImageFilter::DirectionContainerType::Pointer TractsToVectorImageFilter::MeanShiftClustering(DirectionContainerType::Pointer dirCont)
{
DirectionContainerType::Pointer container = DirectionContainerType::New();
float max = 0;
for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
{
vnl_vector_fixed<double, 3> mean = ClusterStep(dirCont, it.Value());
if (mean.is_zero())
continue;
bool addMean = true;
for (DirectionContainerType::ConstIterator it2 = container->Begin(); it2!=container->End(); ++it2)
{
vnl_vector_fixed<double, 3> dir = it2.Value();
float angle = fabs(dot_product(mean, dir)/(mean.magnitude()*dir.magnitude()));
if (angle>=m_Epsilon)
{
addMean = false;
break;
}
}
if (addMean)
{
if (m_NormalizeVectors)
mean.normalize();
else if (mean.magnitude()>max)
max = mean.magnitude();
container->InsertElement(container->Size(), mean);
}
}
// max normalize voxel directions
if (max>0 && !m_NormalizeVectors)
for (int i=0; i<container->Size(); i++)
container->ElementAt(i) /= max;
if (container->Size()<dirCont->Size())
return MeanShiftClustering(container);
else
return container;
}
vnl_vector_fixed<double, 3> TractsToVectorImageFilter::ClusterStep(DirectionContainerType::Pointer dirCont, vnl_vector_fixed<double, 3> currentMean)
{
vnl_vector_fixed<double, 3> newMean; newMean.fill(0);
for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
{
vnl_vector_fixed<double, 3> dir = it.Value();
float angle = dot_product(currentMean, dir)/(currentMean.magnitude()*dir.magnitude());
if (angle>=m_AngularThreshold)
newMean += dir;
else if (-angle>=m_AngularThreshold)
newMean -= dir;
}
if (fabs(dot_product(currentMean, newMean)/(currentMean.magnitude()*newMean.magnitude()))>=m_Epsilon || newMean.is_zero())
return newMean;
else
return ClusterStep(dirCont, newMean);
}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h
index 57b50d5d2f..b5e86bfd0b 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h
@@ -1,110 +1,107 @@
#ifndef __itkTractsToVectorImageFilter_h__
#define __itkTractsToVectorImageFilter_h__
// MITK
#include <mitkFiberBundleX.h>
// ITK
#include <itkImageSource.h>
#include <itkVectorImage.h>
// VTK
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
using namespace mitk;
namespace itk{
/**
* \brief Extracts the voxel-wise main directions of the input fiber bundle. */
class TractsToVectorImageFilter : public ImageSource< VectorImage< float, 3 > >
{
public:
typedef TractsToVectorImageFilter Self;
typedef ProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
typedef itk::Vector<float,3> OutputVectorType;
typedef itk::Image<OutputVectorType, 3> OutputImageType;
typedef std::vector< OutputImageType::Pointer > OutputImageContainerType;
typedef vnl_vector_fixed< double, 3 > DirectionType;
typedef VectorContainer< int, DirectionType > DirectionContainerType;
typedef VectorContainer< int, DirectionContainerType::Pointer > ContainerType;
typedef Image< Vector< float, 3 >, 3> ItkDirectionImageType;
typedef VectorContainer< int, ItkDirectionImageType::Pointer > DirectionImageContainerType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
itkNewMacro(Self)
itkTypeMacro( TractsToVectorImageFilter, ImageSource )
itkSetMacro( AngularThreshold, float) ///< cluster directions that are closer together than the specified threshold
itkGetMacro( AngularThreshold, float) ///< cluster directions that are closer together than the specified threshold
- itkSetMacro( FiberSampling, int) ///< Sampling points per voxel
- itkGetMacro( FiberSampling, int) ///< Sampling points per voxel
itkSetMacro( NormalizeVectors, bool) ///< Normalize vectors to length 1
itkGetMacro( NormalizeVectors, bool) ///< Normalize vectors to length 1
itkSetMacro( UseWorkingCopy, bool) ///< Do not modify input fiber bundle. Use a copy.
itkGetMacro( UseWorkingCopy, bool) ///< Do not modify input fiber bundle. Use a copy.
itkSetMacro( MaxNumDirections, int) ///< If more directions are extracted, only the largest are kept.
itkGetMacro( MaxNumDirections, int) ///< If more directions are extracted, only the largest are kept.
itkSetMacro( MaskImage, ItkUcharImgType::Pointer) ///< only process voxels inside mask
itkSetMacro( FiberBundle, FiberBundleX::Pointer) ///< input fiber bundle
itkGetMacro( ClusteredDirectionsContainer, ContainerType::Pointer) ///< output directions
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer) ///< nimber of directions per voxel
itkGetMacro( CrossingsImage, ItkUcharImgType::Pointer) ///< mask voxels containing crossings
itkGetMacro( OutputFiberBundle, FiberBundleX::Pointer) ///< vector field for visualization purposes
itkGetMacro( DirectionImageContainer, DirectionImageContainerType::Pointer) ///< output directions
void GenerateData();
protected:
std::vector< DirectionType > Clustering(std::vector< DirectionType >& inDirs);
std::vector< DirectionType > FastClustering(std::vector< DirectionType >& inDirs); ///< cluster fiber directions
DirectionContainerType::Pointer MeanShiftClustering(DirectionContainerType::Pointer dirCont);
vnl_vector_fixed<double, 3> ClusterStep(DirectionContainerType::Pointer dirCont, vnl_vector_fixed<double, 3> currentMean);
vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
itk::Point<float, 3> GetItkPoint(double point[3]);
TractsToVectorImageFilter();
virtual ~TractsToVectorImageFilter();
FiberBundleX::Pointer m_FiberBundle; ///< input fiber bundle
float m_AngularThreshold; ///< cluster directions that are closer together than the specified threshold
float m_Epsilon; ///< epsilon for vector equality check
ItkUcharImgType::Pointer m_MaskImage; ///< only voxels inside the binary mask are processed
bool m_NormalizeVectors; ///< normalize vectors to length 1
mitk::Vector3D m_OutImageSpacing; ///< spacing of output image
ContainerType::Pointer m_DirectionsContainer; ///< container for fiber directions
bool m_UseWorkingCopy; ///< do not modify input fiber bundle but work on copy
bool m_UseTrilinearInterpolation; ///< trilinearly interpolate between neighbouring voxels
int m_MaxNumDirections; ///< if more directions per voxel are extracted, only the largest are kept
- int m_FiberSampling; ///< fiber points per voxel
float m_Thres; ///< distance threshold for trilinear interpolation
// output datastructures
ContainerType::Pointer m_ClusteredDirectionsContainer; ///< contains direction vectors for each voxel
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< shows number of fibers per voxel
ItkUcharImgType::Pointer m_CrossingsImage; ///< shows voxels containing more than one fiber
DirectionImageContainerType::Pointer m_DirectionImageContainer; ///< contains images that contain the output directions
FiberBundleX::Pointer m_OutputFiberBundle; ///< vector field for visualization purposes
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTractsToVectorImageFilter.cpp"
#endif
#endif // __itkTractsToVectorImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.cpp
deleted file mode 100644
index 29d329292b..0000000000
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#ifndef __mitkTractAnalyzer_cpp
-#define __mitkTractAnalyzer_cpp
-
-
-
-#include <mitkLogMacros.h>
-#include <mitkTractAnalyzer.h>
-
-#include <itkImageRegionIteratorWithIndex.h>
-
-
-#include <itkShortestPathCostFunctionTbss.h>
-#include <itkShortestPathImageFilter.h>
-
-#include <iostream>
-#include <fstream>
-
-
-using namespace std;
-
-namespace mitk {
-
- TractAnalyzer::TractAnalyzer()
- {
-
- }
-
-
- void TractAnalyzer::BuildGraph(itk::Index<3> startPoint, itk::Index<3> endPoint)
- {
-
- typedef itk::ShortestPathImageFilter<FloatImageType, CharImageType> ShortestPathFilterType;
- typedef itk::ShortestPathCostFunctionTbss<FloatImageType> CostFunctionType;
-
-
- FloatImageType::Pointer meanSkeleton;
-
- mitk::CastToItkImage(m_InputImage, meanSkeleton);
-
- // Only use the mitk image
-
-
-
- if(meanSkeleton)
- {
- CostFunctionType::Pointer costFunction = CostFunctionType::New();
- costFunction->SetImage(meanSkeleton);
- costFunction->SetStartIndex(startPoint);
- costFunction->SetEndIndex(endPoint);
- costFunction->SetThreshold(m_Threshold);
-
- ShortestPathFilterType::Pointer pathFinder = ShortestPathFilterType::New();
- pathFinder->SetCostFunction(costFunction);
- pathFinder->SetFullNeighborsMode(true);
- //pathFinder->SetCalcMode(ShortestPathFilterType::A_STAR);
- pathFinder->SetInput(meanSkeleton);
- pathFinder->SetStartIndex(startPoint);
- pathFinder->SetEndIndex(endPoint);
- pathFinder->Update();
-
- m_Path = pathFinder->GetVectorPath();
-
-
- m_RoiImg = pathFinder->GetOutput();
- }
-
-
-
- }
-
- void TractAnalyzer::MeasureRoi()
- {
-
- // Output two types
- ProjectionsImageType::SizeType size = m_Projections->GetLargestPossibleRegion().GetSize();
-
- std::ofstream file(m_FileName.c_str());
-
- std::vector<std::string> individuals;
- for(int i=0; i<m_Groups.size(); i++)
- {
- std::pair<std::string, int> group = m_Groups[i];
- for(int j=0; j<group.second; j++)
- {
- individuals.push_back(group.first);
- }
- }
-
-
- // Position ID
-
- file << "position ";
-
- for(int i=0; i<m_Roi.size(); i++)
- {
- file << "pos" << i << " ";
- }
-
- file << "\n";
-
- // For every subect
- for(int j=0; j<size[3]; j++)
- {
-
- file << individuals[j] << " ";
-
- // For every point on the current ROI
- for(int k=0; k<m_Roi.size(); k++)
- {
- itk::Index<3> ix = m_Roi[k];
- itk::Index<4> ix4;
- ix4[0] = ix[0];
- ix4[1] = ix[1];
- ix4[2] = ix[2];
- ix4[3] = j;
-
- float f = m_Projections->GetPixel(ix4);
-
- file << f << " ";
-
- }
-
- file << "\n";
-
- }
-
- file.close();
-
-
-
- // Write the long format output
- std::ofstream fileLong(m_FileNameLong.c_str());
-
- fileLong << "ID " << "group " << "position " << "value\n";
-
- for(int i=0; i<m_Roi.size(); i++)
- {
- for (int j=0; j<individuals.size(); j++)
- {
- itk::Index<3> ix = m_Roi[i];
- itk::Index<4> ix4;
- ix4[0] = ix[0];
- ix4[1] = ix[1];
- ix4[2] = ix[2];
- ix4[3] = j;
-
- float f = m_Projections->GetPixel(ix4);
-
- fileLong << "ID" << j << " " << individuals[j] << " " << "pos" << i << " "<< f << "\n";
- }
- }
-
- fileLong.close();
-
-
- }
-
-
-
-}
-#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.h
deleted file mode 100644
index ccedb1ce6b..0000000000
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-/*===================================================================
-
-This file is based heavily on a corresponding ITK filter.
-
-===================================================================*/
-#ifndef __mitkTractAnalyzer_h_
-#define __mitkTractAnalyzer_h_
-
-#include "FiberTrackingExports.h"
-#include <itkImage.h>
-#include <itkVectorImage.h>
-#include "mitkImage.h"
-#include "mitkImageCast.h"
-
-//#include <mitkTbssImage.h>
-
-
-namespace mitk{
-/** \class TractAnalyzer
- */
-
-
-class FiberTracking_EXPORT TractAnalyzer
-{
-
-public:
-
-
- TractAnalyzer();
- ~TractAnalyzer() {};
-
- typedef itk::Image<char,3> CharImageType;
- typedef itk::Image<float,3> FloatImageType;
- typedef itk::Image<float,4> ProjectionsImageType;
- typedef itk::VectorImage<float, 3> VectorImageType;
-
-
-
- /*
- void SetSkeleton(CharImageType::Pointer skeleton)
- {
- m_Skeleton = skeleton;
- }
-
- void SetMeanSkeleton(FloatImageType::Pointer i)
- {
- m_MeanSkeleton = i;
- }*/
-
-
- /* Unused method - would introduce circular dependency to the new module structure
- * of the diffusion imaging
- void SetTbssImage(mitk::TbssImage::Pointer tbssImg)
- {
- m_TbssImage = tbssImg;
- }*/
-
- void SetProjections(ProjectionsImageType::Pointer projections)
- {
- m_Projections = projections;
- }
-
- void BuildGraph(itk::Index<3> startPoint, itk::Index<3> endPoint);
-
- std::vector< itk::Index<3> > GetPath()
- {
- return m_Path;
- }
-
- void SetFileName(std::string fname)
- {
- m_FileName = fname;
- }
-
- void SetFileNameLong(std::string fname)
- {
- m_FileNameLong = fname;
- }
-
- void SetRoi(std::vector< itk::Index<3> > roi)
- {
- m_Roi = roi;
- }
-
- CharImageType::Pointer GetRoiImage()
- {
- return m_RoiImg;
- }
-
- void SetGroups(std::vector< std::pair<std::string, int> > groups)
- {
- m_Groups = groups;
- }
-
- void MeasureRoi();
-
- void SetInputImage(mitk::Image::Pointer inputImage)
- {
- m_InputImage = inputImage;
- }
-
-
- void SetThreshold(double threshold)
- {
- m_Threshold = threshold;
- }
-
-
-protected:
-
-
- //CharImageType::Pointer m_Skeleton;
- CharImageType::Pointer m_RoiImg;
- ProjectionsImageType::Pointer m_Projections;
- //FloatImageType::Pointer m_MeanSkeleton;
- //mitk::TbssImage::Pointer m_TbssImage;
-
- mitk::Image::Pointer m_InputImage;
-
- double m_Threshold;
-
- std::vector< itk::Index<3> > m_Path;
-
- std::string m_FileName;
-
- std::string m_FileNameLong; // For the regression analysis 'friendly' file
-
- std::vector< std::pair<std::string, int> > m_Groups;
-
- std::vector< itk::Index<3> > m_Roi;
-
-private:
-
-};
-
-}
-
-#endif //__itkTractAnalyzer_h_
-
diff --git a/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
index 833650d9e1..0b885f1b05 100644
--- a/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
+++ b/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
@@ -1,44 +1,45 @@
MITK_CHECK_MODULE(_missing_deps DiffusionCore MitkGraphAlgorithms)
if(NOT _missing_deps)
set(lut_url http://mitk.org/download/data/FibertrackingLUT.tar.gz)
set(lut_tarball ${CMAKE_CURRENT_BINARY_DIR}/FibertrackingLUT.tar.gz)
message("Downloading FiberTracking LUT ${lut_url}...")
file(DOWNLOAD ${lut_url} ${lut_tarball}
EXPECTED_MD5 38ecb6d4a826c9ebb0f4965eb9aeee44
TIMEOUT 20
STATUS status
SHOW_PROGRESS
)
list(GET status 0 status_code)
list(GET status 1 status_msg)
if(NOT status_code EQUAL 0)
message(SEND_ERROR "${status_msg} (error code ${status_code})")
else()
message("done.")
endif()
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Resources)
message("Unpacking FiberTracking LUT tarball...")
execute_process(COMMAND ${CMAKE_COMMAND} -E tar xzf ../FibertrackingLUT.tar.gz
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Resources
RESULT_VARIABLE result
ERROR_VARIABLE err_msg)
if(result)
message(SEND_ERROR "Unpacking FibertrackingLUT.tar.gz failed: ${err_msg}")
else()
message("done.")
endif()
endif()
MITK_CREATE_MODULE( FiberTracking
SUBPROJECTS MITK-DTI
INCLUDE_DIRS Algorithms Algorithms/GibbsTracking Algorithms/StochasticTracking IODataStructures IODataStructures/FiberBundleX IODataStructures/PlanarFigureComposite Interactions SignalModels Rendering ${CMAKE_CURRENT_BINARY_DIR}
DEPENDS DiffusionCore MitkGraphAlgorithms
)
if(MODULE_IS_ENABLED)
add_subdirectory(Testing)
+ add_subdirectory(MiniApps)
endif()
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
old mode 100644
new mode 100755
index 84f0269df5..70bf2f97ec
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
@@ -1,1740 +1,1703 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#define _USE_MATH_DEFINES
#include "mitkFiberBundleX.h"
#include <mitkPlanarCircle.h>
#include <mitkPlanarPolygon.h>
#include <mitkPlanarFigureComposite.h>
#include <vtkPointData.h>
#include <vtkDataArray.h>
#include <vtkUnsignedCharArray.h>
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <vtkIdFilter.h>
#include <vtkClipPolyData.h>
#include <vtkPlane.h>
#include <vtkDoubleArray.h>
#include <vtkKochanekSpline.h>
#include <vtkParametricFunctionSource.h>
#include <vtkParametricSpline.h>
#include <vtkPolygon.h>
#include <vtkCleanPolyData.h>
#include <cmath>
#include <boost/progress.hpp>
const char* mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED = "Color_Orient";
//const char* mitk::FiberBundleX::COLORCODING_FA_AS_OPACITY = "Color_Orient_FA_Opacity";
const char* mitk::FiberBundleX::COLORCODING_FA_BASED = "FA_Values";
const char* mitk::FiberBundleX::COLORCODING_CUSTOM = "custom";
const char* mitk::FiberBundleX::FIBER_ID_ARRAY = "Fiber_IDs";
using namespace std;
mitk::FiberBundleX::FiberBundleX( vtkPolyData* fiberPolyData )
: m_CurrentColorCoding(NULL)
, m_NumFibers(0)
, m_FiberSampling(0)
{
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
if (fiberPolyData != NULL)
{
m_FiberPolyData = fiberPolyData;
//m_FiberPolyData->DeepCopy(fiberPolyData);
this->DoColorCodingOrientationBased();
}
- m_NumFibers = m_FiberPolyData->GetNumberOfLines();
-
this->UpdateFiberGeometry();
this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
this->GenerateFiberIds();
}
mitk::FiberBundleX::~FiberBundleX()
{
}
mitk::FiberBundleX::Pointer mitk::FiberBundleX::GetDeepCopy()
{
mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(m_FiberPolyData);
newFib->SetColorCoding(m_CurrentColorCoding);
return newFib;
}
vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GeneratePolyDataByIds(std::vector<long> fiberIds)
{
MITK_DEBUG << "\n=====FINAL RESULT: fib_id ======\n";
MITK_DEBUG << "Number of new Fibers: " << fiberIds.size();
// iterate through the vectorcontainer hosting all desired fiber Ids
vtkSmartPointer<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
// if FA array available, initialize fa double array
// if color orient array is available init color array
vtkSmartPointer<vtkDoubleArray> faValueArray;
vtkSmartPointer<vtkUnsignedCharArray> colorsT;
//colors and alpha value for each single point, RGBA = 4 components
unsigned char rgba[4] = {0,0,0,0};
int componentSize = sizeof(rgba);
if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_FA_BASED)){
MITK_DEBUG << "FA VALUES AVAILABLE, init array for new fiberbundle";
faValueArray = vtkSmartPointer<vtkDoubleArray>::New();
}
if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED)){
MITK_DEBUG << "colorValues available, init array for new fiberbundle";
colorsT = vtkUnsignedCharArray::New();
colorsT->SetNumberOfComponents(componentSize);
colorsT->SetName(COLORCODING_ORIENTATION_BASED);
}
std::vector<long>::iterator finIt = fiberIds.begin();
while ( finIt != fiberIds.end() )
{
if (*finIt < 0 || *finIt>GetNumFibers()){
MITK_INFO << "FiberID can not be negative or >NumFibers!!! check id Extraction!" << *finIt;
break;
}
vtkSmartPointer<vtkCell> fiber = m_FiberIdDataSet->GetCell(*finIt);//->DeepCopy(fiber);
vtkSmartPointer<vtkPoints> fibPoints = fiber->GetPoints();
vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
newFiber->GetPointIds()->SetNumberOfIds( fibPoints->GetNumberOfPoints() );
for(int i=0; i<fibPoints->GetNumberOfPoints(); i++)
{
// MITK_DEBUG << "id: " << fiber->GetPointId(i);
// MITK_DEBUG << fibPoints->GetPoint(i)[0] << " | " << fibPoints->GetPoint(i)[1] << " | " << fibPoints->GetPoint(i)[2];
newFiber->GetPointIds()->SetId(i, newPointSet->GetNumberOfPoints());
newPointSet->InsertNextPoint(fibPoints->GetPoint(i)[0], fibPoints->GetPoint(i)[1], fibPoints->GetPoint(i)[2]);
if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_FA_BASED)){
// MITK_DEBUG << m_FiberIdDataSet->GetPointData()->GetArray(FA_VALUE_ARRAY)->GetTuple(fiber->GetPointId(i));
}
if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED)){
// MITK_DEBUG << "ColorValue: " << m_FiberIdDataSet->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetTuple(fiber->GetPointId(i))[0];
}
}
newLineSet->InsertNextCell(newFiber);
++finIt;
}
newFiberPolyData->SetPoints(newPointSet);
newFiberPolyData->SetLines(newLineSet);
MITK_DEBUG << "new fiberbundle polydata points: " << newFiberPolyData->GetNumberOfPoints();
MITK_DEBUG << "new fiberbundle polydata lines: " << newFiberPolyData->GetNumberOfLines();
MITK_DEBUG << "=====================\n";
// mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(newFiberPolyData);
return newFiberPolyData;
}
// merge two fiber bundles
mitk::FiberBundleX::Pointer mitk::FiberBundleX::AddBundle(mitk::FiberBundleX* fib)
{
if (fib==NULL)
{
MITK_WARN << "trying to call AddBundle with NULL argument";
return NULL;
}
MITK_INFO << "Adding fibers";
vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
-
// add current fiber bundle
- int numFibers = GetNumFibers();
- boost::progress_display disp(numFibers);
- for( int i=0; i<numFibers; i++ )
+ for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
{
- ++disp;
- vtkIdType numPoints(0);
- vtkIdType* points(NULL);
- vLines->GetNextCell ( numPoints, points );
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
- for( int j=0; j<numPoints; j++)
+ for (int j=0; j<numPoints; j++)
{
- vtkIdType id = vNewPoints->InsertNextPoint(m_FiberPolyData->GetPoint(points[j]));
+ double p[3];
+ points->GetPoint(j, p);
+
+ vtkIdType id = vNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vNewLines->InsertNextCell(container);
}
- vLines = fib->m_FiberPolyData->GetLines();
- vLines->InitTraversal();
-
// add new fiber bundle
- numFibers = fib->GetNumFibers();
- for( int i=0; i<numFibers; i++ )
+ for (int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
{
- vtkIdType numPoints(0);
- vtkIdType* points(NULL);
- vLines->GetNextCell ( numPoints, points );
+ vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
- for( int j=0; j<numPoints; j++)
+ for (int j=0; j<numPoints; j++)
{
- vtkIdType id = vNewPoints->InsertNextPoint(fib->m_FiberPolyData->GetPoint(points[j]));
+ double p[3];
+ points->GetPoint(j, p);
+
+ vtkIdType id = vNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vNewLines->InsertNextCell(container);
}
// initialize polydata
vNewPolyData->SetPoints(vNewPoints);
vNewPolyData->SetLines(vNewLines);
// initialize fiber bundle
mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
return newFib;
}
// subtract two fiber bundles
mitk::FiberBundleX::Pointer mitk::FiberBundleX::SubtractBundle(mitk::FiberBundleX* fib)
{
MITK_INFO << "Subtracting fibers";
vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
-
// iterate over current fibers
int numFibers = GetNumFibers();
boost::progress_display disp(numFibers);
for( int i=0; i<numFibers; i++ )
{
++disp;
- vtkIdType numPoints(0);
- vtkIdType* points(NULL);
- vLines->GetNextCell ( numPoints, points );
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
- if (points==NULL)
+ if (points==NULL || numPoints<=0)
continue;
- vtkSmartPointer<vtkCellArray> vLines2 = fib->m_FiberPolyData->GetLines();
- vLines2->InitTraversal();
int numFibers2 = fib->GetNumFibers();
bool contained = false;
-
for( int i2=0; i2<numFibers2; i2++ )
{
- vtkIdType numPoints2(0);
- vtkIdType* points2(NULL);
- vLines2->GetNextCell ( numPoints2, points2 );
+ vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i2);
+ int numPoints2 = cell2->GetNumberOfPoints();
+ vtkPoints* points2 = cell2->GetPoints();
- if (points2==NULL)
+ if (points2==NULL || numPoints2<=0)
continue;
// check endpoints
- itk::Point<float, 3> point_start = GetItkPoint(m_FiberPolyData->GetPoint(points[0]));
- itk::Point<float, 3> point_end = GetItkPoint(m_FiberPolyData->GetPoint(points[numPoints-1]));
- itk::Point<float, 3> point2_start = GetItkPoint(fib->m_FiberPolyData->GetPoint(points2[0]));
- itk::Point<float, 3> point2_end = GetItkPoint(fib->m_FiberPolyData->GetPoint(points2[numPoints2-1]));
+ itk::Point<float, 3> point_start = GetItkPoint(points->GetPoint(0));
+ itk::Point<float, 3> point_end = GetItkPoint(points->GetPoint(numPoints-1));
+ itk::Point<float, 3> point2_start = GetItkPoint(points2->GetPoint(0));
+ itk::Point<float, 3> point2_end = GetItkPoint(points2->GetPoint(numPoints2-1));
if (point_start.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps ||
point_start.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps)
{
// further checking ???
if (numPoints2==numPoints)
contained = true;
}
}
// add to result because fiber is not subtracted
if (!contained)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for( int j=0; j<numPoints; j++)
{
- vtkIdType id = vNewPoints->InsertNextPoint(m_FiberPolyData->GetPoint(points[j]));
+ vtkIdType id = vNewPoints->InsertNextPoint(points->GetPoint(j));
container->GetPointIds()->InsertNextId(id);
}
vNewLines->InsertNextCell(container);
}
}
if(vNewLines->GetNumberOfCells()==0)
return NULL;
// initialize polydata
vNewPolyData->SetPoints(vNewPoints);
vNewPolyData->SetLines(vNewLines);
// initialize fiber bundle
mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
return newFib;
}
itk::Point<float, 3> mitk::FiberBundleX::GetItkPoint(double point[3])
{
itk::Point<float, 3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
return itkPoint;
}
/*
* set polydata (additional flag to recompute fiber geometry, default = true)
*/
void mitk::FiberBundleX::SetFiberPolyData(vtkSmartPointer<vtkPolyData> fiberPD, bool updateGeometry)
{
if (fiberPD == NULL)
this->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
else
{
m_FiberPolyData->DeepCopy(fiberPD);
DoColorCodingOrientationBased();
}
m_NumFibers = m_FiberPolyData->GetNumberOfLines();
if (updateGeometry)
UpdateFiberGeometry();
SetColorCoding(COLORCODING_ORIENTATION_BASED);
GenerateFiberIds();
}
/*
* return vtkPolyData
*/
vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GetFiberPolyData()
{
return m_FiberPolyData;
}
void mitk::FiberBundleX::DoColorCodingOrientationBased()
{
//===== FOR WRITING A TEST ========================
// colorT size == tupelComponents * tupelElements
// compare color results
// to cover this code 100% also polydata needed, where colorarray already exists
// + one fiber with exactly 1 point
// + one fiber with 0 points
//=================================================
/* make sure that processing colorcoding is only called when necessary */
if ( m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED) &&
m_FiberPolyData->GetNumberOfPoints() ==
m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetNumberOfTuples() )
{
// fiberstructure is already colorcoded
MITK_DEBUG << " NO NEED TO REGENERATE COLORCODING! " ;
this->ResetFiberOpacity();
this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
return;
}
/* Finally, execute color calculation */
vtkPoints* extrPoints = NULL;
extrPoints = m_FiberPolyData->GetPoints();
int numOfPoints = 0;
if (extrPoints!=NULL)
numOfPoints = extrPoints->GetNumberOfPoints();
//colors and alpha value for each single point, RGBA = 4 components
unsigned char rgba[4] = {0,0,0,0};
// int componentSize = sizeof(rgba);
int componentSize = 4;
vtkSmartPointer<vtkUnsignedCharArray> colorsT = vtkSmartPointer<vtkUnsignedCharArray>::New();
colorsT->Allocate(numOfPoints * componentSize);
colorsT->SetNumberOfComponents(componentSize);
colorsT->SetName(COLORCODING_ORIENTATION_BASED);
/* checkpoint: does polydata contain any fibers */
int numOfFibers = m_FiberPolyData->GetNumberOfLines();
if (numOfFibers < 1) {
MITK_DEBUG << "\n ========= Number of Fibers is 0 and below ========= \n";
return;
}
/* extract single fibers of fiberBundle */
vtkCellArray* fiberList = m_FiberPolyData->GetLines();
fiberList->InitTraversal();
for (int fi=0; fi<numOfFibers; ++fi) {
vtkIdType* idList; // contains the point id's of the line
vtkIdType pointsPerFiber; // number of points for current line
fiberList->GetNextCell(pointsPerFiber, idList);
// MITK_DEBUG << "Fib#: " << fi << " of " << numOfFibers << " pnts in fiber: " << pointsPerFiber ;
/* single fiber checkpoints: is number of points valid */
if (pointsPerFiber > 1)
{
/* operate on points of single fiber */
for (int i=0; i <pointsPerFiber; ++i)
{
/* process all points except starting and endpoint
* for calculating color value take current point, previous point and next point */
if (i<pointsPerFiber-1 && i > 0)
{
/* The color value of the current point is influenced by the previous point and next point. */
vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
vnl_vector_fixed< double, 3 > diff1;
diff1 = currentPntvtk - nextPntvtk;
vnl_vector_fixed< double, 3 > diff2;
diff2 = currentPntvtk - prevPntvtk;
vnl_vector_fixed< double, 3 > diff;
diff = (diff1 - diff2) / 2.0;
diff.normalize();
rgba[0] = (unsigned char) (255.0 * std::fabs(diff[0]));
rgba[1] = (unsigned char) (255.0 * std::fabs(diff[1]));
rgba[2] = (unsigned char) (255.0 * std::fabs(diff[2]));
rgba[3] = (unsigned char) (255.0);
} else if (i==0) {
/* First point has no previous point, therefore only diff1 is taken */
vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
vnl_vector_fixed< double, 3 > diff1;
diff1 = currentPntvtk - nextPntvtk;
diff1.normalize();
rgba[0] = (unsigned char) (255.0 * std::fabs(diff1[0]));
rgba[1] = (unsigned char) (255.0 * std::fabs(diff1[1]));
rgba[2] = (unsigned char) (255.0 * std::fabs(diff1[2]));
rgba[3] = (unsigned char) (255.0);
} else if (i==pointsPerFiber-1) {
/* Last point has no next point, therefore only diff2 is taken */
vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
vnl_vector_fixed< double, 3 > diff2;
diff2 = currentPntvtk - prevPntvtk;
diff2.normalize();
rgba[0] = (unsigned char) (255.0 * std::fabs(diff2[0]));
rgba[1] = (unsigned char) (255.0 * std::fabs(diff2[1]));
rgba[2] = (unsigned char) (255.0 * std::fabs(diff2[2]));
rgba[3] = (unsigned char) (255.0);
}
colorsT->InsertTupleValue(idList[i], rgba);
} //end for loop
} else if (pointsPerFiber == 1) {
/* a single point does not define a fiber (use vertex mechanisms instead */
continue;
// colorsT->InsertTupleValue(0, rgba);
} else {
MITK_DEBUG << "Fiber with 0 points detected... please check your tractography algorithm!" ;
continue;
}
}//end for loop
m_FiberPolyData->GetPointData()->AddArray(colorsT);
/*=========================
- this is more relevant for renderer than for fiberbundleX datastructure
- think about sourcing this to a explicit method which coordinates colorcoding */
this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
// ===========================
//mini test, shall be ported to MITK TESTINGS!
if (colorsT->GetSize() != numOfPoints*componentSize)
MITK_DEBUG << "ALLOCATION ERROR IN INITIATING COLOR ARRAY";
}
void mitk::FiberBundleX::DoColorCodingFaBased()
{
if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED) != 1 )
return;
this->SetColorCoding(COLORCODING_FA_BASED);
MITK_DEBUG << "FBX: done CC FA based";
this->GenerateFiberIds();
}
void mitk::FiberBundleX::DoUseFaFiberOpacity()
{
if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED) != 1 )
return;
if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED) != 1 )
return;
vtkDoubleArray* FAValArray = (vtkDoubleArray*) m_FiberPolyData->GetPointData()->GetArray(COLORCODING_FA_BASED);
vtkUnsignedCharArray* ColorArray = dynamic_cast<vtkUnsignedCharArray*> (m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED));
for(long i=0; i<ColorArray->GetNumberOfTuples(); i++) {
double faValue = FAValArray->GetValue(i);
faValue = faValue * 255.0;
ColorArray->SetComponent(i,3, (unsigned char) faValue );
}
this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
MITK_DEBUG << "FBX: done CC OPACITY";
this->GenerateFiberIds();
}
void mitk::FiberBundleX::ResetFiberOpacity() {
vtkUnsignedCharArray* ColorArray = dynamic_cast<vtkUnsignedCharArray*> (m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED));
if (ColorArray==NULL)
return;
for(long i=0; i<ColorArray->GetNumberOfTuples(); i++)
ColorArray->SetComponent(i,3, 255.0 );
}
void mitk::FiberBundleX::SetFAMap(mitk::Image::Pointer FAimage)
{
MITK_DEBUG << "SetFAMap";
vtkSmartPointer<vtkDoubleArray> faValues = vtkSmartPointer<vtkDoubleArray>::New();
faValues->SetName(COLORCODING_FA_BASED);
faValues->Allocate(m_FiberPolyData->GetNumberOfPoints());
faValues->SetNumberOfValues(m_FiberPolyData->GetNumberOfPoints());
vtkPoints* pointSet = m_FiberPolyData->GetPoints();
for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
{
Point3D px;
px[0] = pointSet->GetPoint(i)[0];
px[1] = pointSet->GetPoint(i)[1];
px[2] = pointSet->GetPoint(i)[2];
double faPixelValue = 1-FAimage->GetPixelValueByWorldCoordinate(px);
faValues->InsertValue(i, faPixelValue);
}
m_FiberPolyData->GetPointData()->AddArray(faValues);
this->GenerateFiberIds();
if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED))
MITK_DEBUG << "FA VALUE ARRAY SET";
}
void mitk::FiberBundleX::GenerateFiberIds()
{
if (m_FiberPolyData == NULL)
return;
vtkSmartPointer<vtkIdFilter> idFiberFilter = vtkSmartPointer<vtkIdFilter>::New();
idFiberFilter->SetInput(m_FiberPolyData);
idFiberFilter->CellIdsOn();
// idFiberFilter->PointIdsOn(); // point id's are not needed
idFiberFilter->SetIdsArrayName(FIBER_ID_ARRAY);
idFiberFilter->FieldDataOn();
idFiberFilter->Update();
m_FiberIdDataSet = idFiberFilter->GetOutput();
MITK_DEBUG << "Generating Fiber Ids...[done] | " << m_FiberIdDataSet->GetNumberOfCells();
}
mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint)
{
vtkSmartPointer<vtkPolyData> polyData = m_FiberPolyData;
if (anyPoint)
{
float minSpacing = 1;
if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
minSpacing = mask->GetSpacing()[0];
else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
minSpacing = mask->GetSpacing()[1];
else
minSpacing = mask->GetSpacing()[2];
mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
fibCopy->ResampleFibers(minSpacing/10);
polyData = fibCopy->GetFiberPolyData();
}
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
- vtkSmartPointer<vtkCellArray> vLines = polyData->GetLines();
- vtkSmartPointer<vtkCellArray> vLinesOriginal = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
- vLinesOriginal->InitTraversal();
MITK_INFO << "Extracting fibers";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp;
- vtkIdType numPoints(0);
- vtkIdType* pointIds(NULL);
- vLines->GetNextCell ( numPoints, pointIds );
- vtkIdType numPointsOriginal(0);
- vtkIdType* pointIdsOriginal(NULL);
- vLinesOriginal->GetNextCell ( numPointsOriginal, pointIdsOriginal );
+ vtkCell* cell = polyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
+
+ vtkCell* cellOriginal = m_FiberPolyData->GetCell(i);
+ int numPointsOriginal = cellOriginal->GetNumberOfPoints();
+ vtkPoints* pointsOriginal = cellOriginal->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
- if (numPoints>1)
+ if (numPoints>1 && numPointsOriginal)
{
if (anyPoint)
{
for (int j=0; j<numPoints; j++)
{
- double* p = polyData->GetPoint(pointIds[j]);
+ double* p = points->GetPoint(j);
itk::Point<float, 3> itkP;
itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
itk::Index<3> idx;
mask->TransformPhysicalPointToIndex(itkP, idx);
- if ( mask->GetPixel(idx)>0 )
+ if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) )
{
for (int k=0; k<numPointsOriginal; k++)
{
- double* p = m_FiberPolyData->GetPoint(pointIdsOriginal[k]);
+ double* p = pointsOriginal->GetPoint(k);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
break;
}
}
}
else
{
- double* start = polyData->GetPoint(pointIds[0]);
+ double* start = pointsOriginal->GetPoint(0);
itk::Point<float, 3> itkStart;
itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
itk::Index<3> idxStart;
mask->TransformPhysicalPointToIndex(itkStart, idxStart);
- double* end = polyData->GetPoint(pointIds[numPoints-1]);
+ double* end = pointsOriginal->GetPoint(numPointsOriginal-1);
itk::Point<float, 3> itkEnd;
itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
itk::Index<3> idxEnd;
mask->TransformPhysicalPointToIndex(itkEnd, idxEnd);
- if ( mask->GetPixel(idxStart)>0 && mask->GetPixel(idxEnd)>0 )
+ if ( mask->GetPixel(idxStart)>0 && mask->GetPixel(idxEnd)>0 && mask->GetLargestPossibleRegion().IsInside(idxStart) && mask->GetLargestPossibleRegion().IsInside(idxEnd) )
{
- for (int j=0; j<numPoints; j++)
+ for (int j=0; j<numPointsOriginal; j++)
{
- double* p = polyData->GetPoint(pointIds[j]);
+ double* p = pointsOriginal->GetPoint(j);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
}
}
}
vtkNewCells->InsertNextCell(container);
}
if (vtkNewCells->GetNumberOfCells()<=0)
return NULL;
vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
newPolyData->SetPoints(vtkNewPoints);
newPolyData->SetLines(vtkNewCells);
return mitk::FiberBundleX::New(newPolyData);
}
mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(mitk::PlanarFigure* pf)
{
if (pf==NULL)
return NULL;
std::vector<long> tmp = ExtractFiberIdSubset(pf);
if (tmp.size()<=0)
return mitk::FiberBundleX::New();
vtkSmartPointer<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp);
return mitk::FiberBundleX::New(pTmp);
}
std::vector<long> mitk::FiberBundleX::ExtractFiberIdSubset(mitk::PlanarFigure* pf)
{
MITK_DEBUG << "Extracting fibers!";
// vector which is returned, contains all extracted FiberIds
std::vector<long> FibersInROI;
if (pf==NULL)
return FibersInROI;
/* Handle type of planarfigure */
// if incoming pf is a pfc
mitk::PlanarFigureComposite::Pointer pfcomp= dynamic_cast<mitk::PlanarFigureComposite*>(pf);
if (!pfcomp.IsNull()) {
// process requested boolean operation of PFC
switch (pfcomp->getOperationType()) {
case 0:
{
MITK_DEBUG << "AND PROCESSING";
//AND
//temporarly store results of the child in this vector, we need that to accumulate the
std::vector<long> childResults = this->ExtractFiberIdSubset(pfcomp->getChildAt(0));
MITK_DEBUG << "first roi got fibers in ROI: " << childResults.size();
MITK_DEBUG << "sorting...";
std::sort(childResults.begin(), childResults.end());
MITK_DEBUG << "sorting done";
std::vector<long> AND_Assamblage(childResults.size());
//std::vector<unsigned long> AND_Assamblage;
fill(AND_Assamblage.begin(), AND_Assamblage.end(), -1);
//AND_Assamblage.reserve(childResults.size()); //max size AND can reach anyway
std::vector<long>::iterator it;
for (int i=1; i<pfcomp->getNumberOfChildren(); ++i)
{
std::vector<long> tmpChild = this->ExtractFiberIdSubset(pfcomp->getChildAt(i));
MITK_DEBUG << "ROI " << i << " has fibers in ROI: " << tmpChild.size();
sort(tmpChild.begin(), tmpChild.end());
it = std::set_intersection(childResults.begin(), childResults.end(),
tmpChild.begin(), tmpChild.end(),
AND_Assamblage.begin() );
}
MITK_DEBUG << "resize Vector";
long i=0;
while (i < AND_Assamblage.size() && AND_Assamblage[i] != -1){ //-1 represents a placeholder in the array
++i;
}
AND_Assamblage.resize(i);
MITK_DEBUG << "returning AND vector, size: " << AND_Assamblage.size();
return AND_Assamblage;
// break;
}
case 1:
{
//OR
std::vector<long> OR_Assamblage = this->ExtractFiberIdSubset(pfcomp->getChildAt(0));
std::vector<long>::iterator it;
MITK_DEBUG << OR_Assamblage.size();
for (int i=1; i<pfcomp->getNumberOfChildren(); ++i) {
it = OR_Assamblage.end();
std::vector<long> tmpChild = this->ExtractFiberIdSubset(pfcomp->getChildAt(i));
OR_Assamblage.insert(it, tmpChild.begin(), tmpChild.end());
MITK_DEBUG << "ROI " << i << " has fibers in ROI: " << tmpChild.size() << " OR Assamblage: " << OR_Assamblage.size();
}
sort(OR_Assamblage.begin(), OR_Assamblage.end());
it = unique(OR_Assamblage.begin(), OR_Assamblage.end());
OR_Assamblage.resize( it - OR_Assamblage.begin() );
MITK_DEBUG << "returning OR vector, size: " << OR_Assamblage.size();
return OR_Assamblage;
}
case 2:
{
//NOT
//get IDs of all fibers
std::vector<long> childResults;
childResults.reserve(this->GetNumFibers());
vtkSmartPointer<vtkDataArray> idSet = m_FiberIdDataSet->GetCellData()->GetArray(FIBER_ID_ARRAY);
MITK_DEBUG << "m_NumOfFib: " << this->GetNumFibers() << " cellIdNum: " << idSet->GetNumberOfTuples();
for(long i=0; i<this->GetNumFibers(); i++)
{
MITK_DEBUG << "i: " << i << " idset: " << idSet->GetTuple(i)[0];
childResults.push_back(idSet->GetTuple(i)[0]);
}
std::sort(childResults.begin(), childResults.end());
std::vector<long> NOT_Assamblage(childResults.size());
//fill it with -1, otherwise 0 will be stored and 0 can also be an ID of fiber!
fill(NOT_Assamblage.begin(), NOT_Assamblage.end(), -1);
std::vector<long>::iterator it;
for (long i=0; i<pfcomp->getNumberOfChildren(); ++i)
{
std::vector<long> tmpChild = ExtractFiberIdSubset(pfcomp->getChildAt(i));
sort(tmpChild.begin(), tmpChild.end());
it = std::set_difference(childResults.begin(), childResults.end(),
tmpChild.begin(), tmpChild.end(),
NOT_Assamblage.begin() );
}
MITK_DEBUG << "resize Vector";
long i=0;
while (NOT_Assamblage[i] != -1){ //-1 represents a placeholder in the array
++i;
}
NOT_Assamblage.resize(i);
return NOT_Assamblage;
}
default:
MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
break;
}
}
else
{
mitk::Geometry2D::ConstPointer pfgeometry = pf->GetGeometry2D();
const mitk::PlaneGeometry* planeGeometry = dynamic_cast<const mitk::PlaneGeometry*> (pfgeometry.GetPointer());
Vector3D planeNormal = planeGeometry->GetNormal();
planeNormal.Normalize();
Point3D planeOrigin = planeGeometry->GetOrigin();
MITK_DEBUG << "planeOrigin: " << planeOrigin[0] << " | " << planeOrigin[1] << " | " << planeOrigin[2] << endl;
MITK_DEBUG << "planeNormal: " << planeNormal[0] << " | " << planeNormal[1] << " | " << planeNormal[2] << endl;
std::vector<int> PointsOnPlane; // contains all pointIds which are crossing the cutting plane
std::vector<int> PointsInROI; // based on PointsOnPlane, all ROI relevant point IDs are stored here
/* Define cutting plane by ROI (PlanarFigure) */
vtkSmartPointer<vtkPlane> plane = vtkSmartPointer<vtkPlane>::New();
plane->SetOrigin(planeOrigin[0],planeOrigin[1],planeOrigin[2]);
plane->SetNormal(planeNormal[0],planeNormal[1],planeNormal[2]);
/* get all points/fibers cutting the plane */
MITK_DEBUG << "start clipping";
vtkSmartPointer<vtkClipPolyData> clipper = vtkSmartPointer<vtkClipPolyData>::New();
clipper->SetInput(m_FiberIdDataSet);
clipper->SetClipFunction(plane);
clipper->GenerateClipScalarsOn();
clipper->GenerateClippedOutputOn();
vtkSmartPointer<vtkPolyData> clipperout = clipper->GetClippedOutput();
MITK_DEBUG << "end clipping";
MITK_DEBUG << "init and update clipperoutput";
clipperout->GetPointData()->Initialize();
clipperout->Update();
MITK_DEBUG << "init and update clipperoutput completed";
MITK_DEBUG << "STEP 1: find all points which have distance 0 to the given plane";
/*======STEP 1======
* extract all points, which are crossing the plane */
// Scalar values describe the distance between each remaining point to the given plane. Values sorted by point index
vtkSmartPointer<vtkDataArray> distanceList = clipperout->GetPointData()->GetScalars();
vtkIdType sizeOfList = distanceList->GetNumberOfTuples();
PointsOnPlane.reserve(sizeOfList); /* use reserve for high-performant push_back, no hidden copy procedures are processed then!
* size of list can be optimized by reducing allocation, but be aware of iterator and vector size*/
for (int i=0; i<sizeOfList; ++i) {
double *distance = distanceList->GetTuple(i);
// check if point is on plane.
// 0.01 due to some approximation errors when calculating distance
if (distance[0] >= -0.01 && distance[0] <= 0.01)
PointsOnPlane.push_back(i);
}
MITK_DEBUG << "Num Of points on plane: " << PointsOnPlane.size();
MITK_DEBUG << "Step 2: extract Interesting points with respect to given extraction planarFigure";
PointsInROI.reserve(PointsOnPlane.size());
/*=======STEP 2=====
* extract ROI relevant pointIds */
mitk::PlanarCircle::Pointer circleName = mitk::PlanarCircle::New();
mitk::PlanarPolygon::Pointer polyName = mitk::PlanarPolygon::New();
if ( pf->GetNameOfClass() == circleName->GetNameOfClass() )
{
//calculate circle radius
mitk::Point3D V1w = pf->GetWorldControlPoint(0); //centerPoint
mitk::Point3D V2w = pf->GetWorldControlPoint(1); //radiusPoint
double distPF = V1w.EuclideanDistanceTo(V2w);
for (int i=0; i<PointsOnPlane.size(); i++)
{
//distance between circle radius and given point
double XdistPnt = sqrt((double) (clipperout->GetPoint(PointsOnPlane[i])[0] - V1w[0]) * (clipperout->GetPoint(PointsOnPlane[i])[0] - V1w[0]) +
(clipperout->GetPoint(PointsOnPlane[i])[1] - V1w[1]) * (clipperout->GetPoint(PointsOnPlane[i])[1] - V1w[1]) +
(clipperout->GetPoint(PointsOnPlane[i])[2] - V1w[2]) * (clipperout->GetPoint(PointsOnPlane[i])[2] - V1w[2])) ;
if( XdistPnt <= distPF)
PointsInROI.push_back(PointsOnPlane[i]);
}
}
else if ( pf->GetNameOfClass() == polyName->GetNameOfClass() )
{
//create vtkPolygon using controlpoints from planarFigure polygon
vtkSmartPointer<vtkPolygon> polygonVtk = vtkSmartPointer<vtkPolygon>::New();
//get the control points from pf and insert them to vtkPolygon
unsigned int nrCtrlPnts = pf->GetNumberOfControlPoints();
for (int i=0; i<nrCtrlPnts; ++i)
{
polygonVtk->GetPoints()->InsertNextPoint((double)pf->GetWorldControlPoint(i)[0], (double)pf->GetWorldControlPoint(i)[1], (double)pf->GetWorldControlPoint(i)[2] );
}
//prepare everything for using pointInPolygon function
double n[3];
polygonVtk->ComputeNormal(polygonVtk->GetPoints()->GetNumberOfPoints(),
static_cast<double*>(polygonVtk->GetPoints()->GetData()->GetVoidPointer(0)), n);
double bounds[6];
polygonVtk->GetPoints()->GetBounds(bounds);
for (int i=0; i<PointsOnPlane.size(); i++)
{
double checkIn[3] = {clipperout->GetPoint(PointsOnPlane[i])[0], clipperout->GetPoint(PointsOnPlane[i])[1], clipperout->GetPoint(PointsOnPlane[i])[2]};
int isInPolygon = polygonVtk->PointInPolygon(checkIn, polygonVtk->GetPoints()->GetNumberOfPoints()
, static_cast<double*>(polygonVtk->GetPoints()->GetData()->GetVoidPointer(0)), bounds, n);
if( isInPolygon )
PointsInROI.push_back(PointsOnPlane[i]);
}
}
MITK_DEBUG << "Step3: Identify fibers";
// we need to access the fiberId Array, so make sure that this array is available
if (!clipperout->GetCellData()->HasArray(FIBER_ID_ARRAY))
{
MITK_DEBUG << "ERROR: FiberID array does not exist, no correlation between points and fiberIds possible! Make sure calling GenerateFiberIds()";
return FibersInROI; // FibersInRoi is empty then
}
if (PointsInROI.size()<=0)
return FibersInROI;
// prepare a structure where each point id is represented as an indexId.
// vector looks like: | pntId | fiberIdx |
std::vector< long > pointindexFiberMap;
// walk through the whole subline section and create an vector sorted by point index
vtkCellArray *clipperlines = clipperout->GetLines();
clipperlines->InitTraversal();
long numOfLineCells = clipperlines->GetNumberOfCells();
long numofClippedPoints = clipperout->GetNumberOfPoints();
pointindexFiberMap.resize(numofClippedPoints);
//prepare resulting vector
FibersInROI.reserve(PointsInROI.size());
MITK_DEBUG << "\n===== Pointindex based structure initialized ======\n";
// go through resulting "sub"lines which are stored as cells, "i" corresponds to current line id.
for (int i=0, ic=0 ; i<numOfLineCells; i++, ic+=3)
{ //ic is the index counter for the cells hosting the desired information, eg. 2 | 45 | 46. each cell consits of 3 items.
vtkIdType npts;
vtkIdType *pts;
clipperlines->GetCell(ic, npts, pts);
// go through point ids in hosting subline, "j" corresponds to current pointindex in current line i. eg. idx[0]=45; idx[1]=46
for (long j=0; j<npts; j++)
{
// MITK_DEBUG << "writing fiber id: " << clipperout->GetCellData()->GetArray(FIBER_ID_ARRAY)->GetTuple(i)[0] << " to pointId: " << pts[j];
pointindexFiberMap[ pts[j] ] = clipperout->GetCellData()->GetArray(FIBER_ID_ARRAY)->GetTuple(i)[0];
// MITK_DEBUG << "in array: " << pointindexFiberMap[ pts[j] ];
}
}
MITK_DEBUG << "\n===== Pointindex based structure finalized ======\n";
// get all Points in ROI with according fiberID
for (long k = 0; k < PointsInROI.size(); k++)
{
//MITK_DEBUG << "point " << PointsInROI[k] << " belongs to fiber " << pointindexFiberMap[ PointsInROI[k] ];
if (pointindexFiberMap[ PointsInROI[k] ]<=GetNumFibers() && pointindexFiberMap[ PointsInROI[k] ]>=0)
FibersInROI.push_back(pointindexFiberMap[ PointsInROI[k] ]);
else
MITK_INFO << "ERROR in ExtractFiberIdSubset; impossible fiber id detected";
}
m_PointsRoi = PointsInROI;
}
// detecting fiberId duplicates
MITK_DEBUG << "check for duplicates";
sort(FibersInROI.begin(), FibersInROI.end());
bool hasDuplicats = false;
for(long i=0; i<FibersInROI.size()-1; ++i)
{
if(FibersInROI[i] == FibersInROI[i+1])
hasDuplicats = true;
}
if(hasDuplicats)
{
std::vector<long>::iterator it;
it = unique (FibersInROI.begin(), FibersInROI.end());
FibersInROI.resize( it - FibersInROI.begin() );
}
return FibersInROI;
}
void mitk::FiberBundleX::UpdateFiberGeometry()
{
vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
cleaner->SetInput(m_FiberPolyData);
cleaner->PointMergingOff();
cleaner->Update();
m_FiberPolyData = cleaner->GetOutput();
m_FiberLengths.clear();
m_MeanFiberLength = 0;
m_MedianFiberLength = 0;
m_LengthStDev = 0;
- m_NumFibers = m_FiberPolyData->GetNumberOfLines();
+ m_NumFibers = m_FiberPolyData->GetNumberOfCells();
if (m_NumFibers<=0) // no fibers present; apply default geometry
{
m_MinFiberLength = 0;
m_MaxFiberLength = 0;
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetImageGeometry(true);
float b[] = {0, 1, 0, 1, 0, 1};
geometry->SetFloatBounds(b);
SetGeometry(geometry);
return;
}
float min = itk::NumericTraits<float>::NonpositiveMin();
float max = itk::NumericTraits<float>::max();
float b[] = {max, min, max, min, max, min};
- vtkCellArray* cells = m_FiberPolyData->GetLines();
- cells->InitTraversal();
for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
{
vtkCell* cell = m_FiberPolyData->GetCell(i);
int p = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
float length = 0;
for (int j=0; j<p; j++)
{
// calculate bounding box
double p1[3];
points->GetPoint(j, p1);
if (p1[0]<b[0])
b[0]=p1[0];
if (p1[0]>b[1])
b[1]=p1[0];
if (p1[1]<b[2])
b[2]=p1[1];
if (p1[1]>b[3])
b[3]=p1[1];
if (p1[2]<b[4])
b[4]=p1[2];
if (p1[2]>b[5])
b[5]=p1[2];
// calculate statistics
if (j<p-1)
{
double p2[3];
points->GetPoint(j+1, p2);
float dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2]));
length += dist;
}
}
m_FiberLengths.push_back(length);
m_MeanFiberLength += length;
if (i==0)
{
m_MinFiberLength = length;
m_MaxFiberLength = length;
}
else
{
if (length<m_MinFiberLength)
m_MinFiberLength = length;
if (length>m_MaxFiberLength)
m_MaxFiberLength = length;
}
}
m_MeanFiberLength /= m_NumFibers;
std::vector< float > sortedLengths = m_FiberLengths;
std::sort(sortedLengths.begin(), sortedLengths.end());
for (int i=0; i<m_NumFibers; i++)
m_LengthStDev += (m_MeanFiberLength-sortedLengths.at(i))*(m_MeanFiberLength-sortedLengths.at(i));
if (m_NumFibers>1)
m_LengthStDev /= (m_NumFibers-1);
else
m_LengthStDev = 0;
m_LengthStDev = std::sqrt(m_LengthStDev);
m_MedianFiberLength = sortedLengths.at(m_NumFibers/2);
// provide some border margin
for(int i=0; i<=4; i+=2)
b[i] -=10;
for(int i=1; i<=5; i+=2)
b[i] +=10;
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetFloatBounds(b);
this->SetGeometry(geometry);
}
QStringList mitk::FiberBundleX::GetAvailableColorCodings()
{
QStringList availableColorCodings;
int numColors = m_FiberPolyData->GetPointData()->GetNumberOfArrays();
for(int i=0; i<numColors; i++)
{
availableColorCodings.append(m_FiberPolyData->GetPointData()->GetArrayName(i));
}
//this controlstructure shall be implemented by the calling method
if (availableColorCodings.isEmpty())
MITK_DEBUG << "no colorcodings available in fiberbundleX";
return availableColorCodings;
}
char* mitk::FiberBundleX::GetCurrentColorCoding()
{
return m_CurrentColorCoding;
}
void mitk::FiberBundleX::SetColorCoding(const char* requestedColorCoding)
{
if (requestedColorCoding==NULL)
return;
MITK_DEBUG << "SetColorCoding:" << requestedColorCoding;
if( strcmp (COLORCODING_ORIENTATION_BASED,requestedColorCoding) == 0 ) {
this->m_CurrentColorCoding = (char*) COLORCODING_ORIENTATION_BASED;
} else if( strcmp (COLORCODING_FA_BASED,requestedColorCoding) == 0 ) {
this->m_CurrentColorCoding = (char*) COLORCODING_FA_BASED;
} else if( strcmp (COLORCODING_CUSTOM,requestedColorCoding) == 0 ) {
this->m_CurrentColorCoding = (char*) COLORCODING_CUSTOM;
} else {
MITK_DEBUG << "FIBERBUNDLE X: UNKNOWN COLORCODING in FIBERBUNDLEX Datastructure";
this->m_CurrentColorCoding = (char*) COLORCODING_CUSTOM; //will cause blank colorcoding of fibers
}
}
void mitk::FiberBundleX::RotateAroundAxis(double x, double y, double z)
{
MITK_INFO << "Rotating fibers";
x = x*M_PI/180;
y = y*M_PI/180;
z = z*M_PI/180;
vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
rotX[1][1] = cos(x);
rotX[2][2] = rotX[1][1];
rotX[1][2] = -sin(x);
rotX[2][1] = -rotX[1][2];
vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
rotY[0][0] = cos(y);
rotY[2][2] = rotY[0][0];
rotY[0][2] = sin(y);
rotY[2][0] = -rotY[0][2];
vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
rotZ[0][0] = cos(z);
rotZ[1][1] = rotZ[0][0];
rotZ[0][1] = -sin(z);
rotZ[1][0] = -rotZ[0][1];
mitk::Geometry3D::Pointer geom = this->GetGeometry();
mitk::Point3D center = geom->GetCenter();
boost::progress_display disp(m_NumFibers);
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
+
for (int i=0; i<m_NumFibers; i++)
{
++disp ;
- vtkIdType numPoints(0);
- vtkIdType* pointIds(NULL);
- vLines->GetNextCell ( numPoints, pointIds );
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
- double* p = m_FiberPolyData->GetPoint(pointIds[j]);
+ double* p = points->GetPoint(j);
vnl_vector_fixed< double, 3 > dir;
dir[0] = p[0]-center[0];
dir[1] = p[1]-center[1];
dir[2] = p[2]-center[2];
dir = rotZ*rotY*rotX*dir;
dir[0] += center[0];
dir[1] += center[1];
dir[2] += center[2];
vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
UpdateColorCoding();
UpdateFiberGeometry();
}
void mitk::FiberBundleX::ScaleFibers(double x, double y, double z)
{
MITK_INFO << "Scaling fibers";
boost::progress_display disp(m_NumFibers);
mitk::Geometry3D* geom = this->GetGeometry();
mitk::Point3D c = geom->GetCenter();
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
for (int i=0; i<m_NumFibers; i++)
{
++disp ;
- vtkIdType numPoints(0);
- vtkIdType* pointIds(NULL);
- vLines->GetNextCell ( numPoints, pointIds );
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
- double* p = m_FiberPolyData->GetPoint(pointIds[j]);
+ double* p = points->GetPoint(j);
p[0] -= c[0]; p[1] -= c[1]; p[2] -= c[2];
p[0] *= x;
p[1] *= y;
p[2] *= z;
p[0] += c[0]; p[1] += c[1]; p[2] += c[2];
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
UpdateColorCoding();
UpdateFiberGeometry();
}
void mitk::FiberBundleX::TranslateFibers(double x, double y, double z)
{
MITK_INFO << "Translating fibers";
boost::progress_display disp(m_NumFibers);
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
for (int i=0; i<m_NumFibers; i++)
{
- ++disp ;
- vtkIdType numPoints(0);
- vtkIdType* pointIds(NULL);
- vLines->GetNextCell ( numPoints, pointIds );
+ ++disp;
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
- double* p = m_FiberPolyData->GetPoint(pointIds[j]);
+ double* p = points->GetPoint(j);
p[0] += x;
p[1] += y;
p[2] += z;
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
UpdateColorCoding();
UpdateFiberGeometry();
}
void mitk::FiberBundleX::MirrorFibers(unsigned int axis)
{
if (axis>2)
return;
MITK_INFO << "Mirroring fibers";
boost::progress_display disp(m_NumFibers);
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
for (int i=0; i<m_NumFibers; i++)
{
- ++disp ;
- vtkIdType numPoints(0);
- vtkIdType* pointIds(NULL);
- vLines->GetNextCell ( numPoints, pointIds );
+ ++disp;
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
- double* p = m_FiberPolyData->GetPoint(pointIds[j]);
+ double* p = points->GetPoint(j);
p[axis] = -p[axis];
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
UpdateColorCoding();
UpdateFiberGeometry();
}
bool mitk::FiberBundleX::ApplyCurvatureThreshold(float minRadius, bool deleteFibers)
{
if (minRadius<0)
return true;
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
- vtkSmartPointer<vtkCellArray> vtkOldCells = m_FiberPolyData->GetLines();
- vtkOldCells->InitTraversal();
MITK_INFO << "Applying curvature threshold";
boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
{
++disp ;
- vtkIdType numPoints(0);
- vtkIdType* points(NULL);
- vtkOldCells->GetNextCell ( numPoints, points );
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
// calculate curvatures
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints-2; j++)
{
double p1[3];
- m_FiberPolyData->GetPoint(points[j], p1);
+ points->GetPoint(j, p1);
double p2[3];
- m_FiberPolyData->GetPoint(points[j+1], p2);
+ points->GetPoint(j+1, p2);
double p3[3];
- m_FiberPolyData->GetPoint(points[j+2], p3);
+ points->GetPoint(j+2, p3);
vnl_vector_fixed< float, 3 > v1, v2, v3;
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
v2[0] = p3[0]-p2[0];
v2[1] = p3[1]-p2[1];
v2[2] = p3[2]-p2[2];
v3[0] = p1[0]-p3[0];
v3[1] = p1[1]-p3[1];
v3[2] = p1[2]-p3[2];
float a = v1.magnitude();
float b = v2.magnitude();
float c = v3.magnitude();
float r = a*b*c/std::sqrt((a+b+c)*(a+b-c)*(b+c-a)*(a-b+c)); // radius of triangle via Heron's formula (area of triangle)
vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
container->GetPointIds()->InsertNextId(id);
if (deleteFibers && r<minRadius)
break;
if (r<minRadius)
{
j += 2;
-// id = vtkNewPoints->InsertNextPoint(p2);
-// container->GetPointIds()->InsertNextId(id);
vtkNewCells->InsertNextCell(container);
container = vtkSmartPointer<vtkPolyLine>::New();
}
else if (j==numPoints-3)
{
id = vtkNewPoints->InsertNextPoint(p2);
container->GetPointIds()->InsertNextId(id);
id = vtkNewPoints->InsertNextPoint(p3);
container->GetPointIds()->InsertNextId(id);
vtkNewCells->InsertNextCell(container);
}
}
}
if (vtkNewCells->GetNumberOfCells()<=0)
return false;
-
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
UpdateColorCoding();
UpdateFiberGeometry();
return true;
}
bool mitk::FiberBundleX::RemoveShortFibers(float lengthInMM)
{
if (lengthInMM<=0 || lengthInMM<m_MinFiberLength)
return true;
if (lengthInMM>m_MaxFiberLength) // can't remove all fibers
return false;
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
float min = m_MaxFiberLength;
MITK_INFO << "Removing short fibers";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp;
- vtkIdType numPoints(0);
- vtkIdType* pointIds(NULL);
- vLines->GetNextCell ( numPoints, pointIds );
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
if (m_FiberLengths.at(i)>=lengthInMM)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
- double* p = m_FiberPolyData->GetPoint(pointIds[j]);
+ double* p = points->GetPoint(j);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
if (m_FiberLengths.at(i)<min)
min = m_FiberLengths.at(i);
}
}
if (vtkNewCells->GetNumberOfCells()<=0)
return false;
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
UpdateColorCoding();
UpdateFiberGeometry();
return true;
}
bool mitk::FiberBundleX::RemoveLongFibers(float lengthInMM)
{
if (lengthInMM<=0 || lengthInMM>m_MaxFiberLength)
return true;
if (lengthInMM<m_MinFiberLength) // can't remove all fibers
return false;
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
MITK_INFO << "Removing long fibers";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp;
- vtkIdType numPoints(0);
- vtkIdType* pointIds(NULL);
- vLines->GetNextCell ( numPoints, pointIds );
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
if (m_FiberLengths.at(i)<=lengthInMM)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
- double* p = m_FiberPolyData->GetPoint(pointIds[j]);
+ double* p = points->GetPoint(j);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
}
if (vtkNewCells->GetNumberOfCells()<=0)
return false;
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
UpdateColorCoding();
UpdateFiberGeometry();
return true;
}
void mitk::FiberBundleX::DoFiberSmoothing(int pointsPerCm, double tension, double continuity, double bias )
{
vtkSmartPointer<vtkPoints> vtkSmoothPoints = vtkSmartPointer<vtkPoints>::New(); //in smoothpoints the interpolated points representing a fiber are stored.
//in vtkcells all polylines are stored, actually all id's of them are stored
vtkSmartPointer<vtkCellArray> vtkSmoothCells = vtkSmartPointer<vtkCellArray>::New(); //cellcontainer for smoothed lines
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
vtkIdType pointHelperCnt = 0;
MITK_INFO << "Resampling fibers";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp;
- vtkIdType numPoints(0);
- vtkIdType* pointIds(NULL);
- vLines->GetNextCell ( numPoints, pointIds );
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
- vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+ vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
for (int j=0; j<numPoints; j++)
- points->InsertNextPoint(m_FiberPolyData->GetPoint(pointIds[j]));
+ newPoints->InsertNextPoint(points->GetPoint(j));
float length = m_FiberLengths.at(i);
length /=10;
int sampling = pointsPerCm*length;
vtkSmartPointer<vtkKochanekSpline> xSpline = vtkSmartPointer<vtkKochanekSpline>::New();
vtkSmartPointer<vtkKochanekSpline> ySpline = vtkSmartPointer<vtkKochanekSpline>::New();
vtkSmartPointer<vtkKochanekSpline> zSpline = vtkSmartPointer<vtkKochanekSpline>::New();
xSpline->SetDefaultBias(bias); xSpline->SetDefaultTension(tension); xSpline->SetDefaultContinuity(continuity);
ySpline->SetDefaultBias(bias); ySpline->SetDefaultTension(tension); ySpline->SetDefaultContinuity(continuity);
zSpline->SetDefaultBias(bias); zSpline->SetDefaultTension(tension); zSpline->SetDefaultContinuity(continuity);
vtkSmartPointer<vtkParametricSpline> spline = vtkSmartPointer<vtkParametricSpline>::New();
spline->SetXSpline(xSpline);
spline->SetYSpline(ySpline);
spline->SetZSpline(zSpline);
- spline->SetPoints(points);
+ spline->SetPoints(newPoints);
vtkSmartPointer<vtkParametricFunctionSource> functionSource = vtkSmartPointer<vtkParametricFunctionSource>::New();
functionSource->SetParametricFunction(spline);
functionSource->SetUResolution(sampling);
functionSource->SetVResolution(sampling);
functionSource->SetWResolution(sampling);
functionSource->Update();
vtkPolyData* outputFunction = functionSource->GetOutput();
vtkPoints* tmpSmoothPnts = outputFunction->GetPoints(); //smoothPoints of current fiber
vtkSmartPointer<vtkPolyLine> smoothLine = vtkSmartPointer<vtkPolyLine>::New();
smoothLine->GetPointIds()->SetNumberOfIds(tmpSmoothPnts->GetNumberOfPoints());
for (int j=0; j<smoothLine->GetNumberOfPoints(); j++)
{
smoothLine->GetPointIds()->SetId(j, j+pointHelperCnt);
vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
}
vtkSmoothCells->InsertNextCell(smoothLine);
pointHelperCnt += tmpSmoothPnts->GetNumberOfPoints();
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkSmoothPoints);
m_FiberPolyData->SetLines(vtkSmoothCells);
UpdateColorCoding();
UpdateFiberGeometry();
m_FiberSampling = pointsPerCm;
}
void mitk::FiberBundleX::DoFiberSmoothing(int pointsPerCm)
{
DoFiberSmoothing(pointsPerCm, 0, 0, 0 );
}
// Resample fiber to get equidistant points
void mitk::FiberBundleX::ResampleFibers(float pointDistance)
{
if (pointDistance<=0.00001)
return;
vtkSmartPointer<vtkPolyData> newPoly = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> newCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
- vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
- vLines->InitTraversal();
int numberOfLines = m_NumFibers;
MITK_INFO << "Resampling fibers";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<numberOfLines; i++)
{
++disp;
- vtkIdType numPoints(0);
- vtkIdType* points(NULL);
- vLines->GetNextCell ( numPoints, points );
+ vtkCell* cell = m_FiberPolyData->GetCell(i);
+ int numPoints = cell->GetNumberOfPoints();
+ vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
- double* point = m_FiberPolyData->GetPoint(points[0]);
+ double* point = points->GetPoint(0);
vtkIdType pointId = newPoints->InsertNextPoint(point);
container->GetPointIds()->InsertNextId(pointId);
float dtau = 0;
int cur_p = 1;
itk::Vector<float,3> dR;
float normdR = 0;
for (;;)
{
while (dtau <= pointDistance && cur_p < numPoints)
{
itk::Vector<float,3> v1;
- point = m_FiberPolyData->GetPoint(points[cur_p-1]);
+ point = points->GetPoint(cur_p-1);
v1[0] = point[0];
v1[1] = point[1];
v1[2] = point[2];
itk::Vector<float,3> v2;
- point = m_FiberPolyData->GetPoint(points[cur_p]);
+ point = points->GetPoint(cur_p);
v2[0] = point[0];
v2[1] = point[1];
v2[2] = point[2];
dR = v2 - v1;
normdR = std::sqrt(dR.GetSquaredNorm());
dtau += normdR;
cur_p++;
}
if (dtau >= pointDistance)
{
itk::Vector<float,3> v1;
- point = m_FiberPolyData->GetPoint(points[cur_p-1]);
+ point = points->GetPoint(cur_p-1);
v1[0] = point[0];
v1[1] = point[1];
v1[2] = point[2];
itk::Vector<float,3> v2 = v1 - dR*( (dtau-pointDistance)/normdR );
pointId = newPoints->InsertNextPoint(v2.GetDataPointer());
container->GetPointIds()->InsertNextId(pointId);
}
else
{
- point = m_FiberPolyData->GetPoint(points[numPoints-1]);
+ point = points->GetPoint(numPoints-1);
pointId = newPoints->InsertNextPoint(point);
container->GetPointIds()->InsertNextId(pointId);
break;
}
dtau = dtau-pointDistance;
}
newCellArray->InsertNextCell(container);
}
newPoly->SetPoints(newPoints);
newPoly->SetLines(newCellArray);
m_FiberPolyData = newPoly;
UpdateFiberGeometry();
UpdateColorCoding();
m_FiberSampling = 10/pointDistance;
}
// reapply selected colorcoding in case polydata structure has changed
void mitk::FiberBundleX::UpdateColorCoding()
{
char* cc = GetCurrentColorCoding();
if( strcmp (COLORCODING_ORIENTATION_BASED,cc) == 0 )
DoColorCodingOrientationBased();
else if( strcmp (COLORCODING_FA_BASED,cc) == 0 )
DoColorCodingFaBased();
}
// reapply selected colorcoding in case polydata structure has changed
bool mitk::FiberBundleX::Equals(mitk::FiberBundleX* fib)
{
if (fib==NULL)
return false;
mitk::FiberBundleX::Pointer tempFib = this->SubtractBundle(fib);
mitk::FiberBundleX::Pointer tempFib2 = fib->SubtractBundle(this);
if (tempFib.IsNull() && tempFib2.IsNull())
return true;
return false;
}
/* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
void mitk::FiberBundleX::UpdateOutputInformation()
{
}
void mitk::FiberBundleX::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::FiberBundleX::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::FiberBundleX::VerifyRequestedRegion()
{
return true;
}
-void mitk::FiberBundleX::SetRequestedRegion( itk::DataObject *data )
+void mitk::FiberBundleX::SetRequestedRegion(const itk::DataObject *data )
{
}
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
index 3588003fdd..aae49e042f 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
@@ -1,157 +1,157 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_FiberBundleX_H
#define _MITK_FiberBundleX_H
//includes for MITK datastructure
#include <mitkBaseData.h>
#include "FiberTrackingExports.h"
#include <mitkImage.h>
//includes storing fiberdata
#include <vtkSmartPointer.h> //may be replaced by class precompile argument
#include <vtkPolyData.h> // may be replaced by class
#include <vtkPoints.h> // my be replaced by class
#include <vtkDataSet.h>
#include <QStringList>
#include <mitkPlanarFigure.h>
namespace mitk {
/**
* \brief Base Class for Fiber Bundles; */
class FiberTracking_EXPORT FiberBundleX : public BaseData
{
public:
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
// fiber colorcodings
static const char* COLORCODING_ORIENTATION_BASED;
static const char* COLORCODING_FA_BASED;
static const char* COLORCODING_CUSTOM;
static const char* FIBER_ID_ARRAY;
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
- virtual void SetRequestedRegion( itk::DataObject *data );
+ virtual void SetRequestedRegion(const itk::DataObject *data );
mitkClassMacro( FiberBundleX, BaseData )
itkNewMacro( Self )
mitkNewMacro1Param(Self, vtkSmartPointer<vtkPolyData>) // custom constructor
// colorcoding related methods
void SetColorCoding(const char*);
void SetFAMap(mitk::Image::Pointer);
void DoColorCodingOrientationBased();
void DoColorCodingFaBased();
void DoUseFaFiberOpacity();
void ResetFiberOpacity();
// fiber smoothing/resampling
void ResampleFibers(float pointDistance = 1);
void DoFiberSmoothing(int pointsPerCm);
void DoFiberSmoothing(int pointsPerCm, double tension, double continuity, double bias );
bool RemoveShortFibers(float lengthInMM);
bool RemoveLongFibers(float lengthInMM);
bool ApplyCurvatureThreshold(float minRadius, bool deleteFibers);
void MirrorFibers(unsigned int axis);
void RotateAroundAxis(double x, double y, double z);
void TranslateFibers(double x, double y, double z);
void ScaleFibers(double x, double y, double z);
// add/subtract fibers
FiberBundleX::Pointer AddBundle(FiberBundleX* fib);
FiberBundleX::Pointer SubtractBundle(FiberBundleX* fib);
// fiber subset extraction
FiberBundleX::Pointer ExtractFiberSubset(PlanarFigure *pf);
std::vector<long> ExtractFiberIdSubset(PlanarFigure* pf);
FiberBundleX::Pointer ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint);
vtkSmartPointer<vtkPolyData> GeneratePolyDataByIds( std::vector<long> ); // TODO: make protected
void GenerateFiberIds(); // TODO: make protected
// get/set data
void SetFiberPolyData(vtkSmartPointer<vtkPolyData>, bool updateGeometry = true);
vtkSmartPointer<vtkPolyData> GetFiberPolyData();
QStringList GetAvailableColorCodings();
char* GetCurrentColorCoding();
itkGetMacro( NumFibers, int)
itkGetMacro( FiberSampling, int)
itkGetMacro( MinFiberLength, float )
itkGetMacro( MaxFiberLength, float )
itkGetMacro( MeanFiberLength, float )
itkGetMacro( MedianFiberLength, float )
itkGetMacro( LengthStDev, float )
std::vector<int> GetPointsRoi()
{
return m_PointsRoi;
}
// copy fiber bundle
mitk::FiberBundleX::Pointer GetDeepCopy();
// compare fiber bundles
bool Equals(FiberBundleX* fib);
protected:
FiberBundleX( vtkPolyData* fiberPolyData = NULL );
virtual ~FiberBundleX();
itk::Point<float, 3> GetItkPoint(double point[3]);
// calculate geometry from fiber extent
void UpdateFiberGeometry();
// calculate colorcoding values according to m_CurrentColorCoding
void UpdateColorCoding();
private:
// actual fiber container
vtkSmartPointer<vtkPolyData> m_FiberPolyData;
// contains fiber ids
vtkSmartPointer<vtkDataSet> m_FiberIdDataSet;
char* m_CurrentColorCoding;
int m_NumFibers;
std::vector< float > m_FiberLengths;
float m_MinFiberLength;
float m_MaxFiberLength;
float m_MeanFiberLength;
float m_MedianFiberLength;
float m_LengthStDev;
int m_FiberSampling;
std::vector<int> m_PointsRoi; // this global variable needs to be refactored
};
} // namespace mitk
#endif /* _MITK_FiberBundleX_H */
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXReader.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXReader.cpp
index c1b5444bf2..e166afc041 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXReader.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXReader.cpp
@@ -1,281 +1,296 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkFiberBundleXReader.h"
#include <itkMetaDataObject.h>
#include <vtkPolyData.h>
#include <vtkDataReader.h>
#include <vtkPolyDataReader.h>
#include <vtkMatrix4x4.h>
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <itksys/SystemTools.hxx>
#include <tinyxml.h>
#include <vtkCleanPolyData.h>
namespace mitk
{
void FiberBundleXReader
::GenerateData()
{
if ( ( ! m_OutputCache ) )
{
Superclass::SetNumberOfRequiredOutputs(0);
this->GenerateOutputInformation();
}
if (!m_OutputCache)
{
itkWarningMacro("Output cache is empty!");
}
Superclass::SetNumberOfRequiredOutputs(1);
Superclass::SetNthOutput(0, m_OutputCache.GetPointer());
}
void FiberBundleXReader::GenerateOutputInformation()
{
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
setlocale(LC_ALL, locale.c_str());
std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
ext = itksys::SystemTools::LowerCase(ext);
vtkSmartPointer<vtkDataReader> chooser=vtkSmartPointer<vtkDataReader>::New();
chooser->SetFileName(m_FileName.c_str() );
if( chooser->IsFilePolyData())
{
MITK_INFO << "Reading vtk fiber bundle";
vtkSmartPointer<vtkPolyDataReader> reader = vtkSmartPointer<vtkPolyDataReader>::New();
reader->SetFileName( m_FileName.c_str() );
reader->Update();
if ( reader->GetOutput() != NULL )
{
vtkSmartPointer<vtkPolyData> fiberPolyData = reader->GetOutput();
// vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
// cleaner->SetInput(fiberPolyData);
// cleaner->Update();
// fiberPolyData = cleaner->GetOutput();
m_OutputCache = OutputType::New(fiberPolyData);
}
}
else // try to read deprecated fiber bundle file format
{
MITK_INFO << "Reading xml fiber bundle";
vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> cellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
TiXmlDocument doc( m_FileName );
if(doc.LoadFile())
{
TiXmlHandle hDoc(&doc);
TiXmlElement* pElem;
TiXmlHandle hRoot(0);
pElem = hDoc.FirstChildElement().Element();
// save this for later
hRoot = TiXmlHandle(pElem);
pElem = hRoot.FirstChildElement("geometry").Element();
// read geometry
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
// read origin
mitk::Point3D origin;
double temp = 0;
pElem->Attribute("origin_x", &temp);
origin[0] = temp;
pElem->Attribute("origin_y", &temp);
origin[1] = temp;
pElem->Attribute("origin_z", &temp);
origin[2] = temp;
geometry->SetOrigin(origin);
// read spacing
float spacing[3];
pElem->Attribute("spacing_x", &temp);
spacing[0] = temp;
pElem->Attribute("spacing_y", &temp);
spacing[1] = temp;
pElem->Attribute("spacing_z", &temp);
spacing[2] = temp;
geometry->SetSpacing(spacing);
// read transform
vtkMatrix4x4* m = vtkMatrix4x4::New();
pElem->Attribute("xx", &temp);
m->SetElement(0,0,temp);
pElem->Attribute("xy", &temp);
m->SetElement(1,0,temp);
pElem->Attribute("xz", &temp);
m->SetElement(2,0,temp);
pElem->Attribute("yx", &temp);
m->SetElement(0,1,temp);
pElem->Attribute("yy", &temp);
m->SetElement(1,1,temp);
pElem->Attribute("yz", &temp);
m->SetElement(2,1,temp);
pElem->Attribute("zx", &temp);
m->SetElement(0,2,temp);
pElem->Attribute("zy", &temp);
m->SetElement(1,2,temp);
pElem->Attribute("zz", &temp);
m->SetElement(2,2,temp);
m->SetElement(0,3,origin[0]);
m->SetElement(1,3,origin[1]);
m->SetElement(2,3,origin[2]);
m->SetElement(3,3,1);
geometry->SetIndexToWorldTransformByVtkMatrix(m);
// read bounds
float bounds[] = {0, 0, 0, 0, 0, 0};
pElem->Attribute("size_x", &temp);
bounds[1] = temp;
pElem->Attribute("size_y", &temp);
bounds[3] = temp;
pElem->Attribute("size_z", &temp);
bounds[5] = temp;
geometry->SetFloatBounds(bounds);
geometry->SetImageGeometry(true);
pElem = hRoot.FirstChildElement("fiber_bundle").FirstChild().Element();
for( pElem; pElem; pElem=pElem->NextSiblingElement())
{
TiXmlElement* pElem2 = pElem->FirstChildElement();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for( pElem2; pElem2; pElem2=pElem2->NextSiblingElement())
{
itk::Point<float> point;
pElem2->Attribute("pos_x", &temp);
point[0] = temp;
pElem2->Attribute("pos_y", &temp);
point[1] = temp;
pElem2->Attribute("pos_z", &temp);
point[2] = temp;
geometry->IndexToWorld(point, point);
vtkIdType id = points->InsertNextPoint(point.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
}
cellArray->InsertNextCell(container);
}
fiberPolyData->SetPoints(points);
fiberPolyData->SetLines(cellArray);
vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
cleaner->SetInput(fiberPolyData);
cleaner->Update();
fiberPolyData = cleaner->GetOutput();
m_OutputCache = OutputType::New(fiberPolyData);
}
else
{
MITK_INFO << "could not open xml file";
throw "could not open xml file";
}
}
setlocale(LC_ALL, currLocale.c_str());
MITK_INFO << "Fiber bundle read";
}
catch(...)
{
throw;
}
}
void FiberBundleXReader::Update()
{
this->GenerateData();
}
const char* FiberBundleXReader
::GetFileName() const
{
return m_FileName.c_str();
}
void FiberBundleXReader
::SetFileName(const char* aFileName)
{
m_FileName = aFileName;
}
const char* FiberBundleXReader
::GetFilePrefix() const
{
return m_FilePrefix.c_str();
}
void FiberBundleXReader
::SetFilePrefix(const char* aFilePrefix)
{
m_FilePrefix = aFilePrefix;
}
const char* FiberBundleXReader
::GetFilePattern() const
{
return m_FilePattern.c_str();
}
void FiberBundleXReader
::SetFilePattern(const char* aFilePattern)
{
m_FilePattern = aFilePattern;
}
bool FiberBundleXReader
::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
{
// First check the extension
if( filename == "" )
{
return false;
}
std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
ext = itksys::SystemTools::LowerCase(ext);
if (ext == ".fib")
{
return true;
}
return false;
}
+ BaseDataSource::DataObjectPointer FiberBundleXReader::MakeOutput(const DataObjectIdentifierType &name)
+ {
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
+ {
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
+ }
+ return static_cast<itk::DataObject*>(OutputType::New().GetPointer());
+ }
+
+ BaseDataSource::DataObjectPointer FiberBundleXReader::MakeOutput(DataObjectPointerArraySizeType /*idx*/)
+ {
+ return OutputType::New().GetPointer();
+ }
+
} //namespace MITK
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXReader.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXReader.h
index 3fcfe85c40..e41f1aab92 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXReader.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXReader.h
@@ -1,77 +1,81 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkFiberBundleXReader_h
#define __mitkFiberBundleXReader_h
#include <mitkCommon.h>
#include <mitkFileReader.h>
#include <mitkFiberBundleX.h>
#include <vtkSmartPointer.h>
#include <FiberTrackingExports.h>
namespace mitk
{
/** \brief
*/
- class FiberTracking_EXPORT FiberBundleXReader : public FileReader, public BaseProcess
+ class FiberTracking_EXPORT FiberBundleXReader : public FileReader, public BaseDataSource
{
public:
/** Types for the standardized TractContainer **/
/* direct linked includes of mitkFiberBundleX DataStructure */
typedef mitk::FiberBundleX OutputType;
- mitkClassMacro( FiberBundleXReader, BaseProcess );
+ mitkClassMacro( FiberBundleXReader, BaseDataSource );
itkNewMacro(Self);
const char* GetFileName() const;
void SetFileName(const char* aFileName);
const char* GetFilePrefix() const;
void SetFilePrefix(const char* aFilePrefix);
const char* GetFilePattern() const;
void SetFilePattern(const char* aFilePattern);
static bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern);
// itkGetMacro(GroupFiberBundleX, FiberGroupType::Pointer);
// itkGetMacro(TractContainer, ContainerType::Pointer);
virtual void Update();
+ BaseDataSource::DataObjectPointer MakeOutput(const DataObjectIdentifierType &name);
+
+ BaseDataSource::DataObjectPointer MakeOutput( DataObjectPointerArraySizeType idx);
+
protected:
/** Does the real work. */
virtual void GenerateData();
virtual void GenerateOutputInformation();
OutputType::Pointer m_OutputCache;
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
private:
void operator=(const Self&); //purposely not implemented
};
} //namespace MITK
#endif // __mitkFiberBundleXReader_h
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.h
index aaf30dee65..56cdee8720 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.h
@@ -1,51 +1,51 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QBallImageSource_H_HEADER_INCLUDED_C1E7D6EC
#define QBallImageSource_H_HEADER_INCLUDED_C1E7D6EC
#include "mitkImageSource.h"
#include "mitkQBallImage.h"
//NOTE>umbenennen .. ableiten von DataSource
namespace mitk {
class QBallImageSource : public ImageSource
{
public:
typedef mitk::QBallImage OutputImageType;
typedef OutputImageType::Pointer OutputImagePointer;
typedef SlicedData::RegionType OutputImageRegionType;
typedef itk::DataObject::Pointer DataObjectPointer;
mitkClassMacro(QBallImageSource,ImageSource);
itkNewMacro(Self);
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx);
protected:
QBallImageSource();
virtual ~QBallImageSource() {}
};
} // namespace mitk
#endif /* QBallImageSource_H_HEADER_INCLUDED_C1E7D6EC */
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
index 5555f35e0d..caf0d042cd 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
@@ -1,254 +1,254 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkFiberBundleXThreadMonitor.h"
mitk::FiberBundleXThreadMonitor::FiberBundleXThreadMonitor()
: m_monitorBracketOpen("[")
, m_monitorBracketClose("]")
, m_monitorHeading("Monitoring Fiberprocessing Threads")
, m_monitorMask("Thread Status:\nStarted: Finished: Terminated:")
, m_monitorStatus("_initialized")
, m_monitorStarted(0)
, m_monitorFinished(0)
, m_monitorTerminated(0)
{
m_monitorBracketOpenPosition[0] = 0;
m_monitorBracketOpenPosition[1] = 0;
m_monitorBracketClosePosition[0] = 0;
m_monitorBracketClosePosition[1] = 0;
m_monitorHeadingPosition[0] = 0;
m_monitorHeadingPosition[1] = 0;
m_monitorMaskPosition[0] = 0;
m_monitorMaskPosition[1] = 0;
m_monitorStatusPosition[0] = 0;
m_monitorStatusPosition[1] = 0;
m_monitorStartedPosition[0] = 0;
m_monitorStartedPosition[1] = 0;
m_monitorFinishedPosition[0] = 0;
m_monitorFinishedPosition[1] = 0;
m_monitorTerminatedPosition[0] = 0;
m_monitorTerminatedPosition[1] = 0;
m_monitorHeadingOpacity = 0;
m_monitorMaskOpacity = 0;
m_monitorTerminatedOpacity = 0;
m_monitorFinishedOpacity = 0;
m_monitorStartedOpacity = 0;
m_monitorStatusOpacity = 0;
}
mitk::FiberBundleXThreadMonitor::~FiberBundleXThreadMonitor()
{
}
QString mitk::FiberBundleXThreadMonitor::getBracketOpen(){
return m_monitorBracketOpen;
}
mitk::Point2D mitk::FiberBundleXThreadMonitor::getBracketOpenPosition(){
return m_monitorBracketOpenPosition;
}
void mitk::FiberBundleXThreadMonitor::setBracketOpenPosition(mitk::Point2D pnt){
m_monitorBracketOpenPosition[0] = pnt[0];
m_monitorBracketOpenPosition[1] = pnt[1];
}
QString mitk::FiberBundleXThreadMonitor::getBracketClose(){
return m_monitorBracketClose;
}
mitk::Point2D mitk::FiberBundleXThreadMonitor::getBracketClosePosition(){
return m_monitorBracketClosePosition;
}
void mitk::FiberBundleXThreadMonitor::setBracketClosePosition(mitk::Point2D pnt){
m_monitorBracketClosePosition[0] = pnt[0];
m_monitorBracketClosePosition[1] = pnt[1];
}
QString mitk::FiberBundleXThreadMonitor::getHeading(){
return m_monitorHeading;
}
mitk::Point2D mitk::FiberBundleXThreadMonitor::getHeadingPosition(){
return m_monitorHeadingPosition;
}
void mitk::FiberBundleXThreadMonitor::setHeadingPosition(mitk::Point2D pnt){
m_monitorHeadingPosition[0] = pnt[0];
m_monitorHeadingPosition[1] = pnt[1];
}
int mitk::FiberBundleXThreadMonitor::getHeadingOpacity(){
return m_monitorHeadingOpacity;
}
void mitk::FiberBundleXThreadMonitor::setHeadingOpacity(int opacity){
m_monitorHeadingOpacity = opacity;
}
QString mitk::FiberBundleXThreadMonitor::getMask(){
return m_monitorMask;
}
mitk::Point2D mitk::FiberBundleXThreadMonitor::getMaskPosition(){
return m_monitorMaskPosition;
}
void mitk::FiberBundleXThreadMonitor::setMaskPosition(mitk::Point2D pnt){
m_monitorMaskPosition[0] = pnt[0];
m_monitorMaskPosition[1] = pnt[1];
}
int mitk::FiberBundleXThreadMonitor::getMaskOpacity(){
return m_monitorMaskOpacity;
}
void mitk::FiberBundleXThreadMonitor::setMaskOpacity(int opacity){
m_monitorMaskOpacity = opacity;
}
QString mitk::FiberBundleXThreadMonitor::getStatus(){
return m_monitorStatus;
}
void mitk::FiberBundleXThreadMonitor::setStatus(QString status){
m_statusMutex.lock();
m_monitorStatus = status;
m_statusMutex.unlock();
}
mitk::Point2D mitk::FiberBundleXThreadMonitor::getStatusPosition(){
return m_monitorStatusPosition;
}
void mitk::FiberBundleXThreadMonitor::setStatusPosition(mitk::Point2D pnt){
m_monitorStatusPosition[0] = pnt[0];
m_monitorStatusPosition[1] = pnt[1];
}
int mitk::FiberBundleXThreadMonitor::getStatusOpacity(){
return m_monitorStatusOpacity;
}
void mitk::FiberBundleXThreadMonitor::setStatusOpacity(int opacity){
m_monitorStatusOpacity = opacity;
}
int mitk::FiberBundleXThreadMonitor::getStarted(){
return m_monitorStarted;
}
/* is thread safe :) */
void mitk::FiberBundleXThreadMonitor::setStarted(int val)
{
m_startedMutex.lock();
m_monitorStarted = val;
m_startedMutex.unlock();
}
mitk::Point2D mitk::FiberBundleXThreadMonitor::getStartedPosition(){
return m_monitorStartedPosition;
}
void mitk::FiberBundleXThreadMonitor::setStartedPosition(mitk::Point2D pnt){
m_monitorStartedPosition[0] = pnt[0];
m_monitorStartedPosition[1] = pnt[1];
}
int mitk::FiberBundleXThreadMonitor::getStartedOpacity(){
return m_monitorStartedOpacity;
}
void mitk::FiberBundleXThreadMonitor::setStartedOpacity(int opacity){
m_monitorStartedOpacity = opacity;
}
int mitk::FiberBundleXThreadMonitor::getFinished(){
return m_monitorFinished;
}
void mitk::FiberBundleXThreadMonitor::setFinished(int val)
{
m_finishedMutex.lock();
m_monitorFinished = val;
m_finishedMutex.unlock();
}
mitk::Point2D mitk::FiberBundleXThreadMonitor::getFinishedPosition(){
return m_monitorFinishedPosition;
}
void mitk::FiberBundleXThreadMonitor::setFinishedPosition(mitk::Point2D pnt){
m_monitorFinishedPosition[0] = pnt[0];
m_monitorFinishedPosition[1] = pnt[1];
}
int mitk::FiberBundleXThreadMonitor::getFinishedOpacity(){
return m_monitorFinishedOpacity;
}
void mitk::FiberBundleXThreadMonitor::setFinishedOpacity(int opacity){
m_monitorFinishedOpacity = opacity;
}
int mitk::FiberBundleXThreadMonitor::getTerminated(){
return m_monitorTerminated;
}
void mitk::FiberBundleXThreadMonitor::setTerminated(int val)
{
m_terminatedMutex.lock();
m_monitorTerminated = val;
m_terminatedMutex.unlock();
}
mitk::Point2D mitk::FiberBundleXThreadMonitor::getTerminatedPosition(){
return m_monitorTerminatedPosition;
}
void mitk::FiberBundleXThreadMonitor::setTerminatedPosition(mitk::Point2D pnt){
m_monitorTerminatedPosition[0] = pnt[0];
m_monitorTerminatedPosition[1] = pnt[1];
}
int mitk::FiberBundleXThreadMonitor::getTerminatedOpacity(){
return m_monitorTerminatedOpacity;
}
void mitk::FiberBundleXThreadMonitor::setTerminatedOpacity(int opacity){
m_monitorTerminatedOpacity = opacity;
}
/* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
void mitk::FiberBundleXThreadMonitor::UpdateOutputInformation()
{
}
void mitk::FiberBundleXThreadMonitor::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::FiberBundleXThreadMonitor::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::FiberBundleXThreadMonitor::VerifyRequestedRegion()
{
return true;
}
-void mitk::FiberBundleXThreadMonitor::SetRequestedRegion( itk::DataObject *data )
+void mitk::FiberBundleXThreadMonitor::SetRequestedRegion(const itk::DataObject *data )
{
}
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
index 208d9d8acd..3d8545f8e1 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
@@ -1,153 +1,153 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_FiberBundleXThreadMonitor_H
#define _MITK_FiberBundleXThreadMonitor_H
//includes for MITK datastructure
#include "mitkBaseData.h"
#include "FiberTrackingExports.h"
#include <QString>
#include <QMutex>
namespace mitk {
/**
* \brief Base Class for Fiber Bundles; */
class FiberTracking_EXPORT FiberBundleXThreadMonitor : public BaseData
{
public:
// ======virtual methods must have======
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
- virtual void SetRequestedRegion( itk::DataObject *data );
+ virtual void SetRequestedRegion(const itk::DataObject *data );
//=======================================
mitkClassMacro( FiberBundleXThreadMonitor, BaseData );
itkNewMacro( Self );
void setTextL1(QString);
QString getTextL1();
QString getBracketOpen();
mitk::Point2D getBracketOpenPosition();
void setBracketOpenPosition(mitk::Point2D);
int getBracketOpenOpacity(); // range 0 - 10, multiplicationfactor 0.1 (in mapper)
QString getBracketClose();
mitk::Point2D getBracketClosePosition();
void setBracketClosePosition(mitk::Point2D);
int getBracketCloseOpacity(); // range 0 - 10, multiplicationfactor 0.1 (in mapper)
QString getHeading();
mitk::Point2D getHeadingPosition();
void setHeadingPosition(mitk::Point2D);
int getHeadingOpacity(); // range 0 - 10, multiplicationfactor 0.1 (in mapper)
void setHeadingOpacity(int);
QString getMask();
mitk::Point2D getMaskPosition();
void setMaskPosition(mitk::Point2D);
int getMaskOpacity(); // multiplicationfactor 0.1 (in mapper)
void setMaskOpacity(int);
QString getStatus();
void setStatus(QString);
mitk::Point2D getStatusPosition();
void setStatusPosition(mitk::Point2D);
int getStatusOpacity(); // multiplicationfactor 0.1 (in mapper)
void setStatusOpacity(int);
int getStarted();
void setStarted(int);
mitk::Point2D getStartedPosition();
void setStartedPosition(mitk::Point2D);
int getStartedOpacity(); // multiplicationfactor 0.1 (in mapper)
void setStartedOpacity(int);
int getFinished();
void setFinished(int);
mitk::Point2D getFinishedPosition();
void setFinishedPosition(mitk::Point2D);
int getFinishedOpacity(); // multiplicationfactor 0.1 (in mapper)
void setFinishedOpacity(int);
int getTerminated();
void setTerminated(int);
mitk::Point2D getTerminatedPosition();
void setTerminatedPosition(mitk::Point2D);
int getTerminatedOpacity(); // multiplicationfactor 0.1 (in mapper)
void setTerminatedOpacity(int);
protected:
FiberBundleXThreadMonitor();
virtual ~FiberBundleXThreadMonitor();
private:
QString m_monitorBracketOpen;
mitk::Point2D m_monitorBracketOpenPosition;
QString m_monitorBracketClose;
mitk::Point2D m_monitorBracketClosePosition;
QString m_monitorHeading;
mitk::Point2D m_monitorHeadingPosition;
int m_monitorHeadingOpacity;
QString m_monitorMask;
mitk::Point2D m_monitorMaskPosition;
int m_monitorMaskOpacity;
QString m_monitorStatus;
mitk::Point2D m_monitorStatusPosition;
int m_monitorStatusOpacity;
int m_monitorStarted;
mitk::Point2D m_monitorStartedPosition;
int m_monitorStartedOpacity;
int m_monitorFinished;
mitk::Point2D m_monitorFinishedPosition;
int m_monitorFinishedOpacity;
int m_monitorTerminated;
mitk::Point2D m_monitorTerminatedPosition;
int m_monitorTerminatedOpacity;
QMutex m_startedMutex;
QMutex m_finishedMutex;
QMutex m_terminatedMutex;
QMutex m_statusMutex;
};
} // namespace mitk
#endif /* _MITK_FiberBundleX_H */
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/MiniApps/CMakeLists.txt
new file mode 100755
index 0000000000..8e7361bdee
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/CMakeLists.txt
@@ -0,0 +1,49 @@
+OPTION(BUILD_FiberTrackingMiniApps "Build commandline tools for fiber tracking" OFF)
+
+IF(BUILD_FiberTrackingMiniApps)
+
+ # include necessary modules here MitkExt QmitkExt
+ MITK_CHECK_MODULE(_RESULT DiffusionCore FiberTracking )
+ IF(_RESULT)
+ MESSAGE("Warning: FiberTrackingMiniApps is missing ${_RESULT}")
+ ELSE(_RESULT)
+ MITK_USE_MODULE( DiffusionCore FiberTracking )
+
+ # needed include directories
+ INCLUDE_DIRECTORIES(
+ ${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${ALL_INCLUDE_DIRECTORIES})
+
+ PROJECT( mitkFiberTrackingMiniApps )
+
+ # fill in the standalone executables here
+ SET(FIBERTRACKINGMINIAPPS
+ mitkFiberTrackingMiniApps
+ )
+
+ # set additional files here
+ SET(FIBERTRACKING_ADDITIONAL_FILES
+ MiniAppManager.cpp
+ GibbsTracking.cpp
+ StreamlineTracking.cpp
+ TractometerAngularErrorTool.cpp
+ )
+
+ # create an executable foreach tool (only one at the moment)
+ FOREACH(tool ${FIBERTRACKINGMINIAPPS})
+ ADD_EXECUTABLE(
+ ${tool}
+ ${tool}.cpp
+ ${FIBERTRACKING_ADDITIONAL_FILES}
+ )
+
+ TARGET_LINK_LIBRARIES(
+ ${tool}
+ ${ALL_LIBRARIES} )
+ ENDFOREACH(tool)
+ ENDIF()
+
+ MITK_INSTALL_TARGETS(EXECUTABLES mitkFiberTrackingMiniApps )
+
+ENDIF(BUILD_FiberTrackingMiniApps)
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/GibbsTracking.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/GibbsTracking.cpp
new file mode 100755
index 0000000000..f15d2bb328
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/GibbsTracking.cpp
@@ -0,0 +1,217 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "MiniAppManager.h"
+
+#include <mitkImageCast.h>
+#include <mitkQBallImage.h>
+#include <mitkTensorImage.h>
+#include <mitkBaseDataIOFactory.h>
+#include <mitkDiffusionCoreObjectFactory.h>
+#include <mitkFiberTrackingObjectFactory.h>
+#include <mitkFiberBundleX.h>
+#include <itkGibbsTrackingFilter.h>
+#include <itkDiffusionTensor3D.h>
+#include <itkShCoefficientImageImporter.h>
+#include <mitkImageToItk.h>
+#include <mitkIOUtil.h>
+#include "ctkCommandLineParser.h"
+
+template<int shOrder>
+typename itk::ShCoefficientImageImporter< float, shOrder >::QballImageType::Pointer TemplatedConvertShCoeffs(mitk::Image* mitkImg, int toolkit)
+{
+ typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
+ typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
+ CasterType::Pointer caster = CasterType::New();
+ caster->SetInput(mitkImg);
+ caster->Update();
+
+ typename FilterType::Pointer filter = FilterType::New();
+
+ switch (toolkit)
+ {
+ case 0:
+ filter->SetToolkit(FilterType::FSL);
+ break;
+ case 1:
+ filter->SetToolkit(FilterType::MRTRIX);
+ break;
+ default:
+ filter->SetToolkit(FilterType::FSL);
+ }
+
+ filter->SetInputImage(caster->GetOutput());
+ filter->GenerateData();
+ return filter->GetQballImage();
+}
+
+int GibbsTracking(int argc, char* argv[])
+{
+ ctkCommandLineParser parser;
+ parser.setArgumentPrefix("--", "-");
+ parser.addArgument("input", "i", ctkCommandLineParser::String, "input image (tensor, Q-ball or FSL/MRTrix SH-coefficient image)", mitk::Any(), false);
+ parser.addArgument("parameters", "p", ctkCommandLineParser::String, "parameter file (.gtp)", mitk::Any(), false);
+ parser.addArgument("mask", "m", ctkCommandLineParser::String, "binary mask image");
+ parser.addArgument("shConvention", "s", ctkCommandLineParser::String, "sh coefficient convention (FSL, MRtrix) (default = FSL)");
+ parser.addArgument("outFile", "o", ctkCommandLineParser::String, "output fiber bundle (.fib)", mitk::Any(), false);
+
+ map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
+ if (parsedArgs.size()==0)
+ return EXIT_FAILURE;
+
+ string inFileName = mitk::any_cast<string>(parsedArgs["input"]);
+ string paramFileName = mitk::any_cast<string>(parsedArgs["parameters"]);
+ string outFileName = mitk::any_cast<string>(parsedArgs["outFile"]);
+
+ try
+ {
+ RegisterDiffusionCoreObjectFactory();
+ RegisterFiberTrackingObjectFactory();
+
+ // instantiate gibbs tracker
+ typedef itk::Vector<float, QBALL_ODFSIZE> OdfVectorType;
+ typedef itk::Image<OdfVectorType,3> ItkQballImageType;
+ typedef itk::GibbsTrackingFilter<ItkQballImageType> GibbsTrackingFilterType;
+ GibbsTrackingFilterType::Pointer gibbsTracker = GibbsTrackingFilterType::New();
+
+ // load input image
+ const std::string s1="", s2="";
+ std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
+
+ // try to cast to qball image
+ QString inImageName(inFileName.c_str());
+ if( inImageName.endsWith(".qbi") )
+ {
+ MITK_INFO << "Loading qball image ...";
+ mitk::QBallImage::Pointer mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.at(0).GetPointer());
+ ItkQballImageType::Pointer itk_qbi = ItkQballImageType::New();
+ mitk::CastToItkImage<ItkQballImageType>(mitkQballImage, itk_qbi);
+ gibbsTracker->SetQBallImage(itk_qbi.GetPointer());
+ }
+ else if( inImageName.endsWith(".dti") )
+ {
+ MITK_INFO << "Loading tensor image ...";
+ typedef itk::Image< itk::DiffusionTensor3D<float>, 3 > ItkTensorImage;
+ mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(infile.at(0).GetPointer());
+ ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
+ mitk::CastToItkImage<ItkTensorImage>(mitkTensorImage, itk_dti);
+ gibbsTracker->SetTensorImage(itk_dti);
+ }
+ else if ( inImageName.endsWith(".nii") )
+ {
+ MITK_INFO << "Loading sh-coefficient image ...";
+ mitk::Image::Pointer mitkImage = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
+
+ int nrCoeffs = mitkImage->GetLargestPossibleRegion().GetSize()[3];
+ int c=3, d=2-2*nrCoeffs;
+ double D = c*c-4*d;
+ int shOrder;
+ if (D>0)
+ {
+ shOrder = (-c+sqrt(D))/2.0;
+ if (shOrder<0)
+ shOrder = (-c-sqrt(D))/2.0;
+ }
+ else if (D==0)
+ shOrder = -c/2.0;
+
+ MITK_INFO << "using SH-order " << shOrder;
+
+ int toolkitConvention = 0;
+
+ if (parsedArgs.count("shConvention"))
+ {
+ QString convention(mitk::any_cast<string>(parsedArgs["shConvention"]).c_str());
+ if ( convention.compare("MRtrix", Qt::CaseInsensitive)==0 )
+ {
+ toolkitConvention = 1;
+ MITK_INFO << "Using MRtrix style sh-coefficient convention";
+ }
+ else
+ MITK_INFO << "Using FSL style sh-coefficient convention";
+ }
+ else
+ MITK_INFO << "Using FSL style sh-coefficient convention";
+
+ switch (shOrder)
+ {
+ case 4:
+ gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<4>(mitkImage, toolkitConvention));
+ break;
+ case 6:
+ gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<6>(mitkImage, toolkitConvention));
+ break;
+ case 8:
+ gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<8>(mitkImage, toolkitConvention));
+ break;
+ case 10:
+ gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<10>(mitkImage, toolkitConvention));
+ break;
+ case 12:
+ gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<12>(mitkImage, toolkitConvention));
+ break;
+ default:
+ MITK_INFO << "SH-order " << shOrder << " not supported";
+ }
+ }
+ else
+ return EXIT_FAILURE;
+
+ // global tracking
+ if (parsedArgs.count("mask"))
+ {
+ typedef itk::Image<float,3> MaskImgType;
+ mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(mitk::any_cast<string>(parsedArgs["mask"]));
+ MaskImgType::Pointer itk_mask = MaskImgType::New();
+ mitk::CastToItkImage<MaskImgType>(mitkMaskImage, itk_mask);
+ gibbsTracker->SetMaskImage(itk_mask);
+ }
+
+ gibbsTracker->SetDuplicateImage(false);
+ gibbsTracker->SetLoadParameterFile( paramFileName );
+// gibbsTracker->SetLutPath( "" );
+ gibbsTracker->Update();
+
+ mitk::FiberBundleX::Pointer mitkFiberBundle = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
+
+ mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
+ for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
+ {
+ if ( (*it)->CanWriteBaseDataType(mitkFiberBundle.GetPointer()) ) {
+ (*it)->SetFileName( outFileName.c_str() );
+ (*it)->DoWrite( mitkFiberBundle.GetPointer() );
+ }
+ }
+ }
+ catch (itk::ExceptionObject e)
+ {
+ MITK_INFO << e;
+ return EXIT_FAILURE;
+ }
+ catch (std::exception e)
+ {
+ MITK_INFO << e.what();
+ return EXIT_FAILURE;
+ }
+ catch (...)
+ {
+ MITK_INFO << "ERROR!?!";
+ return EXIT_FAILURE;
+ }
+ MITK_INFO << "DONE";
+ return EXIT_SUCCESS;
+}
+RegisterFiberTrackingMiniApp(GibbsTracking);
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/MiniAppManager.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/MiniAppManager.cpp
new file mode 100755
index 0000000000..ff9b82b1ad
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/MiniAppManager.cpp
@@ -0,0 +1,91 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "MiniAppManager.h"
+
+MiniAppManager* MiniAppManager::GetInstance()
+{
+ static MiniAppManager instance;
+ return &instance;
+}
+
+// Attention: Name of the miniApp must be the last argument!!!
+// it will be cut off from the rest of the arguments and then
+// the app will be run
+int MiniAppManager::RunMiniApp(int argc, char* argv[])
+{
+ try
+ {
+ std::string nameOfMiniApp;
+ std::map< std::string, MiniAppFunction >::iterator it = m_Functions.begin();
+
+ if( argc < 2)
+ {
+ std::cout << "Please choose the mini app to execute: " << std::endl;
+
+ for(int i=0; it != m_Functions.end(); ++i,++it)
+ {
+ std::cout << "(" << i << ")" << " " << it->first << std::endl;
+ }
+ std::cout << "Please select: ";
+ int choose;
+ std::cin >> choose;
+
+ it = m_Functions.begin();
+ std::advance(it, choose);
+ if( it != m_Functions.end() )
+ nameOfMiniApp = it->first;
+ }
+ else
+ {
+ nameOfMiniApp = argv[1];
+ //--argc;
+ }
+
+ it = m_Functions.find(nameOfMiniApp);
+ if(it == m_Functions.end())
+ {
+ std::ostringstream s; s << "MiniApp (" << nameOfMiniApp << ") not found!";
+ throw std::invalid_argument(s.str().c_str());
+ }
+
+ MITK_INFO << "Start " << nameOfMiniApp << " ..";
+ MiniAppFunction func = it->second;
+ return func( argc, argv );
+ }
+
+ catch(std::exception& e)
+ {
+ MITK_ERROR << e.what();
+ }
+
+ catch(...)
+ {
+ MITK_ERROR << "Unknown error occurred";
+ }
+
+ return EXIT_FAILURE;
+}
+
+/////////////////////
+// MiniAppFunction //
+/////////////////////
+MiniAppManager::MiniAppFunction
+MiniAppManager::AddFunction(const std::string& name, MiniAppFunction func)
+{
+ m_Functions.insert( std::pair<std::string, MiniAppFunction>(name, func) );
+ return func;
+}
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/MiniAppManager.h b/Modules/DiffusionImaging/FiberTracking/MiniApps/MiniAppManager.h
new file mode 100755
index 0000000000..989baad3cc
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/MiniAppManager.h
@@ -0,0 +1,38 @@
+#ifndef MiniAppManager_h
+#define MiniAppManager_h
+
+#include <mitkCommon.h>
+
+struct MiniAppManager
+{
+
+public:
+
+ typedef int (*MiniAppFunction)(int argc, char* argv[]);
+
+public:
+
+ static MiniAppManager* GetInstance();
+
+ // Attention: Name of the miniApp must be the last argument!!!
+ // it will be cut off from the rest of the arguments and then
+ // the app will be run
+ int RunMiniApp(int argc, char* argv[]);
+
+ //
+ // Add miniApp
+ //
+ MiniAppFunction AddFunction(const std::string& name, MiniAppFunction func);
+
+protected:
+
+ std::map< std::string, MiniAppFunction > m_Functions;
+};
+
+//
+// Register miniApps
+//
+#define RegisterFiberTrackingMiniApp(functionName) \
+ static MiniAppManager::MiniAppFunction MiniApp##functionName = \
+ MiniAppManager::GetInstance()->AddFunction(#functionName, &functionName)
+#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/StreamlineTracking.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/StreamlineTracking.cpp
new file mode 100755
index 0000000000..f95d8dfe8d
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/StreamlineTracking.cpp
@@ -0,0 +1,174 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "MiniAppManager.h"
+#include <mitkImageCast.h>
+#include <mitkTensorImage.h>
+#include <mitkIOUtil.h>
+#include <mitkBaseDataIOFactory.h>
+#include <mitkDiffusionCoreObjectFactory.h>
+#include <mitkFiberTrackingObjectFactory.h>
+#include <mitkFiberBundleX.h>
+#include <itkStreamlineTrackingFilter.h>
+#include <itkDiffusionTensor3D.h>
+#include "ctkCommandLineParser.h"
+
+int StreamlineTracking(int argc, char* argv[])
+{
+ ctkCommandLineParser parser;
+ parser.setArgumentPrefix("--", "-");
+ parser.addArgument("input", "i", ctkCommandLineParser::String, "input tensor image (.dti)", mitk::Any(), false);
+ parser.addArgument("seed", "s", ctkCommandLineParser::String, "binary seed image");
+ parser.addArgument("mask", "m", ctkCommandLineParser::String, "binary mask image");
+ parser.addArgument("minFA", "t", ctkCommandLineParser::Float, "minimum fractional anisotropy threshold", 0.15, true);
+ parser.addArgument("minCurv", "c", ctkCommandLineParser::Float, "minimum curvature radius in mm (default = 0.5*minimum-spacing)");
+ parser.addArgument("stepSize", "s", ctkCommandLineParser::Float, "stepsize in mm (default = 0.1*minimum-spacing)");
+ parser.addArgument("tendf", "f", ctkCommandLineParser::Float, "Weighting factor between first eigenvector (f=1 equals FACT tracking) and input vector dependent direction (f=0).", 1.0, true);
+ parser.addArgument("tendg", "g", ctkCommandLineParser::Float, "Weighting factor between input vector (g=0) and tensor deflection (g=1 equals TEND tracking)", 0.0, true);
+ parser.addArgument("numSeeds", "n", ctkCommandLineParser::Int, "Number of seeds per voxel.", 1, true);
+ parser.addArgument("minLength", "l", ctkCommandLineParser::Float, "minimum fiber length in mm", 20, true);
+
+ parser.addArgument("interpolate", "a", ctkCommandLineParser::Bool, "Use linear interpolation", false, true);
+ parser.addArgument("outFile", "o", ctkCommandLineParser::String, "output fiber bundle (.fib)", mitk::Any(), false);
+
+ map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
+ if (parsedArgs.size()==0)
+ return EXIT_FAILURE;
+
+ string dtiFileName = mitk::any_cast<string>(parsedArgs["input"]);
+ string outFileName = mitk::any_cast<string>(parsedArgs["outFile"]);
+
+ float minFA = 0.15;
+ float minCurv = -1;
+ float stepSize = -1;
+ float tendf = 1;
+ float tendg = 0;
+ float minLength = 20;
+ int numSeeds = 1;
+ bool interpolate = false;
+
+ if (parsedArgs.count("minCurv"))
+ minCurv = mitk::any_cast<float>(parsedArgs["minCurv"]);
+ if (parsedArgs.count("minFA"))
+ minFA = mitk::any_cast<float>(parsedArgs["minFA"]);
+ if (parsedArgs.count("stepSize"))
+ stepSize = mitk::any_cast<float>(parsedArgs["stepSize"]);
+ if (parsedArgs.count("tendf"))
+ tendf = mitk::any_cast<float>(parsedArgs["tendf"]);
+ if (parsedArgs.count("tendg"))
+ tendg = mitk::any_cast<float>(parsedArgs["tendg"]);
+ if (parsedArgs.count("minLength"))
+ minLength = mitk::any_cast<float>(parsedArgs["minLength"]);
+ if (parsedArgs.count("numSeeds"))
+ numSeeds = mitk::any_cast<int>(parsedArgs["numSeeds"]);
+
+
+ if (parsedArgs.count("interpolate"))
+ interpolate = mitk::any_cast<bool>(parsedArgs["interpolate"]);
+
+
+
+ try
+ {
+ RegisterDiffusionCoreObjectFactory();
+ RegisterFiberTrackingObjectFactory();
+
+ // load input image
+ const std::string s1="", s2="";
+ std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( dtiFileName, s1, s2, false );
+
+ MITK_INFO << "Loading tensor image ...";
+ typedef itk::Image< itk::DiffusionTensor3D<float>, 3 > ItkTensorImage;
+ mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(infile.at(0).GetPointer());
+ ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
+ mitk::CastToItkImage<ItkTensorImage>(mitkTensorImage, itk_dti);
+
+ MITK_INFO << "Loading seed image ...";
+ typedef itk::Image< unsigned char, 3 > ItkUCharImageType;
+ mitk::Image::Pointer mitkSeedImage = NULL;
+ if (parsedArgs.count("seed"))
+ mitkSeedImage = mitk::IOUtil::LoadImage(mitk::any_cast<string>(parsedArgs["seed"]));
+
+ MITK_INFO << "Loading mask image ...";
+ mitk::Image::Pointer mitkMaskImage = NULL;
+ if (parsedArgs.count("mask"))
+ mitkMaskImage = mitk::IOUtil::LoadImage(mitk::any_cast<string>(parsedArgs["mask"]));
+
+ // instantiate tracker
+ typedef itk::StreamlineTrackingFilter< float > FilterType;
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetInput(itk_dti);
+ filter->SetSeedsPerVoxel(numSeeds);
+ filter->SetFaThreshold(minFA);
+ filter->SetMinCurvatureRadius(minCurv);
+ filter->SetStepSize(stepSize);
+ filter->SetF(tendf);
+ filter->SetG(tendg);
+ filter->SetInterpolate(interpolate);
+ filter->SetMinTractLength(minLength);
+
+ if (mitkSeedImage.IsNotNull())
+ {
+ ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
+ mitk::CastToItkImage<ItkUCharImageType>(mitkSeedImage, mask);
+ filter->SetSeedImage(mask);
+ }
+
+ if (mitkMaskImage.IsNotNull())
+ {
+ ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
+ mitk::CastToItkImage<ItkUCharImageType>(mitkMaskImage, mask);
+ filter->SetMaskImage(mask);
+ }
+
+ filter->Update();
+
+ vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
+ if ( fiberBundle->GetNumberOfLines()==0 )
+ {
+ MITK_INFO << "No fibers reconstructed. Check parametrization.";
+ return EXIT_FAILURE;
+ }
+ mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberBundle);
+
+ mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
+ for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
+ {
+ if ( (*it)->CanWriteBaseDataType(fib.GetPointer()) ) {
+ (*it)->SetFileName( outFileName.c_str() );
+ (*it)->DoWrite( fib.GetPointer() );
+ }
+ }
+ }
+ catch (itk::ExceptionObject e)
+ {
+ MITK_INFO << e;
+ return EXIT_FAILURE;
+ }
+ catch (std::exception e)
+ {
+ MITK_INFO << e.what();
+ return EXIT_FAILURE;
+ }
+ catch (...)
+ {
+ MITK_INFO << "ERROR!?!";
+ return EXIT_FAILURE;
+ }
+ MITK_INFO << "DONE";
+ return EXIT_SUCCESS;
+}
+RegisterFiberTrackingMiniApp(StreamlineTracking);
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp
new file mode 100755
index 0000000000..00996996dd
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp
@@ -0,0 +1,247 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "MiniAppManager.h"
+#include <mitkBaseDataIOFactory.h>
+#include <mitkBaseData.h>
+#include <mitkImageCast.h>
+#include <mitkImageToItk.h>
+#include <mitkDiffusionCoreObjectFactory.h>
+#include <mitkFiberTrackingObjectFactory.h>
+#include <itkEvaluateDirectionImagesFilter.h>
+#include <metaCommand.h>
+#include "ctkCommandLineParser.h"
+#include "ctkCommandLineParser.cpp"
+#include <mitkAny.h>
+#include <itkImageFileWriter.h>
+#include <QString>
+#include <QFile>
+#include <QTextStream>
+#include <itkTractsToVectorImageFilter.h>
+#include <mitkIOUtil.h>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+int TractometerAngularErrorTool(int argc, char* argv[])
+{
+ ctkCommandLineParser parser;
+ parser.setArgumentPrefix("--", "-");
+ parser.addArgument("input", "i", ctkCommandLineParser::String, "input tractogram (.fib, vtk ascii file format)", mitk::Any(), false);
+ parser.addArgument("reference", "r", ctkCommandLineParser::StringList, "reference direction images", mitk::Any(), false);
+ parser.addArgument("out", "o", ctkCommandLineParser::String, "output root", mitk::Any(), false);
+ parser.addArgument("mask", "m", ctkCommandLineParser::String, "mask image");
+ parser.addArgument("athresh", "a", ctkCommandLineParser::Float, "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
+ parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "output optional and intermediate calculation results");
+
+ map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
+ if (parsedArgs.size()==0)
+ return EXIT_FAILURE;
+
+ ctkCommandLineParser::StringContainerType referenceImages = mitk::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
+
+ string fibFile = mitk::any_cast<string>(parsedArgs["input"]);
+
+ string maskImage("");
+ if (parsedArgs.count("mask"))
+ maskImage = mitk::any_cast<string>(parsedArgs["mask"]);
+
+ float angularThreshold = 25;
+ if (parsedArgs.count("athresh"))
+ angularThreshold = mitk::any_cast<float>(parsedArgs["athresh"]);
+
+ string outRoot = mitk::any_cast<string>(parsedArgs["out"]);
+
+ bool verbose = false;
+ if (parsedArgs.count("verbose"))
+ verbose = mitk::any_cast<bool>(parsedArgs["verbose"]);
+
+ try
+ {
+ RegisterDiffusionCoreObjectFactory();
+ RegisterFiberTrackingObjectFactory();
+
+ typedef itk::Image<unsigned char, 3> ItkUcharImgType;
+ typedef itk::Image< itk::Vector< float, 3>, 3 > ItkDirectionImage3DType;
+ typedef itk::VectorContainer< int, ItkDirectionImage3DType::Pointer > ItkDirectionImageContainerType;
+ typedef itk::EvaluateDirectionImagesFilter< float > EvaluationFilterType;
+
+ // load fiber bundle
+ mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+
+ // load reference directions
+ ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
+ for (int i=0; i<referenceImages.size(); i++)
+ {
+ try
+ {
+ mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
+ typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
+ CasterType::Pointer caster = CasterType::New();
+ caster->SetInput(img);
+ caster->Update();
+ ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
+ referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
+ }
+ catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
+ }
+
+ // load/create mask image
+ ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
+ if (maskImage.compare("")==0)
+ {
+ ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
+ itkMaskImage->SetSpacing( dirImg->GetSpacing() );
+ itkMaskImage->SetOrigin( dirImg->GetOrigin() );
+ itkMaskImage->SetDirection( dirImg->GetDirection() );
+ itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
+ itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
+ itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
+ itkMaskImage->Allocate();
+ itkMaskImage->FillBuffer(1);
+ }
+ else
+ {
+ mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
+ CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
+ }
+
+
+ // extract directions from fiber bundle
+ itk::TractsToVectorImageFilter::Pointer fOdfFilter = itk::TractsToVectorImageFilter::New();
+ fOdfFilter->SetFiberBundle(inputTractogram);
+ fOdfFilter->SetMaskImage(itkMaskImage);
+ fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
+ fOdfFilter->SetNormalizeVectors(true);
+ fOdfFilter->SetUseWorkingCopy(false);
+ fOdfFilter->Update();
+ ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
+
+ if (verbose)
+ {
+ // write vector field
+ mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
+ mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
+ for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
+ {
+ if ( (*it)->CanWriteBaseDataType(directions.GetPointer()) ) {
+ QString outfilename(outRoot.c_str());
+ outfilename += "_VECTOR_FIELD.fib";
+ (*it)->SetFileName( outfilename.toStdString().c_str() );
+ (*it)->DoWrite( directions.GetPointer() );
+ }
+ }
+
+ // write direction images
+ for (int i=0; i<directionImageContainer->Size(); i++)
+ {
+ itk::TractsToVectorImageFilter::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
+ typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter::ItkDirectionImageType > WriterType;
+ WriterType::Pointer writer = WriterType::New();
+ QString outfilename(outRoot.c_str());
+ outfilename += "_DIRECTION_";
+ outfilename += QString::number(i);
+ outfilename += ".nrrd";
+ MITK_INFO << "writing " << outfilename.toStdString();
+ writer->SetFileName(outfilename.toStdString().c_str());
+ writer->SetInput(itkImg);
+ writer->Update();
+ }
+
+ // write num direction image
+ {
+ ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
+ typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
+ WriterType::Pointer writer = WriterType::New();
+ QString outfilename(outRoot.c_str());
+ outfilename += "_NUM_DIRECTIONS.nrrd";
+ MITK_INFO << "writing " << outfilename.toStdString();
+ writer->SetFileName(outfilename.toStdString().c_str());
+ writer->SetInput(numDirImage);
+ writer->Update();
+ }
+ }
+
+ // evaluate directions
+ EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
+ evaluationFilter->SetImageSet(directionImageContainer);
+ evaluationFilter->SetReferenceImageSet(referenceImageContainer);
+ evaluationFilter->SetMaskImage(itkMaskImage);
+ evaluationFilter->Update();
+
+ if (verbose)
+ {
+ EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
+ typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
+ WriterType::Pointer writer = WriterType::New();
+ QString outfilename(outRoot.c_str());
+ outfilename += "_ERROR_IMAGE.nrrd";
+ writer->SetFileName(outfilename.toStdString().c_str());
+ writer->SetInput(angularErrorImage);
+ writer->Update();
+ }
+
+ QString logFile(outRoot.c_str()); logFile += "_ANGULAR_ERROR.csv";
+ QFile file(logFile);
+ file.open(QIODevice::WriteOnly | QIODevice::Text);
+ QTextStream out(&file);
+ QString sens = QString("Mean:");
+ sens += ",";
+ sens += QString::number(evaluationFilter->GetMeanAngularError());
+ sens += ";";
+
+ sens += QString("Median:");
+ sens += ",";
+ sens += QString::number(evaluationFilter->GetMedianAngularError());
+ sens += ";";
+
+ sens += QString("Maximum:");
+ sens += ",";
+ sens += QString::number(evaluationFilter->GetMaxAngularError());
+ sens += ";";
+
+ sens += QString("Minimum:");
+ sens += ",";
+ sens += QString::number(evaluationFilter->GetMinAngularError());
+ sens += ";";
+
+ sens += QString("STDEV:");
+ sens += ",";
+ sens += QString::number(std::sqrt(evaluationFilter->GetVarAngularError()));
+ sens += ";";
+
+ out << sens;
+
+ MITK_INFO << "DONE";
+ }
+ catch (itk::ExceptionObject e)
+ {
+ MITK_INFO << e;
+ return EXIT_FAILURE;
+ }
+ catch (std::exception e)
+ {
+ MITK_INFO << e.what();
+ return EXIT_FAILURE;
+ }
+ catch (...)
+ {
+ MITK_INFO << "ERROR!?!";
+ return EXIT_FAILURE;
+ }
+ return EXIT_SUCCESS;
+}
+RegisterFiberTrackingMiniApp(TractometerAngularErrorTool);
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/ctkCommandLineParser.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/ctkCommandLineParser.cpp
new file mode 100755
index 0000000000..72da974c5b
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/ctkCommandLineParser.cpp
@@ -0,0 +1,727 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+/*=========================================================================
+
+ Library: CTK
+
+ Copyright (c) Kitware Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0.txt
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+=========================================================================*/
+
+// STL includes
+#include <stdexcept>
+
+
+// CTK includes
+#include "ctkCommandLineParser.h"
+
+using namespace std;
+
+namespace
+{
+// --------------------------------------------------------------------------
+class CommandLineParserArgumentDescription
+{
+public:
+
+
+ CommandLineParserArgumentDescription(
+ const string& longArg, const string& longArgPrefix,
+ const string& shortArg, const string& shortArgPrefix,
+ ctkCommandLineParser::Type type, const string& argHelp,
+ const mitk::Any& defaultValue, bool ignoreRest,
+ bool deprecated, bool optional)
+ : LongArg(longArg), LongArgPrefix(longArgPrefix),
+ ShortArg(shortArg), ShortArgPrefix(shortArgPrefix),
+ ArgHelp(argHelp), IgnoreRest(ignoreRest), NumberOfParametersToProcess(0),
+ Deprecated(deprecated), DefaultValue(defaultValue), Value(type), ValueType(type), Optional(optional)
+ {
+ Value = defaultValue;
+
+ switch (type)
+ {
+ case ctkCommandLineParser::String:
+ {
+ NumberOfParametersToProcess = 1;
+ }
+ break;
+ case ctkCommandLineParser::Bool:
+ {
+ NumberOfParametersToProcess = 0;
+ }
+ break;
+ case ctkCommandLineParser::StringList:
+ {
+ NumberOfParametersToProcess = -1;
+ }
+ break;
+ case ctkCommandLineParser::Int:
+ {
+ NumberOfParametersToProcess = 1;
+ }
+ break;
+ case ctkCommandLineParser::Float:
+ {
+ NumberOfParametersToProcess = 1;
+ }
+ break;
+ default:
+ MITK_INFO << "Type not supported: " << static_cast<int>(type);
+ }
+
+ }
+
+ ~CommandLineParserArgumentDescription(){}
+
+ bool addParameter(const string& value);
+
+ string helpText();
+
+ string LongArg;
+ string LongArgPrefix;
+ string ShortArg;
+ string ShortArgPrefix;
+ string ArgHelp;
+ bool IgnoreRest;
+ int NumberOfParametersToProcess;
+ bool Deprecated;
+ bool Optional;
+
+ mitk::Any DefaultValue;
+ mitk::Any Value;
+ ctkCommandLineParser::Type ValueType;
+};
+
+// --------------------------------------------------------------------------
+bool CommandLineParserArgumentDescription::addParameter(const string &value)
+{
+ switch (ValueType)
+ {
+ case ctkCommandLineParser::String:
+ {
+ Value = value;
+ }
+ break;
+ case ctkCommandLineParser::Bool:
+ {
+ if (value.compare("true")==0)
+ Value = true;
+ else
+ Value = false;
+ }
+ break;
+ case ctkCommandLineParser::StringList:
+ {
+ try
+ {
+ ctkCommandLineParser::StringContainerType list = mitk::any_cast<ctkCommandLineParser::StringContainerType>(Value);
+ list.push_back(value);
+ Value = list;
+ }
+ catch(...)
+ {
+ ctkCommandLineParser::StringContainerType list;
+ list.push_back(value);
+ Value = list;
+ }
+ }
+ break;
+ case ctkCommandLineParser::Int:
+ {
+ stringstream ss(value);
+ int i;
+ ss >> i;
+ Value = i;
+ }
+ break;
+ case ctkCommandLineParser::Float:
+ {
+ stringstream ss(value);
+ float f;
+ ss >> f;
+ Value = f;
+ }
+ break;
+ default:
+ return false;
+ }
+
+ return true;
+}
+
+// --------------------------------------------------------------------------
+string CommandLineParserArgumentDescription::helpText()
+{
+ string text;
+
+ string shortAndLongArg;
+ if (!this->ShortArg.empty())
+ {
+ shortAndLongArg = " ";
+ shortAndLongArg += this->ShortArgPrefix;
+ shortAndLongArg += this->ShortArg;
+ }
+
+ if (!this->LongArg.empty())
+ {
+ if (this->ShortArg.empty())
+ shortAndLongArg.append(" ");
+ else
+ shortAndLongArg.append(", ");
+
+ shortAndLongArg += this->LongArgPrefix;
+ shortAndLongArg += this->LongArg;
+ }
+
+ text = text + shortAndLongArg + ", " + this->ArgHelp;
+
+ if (this->Optional)
+ text += " (optional)";
+
+ if (!this->DefaultValue.Empty())
+ {
+ text = text + ", (default: " + this->DefaultValue.ToString() + ")";
+ }
+ text += "\n";
+ return text;
+}
+
+}
+
+// --------------------------------------------------------------------------
+// ctkCommandLineParser::ctkInternal class
+
+// --------------------------------------------------------------------------
+class ctkCommandLineParser::ctkInternal
+{
+public:
+ ctkInternal()
+ : Debug(false), FieldWidth(0), StrictMode(false)
+ {}
+
+ ~ctkInternal() { }
+
+ CommandLineParserArgumentDescription* argumentDescription(const string& argument);
+
+ vector<CommandLineParserArgumentDescription*> ArgumentDescriptionList;
+ map<string, CommandLineParserArgumentDescription*> ArgNameToArgumentDescriptionMap;
+ map<string, vector<CommandLineParserArgumentDescription*> > GroupToArgumentDescriptionListMap;
+
+ StringContainerType UnparsedArguments;
+ StringContainerType ProcessedArguments;
+ string ErrorString;
+ bool Debug;
+ int FieldWidth;
+ string LongPrefix;
+ string ShortPrefix;
+ string CurrentGroup;
+ string DisableQSettingsLongArg;
+ string DisableQSettingsShortArg;
+ bool StrictMode;
+};
+
+// --------------------------------------------------------------------------
+// ctkCommandLineParser::ctkInternal methods
+
+// --------------------------------------------------------------------------
+CommandLineParserArgumentDescription*
+ctkCommandLineParser::ctkInternal::argumentDescription(const string& argument)
+{
+ string unprefixedArg = argument;
+
+ if (!LongPrefix.empty() && argument.compare(0, LongPrefix.size(), LongPrefix)==0)
+ {
+ // Case when (ShortPrefix + UnPrefixedArgument) matches LongPrefix
+ if (argument == LongPrefix && !ShortPrefix.empty() && argument.compare(0, ShortPrefix.size(), ShortPrefix)==0)
+ {
+ unprefixedArg = argument.substr(ShortPrefix.size(),argument.size());
+ }
+ else
+ {
+ unprefixedArg = argument.substr(LongPrefix.size(),argument.size());
+ }
+ }
+ else if (!ShortPrefix.empty() && argument.compare(0, ShortPrefix.size(), ShortPrefix)==0)
+ {
+ unprefixedArg = argument.substr(ShortPrefix.size(),argument.size());
+ }
+ else if (!LongPrefix.empty() && !ShortPrefix.empty())
+ {
+ return 0;
+ }
+
+ if (ArgNameToArgumentDescriptionMap.count(unprefixedArg))
+ {
+ return this->ArgNameToArgumentDescriptionMap[unprefixedArg];
+ }
+ return 0;
+}
+
+// --------------------------------------------------------------------------
+// ctkCommandLineParser methods
+
+// --------------------------------------------------------------------------
+ctkCommandLineParser::ctkCommandLineParser()
+{
+ this->Internal = new ctkInternal();
+}
+
+// --------------------------------------------------------------------------
+ctkCommandLineParser::~ctkCommandLineParser()
+{
+ delete this->Internal;
+}
+
+// --------------------------------------------------------------------------
+map<string, mitk::Any> ctkCommandLineParser::parseArguments(const StringContainerType& arguments,
+ bool* ok)
+{
+ // Reset
+ this->Internal->UnparsedArguments.clear();
+ this->Internal->ProcessedArguments.clear();
+ this->Internal->ErrorString.clear();
+ // foreach (CommandLineParserArgumentDescription* desc, this->Internal->ArgumentDescriptionList)
+ for (int i=0; i<Internal->ArgumentDescriptionList.size(); i++)
+ {
+ CommandLineParserArgumentDescription* desc = Internal->ArgumentDescriptionList.at(i);
+ desc->Value = mitk::Any(desc->ValueType);
+ if (!desc->DefaultValue.Empty())
+ {
+ desc->Value = desc->DefaultValue;
+ }
+ }
+
+ bool error = false;
+ bool ignoreRest = false;
+ CommandLineParserArgumentDescription * currentArgDesc = 0;
+ vector<CommandLineParserArgumentDescription*> parsedArgDescriptions;
+ for(int i = 1; i < arguments.size(); ++i)
+ {
+ string argument = arguments.at(i);
+ if (this->Internal->Debug) { MITK_DEBUG << "Processing" << argument; }
+
+ // should argument be ignored ?
+ if (ignoreRest)
+ {
+ if (this->Internal->Debug)
+ {
+ MITK_DEBUG << " Skipping: IgnoreRest flag was been set";
+ }
+ this->Internal->UnparsedArguments.push_back(argument);
+ continue;
+ }
+
+ // Skip if the argument does not start with the defined prefix
+ if (!(argument.compare(0, Internal->LongPrefix.size(), Internal->LongPrefix)==0
+ || argument.compare(0, Internal->ShortPrefix.size(), Internal->ShortPrefix)==0))
+ {
+ if (this->Internal->StrictMode)
+ {
+ this->Internal->ErrorString = "Unknown argument ";
+ this->Internal->ErrorString += argument;
+ error = true;
+ break;
+ }
+ if (this->Internal->Debug)
+ {
+ MITK_DEBUG << " Skipping: It does not start with the defined prefix";
+ }
+ this->Internal->UnparsedArguments.push_back(argument);
+ continue;
+ }
+
+ // Skip if argument has already been parsed ...
+ bool alreadyProcessed = false;
+ for (int i=0; i<Internal->ProcessedArguments.size(); i++)
+ if (argument.compare(Internal->ProcessedArguments.at(i))==0)
+ {
+ alreadyProcessed = true;
+ break;
+ }
+
+ if (alreadyProcessed)
+ {
+ if (this->Internal->StrictMode)
+ {
+ this->Internal->ErrorString = "Argument ";
+ this->Internal->ErrorString += argument;
+ this->Internal->ErrorString += " already processed !";
+ error = true;
+ break;
+ }
+ if (this->Internal->Debug)
+ {
+ MITK_DEBUG << " Skipping: Already processed !";
+ }
+ continue;
+ }
+
+ // Retrieve corresponding argument description
+ currentArgDesc = this->Internal->argumentDescription(argument);
+
+ // Is there a corresponding argument description ?
+ if (currentArgDesc)
+ {
+ // If the argument is deprecated, print the help text but continue processing
+ if (currentArgDesc->Deprecated)
+ {
+ MITK_WARN << "Deprecated argument " << argument << ": " << currentArgDesc->ArgHelp;
+ }
+ else
+ {
+ parsedArgDescriptions.push_back(currentArgDesc);
+ }
+
+ this->Internal->ProcessedArguments.push_back(currentArgDesc->ShortArg);
+ this->Internal->ProcessedArguments.push_back(currentArgDesc->LongArg);
+ int numberOfParametersToProcess = currentArgDesc->NumberOfParametersToProcess;
+ ignoreRest = currentArgDesc->IgnoreRest;
+ if (this->Internal->Debug && ignoreRest)
+ {
+ MITK_DEBUG << " IgnoreRest flag is True";
+ }
+
+ // Is the number of parameters associated with the argument being processed known ?
+ if (numberOfParametersToProcess == 0)
+ {
+ currentArgDesc->addParameter("true");
+ }
+ else if (numberOfParametersToProcess > 0)
+ {
+ string missingParameterError =
+ "Argument %1 has %2 value(s) associated whereas exacly %3 are expected.";
+ for(int j=1; j <= numberOfParametersToProcess; ++j)
+ {
+ if (i + j >= arguments.size())
+ {
+// this->Internal->ErrorString =
+// missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
+// if (this->Internal->Debug) { MITK_DEBUG << this->Internal->ErrorString; }
+ if (ok) { *ok = false; }
+ return map<string, mitk::Any>();
+ }
+ string parameter = arguments.at(i + j);
+ if (this->Internal->Debug)
+ {
+ MITK_DEBUG << " Processing parameter" << j << ", value:" << parameter;
+ }
+ if (this->argumentAdded(parameter))
+ {
+// this->Internal->ErrorString =
+// missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
+// if (this->Internal->Debug) { MITK_DEBUG << this->Internal->ErrorString; }
+ if (ok) { *ok = false; }
+ return map<string, mitk::Any>();
+ }
+ if (!currentArgDesc->addParameter(parameter))
+ {
+// this->Internal->ErrorString = string(
+// "Value(s) associated with argument %1 are incorrect. %2").
+// arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
+// if (this->Internal->Debug) { MITK_DEBUG << this->Internal->ErrorString; }
+ if (ok) { *ok = false; }
+ return map<string, mitk::Any>();
+ }
+ }
+ // Update main loop increment
+ i = i + numberOfParametersToProcess;
+ }
+ else if (numberOfParametersToProcess == -1)
+ {
+ if (this->Internal->Debug)
+ {
+ MITK_DEBUG << " Proccessing StringList ...";
+ }
+ int j = 1;
+ while(j + i < arguments.size())
+ {
+ if (this->argumentAdded(arguments.at(j + i)))
+ {
+ if (this->Internal->Debug)
+ {
+ MITK_DEBUG << " No more parameter for" << argument;
+ }
+ break;
+ }
+ string parameter = arguments.at(j + i);
+
+ if (parameter.compare(0, Internal->LongPrefix.size(), Internal->LongPrefix)==0
+ || parameter.compare(0, Internal->ShortPrefix.size(), Internal->ShortPrefix)==0)
+ {
+ j--;
+ break;
+ }
+
+ if (this->Internal->Debug)
+ {
+ MITK_DEBUG << " Processing parameter" << j << ", value:" << parameter;
+ }
+ if (!currentArgDesc->addParameter(parameter))
+ {
+// this->Internal->ErrorString = string(
+// "Value(s) associated with argument %1 are incorrect. %2").
+// arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
+// if (this->Internal->Debug) { MITK_DEBUG << this->Internal->ErrorString; }
+ if (ok) { *ok = false; }
+ return map<string, mitk::Any>();
+ }
+ j++;
+ }
+ // Update main loop increment
+ i = i + j;
+ }
+ }
+ else
+ {
+ if (this->Internal->StrictMode)
+ {
+ this->Internal->ErrorString = "Unknown argument ";
+ this->Internal->ErrorString += argument;
+ error = true;
+ break;
+ }
+ if (this->Internal->Debug)
+ {
+ MITK_DEBUG << " Skipping: Unknown argument";
+ }
+ this->Internal->UnparsedArguments.push_back(argument);
+ }
+ }
+
+ if (ok)
+ {
+ *ok = !error;
+ }
+
+ map<string, mitk::Any> parsedArguments;
+
+ int obligatoryArgs = 0;
+ vector<CommandLineParserArgumentDescription*>::iterator it;
+ for(it = Internal->ArgumentDescriptionList.begin(); it != Internal->ArgumentDescriptionList.end();++it)
+ {
+ CommandLineParserArgumentDescription* desc = *it;
+
+ if(!desc->Optional)
+ obligatoryArgs++;
+ }
+
+ int parsedObligatoryArgs = 0;
+ for(it = parsedArgDescriptions.begin(); it != parsedArgDescriptions.end();++it)
+ {
+ CommandLineParserArgumentDescription* desc = *it;
+
+ string key;
+ if (!desc->LongArg.empty())
+ {
+ key = desc->LongArg;
+ }
+ else
+ {
+ key = desc->ShortArg;
+ }
+
+ if(!desc->Optional)
+ parsedObligatoryArgs++;
+
+ std::pair<string, mitk::Any> elem; elem.first = key; elem.second = desc->Value;
+ parsedArguments.insert(elem);
+ }
+
+ if (obligatoryArgs>parsedObligatoryArgs)
+ {
+ parsedArguments.clear();
+ cout << helpText();
+ }
+
+ return parsedArguments;
+}
+
+// -------------------------------------------------------------------------
+map<string, mitk::Any> ctkCommandLineParser::parseArguments(int argc, char** argv, bool* ok)
+{
+ StringContainerType arguments;
+
+ // Create a StringContainerType of arguments
+ for(int i = 0; i < argc; ++i)
+ arguments.push_back(argv[i]);
+
+ return this->parseArguments(arguments, ok);
+}
+
+// -------------------------------------------------------------------------
+string ctkCommandLineParser::errorString() const
+{
+ return this->Internal->ErrorString;
+}
+
+// -------------------------------------------------------------------------
+const ctkCommandLineParser::StringContainerType& ctkCommandLineParser::unparsedArguments() const
+{
+ return this->Internal->UnparsedArguments;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::addArgument(const string& longarg, const string& shortarg,
+ Type type, const string& argHelp,
+ const mitk::Any& defaultValue, bool optional, bool ignoreRest,
+ bool deprecated)
+{
+ if (longarg.empty() && shortarg.empty()) { return; }
+
+ /* Make sure it's not already added */
+ bool added = this->Internal->ArgNameToArgumentDescriptionMap.count(longarg);
+ if (added) { return; }
+
+ added = this->Internal->ArgNameToArgumentDescriptionMap.count(shortarg);
+ if (added) { return; }
+
+ CommandLineParserArgumentDescription* argDesc =
+ new CommandLineParserArgumentDescription(longarg, this->Internal->LongPrefix,
+ shortarg, this->Internal->ShortPrefix, type,
+ argHelp, defaultValue, ignoreRest, deprecated, optional);
+
+ int argWidth = 0;
+ if (!longarg.empty())
+ {
+ this->Internal->ArgNameToArgumentDescriptionMap[longarg] = argDesc;
+ argWidth += longarg.size() + this->Internal->LongPrefix.size();
+ }
+ if (!shortarg.empty())
+ {
+ this->Internal->ArgNameToArgumentDescriptionMap[shortarg] = argDesc;
+ argWidth += shortarg.size() + this->Internal->ShortPrefix.size() + 2;
+ }
+ argWidth += 5;
+
+ // Set the field width for the arguments
+ if (argWidth > this->Internal->FieldWidth)
+ {
+ this->Internal->FieldWidth = argWidth;
+ }
+
+ this->Internal->ArgumentDescriptionList.push_back(argDesc);
+ this->Internal->GroupToArgumentDescriptionListMap[this->Internal->CurrentGroup].push_back(argDesc);
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::addDeprecatedArgument(
+ const string& longarg, const string& shortarg, const string& argHelp)
+{
+ addArgument(longarg, shortarg, StringList, argHelp, mitk::Any(), false, true);
+}
+
+// --------------------------------------------------------------------------
+int ctkCommandLineParser::fieldWidth() const
+{
+ return this->Internal->FieldWidth;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::beginGroup(const string& description)
+{
+ this->Internal->CurrentGroup = description;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::endGroup()
+{
+ this->Internal->CurrentGroup.clear();
+}
+
+// --------------------------------------------------------------------------
+string ctkCommandLineParser::helpText() const
+{
+ string text;
+ vector<CommandLineParserArgumentDescription*> deprecatedArgs;
+
+ // Loop over grouped argument descriptions
+ map<string, vector<CommandLineParserArgumentDescription*> >::iterator it;
+ for(it = Internal->GroupToArgumentDescriptionListMap.begin(); it != Internal->GroupToArgumentDescriptionListMap.end();++it)
+ {
+ if (!(*it).first.empty())
+ {
+ text = text + "\n" + (*it).first + "\n";
+ }
+
+ vector<CommandLineParserArgumentDescription*>::iterator it2;
+ for(it2 = (*it).second.begin(); it2 != (*it).second.end(); ++it2)
+ {
+ CommandLineParserArgumentDescription* argDesc = *it2;
+ if (argDesc->Deprecated)
+ {
+ deprecatedArgs.push_back(argDesc);
+ }
+ else
+ {
+ text += argDesc->helpText();
+ }
+ }
+ }
+
+ if (!deprecatedArgs.empty())
+ {
+ text += "\nDeprecated arguments:\n";
+ vector<CommandLineParserArgumentDescription*>::iterator it2;
+ for(it2 = deprecatedArgs.begin(); it2 != deprecatedArgs.end(); ++it2)
+ {
+ CommandLineParserArgumentDescription* argDesc = *it2;
+ text += argDesc->helpText();
+ }
+ }
+
+ return text;
+}
+
+// --------------------------------------------------------------------------
+bool ctkCommandLineParser::argumentAdded(const string& argument) const
+{
+ return this->Internal->ArgNameToArgumentDescriptionMap.count(argument);
+}
+
+// --------------------------------------------------------------------------
+bool ctkCommandLineParser::argumentParsed(const string& argument) const
+{
+ for (int i=0; i<Internal->ProcessedArguments.size(); i++)
+ if (argument.compare(Internal->ProcessedArguments.at(i))==0)
+ return true;
+ return false;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::setArgumentPrefix(const string& longPrefix, const string& shortPrefix)
+{
+ this->Internal->LongPrefix = longPrefix;
+ this->Internal->ShortPrefix = shortPrefix;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::setStrictModeEnabled(bool strictMode)
+{
+ this->Internal->StrictMode = strictMode;
+}
+
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/ctkCommandLineParser.h b/Modules/DiffusionImaging/FiberTracking/MiniApps/ctkCommandLineParser.h
new file mode 100755
index 0000000000..e7eb221379
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/ctkCommandLineParser.h
@@ -0,0 +1,422 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+/*=========================================================================
+
+ Library: CTK
+
+ Copyright (c) Kitware Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0.txt
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+=========================================================================*/
+
+#ifndef __ctkCommandLineParser_h
+#define __ctkCommandLineParser_h
+
+#include <mitkAny.h>
+#include <map>
+
+
+/**
+ * \ingroup Core
+ *
+ * The CTK command line parser.
+ *
+ * Use this class to add information about the command line arguments
+ * your program understands and to easily parse them from a given list
+ * of strings.
+ *
+ * This parser provides the following features:
+ *
+ * <ul>
+ * <li>Add arguments by supplying a long name and/or a short name.
+ * Arguments are validated using a regular expression. They can have
+ * a default value and a help string.</li>
+ * <li>Deprecated arguments.</li>
+ * <li>Custom regular expressions for argument validation.</li>
+ * <li>Set different argument name prefixes for native platform look and feel.</li>
+ * <li>QSettings support. Default values for arguments can be read from
+ * a QSettings object.</li>
+ * <li>Create a help text for the command line arguments with support for
+ * grouping arguments.</li>
+ * </ul>
+ *
+ * Here is an example how to use this class inside a main function:
+ *
+ * \code
+ * #include <ctkCommandLineParser.h>
+ * #include <QCoreApplication>
+ * #include <QTextStream>
+ *
+ * int main(int argc, char** argv)
+ * {
+ * QCoreApplication app(argc, argv);
+ * // This is used by QSettings
+ * QCoreApplication::setOrganizationName("MyOrg");
+ * QCoreApplication::setApplicationName("MyApp");
+ *
+ * ctkCommandLineParser parser;
+ * // Use Unix-style argument names
+ * parser.setArgumentPrefix("--", "-");
+ * // Enable QSettings support
+ * parser.enableSettings("disable-settings");
+ *
+ * // Add command line argument names
+ * parser.addArgument("disable-settings", "", mitk::Any::Bool, "Do not use QSettings");
+ * parser.addArgument("help", "h", mitk::Any::Bool, "Show this help text");
+ * parser.addArgument("search-paths", "s", mitk::Any::StringList, "A list of paths to search");
+ *
+ * // Parse the command line arguments
+ * bool ok = false;
+ * map<string, mitk::Any> parsedArgs = parser.parseArguments(QCoreApplication::arguments(), &ok);
+ * if (!ok)
+ * {
+ * QTextStream(stderr, QIODevice::WriteOnly) << "Error parsing arguments: "
+ * << parser.errorString() << "\n";
+ * return EXIT_FAILURE;
+ * }
+ *
+ * // Show a help message
+ * if (parsedArgs.contains("help") || parsedArgs.contains("h"))
+ * {
+ * QTextStream(stdout, QIODevice::WriteOnly) << parser.helpText();
+ * return EXIT_SUCCESS;
+ * }
+ *
+ * // Do something
+ *
+ * return EXIT_SUCCESS;
+ * }
+ * \endcode
+ */
+
+using namespace std;
+
+class ctkCommandLineParser
+{
+
+public:
+
+ enum Type {
+ String = 0,
+ Bool = 1,
+ StringList = 2,
+ Int = 3,
+ Float = 4
+ };
+
+ typedef std::vector< std::string > StringContainerType;
+
+ /**
+ * Constructs a parser instance.
+ *
+ * If QSettings support is enabled by a call to <code>enableSettings()</code>
+ * a default constructed QSettings instance will be used when parsing
+ * the command line arguments. Make sure to call <code>QCoreApplication::setOrganizationName()</code>
+ * and <code>QCoreApplication::setApplicationName()</code> before using default
+ * constructed QSettings objects.
+ *
+ * @param newParent The QObject parent.
+ */
+ ctkCommandLineParser();
+
+ ~ctkCommandLineParser();
+
+ /**
+ * Parse a given list of command line arguments.
+ *
+ * This method parses a list of string elements considering the known arguments
+ * added by calls to <code>addArgument()</code>. If any one of the argument
+ * values does not match the corresponding regular expression,
+ * <code>ok</code> is set to false and an empty map object is returned.
+ *
+ * The keys in the returned map object correspond to the long argument string,
+ * if it is not empty. Otherwise, the short argument string is used as key. The
+ * mitk::Any values can safely be converted to the type specified in the
+ * <code>addArgument()</code> method call.
+ *
+ * @param arguments A StringContainerType containing command line arguments. Usually
+ * given by <code>QCoreApplication::arguments()</code>.
+ * @param ok A pointer to a boolean variable. Will be set to <code>true</code>
+ * if all regular expressions matched, <code>false</code> otherwise.
+ * @return A map object mapping the long argument (if empty, the short one)
+ * to a mitk::Any containing the value.
+ */
+
+ map<string, mitk::Any> parseArguments(const StringContainerType &arguments, bool* ok = 0);
+
+ /**
+ * Convenient method allowing to parse a given list of command line arguments.
+ * @see parseArguments(const StringContainerType &, bool*)
+ */
+ map<string, mitk::Any> parseArguments(int argc, char** argv, bool* ok = 0);
+
+ /**
+ * Returns a detailed error description if a call to <code>parseArguments()</code>
+ * failed.
+ *
+ * @return The error description, empty if no error occured.
+ * @see parseArguments(const StringContainerType&, bool*)
+ */
+ string errorString() const;
+
+ /**
+ * This method returns all unparsed arguments, i.e. all arguments
+ * for which no long or short name has been registered via a call
+ * to <code>addArgument()</code>.
+ *
+ * @see addArgument()
+ *
+ * @return A list containing unparsed arguments.
+ */
+ const StringContainerType& unparsedArguments() const;
+
+ /**
+ * Checks if the given argument has been added via a call
+ * to <code>addArgument()</code>.
+ *
+ * @see addArgument()
+ *
+ * @param argument The argument to be checked.
+ * @return <code>true</code> if the argument was added, <code>false</code>
+ * otherwise.
+ */
+ bool argumentAdded(const string& argument) const;
+
+ /**
+ * Checks if the given argument has been parsed successfully by a previous
+ * call to <code>parseArguments()</code>.
+ *
+ * @param argument The argument to be checked.
+ * @return <code>true</code> if the argument was parsed, <code>false</code>
+ * otherwise.
+ */
+ bool argumentParsed(const string& argument) const;
+
+ /**
+ * Adds a command line argument. An argument can have a long name
+ * (like --long-argument-name), a short name (like -l), or both. The type
+ * of the argument can be specified by using the <code>type</code> parameter.
+ * The following types are supported:
+ *
+ * <table>
+ * <tr><td><b>Type</b></td><td><b># of parameters</b></td><td><b>Default regular expr</b></td>
+ * <td><b>Example</b></td></tr>
+ * <tr><td>mitk::Any::String</td><td>1</td><td>.*</td><td>--test-string StringParameter</td></tr>
+ * <tr><td>mitk::Any::Bool</td><td>0</td><td>does not apply</td><td>--enable-something</td></tr>
+ * <tr><td>mitk::Any::StringList</td><td>-1</td><td>.*</td><td>--test-list string1 string2</td></tr>
+ * <tr><td>mitk::Any::Int</td><td>1</td><td>-?[0-9]+</td><td>--test-int -5</td></tr>
+ * </table>
+ *
+ * The regular expressions are used to validate the parameters of command line
+ * arguments. You can restrict the valid set of parameters by calling
+ * <code>setExactMatchRegularExpression()</code> for your argument.
+ *
+ * Optionally, a help string and a default value can be provided for the argument. If
+ * the mitk::Any type of the default value does not match <code>type</code>, an
+ * exception is thrown. Arguments with default values are always returned by
+ * <code>parseArguments()</code>.
+ *
+ * You can also declare an argument deprecated, by setting <code>deprecated</code>
+ * to <code>true</code>. Alternatively you can add a deprecated argument by calling
+ * <code>addDeprecatedArgument()</code>.
+ *
+ * If the long or short argument has already been added, or if both are empty strings,
+ * the method call has no effect.
+ *
+ * @param longarg The long argument name.
+ * @param shortarg The short argument name.
+ * @param type The argument type (see the list above for supported types).
+ * @param argHelp A help string describing the argument.
+ * @param defaultValue A default value for the argument.
+ * @param ignoreRest All arguments after the current one will be ignored.
+ * @param deprecated Declares the argument deprecated.
+ *
+ * @see setExactMatchRegularExpression()
+ * @see addDeprecatedArgument()
+ * @throws std::logic_error If the mitk::Any type of <code>defaultValue</code>
+ * does not match <code>type</code>, a <code>std::logic_error</code> is thrown.
+ */
+ void addArgument(const string& longarg, const string& shortarg,
+ Type type, const string& argHelp = string(),
+ const mitk::Any& defaultValue = mitk::Any(), bool optional=true,
+ bool ignoreRest = false, bool deprecated = false);
+
+ /**
+ * Adds a deprecated command line argument. If a deprecated argument is provided
+ * on the command line, <code>argHelp</code> is displayed in the console and
+ * processing continues with the next argument.
+ *
+ * Deprecated arguments are grouped separately at the end of the help text
+ * returned by <code>helpText()</code>.
+ *
+ * @param longarg The long argument name.
+ * @param shortarg The short argument name.
+ * @param argHelp A help string describing alternatives to the deprecated argument.
+ */
+ void addDeprecatedArgument(const string& longarg, const string& shortarg,
+ const string& argHelp);
+
+ /**
+ * Sets a custom regular expression for validating argument parameters. The method
+ * <code>errorString()</code> can be used the get the last error description.
+ *
+ * @param argument The previously added long or short argument name.
+ * @param expression A regular expression which the arugment parameters must match.
+ * @param exactMatchFailedMessage An error message explaining why the parameter did
+ * not match.
+ *
+ * @return <code>true</code> if the argument was found and the regular expression was set,
+ * <code>false</code> otherwise.
+ *
+ * @see errorString()
+ */
+ bool setExactMatchRegularExpression(const string& argument, const string& expression,
+ const string& exactMatchFailedMessage);
+
+ /**
+ * The field width for the argument names without the help text.
+ *
+ * @return The argument names field width in the help text.
+ */
+ int fieldWidth() const;
+
+ /**
+ * Creates a help text containing properly formatted argument names and help strings
+ * provided by calls to <code>addArgument()</code>. The arguments can be grouped by
+ * using <code>beginGroup()</code> and <code>endGroup()</code>.
+ *
+ * @param charPad The padding character.
+ * @return The formatted help text.
+ */
+ string helpText() const;
+
+ /**
+ * Sets the argument prefix for long and short argument names. This can be used
+ * to create native command line arguments without changing the calls to
+ * <code>addArgument()</code>. For example on Unix-based systems, long argument
+ * names start with "--" and short names with "-", while on Windows argument names
+ * always start with "/".
+ *
+ * Note that all methods in ctkCommandLineParser which take an argument name
+ * expect the name as it was supplied to <code>addArgument</code>.
+ *
+ * Example usage:
+ *
+ * \code
+ * ctkCommandLineParser parser;
+ * parser.setArgumentPrefix("--", "-");
+ * parser.addArgument("long-argument", "l", mitk::Any::String);
+ * StringContainerType args;
+ * args << "program name" << "--long-argument Hi";
+ * parser.parseArguments(args);
+ * \endcode
+ *
+ * @param longPrefix The prefix for long argument names.
+ * @param shortPrefix The prefix for short argument names.
+ */
+ void setArgumentPrefix(const string& longPrefix, const string& shortPrefix);
+
+ /**
+ * Begins a new group for documenting arguments. All newly added arguments via
+ * <code>addArgument()</code> will be put in the new group. You can close the
+ * current group by calling <code>endGroup()</code> or be opening a new group.
+ *
+ * Note that groups cannot be nested and all arguments which do not belong to
+ * a group will be listed at the top of the text created by <code>helpText()</code>.
+ *
+ * @param description The description of the group
+ */
+ void beginGroup(const string& description);
+
+ /**
+ * Ends the current group.
+ *
+ * @see beginGroup(const string&)
+ */
+ void endGroup();
+
+ /**
+ * Enables QSettings support in ctkCommandLineParser. If an argument name is found
+ * in the QSettings instance with a valid mitk::Any, the value is considered as
+ * a default value and overwrites default values registered with
+ * <code>addArgument()</code>. User supplied values on the command line overwrite
+ * values in the QSettings instance, except for arguments with multiple parameters
+ * which are merged with QSettings values. Call <code>mergeSettings(false)</code>
+ * to disable merging.
+ *
+ * See <code>ctkCommandLineParser(QSettings*)</code> for information about how to
+ * supply a QSettings instance.
+ *
+ * Additionally, a long and short argument name can be specified which will disable
+ * QSettings support if supplied on the command line. The argument name must be
+ * registered as a regular argument via <code>addArgument()</code>.
+ *
+ * @param disableLongArg Long argument name.
+ * @param disableShortArg Short argument name.
+ *
+ * @see ctkCommandLineParser(QSettings*)
+ */
+ void enableSettings(const string& disableLongArg = "",
+ const string& disableShortArg = "");
+
+ /**
+ * Controlls the merging behavior of user values and QSettings values.
+ *
+ * If merging is on (the default), user supplied values for an argument
+ * which can take more than one parameter are merged with values stored
+ * in the QSettings instance. If merging is off, the user values overwrite
+ * the QSettings values.
+ *
+ * @param merge <code>true</code> enables QSettings merging, <code>false</code>
+ * disables it.
+ */
+ void mergeSettings(bool merge);
+
+ /**
+ * Can be used to check if QSettings support has been enabled by a call to
+ * <code>enableSettings()</code>.
+ *
+ * @return <code>true</code> if QSettings support is enabled, <code>false</code>
+ * otherwise.
+ */
+ bool settingsEnabled() const;
+
+
+ /**
+ * Can be used to teach the parser to stop parsing the arguments and return False when
+ * an unknown argument is encountered. By default <code>StrictMode</code> is disabled.
+ *
+ * @see parseArguments(const StringContainerType &, bool*)
+ */
+ void setStrictModeEnabled(bool strictMode);
+
+private:
+ class ctkInternal;
+ ctkInternal * Internal;
+};
+
+#endif
diff --git a/Core/Code/Rendering/mitkVtkMapper2D.h b/Modules/DiffusionImaging/FiberTracking/MiniApps/mitkFiberTrackingMiniApps.cpp
old mode 100644
new mode 100755
similarity index 58%
copy from Core/Code/Rendering/mitkVtkMapper2D.h
copy to Modules/DiffusionImaging/FiberTracking/MiniApps/mitkFiberTrackingMiniApps.cpp
index f9db3be352..c7d6ac601a
--- a/Core/Code/Rendering/mitkVtkMapper2D.h
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/mitkFiberTrackingMiniApps.cpp
@@ -1,32 +1,22 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
+#include <MiniAppManager.h>
-#ifndef BASEVTKMAPPER2D_H_HEADER_INCLUDED
-#define BASEVTKMAPPER2D_H_HEADER_INCLUDED
-
-#include "mitkVtkMapper.h"
-
-namespace mitk {
-
- // typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead.
- DEPRECATED(typedef VtkMapper VtkMapper2D);
-
-} // namespace mitk
-
-
-#endif /* BASEVTKMAPPER2D_H_HEADER_INCLUDED */
+int main(int argc, char* argv[])
+{
+ return MiniAppManager::GetInstance()->RunMiniApp(argc, argv);
+}
diff --git a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXMapper2D.h b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXMapper2D.h
index 59cc048edf..757724fa08 100644
--- a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXMapper2D.h
+++ b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXMapper2D.h
@@ -1,110 +1,110 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef FIBERBUNDLEXMAPPER2D_H_HEADER_INCLUDED
#define FIBERBUNDLEXMAPPER2D_H_HEADER_INCLUDED
//MITK Rendering
#include <mitkCommon.h>
#include <mitkBaseRenderer.h>
//#include "FiberTrackingExports.h"
#include <mitkVtkMapper.h>
#include <mitkFiberBundleX.h>
#include <vtkSmartPointer.h>
class vtkActor;
//class vtkPropAssembly; //lets see if we need it
class mitkBaseRenderer;
class vtkPolyDataMapper;
class vtkCutter;
class vtkPlane;
class vtkPolyData;
namespace mitk {
struct IShaderRepository;
class FiberBundleXMapper2D : public VtkMapper
{
public:
mitkClassMacro(FiberBundleXMapper2D, VtkMapper);
itkNewMacro(Self);
mitk::FiberBundleX* GetInput();
/** \brief Checks whether this mapper needs to update itself and generate
* data. */
virtual void Update(mitk::BaseRenderer * renderer);
static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
//### methods of MITK-VTK rendering pipeline
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
//### end of methods of MITK-VTK rendering pipeline
class FBXLocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
/** \brief Point Actor of a 2D render window. */
vtkSmartPointer<vtkActor> m_PointActor;
/** \brief Point Mapper of a 2D render window. */
vtkSmartPointer<vtkPolyDataMapper> m_PointMapper;
vtkSmartPointer<vtkPlane> m_SlicingPlane; //needed later when optimized 2D mapper
vtkSmartPointer<vtkPolyData> m_SlicedResult; //might be depricated in optimized 2D mapper
/** \brief Timestamp of last update of stored data. */
itk::TimeStamp m_LastUpdateTime;
/** \brief Constructor of the local storage. Do as much actions as possible in here to avoid double executions. */
FBXLocalStorage(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file
~FBXLocalStorage()
{
}
};
/** \brief This member holds all three LocalStorages for the three 2D render windows. */
- mitk::Mapper::LocalStorageHandler<FBXLocalStorage> m_LSH;
+ mitk::LocalStorageHandler<FBXLocalStorage> m_LSH;
protected:
FiberBundleXMapper2D();
virtual ~FiberBundleXMapper2D();
/** Does the actual resampling, without rendering. */
virtual void GenerateDataForRenderer(mitk::BaseRenderer*);
void UpdateShaderParameter(mitk::BaseRenderer*);
static IShaderRepository* GetShaderRepository();
private:
vtkSmartPointer<vtkLookupTable> m_lut;
};
}//end namespace
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXMapper3D.h b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXMapper3D.h
index f4e73c98e4..d6e2f3ce34 100644
--- a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXMapper3D.h
+++ b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXMapper3D.h
@@ -1,104 +1,104 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef FiberBundleXMapper3D_H_HEADER_INCLUDED
#define FiberBundleXMapper3D_H_HEADER_INCLUDED
//#include <mitkBaseData.h> //?? necessary
#include <FiberTrackingExports.h>
#include <mitkVtkMapper.h>
#include <mitkFiberBundleX.h>
#include <vtkSmartPointer.h>
#include <vtkOpenGLPolyDataMapper.h>
#include <vtkOpenGLActor.h>
#include <vtkLookupTable.h>
class vtkPropAssembly;
namespace mitk {
//##Documentation
//## @brief Mapper for FiberBundleX
//## @ingroup Mapper
class FiberTracking_EXPORT FiberBundleXMapper3D : public VtkMapper
{
public:
mitkClassMacro(FiberBundleXMapper3D, VtkMapper);
itkNewMacro(Self);
//========== essential implementation for 3D mapper ========
const FiberBundleX* GetInput();
virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer); //looks like depricated.. should be replaced bz GetViewProp()
static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
virtual void ApplyProperties(mitk::BaseRenderer* renderer);
static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper);
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
//=========================================================
virtual void GenerateData(mitk::BaseRenderer *renderer);
class FBXLocalStorage3D : public mitk::Mapper::BaseLocalStorage
{
public:
/** \brief Point Actor of a 3D render window. */
vtkSmartPointer<vtkActor> m_FiberActor;
/** \brief Point Mapper of a 3D render window. */
vtkSmartPointer<vtkPolyDataMapper> m_FiberMapper;
vtkSmartPointer<vtkPropAssembly> m_FiberAssembly;
/** \brief Timestamp of last update of stored data. */
itk::TimeStamp m_LastUpdateTime;
/** \brief Constructor of the local storage. Do as much actions as possible in here to avoid double executions. */
FBXLocalStorage3D(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file
~FBXLocalStorage3D()
{
}
};
/** \brief This member holds all three LocalStorages for the 3D render window(s). */
- mitk::Mapper::LocalStorageHandler<FBXLocalStorage3D> m_LSH;
+ mitk::LocalStorageHandler<FBXLocalStorage3D> m_LSH;
protected:
FiberBundleXMapper3D();
virtual ~FiberBundleXMapper3D();
void UpdateVtkObjects(); //??
private:
vtkSmartPointer<vtkLookupTable> m_lut;
};
} // end namespace mitk
#endif /* FiberBundleXMapper3D_H_HEADER_INCLUDED */
diff --git a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
index 311a5f6733..cff4f67bb3 100644
--- a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
@@ -1,205 +1,206 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkFiberBundleXThreadMonitorMapper3D.h"
#include <mitkProperties.h>
#include <vtkPropAssembly.h>
//#include <vtkTextActor.h>
#include <vtkTextProperty.h>
mitk::FiberBundleXThreadMonitorMapper3D::FiberBundleXThreadMonitorMapper3D()
: m_FiberMonitorMapper(vtkSmartPointer<vtkPolyDataMapper>::New())
, m_TextActorClose(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorOpen(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorHeading(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorMask(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorStatus(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorStarted(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorFinished(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorTerminated(vtkSmartPointer<vtkTextActor>::New())
, m_FiberAssembly(vtkPropAssembly::New())
, m_lastModifiedMonitorNodeTime(-1)
{
m_FiberAssembly->AddPart(m_TextActorClose);
m_FiberAssembly->AddPart(m_TextActorOpen);
m_FiberAssembly->AddPart(m_TextActorHeading);
m_FiberAssembly->AddPart(m_TextActorMask);
m_FiberAssembly->AddPart(m_TextActorStatus);
m_FiberAssembly->AddPart(m_TextActorStarted);
m_FiberAssembly->AddPart(m_TextActorFinished);
m_FiberAssembly->AddPart(m_TextActorTerminated);
}
mitk::FiberBundleXThreadMonitorMapper3D::~FiberBundleXThreadMonitorMapper3D()
{
m_FiberAssembly->Delete();
}
const mitk::FiberBundleXThreadMonitor* mitk::FiberBundleXThreadMonitorMapper3D::GetInput()
{
return static_cast<const mitk::FiberBundleXThreadMonitor * > ( GetDataNode()->GetData() );
}
/*
This method is called once the mapper gets new input,
for UI rotation or changes in colorcoding this method is NOT called
*/
void mitk::FiberBundleXThreadMonitorMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
+ bool visible = true;
+ GetDataNode()->GetVisibility(visible, renderer, "visible");
+
+ if ( !visible ) return;
+
+ const DataNode *node = this->GetDataNode();
+
+ if (m_lastModifiedMonitorNodeTime >= node->GetMTime())
+ return;
+
+ m_lastModifiedMonitorNodeTime = node->GetMTime();
// MITK_INFO << m_LastUpdateTime;
FiberBundleXThreadMonitor* monitor = dynamic_cast<FiberBundleXThreadMonitor * > ( GetDataNode()->GetData() );
// m_TextActor->SetInput( monitor->getTextL1().toStdString().c_str() );
m_TextActorClose->SetInput( monitor->getBracketClose().toStdString().c_str() );
vtkTextProperty* tpropClose = m_TextActorClose->GetTextProperty();
//tprop->SetFontFamilyToArial ();
//tprop->SetLineSpacing(1.0);
tpropClose->SetFontSize(16);
tpropClose->SetColor(0.85,0.8,0.8);
m_TextActorClose->SetDisplayPosition( monitor->getBracketClosePosition()[0], monitor->getBracketClosePosition()[1] );
//m_TextActorClose->Modified();
m_TextActorOpen->SetInput( monitor->getBracketOpen().toStdString().c_str() );
vtkTextProperty* tpropOpen = m_TextActorOpen->GetTextProperty();
//tprop->SetFontFamilyToArial ();
//tprop->SetLineSpacing(1.0);
tpropOpen->SetFontSize(16);
tpropOpen->SetColor(0.85,0.8,0.8);
m_TextActorOpen->SetDisplayPosition( monitor->getBracketOpenPosition()[0], monitor->getBracketOpenPosition()[1] );
//m_TextActorOpen->Modified();
m_TextActorHeading->SetInput( monitor->getHeading().toStdString().c_str() );
vtkTextProperty* tpropHeading = m_TextActorHeading->GetTextProperty();
tpropHeading->SetFontSize(12);
tpropHeading->SetOpacity( monitor->getHeadingOpacity() * 0.1 );
tpropHeading->SetColor(0.85,0.8,0.8);
m_TextActorHeading->SetDisplayPosition( monitor->getHeadingPosition()[0], monitor->getHeadingPosition()[1] );
//m_TextActorHeading->Modified();
m_TextActorMask->SetInput( monitor->getMask().toStdString().c_str() );
vtkTextProperty* tpropMask = m_TextActorMask->GetTextProperty();
tpropMask->SetFontSize(12);
tpropMask->SetOpacity( monitor->getMaskOpacity() * 0.1 );
tpropMask->SetColor(1.0,1.0,1.0);
m_TextActorMask->SetDisplayPosition( monitor->getMaskPosition()[0], monitor->getMaskPosition()[1] );
//m_TextActorHeading->Modified();
m_TextActorStatus->SetInput(monitor->getStatus().toStdString().c_str());
vtkTextProperty* tpropStatus = m_TextActorStatus->GetTextProperty();
tpropStatus->SetFontSize(10);
tpropStatus->SetOpacity( monitor->getStatusOpacity() * 0.1 );
tpropStatus->SetColor(0.85,0.8,0.8);
m_TextActorStatus->SetDisplayPosition( monitor->getStatusPosition()[0], monitor->getStatusPosition()[1] );
//m_TextActorStatus->Modified();
m_TextActorStarted->SetInput(QString::number(monitor->getStarted()).toStdString().c_str());
vtkTextProperty* tpropStarted = m_TextActorStarted->GetTextProperty();
tpropStarted->SetFontSize(12);
tpropStarted->SetOpacity( monitor->getStartedOpacity() * 0.1 );
tpropStarted->SetColor(0.0,1.0,0.0);
m_TextActorStarted->SetDisplayPosition( monitor->getStartedPosition()[0], monitor->getStartedPosition()[1] );
//m_TextActorStarted->Modified();
m_TextActorFinished->SetInput(QString::number(monitor->getFinished()).toStdString().c_str());
vtkTextProperty* tpropFinished = m_TextActorFinished->GetTextProperty();
tpropFinished->SetFontSize(12);
tpropFinished->SetOpacity( monitor->getFinishedOpacity() * 0.1 );
tpropFinished->SetColor(1.0,1.0,1.0);
m_TextActorFinished->SetDisplayPosition( monitor->getFinishedPosition()[0], monitor->getFinishedPosition()[1] );
//m_TextActorFinished->Modified();
m_TextActorTerminated->SetInput(QString::number(monitor->getTerminated()).toStdString().c_str());
vtkTextProperty* tpropTerminated = m_TextActorTerminated->GetTextProperty();
tpropTerminated->SetFontSize(12);
tpropTerminated->SetOpacity( monitor->getTerminatedOpacity() * 0.1 );
tpropTerminated->SetColor(1.0,1.0,1.0);
m_TextActorTerminated->SetDisplayPosition( monitor->getTerminatedPosition()[0], monitor->getTerminatedPosition()[1] );
//m_TextActorTerminated->Modified();
- bool visible = true;
- GetDataNode()->GetVisibility(visible, renderer, "visible");
-
- if ( !visible ) return;
// Calculate time step of the input data for the specified renderer (integer value)
// this method is implemented in mitkMapper
// this->CalculateTimeStep( renderer );
- const DataNode *node = this->GetDataNode();
-
- if (m_lastModifiedMonitorNodeTime < node->GetMTime())
- {
- m_lastModifiedMonitorNodeTime = node->GetMTime();
- }
}
void mitk::FiberBundleXThreadMonitorMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
// MITK_INFO << "FiberBundleXxXXMapper3D()SetDefaultProperties";
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
vtkProp* mitk::FiberBundleXThreadMonitorMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
//MITK_INFO << "FiberBundleXxXXMapper3D()GetVTKProp";
//this->GenerateData();
return m_FiberAssembly;
}
void mitk::FiberBundleXThreadMonitorMapper3D::ApplyProperties(mitk::BaseRenderer* renderer)
{
// MITK_INFO << "FiberBundleXXXXMapper3D ApplyProperties(renderer)";
}
void mitk::FiberBundleXThreadMonitorMapper3D::UpdateVtkObjects()
{
// MITK_INFO << "FiberBundleXxxXMapper3D UpdateVtkObjects()";
}
void mitk::FiberBundleXThreadMonitorMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
{
}
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkDiffusionNoiseModel.h b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkDiffusionNoiseModel.h
index 7d16b63563..ef545d6511 100644
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkDiffusionNoiseModel.h
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkDiffusionNoiseModel.h
@@ -1,55 +1,56 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_DiffusionNoiseModel_H
#define _MITK_DiffusionNoiseModel_H
#include <FiberTrackingExports.h>
#include <itkVariableLengthVector.h>
#include <itkVector.h>
#include <vnl/vnl_vector_fixed.h>
namespace mitk {
/**
* \brief Abstract class for diffusion noise models
*
*/
template< class ScalarType >
class DiffusionNoiseModel
{
public:
DiffusionNoiseModel(){}
~DiffusionNoiseModel(){}
typedef itk::VariableLengthVector< ScalarType > PixelType;
/** Adds noise according to model to the input pixel. Has to be implemented in subclass. **/
virtual void AddNoise(PixelType& pixel) = 0;
void SetNoiseVariance(double var){ m_NoiseVariance = var; }
+ double GetNoiseVariance(){ return m_NoiseVariance; }
protected:
double m_NoiseVariance; ///< variance of underlying distribution
};
}
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkDiffusionSignalModel.h b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkDiffusionSignalModel.h
index f11b07d7c8..ea818ecbe8 100644
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkDiffusionSignalModel.h
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkDiffusionSignalModel.h
@@ -1,90 +1,91 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_DiffusionSignalModel_H
#define _MITK_DiffusionSignalModel_H
#include <FiberTrackingExports.h>
#include <itkVariableLengthVector.h>
#include <itkVector.h>
#include <vnl/vnl_vector_fixed.h>
namespace mitk {
/**
* \brief Abstract class for diffusion signal models
*
*/
template< class ScalarType >
class DiffusionSignalModel
{
public:
DiffusionSignalModel()
: m_T2(100)
, m_Weight(1)
{}
~DiffusionSignalModel(){}
typedef itk::VariableLengthVector< ScalarType > PixelType;
typedef itk::Vector<double,3> GradientType;
typedef std::vector<GradientType> GradientListType;
/** Realizes actual signal generation. Has to be implemented in subclass. **/
virtual PixelType SimulateMeasurement() = 0;
+ GradientType GetGradientDirection(int i) { return m_GradientList.at(i); }
void SetFiberDirection(GradientType fiberDirection){ m_FiberDirection = fiberDirection; }
void SetGradientList(GradientListType gradientList) { m_GradientList = gradientList; }
void SetT2(double T2) { m_T2 = T2; }
void SetWeight(double Weight) { m_Weight = Weight; }
double GetWeight() { return m_Weight; }
double GetT2() { return m_T2; }
int GetNumGradients(){ return m_GradientList.size(); }
std::vector< int > GetBaselineIndices()
{
std::vector< int > result;
for( unsigned int i=0; i<this->m_GradientList.size(); i++)
if (m_GradientList.at(i).GetNorm()<0.0001)
result.push_back(i);
return result;
}
int GetFirstBaselineIndex()
{
for( unsigned int i=0; i<this->m_GradientList.size(); i++)
if (m_GradientList.at(i).GetNorm()<0.0001)
return i;
return -1;
}
bool IsBaselineIndex(int idx)
{
if (m_GradientList.size()>idx && m_GradientList.at(idx).GetNorm()<0.0001)
return true;
return false;
}
protected:
GradientType m_FiberDirection; ///< Needed to generate anisotropc signal to determin direction of anisotropy
GradientListType m_GradientList; ///< Diffusion gradient direction container
double m_T2; ///< Tissue specific relaxation time
double m_Weight;
};
}
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.cpp b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.cpp
deleted file mode 100644
index fc094304c2..0000000000
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#include <math.h>
-
-template< class ScalarType >
-GibbsRingingArtifact< ScalarType >::GibbsRingingArtifact()
- : m_KspaceCropping(0.1)
-{
-
-}
-
-template< class ScalarType >
-GibbsRingingArtifact< ScalarType >::~GibbsRingingArtifact()
-{
-
-}
-
-template< class ScalarType >
-typename GibbsRingingArtifact< ScalarType >::ComplexSliceType::Pointer GibbsRingingArtifact< ScalarType >::AddArtifact(typename ComplexSliceType::Pointer slice)
-{
- itk::ImageRegion<2> region = slice->GetLargestPossibleRegion();
-
- int x = region.GetSize()[0]/m_KspaceCropping;
- int y = region.GetSize()[1]/m_KspaceCropping;
-
- typename ComplexSliceType::Pointer newSlice = ComplexSliceType::New();
- itk::ImageRegion<2> newRegion;
- newRegion.SetSize(0, x);
- newRegion.SetSize(1, y);
-
- newSlice->SetLargestPossibleRegion( newRegion );
- newSlice->SetBufferedRegion( newRegion );
- newSlice->SetRequestedRegion( newRegion );
- newSlice->Allocate();
-
- itk::ImageRegionIterator<ComplexSliceType> it(newSlice, newRegion);
- while(!it.IsAtEnd())
- {
- typename ComplexSliceType::IndexType idx;
- idx[0] = region.GetSize()[0]/2-x/2+it.GetIndex()[0];
- idx[1] = region.GetSize()[1]/2-y/2+it.GetIndex()[1];
-
- it.Set(slice->GetPixel(idx));
-
- ++it;
- }
- return newSlice;
-}
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.h b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.h
deleted file mode 100644
index 9115346e66..0000000000
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#ifndef _MITK_GibbsRingingArtifact_H
-#define _MITK_GibbsRingingArtifact_H
-
-#include <FiberTrackingExports.h>
-#include <mitkKspaceArtifact.h>
-#include <itkImageRegion.h>
-#include <itkImageRegionIterator.h>
-
-namespace mitk {
-
-/**
- * \brief Class to add gibbs ringing artifact to input complex slice
- *
- */
-template< class ScalarType >
-class GibbsRingingArtifact : public KspaceArtifact< ScalarType >
-{
-public:
-
- GibbsRingingArtifact();
- ~GibbsRingingArtifact();
-
- typedef typename KspaceArtifact< ScalarType >::ComplexSliceType ComplexSliceType;
-
- /** Adds Gibbs ringing to the input slice (by zero padding). **/
- typename ComplexSliceType::Pointer AddArtifact(typename ComplexSliceType::Pointer slice);
-
- void SetKspaceCropping(int factor){ m_KspaceCropping=factor; }
- int GetKspaceCropping(){ return m_KspaceCropping; }
-
-protected:
-
- int m_KspaceCropping;
-
-};
-
-#include "mitkGibbsRingingArtifact.cpp"
-
-}
-
-#endif
-
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkKspaceArtifact.h b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkKspaceArtifact.h
index a94d8dfb5d..42d575de35 100644
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkKspaceArtifact.h
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkKspaceArtifact.h
@@ -1,67 +1,64 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_KspaceArtifact_H
#define _MITK_KspaceArtifact_H
#include <FiberTrackingExports.h>
#include <itkImage.h>
-#include <itkFFTRealToComplexConjugateImageFilter.h>
+#include <itkVnlForwardFFTImageFilter.h>
namespace mitk {
/**
* \brief Abstract class for diffusion noise models
*
*/
template< class ScalarType >
class KspaceArtifact
{
public:
KspaceArtifact()
- : m_T2(2000)
- , m_TE(100)
+ : m_TE(100)
, m_Tinhom(50)
, m_LineReadoutTime(1)
{
}
~KspaceArtifact(){}
- typedef typename itk::FFTRealToComplexConjugateImageFilter< ScalarType, 2 >::OutputImageType ComplexSliceType;
+ typedef itk::Image< ScalarType, 2 > WorkImageType;
+ typedef typename itk::VnlForwardFFTImageFilter< WorkImageType >::OutputImageType ComplexSliceType;
/** Adds artifact according to model to the input slice. Has to be implemented in subclass. **/
virtual typename ComplexSliceType::Pointer AddArtifact(typename ComplexSliceType::Pointer slice) = 0;
- // all times stored internally in µ seconds, input in milliseconds
void SetTline(double LineReadoutTime){ m_LineReadoutTime=LineReadoutTime; }
void SetTE(double TE){ m_TE=TE; }
- void SetT2(double T2){ m_T2=T2; }
void SetTinhom(unsigned int Tinhom){ m_Tinhom=Tinhom; }
protected:
double m_Tinhom;
- double m_T2;
double m_TE;
double m_LineReadoutTime;
};
}
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkSignalDecay.cpp b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkSignalDecay.cpp
deleted file mode 100644
index e68047ecad..0000000000
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkSignalDecay.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-template< class ScalarType >
-SignalDecay< ScalarType >::SignalDecay()
-{
-
-}
-
-template< class ScalarType >
-SignalDecay< ScalarType >::~SignalDecay()
-{
-
-}
-
-template< class ScalarType >
-typename SignalDecay< ScalarType >::ComplexSliceType::Pointer SignalDecay< ScalarType >::AddArtifact(typename ComplexSliceType::Pointer slice)
-{
- itk::ImageRegion<2> region = slice->GetLargestPossibleRegion();
-
- double dt = this->m_LineReadoutTime/region.GetSize(0);
-
- double from90 = this->m_TE - this->m_LineReadoutTime*region.GetSize(1)/2;
- double fromMaxEcho = - this->m_LineReadoutTime*region.GetSize(1)/2;
-
- for (int y=0; y<region.GetSize(1); y++)
- for (int x=0; x<region.GetSize(0); x++)
- {
- typename ComplexSliceType::IndexType idx;
- idx[0]=x; idx[1]=y;
- std::complex< double > pix = slice->GetPixel(idx);
-
- double fact = exp(-from90/this->m_T2 -fabs(fromMaxEcho)/this->m_Tinhom);
- std::complex< double > newPix(fact*pix.real(), fact*pix.imag());
- slice->SetPixel(idx, newPix);
-
- from90 += dt;
- fromMaxEcho += dt;
- }
- return slice;
-}
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkSignalDecay.h b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkSignalDecay.h
deleted file mode 100644
index 495e6a41d6..0000000000
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkSignalDecay.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#ifndef _MITK_SignalDecay_H
-#define _MITK_SignalDecay_H
-
-#include <FiberTrackingExports.h>
-#include <mitkKspaceArtifact.h>
-#include <itkImageRegion.h>
-#include <itkImageRegionIterator.h>
-
-namespace mitk {
-
-/**
- * \brief Class to add gibbs ringing artifact to input complex slice
- *
- */
-template< class ScalarType >
-class SignalDecay : public KspaceArtifact< ScalarType >
-{
-public:
-
- SignalDecay();
- ~SignalDecay();
-
- typedef typename KspaceArtifact< ScalarType >::ComplexSliceType ComplexSliceType;
-
- /** Attenuate signal according to given relaxation times. **/
- typename ComplexSliceType::Pointer AddArtifact(typename ComplexSliceType::Pointer slice);
-
-protected:
-
-};
-
-#include "mitkSignalDecay.cpp"
-
-}
-
-#endif
-
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake b/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake
index b5d52ea256..affeb8469e 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake
@@ -1,7 +1,8 @@
SET(MODULE_CUSTOM_TESTS
mitkFiberBundleXReaderWriterTest.cpp
mitkFiberBundleXTest.cpp
mitkGibbsTrackingTest.cpp
+ mitkFiberProcessing.cpp
)
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberProcessing.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberProcessing.cpp
new file mode 100644
index 0000000000..866dc7b9fc
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberProcessing.cpp
@@ -0,0 +1,131 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkTestingMacros.h"
+
+#include <vector>
+#include <iostream>
+#include <fstream>
+#include <algorithm>
+#include <string>
+
+#include <itkImage.h>
+#include <itkImageFileReader.h>
+#include <itkExceptionObject.h>
+#include <itkImageFileWriter.h>
+#include <itkMetaDataObject.h>
+#include <itkVectorImage.h>
+#include <itkResampleImageFilter.h>
+
+#include <mitkBaseDataIOFactory.h>
+#include <mitkDiffusionImage.h>
+#include <mitkQBallImage.h>
+#include <mitkBaseData.h>
+#include <QmitkCommonFunctionality.h>
+#include <mitkDiffusionCoreObjectFactory.h>
+#include <mitkFiberTrackingObjectFactory.h>
+#include <mitkFiberBundleX.h>
+
+/**
+ * Short program to average redundant gradients in dwi-files
+ */
+
+mitk::FiberBundleX::Pointer LoadFib(std::string filename)
+{
+ const std::string s1="", s2="";
+ std::vector<mitk::BaseData::Pointer> fibInfile = mitk::BaseDataIO::LoadBaseDataFromFile( filename, s1, s2, false );
+ if( fibInfile.empty() )
+ MITK_INFO << "File " << filename << " could not be read!";
+
+ mitk::BaseData::Pointer baseData = fibInfile.at(0);
+ return dynamic_cast<mitk::FiberBundleX*>(baseData.GetPointer());
+}
+
+int mitkFiberProcessing(int argc, char* argv[])
+{
+ MITK_TEST_BEGIN("mitkFiberBundleXTest");
+
+ if ( argc<6 )
+ {
+ std::cout << argv[0] << " <input file> <point distance> <min. length threshold mm> <curvature threshold mm (radius)> <mirror SCT> <output file>" << std::endl;
+ std::cout << std::endl;
+ return EXIT_FAILURE;
+ }
+
+ try
+ {
+ RegisterDiffusionCoreObjectFactory();
+ RegisterFiberTrackingObjectFactory();
+
+ mitk::FiberBundleX::Pointer fib = LoadFib(argv[1]);
+ int pointDist = QString(argv[2]).toFloat();
+ float lenThres = QString(argv[3]).toFloat();
+ float curvThres = QString(argv[4]).toFloat();
+
+ std::string outfilename;
+ if (argc==7)
+ outfilename = argv[6];
+ else
+ outfilename = argv[1];
+
+ if (lenThres>0)
+ fib->RemoveShortFibers(lenThres);
+
+ if (curvThres>0)
+ fib->ApplyCurvatureThreshold(curvThres, false);
+
+ if (pointDist>0)
+ fib->ResampleFibers(pointDist);
+
+ int axis = QString(argv[5]).toInt();
+ if (axis/100==1)
+ fib->MirrorFibers(0);
+
+ if ((axis%100)/10==1)
+ fib->MirrorFibers(1);
+
+ if (axis%10==1)
+ fib->MirrorFibers(2);
+
+ mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
+ for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
+ {
+ if ( (*it)->CanWriteBaseDataType(fib.GetPointer()) ) {
+ MITK_INFO << "writing " << outfilename;
+ (*it)->SetFileName( outfilename.c_str() );
+ (*it)->DoWrite( fib.GetPointer() );
+ }
+ }
+ }
+ catch (itk::ExceptionObject e)
+ {
+ MITK_INFO << e;
+ return EXIT_FAILURE;
+ }
+ catch (std::exception e)
+ {
+ MITK_INFO << e.what();
+ return EXIT_FAILURE;
+ }
+ catch (...)
+ {
+ MITK_INFO << "ERROR!?!";
+ return EXIT_FAILURE;
+ }
+ MITK_INFO << "DONE";
+
+ MITK_TEST_END();
+}
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp
index 937e752d2a..85df7144a6 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp
@@ -1,99 +1,98 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkImageCast.h>
#include <mitkQBallImage.h>
#include <mitkBaseDataIOFactory.h>
#include <mitkFiberTrackingObjectFactory.h>
#include <mitkDiffusionCoreObjectFactory.h>
#include <itkGibbsTrackingFilter.h>
#include <mitkFiberBundleX.h>
using namespace mitk;
/**Documentation
* Test for gibbs tracking filter
*/
int mitkGibbsTrackingTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkGibbsTrackingTest");
MITK_TEST_CONDITION_REQUIRED(argc>4,"check for input data")
QBallImage::Pointer mitkQballImage;
Image::Pointer mitkMaskImage;
mitk::FiberBundleX::Pointer fib1;
try{
MITK_INFO << "Q-Ball image: " << argv[1];
MITK_INFO << "Mask image: " << argv[2];
MITK_INFO << "Parameter file: " << argv[3];
MITK_INFO << "Reference bundle: " << argv[4];
RegisterDiffusionCoreObjectFactory();
RegisterFiberTrackingObjectFactory();
- // test if fib1 can be read
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( argv[1], s1, s2, false );
mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.at(0).GetPointer());
MITK_TEST_CONDITION_REQUIRED(mitkQballImage.IsNotNull(),"check qball image")
infile = mitk::BaseDataIO::LoadBaseDataFromFile( argv[2], s1, s2, false );
mitkMaskImage = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
MITK_TEST_CONDITION_REQUIRED(mitkMaskImage.IsNotNull(),"check mask image")
infile = mitk::BaseDataIO::LoadBaseDataFromFile( argv[4], s1, s2, false );
fib1 = dynamic_cast<mitk::FiberBundleX*>(infile.at(0).GetPointer());
MITK_TEST_CONDITION_REQUIRED(fib1.IsNotNull(),"check fiber bundle")
typedef itk::Vector<float, QBALL_ODFSIZE> OdfVectorType;
typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
typedef itk::Image<float,3> MaskImgType;
typedef itk::GibbsTrackingFilter<OdfVectorImgType> GibbsTrackingFilterType;
OdfVectorImgType::Pointer itk_qbi = OdfVectorImgType::New();
mitk::CastToItkImage<OdfVectorImgType>(mitkQballImage, itk_qbi);
MaskImgType::Pointer itk_mask = MaskImgType::New();
mitk::CastToItkImage<MaskImgType>(mitkMaskImage, itk_mask);
GibbsTrackingFilterType::Pointer gibbsTracker = GibbsTrackingFilterType::New();
gibbsTracker->SetQBallImage(itk_qbi.GetPointer());
gibbsTracker->SetMaskImage(itk_mask);
gibbsTracker->SetDuplicateImage(false);
gibbsTracker->SetRandomSeed(1);
gibbsTracker->SetLoadParameterFile(argv[3]);
gibbsTracker->Update();
mitk::FiberBundleX::Pointer fib2 = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
MITK_TEST_CONDITION_REQUIRED(fib1->Equals(fib2), "check if gibbs tracking has changed");
gibbsTracker->SetRandomSeed(0);
gibbsTracker->Update();
fib2 = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
MITK_TEST_CONDITION_REQUIRED(!fib1->Equals(fib2), "check if gibbs tracking has changed after wrong seed");
}
catch(...)
{
return EXIT_FAILURE;
}
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/FiberTracking/files.cmake b/Modules/DiffusionImaging/FiberTracking/files.cmake
index dec7c0be87..912c88e510 100644
--- a/Modules/DiffusionImaging/FiberTracking/files.cmake
+++ b/Modules/DiffusionImaging/FiberTracking/files.cmake
@@ -1,100 +1,105 @@
set(CPP_FILES
-# DataStructures -> FiberBundleX
+ MiniApps/ctkCommandLineParser.h
+
+ # DataStructures -> FiberBundleX
IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
IODataStructures/FiberBundleX/mitkFiberBundleXWriter.cpp
IODataStructures/FiberBundleX/mitkFiberBundleXReader.cpp
IODataStructures/FiberBundleX/mitkFiberBundleXIOFactory.cpp
IODataStructures/FiberBundleX/mitkFiberBundleXWriterFactory.cpp
IODataStructures/FiberBundleX/mitkFiberBundleXSerializer.cpp
IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
# DataStructures -> PlanarFigureComposite
IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp
# DataStructures
IODataStructures/mitkFiberTrackingObjectFactory.cpp
# Rendering
Rendering/mitkFiberBundleXMapper2D.cpp
Rendering/mitkFiberBundleXMapper3D.cpp
Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
#Rendering/mitkPlanarFigureMapper3D.cpp
# Interactions
Interactions/mitkFiberBundleInteractor.cpp
- # Algorithms
- Algorithms/mitkTractAnalyzer.cpp
# Tractography
Algorithms/GibbsTracking/mitkParticleGrid.cpp
Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.cpp
Algorithms/GibbsTracking/mitkEnergyComputer.cpp
Algorithms/GibbsTracking/mitkGibbsEnergyComputer.cpp
Algorithms/GibbsTracking/mitkFiberBuilder.cpp
Algorithms/GibbsTracking/mitkSphereInterpolator.cpp
)
set(H_FILES
+ MiniApps/ctkCommandLineParser.h
+
# Rendering
Rendering/mitkFiberBundleXMapper3D.h
Rendering/mitkFiberBundleXMapper2D.h
Rendering/mitkFiberBundleXThreadMonitorMapper3D.h
#Rendering/mitkPlanarFigureMapper3D.h
# DataStructures -> FiberBundleX
IODataStructures/FiberBundleX/mitkFiberBundleX.h
IODataStructures/FiberBundleX/mitkFiberBundleXWriter.h
IODataStructures/FiberBundleX/mitkFiberBundleXReader.h
IODataStructures/FiberBundleX/mitkFiberBundleXIOFactory.h
IODataStructures/FiberBundleX/mitkFiberBundleXWriterFactory.h
IODataStructures/FiberBundleX/mitkFiberBundleXSerializer.h
IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
IODataStructures/mitkFiberTrackingObjectFactory.h
# Algorithms
Algorithms/itkTractDensityImageFilter.h
Algorithms/itkTractsToFiberEndingsImageFilter.h
Algorithms/itkTractsToRgbaImageFilter.h
Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
Algorithms/itkFibersFromPlanarFiguresFilter.h
Algorithms/itkTractsToDWIImageFilter.h
Algorithms/itkTractsToVectorImageFilter.h
+ Algorithms/itkKspaceImageFilter.h
+ Algorithms/itkDftImageFilter.h
+ Algorithms/itkAddArtifactsToDwiImageFilter.h
+ Algorithms/itkFieldmapGeneratorFilter.h
+ Algorithms/itkEvaluateDirectionImagesFilter.h
# (old) Tractography
Algorithms/itkGibbsTrackingFilter.h
Algorithms/itkStochasticTractographyFilter.h
Algorithms/itkStreamlineTrackingFilter.h
Algorithms/GibbsTracking/mitkParticle.h
Algorithms/GibbsTracking/mitkParticleGrid.h
Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.h
Algorithms/GibbsTracking/mitkSimpSamp.h
Algorithms/GibbsTracking/mitkEnergyComputer.h
Algorithms/GibbsTracking/mitkGibbsEnergyComputer.h
Algorithms/GibbsTracking/mitkSphereInterpolator.h
Algorithms/GibbsTracking/mitkFiberBuilder.h
# Signal Models
SignalModels/mitkDiffusionSignalModel.h
SignalModels/mitkTensorModel.h
SignalModels/mitkBallModel.h
SignalModels/mitkDotModel.h
SignalModels/mitkAstroStickModel.h
SignalModels/mitkStickModel.h
SignalModels/mitkDiffusionNoiseModel.h
SignalModels/mitkRicianNoiseModel.h
SignalModels/mitkKspaceArtifact.h
- SignalModels/mitkGibbsRingingArtifact.h
- SignalModels/mitkSignalDecay.h
)
set(RESOURCE_FILES
# Binary directory resources
FiberTrackingLUTBaryCoords.bin
FiberTrackingLUTIndices.bin
# Shaders
Shaders/mitkShaderFiberClipping.xml
)
diff --git a/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMLocalVariationImageFilter.h b/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMLocalVariationImageFilter.h
index ded47c327a..af2d0217c5 100644
--- a/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMLocalVariationImageFilter.h
+++ b/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMLocalVariationImageFilter.h
@@ -1,152 +1,152 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkRegularizedIVIMLocalVariationImageFilter_h
#define __itkRegularizedIVIMLocalVariationImageFilter_h
#include "itkImageToImageFilter.h"
#include "itkImage.h"
namespace itk
{
template<class TPixelType>
class IVIMSquaredEuclideanMetric
{
public:
static double Calc(TPixelType p)
{
return p*p;
}
};
template<>
class IVIMSquaredEuclideanMetric<itk::Vector<double,3> >
{
public:
static double Calc(itk::Vector<double,3> p)
{
return p[1]*p[1];
}
};
template<>
class IVIMSquaredEuclideanMetric<itk::VariableLengthVector<float> >
{
public:
static double Calc(itk::VariableLengthVector<float> p)
{
return p.GetSquaredNorm();
}
};
template<>
class IVIMSquaredEuclideanMetric<itk::VariableLengthVector<double> >
{
public:
static double Calc(itk::VariableLengthVector<double> p)
{
return p.GetSquaredNorm();
}
};
/** \class RegularizedIVIMLocalVariationImageFilter
* \brief Calculates the local variation in each pixel
*
* Reference: Tony F. Chan et al., The digital TV filter and nonlinear denoising
*
* \sa Image
* \sa Neighborhood
* \sa NeighborhoodOperator
* \sa NeighborhoodIterator
*
* \ingroup IntensityImageFilters
*/
template <class TInputImage, class TOutputImage>
class RegularizedIVIMLocalVariationImageFilter :
public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
/** Extract dimension from input and output image. */
itkStaticConstMacro(InputImageDimension, unsigned int,
TInputImage::ImageDimension);
itkStaticConstMacro(OutputImageDimension, unsigned int,
TOutputImage::ImageDimension);
/** Convenient typedefs for simplifying declarations. */
typedef TInputImage InputImageType;
typedef TOutputImage OutputImageType;
/** Standard class typedefs. */
typedef RegularizedIVIMLocalVariationImageFilter Self;
typedef ImageToImageFilter< InputImageType, OutputImageType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(RegularizedIVIMLocalVariationImageFilter, ImageToImageFilter);
/** Image typedef support. */
typedef typename InputImageType::PixelType InputPixelType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef typename OutputImageType::RegionType OutputImageRegionType;
typedef typename InputImageType::SizeType InputSizeType;
/** MedianImageFilter needs a larger input requested region than
* the output requested region. As such, MedianImageFilter needs
* to provide an implementation for GenerateInputRequestedRegion()
* in order to inform the pipeline execution model.
*
* \sa ImageToImageFilter::GenerateInputRequestedRegion() */
virtual void GenerateInputRequestedRegion()
throw(InvalidRequestedRegionError);
protected:
RegularizedIVIMLocalVariationImageFilter();
virtual ~RegularizedIVIMLocalVariationImageFilter() {}
void PrintSelf(std::ostream& os, Indent indent) const;
/** MedianImageFilter can be implemented as a multithreaded filter.
* Therefore, this implementation provides a ThreadedGenerateData()
* routine which is called for each processing thread. The output
* image data is allocated automatically by the superclass prior to
* calling ThreadedGenerateData(). ThreadedGenerateData can only
* write to the portion of the output image specified by the
* parameter "outputRegionForThread"
*
* \sa ImageToImageFilter::ThreadedGenerateData(),
* ImageToImageFilter::GenerateData() */
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId );
+ ThreadIdType threadId );
private:
RegularizedIVIMLocalVariationImageFilter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkRegularizedIVIMLocalVariationImageFilter.txx"
#endif
#endif //RegularizedIVIMLocalVariationImageFilter
diff --git a/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMLocalVariationImageFilter.txx b/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMLocalVariationImageFilter.txx
index 54acf9f02f..3acd73b82a 100644
--- a/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMLocalVariationImageFilter.txx
+++ b/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMLocalVariationImageFilter.txx
@@ -1,192 +1,192 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _itkRegularizedIVIMLocalVariationImageFilter_txx
#define _itkRegularizedIVIMLocalVariationImageFilter_txx
#include "itkConstShapedNeighborhoodIterator.h"
#include "itkNeighborhoodInnerProduct.h"
#include "itkImageRegionIterator.h"
#include "itkNeighborhoodAlgorithm.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
#include "itkOffset.h"
#include "itkProgressReporter.h"
#include "itkVectorImage.h"
#include <vector>
#include <algorithm>
namespace itk
{
template <class TInputImage, class TOutputImage>
RegularizedIVIMLocalVariationImageFilter<TInputImage, TOutputImage>
::RegularizedIVIMLocalVariationImageFilter()
{}
template <class TInputImage, class TOutputImage>
void
RegularizedIVIMLocalVariationImageFilter<TInputImage, TOutputImage>
::GenerateInputRequestedRegion() throw (InvalidRequestedRegionError)
{
// call the superclass' implementation of this method
Superclass::GenerateInputRequestedRegion();
// get pointers to the input and output
typename Superclass::InputImagePointer inputPtr =
const_cast< TInputImage * >( this->GetInput() );
typename Superclass::OutputImagePointer outputPtr = this->GetOutput();
if ( !inputPtr || !outputPtr )
{
return;
}
// get a copy of the input requested region (should equal the output
// requested region)
typename TInputImage::RegionType inputRequestedRegion;
inputRequestedRegion = inputPtr->GetRequestedRegion();
// pad the input requested region by 1
inputRequestedRegion.PadByRadius( 1 );
// crop the input requested region at the input's largest possible region
if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) )
{
inputPtr->SetRequestedRegion( inputRequestedRegion );
return;
}
else
{
// Couldn't crop the region (requested region is outside the largest
// possible region). Throw an exception.
// store what we tried to request (prior to trying to crop)
inputPtr->SetRequestedRegion( inputRequestedRegion );
// build an exception
InvalidRequestedRegionError e(__FILE__, __LINE__);
e.SetLocation(ITK_LOCATION);
e.SetDescription("Requested region outside possible region.");
e.SetDataObject(inputPtr);
throw e;
}
}
template< class TInputImage, class TOutputImage>
void
RegularizedIVIMLocalVariationImageFilter< TInputImage, TOutputImage>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId)
+ ThreadIdType threadId)
{
// Allocate output
typename OutputImageType::Pointer output = this->GetOutput();
typename InputImageType::ConstPointer input = this->GetInput();
itk::Size<InputImageDimension> size;
for( int i=0; i<InputImageDimension; i++)
size[i] = 1;
// Find the data-set boundary "faces"
NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<InputImageType> bC;
typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType
faceList = bC(input, outputRegionForThread, size);
// support progress methods/callbacks
ProgressReporter progress(
this, threadId, outputRegionForThread.GetNumberOfPixels());
ZeroFluxNeumannBoundaryCondition<InputImageType> nbc;
std::vector<InputPixelType> pixels;
// Process each of the boundary faces. These are N-d regions which border
// the edge of the buffer.
for ( typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType::iterator
fit=faceList.begin(); fit != faceList.end(); ++fit)
{
// iterators over output and input
ImageRegionIterator<OutputImageType>
output_image_it(output, *fit);
ImageRegionConstIterator<InputImageType>
input_image_it(input.GetPointer(), *fit);
// neighborhood iterator for input image
ConstShapedNeighborhoodIterator<InputImageType>
input_image_neighbors_it(size, input, *fit);
typename ConstShapedNeighborhoodIterator<InputImageType>::
OffsetType offset;
input_image_neighbors_it.OverrideBoundaryCondition(&nbc);
input_image_neighbors_it.ClearActiveList();
for(int i=0; i<InputImageDimension; i++)
{
offset.Fill(0);
offset[i] = -1;
input_image_neighbors_it.ActivateOffset(offset);
offset[i] = 1;
input_image_neighbors_it.ActivateOffset(offset);
}
input_image_neighbors_it.GoToBegin();
//const unsigned int neighborhoodSize = InputImageDimension*2;
while ( ! input_image_neighbors_it.IsAtEnd() )
{
// collect all the pixels in the neighborhood, note that we use
// GetPixel on the NeighborhoodIterator to honor the boundary conditions
typename OutputImageType::PixelType locVariation = 0;
typename ConstShapedNeighborhoodIterator<InputImageType>::
ConstIterator input_neighbors_it;
for (input_neighbors_it = input_image_neighbors_it.Begin();
! input_neighbors_it.IsAtEnd();
input_neighbors_it++)
{
typename TInputImage::PixelType diffVec =
input_neighbors_it.Get()-input_image_it.Get();
locVariation += IVIMSquaredEuclideanMetric
<typename TInputImage::PixelType>::Calc(diffVec);
}
locVariation = sqrt(locVariation + 0.0001);
output_image_it.Set(locVariation);
// update iterators
++input_image_neighbors_it;
++output_image_it;
++input_image_it;
// report progress
progress.CompletedPixel();
}
}
}
/**
* Standard "PrintSelf" method
*/
template <class TInputImage, class TOutput>
void
RegularizedIVIMLocalVariationImageFilter<TInputImage, TOutput>
::PrintSelf(
std::ostream& os,
Indent indent) const
{
Superclass::PrintSelf( os, indent );
}
} // end namespace itk
#endif //_itkRegularizedIVIMLocalVariationImageFilter_txx
diff --git a/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMReconstructionSingleIteration.h b/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMReconstructionSingleIteration.h
index 42701e4c20..3e5dbc7faf 100644
--- a/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMReconstructionSingleIteration.h
+++ b/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMReconstructionSingleIteration.h
@@ -1,141 +1,141 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkRegularizedIVIMReconstructionSingleIteration_h
#define __itkRegularizedIVIMReconstructionSingleIteration_h
#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "itkVectorImage.h"
namespace itk
{
/** \class RegularizedIVIMReconstructionSingleIteration
* \brief Applies a total variation denoising filter to an image
*
* Reference: Tony F. Chan et al., The digital TV filter and nonlinear denoising
*
* \sa Image
* \sa Neighborhood
* \sa NeighborhoodOperator
* \sa NeighborhoodIterator
*
* \ingroup IntensityImageFilters
*/
template <class TInputPixel, class TOutputPixel, class TRefPixelType>
class RegularizedIVIMReconstructionSingleIteration :
public ImageToImageFilter< itk::Image<itk::Vector<TInputPixel,3>, 3>, itk::Image<itk::Vector<TOutputPixel,3>, 3> >
{
public:
/** Convenient typedefs for simplifying declarations. */
typedef itk::Image<itk::Vector<TInputPixel,3>, 3> InputImageType;
typedef itk::Image<itk::Vector<TOutputPixel,3>, 3> OutputImageType;
typedef itk::VectorImage<TRefPixelType,3> RefImageType;
/** Extract dimension from input and output image. */
itkStaticConstMacro(InputImageDimension, unsigned int,
InputImageType::ImageDimension);
itkStaticConstMacro(OutputImageDimension, unsigned int,
OutputImageType::ImageDimension);
typedef itk::Image<float,InputImageDimension> LocalVariationImageType;
/** Standard class typedefs. */
typedef RegularizedIVIMReconstructionSingleIteration Self;
typedef ImageToImageFilter< InputImageType, OutputImageType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(RegularizedIVIMReconstructionSingleIteration, ImageToImageFilter);
/** Image typedef support. */
typedef typename InputImageType::PixelType InputPixelType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef typename OutputImageType::RegionType OutputImageRegionType;
typedef typename InputImageType::SizeType InputSizeType;
/** A larger input requested region than
* the output requested region is required.
* Therefore, an implementation for GenerateInputRequestedRegion()
* is provided.
*
* \sa ImageToImageFilter::GenerateInputRequestedRegion() */
virtual void GenerateInputRequestedRegion()
throw(InvalidRequestedRegionError);
itkSetMacro(Lambda, double);
itkGetMacro(Lambda, double);
void SetBValues(vnl_vector<double> bvals)
{ this->m_BValues = bvals; }
vnl_vector<double> GetBValues()
{ return this->m_BValues; }
void SetOriginalImage(RefImageType* in)
{ this->m_OriginalImage = in; }
typename RefImageType::Pointer GetOriginialImage()
{ return this->m_OriginalImage; }
protected:
RegularizedIVIMReconstructionSingleIteration();
virtual ~RegularizedIVIMReconstructionSingleIteration() {}
void PrintSelf(std::ostream& os, Indent indent) const;
/** MedianImageFilter can be implemented as a multithreaded filter.
* Therefore, this implementation provides a ThreadedGenerateData()
* routine which is called for each processing thread. The output
* image data is allocated automatically by the superclass prior to
* calling ThreadedGenerateData(). ThreadedGenerateData can only
* write to the portion of the output image specified by the
* parameter "outputRegionForThread"
*
* \sa ImageToImageFilter::ThreadedGenerateData(),
* ImageToImageFilter::GenerateData() */
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId );
+ ThreadIdType threadId );
void BeforeThreadedGenerateData();
typename LocalVariationImageType::Pointer m_LocalVariation;
typename RefImageType::Pointer m_OriginalImage;
double m_Lambda;
vnl_vector<double> m_BValues;
private:
RegularizedIVIMReconstructionSingleIteration(const Self&);
void operator=(const Self&);
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkRegularizedIVIMReconstructionSingleIteration.txx"
#endif
#endif //__itkRegularizedIVIMReconstructionSingleIteration__
diff --git a/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMReconstructionSingleIteration.txx b/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMReconstructionSingleIteration.txx
index 09d0e5d527..adc1d08ac1 100644
--- a/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMReconstructionSingleIteration.txx
+++ b/Modules/DiffusionImaging/Quantification/Algorithms/itkRegularizedIVIMReconstructionSingleIteration.txx
@@ -1,310 +1,310 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _itkRegularizedIVIMReconstructionSingleIteration_txx
#define _itkRegularizedIVIMReconstructionSingleIteration_txx
// itk includes
#include "itkConstShapedNeighborhoodIterator.h"
#include "itkNeighborhoodInnerProduct.h"
#include "itkImageRegionIterator.h"
#include "itkNeighborhoodAlgorithm.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
#include "itkOffset.h"
#include "itkProgressReporter.h"
#include "itkRegularizedIVIMLocalVariationImageFilter.h"
// other includes
#include <vector>
#include <algorithm>
#define IVIM_FOO -100000
namespace itk
{
/**
* constructor
*/
template <class TInputPixel, class TOutputPixel, class TRefPixelType>
RegularizedIVIMReconstructionSingleIteration<TInputPixel, TOutputPixel, TRefPixelType>
::RegularizedIVIMReconstructionSingleIteration()
{
m_Lambda = 1.0;
m_LocalVariation = LocalVariationImageType::New();
}
/**
* generate requested region
*/
template <class TInputPixel, class TOutputPixel, class TRefPixelType>
void
RegularizedIVIMReconstructionSingleIteration<TInputPixel, TOutputPixel, TRefPixelType>
::GenerateInputRequestedRegion() throw (InvalidRequestedRegionError)
{
// call the superclass' implementation of this method
Superclass::GenerateInputRequestedRegion();
// get pointers to the input and output
typename Superclass::InputImagePointer inputPtr =
const_cast< InputImageType * >( this->GetInput() );
typename Superclass::OutputImagePointer outputPtr = this->GetOutput();
if ( !inputPtr || !outputPtr )
{
return;
}
// get a copy of the input requested region (should equal the output
// requested region)
typename InputImageType::RegionType inputRequestedRegion;
inputRequestedRegion = inputPtr->GetRequestedRegion();
// pad the input requested region by 1
inputRequestedRegion.PadByRadius( 1 );
// crop the input requested region at the input's largest possible region
if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) )
{
inputPtr->SetRequestedRegion( inputRequestedRegion );
return;
}
else
{
// Couldn't crop the region (requested region is outside the largest
// possible region). Throw an exception.
// store what we tried to request (prior to trying to crop)
inputPtr->SetRequestedRegion( inputRequestedRegion );
// build an exception
InvalidRequestedRegionError e(__FILE__, __LINE__);
e.SetLocation(ITK_LOCATION);
e.SetDescription("Requested region outside possible region.");
e.SetDataObject(inputPtr);
throw e;
}
}
/**
* generate output
*/
template <class TInputPixel, class TOutputPixel, class TRefPixelType>
void
RegularizedIVIMReconstructionSingleIteration<TInputPixel, TOutputPixel, TRefPixelType>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- int threadId)
+ ThreadIdType)
{
typename OutputImageType::Pointer output = this->GetOutput();
typename InputImageType::ConstPointer input = this->GetInput();
// Find the data-set boundary "faces"
itk::Size<InputImageDimension> size;
for( int i=0; i<InputImageDimension; i++)
size[i] = 1;
NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<InputImageType> bC;
typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType
faceList = bC(input, outputRegionForThread, size);
NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<LocalVariationImageType> lv_bC;
typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<LocalVariationImageType>::FaceListType
lv_faceList = lv_bC(m_LocalVariation, outputRegionForThread, size);
ZeroFluxNeumannBoundaryCondition<InputImageType> nbc;
ZeroFluxNeumannBoundaryCondition<LocalVariationImageType> lv_nbc;
std::vector<double> ws;
std::vector<double> hs;
typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType::iterator
lv_fit=lv_faceList.begin();
// Process each of the boundary faces. These are N-d regions which border
// the edge of the buffer.
for ( typename NeighborhoodAlgorithm::
ImageBoundaryFacesCalculator<InputImageType>::FaceListType::iterator
fit=faceList.begin(); fit != faceList.end(); ++fit)
{
// iterators over output, input, original and local variation image
ImageRegionIterator<OutputImageType> output_image_it =
ImageRegionIterator<OutputImageType>(output, *fit);
ImageRegionConstIterator<InputImageType> input_image_it =
ImageRegionConstIterator<InputImageType>(input, *fit);
ImageRegionConstIterator<RefImageType> orig_image_it =
ImageRegionConstIterator<RefImageType>(m_OriginalImage, *fit);
ImageRegionConstIterator<LocalVariationImageType> loc_var_image_it =
ImageRegionConstIterator<LocalVariationImageType>(
m_LocalVariation, *fit);
// neighborhood in input image
ConstShapedNeighborhoodIterator<InputImageType>
input_image_neighbors_it(size, input, *fit);
typename ConstShapedNeighborhoodIterator<InputImageType>::
OffsetType offset;
input_image_neighbors_it.OverrideBoundaryCondition(&nbc);
input_image_neighbors_it.ClearActiveList();
for(int i=0; i<InputImageDimension; i++)
{
offset.Fill(0);
offset[i] = -1;
input_image_neighbors_it.ActivateOffset(offset);
offset[i] = 1;
input_image_neighbors_it.ActivateOffset(offset);
}
input_image_neighbors_it.GoToBegin();
// neighborhood in local variation image
ConstShapedNeighborhoodIterator<LocalVariationImageType>
loc_var_image_neighbors_it(size, m_LocalVariation, *lv_fit);
loc_var_image_neighbors_it.OverrideBoundaryCondition(&lv_nbc);
loc_var_image_neighbors_it.ClearActiveList();
for(int i=0; i<InputImageDimension; i++)
{
offset.Fill(0);
offset[i] = -1;
loc_var_image_neighbors_it.ActivateOffset(offset);
offset[i] = 1;
loc_var_image_neighbors_it.ActivateOffset(offset);
}
loc_var_image_neighbors_it.GoToBegin();
const unsigned int neighborhoodSize = InputImageDimension*2;
ws.resize(neighborhoodSize);
while ( ! output_image_it.IsAtEnd() )
{
//MITK_INFO << "looking at voxel " << output_image_it.GetIndex();
// 1 / ||nabla_alpha(u)||_a
double locvar_alpha_inv = 1.0/loc_var_image_it.Get();
//MITK_INFO << "locvar: " << loc_var_image_it.Get();
// compute w_alphabetas
int count = 0;
double wsum = 0;
typename ConstShapedNeighborhoodIterator<LocalVariationImageType>::
ConstIterator loc_var_neighbors_it;
for (loc_var_neighbors_it = loc_var_image_neighbors_it.Begin();
! loc_var_neighbors_it.IsAtEnd();
loc_var_neighbors_it++)
{
// w_alphabeta(u) =
// 1 / ||nabla_alpha(u)||_a + 1 / ||nabla_beta(u)||_a
ws[count] =
locvar_alpha_inv + (1.0/(double)loc_var_neighbors_it.Get());
wsum += ws[count++];
//MITK_INFO << "nb var: " << count << ": " << loc_var_neighbors_it.Get();
}
//MITK_INFO << "wsum: " << wsum;
// h_alphaalpha * u_alpha^zero
typename RefImageType::PixelType orig = orig_image_it.Get();
// vnl_vector<double> estim(orig.GetSize());
// vnl_matrix<double> diff(orig.GetSize(),1);
// vnl_matrix<double> estimdash(orig.GetSize(),2);
vnl_vector_fixed<double,2> step;
step[0] = 0; step[1]=0;
- for(int ind=0; ind<m_BValues.size(); ind++)
+ for(size_t ind=0; ind<m_BValues.size(); ind++)
{
//MITK_INFO << "refval: " << orig[ind];
double estim = (1-input_image_it.Get()[0])*exp(-m_BValues[ind]*input_image_it.Get()[1]);
double estimdash1 = exp(-m_BValues[ind]*input_image_it.Get()[1]);
double estimdash2 = (-1.0) * (1.0-input_image_it.Get()[0]) * m_BValues[ind] * exp(-m_BValues[ind]*input_image_it.Get()[1]);
//MITK_INFO << "estimdash1: " << estimdash1 << "; estimdash2: " << estimdash2 << "; diff: " << (double) orig[ind] - estim;
if(orig[ind] != IVIM_FOO)
{
step[0] += ((double) orig[ind] - estim) * estimdash2;
step[1] += ((double) orig[ind] - estim) * estimdash1;
}
}
step[1] *= m_Lambda / (m_Lambda+wsum);
// add the different h_alphabeta * u_beta
count = 0;
typename ConstShapedNeighborhoodIterator<InputImageType>::
ConstIterator input_neighbors_it;
for (input_neighbors_it = input_image_neighbors_it.Begin();
! input_neighbors_it.IsAtEnd();
input_neighbors_it++)
{
step[1] += (input_neighbors_it.Get()[1] - input_image_it.Get()[1]) * (ws[count++] / (m_Lambda+wsum));
}
//MITK_INFO << "stepfinal: " << step[0] << "; " << step[1];
// set output result
OutputPixelType out;
out[0] = input_image_it.Get()[0] + .001*step[0];
out[1] = input_image_it.Get()[1] + .00001*step[1];
output_image_it.Set( out );
//MITK_INFO << "(" << input_image_it.Get()[0] << " ; " << input_image_it.Get()[1] << ") => (" << out[0] << " ; " << out[1] << ")";
// increment iterators
++output_image_it;
++input_image_it;
++orig_image_it;
++loc_var_image_it;
++input_image_neighbors_it;
++loc_var_image_neighbors_it;
}
++lv_fit;
}
}
/**
* first calculate local variation in the image
*/
template <class TInputPixel, class TOutputPixel, class TRefPixelType>
void
RegularizedIVIMReconstructionSingleIteration<TInputPixel, TOutputPixel, TRefPixelType>
::BeforeThreadedGenerateData()
{
typedef typename itk::RegularizedIVIMLocalVariationImageFilter
<InputImageType,LocalVariationImageType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(this->GetInput(0));
filter->SetNumberOfThreads(this->GetNumberOfThreads());
filter->Update();
this->m_LocalVariation = filter->GetOutput();
}
/**
* Standard "PrintSelf" method
*/
template <class TInputPixel, class TOutputPixel, class TRefPixelType>
void
RegularizedIVIMReconstructionSingleIteration<TInputPixel, TOutputPixel, TRefPixelType>
::PrintSelf(
std::ostream& os,
Indent indent) const
{
Superclass::PrintSelf( os, indent );
}
} // end namespace itk
#endif
diff --git a/Modules/DiffusionImaging/Quantification/Algorithms/itkSkeletonizationFilter.h b/Modules/DiffusionImaging/Quantification/Algorithms/itkSkeletonizationFilter.h
index e6b561abef..9a46f4f167 100644
--- a/Modules/DiffusionImaging/Quantification/Algorithms/itkSkeletonizationFilter.h
+++ b/Modules/DiffusionImaging/Quantification/Algorithms/itkSkeletonizationFilter.h
@@ -1,119 +1,115 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef ITKSKELETONIZATIONFILTER_H_
#define ITKSKELETONIZATIONFILTER_H_
#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "mitkImage.h"
#include <itkVectorImage.h>
namespace itk
{
-template < class TInputImage, class TOutputImage >
-class SkeletonizationFilter : public ImageToImageFilter<TInputImage, TOutputImage>
-{
- /*!
- \brief itkSkeletonizationFilter
- \brief Skeletonization algorithm from TBSS (Smith et al. 2006)
+/**
+ * \brief Skeletonization part of the TBSS pipeline
+ *
+ * This class takes a 3D image (typically the mean FA image as calculated in the standard TBSS pipeline)
+ * and performs the non-maximum-suppression (see Smith et al., 2009. http://dx.doi.org/10.1016/j.neuroimage.2006.02.024 )
+ */
- \sa itkImageToImageFilter
+template < class TInputImage, class TOutputImage >
+class SkeletonizationFilter : public ImageToImageFilter<TInputImage, TOutputImage>
+{
- */
public:
/** Typedef for input ImageType. */
typedef TInputImage InputImageType;
typedef itk::CovariantVector<int,3> VectorType;
typedef itk::Image<VectorType, 3> VectorImageType;
/** Typedef for output ImageType. */
typedef TOutputImage OutputImageType;
typedef itk::VectorImage<int, 3> GradientImageType;
/** */
typedef SkeletonizationFilter Self;
/** Superclass */
typedef ImageToImageFilter<InputImageType, OutputImageType> Superclass;
- /** Smart Pointer */
typedef SmartPointer<Self> Pointer;
- /** Smart Pointer */
typedef SmartPointer<const Self> ConstPointer;
- /** */
- itkNewMacro( Self);
+ itkNewMacro( Self)
- /** Generate Data. The image will be divided into a number of pieces, a number of threads
- will be spawned and Threaded GenerateData() will be called in each thread. */
+ /** \brief Performs the work */
virtual void GenerateData();
+ /** \brief Output the gradient image as itkVectorImage
+ *
+ * Output the gradient image by first converting it to an itk vector image
+ */
GradientImageType::Pointer GetGradientImage();
+ /** \brief Output the gradient image as an itkImage containing vector */
VectorImageType::Pointer GetVectorImage()
{
return m_DirectionImage;
}
protected:
- /** Constructor */
SkeletonizationFilter();
- /** Destructor */
virtual ~SkeletonizationFilter();
- void CalculatePerpendicularDirections();
-
VectorImageType::Pointer m_DirectionImage;
- //FloatVectorImageType::Pointer m_FixedDirImage;
-
int round(float x)
{
if (x>0.0) return ((int) (x+0.5));
else return ((int) (x-0.5));
}
protected:
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkSkeletonizationFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/Quantification/Algorithms/itkSkeletonizationFilter.txx b/Modules/DiffusionImaging/Quantification/Algorithms/itkSkeletonizationFilter.txx
index faf739e00f..f42a3bcaf8 100644
--- a/Modules/DiffusionImaging/Quantification/Algorithms/itkSkeletonizationFilter.txx
+++ b/Modules/DiffusionImaging/Quantification/Algorithms/itkSkeletonizationFilter.txx
@@ -1,312 +1,306 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _itkSkeletonizationFilter_txx
#define _itkSkeletonizationFilter_txx
#include "itkSkeletonizationFilter.h"
#include "mitkProgressBar.h"
#include <limits>
#include <time.h>
namespace itk
{
template< class TInputImage, class TOutputImage >
SkeletonizationFilter<TInputImage, TOutputImage>::SkeletonizationFilter()
{
m_DirectionImage = VectorImageType::New();
}
template< class TInputImage, class TOutputImage >
SkeletonizationFilter<TInputImage, TOutputImage>::~SkeletonizationFilter()
{
}
template< class TInputImage, class TOutputImage >
void SkeletonizationFilter<TInputImage, TOutputImage>::GenerateData()
{
//----------------------------------------------------------------------//
// Progress bar //
//----------------------------------------------------------------------//
mitk::ProgressBar::GetInstance()->AddStepsToDo( 3 );
std::cout << "Skeletonize" << std::endl;
- CalculatePerpendicularDirections();
- }
-
- template< class TInputImage, class TOutputImage >
- void SkeletonizationFilter<TInputImage, TOutputImage>::CalculatePerpendicularDirections()
- {
-
const InputImageType* faImage = this->GetInput();
typename InputImageType::SizeType size = faImage->GetRequestedRegion().GetSize();
//typename RealImageType::SizeType size = m_FaImage->GetRequestedRegion().GetSize();
m_DirectionImage->SetRegions(faImage->GetRequestedRegion());
m_DirectionImage->SetDirection(faImage->GetDirection());
m_DirectionImage->SetSpacing(faImage->GetSpacing());
m_DirectionImage->SetOrigin(faImage->GetOrigin());
m_DirectionImage->Allocate();
m_DirectionImage->FillBuffer(0.0);
for(int z=1; z<size[2]-1; z++) for(int y=1; y<size[1]-1; y++) for(int x=1; x<size[0]-1; x++)
{
typename InputImageType::IndexType ix;
ix[0]=x; ix[1]=y; ix[2]=z;
float theval = faImage->GetPixel(ix);
if(theval != 0)
{
/* Calculate point of gravity. We will consider each 3x3x3 neighbourhood as a unit cube. The center
* point of each voxel will be a multiplicative of 1/6. The center of the unit cube is 3/6 = 1/2/
*/
float cogX = 0.0; float cogY = 0.0; float cogZ = 0.0; float sum = 0.0; float l;
int vecX = 0; int vecY = 0; int vecZ = 0;
for(int dz=-1; dz<=1; dz++) for(int dy=-1; dy<=1; dy++) for(int dx=-1; dx<=1;dx++)
{
typename InputImageType::IndexType p;
p[0] = x+dx; p[1] = y+dy; p[2] = z+dz;
float mass = faImage->GetPixel(p);
sum += mass;
cogX += (float)dx*mass; cogY += (float)dy*mass; cogZ += (float)dz*mass;
}
cogX /= sum; cogY /= sum; cogZ /= sum;
l = sqrt(cogX*cogX + cogY*cogY + cogZ*cogZ);
if (l > 0.1) /* is CofG far enough away from centre voxel? */
{
vecX = std::max(std::min(round(cogX/l),1),-1);
vecY = std::max(std::min(round(cogY/l),1),-1);
vecZ = std::max(std::min(round(cogZ/l),1),-1);
}
else
// Find direction of max curvature
{
float maxcost=0, centreval=2*theval;
for(int zz=0; zz<=1; zz++) // note - starts at zero as we're only searching half the voxels
{
for(int yy=-1; yy<=1; yy++)
{
for(int xx=-1; xx<=1; xx++)
{
if ( (zz==1) || (yy==1) || ((yy==0)&&(xx==1)) )
{
float weighting = pow( (float)(xx*xx+yy*yy+zz*zz) , (float)-0.7 ); // power is arbitrary: maybe test other functions here
typename InputImageType::IndexType i,j;
i[0] = x+xx; i[1] = y+yy; i[2] = z+zz;
j[0] = x-xx; j[1] = y-yy; j[2] = z-zz;
float cost = weighting * ( centreval
- (float)faImage->GetPixel(i)
- (float)faImage->GetPixel(j));
if (cost>maxcost)
{
maxcost=cost;
vecX=xx;
vecY=yy;
vecZ=zz;
}
}
}
}
}
}
VectorType vec;
vec[0] = vecX; vec[1] = vecY; vec[2]=vecZ;
m_DirectionImage->SetPixel(ix, vec);
}
}
mitk::ProgressBar::GetInstance()->Progress();
// Smooth m_DirectionImage and store in directionSmoothed by finding the
// mode in a 3*3 neighbourhoud
VectorImageType::Pointer directionSmoothed = VectorImageType::New();
directionSmoothed->SetRegions(faImage->GetRequestedRegion());
directionSmoothed->SetDirection(faImage->GetDirection());
directionSmoothed->SetSpacing(faImage->GetSpacing());
directionSmoothed->SetOrigin(faImage->GetOrigin());
directionSmoothed->Allocate();
VectorImageType::PixelType p;
p[0]=0; p[1]=0; p[2]=0;
directionSmoothed->FillBuffer(p);
for(int z=1; z<size[2]-1; z++) for(int y=1; y<size[1]-1; y++) for(int x=1; x<size[0]-1; x++)
{
VectorImageType::IndexType ix;
ix[0]=x; ix[1]=y; ix[2]=z;
// Find the vector that occured most
int* localsum = new int[27];
int localmax=0, xxx, yyy, zzz;
for(int zz=0; zz<27; zz++) localsum[zz]=0;
for(int zz=-1; zz<=1; zz++) for(int yy=-1; yy<=1; yy++) for(int xx=-1; xx<=1; xx++)
{
VectorImageType::IndexType i;
i[0] = x+xx; i[1] = y+yy; i[2] = z+zz;
VectorType v = m_DirectionImage->GetPixel(i);
xxx = v[0];
yyy = v[1];
zzz = v[2];
localsum[(1+zzz)*9+(1+yyy)*3+1+xxx]++;
localsum[(1-zzz)*9+(1-yyy)*3+1-xxx]++;
}
for(int zz=-1; zz<=1; zz++) for(int yy=-1; yy<=1; yy++) for(int xx=-1; xx<=1; xx++)
{
if (localsum[(1+zz)*9+(1+yy)*3+1+xx]>localmax)
{
localmax=localsum[(1+zz)*9+(1+yy)*3+1+xx];
VectorType v;
v[0] = xx; v[1] = yy; v[2] = zz;
directionSmoothed->SetPixel(ix, v);
}
}
delete localsum;
}
m_DirectionImage = directionSmoothed;
mitk::ProgressBar::GetInstance()->Progress();
// Do non-max-suppression in the direction of perp and set as output of the filter
typename OutputImageType::Pointer outputImg = OutputImageType::New();
outputImg->SetRegions(faImage->GetRequestedRegion());
outputImg->SetDirection(faImage->GetDirection());
outputImg->SetSpacing(faImage->GetSpacing());
outputImg->SetOrigin(faImage->GetOrigin());
outputImg->Allocate();
outputImg->FillBuffer(0.0);
for(int z=1; z<size[2]-1; z++) for(int y=1; y<size[1]-1; y++) for(int x=1; x<size[0]-1; x++)
{
typename InputImageType::IndexType ix;
ix[0]=x; ix[1]=y; ix[2]=z;
float theval = faImage->GetPixel(ix);
VectorType v = directionSmoothed->GetPixel(ix);
typename VectorImageType::IndexType i;
i[0] = x-v[0]; i[1] = y-v[1]; i[2] = z-v[2];
float min = faImage->GetPixel(i);
i[0] = x+v[0]; i[1] = y+v[1]; i[2] = z+v[2];
float plus = faImage->GetPixel(i);
i[0] = x-2*v[0]; i[1] = y-2*v[1]; i[2] = z-2*v[2];
float minmin = faImage->GetPixel(i);
i[0] = x+2*v[0]; i[1] = y+2*v[1]; i[2] = z+2*v[2];
float plusplus = faImage->GetPixel(i);
if( ((v[0]!=0) || (v[1]!=0) || (v[2]!=0)) &&
theval >= plus && theval > min && theval >= plusplus && theval > minmin )
{
outputImg->SetPixel(ix, theval);
}
}
Superclass::SetNthOutput( 0, outputImg );
mitk::ProgressBar::GetInstance()->Progress();
-
}
+
+ // Can provide a vector image to visualize the gradient image used in the search for local maxima.
template< class TInputImage, class TOutputImage >
itk::VectorImage<int, 3>::Pointer SkeletonizationFilter<TInputImage, TOutputImage>::GetGradientImage()
{
GradientImageType::Pointer gradImg = GradientImageType::New();
if(m_DirectionImage.IsNotNull())
{
gradImg->SetSpacing(m_DirectionImage->GetSpacing());
gradImg->SetOrigin(m_DirectionImage->GetOrigin());
gradImg->SetDirection(m_DirectionImage->GetDirection());
gradImg->SetRegions(m_DirectionImage->GetLargestPossibleRegion().GetSize());
gradImg->SetVectorLength(3);
gradImg->Allocate();
VectorImageType::SizeType size = m_DirectionImage->GetLargestPossibleRegion().GetSize();
for(int i=0; i<size[0]; i++)
{
for(int j=0; j<size[1]; j++)
{
for(int k=0; k<size[2]; k++)
{
itk::Index<3> ix;
ix[0] = i;
ix[1] = j;
ix[2] = k;
VectorType vec = m_DirectionImage->GetPixel(ix);
itk::VariableLengthVector<int> pixel;
pixel.SetSize(3);
pixel.SetElement(0, vec.GetElement(0));
pixel.SetElement(1, vec.GetElement(1));
pixel.SetElement(2, vec.GetElement(2));
gradImg->SetPixel(ix, pixel);
}
}
}
}
return gradImg;
}
}
#endif // _itkSkeletonizationFilter_txx
diff --git a/Modules/DiffusionImaging/Quantification/Algorithms/mitkTractAnalyzer.cpp b/Modules/DiffusionImaging/Quantification/Algorithms/mitkTractAnalyzer.cpp
new file mode 100644
index 0000000000..7c408361cc
--- /dev/null
+++ b/Modules/DiffusionImaging/Quantification/Algorithms/mitkTractAnalyzer.cpp
@@ -0,0 +1,209 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __mitkTractAnalyzer_cpp
+#define __mitkTractAnalyzer_cpp
+
+
+#include <mitkProgressBar.h>
+#include <mitkLogMacros.h>
+#include <mitkTractAnalyzer.h>
+
+#include <itkImageRegionIteratorWithIndex.h>
+
+
+#include <itkShortestPathCostFunctionTbss.h>
+#include <itkShortestPathImageFilter.h>
+
+#include <iostream>
+#include <fstream>
+
+
+#include <QMessageBox>
+
+
+
+using namespace std;
+
+namespace mitk {
+
+ TractAnalyzer::TractAnalyzer() { }
+
+
+ void TractAnalyzer::MakeRoi()
+ {
+
+ int n = 0;
+ if(m_PointSetNode.IsNotNull())
+ {
+ n = m_PointSetNode->GetSize();
+ if(n==0)
+ {
+ QMessageBox msgBox;
+ msgBox.setText("No points have been set yet.");
+ msgBox.exec();
+ }
+ }
+ else{
+ QMessageBox msgBox;
+ msgBox.setText("No points have been set yet.");
+ msgBox.exec();
+ }
+
+ std::string pathDescription = "";
+ std::vector< itk::Index<3> > totalPath;
+
+ if(n>0)
+ {
+ for(int i=0; i<n-1; ++i)
+ {
+
+ mitk::ProgressBar::GetInstance()->Progress();
+
+ mitk::Point3D p = m_PointSetNode->GetPoint(i);
+ mitk::Point3D p2 = m_PointSetNode->GetPoint(i+1);
+
+
+ itk::Index<3> startPoint;
+ itk::Index<3> endPoint;
+
+ m_InputImage->GetGeometry()->WorldToIndex(p,startPoint);
+ m_InputImage->GetGeometry()->WorldToIndex(p2,endPoint);
+
+ MITK_INFO << "create roi";
+
+ std::vector< itk::Index<3> > path = CreateSegment(startPoint, endPoint);
+
+ for(std::vector< itk::Index<3> >::iterator it = path.begin();
+ it != path.end(); it++)
+ {
+ itk::Index<3> ix = *it;
+
+ if (!(ix==endPoint))
+ {
+ mitk::ProgressBar::GetInstance()->Progress();
+
+ totalPath.push_back(ix);
+ std::stringstream ss;
+ ss << ix[0] << " " << ix[1] << " " << ix[2] << "\n";
+ pathDescription += ss.str();
+ }
+ else
+ {
+ // Only when dealing with the last segment the last point should be added. This one will not occur
+ // as the first point of the next roi segment.
+ if(i == (n-2))
+ {
+ totalPath.push_back(endPoint);
+ std::stringstream ss;
+ ss << endPoint[0] << " " << endPoint[1] << " " << endPoint[2] << "\n";
+ pathDescription += ss.str();
+ }
+
+ }
+
+ }
+
+ }
+
+
+ // save pathDescription to m_PathDescription
+ m_PathDescription = pathDescription;
+
+ FloatImageType::Pointer itkImg = FloatImageType::New();
+ mitk::CastToItkImage(m_InputImage, itkImg);
+
+ CharImageType::Pointer roiImg = CharImageType::New();
+ roiImg->SetRegions(itkImg->GetLargestPossibleRegion().GetSize());
+ roiImg->SetOrigin(itkImg->GetOrigin());
+ roiImg->SetSpacing(itkImg->GetSpacing());
+ roiImg->SetDirection(itkImg->GetDirection());
+ roiImg->Allocate();
+ roiImg->FillBuffer(0);
+
+
+ std::vector< itk::Index<3> > roi;
+
+ std::vector< itk::Index<3> >::iterator it;
+ for(it = totalPath.begin();
+ it != totalPath.end();
+ it++)
+ {
+ itk::Index<3> ix = *it;
+ roiImg->SetPixel(ix, 1);
+ roi.push_back(ix);
+ }
+
+
+ m_TbssRoi = mitk::TbssRoiImage::New();
+
+ m_TbssRoi->SetRoi(roi);
+
+ m_TbssRoi->SetImage(roiImg);
+
+ m_TbssRoi->InitializeFromImage();
+
+
+
+ }
+
+
+
+ }
+
+
+
+ std::vector< itk::Index<3> > TractAnalyzer::CreateSegment(itk::Index<3> startPoint, itk::Index<3> endPoint)
+ {
+
+ typedef itk::ShortestPathImageFilter<FloatImageType, CharImageType> ShortestPathFilterType;
+ typedef itk::ShortestPathCostFunctionTbss<FloatImageType> CostFunctionType;
+
+
+ FloatImageType::Pointer meanSkeleton;
+
+ mitk::CastToItkImage(m_InputImage, meanSkeleton);
+
+ // Only use the mitk image
+
+
+
+ if(meanSkeleton)
+ {
+ CostFunctionType::Pointer costFunction = CostFunctionType::New();
+ costFunction->SetImage(meanSkeleton);
+ costFunction->SetStartIndex(startPoint);
+ costFunction->SetEndIndex(endPoint);
+ costFunction->SetThreshold(m_Threshold);
+
+ ShortestPathFilterType::Pointer pathFinder = ShortestPathFilterType::New();
+ pathFinder->SetCostFunction(costFunction);
+ pathFinder->SetFullNeighborsMode(true);
+ //pathFinder->SetCalcMode(ShortestPathFilterType::A_STAR);
+ pathFinder->SetInput(meanSkeleton);
+ pathFinder->SetStartIndex(startPoint);
+ pathFinder->SetEndIndex(endPoint);
+ pathFinder->Update();
+
+ return pathFinder->GetVectorPath();
+
+
+ }
+ }
+
+
+}
+#endif
diff --git a/Modules/DiffusionImaging/Quantification/Algorithms/mitkTractAnalyzer.h b/Modules/DiffusionImaging/Quantification/Algorithms/mitkTractAnalyzer.h
new file mode 100644
index 0000000000..d9c3296fcf
--- /dev/null
+++ b/Modules/DiffusionImaging/Quantification/Algorithms/mitkTractAnalyzer.h
@@ -0,0 +1,152 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+
+#ifndef __mitkTractAnalyzer_h_
+#define __mitkTractAnalyzer_h_
+
+#include "QuantificationExports.h"
+#include <itkImage.h>
+#include "mitkImage.h"
+#include "mitkImageCast.h"
+
+#include <mitkTbssRoiImage.h>
+#include <mitkPointSet.h>
+
+
+namespace mitk{
+/**
+ * \brief Creates a region of interest for tract-specific analysis of existing TBSS data
+ *
+ * This class needs a 3D image (typically a mean FA skeleton as produced by the standard TBSS pipeline of FSL)
+ * and a user-defined point set defining the points through which the region of interest should pass.
+ */
+
+
+class Quantification_EXPORT TractAnalyzer
+{
+
+public:
+
+
+ TractAnalyzer();
+ ~TractAnalyzer() {}
+
+
+ /** Image type definitions */
+ typedef itk::Image<char,3> CharImageType;
+ typedef itk::Image<float,3> FloatImageType;
+
+
+ /** \brief Main method for region of interest calculation
+ *
+ * A region of interest is calculated adding the segments between the points on the ROI
+ * that was specified by the user.
+ */
+ void MakeRoi();
+
+
+
+ /** \brief Sets the input image
+ *
+ * The region of interest is calculated on a 3D image. This is generally the mean FA skeleton as calculated
+ * in the standard TBSS pipeline (see http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/TBSS).
+ */
+ mitk::TbssRoiImage::Pointer GetRoiImage()
+ {
+ return m_TbssRoi;
+ }
+
+
+ /** \brief Sets the input image
+ *
+ * The region of interest is calculated on a 3D image. This is generally the mean FA skeleton as calculated
+ * in the standard TBSS pipeline (see http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/TBSS).
+ */
+ void SetInputImage(mitk::Image::Pointer inputImage)
+ {
+ m_InputImage = inputImage;
+ }
+
+
+ /** \brief Sets the user-defined point set
+ *
+ * Set the user-defined point sets. The region of interest must pass through these points.
+ */
+ void SetPointSet(mitk::PointSet::Pointer pointSet)
+ {
+ m_PointSetNode = pointSet;
+ }
+
+
+ /** \brief Sets a lower bound for the threshold.
+ *
+ * Low fractional anisotropy values can indicate partial volume of non white matter tissue.
+ * This thresholds limits the search for a region of interest to voxels with a minimum value.
+ */
+ void SetThreshold(double threshold)
+ {
+ m_Threshold = threshold;
+ }
+
+
+
+ /** \brief Returns a string with the indices of points on the region of interest
+ *
+ * The region of interest calculated by the TractAnalyzer contains a list of ITK indices.
+ * This method returns a string containing these indices for display in the GUI
+ */
+ std::string GetPathDescription()
+ {
+ return m_PathDescription;
+ }
+
+protected:
+
+
+
+ /** \brief Calculates a segment of the region of interest
+ *
+ * The region of interest is calculated on a 3D image. This is generally the mean FA skeleton as calculated
+ * in the standard TBSS pipeline (see http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/TBSS).
+ */
+ std::vector< itk::Index<3> > CreateSegment(itk::Index<3> startPoint, itk::Index<3> endPoint);
+
+
+ /** \brief Output TbssRoiImage */
+ mitk::TbssRoiImage::Pointer m_TbssRoi;
+
+ /** \brief Inputimage */
+ mitk::Image::Pointer m_InputImage;
+
+ /** \brief Threshold for ROI search */
+ double m_Threshold;
+
+ /** \brief User defined point set */
+ mitk::PointSet::Pointer m_PointSetNode;
+
+ /** \brief Path description in as string for display in GUI */
+ std::string m_PathDescription;
+
+
+
+private:
+
+};
+
+}
+
+#endif //__itkTractAnalyzer_h_
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
index 12caf847cb..39d0507e70 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
@@ -1,413 +1,295 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkNrrdTbssImageReader_cpp
#define __mitkNrrdTbssImageReader_cpp
#include "mitkNrrdTbssImageReader.h"
#include "itkImageFileReader.h"
#include "itkMetaDataObject.h"
#include "itkNrrdImageIO.h"
#include "itkNiftiImageIO.h"
#include <itkImageFileWriter.h>
#include <iostream>
#include <fstream>
#include "itksys/SystemTools.hxx"
namespace mitk
{
void NrrdTbssImageReader
::GenerateData()
{
// Since everything is completely read in GenerateOutputInformation() it is stored
// in a cache variable. A timestamp is associated.
// If the timestamp of the cache variable is newer than the MTime, we only need to
// assign the cache variable to the DataObject.
// Otherwise, the tree must be read again from the file and OuputInformation must
// be updated!
if ( ( ! m_OutputCache ) || ( this->GetMTime( ) > m_CacheTime.GetMTime( ) ) )
{
this->GenerateOutputInformation();
itkWarningMacro("Cache regenerated!");
}
if (!m_OutputCache)
{
itkWarningMacro("Tree cache is empty!")
}
- int vecsize = m_OutputCache->GetImage()->GetVectorLength();
- static_cast<OutputType*>(this->GetOutput(0))
+ static_cast<OutputType*>(this->GetPrimaryOutput())
->SetImage(m_OutputCache->GetImage());
- static_cast<OutputType*>(this->GetOutput(0))
+ static_cast<OutputType*>(this->GetPrimaryOutput())
->SetGroupInfo(m_OutputCache->GetGroupInfo());
- static_cast<OutputType*>(this->GetOutput(0))
- ->SetMetaInfo(m_OutputCache->GetMetaInfo());
- static_cast<OutputType*>(this->GetOutput(0))
- ->SetIsMeta(m_OutputCache->GetIsMeta());
- static_cast<OutputType*>(this->GetOutput(0))
- ->SetContainsDistanceMap(m_OutputCache->GetContainsDistanceMap());
- static_cast<OutputType*>(this->GetOutput(0))
- ->SetContainsMeanSkeleton(m_OutputCache->GetContainsMeanSkeleton());
- static_cast<OutputType*>(this->GetOutput(0))
- ->SetContainsSkeletonMask(m_OutputCache->GetContainsSkeletonMask());
- static_cast<OutputType*>(this->GetOutput(0))
- ->SetContainsGradient(m_OutputCache->GetContainsGradient());
- static_cast<OutputType*>(this->GetOutput(0))
+
+ static_cast<OutputType*>(this->GetPrimaryOutput())
->InitializeFromVectorImage();
}
void NrrdTbssImageReader
::GenerateOutputInformation()
{
OutputType::Pointer outputForCache = OutputType::New();
if ( m_FileName == "")
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
}
else
{
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
MITK_INFO << "NrrdTbssImageReader READING IMAGE INFORMATION";
ImageType::Pointer img;
std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
ext = itksys::SystemTools::LowerCase(ext);
if (ext == ".tbss")
{
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetFileName(this->m_FileName);
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
reader->SetImageIO(io);
reader->Update();
img = reader->GetOutput();
MITK_INFO << "NrrdTbssImageReader READING HEADER INFORMATION";
itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
std::string metaString;
- //int numberOfGradientImages = 0;
- std::string measurementInfo;
- bool isMeta = false;
- bool containsSkeleton = false;
- bool containsSkeletonMask = false;
- bool containsGradient = false;
- bool containsDistanceMap = false;
-
+ std::string measurementInfo;
- std::vector<std::pair<mitk::TbssImage::MetaDataFunction, int > > metaInfo;
std::vector< std::pair<std::string, int> > groups;
for (; itKey != imgMetaKeys.end(); itKey ++)
{
itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
MITK_INFO << *itKey << " ---> " << metaString;
if (itKey->find("Group_index") != std::string::npos)
{
std::vector<std::string> tokens;
this->Tokenize(metaString, tokens, " ");
std::pair< std::string, int > p;
p.first="";
for (int i=0; i<tokens.size()-1;i++)
{
p.first.append(" ");
p.first.append(tokens.at(i));
}
std::cout << p.first << std::endl;
p.second = atoi(tokens.at(tokens.size()-1 ).c_str());
groups.push_back(p);
}
else if(itKey->find("Measurement info") != std::string::npos)
{
measurementInfo = metaString;
}
- else if(itKey->find("meta") != std::string::npos)
- {
- if(metaString == "true")
- {
- isMeta = true;
- }
- }
-
- else if(itKey->find("mean fa skeleton mask") != std::string::npos)
- {
- std::pair<mitk::TbssImage::MetaDataFunction, int> p;
- p.first = mitk::TbssImage::MEAN_FA_SKELETON_MASK;
- p.second = atoi(metaString.c_str());
- metaInfo.push_back(p);
- containsSkeletonMask = true;
- }
-
- else if(itKey->find("mean fa skeleton") != std::string::npos)
- {
- std::pair<mitk::TbssImage::MetaDataFunction, int> p;
- p.first = mitk::TbssImage::MEAN_FA_SKELETON;
- p.second = atoi(metaString.c_str());
- metaInfo.push_back(p);
- containsSkeleton = true;
- }
- else if(itKey->find("gradient_x") != std::string::npos)
- {
- std::pair<mitk::TbssImage::MetaDataFunction, int> p;
- p.first = mitk::TbssImage::GRADIENT_X;
- p.second = atoi(metaString.c_str());
- metaInfo.push_back(p);
- containsGradient = true;
- }
- else if(itKey->find("gradient_y") != std::string::npos)
- {
- std::pair<mitk::TbssImage::MetaDataFunction, int> p;
- p.first = mitk::TbssImage::GRADIENT_Y;
- p.second = atoi(metaString.c_str());
- metaInfo.push_back(p);
- containsGradient = true;
- }
-
- else if(itKey->find("gradient_z") != std::string::npos)
- {
- std::pair<mitk::TbssImage::MetaDataFunction, int> p;
- p.first = mitk::TbssImage::GRADIENT_Z;
- p.second = atoi(metaString.c_str());
- metaInfo.push_back(p);
- containsGradient = true;
- }
-
-
- else if(itKey->find("tubular structure") != std::string::npos)
- {
- std::pair<mitk::TbssImage::MetaDataFunction, int> p;
- p.first = mitk::TbssImage::TUBULAR_STRUCTURE;
- p.second = atoi(metaString.c_str());
- metaInfo.push_back(p);
- }
-
- else if(itKey->find("distance map") != std::string::npos)
- {
- std::pair<mitk::TbssImage::MetaDataFunction, int> p;
- p.first = mitk::TbssImage::DISTANCE_MAP;
- p.second = atoi(metaString.c_str());
- metaInfo.push_back(p);
- containsDistanceMap = true;
- }
}
- outputForCache->SetIsMeta(isMeta);
- outputForCache->SetContainsGradient(containsGradient);
- outputForCache->SetContainsSkeletonMask(containsSkeletonMask);
- outputForCache->SetContainsMeanSkeleton(containsSkeleton);
- outputForCache->SetContainsDistanceMap(containsDistanceMap);
+
outputForCache->SetGroupInfo(groups);
outputForCache->SetMeasurementInfo(measurementInfo);
- outputForCache->SetMetaInfo(metaInfo);
+
}
// This call updates the output information of the associated VesselTreeData
outputForCache->SetImage(img);
- // outputForCache->SetB_Value(m_B_Value);
- //outputForCache->SetDirections(m_DiffusionVectors);
- // outputForCache->SetOriginalDirections(m_OriginalDiffusionVectors);
- // outputForCache->SetMeasurementFrame(m_MeasurementFrame);
// Since we have already read the tree, we can store it in a cache variable
// so that it can be assigned to the DataObject in GenerateData();
m_OutputCache = outputForCache;
m_CacheTime.Modified();
try
{
MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
catch(std::exception& e)
{
MITK_INFO << "Std::Exception while reading file!!";
MITK_INFO << e.what();
throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
}
catch(...)
{
MITK_INFO << "Exception while reading file!!";
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
}
}
}
const char* NrrdTbssImageReader
::GetFileName() const
{
return m_FileName.c_str();
}
void NrrdTbssImageReader
::SetFileName(const char* aFileName)
{
m_FileName = aFileName;
}
const char* NrrdTbssImageReader
::GetFilePrefix() const
{
return m_FilePrefix.c_str();
}
void NrrdTbssImageReader
::SetFilePrefix(const char* aFilePrefix)
{
m_FilePrefix = aFilePrefix;
}
const char* NrrdTbssImageReader
::GetFilePattern() const
{
return m_FilePattern.c_str();
}
void NrrdTbssImageReader
::SetFilePattern(const char* aFilePattern)
{
m_FilePattern = aFilePattern;
}
bool NrrdTbssImageReader
::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
// First check the extension
if( filename == "" )
return false;
// check if image is serie
if( filePattern != "" && filePrefix != "" )
return false;
std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
ext = itksys::SystemTools::LowerCase(ext);
if (ext == ".tbss")
{
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(filename);
try
{
reader->Update();
}
catch(itk::ExceptionObject e)
{
MITK_INFO << e.GetDescription();
return false;
}
-/*
- typename ImageType::Pointer img = reader->GetOutput();
- itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
- std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
- std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
- std::string metaString;
-
- for (; itKey != imgMetaKeys.end(); itKey ++)
- {
- itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
- if (itKey->find("tbss") != std::string::npos)
- {
- if (metaString.find("ROI") != std::string::npos)
- {
- return true;
- }
- }
- }
- }
-*/
- // return false;
-
return true;
}
return false;
}
} //namespace MITK
#endif
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageReader.h b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageReader.h
index 257afe1981..0aaf2223ea 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageReader.h
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageReader.h
@@ -1,103 +1,102 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkNrrdTbssImageReader_h
#define __mitkNrrdTbssImageReader_h
#include "mitkCommon.h"
#include "mitkFileReader.h"
#include "mitkTbssImageSource.h"
#include "itkImage.h"
#include "itkVectorImage.h"
#include "mitkTbssImage.h"
namespace mitk
{
/** \brief
*/
class Quantification_EXPORT NrrdTbssImageReader : public mitk::TbssImageSource, public FileReader
{
public:
typedef mitk::TbssImage OutputType;
typedef itk::VectorImage<float,3> ImageType;
typedef TbssImageSource TbssVolSourceType;
mitkClassMacro( NrrdTbssImageReader, TbssVolSourceType )
itkNewMacro(Self)
const char* GetFileName() const;
void SetFileName(const char* aFileName);
const char* GetFilePrefix() const;
void SetFilePrefix(const char* aFilePrefix);
const char* GetFilePattern() const;
void SetFilePattern(const char* aFilePattern);
static bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern);
protected:
/** Does the real work. */
virtual void GenerateData();
virtual void GenerateOutputInformation();
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
std::vector< std::pair<std::string, int> > m_GroupInfo;
OutputType::Pointer m_OutputCache;
itk::TimeStamp m_CacheTime;
void Tokenize(const std::string& str,
std::vector<std::string>& tokens,
const std::string& delimiters = " ")
{
// Skip delimiters at beginning.
std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
// Find first "non-delimiter".
std::string::size_type pos = str.find_first_of(delimiters, lastPos);
while (std::string::npos != pos || std::string::npos != lastPos)
{
// Found a token, add it to the vector.
tokens.push_back(str.substr(lastPos, pos - lastPos));
// Skip delimiters. Note the "not_of"
lastPos = str.find_first_not_of(delimiters, pos);
// Find next "non-delimiter"
pos = str.find_first_of(delimiters, lastPos);
}
}
private:
void operator=(const Self&); //purposely not implemented
};
} //namespace MITK
-//#include "mitkNrrdTbssImageReader.cpp"
#endif // __mitkNrrdTbssImageReader_h
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
index 824581c3fe..c7ab1ff07e 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
@@ -1,211 +1,119 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkNrrdTbssImageWriter__cpp
#define __mitkNrrdTbssImageWriter__cpp
#include "mitkNrrdTbssImageWriter.h"
#include "itkMetaDataDictionary.h"
#include "itkMetaDataObject.h"
#include "itkNrrdImageIO.h"
//#include "itkNiftiImageIO.h"
#include "itkImageFileWriter.h"
#include "itksys/SystemTools.hxx"
#include "boost/lexical_cast.hpp"
#include <iostream>
#include <fstream>
mitk::NrrdTbssImageWriter::NrrdTbssImageWriter()
: m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
{
this->SetNumberOfRequiredInputs( 1 );
}
mitk::NrrdTbssImageWriter::~NrrdTbssImageWriter()
{}
void mitk::NrrdTbssImageWriter::GenerateData()
{
m_Success = false;
InputType* input = this->GetInput();
if (input == NULL)
{
itkWarningMacro(<<"Sorry, input to NrrdTbssImageWriter is NULL!");
return;
}
if ( m_FileName == "" )
{
itkWarningMacro( << "Sorry, filename has not been set!" );
return ;
}
itk::VectorImage<float, 3>::Pointer img = input->GetImage();
- std::string key;
- std::string val;
-
-
- /* For the case of a tbss image containing data of the patients:
- Save info about the groups and the type of measurement */
-
- if(!input->GetIsMeta())
- {
- key = "meta";
- val = "false";
- itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
-
-
- std::vector< std::pair <std::string, int> > groups = input->GetGroupInfo();
- std::vector< std::pair <std::string, int> >::iterator it = groups.begin();
-
- int i=0;
- while(it != groups.end())
- {
- std::pair<std::string, int> p = *it;
-
- key = "Group_index_" + boost::lexical_cast<std::string>(i);
- val = " " + p.first + " " + boost::lexical_cast<std::string>(p.second);
- //sprintf( keybuffer, "Group_index_%04d", std::string(i) );
- // sprintf( valbuffer, "%1d %1d", p.first, p.second);
-
- //std::cout << valbuffer << std::endl;
-
- //itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
- itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
- it++;
- ++i;
- }
-
- key = "Measurement info";
- val = input->GetMeasurementInfo();
- itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
- }
- /* If we are dealing with metadata we need to know what index of the vector corresponds to what image.
- Metadata are the images involved in the algorithms of tbss, like the mean FA Skeleton. */
- else
- {
- key = "meta";
- val = "true";
- itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
-
- std::vector< std::pair<mitk::TbssImage::MetaDataFunction, int> > metaInfo = input->GetMetaInfo();
- std::vector< std::pair<mitk::TbssImage::MetaDataFunction, int> >::iterator it = metaInfo.begin();
- while(it != metaInfo.end())
- {
- std::pair<mitk::TbssImage::MetaDataFunction, int> p = *it;
- key = RetrieveString(p.first);
- val = " " + boost::lexical_cast<std::string>(p.second);
- itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
- it++;
- }
- }
typedef itk::VectorImage<float,3> ImageType;
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
io->SetFileType( itk::ImageIOBase::Binary );
io->UseCompressionOn();
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer nrrdWriter = WriterType::New();
nrrdWriter->UseInputMetaDataDictionaryOn();
nrrdWriter->SetInput( img );
nrrdWriter->SetImageIO(io);
nrrdWriter->SetFileName(m_FileName);
nrrdWriter->UseCompressionOn();
nrrdWriter->SetImageIO(io);
try
{
nrrdWriter->Update();
}
catch (itk::ExceptionObject e)
{
std::cout << e << std::endl;
}
m_Success = true;
}
-std::string mitk::NrrdTbssImageWriter::RetrieveString(mitk::TbssImage::MetaDataFunction meta)
-{
- if(meta == mitk::TbssImage::MEAN_FA_SKELETON)
- {
- return "mean fa skeleton";
- }
- else if(meta == mitk::TbssImage::MEAN_FA_SKELETON_MASK)
- {
- return "mean fa skeleton mask";
- }
- else if(meta == mitk::TbssImage::GRADIENT_X)
- {
- return "gradient_x";
- }
- else if(meta == mitk::TbssImage::GRADIENT_Y)
- {
- return "gradient_y";
- }
- else if(meta == mitk::TbssImage::GRADIENT_Z)
- {
- return "gradient_z";
- }
- else if(meta == mitk::TbssImage::TUBULAR_STRUCTURE)
- {
- return "tubular structure";
- }
- else if(meta == mitk::TbssImage::DISTANCE_MAP)
- {
- return "distance map";
- }
- return "";
-}
-
-
void mitk::NrrdTbssImageWriter::SetInput( InputType* tbssVol )
{
this->ProcessObject::SetNthInput( 0, tbssVol );
}
mitk::TbssImage* mitk::NrrdTbssImageWriter::GetInput()
{
if ( this->GetNumberOfInputs() < 1 )
{
return NULL;
}
else
{
return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( 0 ) );
}
}
std::vector<std::string> mitk::NrrdTbssImageWriter::GetPossibleFileExtensions()
{
std::vector<std::string> possibleFileExtensions;
possibleFileExtensions.push_back(".tbss");
return possibleFileExtensions;
}
#endif //__mitkNrrdTbssImageWriter__cpp
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.h b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.h
index 9a1fcfdd4b..9d285c094b 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.h
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.h
@@ -1,140 +1,140 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_NRRDTBSSVOL_WRITER__H_
#define _MITK_NRRDTBSSVOL_WRITER__H_
#include <itkProcessObject.h>
#include <mitkFileWriterWithInformation.h>
#include <mitkTbssImage.h>
#include <QString>
#include "QuantificationExports.h"
namespace mitk
{
/**
* Writes diffusion volumes to a file
* @ingroup Process
*/
class Quantification_EXPORT NrrdTbssImageWriter : public mitk::FileWriterWithInformation
{
public:
mitkClassMacro( NrrdTbssImageWriter, mitk::FileWriterWithInformation )
mitkWriterMacro
itkNewMacro( Self )
typedef mitk::TbssImage InputType;
/**
* Sets the filename of the file to write.
* @param FileName the nameInputType of the file to write.
*/
itkSetStringMacro( FileName )
/**
* @returns the name of the file to be written to disk.
*/
itkGetStringMacro( FileName )
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePrefix )
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePrefix )
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePattern )
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePattern )
/**image
* Sets the input object for the filter.
* @param input the diffusion volumes to write to file.
*/
void SetInput( InputType* input );
/**itk::VectorImage<TPixelType, 3>
* @returns the 0'th input object of the filter.
*/
InputType* GetInput();
/**
* Returns false if an error happened during writing
*/
itkGetMacro( Success, bool )
/**
* @return possible file extensions for the data type associated with the writer
*/
virtual std::vector<std::string> GetPossibleFileExtensions();
// FileWriterWithInformation methods
virtual const char * GetDefaultFilename() { return "TbssImage.tbss"; }
virtual const char * GetFileDialogPattern() { return "Tbss Images (*.tbss)"; }
virtual const char * GetDefaultExtension() { return ".tbss"; }
virtual bool CanWriteBaseDataType(BaseData::Pointer data)
{
return (dynamic_cast<mitk::TbssImage*>(data.GetPointer()) != NULL);
}
virtual void DoWrite(BaseData::Pointer data) {
if (CanWriteBaseDataType(data)) {
this->SetInput(dynamic_cast<mitk::TbssImage*>(data.GetPointer()));
this->Update();
}
}
protected:
NrrdTbssImageWriter();
virtual ~NrrdTbssImageWriter();
virtual void GenerateData();
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
bool m_Success;
- std::string RetrieveString(mitk::TbssImage::MetaDataFunction meta);
+
};
} // end of namespace mitk
#endif
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
index 73e833b1b3..e3712b7701 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
@@ -1,363 +1,356 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkNrrdTbssRoiReader_cpp
#define __mitkNrrdTbssRoiReader_cpp
#include "mitkNrrdTbssRoiImageReader.h"
#include "itkImageFileReader.h"
#include "itkMetaDataObject.h"
#include "itkNrrdImageIO.h"
#include "itkNiftiImageIO.h"
#include <itkImageFileWriter.h>
#include <iostream>
#include <fstream>
#include "itksys/SystemTools.hxx"
namespace mitk
{
void NrrdTbssRoiImageReader
::GenerateData()
{
try
{
// Change locale if needed
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
// READ IMAGE INFORMATION
const unsigned int MINDIM = 3;
const unsigned int MAXDIM = 4;
MITK_INFO << "loading " << m_FileName << " via mitk::NrrdTbssImageReader... " << std::endl;
// Check to see if we can read the file given the name or prefix
if ( m_FileName == "" )
{
itkWarningMacro( << "Filename is empty!" )
return;
}
itk::NrrdImageIO::Pointer imageIO = itk::NrrdImageIO::New();
imageIO->SetFileName( m_FileName.c_str() );
imageIO->ReadImageInformation();
unsigned int ndim = imageIO->GetNumberOfDimensions();
if ( ndim < MINDIM || ndim > MAXDIM )
{
itkWarningMacro( << "Sorry, only dimensions 3 is supported. The given file has " << ndim << " dimensions!" )
return;
}
itk::ImageIORegion ioRegion( ndim );
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
unsigned int dimensions[ MAXDIM ];
dimensions[ 0 ] = 0;
dimensions[ 1 ] = 0;
dimensions[ 2 ] = 0;
dimensions[ 3 ] = 0;
float spacing[ MAXDIM ];
spacing[ 0 ] = 1.0f;
spacing[ 1 ] = 1.0f;
spacing[ 2 ] = 1.0f;
spacing[ 3 ] = 1.0f;
Point3D origin;
origin.Fill(0);
unsigned int i;
for ( i = 0; i < ndim ; ++i )
{
ioStart[ i ] = 0;
ioSize[ i ] = imageIO->GetDimensions( i );
if(i<MAXDIM)
{
dimensions[ i ] = imageIO->GetDimensions( i );
spacing[ i ] = imageIO->GetSpacing( i );
if(spacing[ i ] <= 0)
spacing[ i ] = 1.0f;
}
if(i<3)
{
origin[ i ] = imageIO->GetOrigin( i );
}
}
ioRegion.SetSize( ioSize );
ioRegion.SetIndex( ioStart );
MITK_INFO << "ioRegion: " << ioRegion << std::endl;
imageIO->SetIORegion( ioRegion );
void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
imageIO->Read( buffer );
//mitk::Image::Pointer static_cast<OutputType*>(this->GetOutput())image = mitk::Image::New();
if((ndim==4) && (dimensions[3]<=1))
ndim = 3;
if((ndim==3) && (dimensions[2]<=1))
ndim = 2;
- mitk::PixelType pixelType = mitk::PixelType(imageIO->GetComponentTypeInfo(), imageIO->GetPixelType(),
- imageIO->GetComponentSize(), imageIO->GetNumberOfComponents(),
- imageIO->GetComponentTypeAsString( imageIO->GetComponentType() ).c_str(),
- imageIO->GetPixelTypeAsString( imageIO->GetPixelType() ).c_str() );
-
- //pixelType.Initialize( imageIO->GetComponentTypeInfo(), imageIO->GetNumberOfComponents(), imageIO->GetPixelType() );
-
- static_cast<OutputType*>(this->GetOutput(0))->Initialize( pixelType, ndim, dimensions );
- static_cast<OutputType*>(this->GetOutput(0))->SetImportChannel( buffer, 0, Image::ManageMemory );
+ static_cast<OutputType*>(this->GetPrimaryOutput())->Initialize( MakePixelType(imageIO), ndim, dimensions );
+ static_cast<OutputType*>(this->GetPrimaryOutput())->SetImportChannel( buffer, 0, Image::ManageMemory );
// access direction of itk::Image and include spacing
mitk::Matrix3D matrix;
matrix.SetIdentity();
unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
for ( i=0; i < itkDimMax3; ++i)
for( j=0; j < itkDimMax3; ++j )
matrix[i][j] = imageIO->GetDirection(j)[i];
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>
(static_cast<OutputType*>
- (this->GetOutput(0))->GetSlicedGeometry(0)->GetGeometry2D(0));
+ (this->GetPrimaryOutput())->GetSlicedGeometry(0)->GetGeometry2D(0));
planeGeometry->SetOrigin(origin);
planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
// re-initialize SlicedGeometry3D
- SlicedGeometry3D* slicedGeometry = static_cast<OutputType*>(this->GetOutput(0))->GetSlicedGeometry(0);
- slicedGeometry->InitializeEvenlySpaced(planeGeometry, static_cast<OutputType*>(this->GetOutput(0))->GetDimension(2));
+ SlicedGeometry3D* slicedGeometry = static_cast<OutputType*>(this->GetPrimaryOutput())->GetSlicedGeometry(0);
+ slicedGeometry->InitializeEvenlySpaced(planeGeometry, static_cast<OutputType*>(this->GetPrimaryOutput())->GetDimension(2));
slicedGeometry->SetSpacing(spacing);
// re-initialize TimeSlicedGeometry
- static_cast<OutputType*>(this->GetOutput(0))->GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, static_cast<OutputType*>(this->GetOutput(0))->GetDimension(3));
+ static_cast<OutputType*>(this->GetPrimaryOutput())->GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, static_cast<OutputType*>(this->GetPrimaryOutput())->GetDimension(3));
buffer = NULL;
- MITK_INFO << "number of image components: "<< static_cast<OutputType*>(this->GetOutput(0))->GetPixelType().GetNumberOfComponents() << std::endl;
+ MITK_INFO << "number of image components: "<< static_cast<OutputType*>(this->GetPrimaryOutput())->GetPixelType().GetNumberOfComponents() << std::endl;
// READ TBSS HEADER INFORMATION
ImageType::Pointer img;
std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
ext = itksys::SystemTools::LowerCase(ext);
if (ext == ".roi")
{
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetFileName(this->m_FileName);
reader->SetImageIO(imageIO);
reader->Update();
img = reader->GetOutput();
- static_cast<OutputType*>(this->GetOutput(0))->SetImage(img);
+ static_cast<OutputType*>(this->GetPrimaryOutput())->SetImage(img);
itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
ReadRoiInfo(imgMetaDictionary);
}
// RESET LOCALE
try
{
MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
MITK_INFO << "...finished!" << std::endl;
}
catch(std::exception& e)
{
MITK_INFO << "Std::Exception while reading file!!";
MITK_INFO << e.what();
throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
}
catch(...)
{
MITK_INFO << "Exception while reading file!!";
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
}
}
void NrrdTbssRoiImageReader
::ReadRoiInfo(itk::MetaDataDictionary dict)
{
std::vector<std::string> imgMetaKeys = dict.GetKeys();
std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
std::string metaString;
std::vector< itk::Index<3> > roi;
for (; itKey != imgMetaKeys.end(); itKey ++)
{
double x,y,z;
itk::Index<3> ix;
itk::ExposeMetaData<std::string> (dict, *itKey, metaString);
if (itKey->find("ROI_index") != std::string::npos)
{
MITK_INFO << *itKey << " ---> " << metaString;
sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
ix[0] = x; ix[1] = y; ix[2] = z;
roi.push_back(ix);
}
else if(itKey->find("preprocessed FA") != std::string::npos)
{
MITK_INFO << *itKey << " ---> " << metaString;
- static_cast<OutputType*>(this->GetOutput(0))->SetPreprocessedFA(true);
- static_cast<OutputType*>(this->GetOutput(0))->SetPreprocessedFAFile(metaString);
+ static_cast<OutputType*>(this->GetPrimaryOutput())->SetPreprocessedFA(true);
+ static_cast<OutputType*>(this->GetPrimaryOutput())->SetPreprocessedFAFile(metaString);
}
// Name of structure
if (itKey->find("structure") != std::string::npos)
{
MITK_INFO << *itKey << " ---> " << metaString;
- static_cast<OutputType*>(this->GetOutput(0))->SetStructure(metaString);
+ static_cast<OutputType*>(this->GetPrimaryOutput())->SetStructure(metaString);
}
}
- static_cast<OutputType*>(this->GetOutput(0))->SetRoi(roi);
+ static_cast<OutputType*>(this->GetPrimaryOutput())->SetRoi(roi);
}
const char* NrrdTbssRoiImageReader
::GetFileName() const
{
return m_FileName.c_str();
}
void NrrdTbssRoiImageReader
::SetFileName(const char* aFileName)
{
m_FileName = aFileName;
}
const char* NrrdTbssRoiImageReader
::GetFilePrefix() const
{
return m_FilePrefix.c_str();
}
void NrrdTbssRoiImageReader
::SetFilePrefix(const char* aFilePrefix)
{
m_FilePrefix = aFilePrefix;
}
const char* NrrdTbssRoiImageReader
::GetFilePattern() const
{
return m_FilePattern.c_str();
}
void NrrdTbssRoiImageReader
::SetFilePattern(const char* aFilePattern)
{
m_FilePattern = aFilePattern;
}
bool NrrdTbssRoiImageReader
::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
// First check the extension
if( filename == "" )
return false;
// check if image is serie
if( filePattern != "" && filePrefix != "" )
return false;
std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
ext = itksys::SystemTools::LowerCase(ext);
if (ext == ".roi")
{
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(filename);
try
{
reader->Update();
}
catch(itk::ExceptionObject e)
{
MITK_INFO << e.GetDescription();
return false;
}
return true;
}
return false;
}
} //namespace MITK
#endif
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.h b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.h
index 589fe0dbcc..2136261626 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.h
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.h
@@ -1,140 +1,138 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_NRRDTBSSROIVOL_WRITER__H_
#define _MITK_NRRDTBSSROIVOL_WRITER__H_
#include <itkProcessObject.h>
#include <mitkFileWriterWithInformation.h>
#include <mitkTbssRoiImage.h>
#include <QString>
#include "QuantificationExports.h"
namespace mitk
{
/**
* Writes diffusion volumes to a file
* @ingroup Process
*/
class Quantification_EXPORT NrrdTbssRoiImageWriter : public mitk::FileWriterWithInformation
{
public:
typedef itk::Image<char,3> ImageType;
mitkClassMacro( NrrdTbssRoiImageWriter, mitk::FileWriterWithInformation )
mitkWriterMacro
itkNewMacro( Self )
typedef mitk::TbssRoiImage InputType;
/**
* Sets the filename of the file to write.
* @param FileName the nameInputType of the file to write.
*/
itkSetStringMacro( FileName );
/**
* @returns the name of the file to be written to disk.
*/
itkGetStringMacro( FileName );
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePrefix );
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePrefix );
/**
* @warning multiple write not (yet) supported
*/
itkSetStringMacro( FilePattern );
/**
* @warning multiple write not (yet) supported
*/
itkGetStringMacro( FilePattern );
/**image
* Sets the input object for the filter.
* @param input the diffusion volumes to write to file.
*/
void SetInput( InputType* input );
/**
* @returns the 0'th input object of the filter.
*/
InputType* GetInput();
/**
* Returns false if an error happened during writing
*/
itkGetMacro( Success, bool );
/**
* @return possible file extensions for the data type associated with the writer
*/
virtual std::vector<std::string> GetPossibleFileExtensions();
// FileWriterWithInformation methods
virtual const char * GetDefaultFilename() { return "TbssRoiImage.roi"; }
virtual const char * GetFileDialogPattern() { return "Tbss Roi Images (*.roi)"; }
virtual const char * GetDefaultExtension() { return ".roi"; }
virtual bool CanWriteBaseDataType(BaseData::Pointer data)
{
return (dynamic_cast<mitk::TbssRoiImage*>(data.GetPointer()) != NULL);
}
virtual void DoWrite(BaseData::Pointer data) {
if (CanWriteBaseDataType(data)) {
this->SetInput(dynamic_cast<mitk::TbssRoiImage*>(data.GetPointer()));
this->Update();
}
}
protected:
NrrdTbssRoiImageWriter();
virtual ~NrrdTbssRoiImageWriter();
virtual void GenerateData();
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
bool m_Success;
};
} // end of namespace mitk
-//#include "mitkNrrdTbssRoiImageWriter.cpp"
-
#endif
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImage.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImage.cpp
index f0e9b105be..4f96937c6d 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImage.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImage.cpp
@@ -1,118 +1,114 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkTbssImage__cpp
#define __mitkTbssImage__cpp
#include "mitkTbssImage.h"
#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIterator.h"
#include "mitkImageCast.h"
mitk::TbssImage::TbssImage()
- : m_IsMeta(false),
- m_ContainsGradient(false),
- m_ContainsMeanSkeleton(false),
- m_ContainsSkeletonMask(false)
{
}
void mitk::TbssImage::InitializeFromVectorImage()
{
if(!m_Image)
{
MITK_INFO << "TBSS Image could not be initialized. Set all members first!" << std::endl;
return;
}
typedef itk::Image<float,3> ImgType;
ImgType::Pointer img = ImgType::New();
img->SetSpacing( m_Image->GetSpacing() ); // Set the image spacing
img->SetOrigin( m_Image->GetOrigin() ); // Set the image origin
img->SetDirection( m_Image->GetDirection() ); // Set the image direction
img->SetLargestPossibleRegion( m_Image->GetLargestPossibleRegion());
img->SetBufferedRegion( m_Image->GetLargestPossibleRegion() );
img->Allocate();
int vecLength = m_Image->GetVectorLength();
InitializeByItk( img.GetPointer(), 1, vecLength );
//for(int i=0; i<vecLength; i++)
//{TbssImage();
itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
itw = itw.Begin();
itk::ImageRegionConstIterator<ImageType> itr (m_Image, m_Image->GetLargestPossibleRegion() );
itr = itr.Begin();
while(!itr.IsAtEnd())
{
itw.Set(itr.Get().GetElement(0));
++itr;
++itw;
}
// init
SetImportVolume(img->GetBufferPointer());//, 0, 0, CopyMemory);
//SetVolume( img->GetBufferPointer(), i );
//}::
m_DisplayIndex = 0;
MITK_INFO << "Tbss-Image successfully initialized.";
}
void mitk::TbssImage::SetDisplayIndexForRendering(int displayIndex)
{
MITK_INFO << "displayindex: " << displayIndex;
int index = displayIndex;
int vecLength = m_Image->GetVectorLength();
index = index > vecLength-1 ? vecLength-1 : index;
if( m_DisplayIndex != index )
{
typedef itk::Image<float,3> ImgType;
ImgType::Pointer img = ImgType::New();
CastToItkImage<ImgType>(this, img);
itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
itw = itw.Begin();
itk::ImageRegionConstIterator<ImageType> itr (m_Image, m_Image->GetLargestPossibleRegion() );
itr = itr.Begin();
while(!itr.IsAtEnd())
{
itw.Set(itr.Get().GetElement(index));
++itr;
++itw;
}
}
m_DisplayIndex = index;
}
#endif /* __mitkTbssImage__cpp */
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImage.h b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImage.h
index 73d79741e3..7c8b039c65 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImage.h
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImage.h
@@ -1,184 +1,116 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkTbssImage__h
#define __mitkTbssImage__h
#include "mitkImage.h"
#include "itkVectorImage.h"
#include "mitkImageCast.h"
#include "QuantificationExports.h"
namespace mitk
{
/**
* \brief this class encapsulates diffusion volumes (vectorimages not
* yet supported by mitkImage)
*/
class Quantification_EXPORT TbssImage : public Image
{
public:
typedef itk::VectorImage<float, 3> ImageType;
typedef itk::Index<3> IndexType;
//typedef typename std::vector <Index<3> > RoiType;
mitkClassMacro( TbssImage, Image )
itkNewMacro(Self)
- enum MetaDataFunction
- {
- MEAN_FA_SKELETON,
- MEAN_FA_SKELETON_MASK,
- GRADIENT_X,
- GRADIENT_Y,
- GRADIENT_Z,
- TUBULAR_STRUCTURE,
- DISTANCE_MAP,
- MISC
- };
-
-
- //void SetRequestedRegionToLargestPossibleReg tbssRoi->SetTbssType(mitk::TbssImage<char>::ROI);ion();
- //bool RequestedRegionIsOutsideOfTheBufferedRegion();
- //virtual bool VerifyRequestedRegion();
- //void SetRequestedRegion(itk::DataObject *data);
-
ImageType::Pointer GetImage()
{
return m_Image;
}
void SetImage(ImageType::Pointer image )
{
this->m_Image = image;
}
void InitializeFromImage()
{
MITK_INFO << "make an mitk image that can be shown by mitk";
this->InitializeByItk(m_Image.GetPointer(),1,1);
}
void SetGroupInfo( std::vector< std::pair<std::string, int> > info)
{
m_GroupInfo = info;
}
std::vector< std::pair<std::string, int> > GetGroupInfo()
{
return m_GroupInfo;
}
- void SetMetaInfo( std::vector< std::pair<MetaDataFunction, int> > info)
- {
- m_MetaInfo = info;
- }
-
- std::vector< std::pair<MetaDataFunction, int> > GetMetaInfo()
- {
- return m_MetaInfo;
- }
void SetMeasurementInfo(std::string s)
{
m_MeasurementInfo = s;
}
std::string GetMeasurementInfo()
{
return m_MeasurementInfo;
}
void InitializeFromVectorImage();
void SetDisplayIndexForRendering(int displayIndex);
- itkGetMacro(IsMeta, bool)
- itkGetMacro(ContainsGradient, bool)
- itkGetMacro(ContainsMeanSkeleton, bool)
- itkGetMacro(ContainsSkeletonMask, bool)
- itkGetMacro(ContainsDistanceMap, bool)
- itkSetMacro(IsMeta, bool)
- itkSetMacro(ContainsGradient, bool)
- itkSetMacro(ContainsMeanSkeleton, bool)
- itkSetMacro(ContainsSkeletonMask, bool)
- itkSetMacro(ContainsDistanceMap, bool)
-
-
protected:
TbssImage();
virtual ~TbssImage(){}
ImageType::Pointer m_Image;
std::vector< std::pair<std::string, int> > m_GroupInfo;
- std::vector< std::pair<MetaDataFunction, int> > m_MetaInfo;
-
int m_DisplayIndex;
std::string m_MeasurementInfo;
- bool m_IsMeta;
-
- bool m_ContainsGradient;
-
- bool m_ContainsMeanSkeleton;
-
- bool m_ContainsSkeletonMask;
-
- bool m_ContainsDistanceMap;
-
};
-/*
- // Does the same es the normal CastToMitkImage, but needed to reimplemented due to the templatet pixeltype
- template <typename ItkOutputImageType>
- void CastToTbssImage(const ItkOutputImageType* itkimage, itk::SmartPointer< mitk::TbssImage >& tbssoutputimage)
- {
- if(tbssoutputimage.IsNull())
- {
- tbssoutputimage = mitk::TbssImage::New();
- }
- tbssoutputimage->InitializeByItk(itkimage);
- tbssoutputimage->SetChannel(itkimage->GetBufferPointer());
- }
-
-
-*/
-
-
} // namespace mitk
//#include "mitkTbssImage.cpp"
#endif /* __mitkTbssImage__h */
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImageSource.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImageSource.cpp
index 0a39a5d1ef..c37424b81a 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImageSource.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImageSource.cpp
@@ -1,51 +1,51 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __MITK_NRRD_TBSS_VOULMES_IO_FACTORY_CPP__
#define __MITK_NRRD_TBSS_VOULMES_IO_FACTORY_CPP__
#include "mitkTbssImageSource.h"
#include "mitkTbssImage.h"
mitk::TbssImageSource::TbssImageSource()
{
// Create the output. We use static_cast<> here because we know the default
// output must be of type DiffusionImage
mitk::TbssImage::Pointer output
= static_cast<mitk::TbssImage*>(this->MakeOutput(0).GetPointer());
Superclass::SetNumberOfRequiredOutputs(1);
Superclass::SetNthOutput(0, output.GetPointer());
}
-itk::DataObject::Pointer mitk::TbssImageSource::MakeOutput( unsigned int /*idx*/ )
+itk::DataObject::Pointer mitk::TbssImageSource::MakeOutput( DataObjectPointerArraySizeType /*idx*/ )
{
return static_cast<itk::DataObject*>(mitk::TbssImage::New().GetPointer());
}
mitk::TbssImageSource::OutputType* mitk::TbssImageSource::GetOutput(unsigned int idx)
{
return static_cast<OutputType*>
(this->ProcessObject::GetOutput(idx));
}
#endif //__MITK_NRRD_TBSS_VOULMES_IO_FACTORY_CPP__
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImageSource.h b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImageSource.h
index 2e1379f2a9..bc717e2ca2 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImageSource.h
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImageSource.h
@@ -1,75 +1,79 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_TBSS_IMAGE_DATA_SOURCE_H_HEADER_
#define _MITK_TBSS_IMAGE_DATA_SOURCE_H_HEADER_
// Should be changed in a new type for TBSS
#include "mitkImageSource.h"
#include "QuantificationExports.h"
namespace mitk {
class TbssImage;
//##Documentation
//## @brief Superclass of all classes generating diffusion volumes (instances
//## of class DiffusionImage) as output.
//##
//## @ingroup Process
class Quantification_EXPORT TbssImageSource : public ImageSource
{
public:
mitkClassMacro(TbssImageSource, BaseProcess)
itkNewMacro(Self)
typedef TbssImage OutputType;
typedef itk::DataObject::Pointer DataObjectPointer;
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx);
+
+ OutputType* GetOutput()
+ {
+ return itkDynamicCastInDebugMode<OutputType*>( this->GetPrimaryOutput() );
+ }
//OutputType * GetOutput(unsigned int idx);
//void SetOutput(OutputType* output);
- //OutputType* GetOutput()
//{return Superclass::GetOutput();}
OutputType* GetOutput(unsigned int idx);
//virtual void GraftOutput(OutputType* graft);
//virtual void GraftNthOutput(unsigned int idx, OutputType *graft);
protected:
TbssImageSource();
virtual ~TbssImageSource(){}
};
} // namespace mitk
//#include "mitkTbssImageSource.cpp"
#endif /* _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_ */
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.cpp
index 775bdafe10..c4c3b939b5 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.cpp
@@ -1,326 +1,126 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkTbssImporter_cpp
#define __mitkTbssImporter_cpp
#include "mitkTbssImporter.h"
-#include <QDir>
-#include <QStringList>
-#include "itkNrrdImageIO.h"
-#include "mitkImageAccessByItk.h"
namespace mitk
{
mitk::TbssImage::Pointer mitk::TbssImporter::Import()
{
// read all images with all_*.nii.gz
mitk::TbssImage::Pointer tbssImg = mitk::TbssImage::New();
m_Data = DataImageType::New();
mitk::Geometry3D* geo = m_InputVolume->GetGeometry();
mitk::Vector3D spacing = geo->GetSpacing();
mitk::Point3D origin = geo->GetOrigin();
//Size size
DataImageType::SizeType dataSize;
dataSize[0] = m_InputVolume->GetDimension(0);
dataSize[1] = m_InputVolume->GetDimension(1);
dataSize[2] = m_InputVolume->GetDimension(2);
m_Data->SetRegions(dataSize);
// Set spacing
DataImageType::SpacingType dataSpacing;
dataSpacing[0] = spacing[0];
dataSpacing[1] = spacing[1];
dataSpacing[2] = spacing[2];
m_Data->SetSpacing(dataSpacing);
DataImageType::PointType dataOrigin;
dataOrigin[0] = origin[0];
dataOrigin[1] = origin[1];
dataOrigin[2] = origin[2];
m_Data->SetOrigin(dataOrigin);
//Direction must be set
DataImageType::DirectionType dir;
const itk::Transform<float, 3, 3>* transform3D = geo->GetParametricTransform();
itk::Transform<float,3,3>::ParametersType p = transform3D->GetParameters();
int t=0;
for(int i=0; i<3; i++)
{
for(int j=0; j<3; j++)
{
dir[i][j] = p[t]; // row-major order (where the column index varies the fastest)
t++;
}
}
m_Data->SetDirection(dir);
// Set the length to one because otherwise allocate fails. Should be changed when groups/measurements are added
m_Data->SetVectorLength(m_InputVolume->GetDimension(3));
m_Data->Allocate();
for(int i=0; i<dataSize[0]; i++)
{
for(int j=0; j<dataSize[1]; j++)
{
for(int k=0; k<dataSize[2]; k++)
{
itk::Index<3> ix;
ix[0] = i;
ix[1] = j;
ix[2] = k;
itk::VariableLengthVector<float> pixel = m_Data->GetPixel(ix);
for(int z=0; z<pixel.Size(); z++)
{
mitk::Index3D ix;
ix[0] = i;
ix[1] = j;
ix[2] = k;
float value = m_InputVolume->GetPixelValueByIndex(ix, z);
pixel.SetElement(z, value);
}
m_Data->SetPixel(ix, pixel);
}
}
}
-// mitk::CastToTbssImage(m_Data.GetPointer(), tbssImg);
-
tbssImg->SetGroupInfo(m_Groups);
tbssImg->SetMeasurementInfo(m_MeasurementInfo);
tbssImg->SetImage(m_Data);
tbssImg->InitializeFromVectorImage();
return tbssImg;
}
- mitk::TbssImage::Pointer mitk::TbssImporter::ImportMeta()
- {
- mitk::TbssImage::Pointer tbssImg = mitk::TbssImage::New();
-
- m_Data = DataImageType::New();
-
- std::vector< std::pair<mitk::TbssImage::MetaDataFunction, int> > metaInfo;
-
- // Gradient images are vector images, so they will add more dimensions to the vector
- int vecLength = m_MetaFiles.size();
- //Check if there is a gradient image
-
- for(int i=0; i < m_MetaFiles.size(); i++)
- {
- std::pair<std::string, std::string> p = m_MetaFiles.at(i);
- if(RetrieveTbssFunction(p.first) == mitk::TbssImage::GRADIENT_X)
- {
- vecLength += 2;
- }
- }
-
-
- int currIndex = 0;
-
-
- for(int i=0; i < m_MetaFiles.size(); i++)
- {
- std::pair<std::string, std::string> p = m_MetaFiles.at(i);
- std::string function = p.first;
- std::string file = p.second;
-
- // Add to metainfo to give the tbss image a function-index pair
- std::pair<mitk::TbssImage::MetaDataFunction, int> pair;
-
-
- pair.first = RetrieveTbssFunction(function);
- pair.second = i;
-
- if(pair.first == mitk::TbssImage::GRADIENT_X)
- {
- metaInfo.push_back(std::pair<mitk::TbssImage::MetaDataFunction, int>(mitk::TbssImage::GRADIENT_X, i));
- metaInfo.push_back(std::pair<mitk::TbssImage::MetaDataFunction, int>(mitk::TbssImage::GRADIENT_Y, i+1));
- metaInfo.push_back(std::pair<mitk::TbssImage::MetaDataFunction, int>(mitk::TbssImage::GRADIENT_Z, i+2));
-
-
- VectorReaderType::Pointer fileReader = VectorReaderType::New();
- fileReader->SetFileName(file);
- itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
- fileReader->SetImageIO(io);
- fileReader->Update();
-
- VectorImageType::Pointer img = fileReader->GetOutput();
-
- VectorImageType::SizeType size = img->GetLargestPossibleRegion().GetSize();
-
- if(i==0)
- {
- // First image in serie. Properties should be used to initialize m_Data
- m_Data->SetRegions(img->GetLargestPossibleRegion().GetSize());
- m_Data->SetSpacing(img->GetSpacing());
- m_Data->SetOrigin(img->GetOrigin());
- m_Data->SetDirection(img->GetDirection());
- m_Data->SetVectorLength(vecLength);
- m_Data->Allocate();
- }
-
-
- /* Dealing with a gradient image, so the size of the vector need to be increased by 2
- since this image contains 3 volumes. Old data should not be deleted*/
-
-
-
- for(int x=0; x<size[0]; x++)
- {
- for(int y=0; y<size[1]; y++)
- {
- for(int z=0; z<size[2]; z++)
- {
- itk::Index<3> ix;
- ix[0] = x;
- ix[1] = y;
- ix[2] = z;
-
- itk::VariableLengthVector<int> vec = img->GetPixel(ix);
- itk::VariableLengthVector<float> pixel = m_Data->GetPixel(ix);
- for(int j=0; j<vec.Size(); j++)
- {
- int pos = currIndex+j;
- float f = vec.GetElement(j);
- pixel.SetElement(pos, f);
-
- }
- m_Data->SetPixel(ix, pixel);
- }
- }
- }
-
- currIndex += img->GetVectorLength();
- tbssImg->SetContainsGradient(true);
- // Read vector image and add to m_Data
- }
- else {
-
- metaInfo.push_back(pair);
- FileReaderType3D::Pointer fileReader = FileReaderType3D::New();
- fileReader->SetFileName(file);
- fileReader->Update();
-
- FloatImage3DType::Pointer img = fileReader->GetOutput();
-
- FloatImage3DType::SizeType size = img->GetLargestPossibleRegion().GetSize();
-
- if(i==0)
- {
- // First image in serie. Properties should be used to initialize m_Data
- m_Data->SetRegions(img->GetLargestPossibleRegion().GetSize());
- m_Data->SetSpacing(img->GetSpacing());
- m_Data->SetOrigin(img->GetOrigin());
- m_Data->SetDirection(img->GetDirection());
- m_Data->SetVectorLength(vecLength);
- m_Data->Allocate();
- }
-
- for(int x=0; x<size[0]; x++)
- {
- for(int y=0; y<size[1]; y++)
- {
- for(int z=0; z<size[2]; z++)
- {
- itk::Index<3> ix;
- ix[0] = x;
- ix[1] = y;
- ix[2] = z;
-
- float f = img->GetPixel(ix);
- itk::VariableLengthVector<float> pixel = m_Data->GetPixel(ix);
- pixel.SetElement(currIndex, f);
- m_Data->SetPixel(ix, pixel);
-
- }
- }
- }
- }
-
- if(pair.first == mitk::TbssImage::MEAN_FA_SKELETON)
- {
- tbssImg->SetContainsMeanSkeleton(true);
- }
- else if(pair.first == mitk::TbssImage::MEAN_FA_SKELETON_MASK)
- {
- tbssImg->SetContainsSkeletonMask(true);
- }
- else if(pair.first == mitk::TbssImage::DISTANCE_MAP)
- {
- tbssImg->SetContainsDistanceMap(true);
- }
-
- currIndex++;
-
- }
-
- tbssImg->SetIsMeta(true);
- tbssImg->SetImage(m_Data);
- tbssImg->SetMetaInfo(metaInfo);
- tbssImg->InitializeFromVectorImage();
-
- return tbssImg;
- }
-
-
- mitk::TbssImage::MetaDataFunction mitk::TbssImporter::RetrieveTbssFunction(std::string s)
- {
- if(s == "skeleton mask")
- {
- return mitk::TbssImage::MEAN_FA_SKELETON_MASK;
- }
- else if(s == "mean fa skeleton")
- {
- return mitk::TbssImage::MEAN_FA_SKELETON;
- }
- else if(s == "gradient image")
- {
- return mitk::TbssImage::GRADIENT_X;
- }
- else if(s == "tubular structure")
- {
- return mitk::TbssImage::TUBULAR_STRUCTURE;
- }
- else if(s == "distance map")
- {
- return mitk::TbssImage::DISTANCE_MAP;
- }
- return mitk::TbssImage::MISC;
- }
}
#endif // __mitkTbssImporter_cpp
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.h b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.h
index b5b4930d4d..c5b6390ad2 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.h
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.h
@@ -1,115 +1,96 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkTbssImporter_h
#define __mitkTbssImporter_h
#include "mitkCommon.h"
#include "mitkFileReader.h"
#include "itkImage.h"
#include "itkVectorImage.h"
-#include "itkImageFileReader.h"
+
#include "mitkTbssImage.h"
#include "QuantificationExports.h"
-
namespace mitk
{
- //template<class TPixelType>
- class Quantification_EXPORT TbssImporter : public itk::Object {
- public:
- // typedef TPixelType PixelType;
- typedef itk::VectorImage<float,3> DataImageType; // type of the 3d vector image containing the skeletonized images
- typedef itk::VectorImage<int,3> VectorImageType; // Datatype of the tbss gradient images
- typedef itk::Image<float, 4> FloatImage4DType;
- typedef itk::ImageFileReader<FloatImage4DType> FileReaderType4D;
- typedef itk::ImageFileReader<VectorImageType> VectorReaderType;
+/**
+ * \brief Converts FSL TBSS data (4D skeleton projection images) to a NRRD image with meta data.
+ *
+ * The TBSS pipeline of FSL produces a 4D image containing the 3D skeleton projections of all individuals.
+ * This class converts the FSL Nifty image to NRRD and adds information about the type of measurement and the study groups.
+ */
- typedef itk::Image<float, 3> FloatImage3DType;
- typedef itk::ImageFileReader<FloatImage3DType> FileReaderType3D;
+ class Quantification_EXPORT TbssImporter : public itk::Object {
+ public:
+ // type of the 3d vector image containing the skeletonized images
+ typedef itk::VectorImage<float,3> DataImageType;
mitkClassMacro( TbssImporter, Object )
itkNewMacro(Self)
-
-
+ /* \brief Converts the FSL Nifty to NRRD and adds the meta data */
mitk::TbssImage::Pointer Import();
- mitk::TbssImage::Pointer ImportMeta();
-
+ /* \brief Group info is set by providing a vector with pairs of group name and number*/
void SetGroupInfo(std::vector< std::pair<std::string, int> > groups)
{
m_Groups = groups;
}
- std::vector< std::pair<std::string, int> > GetGroupInfo()
- {
- return m_Groups;
- }
-
- void SetTbssDatasets(std::vector< std::pair<std::string, std::string> > files)
- {
- m_MetaFiles = files;
- }
+ /* \brief Used to indicate the type of measurement */
void SetMeasurementInfo(std::string s)
{
m_MeasurementInfo = s;
}
- std::string GetMeasurementInfo()
- {
- return m_MeasurementInfo;
- }
-
+ /* \brief Sets the FSL import volume */
void SetImportVolume(mitk::Image::Pointer inputVolume)
{
m_InputVolume = inputVolume;
}
protected:
TbssImporter(){}
virtual ~TbssImporter(){}
DataImageType::Pointer m_Data;
+
std::vector< std::pair<std::string, int> > m_Groups;
- std::vector< std::pair<std::string, std::string> > m_MetaFiles;
std::string m_MeasurementInfo;
-
mitk::Image::Pointer m_InputVolume;
- mitk::TbssImage::MetaDataFunction RetrieveTbssFunction(std::string s);
};
}
-//#include "mitkTbssImporter.cpp"
#endif // __mitkTbssImporter_h
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImage.h b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImage.h
index d11743670f..f31dd5a975 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImage.h
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImage.h
@@ -1,132 +1,132 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkTbssRoiImage__h
#define __mitkTbssRoiImage__h
#include "mitkImage.h"
#include "itkImage.h"
#include "mitkImageCast.h"
#include "QuantificationExports.h"
namespace mitk
{
/**
* \brief this class encapsulates diffusion volumes (vectorimages not
* yet supported by mitkImage)
*/
class Quantification_EXPORT TbssRoiImage : public Image
{
public:
typedef itk::Image<char, 3> ImageType;
typedef itk::Index<3> IndexType;
//typedef typename std::vector <Index<3> > RoiType;
mitkClassMacro( TbssRoiImage, Image )
itkNewMacro(Self)
//void SetRequestedRegionToLargestPossibleRegion();
//bool RequestedRegionIsOutsideOfTheBufferedRegion();
//virtual bool VerifyRequestedRegion();
- //void SetRequestedRegion(itk::DataObject *data);
+ //void SetRequestedRegion( const itk::DataObject *data);
ImageType::Pointer GetImage()
{
return m_Image;
}
void SetImage(ImageType::Pointer image )
{
this->m_Image = image;
}
itkGetMacro(PreprocessedFA, bool)
itkSetMacro(PreprocessedFA, bool)
itkGetMacro(PreprocessedFAFile, std::string)
itkSetMacro(PreprocessedFAFile, std::string)
itkGetMacro(Structure, std::string)
itkSetMacro(Structure, std::string)
void SetRoi(std::vector< itk::Index<3> > roi)
{
m_Roi = roi;
}
// depricated
std::vector< itk::Index<3> > GetRoi()
{
return m_Roi;
}
void InitializeFromImage()
{
MITK_INFO << "make an mitk image that can be shown by mitk";
this->InitializeByItk(m_Image.GetPointer());
this->SetChannel(m_Image->GetBufferPointer());
}
protected:
TbssRoiImage();
virtual ~TbssRoiImage(){}
ImageType::Pointer m_Image;
std::vector< itk::Index<3> > m_Roi;
bool m_PreprocessedFA;
std::string m_PreprocessedFAFile;
std::string m_Structure;
};
// Does the same es the normal CastToMitkImage, but needed to reimplemented due to the templatet pixeltype
/*
template <typename ItkOutputImageType>
void CastToTbssImage(const ItkOutputImageType* itkimage, itk::SmartPointer< mitk::TbssRoiImage >& tbssoutputimage)
{
if(tbssoutputimage.IsNull())
{
tbssoutputimage = mitk::TbssRoiImage::New();
}
tbssoutputimage->InitializeByItk(itkimage);
tbssoutputimage->SetChannel(itkimage->GetBufferPointer());
}
*/
} // namespace mitk
//#include "mitkTbssRoiImage.cpp"
#endif /* __mitkTbssRoiImage__h */
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp
index 9d225df905..7822a3de94 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp
@@ -1,51 +1,49 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __MITK_NRRD_TBSSROI_VOLUMES_IO_FACTORY_CPP__
#define __MITK_NRRD_TBSSROI_VOLUMES_IO_FACTORY_CPP__
#include "mitkTbssRoiImageSource.h"
#include "mitkTbssRoiImage.h"
mitk::TbssRoiImageSource::TbssRoiImageSource()
{
// Create the output. We use static_cast<> here because we know the default
// output must be of type DiffusionImage
mitk::TbssRoiImage::Pointer output
= static_cast<mitk::TbssRoiImage*>(this->MakeOutput(0).GetPointer());
Superclass::SetNumberOfRequiredOutputs(1);
Superclass::SetNthOutput(0, output.GetPointer());
}
-itk::DataObject::Pointer mitk::TbssRoiImageSource::MakeOutput( unsigned int /*idx*/ )
+itk::DataObject::Pointer mitk::TbssRoiImageSource::MakeOutput( itk::ProcessObject::DataObjectPointerArraySizeType /*idx*/ )
{
return static_cast<itk::DataObject*>(mitk::TbssRoiImage::New().GetPointer());
}
mitk::TbssRoiImageSource::OutputType* mitk::TbssRoiImageSource::GetOutput(unsigned int idx)
{
return static_cast<OutputType*>
(this->ProcessObject::GetOutput(idx));
}
-
-
#endif //__MITK_NRRD_TBSS_VOULMES_IO_FACTORY_CPP__
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImageSource.h b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImageSource.h
index 993fa324fa..4570c69165 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImageSource.h
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssRoiImageSource.h
@@ -1,75 +1,62 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_TBSS_ROI_IMAGE_DATA_SOURCE_H_HEADER_
#define _MITK_TBSS_ROI_IMAGE_DATA_SOURCE_H_HEADER_
// Should be changed in a new type for TBSS
#include "mitkImageSource.h"
#include "QuantificationExports.h"
namespace mitk {
class TbssRoiImage;
//##Documentation
//## @brief Superclass of all classes generating diffusion volumes (instances
//## of class DiffusionImage) as output.
//##
//## @ingroup Process
class Quantification_EXPORT TbssRoiImageSource : public ImageSource
{
public:
mitkClassMacro(TbssRoiImageSource, BaseProcess)
itkNewMacro(Self)
typedef TbssRoiImage OutputType;
typedef itk::DataObject::Pointer DataObjectPointer;
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx);
- OutputType * GetOutput(unsigned int idx);
-
- //void SetOutput(OutputType* output);
-
- OutputType* GetOutput();
- //{return Superclass::GetOutput();}
-
- //OutputType* GetOutput(unsigned int idx);
-
- //virtual void GraftOutput(OutputType* graft);
-
- //virtual void GraftNthOutput(unsigned int idx, OutputType *graft);
+ OutputType* GetOutput(unsigned int idx);
protected:
TbssRoiImageSource();
virtual ~TbssRoiImageSource(){}
};
} // namespace mitk
-//#include "mitkTbssRoiImageSource.cpp"
-
#endif /* _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_ */
diff --git a/Modules/DiffusionImaging/Quantification/Testing/mitkTbssNrrdImageReaderTest.cpp b/Modules/DiffusionImaging/Quantification/Testing/mitkTbssNrrdImageReaderTest.cpp
index b37d0ed7f9..0070af8578 100644
--- a/Modules/DiffusionImaging/Quantification/Testing/mitkTbssNrrdImageReaderTest.cpp
+++ b/Modules/DiffusionImaging/Quantification/Testing/mitkTbssNrrdImageReaderTest.cpp
@@ -1,67 +1,67 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkNrrdTbssImageReader.h>
#include "mitkQuantificationObjectFactory.h"
#include "mitkCoreObjectFactory.h"
/**Documentation
* test for the class "mitkNrrdTbssImageReader".
*/
int mitkTbssNrrdImageReaderTest(int argc , char* argv[])
{
MITK_TEST_BEGIN("TbssNrrdImageReaderTest");
mitk::NrrdTbssImageReader::Pointer tbssNrrdReader = mitk::NrrdTbssImageReader::New();
MITK_TEST_CONDITION_REQUIRED(tbssNrrdReader.GetPointer(), "Testing initialization of test object!");
RegisterQuantificationObjectFactory();
tbssNrrdReader->SetFileName(argv[1]);
MITK_TEST_CONDITION_REQUIRED( tbssNrrdReader->CanReadFile(argv[1], "", ""), "Testing CanReadFile() method with valid input file name!");
tbssNrrdReader->Update();
- mitk::TbssImage* tbssImg = tbssNrrdReader->GetOutput(0);
+ mitk::TbssImage* tbssImg = tbssNrrdReader->GetOutput();
MITK_TEST_CONDITION_REQUIRED(tbssImg != NULL, "Testing that tbssImg is not null");
mitk::TbssImage::SizeType size = tbssImg->GetLargestPossibleRegion().GetSize();
MITK_TEST_CONDITION_REQUIRED(size[0]==2 && size[1]==2 && size[2]==2, "Test size of tbss image");
// Test groups
std::vector< std::pair<std::string, int> > groups = tbssImg->GetGroupInfo();
std::pair<std::string, int> group1 = groups.at(0);
std::pair<std::string, int> group2 = groups.at(1);
MITK_TEST_CONDITION_REQUIRED(group1.first.compare("group1") && group1.second==1, "Test group 1 info");
MITK_TEST_CONDITION_REQUIRED(group2.first.compare("group2") && group2.second==1, "Test group 2 info");
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/Quantification/Testing/mitkTbssNrrdImageWriterTest.cpp b/Modules/DiffusionImaging/Quantification/Testing/mitkTbssNrrdImageWriterTest.cpp
index 8a43eb80a2..dddcc06f26 100644
--- a/Modules/DiffusionImaging/Quantification/Testing/mitkTbssNrrdImageWriterTest.cpp
+++ b/Modules/DiffusionImaging/Quantification/Testing/mitkTbssNrrdImageWriterTest.cpp
@@ -1,79 +1,79 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkNrrdTbssImageReader.h>
#include <mitkNrrdTbssImageWriter.h>
#include "mitkQuantificationObjectFactory.h"
#include "mitkCoreObjectFactory.h"
/**Documentation
* test for the class "mitkNrrdTbssImageWriter".
*/
int mitkTbssNrrdImageWriterTest(int argc , char* argv[])
{
MITK_TEST_BEGIN("TbssNrrdImageWriterTest");
mitk::NrrdTbssImageReader::Pointer tbssNrrdReader = mitk::NrrdTbssImageReader::New();
MITK_TEST_CONDITION_REQUIRED(tbssNrrdReader.GetPointer(), "Testing initialization of test object!");
RegisterQuantificationObjectFactory();
tbssNrrdReader->SetFileName(argv[1]);
MITK_TEST_CONDITION_REQUIRED( tbssNrrdReader->CanReadFile(argv[1], "", ""), "Testing CanReadFile() method with valid input file name!");
tbssNrrdReader->Update();
- mitk::TbssImage* tbssImg = tbssNrrdReader->GetOutput(0);
+ mitk::TbssImage* tbssImg = tbssNrrdReader->GetOutput();
MITK_TEST_CONDITION_REQUIRED(tbssImg != NULL, "Testing that tbssImg is not null");
mitk::NrrdTbssImageWriter::Pointer tbssNrrdWriter = mitk::NrrdTbssImageWriter::New();
try{
tbssNrrdWriter->SetFileName(argv[2]);
tbssNrrdWriter->SetInput(tbssImg);
tbssNrrdWriter->Update();
}
catch(...) {
std::cout << "Writing failed" << std::endl;
return EXIT_FAILURE;
}
mitk::NrrdTbssImageReader::Pointer tbssNrrdReader2 = mitk::NrrdTbssImageReader::New();
tbssNrrdReader2->SetFileName(argv[1]);
MITK_TEST_CONDITION_REQUIRED( tbssNrrdReader2->CanReadFile(argv[1], "", ""), "Testing CanReadFile() method with previously saved file!");
tbssNrrdReader2->Update();
- mitk::TbssImage* tbssImg2 = tbssNrrdReader2->GetOutput(0);
+ mitk::TbssImage* tbssImg2 = tbssNrrdReader2->GetOutput();
std::vector< std::pair<std::string, int> > groups = tbssImg->GetGroupInfo();
std::vector< std::pair<std::string, int> > groups2 = tbssImg2->GetGroupInfo();
MITK_TEST_CONDITION(groups == groups2, "Check that group information is identical");
mitk::TbssImage::SizeType size = tbssImg->GetLargestPossibleRegion().GetSize();
mitk::TbssImage::SizeType size2 = tbssImg2->GetLargestPossibleRegion().GetSize();
MITK_TEST_CONDITION(size == size2, "Check that sizes are equal");
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/Quantification/Testing/mitkTbssRoiNrrdImageReaderTest.cpp b/Modules/DiffusionImaging/Quantification/Testing/mitkTbssRoiNrrdImageReaderTest.cpp
index f2bdb0612b..259086685e 100644
--- a/Modules/DiffusionImaging/Quantification/Testing/mitkTbssRoiNrrdImageReaderTest.cpp
+++ b/Modules/DiffusionImaging/Quantification/Testing/mitkTbssRoiNrrdImageReaderTest.cpp
@@ -1,69 +1,69 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkNrrdTbssRoiImageReader.h>
#include "mitkDiffusionImagingObjectFactory.h"
#include "mitkCoreObjectFactory.h"
/**Documentation
* test for the class "mitkNrrdTbssImageReader".
*/
int mitkTbssRoiNrrdImageReaderTest(int argc , char* argv[])
{
MITK_TEST_BEGIN("NrrdTbssRoiImageReaderTest");
mitk::NrrdTbssRoiImageReader::Pointer roiReader = mitk::NrrdTbssRoiImageReader::New();
MITK_TEST_CONDITION_REQUIRED(roiReader.GetPointer(), "Testing initialization of test object!");
RegisterDiffusionImagingObjectFactory();
roiReader->SetFileName(argv[1]);
MITK_TEST_CONDITION_REQUIRED( roiReader->CanReadFile(argv[1], "", ""), "Testing CanReadFile() method with valid input file name!");
roiReader->Update();
- mitk::TbssRoiImage* roiImg = roiReader->GetOutput(0);
+ mitk::TbssRoiImage* roiImg = roiReader->GetOutput();
MITK_TEST_CONDITION_REQUIRED(roiImg != NULL, "Testing that roiImg is not null");
mitk::TbssRoiImage::SizeType size = roiImg->GetLargestPossibleRegion().GetSize();
MITK_TEST_CONDITION_REQUIRED(size[0]==182 && size[1]==218 && size[2]==182, "Test size of ROI image");
// Test indices of the roi
std::vector< itk::Index<3> > indices = roiImg->GetRoi();
MITK_TEST_CONDITION(indices.size() == 24, "Test the number of indices belonging to the Roi");
itk::Index<3> ix = indices.at(0);
MITK_TEST_CONDITION(ix[0]==90 && ix[1]==132 && ix[2]==74, "Test whether first index is correct");
ix = indices.at(23);
MITK_TEST_CONDITION(ix[0]==90 && ix[1]==117 && ix[2]==88, "Test whether last index is correct");
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/Quantification/files.cmake b/Modules/DiffusionImaging/Quantification/files.cmake
index 817dd133ab..5f136e1209 100644
--- a/Modules/DiffusionImaging/Quantification/files.cmake
+++ b/Modules/DiffusionImaging/Quantification/files.cmake
@@ -1,35 +1,38 @@
set(CPP_FILES
# DataStructures -> Tbss
IODataStructures/TbssImages/mitkTbssImageSource.cpp
IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp
IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
IODataStructures/TbssImages/mitkNrrdTbssImageIOFactory.cpp
IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
IODataStructures/TbssImages/mitkNrrdTbssRoiImageIOFactory.cpp
IODataStructures/TbssImages/mitkTbssImage.cpp
IODataStructures/TbssImages/mitkTbssRoiImage.cpp
IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
IODataStructures/TbssImages/mitkNrrdTbssImageWriterFactory.cpp
IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.cpp
IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriterFactory.cpp
IODataStructures/TbssImages/mitkTbssImporter.cpp
# DataStructures
IODataStructures/mitkQuantificationObjectFactory.cpp
# Rendering
Rendering/mitkTbssImageMapper.cpp
+
+ #Algorithms
+ Algorithms/mitkTractAnalyzer.cpp
)
set(H_FILES
# DataStructures
IODataStructures/TbssImages/mitkTbssImporter.h
# Rendering
Rendering/mitkTbssImageMapper.h
Algorithms/itkRegularizedIVIMLocalVariationImageFilter.h
Algorithms/itkRegularizedIVIMReconstructionFilter.h
Algorithms/itkRegularizedIVIMReconstructionSingleIteration.h
)
\ No newline at end of file
diff --git a/Modules/GraphAlgorithms/files.cmake b/Modules/GraphAlgorithms/files.cmake
index 0de34bc90f..433112a1c8 100644
--- a/Modules/GraphAlgorithms/files.cmake
+++ b/Modules/GraphAlgorithms/files.cmake
@@ -1,9 +1,10 @@
set(CPP_FILES
itkShortestPathNode.cpp
)
set(H_FILES
itkShortestPathCostFunction.h
itkShortestPathCostFunctionTbss.h
itkShortestPathNode.h
itkShortestPathImageFilter.h
+ itkShortestPathCostFunctionLiveWire.h
)
diff --git a/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.h b/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.h
new file mode 100644
index 0000000000..033c92951c
--- /dev/null
+++ b/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.h
@@ -0,0 +1,204 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __itkShortestPathCostFunctionLiveWire_h
+#define __itkShortestPathCostFunctionLiveWire_h
+
+#include "itkObject.h"
+#include "itkObjectFactory.h"
+#include "itkShortestPathCostFunction.h" // Superclass of Metrics
+
+#include <itkImageRegionConstIterator.h>
+
+
+
+
+namespace itk
+{
+ /** \brief Cost function for LiveWire purposes.
+ Specific features are considered to calculate cummulative
+ costs of a link between two pixels. These are:
+
+ - Gradient Magnitude
+ - Gradient Direction
+ - Laplacian Zero Crossing
+
+ By default the Gradient Magnitude is mapped linear to costs
+ between 0 (good) and 1 (bad). Via SetDynamicCostMap( std::map< int, int > &costMap)
+ a cost map can be set to dynamically map Gradient Magnitude (non
+ linear). Thus lower values can be considered with lower costs
+ than higher values of gradient magnitudes.
+ To compute the costs of the gradient magnitude dynamically
+ a iverted map of the histogram of gradient magnitude image is used.
+
+ */
+ template <class TInputImageType>
+ class ITK_EXPORT ShortestPathCostFunctionLiveWire : public ShortestPathCostFunction<TInputImageType>
+ {
+ public:
+ /** Standard class typedefs. */
+ typedef ShortestPathCostFunctionLiveWire Self;
+ typedef ShortestPathCostFunction<TInputImageType> Superclass;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+ typedef itk::ImageRegionConstIterator<TInputImageType> ConstIteratorType;
+
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self);
+
+ /** Run-time type information (and related methods). */
+ itkTypeMacro(ShortestPathCostFunctionLiveWire, ShortestPathCostFunction);
+
+
+ typedef itk::Image<unsigned char, 2> UnsignedCharImageType;
+ typedef itk::Image<float, 2> FloatImageType;
+
+ typedef float ComponentType;
+ typedef itk::CovariantVector< ComponentType, 2 > OutputPixelType;
+ typedef itk::Image< OutputPixelType, 2 > VectorOutputImageType;
+
+ typedef typename TInputImageType::IndexType IndexType;
+ typedef TInputImageType ImageType;
+ typedef itk::ImageRegion<2> RegionType;
+
+
+
+ /** \brief calculates the costs for going from p1 to p2*/
+ virtual double GetCost(IndexType p1, IndexType p2);
+
+ /** \brief returns the minimal costs possible (needed for A*)*/
+ virtual double GetMinCost();
+
+ /** \brief Initialize the metric*/
+ virtual void Initialize ();
+
+
+ /** \brief Set repulsive path*/
+ virtual void AddRepulsivePoint( itk::Index<3> );
+
+ /** \brief Clear repulsive path*/
+ virtual void ClearRepulsivePoints( );
+
+
+
+ ShortestPathCostFunctionLiveWire();
+
+
+ itkSetMacro (RequestedRegion, RegionType);
+ itkGetMacro (RequestedRegion, RegionType);
+
+ // Set/Get function for sigma parameter
+ itkSetMacro (UseApproximateGradient, bool);
+ itkGetMacro (UseApproximateGradient, bool);
+
+ virtual void SetImage(const TInputImageType* _arg)
+ {
+ if (this->m_Image != _arg)
+ {
+ this->m_Image = _arg;
+ this->Modified();
+ this->m_Initialized = false;
+ }
+ }
+
+ void SetDynamicCostMap( std::map< int, int > &costMap)
+ {
+ this->m_CostMap = costMap;
+ this->m_UseCostMap = true;
+ this->m_MaxMapCosts = -1;
+ this->Modified();
+ }
+
+ void SetUseCostMap(bool useCostMap)
+ {
+ this->m_UseCostMap = useCostMap;
+ }
+
+ /**
+ \brief Set the maximum of the dynamic cost map to save computation time.
+ */
+ void SetCostMapMaximum(double max)
+ {
+ this->m_MaxMapCosts = max;
+ }
+
+
+ enum Constants{
+ MAPSCALEFACTOR = 10
+ };
+
+ /** \brief Returns the y value of gaussian with given offset and amplitude
+
+ gaussian approximation
+ f(x) = v(bin) * e^ ( -1/2 * (|x-k(bin)| / sigma)^2 )
+
+ \param x
+ \param xOfGaussian - offset
+ \param yOfGaussian - amplitude
+ */
+ static double Gaussian(double x, double xOfGaussian, double yOfGaussian);
+
+ protected:
+
+ virtual ~ShortestPathCostFunctionLiveWire() {};
+
+
+ typename ImageType::Pointer m_GradientMagnImage;
+ typename UnsignedCharImageType::Pointer m_ZeroCrossingsImage;
+ typename FloatImageType::Pointer m_EdgeImage;
+ typename VectorOutputImageType::Pointer m_GradientImage;
+
+ double minCosts;
+
+ bool m_UseRepulsivePoint;
+
+ std::vector< itk::Index<3> > m_RepulsivePoints;
+
+ typename Superclass::PixelType val;
+
+ typename Superclass::PixelType startValue;
+ typename Superclass::PixelType endValue;
+
+ double m_GradientMax;
+
+ RegionType m_RequestedRegion;
+
+ bool m_UseApproximateGradient;
+
+ bool m_Initialized;
+
+ std::map< int, int > m_CostMap;
+
+ bool m_UseCostMap;
+
+ double m_MaxMapCosts;
+
+ private:
+
+ double SigmoidFunction(double I, double max, double min, double alpha, double beta);
+
+
+ };
+
+} // end namespace itk
+
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkShortestPathCostFunctionLiveWire.txx"
+#endif
+
+#endif /* __itkShortestPathCostFunctionLiveWire_h */
diff --git a/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.txx b/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.txx
new file mode 100644
index 0000000000..a9ad943a75
--- /dev/null
+++ b/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.txx
@@ -0,0 +1,441 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __itkShortestPathCostFunctionLiveWire_txx
+#define __itkShortestPathCostFunctionLiveWire_txx
+
+#include "itkShortestPathCostFunctionLiveWire.h"
+
+#include <math.h>
+
+#include <itkStatisticsImageFilter.h>
+#include <itkZeroCrossingImageFilter.h>
+#include <itkCannyEdgeDetectionImageFilter.h>
+#include <itkCastImageFilter.h>
+#include <itkGradientImageFilter.h>
+#include <itkGradientRecursiveGaussianImageFilter.h>
+#include <itkGradientMagnitudeImageFilter.h>
+#include <itkGradientMagnitudeRecursiveGaussianImageFilter.h>
+#include <itkLaplacianImageFilter.h>
+
+
+namespace itk
+{
+
+ // Constructor
+ template<class TInputImageType>
+ ShortestPathCostFunctionLiveWire<TInputImageType>
+ ::ShortestPathCostFunctionLiveWire()
+ {
+ m_UseRepulsivePoint = false;
+ m_GradientMax = 0.0;
+ m_Initialized = false;
+ m_UseCostMap = false;
+ m_MaxMapCosts = -1.0;
+ }
+
+
+
+ template<class TInputImageType>
+ void ShortestPathCostFunctionLiveWire<TInputImageType>
+ ::AddRepulsivePoint( itk::Index<3> c )
+ {
+ m_RepulsivePoints.push_back(c);
+ m_UseRepulsivePoint = true;
+ }
+
+
+
+ template<class TInputImageType>
+ void ShortestPathCostFunctionLiveWire<TInputImageType>
+ ::ClearRepulsivePoints()
+ {
+ m_RepulsivePoints.clear();
+ m_UseRepulsivePoint = false;
+ }
+
+
+
+ template<class TInputImageType>
+ double ShortestPathCostFunctionLiveWire<TInputImageType>
+ ::GetCost(IndexType p1 ,IndexType p2)
+ {
+
+ unsigned long xMAX = this->m_Image->GetLargestPossibleRegion().GetSize()[0];
+ unsigned long yMAX = this->m_Image->GetLargestPossibleRegion().GetSize()[1];
+
+ double gradientX, gradientY;
+ gradientX = gradientY = 0.0;
+
+ double gradientCost;
+
+ double gradientMagnitude;
+
+ /* ++++++++++++++++++++ GradientMagnitude costs ++++++++++++++++++++++++++*/
+
+ gradientMagnitude = this->m_GradientMagnImage->GetPixel(p2);
+ gradientX = m_GradientImage->GetPixel(p2)[0];
+ gradientY = m_GradientImage->GetPixel(p2)[1];
+
+
+
+ if(m_UseCostMap && !m_CostMap.empty())
+ {
+ std::map< int, int >::iterator end = m_CostMap.end();
+ std::map< int, int >::iterator last = --(m_CostMap.end());
+
+ //current position
+ std::map< int, int >::iterator x;
+ //std::map< int, int >::key_type keyOfX = static_cast<std::map< int, int >::key_type>(gradientMagnitude * 1000);
+ int keyOfX = static_cast<int >(gradientMagnitude /* ShortestPathCostFunctionLiveWire::MAPSCALEFACTOR*/);
+ x = m_CostMap.find( keyOfX );
+
+ std::map< int, int >::iterator left2;
+ std::map< int, int >::iterator left1;
+ std::map< int, int >::iterator right1;
+ std::map< int, int >::iterator right2;
+
+ if( x == end )
+ {//x can also be == end if the key is not in the map but between two other keys
+ //search next key within map from x upwards
+ right1 = m_CostMap.lower_bound( keyOfX );
+ }
+ else
+ {
+ right1 = x;
+ }
+
+ if(right1 == end || right1 == last )
+ {
+ right2 = end;
+ }
+ else//( right1 != (end-1) )
+ {
+ std::map< int, int >::iterator temp = right1;
+ right2 = ++right1;//rght1 + 1
+ right1 = temp;
+ }
+
+
+ if( right1 == m_CostMap.begin() )
+ {
+ left1 = end;
+ left2 = end;
+ }
+ else if( right1 == (++(m_CostMap.begin())) )
+ {
+ std::map< int, int >::iterator temp = right1;
+ left1 = --right1;//rght1 - 1
+ right1 = temp;
+ left2 = end;
+ }
+ else
+ {
+ std::map< int, int >::iterator temp = right1;
+ left1 = --right1;//rght1 - 1
+ left2 = --right1;//rght1 - 2
+ right1 = temp;
+ }
+
+ double partRight1, partRight2, partLeft1, partLeft2;
+ partRight1 = partRight2 = partLeft1 = partLeft2 = 0.0;
+
+
+ /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ f(x) = v(bin) * e^ ( -1/2 * (|x-k(bin)| / sigma)^2 )
+
+ gaussian approximation
+
+ where
+ v(bin) is the value in the map
+ k(bin) is the key
+ */
+ if( left2 != end )
+ {
+ partLeft2 = ShortestPathCostFunctionLiveWire<TInputImageType>::Gaussian(keyOfX, left2->first, left2->second);
+ }
+
+ if( left1 != end )
+ {
+ partLeft1 = ShortestPathCostFunctionLiveWire<TInputImageType>::Gaussian(keyOfX, left1->first, left1->second);
+ }
+
+ if( right1 != end )
+ {
+ partRight1 = ShortestPathCostFunctionLiveWire<TInputImageType>::Gaussian(keyOfX, right1->first, right1->second);
+ }
+
+ if( right2 != end )
+ {
+ partRight2 = ShortestPathCostFunctionLiveWire<TInputImageType>::Gaussian(keyOfX, right2->first, right2->second);
+ }
+ /*----------------------------------------------------------------------------*/
+
+
+ if( m_MaxMapCosts > 0.0 )
+ {
+ gradientCost = 1.0 - ( (partRight1 + partRight2 + partLeft1 + partLeft2) / m_MaxMapCosts );
+ }
+ else
+ {//use linear mapping
+ gradientCost = 1.0 - (gradientMagnitude / m_GradientMax);
+ }
+
+ }
+ else
+ {//use linear mapping
+ //value between 0 (good) and 1 (bad)
+ gradientCost = 1.0 - (gradientMagnitude / m_GradientMax);
+
+ }
+ /* -----------------------------------------------------------------------------*/
+
+
+
+ /* ++++++++++++++++++++ Laplacian zero crossing costs ++++++++++++++++++++++++++*/
+ // f(p) = 0; if I(p)=0
+ // or 1; if I(p)!=0
+ double laplacianCost;
+ typename Superclass::PixelType laplaceImageValue;
+
+
+ laplaceImageValue = m_EdgeImage->GetPixel(p2);
+
+ if(laplaceImageValue < 0 || laplaceImageValue > 0)
+ {
+ laplacianCost = 1.0;
+ }
+ else
+ {
+ laplacianCost = 0.0;
+ }
+
+ /* -----------------------------------------------------------------------------*/
+
+
+
+ /* ++++++++++++++++++++ Gradient direction costs ++++++++++++++++++++++++++*/
+ //vector q-p i.e. p2-p1
+ double vQP[2];
+ vQP[0] = p2[0] - p1[0];
+ vQP[1] = p2[1] - p1[1];
+ //-------
+
+ //vector p-q i.e. p1-p2
+ double vPQ[2];
+ vPQ[0] = p1[0] - p2[0];
+ vPQ[1] = p1[1] - p2[1];
+ //-------
+
+ // gradient vector at p1
+ double nGradientAtP1[2];
+ nGradientAtP1[0] = gradientX;//previously computed for gradient magnitude
+ nGradientAtP1[1] = gradientY;
+
+ //gradient direction unit vector of p1
+ nGradientAtP1[0] /= gradientMagnitude;
+ nGradientAtP1[1] /= gradientMagnitude;
+ //-------
+
+ // gradient vector at p1
+ double nGradientAtP2[2];
+
+
+ nGradientAtP2[0] = m_GradientImage->GetPixel(p2)[0];
+ nGradientAtP2[1] = m_GradientImage->GetPixel(p2)[1];
+
+ nGradientAtP2[0] /= m_GradientMagnImage->GetPixel(p2);
+ nGradientAtP2[1] /= m_GradientMagnImage->GetPixel(p2);
+
+
+ double scalarProduct = (nGradientAtP1[0] * nGradientAtP2[0]) + (nGradientAtP1[1] * nGradientAtP2[1]);
+ if( abs(scalarProduct) >= 1.0)
+ {
+ //this should probably not happen; make sure the input for acos is valid
+ scalarProduct = 0.999999999;
+ }
+
+ double gradientDirectionCost = acos( scalarProduct ) / 3.14159265;
+ /*------------------------------------------------------------------------*/
+
+
+
+
+ /*+++++++++++++++++++++ local component costs +++++++++++++++++++++++++++*/
+ /*weights*/
+ double w1;
+ double w2;
+ double w3;
+ double costs = 0.0;
+
+ if (this->m_UseCostMap){
+ w1 = 0.43;
+ w2= 0.43;
+ w3 = 0.14;
+ }else{
+ w1 = 0.10;
+ w2= 0.85;
+ w3 = 0.05;
+ }
+ costs = w1 * laplacianCost + w2 * gradientCost + w3 * gradientDirectionCost;
+
+
+ //scale by euclidian distance
+ double costScale;
+ if( p1[0] == p2[0] || p1[1] == p2[1])
+ {
+ //horizontal or vertical neighbor
+ costScale = 1.0;
+ }
+ else
+ {
+ //diagonal neighbor
+ costScale = sqrt(2.0);
+ }
+
+ costs *= costScale;
+
+ return costs;
+ }
+
+
+
+ template<class TInputImageType>
+ double ShortestPathCostFunctionLiveWire<TInputImageType>
+ ::GetMinCost()
+ {
+ return minCosts;
+ }
+
+
+
+ template<class TInputImageType>
+ void ShortestPathCostFunctionLiveWire<TInputImageType>
+ ::Initialize()
+ {
+ if(!m_Initialized)
+ {
+
+
+ typedef itk::CastImageFilter< TInputImageType, FloatImageType > CastFilterType;
+ typename CastFilterType::Pointer castFilter = CastFilterType::New();
+ castFilter->SetInput(this->m_Image);
+
+
+ // init gradient magnitude image
+ typedef itk::GradientMagnitudeImageFilter< FloatImageType, FloatImageType> GradientMagnitudeFilterType;
+ typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
+ gradientFilter->SetInput(castFilter->GetOutput());
+ //gradientFilter->SetNumberOfThreads(4);
+ //gradientFilter->GetOutput()->SetRequestedRegion(m_RequestedRegion);
+
+ gradientFilter->Update();
+ m_GradientMagnImage = gradientFilter->GetOutput();
+
+ typedef itk::StatisticsImageFilter<FloatImageType> StatisticsImageFilterType;
+ typename StatisticsImageFilterType::Pointer statisticsImageFilter = StatisticsImageFilterType::New();
+ statisticsImageFilter->SetInput(this->m_GradientMagnImage);
+ statisticsImageFilter->Update();
+
+ m_GradientMax = statisticsImageFilter->GetMaximum();
+
+
+
+ //Filter class is instantiated
+ /*typedef itk::GradientRecursiveGaussianImageFilter<TInputImageType, VectorOutputImageType> GradientFilterType;*/
+
+ typedef itk::GradientImageFilter< FloatImageType > GradientFilterType;
+
+ typename GradientFilterType::Pointer filter = GradientFilterType::New();
+ //sigma is specified in millimeters
+ //filter->SetSigma( 1.5 );
+ filter->SetInput(castFilter->GetOutput());
+ filter->Update();
+
+ m_GradientImage = filter->GetOutput();
+
+
+ // init zero crossings
+ //typedef itk::ZeroCrossingImageFilter< TInputImageType, UnsignedCharImageType > ZeroCrossingImageFilterType;
+ //ZeroCrossingImageFilterType::Pointer zeroCrossingImageFilter = ZeroCrossingImageFilterType::New();
+ //zeroCrossingImageFilter->SetInput(this->m_Image);
+ //zeroCrossingImageFilter->SetBackgroundValue(1);
+ //zeroCrossingImageFilter->SetForegroundValue(0);
+ //zeroCrossingImageFilter->SetNumberOfThreads(4);
+ //zeroCrossingImageFilter->Update();
+
+ //m_EdgeImage = zeroCrossingImageFilter->GetOutput();
+
+
+ //cast image to float to apply canny edge dection filter
+ /*typedef itk::CastImageFilter< TInputImageType, FloatImageType > CastFilterType;
+ CastFilterType::Pointer castFilter = CastFilterType::New();
+ castFilter->SetInput(this->m_Image);*/
+
+ //typedef itk::LaplacianImageFilter<FloatImageType, FloatImageType > filterType;
+ //filterType::Pointer laplacianFilter = filterType::New();
+ //laplacianFilter->SetInput( castFilter->GetOutput() ); // NOTE: input image type must be double or float
+ //laplacianFilter->Update();
+
+ //m_EdgeImage = laplacianFilter->GetOutput();
+
+ //init canny edge detection
+ typedef itk::CannyEdgeDetectionImageFilter<FloatImageType, FloatImageType> CannyEdgeDetectionImageFilterType;
+ typename CannyEdgeDetectionImageFilterType::Pointer cannyEdgeDetectionfilter = CannyEdgeDetectionImageFilterType::New();
+ cannyEdgeDetectionfilter->SetInput(castFilter->GetOutput());
+ cannyEdgeDetectionfilter->SetUpperThreshold(30);
+ cannyEdgeDetectionfilter->SetLowerThreshold(15);
+ cannyEdgeDetectionfilter->SetVariance(4);
+ cannyEdgeDetectionfilter->SetMaximumError(.01f);
+
+ cannyEdgeDetectionfilter->Update();
+ m_EdgeImage = cannyEdgeDetectionfilter->GetOutput();
+
+
+ // set minCosts
+ minCosts = 0.0; // The lower, the more thouroughly! 0 = dijkstra. If estimate costs are lower than actual costs everything is fine. If estimation is higher than actual costs, you might not get the shortest but a different path.
+
+ m_Initialized = true;
+ }
+
+ // check start/end point value
+ startValue= this->m_Image->GetPixel(this->m_StartIndex);
+ endValue= this->m_Image->GetPixel(this->m_EndIndex);
+ }
+
+
+
+ template<class TInputImageType>
+ double ShortestPathCostFunctionLiveWire<TInputImageType>::SigmoidFunction(double I, double max, double min, double alpha, double beta)
+ {
+ // Using the SIgmoid formula from ITK Software Guide 6.3.2 Non Linear Mappings
+ double Exponent = -1 * ((I - beta) / alpha);
+ double Factor = 1 / (1 + exp(Exponent));
+ double newI = (max - min) * Factor + min;
+
+ return newI;
+ }
+
+
+ template<class TInputImageType>
+ double ShortestPathCostFunctionLiveWire<TInputImageType>::Gaussian(double x, double xOfGaussian, double yOfGaussian)
+ {
+ return yOfGaussian * exp( -0.5 * pow( (x - xOfGaussian), 2) );
+ }
+
+} // end namespace itk
+
+#endif // __itkShortestPathCostFunctionLiveWire_txx
diff --git a/Modules/GraphAlgorithms/itkShortestPathImageFilter.h b/Modules/GraphAlgorithms/itkShortestPathImageFilter.h
index c93a0204a3..1a3216a6dc 100644
--- a/Modules/GraphAlgorithms/itkShortestPathImageFilter.h
+++ b/Modules/GraphAlgorithms/itkShortestPathImageFilter.h
@@ -1,225 +1,232 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkShortestPathImageFilter_h
#define __itkShortestPathImageFilter_h
#include "itkImageToImageFilter.h"
#include "itkShortestPathCostFunction.h"
#include "itkShortestPathNode.h"
#include <itkImageRegionIteratorWithIndex.h>
#include <itkMacro.h>
// ------- INFORMATION ----------
/// SET FUNCTIONS
//void SetInput( ItkImage ) // Compulsory
//void SetStartIndex (const IndexType & StartIndex); // Compulsory
//void SetEndIndex(const IndexType & EndIndex); // Compulsory
//void SetFullNeighborsMode(bool) // Optional (default=false), if false N4, if true N26
//void SetActivateTimeOut(bool) // Optional (default=false), for debug issues: after 30s algorithms terminates. You can have a look at the VectorOrderImage to see how far it came
//void SetMakeOutputImage(bool) // Optional (default=true), Generate an outputimage of the path. You can also get the path directoy with GetVectorPath()
//void SetCalcAllDistances(bool) // Optional (default=false), Calculate Distances over the whole image. CAREFUL, algorithm time extends a lot. Necessary for GetDistanceImage
//void SetStoreVectorOrder(bool) // Optional (default=false), Stores in which order the pixels were checked. Necessary for GetVectorOrderImage
//void AddEndIndex(const IndexType & EndIndex) //Optional. By calling this function you can add several endpoints! The algorithm will look for several shortest Pathes. From Start to all Endpoints.
//
/// GET FUNCTIONS
//std::vector< itk::Index<3> > GetVectorPath(); // returns the shortest path as vector
//std::vector< std::vector< itk::Index<3> > GetMultipleVectorPathe(); // returns a vector of shortest Pathes (which are vectors of points)
//GetDistanceImage // Returns the distance image
//GetVectorOrderIMage // Returns the Vector Order image
//
// EXAMPLE USE
// pleae see qmitkmitralvalvesegmentation4dtee bundle
namespace itk
{
template <class TInputImageType, class TOutputImageType>
class ShortestPathImageFilter :
public ImageToImageFilter<TInputImageType, TOutputImageType>
{
public:
//Standard Typedefs
typedef ShortestPathImageFilter Self;
typedef ImageToImageFilter<TInputImageType,TOutputImageType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
// Typdefs for metric
typedef ShortestPathCostFunction< TInputImageType > CostFunctionType;
typedef typename CostFunctionType::Pointer CostFunctionTypePointer;
// More typdefs for convenience
typedef TInputImageType InputImageType;
typedef typename TInputImageType::Pointer InputImagePointer;
typedef typename TInputImageType::PixelType InputImagePixelType;
typedef typename TInputImageType::SizeType InputImageSizeType;
typedef typename TInputImageType::IndexType IndexType;
typedef typename itk::ImageRegionIteratorWithIndex< InputImageType > InputImageIteratorType;
typedef TOutputImageType OutputImageType;
typedef typename TOutputImageType::Pointer OutputImagePointer;
typedef typename TOutputImageType::PixelType OutputImagePixelType;
typedef typename TOutputImageType::IndexType OutputImageIndexType;
typedef ImageRegionIteratorWithIndex< OutputImageType > OutputImageIteratorType;
typedef itk::ShapedNeighborhoodIterator< TInputImageType > itkShapedNeighborhoodIteratorType;
// New Macro for smartpointer instantiation
itkNewMacro(Self)
// Run-time type information
itkTypeMacro(ShortestPathImageFilter, ImageToImageFilter)
// Display
void PrintSelf( std::ostream& os, Indent indent ) const;
// Compare function for A_STAR
struct CompareNodeStar
{
bool operator()(ShortestPathNode *a, ShortestPathNode *b)
{
return (a->distAndEst > b->distAndEst);
}
};
// \brief Set Starpoint for ShortestPath Calculation
void SetStartIndex (const IndexType & StartIndex);
// \brief Adds Endpoint for multiple ShortestPath Calculation
void AddEndIndex (const IndexType & index);
// \brief Set Endpoint for ShortestPath Calculation
void SetEndIndex(const IndexType & EndIndex);
// \brief Set FullNeighborsMode. false = no diagonal neighbors, in 2D this means N4 Neigborhood. true = would be N8 in 2D
itkSetMacro (FullNeighborsMode, bool);
itkGetMacro (FullNeighborsMode, bool);
// \brief (default=true), Produce output image, which shows the shortest path. But you can also get the shortest Path directly as vector with the function GetVectorPath
itkSetMacro (MakeOutputImage, bool);
itkGetMacro (MakeOutputImage, bool);
// \brief (default=false), Store an Vector of Order, so you can call getVectorOrderImage after update
itkSetMacro (StoreVectorOrder, bool);
itkGetMacro (StoreVectorOrder, bool);
// \brief (default=false), // Calculate all Distances to all pixels, so you can call getDistanceImage after update (warning algo will take a long time)
itkSetMacro (CalcAllDistances, bool);
itkGetMacro (CalcAllDistances, bool);
// \brief (default=false), for debug issues: after 30s algorithms terminates. You can have a look at the VectorOrderImage to see how far it came
itkSetMacro (ActivateTimeOut, bool);
itkGetMacro (ActivateTimeOut, bool);
// \brief returns shortest Path as vector
- std::vector< itk::Index<3> > GetVectorPath();
+ std::vector< IndexType > GetVectorPath();
// \brief returns Multiple shortest Paths. You can call this function, when u performed a multiple shortest path search (one start, several ends)
- std::vector< std::vector< itk::Index<3> > > GetMultipleVectorPaths();
+ std::vector< std::vector< IndexType > > GetMultipleVectorPaths();
// \brief returns the vector order image. It shows in which order the pixels were checked. good for debugging. Be sure to have m_StoreVectorOrder=true
OutputImagePointer GetVectorOrderImage();
// \brief returns the distance image. It shows the distances from the startpoint to all other pixels. Be sure to have m_CalcAllDistances=true
OutputImagePointer GetDistanceImage();
+
+ // \brief Fill m_VectorPath
+ void MakeShortestPathVector();
+
// \brief cleans up the filter
void CleanUp();
itkSetObjectMacro( CostFunction, CostFunctionType ); // itkSetObjectMacro = set function that uses pointer as parameter
itkGetObjectMacro( CostFunction, CostFunctionType );
protected:
std::vector< IndexType > m_endPoints; // if you fill this vector, the algo will not rest until all endPoints have been reached
std::vector< IndexType > m_endPointsClosed;
ShortestPathNode* m_Nodes; // main list that contains all nodes
NodeNumType m_Graph_NumberOfNodes;
NodeNumType m_Graph_StartNode;
NodeNumType m_Graph_EndNode;
int m_ImageDimensions;
bool m_Graph_fullNeighbors;
std::vector<ShortestPathNode*> m_Graph_DiscoveredNodeList;
ShortestPathImageFilter(Self&); // intentionally not implemented
void operator=(const Self&); // intentionally not implemented
const static int BACKGROUND = 0;
const static int FOREGROUND = 255;
bool m_FullNeighborsMode;
bool m_MakeOutputImage;
bool m_StoreVectorOrder; // Store an Vector of Order, so you can call getVectorOrderImage after update
bool m_CalcAllDistances; // Calculate all Distances, so you can call getDistanceImage after update (warning algo will take a long time)
bool multipleEndPoints;
bool m_ActivateTimeOut; // if true, then i search max. 30 secs. then abort
+
+ bool m_Initialized;
+
+
CostFunctionTypePointer m_CostFunction;
IndexType m_StartIndex, m_EndIndex;
- std::vector< itk::Index<3> > m_VectorPath;
- std::vector< std::vector< itk::Index<3> > > m_MultipleVectorPaths;
+ std::vector< IndexType > m_VectorPath;
+ std::vector< std::vector< IndexType > > m_MultipleVectorPaths;
std::vector< NodeNumType > m_VectorOrder;
ShortestPathImageFilter();
- // \brief Fill m_VectorPath
- void MakeShortestPathVector();
+ ~ShortestPathImageFilter();
// \brief Create all the outputs
void MakeOutputs();
// \brief Generate Data
void GenerateData();
// \brief gets the estimate costs from pixel a to target.
double getEstimatedCostsToTarget(const IndexType & a);
typename InputImageType::Pointer m_magnitudeImage;
// \brief Convert a indexnumber of a node in m_Nodes to image coordinates
typename TInputImageType::IndexType NodeToCoord(NodeNumType);
// \brief Convert image coordinate to a indexnumber of a node in m_Nodes
unsigned int CoordToNode(IndexType);
// \brief Returns the neighbors of a node
std::vector<ShortestPathNode*> GetNeighbors(NodeNumType nodeNum, bool FullNeighbors);
// \brief Check if coords are in bounds of image
bool CoordIsInBounds(IndexType);
// \brief Initializes the graph
void InitGraph();
// \brief Start ShortestPathSearch
void StartShortestPathSearch();
};
} // end of namespace itk
#include "itkShortestPathImageFilter.txx"
#endif
diff --git a/Modules/GraphAlgorithms/itkShortestPathImageFilter.txx b/Modules/GraphAlgorithms/itkShortestPathImageFilter.txx
index a255040bfb..933130fe43 100644
--- a/Modules/GraphAlgorithms/itkShortestPathImageFilter.txx
+++ b/Modules/GraphAlgorithms/itkShortestPathImageFilter.txx
@@ -1,939 +1,951 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkShortestPathImageFilter_txx
#define __itkShortestPathImageFilter_txx
#include "time.h"
#include "mitkMemoryUtilities.h"
#include <iostream>
#include <algorithm>
#include <vector>
namespace itk
{
// Constructor (initialize standard values)
template <class TInputImageType, class TOutputImageType>
ShortestPathImageFilter<TInputImageType, TOutputImageType>
::ShortestPathImageFilter() :
m_FullNeighborsMode(false),
m_MakeOutputImage(true),
m_StoreVectorOrder(false),
m_CalcAllDistances(false),
m_ActivateTimeOut(false),
- multipleEndPoints(false),
- m_Nodes(0),
- m_Graph_NumberOfNodes(0)
+ multipleEndPoints(false),
+ m_Initialized(false),
+ m_Nodes(0),
+ m_Graph_NumberOfNodes(0)
{
- m_endPoints.clear();
- m_endPointsClosed.clear();
+ m_endPoints.clear();
+ m_endPointsClosed.clear();
- if (m_MakeOutputImage)
- {
- this->SetNumberOfRequiredOutputs(1);
- this->SetNthOutput( 0, OutputImageType::New() );
- }
+ if (m_MakeOutputImage)
+ {
+ this->SetNumberOfRequiredOutputs(1);
+ this->SetNthOutput( 0, OutputImageType::New() );
+ }
}
+
+
+ template <class TInputImageType, class TOutputImageType>
+ ShortestPathImageFilter<TInputImageType, TOutputImageType>
+ ::~ShortestPathImageFilter()
+ {
+ delete [] m_Nodes;
+ }
+
+
+
+
template <class TInputImageType, class TOutputImageType>
inline typename ShortestPathImageFilter<TInputImageType, TOutputImageType>::IndexType
ShortestPathImageFilter<TInputImageType, TOutputImageType>
::NodeToCoord (NodeNumType node)
{
const InputImageSizeType &size = this->GetInput()->GetRequestedRegion().GetSize();
int dim = InputImageType::ImageDimension;
IndexType coord;
if (dim == 2)
{
coord[1] = node / size[0];
coord[0] = node % size[0];
if ((coord[0] >= size[0]) || (coord[1] >= size[1]))
{
coord[0] = 0;
coord[1] = 0;
}
}
if (dim == 3)
{
coord[2] = node / (size[0]*size[1]);
coord[1] = (node % (size[0]*size[1])) / size[0];
coord[0] = (node % (size[0]*size[1])) % size[0];
if ((coord[0] >= size[0]) || (coord[1] >= size[1]) || (coord[2] >= size[2]))
{
coord[0] = 0;
coord[1] = 0;
coord[2] = 0;
}
}
return coord;
}
template <class TInputImageType, class TOutputImageType>
inline typename itk::NodeNumType
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
CoordToNode (IndexType coord)
{
const InputImageSizeType &size = this->GetInput()->GetRequestedRegion().GetSize();
int dim = InputImageType::ImageDimension;
NodeNumType node = 0;
if (dim == 2)
{
node = (coord[1]*size[0]) + coord[0];
}
if (dim == 3)
{
node = (coord[2]*size[0]*size[1]) + (coord[1]*size[0]) + coord[0];
}
if ((m_Graph_NumberOfNodes > 0) && (node >= m_Graph_NumberOfNodes))
- {
- MITK_INFO << "WARNING! Coordinates outside image!";
- MITK_INFO << "Coords = " << coord ;
- MITK_INFO << "ImageDim = " << dim ;
- MITK_INFO << "RequestedRegionSize = " << size ;
+ {
+ /*MITK_INFO << "WARNING! Coordinates outside image!";
+ MITK_INFO << "Coords = " << coord ;
+ MITK_INFO << "ImageDim = " << dim ;
+ MITK_INFO << "RequestedRegionSize = " << size ;*/
node = 0;
- }
+ }
return node;
}
template <class TInputImageType, class TOutputImageType>
inline bool
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
CoordIsInBounds (IndexType coord)
{
const InputImageSizeType &size = this->GetInput()->GetRequestedRegion().GetSize();
int dim = InputImageType::ImageDimension;
if (dim == 2)
{
if ((coord[0] >= 0)
&& (coord[0] < size[0])
&& (coord[1] >= 0 )
&& (coord[1] < size[1] ))
{
return true;
}
}
if (dim == 3)
{
if ((coord[0] >= 0)
&& (coord[0] < size[0])
&& (coord[1] >= 0 )
&& (coord[1] < size[1] )
&& (coord[2] >= 0 )
&& (coord[2] < size[2] ))
{
return true;
}
}
return false;
}
template <class TInputImageType, class TOutputImageType>
inline std::vector< ShortestPathNode* >
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
GetNeighbors (unsigned int nodeNum, bool FullNeighbors)
{
// returns a vector of nodepointers.. these nodes are the neighbors
int dim = InputImageType::ImageDimension;
IndexType Coord = NodeToCoord(nodeNum);
IndexType NeighborCoord;
std::vector<ShortestPathNode*> nodeList;
int neighborDistance = 1; //if i increase that, i might not hit the endnote
- // maybe use itkNeighborhoodIterator here, might be faster
+ // maybe use itkNeighborhoodIterator here, might be faster
if ( dim == 2)
{
// N4
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
if (FullNeighbors)
{
// N8
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
}
}
if ( dim == 3)
{
// N6
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1]-neighborDistance;
NeighborCoord[2] = Coord[2];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1];
NeighborCoord[2] = Coord[2];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1]+neighborDistance;
NeighborCoord[2] = Coord[2];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1];
NeighborCoord[2] = Coord[2];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1];
NeighborCoord[2] = Coord[2]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1];
NeighborCoord[2] = Coord[2]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
if (FullNeighbors)
{
// N26
// Middle Slice
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1]-neighborDistance;
NeighborCoord[2] = Coord[2];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1]-neighborDistance;
NeighborCoord[2] = Coord[2];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1]+neighborDistance;
NeighborCoord[2] = Coord[2];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1]+neighborDistance;
NeighborCoord[2] = Coord[2];
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
// BackSlice (Diagonal)
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1]-neighborDistance;
NeighborCoord[2] = Coord[2]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1]-neighborDistance;
NeighborCoord[2] = Coord[2]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1]+neighborDistance;
NeighborCoord[2] = Coord[2]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1]+neighborDistance;
NeighborCoord[2] = Coord[2]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
//BackSlice (Non-Diag)
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1]-neighborDistance;
NeighborCoord[2] = Coord[2]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1];
NeighborCoord[2] = Coord[2]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1]+neighborDistance;
NeighborCoord[2] = Coord[2]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1];
NeighborCoord[2] = Coord[2]-neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
// FrontSlice (Diagonal)
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1]-neighborDistance;
NeighborCoord[2] = Coord[2]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1]-neighborDistance;
NeighborCoord[2] = Coord[2]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1]+neighborDistance;
NeighborCoord[2] = Coord[2]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1]+neighborDistance;
NeighborCoord[2] = Coord[2]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
//FrontSlice(Non-Diag)
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1]-neighborDistance;
NeighborCoord[2] = Coord[2]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]+neighborDistance;
NeighborCoord[1] = Coord[1];
NeighborCoord[2] = Coord[2]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0];
NeighborCoord[1] = Coord[1]+neighborDistance;
NeighborCoord[2] = Coord[2]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
NeighborCoord[0] = Coord[0]-neighborDistance;
NeighborCoord[1] = Coord[1];
NeighborCoord[2] = Coord[2]+neighborDistance;
if (CoordIsInBounds(NeighborCoord))
nodeList.push_back(&m_Nodes[CoordToNode(NeighborCoord)]);
}
}
return nodeList;
}
template <class TInputImageType, class TOutputImageType>
void ShortestPathImageFilter<TInputImageType, TOutputImageType>::
SetStartIndex (const typename TInputImageType::IndexType &StartIndex)
{
for (unsigned int i=0;i<TInputImageType::ImageDimension;++i)
{
m_StartIndex[i] = StartIndex[i];
}
- m_Graph_StartNode = CoordToNode(m_StartIndex);
- //MITK_INFO << "StartIndex = " << StartIndex;
- //MITK_INFO << "StartNode = " << m_Graph_StartNode;
+ m_Graph_StartNode = CoordToNode(m_StartIndex);
+ //MITK_INFO << "StartIndex = " << StartIndex;
+ //MITK_INFO << "StartNode = " << m_Graph_StartNode;
+ m_Initialized = false;
}
template <class TInputImageType, class TOutputImageType>
void ShortestPathImageFilter<TInputImageType, TOutputImageType>::
SetEndIndex (const typename TInputImageType::IndexType &EndIndex)
{
for (unsigned int i=0;i<TInputImageType::ImageDimension;++i)
{
m_EndIndex[i] = EndIndex[i];
}
- m_Graph_EndNode = CoordToNode(m_EndIndex);
- //MITK_INFO << "EndNode = " << m_Graph_EndNode;
+ m_Graph_EndNode = CoordToNode(m_EndIndex);
+ //MITK_INFO << "EndNode = " << m_Graph_EndNode;
}
- template <class TInputImageType, class TOutputImageType>
+ template <class TInputImageType, class TOutputImageType>
void ShortestPathImageFilter<TInputImageType, TOutputImageType>::
- AddEndIndex (const typename TInputImageType::IndexType &index)
+ AddEndIndex (const typename TInputImageType::IndexType &index)
{
- // ONLY FOR MULTIPLE END POINTS SEARCH
- IndexType newEndIndex;
+ // ONLY FOR MULTIPLE END POINTS SEARCH
+ IndexType newEndIndex;
for (unsigned int i=0;i<TInputImageType::ImageDimension;++i)
{
newEndIndex[i] = index[i];
}
- m_endPoints.push_back(newEndIndex);
- SetEndIndex( m_endPoints[0] );
- multipleEndPoints = true;
+ m_endPoints.push_back(newEndIndex);
+ SetEndIndex( m_endPoints[0] );
+ multipleEndPoints = true;
}
template <class TInputImageType, class TOutputImageType>
inline double ShortestPathImageFilter<TInputImageType, TOutputImageType>::
getEstimatedCostsToTarget (const typename TInputImageType::IndexType &a)
{
// Returns the minimal possible costs for a path from "a" to targetnode.
- itk::Vector<float,3> v;
+ itk::Vector<float,3> v;
v[0] = m_EndIndex[0]-a[0];
v[1] = m_EndIndex[1]-a[1];
v[2] = m_EndIndex[2]-a[2];
- return m_CostFunction->GetMinCost() * v.GetNorm();
+ return m_CostFunction->GetMinCost() * v.GetNorm();
}
template <class TInputImageType, class TOutputImageType>
void
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
InitGraph()
{
- // Clean up previous stuff
- CleanUp();
+ if(!m_Initialized)
+ {
+ // Clean up previous stuff
+ CleanUp();
- // initalize cost function
- m_CostFunction->Initialize();
+ // Calc Number of nodes
+ m_ImageDimensions = TInputImageType::ImageDimension;
+ const InputImageSizeType &size = this->GetInput()->GetRequestedRegion().GetSize();
+ m_Graph_NumberOfNodes = 1;
+ for (NodeNumType i=0; i<m_ImageDimensions; ++i)
+ m_Graph_NumberOfNodes=m_Graph_NumberOfNodes*size[i];
- // Calc Number of nodes
- m_ImageDimensions = TInputImageType::ImageDimension;
- const InputImageSizeType &size = this->GetInput()->GetRequestedRegion().GetSize();
- m_Graph_NumberOfNodes = 1;
- for (NodeNumType i=0; i<m_ImageDimensions; ++i)
- m_Graph_NumberOfNodes=m_Graph_NumberOfNodes*size[i];
+ // Initialize mainNodeList with that number
+ m_Nodes = new ShortestPathNode[m_Graph_NumberOfNodes];
- // Initialize mainNodeList with that number
- m_Nodes = new ShortestPathNode[m_Graph_NumberOfNodes];
+ // Initialize each node in nodelist
+ for (NodeNumType i=0; i<m_Graph_NumberOfNodes; i++)
+ {
+ m_Nodes[i].distAndEst = -1;
+ m_Nodes[i].distance = -1;
+ m_Nodes[i].prevNode = -1;
+ m_Nodes[i].mainListIndex=i;
+ m_Nodes[i].closed=false;
+ }
- // Initialize each node in nodelist
- for (NodeNumType i=0; i<m_Graph_NumberOfNodes; i++)
- {
- m_Nodes[i].distAndEst = -1;
- m_Nodes[i].distance = -1;
- m_Nodes[i].prevNode = -1;
- m_Nodes[i].mainListIndex=i;
- m_Nodes[i].closed=false;
+ m_Initialized = true;
}
// In the beginning, the Startnode needs a distance of 0
m_Nodes[m_Graph_StartNode].distance = 0;
- m_Nodes[m_Graph_StartNode].distAndEst = 0;
+ m_Nodes[m_Graph_StartNode].distAndEst = 0;
+
+ // initalize cost function
+ m_CostFunction->Initialize();
}
template <class TInputImageType, class TOutputImageType>
void
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
StartShortestPathSearch()
{
- // Setup Timer
+ // Setup Timer
clock_t startAll = clock();
clock_t stopAll = clock();
- // init variables
+ // init variables
double durationAll = 0;
bool timeout = false;
bool makeNewHeapNecessary = false;
- NodeNumType mainNodeListIndex = 0;
+ NodeNumType mainNodeListIndex = 0;
DistanceType curNodeDistance = 0;
DistanceType curNodeDistAndEst = 0;
- NodeNumType numberOfNodesChecked = 0;
+ NodeNumType numberOfNodesChecked = 0;
- // Create Multimap (tree structure for fast searching)
- std::multimap<double,ShortestPathNode*> myMap;
- std::pair< std::multimap<double,ShortestPathNode*>::iterator, std::multimap<double,ShortestPathNode*>::iterator> ret;
- std::multimap<double,ShortestPathNode*>::iterator it;
+ // Create Multimap (tree structure for fast searching)
+ std::multimap<double,ShortestPathNode*> myMap;
+ std::pair< std::multimap<double,ShortestPathNode*>::iterator, std::multimap<double,ShortestPathNode*>::iterator> ret;
+ std::multimap<double,ShortestPathNode*>::iterator it;
- // At first, only startNote is discovered.
- myMap.insert( std::pair<double,ShortestPathNode*> (m_Nodes[m_Graph_StartNode].distAndEst, &m_Nodes[m_Graph_StartNode]) );
+ // At first, only startNote is discovered.
+ myMap.insert( std::pair<double,ShortestPathNode*> (m_Nodes[m_Graph_StartNode].distAndEst, &m_Nodes[m_Graph_StartNode]) );
// While there are discovered Nodes, pick the one with lowest distance,
- // update its neighbors and eventually delete it from the discovered Nodes list.
+ // update its neighbors and eventually delete it from the discovered Nodes list.
while(!myMap.empty())
{
- numberOfNodesChecked++;
- if ( (numberOfNodesChecked % (m_Graph_NumberOfNodes/100)) == 0)
- {
- MITK_INFO << "Checked " << ( numberOfNodesChecked / (m_Graph_NumberOfNodes/100) ) << "% List: " << myMap.size() << "\n";
- }
-
- // Get element with lowest score
- mainNodeListIndex = myMap.begin()->second->mainListIndex;
+ numberOfNodesChecked++;
+ /*if ( (numberOfNodesChecked % (m_Graph_NumberOfNodes/100)) == 0)
+ {
+ MITK_INFO << "Checked " << ( numberOfNodesChecked / (m_Graph_NumberOfNodes/100) ) << "% List: " << myMap.size() << "\n";
+ }*/
+
+ // Get element with lowest score
+ mainNodeListIndex = myMap.begin()->second->mainListIndex;
curNodeDistAndEst = myMap.begin()->second->distAndEst;
curNodeDistance = myMap.begin()->second->distance;
- myMap.begin()->second->closed = true; // close it
+ myMap.begin()->second->closed = true; // close it
- // Debug:
- //MITK_INFO << "INFO: size " << myMap.size();
- /*
- for (it = myMap.begin(); it != myMap.end(); ++it)
- {
- MITK_INFO << "(1) " << it->first << "|" << it->second->distAndEst << "|"<<it->second->mainListIndex;
- }
- */
+ // Debug:
+ //MITK_INFO << "INFO: size " << myMap.size();
+ /*
+ for (it = myMap.begin(); it != myMap.end(); ++it)
+ {
+ MITK_INFO << "(1) " << it->first << "|" << it->second->distAndEst << "|"<<it->second->mainListIndex;
+ }
+ */
// Kicks out element with lowest score
- myMap.erase( myMap.begin() );
+ myMap.erase( myMap.begin() );
- // if wanted, store vector order
+ // if wanted, store vector order
if (m_StoreVectorOrder)
- {
+ {
m_VectorOrder.push_back(mainNodeListIndex);
- }
+ }
// Check neighbors
std::vector<ShortestPathNode*> neighborNodes = GetNeighbors(mainNodeListIndex, m_Graph_fullNeighbors);
for (NodeNumType i=0; i<neighborNodes.size(); i++)
{
- if (neighborNodes[i]->closed)
- continue; // this nodes is already closed, go to next neighbor
+ if (neighborNodes[i]->closed)
+ continue; // this nodes is already closed, go to next neighbor
IndexType coordCurNode = NodeToCoord(mainNodeListIndex);
IndexType coordNeighborNode = NodeToCoord(neighborNodes[i]->mainListIndex);
// calculate the new Distance to the current neighbor
double newDistance = curNodeDistance
+ (m_CostFunction->GetCost(coordCurNode, coordNeighborNode));
// if it is shorter than any yet known path to this neighbor, than the current path is better. Save that!
if ((newDistance < neighborNodes[i]->distance) || (neighborNodes[i]->distance == -1) )
{
// if that neighbornode is not in discoverednodeList yet, Push it there and update
if (neighborNodes[i]->distance == -1)
{
neighborNodes[i]->distance = newDistance;
neighborNodes[i]->distAndEst = newDistance + getEstimatedCostsToTarget(coordNeighborNode);
neighborNodes[i]->prevNode = mainNodeListIndex;
- myMap.insert( std::pair<double,ShortestPathNode*> (m_Nodes[neighborNodes[i]->mainListIndex].distAndEst, &m_Nodes[neighborNodes[i]->mainListIndex]) );
- /*
- MITK_INFO << "Inserted: " << m_Nodes[neighborNodes[i]->mainListIndex].distAndEst << "|" << m_Nodes[neighborNodes[i]->mainListIndex].mainListIndex;
- MITK_INFO << "INFO: size " << myMap.size();
- for (it = myMap.begin(); it != myMap.end(); ++it)
- {
- MITK_INFO << "(1) " << it->first << "|" << it->second->distAndEst << "|"<<it->second->mainListIndex;
- }
- */
+ myMap.insert( std::pair<double,ShortestPathNode*> (m_Nodes[neighborNodes[i]->mainListIndex].distAndEst, &m_Nodes[neighborNodes[i]->mainListIndex]) );
+ /*
+ MITK_INFO << "Inserted: " << m_Nodes[neighborNodes[i]->mainListIndex].distAndEst << "|" << m_Nodes[neighborNodes[i]->mainListIndex].mainListIndex;
+ MITK_INFO << "INFO: size " << myMap.size();
+ for (it = myMap.begin(); it != myMap.end(); ++it)
+ {
+ MITK_INFO << "(1) " << it->first << "|" << it->second->distAndEst << "|"<<it->second->mainListIndex;
+ }
+ */
}
// or if is already in discoverednodelist, update
else
{
- /*
- it = myMap.find(neighborNodes[i]->distAndEst);
- if (it == myMap.end() )
- {
- MITK_INFO << "Nothing!";
- // look further
- for (it = myMap.begin(); it != myMap.end(); ++it)
- {
- if ((*it).second->mainListIndex == lookForId)
- {
- MITK_INFO << "But it is there!!!";
- MITK_INFO << "Searched for: " << lookFor << " but had: " << (*it).second->distAndEst;
- }
-
- }
- }
- */
+ /*
+ it = myMap.find(neighborNodes[i]->distAndEst);
+ if (it == myMap.end() )
+ {
+ MITK_INFO << "Nothing!";
+ // look further
+ for (it = myMap.begin(); it != myMap.end(); ++it)
+ {
+ if ((*it).second->mainListIndex == lookForId)
+ {
+ MITK_INFO << "But it is there!!!";
+ MITK_INFO << "Searched for: " << lookFor << " but had: " << (*it).second->distAndEst;
+ }
- // 1st : find and delete old element
- bool found = false;
- double lookFor = neighborNodes[i]->distAndEst;
- unsigned int lookForId = neighborNodes[i]->mainListIndex;
- ret = myMap.equal_range(neighborNodes[i]->distAndEst);
+ }
+ }
+ */
- if ((ret.first == ret.second))
- {
- MITK_INFO << "No exact match!"; // if this happens, you are screwed
- /*
- MITK_INFO << "Was looking for: " << lookFor << " ID: " << lookForId;
- if (ret.first != myMap.end() )
- {
- it = ret.first;
- MITK_INFO << "Found: " << it->first << " ID: " << it->second->mainListIndex;
- ++it;
- MITK_INFO << "Found: " << it->first << " ID: " << it->second->mainListIndex;
- --it;
- --it;
- MITK_INFO << "Found: " << it->first << " ID: " << it->second->mainListIndex;
- }
-
- // look if that ID is found in the map
- for (it = myMap.begin(); it != myMap.end(); ++it)
- {
- if ((*it).second->mainListIndex == lookForId)
- {
- MITK_INFO << "But it is there!!!";
- MITK_INFO << "Searched dist: " << lookFor << " found dist: " << (*it).second->distAndEst;
- }
-
- }
- */
- }
- else
- {
- for (it=ret.first; it!=ret.second; ++it)
- {
- if (it->second->mainListIndex == neighborNodes[i]->mainListIndex)
- {
- found = true;
- myMap.erase(it);
- /*
- MITK_INFO << "INFO: size " << myMap.size();
- MITK_INFO << "Erase: " << it->first << "|" << it->second->mainListIndex;
-
- MITK_INFO << "INFO: size " << myMap.size();
- for (it = myMap.begin(); it != myMap.end(); ++it)
- {
- MITK_INFO << "(1) " << it->first << "|" << it->second->distAndEst << "|"<<it->second->mainListIndex;
- }
- */
- break;
- }
- }
- }
+ // 1st : find and delete old element
+ bool found = false;
+ double lookFor = neighborNodes[i]->distAndEst;
+ unsigned int lookForId = neighborNodes[i]->mainListIndex;
+ ret = myMap.equal_range(neighborNodes[i]->distAndEst);
+ if ((ret.first == ret.second))
+ {
+ /*+++++++++++++ no exact match +++++++++++++*/
+ //MITK_INFO << "No exact match!"; // if this happens, you are screwed
+ /*
+ MITK_INFO << "Was looking for: " << lookFor << " ID: " << lookForId;
+ if (ret.first != myMap.end() )
+ {
+ it = ret.first;
+ MITK_INFO << "Found: " << it->first << " ID: " << it->second->mainListIndex;
+ ++it;
+ MITK_INFO << "Found: " << it->first << " ID: " << it->second->mainListIndex;
+ --it;
+ --it;
+ MITK_INFO << "Found: " << it->first << " ID: " << it->second->mainListIndex;
+ }
+
+ // look if that ID is found in the map
+ for (it = myMap.begin(); it != myMap.end(); ++it)
+ {
+ if ((*it).second->mainListIndex == lookForId)
+ {
+ MITK_INFO << "But it is there!!!";
+ MITK_INFO << "Searched dist: " << lookFor << " found dist: " << (*it).second->distAndEst;
+ }
+
+ }
+ */
+ }
+ else
+ {
+ for (it=ret.first; it!=ret.second; ++it)
+ {
+ if (it->second->mainListIndex == neighborNodes[i]->mainListIndex)
+ {
+ found = true;
+ myMap.erase(it);
+ /*
+ MITK_INFO << "INFO: size " << myMap.size();
+ MITK_INFO << "Erase: " << it->first << "|" << it->second->mainListIndex;
- if (!found)
+ MITK_INFO << "INFO: size " << myMap.size();
+ for (it = myMap.begin(); it != myMap.end(); ++it)
{
- MITK_INFO << "Could not find it! :(";
- continue;
+ MITK_INFO << "(1) " << it->first << "|" << it->second->distAndEst << "|"<<it->second->mainListIndex;
}
+ */
+ break;
+ }
+ }
+ }
- // 2nd: update and insert new element
- neighborNodes[i]->distance = newDistance;
+ if (!found)
+ {
+ //MITK_INFO << "Could not find it! :(";
+ continue;
+ }
+
+ // 2nd: update and insert new element
+ neighborNodes[i]->distance = newDistance;
neighborNodes[i]->distAndEst = newDistance + getEstimatedCostsToTarget(coordNeighborNode);
neighborNodes[i]->prevNode = mainNodeListIndex;
- //myMap.insert( std::pair<double,ShortestPathNode*> (neighborNodes[i]->distAndEst, neighborNodes[i]));
- myMap.insert( std::pair<double,ShortestPathNode*> (m_Nodes[neighborNodes[i]->mainListIndex].distAndEst, &m_Nodes[neighborNodes[i]->mainListIndex]) );
+ //myMap.insert( std::pair<double,ShortestPathNode*> (neighborNodes[i]->distAndEst, neighborNodes[i]));
+ myMap.insert( std::pair<double,ShortestPathNode*> (m_Nodes[neighborNodes[i]->mainListIndex].distAndEst, &m_Nodes[neighborNodes[i]->mainListIndex]) );
- //MITK_INFO << "Re-Inserted: " << m_Nodes[neighborNodes[i]->mainListIndex].distAndEst << "|" << m_Nodes[neighborNodes[i]->mainListIndex].mainListIndex;
- //MITK_INFO << "INFO: size " << myMap.size();
- /*for (it = myMap.begin(); it != myMap.end(); ++it)
- {
- MITK_INFO << "(1) " << it->first << "|" << it->second->distAndEst << "|"<<it->second->mainListIndex;
- }*/
+ //MITK_INFO << "Re-Inserted: " << m_Nodes[neighborNodes[i]->mainListIndex].distAndEst << "|" << m_Nodes[neighborNodes[i]->mainListIndex].mainListIndex;
+ //MITK_INFO << "INFO: size " << myMap.size();
+ /*for (it = myMap.begin(); it != myMap.end(); ++it)
+ {
+ MITK_INFO << "(1) " << it->first << "|" << it->second->distAndEst << "|"<<it->second->mainListIndex;
+ }*/
}
}
}
// finished with checking all neighbors.
// Check Timeout, if activated
if (m_ActivateTimeOut)
{
stopAll = clock();
durationAll = (double)(stopAll - startAll) / CLOCKS_PER_SEC;
if (durationAll >= 30)
{
- MITK_INFO << "TIMEOUT!! Search took over 30 seconds";
+ //MITK_INFO << "TIMEOUT!! Search took over 30 seconds";
timeout = true ;
}
}
- // Check end criteria:
- // For multiple points
- if ( multipleEndPoints )
- {
- // super slow, make it faster
- for (int i=0 ;i<m_endPoints.size(); i++)
+ // Check end criteria:
+ // For multiple points
+ if ( multipleEndPoints )
+ {
+ // super slow, make it faster
+ for (int i=0 ;i<m_endPoints.size(); i++)
+ {
+ if (CoordToNode(m_endPoints[i]) == mainNodeListIndex)
+ {
+ m_endPointsClosed.push_back(NodeToCoord(mainNodeListIndex));
+ m_endPoints.erase(m_endPoints.begin()+i);
+ if (m_endPoints.empty())
{
- if (CoordToNode(m_endPoints[i]) == mainNodeListIndex)
- {
- m_endPointsClosed.push_back(NodeToCoord(mainNodeListIndex));
- m_endPoints.erase(m_endPoints.begin()+i);
- if (m_endPoints.empty())
- {
- // Finished! break
- return;
- }
- if (m_Graph_EndNode == mainNodeListIndex)
- {
- // set new end
- SetEndIndex( m_endPoints[0] );
- }
- }
+ // Finished! break
+ return;
+ }
+ if (m_Graph_EndNode == mainNodeListIndex)
+ {
+ // set new end
+ SetEndIndex( m_endPoints[0] );
}
- }
- // if single end point, then end, if this one is reached or timeout happened.
+ }
+ }
+ }
+ // if single end point, then end, if this one is reached or timeout happened.
else if ( ( mainNodeListIndex == m_Graph_EndNode || timeout) && !m_CalcAllDistances)
{
- if (m_StoreVectorOrder)
- MITK_INFO << "Number of Nodes checked: " << m_VectorOrder.size() ;
+ /*if (m_StoreVectorOrder)
+ MITK_INFO << "Number of Nodes checked: " << m_VectorOrder.size() ;*/
return;
}
}
}
template <class TInputImageType, class TOutputImageType>
void
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
MakeOutputs()
{
- MITK_INFO << "Make Output";
+ //MITK_INFO << "Make Output";
- if (m_MakeOutputImage)
+ if (m_MakeOutputImage)
+ {
+ OutputImagePointer output0 = this->GetOutput(0);
+ output0->SetRegions( this->GetInput()->GetLargestPossibleRegion() );
+ output0->Allocate();
+ OutputImageIteratorType shortestPathImageIt (output0, output0->GetRequestedRegion());
+ // Create ShortestPathImage (Output 0)
+ for (shortestPathImageIt.GoToBegin(); !shortestPathImageIt.IsAtEnd(); ++shortestPathImageIt)
{
- OutputImagePointer output0 = this->GetOutput(0);
- output0->SetRegions( this->GetInput()->GetLargestPossibleRegion() );
- output0->Allocate();
- OutputImageIteratorType shortestPathImageIt (output0, output0->GetRequestedRegion());
- // Create ShortestPathImage (Output 0)
- for (shortestPathImageIt.GoToBegin(); !shortestPathImageIt.IsAtEnd(); ++shortestPathImageIt)
- {
- // First intialize with background color
- shortestPathImageIt.Set( BACKGROUND ) ;
- }
-
- if (!multipleEndPoints) // Only one path was calculated
- {
- for (int i=0; i< m_VectorPath.size(); i++)
+ // First intialize with background color
+ shortestPathImageIt.Set( BACKGROUND ) ;
+ }
+
+ if (!multipleEndPoints) // Only one path was calculated
+ {
+ for (int i=0; i< m_VectorPath.size(); i++)
+ {
+ shortestPathImageIt.SetIndex( m_VectorPath[i] );
+ shortestPathImageIt.Set( FOREGROUND ) ;
+ }
+ }
+ else // multiple pathes has been calculated, draw all
+ {
+ for (int i =0; i<m_MultipleVectorPaths.size(); i++)
+ {
+ for (int j=0; j< m_MultipleVectorPaths[i].size(); j++)
{
- shortestPathImageIt.SetIndex( m_VectorPath[i] );
+ shortestPathImageIt.SetIndex( m_MultipleVectorPaths[i][j] );
shortestPathImageIt.Set( FOREGROUND ) ;
}
- }
- else // multiple pathes has been calculated, draw all
- {
- for (int i =0; i<m_MultipleVectorPaths.size(); i++)
- {
- for (int j=0; j< m_MultipleVectorPaths[i].size(); j++)
- {
- shortestPathImageIt.SetIndex( m_MultipleVectorPaths[i][j] );
- shortestPathImageIt.Set( FOREGROUND ) ;
- }
- }
- }
+ }
}
+ }
}
template <class TInputImageType, class TOutputImageType>
- typename ShortestPathImageFilter<TInputImageType, TOutputImageType>::OutputImagePointer
+ typename ShortestPathImageFilter<TInputImageType, TOutputImageType>::OutputImagePointer
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
GetVectorOrderImage()
{
- // Create Vector Order Image
- // Return it
+ // Create Vector Order Image
+ // Return it
- OutputImagePointer image = OutputImageType::New();
- image->SetRegions( this->GetInput()->GetLargestPossibleRegion() );
- image->Allocate();
- OutputImageIteratorType vectorOrderImageIt (image, image->GetRequestedRegion());
+ OutputImagePointer image = OutputImageType::New();
+ image->SetRegions( this->GetInput()->GetLargestPossibleRegion() );
+ image->Allocate();
+ OutputImageIteratorType vectorOrderImageIt (image, image->GetRequestedRegion());
- MITK_INFO << "GetVectorOrderImage";
- for (vectorOrderImageIt.GoToBegin(); !vectorOrderImageIt.IsAtEnd(); ++vectorOrderImageIt)
- {
- // First intialize with background color
- vectorOrderImageIt.Value() = BACKGROUND ;
- }
- for (int i=0; i< m_VectorOrder.size(); i++)
- {
- vectorOrderImageIt.SetIndex(NodeToCoord(m_VectorOrder[i]) );
- vectorOrderImageIt.Set( BACKGROUND+i) ;
- }
+ //MITK_INFO << "GetVectorOrderImage";
+ for (vectorOrderImageIt.GoToBegin(); !vectorOrderImageIt.IsAtEnd(); ++vectorOrderImageIt)
+ {
+ // First intialize with background color
+ vectorOrderImageIt.Value() = BACKGROUND ;
+ }
+ for (int i=0; i< m_VectorOrder.size(); i++)
+ {
+ vectorOrderImageIt.SetIndex(NodeToCoord(m_VectorOrder[i]) );
+ vectorOrderImageIt.Set( BACKGROUND+i) ;
+ }
return image;
}
template <class TInputImageType, class TOutputImageType>
typename ShortestPathImageFilter<TInputImageType, TOutputImageType>::OutputImagePointer
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
GetDistanceImage()
{
- // Create Distance Image
- // Return it
-
- OutputImagePointer image = OutputImageType::New();
- image->SetRegions( this->GetInput()->GetLargestPossibleRegion() );
- image->Allocate();;
- OutputImageIteratorType distanceImageIt (image, image->GetRequestedRegion());
- // Create Distance Image (Output 1)
- NodeNumType myNodeNum;
- for (distanceImageIt.GoToBegin(); !distanceImageIt.IsAtEnd(); ++distanceImageIt)
- {
- IndexType index = distanceImageIt.GetIndex();
- myNodeNum = CoordToNode(index);
- double newVal = m_Nodes[myNodeNum].distance;
- distanceImageIt.Set(newVal);
- }
- }
+ // Create Distance Image
+ // Return it
+
+ OutputImagePointer image = OutputImageType::New();
+ image->SetRegions( this->GetInput()->GetLargestPossibleRegion() );
+ image->Allocate();;
+ OutputImageIteratorType distanceImageIt (image, image->GetRequestedRegion());
+ // Create Distance Image (Output 1)
+ NodeNumType myNodeNum;
+ for (distanceImageIt.GoToBegin(); !distanceImageIt.IsAtEnd(); ++distanceImageIt)
+ {
+ IndexType index = distanceImageIt.GetIndex();
+ myNodeNum = CoordToNode(index);
+ double newVal = m_Nodes[myNodeNum].distance;
+ distanceImageIt.Set(newVal);
+ }
+ }
template <class TInputImageType, class TOutputImageType>
- std::vector< itk::Index<3> >
+ std::vector< typename ShortestPathImageFilter<TInputImageType, TOutputImageType>::IndexType >
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
GetVectorPath()
{
return m_VectorPath;
}
- template <class TInputImageType, class TOutputImageType>
- std::vector< std::vector< itk::Index<3> > >
+ template <class TInputImageType, class TOutputImageType>
+ std::vector< std::vector< typename ShortestPathImageFilter<TInputImageType, TOutputImageType>::IndexType > >
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
GetMultipleVectorPaths()
{
return m_MultipleVectorPaths;
}
template <class TInputImageType, class TOutputImageType>
void
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
MakeShortestPathVector()
{
- MITK_INFO << "Make ShortestPath Vec";
-
- // single end point
- if ( !multipleEndPoints )
- {
- // fill m_VectorPath with the Shortest Path
- m_VectorPath.clear();
+ //MITK_INFO << "Make ShortestPath Vec";
- // Go backwards from endnote to startnode
- NodeNumType prevNode = m_Graph_EndNode;
- while (prevNode != -1)
- {
- m_VectorPath.push_back( NodeToCoord(prevNode) );
+ // single end point
+ if ( !multipleEndPoints )
+ {
+ // fill m_VectorPath with the Shortest Path
+ m_VectorPath.clear();
- if (prevNode == m_Graph_StartNode)
- break;
+ // Go backwards from endnote to startnode
+ NodeNumType prevNode = m_Graph_EndNode;
+ while (prevNode != -1)
+ {
+ m_VectorPath.push_back( NodeToCoord(prevNode) );
- prevNode = m_Nodes[prevNode].prevNode;
- }
+ if (prevNode == m_Graph_StartNode)
+ break;
- // reverse it
- std::reverse(m_VectorPath.begin(), m_VectorPath.end() );
+ prevNode = m_Nodes[prevNode].prevNode;
}
- // Multiple end end points and pathes
- else
+
+ // reverse it
+ std::reverse(m_VectorPath.begin(), m_VectorPath.end() );
+ }
+ // Multiple end end points and pathes
+ else
+ {
+ for (int i=0; i<m_endPointsClosed.size(); i++)
{
- for (int i=0; i<m_endPointsClosed.size(); i++)
- {
- m_VectorPath.clear();
- // Go backwards from endnote to startnode
- NodeNumType prevNode = CoordToNode(m_endPointsClosed[i]);
- while (prevNode != -1)
- {
- m_VectorPath.push_back( NodeToCoord(prevNode) );
+ m_VectorPath.clear();
+ // Go backwards from endnote to startnode
+ NodeNumType prevNode = CoordToNode(m_endPointsClosed[i]);
+ while (prevNode != -1)
+ {
+ m_VectorPath.push_back( NodeToCoord(prevNode) );
- if (prevNode == m_Graph_StartNode)
- break;
+ if (prevNode == m_Graph_StartNode)
+ break;
- prevNode = m_Nodes[prevNode].prevNode;
- }
+ prevNode = m_Nodes[prevNode].prevNode;
+ }
- // reverse it
- std::reverse(m_VectorPath.begin(), m_VectorPath.end() );
- // push_back
- m_MultipleVectorPaths.push_back( m_VectorPath );
- }
+ // reverse it
+ std::reverse(m_VectorPath.begin(), m_VectorPath.end() );
+ // push_back
+ m_MultipleVectorPaths.push_back( m_VectorPath );
}
+ }
}
template <class TInputImageType, class TOutputImageType>
void
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
CleanUp()
{
-
- m_VectorPath.clear();
- //TODO: if multiple Path, clear all multiple Paths
- /*
- for (NodeNumType i=0; i<m_Graph_NumberOfNodes; i++)
- {
- delete m_Nodes[i];
- }*/
-
- // This is properly not a proper cleanup
- if (m_Nodes)
- delete m_Nodes;
m_VectorOrder.clear();
+ m_VectorPath.clear();
+ //TODO: if multiple Path, clear all multiple Paths
+ if (m_Nodes)
+ delete [] m_Nodes;
}
+
template <class TInputImageType, class TOutputImageType>
void
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
GenerateData()
{
// Build Graph
InitGraph();
// Calc Shortest Parth
StartShortestPathSearch();
// Fill Shortest Path
MakeShortestPathVector();
// Make Outputs
MakeOutputs();
}
template <class TInputImageType, class TOutputImageType>
void
ShortestPathImageFilter<TInputImageType, TOutputImageType>::
PrintSelf( std::ostream& os, Indent indent ) const
{
Superclass::PrintSelf(os,indent);
}
} /* end namespace itk */
#endif
diff --git a/Modules/IGT/Documentation/doxygen/IGTTutorialStep1.dox b/Modules/IGT/Documentation/doxygen/IGTTutorialStep1.dox
index 74448ca274..e7cd68507a 100644
--- a/Modules/IGT/Documentation/doxygen/IGTTutorialStep1.dox
+++ b/Modules/IGT/Documentation/doxygen/IGTTutorialStep1.dox
@@ -1,213 +1,212 @@
/**
\page IGTCodeTutorialPage The IGT Code Tutorial
The IGT tutorial consists of four main parts for construction of a small navigation pipeline using a virtual tracking device.
The virtual tracking device produces random tool data (position and orientation) so no additional hardware is required.
\section sec1 In Tracking Layer
-
+
Firstly a new object "tracker" of the type mitk::VirtualTrackingDevice is created, then two tools, named "tool1" and "tool2",
are added to this "tracker". Since, the tracking device "tracker" is treated as a virtual tracking
-device "tool1" and "tool2" are just added to the object by method AddTool(name).
+device "tool1" and "tool2" are just added to the object by method AddTool(name).
\section sec2 In Navigation Layer
-\image html IGTTutorialStep1.png
+\image html IGTTutorialStep1.png
-Secondly, a new source of the type mitk::TrackingDeviceSource has to be created with outputs for each single tool of a tracker.
+Secondly, a new source of the type mitk::TrackingDeviceSource has to be created with outputs for each single tool of a tracker.
The source sets the following tracking device by using method SetTrackingDevice as shown below
\code
source->SetTrackingDevice(tracker);
\endcode
So now, the source is initialized with the virtual tracking device. Next, the source is connected and tracking is started.
-
+
In part II, a displacemt filter (object "displacer") is constructed to change the positions of the filtered NavigationData objects
with an offset for each direction (X,Y,Z). The given filter has inputs and outputs for each tool, in this example we have 2 tools, hence there exists two inputs and outputs. Every output of the displacement filter object is connected to the recorder object in the next part.
In part III, all the NavigationData is recorded with the NavigationDataRecorder. In order to record, we simply create
an object "recorder" of the type mitk::NavigationDataRecorder and set the appropriate file to it. Now the displacer object is connected to the
-recorder object for every output by using a for-loop in the code, the method StartRecording() is called on the next line. Afterwards,
-the recorder has to be updated a couple of times. In this example the recorder is updating 100 times through
-the second for-loop statement in part III. This can also be seen as a simulation of a timer by using a for-loop.
+recorder object for every output by using a for-loop in the code, the method StartRecording() is called on the next line. Afterwards,
+the recorder has to be updated a couple of times. In this example the recorder is updating 100 times through
+the second for-loop statement in part III. This can also be seen as a simulation of a timer by using a for-loop.
Part IV explains how the recoded file can be played for further use. After the object "player" of a type mitk::NavigationDataPlayer
-is created, the required file has to be set to the player and playing has to be started. Here, there exists a new pipeline which functions by reading
+is created, the required file has to be set to the player and playing has to be started. Here, there exists a new pipeline which functions by reading
the recorded file from the harddisc and plays it by using the player as source. During the play, the for-loop makes the file update as in part III.
-\image html IGTTutorialStep1-2.png
+\image html IGTTutorialStep1-2.png
The full code of small navigation pipeline is shown below.
\code
int main(int /*argc*/, char* /*argv*/[])
{
//*************************************************************************
// What we will do...
//*************************************************************************
//In this tutorial we build up a small navigation pipeline with a virtual tracking device
//which produce random positions and orientation so no additional hardware is required.
//The source of the pipeline is a TrackingDeviceSource object. This we connect to a simple
//filter which just displaces the positions with an offset. After that we use a recorder
//to store this new positions and other information to disc in a XML file. After that we use
//another source (NavigationDataPlayer) to replay the recorded data.
-
+
//*************************************************************************
// Part I: Basic initialization of the source and tracking device
//*************************************************************************
//First of all create a tracking device object and two tools for this "device".
- //Here we take the VirtualTrackingDevice. This is not a real tracking device it just delivers random
- //positions and orientations. You can use other/real tracking devices if you replace the following
+ //Here we take the VirtualTrackingDevice. This is not a real tracking device it just delivers random
+ //positions and orientations. You can use other/real tracking devices if you replace the following
//code with different tracking devices, e.g. mitk::NDITrackingDevice. The tools represent the
//sensors of the tracking device. The TrackingDevice fills the tools with data.
std::cout << "Generating TrackingDevice ..." << std::endl;
mitk::VirtualTrackingDevice::Pointer tracker = mitk::VirtualTrackingDevice::New();
tracker->AddTool("tool1");
tracker->AddTool("tool2");
//The tracking device object is used for the physical connection to the device. To use the
//data inside of our tracking pipeline we need a source. This source encapsulate the tracking device
- //and provides objects of the type mitk::NavigationData as output. The NavigationData objects stores
- //position, orientation, if the data is valid or not and special error informations in a covariance
+ //and provides objects of the type mitk::NavigationData as output. The NavigationData objects stores
+ //position, orientation, if the data is valid or not and special error informations in a covariance
//matrix.
//
- //Typically the start of our pipeline is a TrackingDeviceSource. To work correct we have to set a
+ //Typically the start of our pipeline is a TrackingDeviceSource. To work correct we have to set a
//TrackingDevice object. Attention you have to set the tools before you set the whole TrackingDevice
- //object to the TrackingDeviceSource because the source need to know how many outputs should be
+ //object to the TrackingDeviceSource because the source need to know how many outputs should be
//generated.
std::cout << "Generating Source ..." << std::endl;
mitk::TrackingDeviceSource::Pointer source = mitk::TrackingDeviceSource::New();
source->SetTrackingDevice(tracker); //here we set the device for the pipeline source
source->Connect(); //here we connect to the tracking system
//Note we do not call this on the TrackingDevice object
- source->StartTracking(); //start the tracking
+ source->StartTracking(); //start the tracking
//Now the source generates outputs.
//*************************************************************************
// Part II: Create a NavigationDataToNavigationDataFilter
//*************************************************************************
- //The next thing we do is using a NavigationDataToNavigationDataFilter. One of these filter is the
- //very simple NavigationDataDisplacementFilter. This filter just changes the positions of the input
- //NavigationData objects with an offset for each direction (X,Y,Z). The input of this filter is the
+ //The next thing we do is using a NavigationDataToNavigationDataFilter. One of these filter is the
+ //very simple NavigationDataDisplacementFilter. This filter just changes the positions of the input
+ //NavigationData objects with an offset for each direction (X,Y,Z). The input of this filter is the
//source and the output of this filter is the "displaced" input.
std::cout << "Generating DisplacementFilter ..." << std::endl;
mitk::NavigationDataDisplacementFilter::Pointer displacer = mitk::NavigationDataDisplacementFilter::New();
mitk::Vector3D offset;
mitk::FillVector3D(offset, 10.0, 100.0, 1.0); //initialize the offset
displacer->SetOffset(offset); //now set the offset in the NavigationDataDisplacementFilter object
//now every output of the source object is connected to the displacer object
for (unsigned int i = 0; i < source->GetNumberOfOutputs(); i++)
{
- displacer->SetInput(i, source->GetOutput(i)); //here we connect to the displacement filter
+ displacer->SetInput(i, source->GetOutput(i)); //here we connect to the displacement filter
}
//*************************************************************************
// Part III: Record the data with the NavigationDataRecorder
//*************************************************************************
//The next part of our pipeline is the recorder. The recorder needs a filename. Otherwise the output
//is redirected to the console. The input of the recorder is the output of the displacement filter
//and the output is a XML file with the name "Test Output-0.xml".
std::cout << "Start Recording ..." << std::endl;
//we need the stringstream for building up our filename
std::stringstream filename;
//the .xml extension and an counter is added automatically
filename << itksys::SystemTools::GetCurrentWorkingDirectory() << "/Test Output";
std::cout << "Record to file: " << filename.str() << "-0.xml ..." << std::endl;
mitk::NavigationDataRecorder::Pointer recorder = mitk::NavigationDataRecorder::New();
recorder->SetFileName(filename.str());
//now every output of the displacer object is connected to the recorder object
for (unsigned int i = 0; i < displacer->GetNumberOfOutputs(); i++)
{
recorder->AddNavigationData(displacer->GetOutput(i)); // here we connect to the recorder
}
- recorder->StartRecording(); //after finishing the settings you can start the recording mechanism
- //now every update of the recorder stores one line into the file for
+ recorder->StartRecording(); //after finishing the settings you can start the recording mechanism
+ //now every update of the recorder stores one line into the file for
//each added NavigationData
for (unsigned int x = 0; x < 100; x++) //write 100 datasets
{
recorder->Update(); //the update causes one line in the XML file for every tool
//in this case two lines
itksys::SystemTools::Delay(100); //sleep a little
}
recorder->StopRecording(); //to get proper XML files you should stop recording
- //if your application crashes during recording no data
+ //if your application crashes during recording no data
//will be lost it is all stored to disc
//*************************************************************************
// Part IV: Play the data with the NavigationDataPlayer
//*************************************************************************
- //The recording is finished now so now we can play the data. The NavigationDataPlayer is similar
- //to the TrackingDevice source. It also derives from NavigationDataSource. So you can use a player
- //instead of a TrackingDeviceSource. The input of this player is the filename and the output are
+ //The recording is finished now so now we can play the data. The NavigationDataPlayer is similar
+ //to the TrackingDevice source. It also derives from NavigationDataSource. So you can use a player
+ //instead of a TrackingDeviceSource. The input of this player is the filename and the output are
//NavigationData object.
filename << "-0.xml";
std::cout << "Start playing from file: " << filename.str() << " ..." << std::endl;
mitk::NavigationDataPlayer::Pointer player = mitk::NavigationDataPlayer::New();
//this is first part of the file name the .xml extension and an counter is added automatically
- player->SetFileName(filename.str());
+ player->SetFileName(filename.str());
player->StartPlaying(); //this starts the player
- //From now on the player provides NavigationDatas in the order and
+ //From now on the player provides NavigationDatas in the order and
//correct time as they were recorded
-
+
//this connects the outputs of the player to the NavigationData objects
- mitk::NavigationData::Pointer nd = player->GetOutput(0);
- mitk::NavigationData::Pointer nd2 = player->GetOutput(1);
- for (unsigned int x=0; x<100; x++)
+ mitk::NavigationData::Pointer nd = player->GetOutput();
+ mitk::NavigationData::Pointer nd2 = player->GetOutput(1);
+ for (unsigned int x=0; x<100; x++)
{
if (nd.IsNotNull()) //check if the output is not null
{
//With this update the NavigationData object propagates through the pipeline to get a new value.
//In this case we only have a source (NavigationDataPlayer).
- nd->Update();
+ nd->Update();
std::cout << x << ": 1:" << nd->GetPosition() << std::endl;
std::cout << x << ": 2:" << nd2->GetPosition() << std::endl;
std::cout << x << ": 1:" << nd->GetOrientation() << std::endl;
std::cout << x << ": 2:" << nd2->GetOrientation() << std::endl;
itksys::SystemTools::Delay(100); //sleep a little like in the recorder part
}
}
player->StopPlaying(); //This stops the player
//With another call of StartPlaying the player will start again at the beginning of the file
itksys::SystemTools::Delay(2000);
std::cout << "finished" << std::endl;
}
\endcode
*/
-
\ No newline at end of file
diff --git a/Modules/IGT/IGTFilters/mitkNavigationData.cpp b/Modules/IGT/IGTFilters/mitkNavigationData.cpp
index 4ea55bd42f..84e65bafdf 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationData.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationData.cpp
@@ -1,138 +1,138 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationData.h"
mitk::NavigationData::NavigationData() : itk::DataObject(),
m_Position(), m_Orientation(0.0, 0.0, 0.0, 0.0), m_CovErrorMatrix(),
-m_HasPosition(true), m_HasOrientation(true), m_DataValid(false), m_TimeStamp(0.0),
+m_HasPosition(true), m_HasOrientation(true), m_DataValid(false), m_IGTTimeStamp(0.0),
m_Name()
{
m_Position.Fill(0.0);
m_CovErrorMatrix.SetIdentity();
}
mitk::NavigationData::~NavigationData()
{
}
void mitk::NavigationData::Graft( const DataObject *data )
{
// Attempt to cast data to an NavigationData
const Self* nd;
try
{
nd = dynamic_cast<const Self *>( data );
}
catch( ... )
{
itkExceptionMacro( << "mitk::NavigationData::Graft cannot cast "
<< typeid(data).name() << " to "
<< typeid(const Self *).name() );
return;
}
if (!nd)
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::NavigationData::Graft cannot cast "
<< typeid(data).name() << " to "
<< typeid(const Self *).name() );
return;
}
// Now copy anything that is needed
this->SetPosition(nd->GetPosition());
this->SetOrientation(nd->GetOrientation());
this->SetDataValid(nd->IsDataValid());
- this->SetTimeStamp(nd->GetTimeStamp());
+ this->SetIGTTimeStamp(nd->GetIGTTimeStamp());
this->SetHasPosition(nd->GetHasPosition());
this->SetHasOrientation(nd->GetHasOrientation());
this->SetCovErrorMatrix(nd->GetCovErrorMatrix());
this->SetName(nd->GetName());
}
bool mitk::NavigationData::IsDataValid() const
{
return m_DataValid;
}
void mitk::NavigationData::PrintSelf(std::ostream& os, itk::Indent indent) const
{
this->Superclass::PrintSelf(os, indent);
os << indent << "data valid: " << this->IsDataValid() << std::endl;
os << indent << "Position: " << this->GetPosition() << std::endl;
- os << indent << "TimeStamp: " << this->GetTimeStamp() << std::endl;
+ os << indent << "TimeStamp: " << this->GetIGTTimeStamp() << std::endl;
os << indent << "HasPosition: " << this->GetHasPosition() << std::endl;
os << indent << "HasOrientation: " << this->GetHasOrientation() << std::endl;
os << indent << "CovErrorMatrix: " << this->GetCovErrorMatrix() << std::endl;
}
void mitk::NavigationData::CopyInformation( const DataObject* data )
{
this->Superclass::CopyInformation( data );
const Self * nd = NULL;
try
{
nd = dynamic_cast<const Self*>(data);
}
catch( ... )
{
// data could not be cast back down
itkExceptionMacro(<< "mitk::NavigationData::CopyInformation() cannot cast "
<< typeid(data).name() << " to "
<< typeid(Self*).name() );
}
if ( !nd )
{
// pointer could not be cast back down
itkExceptionMacro(<< "mitk::NavigationData::CopyInformation() cannot cast "
<< typeid(data).name() << " to "
<< typeid(Self*).name() );
}
/* copy all meta data */
}
void mitk::NavigationData::SetPositionAccuracy(mitk::ScalarType error)
{
for ( int i = 0; i < 3; i++ )
for ( int j = 0; j < 3; j++ )
{
m_CovErrorMatrix[ i ][ j ] = 0;
// assume independence of position and orientation
m_CovErrorMatrix[ i + 3 ][ j ] = 0;
m_CovErrorMatrix[ i ][ j + 3 ] = 0;
}
m_CovErrorMatrix[0][0] = m_CovErrorMatrix[1][1] = m_CovErrorMatrix[2][2] = error * error;
}
void mitk::NavigationData::SetOrientationAccuracy(mitk::ScalarType error)
{
for ( int i = 0; i < 3; i++ )
for ( int j = 0; j < 3; j++ ) {
m_CovErrorMatrix[ i + 3 ][ j + 3 ] = 0;
// assume independence of position and orientation
m_CovErrorMatrix[ i + 3 ][ j ] = 0;
m_CovErrorMatrix[ i ][ j + 3 ] = 0;
}
m_CovErrorMatrix[3][3] = m_CovErrorMatrix[4][4] = m_CovErrorMatrix[5][5] = error * error;
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationData.h b/Modules/IGT/IGTFilters/mitkNavigationData.h
index a346b441da..3a8cc9c7af 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationData.h
+++ b/Modules/IGT/IGTFilters/mitkNavigationData.h
@@ -1,206 +1,206 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKNAVIGATIONDATA_H_HEADER_INCLUDED_
#define MITKNAVIGATIONDATA_H_HEADER_INCLUDED_
#include <itkDataObject.h>
#include <MitkIGTExports.h>
#include <mitkCommon.h>
#include <mitkVector.h>
namespace mitk {
/**Documentation
* \brief Navigation Data
*
* This class represents the data object that is passed through the MITK-IGT navigation filter
* pipeline. It encapsulates position and orientation of a tracked tool/sensor. Additionally,
* it contains a data structure that contains error/plausibility information
*
* \ingroup IGT
*/
class MitkIGT_EXPORT NavigationData : public itk::DataObject
{
public:
mitkClassMacro(NavigationData, itk::DataObject);
itkNewMacro(Self);
/**
* \brief Type that holds the position part of the tracking data
*/
typedef mitk::Point3D PositionType;
/**
* \brief Type that holds the orientation part of the tracking data
*/
typedef mitk::Quaternion OrientationType;
/**
* \brief type that holds the error characterization of the position and orientation measurements
*/
typedef itk::Matrix<mitk::ScalarType,6,6> CovarianceMatrixType;
/**
* \brief type that holds the time at which the data was recorded
*/
typedef double TimeStampType;
/**
* \brief sets the position of the NavigationData object
*/
itkSetMacro(Position, PositionType);
/**
* \brief returns position of the NavigationData object
*/
itkGetConstMacro(Position, PositionType);
/**
* \brief sets the orientation of the NavigationData object
*/
itkSetMacro(Orientation, OrientationType);
/**
* \brief returns the orientation of the NavigationData object
*/
itkGetConstMacro(Orientation, OrientationType);
/**
* \brief returns true if the object contains valid data
*/
virtual bool IsDataValid() const;
/**
* \brief sets the dataValid flag of the NavigationData object indicating if the object contains valid data
*/
itkSetMacro(DataValid, bool);
/**
- * \brief sets the timestamp of the NavigationData object
+ * \brief sets the IGT timestamp of the NavigationData object
*/
- itkSetMacro(TimeStamp, TimeStampType);
+ itkSetMacro(IGTTimeStamp, TimeStampType);
/**
- * \brief gets the timestamp of the NavigationData object
+ * \brief gets the IGT timestamp of the NavigationData object
*/
- itkGetConstMacro(TimeStamp, TimeStampType);
+ itkGetConstMacro(IGTTimeStamp, TimeStampType);
/**
* \brief sets the HasPosition flag of the NavigationData object
*/
itkSetMacro(HasPosition, bool);
/**
* \brief gets the HasPosition flag of the NavigationData object
*/
itkGetConstMacro(HasPosition, bool);
/**
* \brief sets the HasOrientation flag of the NavigationData object
*/
itkSetMacro(HasOrientation, bool);
/**
* \brief gets the HasOrientation flag of the NavigationData object
*/
itkGetConstMacro(HasOrientation, bool);
/**
* \brief sets the 6x6 Error Covariance Matrix of the NavigationData object
*/
itkSetMacro(CovErrorMatrix, CovarianceMatrixType);
/**
* \brief gets the 6x6 Error Covariance Matrix of the NavigationData object
*/
itkGetConstMacro(CovErrorMatrix, CovarianceMatrixType);
/**
* \brief set the name of the NavigationData object
*/
itkSetStringMacro(Name);
/**
* \brief returns the name of the NavigationData object
*/
itkGetStringMacro(Name);
/**
* \brief Graft the data and information from one NavigationData to another.
*
* Copies the content of data into this object.
* This is a convenience method to setup a second NavigationData object with all the meta
* information of another NavigationData object.
* Note that this method is different than just using two
* SmartPointers to the same NavigationData object since separate DataObjects are
* still maintained.
*/
virtual void Graft(const DataObject *data);
/**
* \brief copy meta data of a NavigationData object
*
* copies all meta data from NavigationData data to this object
*/
virtual void CopyInformation(const DataObject* data);
/**
* \brief Prints the object information to the given stream os.
* \param os The stream which is used to print the output.
* \param indent Defines the indentation of the output.
*/
void PrintSelf(std::ostream& os, itk::Indent indent) const;
/**
* Set the position part of m_CovErrorMatrix to I*error^2
* This means that all position variables are assumed to be independent
*/
void SetPositionAccuracy(mitk::ScalarType error);
/**
* Set the orientation part of m_CovErrorMatrix to I*error^2
* This means that all orientation variables are assumed to be independent
*/
void SetOrientationAccuracy(mitk::ScalarType error);
protected:
NavigationData();
virtual ~NavigationData();
/**
* \brief holds the position part of the tracking data
*/
PositionType m_Position;
/**
* \brief holds the orientation part of the tracking data
*/
OrientationType m_Orientation;
/**
* \brief A 6x6 covariance matrix parameterizing the Gaussian error
* distribution of the measured position and orientation.
*
* The hasPosition/hasOrientation fields define which entries
* are valid.
*/
CovarianceMatrixType m_CovErrorMatrix; ///< holds the error characterization of the position and orientation
/**
* \brief defines if position part of m_CovErrorMatrix is valid
*/
bool m_HasPosition;
/**
* \brief defines if orientation part of m_CovErrorMatrix is valid
*/
bool m_HasOrientation;
/**
* \brief defines if the object contains valid values
*/
bool m_DataValid;
/**
* \brief contains the time at which the tracking data was recorded
*/
- TimeStampType m_TimeStamp;
+ TimeStampType m_IGTTimeStamp;
/**
* \brief name of the navigation data
*/
std::string m_Name;
};
} // namespace mitk
#endif /* MITKNAVIGATIONDATA_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataLandmarkTransformFilter.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataLandmarkTransformFilter.cpp
index 42bd72ed0f..b0f6257888 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataLandmarkTransformFilter.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataLandmarkTransformFilter.cpp
@@ -1,459 +1,461 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataLandmarkTransformFilter.h"
#include "itkIndent.h"
#include "itkEuler3DTransform.h"
#include "itkVersorRigid3DTransform.h"
#include "itkEuclideanDistancePointMetric.h"
#include "itkLevenbergMarquardtOptimizer.h"
#include "itkPointSet.h"
#include "itkPointSetToPointSetRegistrationMethod.h"
#include <algorithm>
mitk::NavigationDataLandmarkTransformFilter::NavigationDataLandmarkTransformFilter() : mitk::NavigationDataToNavigationDataFilter(),
m_ErrorMean(-1.0), m_ErrorStdDev(-1.0), m_ErrorRMS(-1.0), m_ErrorMin(-1.0), m_ErrorMax(-1.0), m_ErrorAbsMax(-1.0),
m_SourcePoints(), m_TargetPoints(), m_LandmarkTransformInitializer(NULL), m_LandmarkTransform(NULL),
m_QuatLandmarkTransform(NULL), m_QuatTransform(NULL), m_Errors(), m_UseICPInitialization(false)
{
m_LandmarkTransform = LandmarkTransformType::New();
m_LandmarkTransformInitializer = TransformInitializerType::New();
m_LandmarkTransformInitializer->SetTransform(m_LandmarkTransform);
//transform to rotate orientation
m_QuatLandmarkTransform = QuaternionTransformType::New();
m_QuatTransform = QuaternionTransformType::New();
}
mitk::NavigationDataLandmarkTransformFilter::~NavigationDataLandmarkTransformFilter()
{
m_LandmarkTransform = NULL;
m_LandmarkTransformInitializer = NULL;
m_QuatLandmarkTransform = NULL;
m_QuatTransform = NULL;
}
void mitk::NavigationDataLandmarkTransformFilter::InitializeLandmarkTransform(LandmarkPointContainer& sources, const LandmarkPointContainer& targets)
{
if (m_UseICPInitialization == true)
{
if (this->FindCorrespondentLandmarks(sources, targets) == false) // determine landmark correspondences with iterative closest point optimization, sort sort landmarks accordingly
{
itkExceptionMacro("Landmark correspondence finding failed.");
}
}
if(m_SourcePoints.size() != m_TargetPoints.size())// check whether target and source points size are equal itk registration won't work otherways
return;
this->UpdateLandmarkTransform(sources, targets); // if size of source and target points is equal
}
void mitk::NavigationDataLandmarkTransformFilter::SetSourceLandmarks(mitk::PointSet::Pointer mitkSourcePointSet)
{
m_SourcePoints.clear();
mitk::PointSet::PointType mitkSourcePoint;
TransformInitializerType::LandmarkPointType lPoint;
for (mitk::PointSet::PointsContainer::ConstIterator it = mitkSourcePointSet->GetPointSet()->GetPoints()->Begin();
it != mitkSourcePointSet->GetPointSet()->GetPoints()->End(); ++it)
{
mitk::FillVector3D(lPoint, it->Value().GetElement(0), it->Value().GetElement(1), it->Value().GetElement(2));
m_SourcePoints.push_back(lPoint);
}
if (m_SourcePoints.size() < 3)
{
itkExceptionMacro("SourcePointSet must contain at least 3 points");
}
if (this->IsInitialized())
this->InitializeLandmarkTransform(m_SourcePoints, m_TargetPoints);
}
void mitk::NavigationDataLandmarkTransformFilter::SetTargetLandmarks(mitk::PointSet::Pointer mitkTargetPointSet)
{
m_TargetPoints.clear();
TransformInitializerType::LandmarkPointType lPoint;
for (mitk::PointSet::PointsContainer::ConstIterator it = mitkTargetPointSet->GetPointSet()->GetPoints()->Begin();
it != mitkTargetPointSet->GetPointSet()->GetPoints()->End(); ++it)
{
mitk::FillVector3D(lPoint, it->Value().GetElement(0), it->Value().GetElement(1), it->Value().GetElement(2));
m_TargetPoints.push_back(lPoint);
}
if (m_TargetPoints.size() < 3)
{
itkExceptionMacro("TargetPointSet must contain at least 3 points");
}
if (this->IsInitialized())
this->InitializeLandmarkTransform(m_SourcePoints, m_TargetPoints);
}
mitk::ScalarType mitk::NavigationDataLandmarkTransformFilter::GetFRE() const
{
return m_ErrorMean;
}
mitk::ScalarType mitk::NavigationDataLandmarkTransformFilter::GetFREStdDev() const
{
return m_ErrorStdDev;
}
mitk::ScalarType mitk::NavigationDataLandmarkTransformFilter::GetRMSError() const
{
return m_ErrorRMS;
}
mitk::ScalarType mitk::NavigationDataLandmarkTransformFilter::GetMinError() const
{
return m_ErrorMin;
}
mitk::ScalarType mitk::NavigationDataLandmarkTransformFilter::GetMaxError() const
{
return m_ErrorMax;
}
mitk::ScalarType mitk::NavigationDataLandmarkTransformFilter::GetAbsMaxError() const
{
return m_ErrorAbsMax;
}
void mitk::NavigationDataLandmarkTransformFilter::AccumulateStatistics(std::vector<mitk::ScalarType>& vector)
{
//mean, min, max
m_ErrorMean = 0.0;
m_ErrorMin = itk::NumericTraits<mitk::ScalarType>::max();
m_ErrorMax = itk::NumericTraits<mitk::ScalarType>::min();
m_ErrorAbsMax = 0.0;
m_ErrorRMS = 0.0;
for (std::vector<mitk::ScalarType>::size_type i = 0; i < vector.size(); i++)
{
m_ErrorMean += vector[i]; // mean
m_ErrorRMS += pow(vector[i],2); // RMS
if(vector[i] < m_ErrorMin) // min
m_ErrorMin = vector[i];
if(vector[i] > m_ErrorMax) // max
m_ErrorMax = vector[i];
if(fabs(vector[i]) > fabs(m_ErrorAbsMax)) // abs_max
m_ErrorAbsMax = vector[i];
}
m_ErrorMean /= vector.size();
m_ErrorRMS = sqrt(m_ErrorRMS/vector.size());
//standard deviation
m_ErrorStdDev = 0.0;
for (std::vector<mitk::ScalarType>::size_type i = 0; i < vector.size(); i++)
m_ErrorStdDev += pow(vector[i] - m_ErrorMean, 2);
if(vector.size() > 1)
m_ErrorStdDev = sqrt(m_ErrorStdDev / (vector.size() - 1.0));
this->Modified();
}
void mitk::NavigationDataLandmarkTransformFilter::GenerateData()
{
this->CreateOutputsForAllInputs(); // make sure that we have the same number of outputs as inputs
TransformInitializerType::LandmarkPointType lPointIn, lPointOut;
/* update outputs with tracking data from tools */
for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i)
{
mitk::NavigationData* output = this->GetOutput(i);
assert(output);
const mitk::NavigationData* input = this->GetInput(i);
assert(input);
if (input->IsDataValid() == false)
{
output->SetDataValid(false);
continue;
}
output->Graft(input); // First, copy all information from input to output
if (this->IsInitialized() == false) // as long as there is no valid transformation matrix, only graft the outputs
continue;
mitk::NavigationData::PositionType tempCoordinate;
tempCoordinate = input->GetPosition();
lPointIn[0] = tempCoordinate[0]; // convert navigation data position to transform point
lPointIn[1] = tempCoordinate[1];
lPointIn[2] = tempCoordinate[2];
/* transform position */
lPointOut = m_LandmarkTransform->TransformPoint(lPointIn); // transform position
tempCoordinate[0] = lPointOut[0]; // convert back into navigation data position
tempCoordinate[1] = lPointOut[1];
tempCoordinate[2] = lPointOut[2];
output->SetPosition(tempCoordinate); // update output navigation data with new position
/* transform orientation */
NavigationData::OrientationType quatIn = input->GetOrientation();
vnl_quaternion<double> const vnlQuatIn(quatIn.x(), quatIn.y(), quatIn.z(), quatIn.r()); // convert orientation into vnl quaternion
m_QuatTransform->SetRotation(vnlQuatIn); // convert orientation into transform
- m_QuatLandmarkTransform->SetMatrix(m_LandmarkTransform->GetRotationMatrix()); // set rotation from landmark transform
+ vnl_quaternion<double> const vnlQLTrans = vnl_quaternion<double>(m_LandmarkTransform->GetMatrix().GetVnlMatrix());
+
+ m_QuatLandmarkTransform->SetRotation(vnlQLTrans); // set rotation from landmark transform
m_QuatLandmarkTransform->Compose(m_QuatTransform, true); // compose navigation data transform and landmark transform
vnl_quaternion<double> vnlQuatOut = m_QuatLandmarkTransform->GetRotation(); // convert composed transform back into a quaternion
NavigationData::OrientationType quatOut(vnlQuatOut[0], vnlQuatOut[1], vnlQuatOut[2], vnlQuatOut[3]); // convert back into navigation data orientation
output->SetOrientation(quatOut); // update output navigation data with new orientation
output->SetDataValid(true); // operation was successful, therefore data of output is valid.
}
}
bool mitk::NavigationDataLandmarkTransformFilter::IsInitialized() const
{
return (m_SourcePoints.size() >= 3) && (m_TargetPoints.size() >= 3);
}
void mitk::NavigationDataLandmarkTransformFilter::PrintSelf( std::ostream& os, itk::Indent indent ) const
{
Superclass::PrintSelf(os, indent);
os << indent << this->GetNameOfClass() << ":\n";
os << indent << m_SourcePoints.size() << " SourcePoints exist: \n";
itk::Indent nextIndent = indent.GetNextIndent();
unsigned int i = 0;
for (LandmarkPointContainer::const_iterator it = m_SourcePoints.begin(); it != m_SourcePoints.end(); ++it)
{
os << nextIndent << "Point " << i++ << ": [";
os << it->GetElement(0);
for (unsigned int i = 1; i < TransformInitializerType::LandmarkPointType::GetPointDimension(); ++i)
{
os << ", " << it->GetElement(i);
}
os << "]\n";
}
os << indent << m_TargetPoints.size() << " TargetPoints exist: \n";
i = 0;
for (LandmarkPointContainer::const_iterator it = m_TargetPoints.begin(); it != m_TargetPoints.end(); ++it)
{
os << nextIndent << "Point " << i++ << ": [";
os << it->GetElement(0);
for (unsigned int i = 1; i < TransformInitializerType::LandmarkPointType::GetPointDimension(); ++i)
{
os << ", " << it->GetElement(i);
}
os << "]\n";
}
os << indent << "Landmarktransform initialized: " << this->IsInitialized() << "\n";
if (this->IsInitialized() == true)
m_LandmarkTransform->Print(os, nextIndent);
os << indent << "Registration error statistics:\n";
os << nextIndent << "FRE: " << this->GetFRE() << "\n";
os << nextIndent << "FRE std.dev.: " << this->GetFREStdDev() << "\n";
os << nextIndent << "FRE RMS: " << this->GetRMSError() << "\n";
os << nextIndent << "Minimum registration error: " << this->GetMinError() << "\n";
os << nextIndent << "Maximum registration error: " << this->GetMaxError() << "\n";
os << nextIndent << "Absolute Maximum registration error: " << this->GetAbsMaxError() << "\n";
}
const mitk::NavigationDataLandmarkTransformFilter::ErrorVector& mitk::NavigationDataLandmarkTransformFilter::GetErrorVector() const
{
return m_Errors;
}
bool mitk::NavigationDataLandmarkTransformFilter::FindCorrespondentLandmarks(LandmarkPointContainer& sources, const LandmarkPointContainer& targets) const
{
if (sources.size() < 6 || targets.size() < 6)
return false;
//throw std::invalid_argument("ICP correspondence finding needs at least 6 landmarks");
/* lots of type definitions */
typedef itk::PointSet<mitk::ScalarType, 3> PointSetType;
//typedef itk::BoundingBox<PointSetType::PointIdentifier, PointSetType::PointDimension> BoundingBoxType;
typedef itk::EuclideanDistancePointMetric< PointSetType, PointSetType> MetricType;
//typedef MetricType::TransformType TransformBaseType;
//typedef MetricType::TransformType::ParametersType ParametersType;
//typedef TransformBaseType::JacobianType JacobianType;
//typedef itk::Euler3DTransform< double > TransformType;
typedef itk::VersorRigid3DTransform< double > TransformType;
typedef TransformType ParametersType;
typedef itk::PointSetToPointSetRegistrationMethod< PointSetType, PointSetType > RegistrationType;
/* copy landmarks to itk pointsets for registration */
PointSetType::Pointer sourcePointSet = PointSetType::New();
unsigned int i = 0;
for (LandmarkPointContainer::const_iterator it = sources.begin(); it != sources.end(); ++it)
{
PointSetType::PointType doublePoint;
mitk::itk2vtk(*it, doublePoint); // copy mitk::ScalarType point into double point as workaround to ITK 3.10 bug
sourcePointSet->SetPoint(i++, doublePoint /**it*/);
}
i = 0;
PointSetType::Pointer targetPointSet = PointSetType::New();
for (LandmarkPointContainer::const_iterator it = targets.begin(); it != targets.end(); ++it)
{
PointSetType::PointType doublePoint;
mitk::itk2vtk(*it, doublePoint); // copy mitk::ScalarType point into double point as workaround to ITK 3.10 bug
targetPointSet->SetPoint(i++, doublePoint /**it*/);
}
/* get centroid and extends of our pointsets */
//BoundingBoxType::Pointer sourceBoundingBox = BoundingBoxType::New();
//sourceBoundingBox->SetPoints(sourcePointSet->GetPoints());
//sourceBoundingBox->ComputeBoundingBox();
//BoundingBoxType::Pointer targetBoundingBox = BoundingBoxType::New();
//targetBoundingBox->SetPoints(targetPointSet->GetPoints());
//targetBoundingBox->ComputeBoundingBox();
TransformType::Pointer transform = TransformType::New();
transform->SetIdentity();
//transform->SetTranslation(targetBoundingBox->GetCenter() - sourceBoundingBox->GetCenter());
itk::LevenbergMarquardtOptimizer::Pointer optimizer = itk::LevenbergMarquardtOptimizer::New();
optimizer->SetUseCostFunctionGradient(false);
RegistrationType::Pointer registration = RegistrationType::New();
// Scale the translation components of the Transform in the Optimizer
itk::LevenbergMarquardtOptimizer::ScalesType scales(transform->GetNumberOfParameters());
const double translationScale = 5000; //sqrtf(targetBoundingBox->GetDiagonalLength2()) * 1000; // dynamic range of translations
const double rotationScale = 1.0; // dynamic range of rotations
scales[0] = 1.0 / rotationScale;
scales[1] = 1.0 / rotationScale;
scales[2] = 1.0 / rotationScale;
scales[3] = 1.0 / translationScale;
scales[4] = 1.0 / translationScale;
scales[5] = 1.0 / translationScale;
//scales.Fill(0.01);
unsigned long numberOfIterations = 80000;
double gradientTolerance = 1e-10; // convergence criterion
double valueTolerance = 1e-10; // convergence criterion
double epsilonFunction = 1e-10; // convergence criterion
optimizer->SetScales( scales );
optimizer->SetNumberOfIterations( numberOfIterations );
optimizer->SetValueTolerance( valueTolerance );
optimizer->SetGradientTolerance( gradientTolerance );
optimizer->SetEpsilonFunction( epsilonFunction );
registration->SetInitialTransformParameters( transform->GetParameters() );
//------------------------------------------------------
// Connect all the components required for Registration
//------------------------------------------------------
MetricType::Pointer metric = MetricType::New();
registration->SetMetric( metric );
registration->SetOptimizer( optimizer );
registration->SetTransform( transform );
registration->SetFixedPointSet( targetPointSet );
registration->SetMovingPointSet( sourcePointSet );
try
{
//registration->StartRegistration();
registration->Update();
}
catch( itk::ExceptionObject & e )
{
MITK_INFO << "Exception caught during ICP optimization: " << e;
return false;
//throw e;
}
MITK_INFO << "ICP successful: Solution = " << transform->GetParameters() << std::endl;
MITK_INFO << "Metric value: " << metric->GetValue(transform->GetParameters());
/* find point correspondences */
//mitk::PointLocator::Pointer pointLocator = mitk::PointLocator::New(); // <<- use mitk::PointLocator instead of searching manually?
//pointLocator->SetPoints()
for (LandmarkPointContainer::const_iterator sourcesIt = sources.begin(); sourcesIt != sources.end(); ++sourcesIt)
{
}
//MetricType::MeasureType closestDistances = metric->GetValue(transform->GetParameters());
//unsigned int index = 0;
LandmarkPointContainer sortedSources;
for (LandmarkPointContainer::const_iterator targetsIt = targets.begin(); targetsIt != targets.end(); ++targetsIt)
{
double minDistance = itk::NumericTraits<double>::max();
LandmarkPointContainer::iterator minDistanceIterator = sources.end();
for (LandmarkPointContainer::iterator sourcesIt = sources.begin(); sourcesIt != sources.end(); ++sourcesIt)
{
TransformInitializerType::LandmarkPointType transformedSource = transform->TransformPoint(*sourcesIt);
double dist = targetsIt->EuclideanDistanceTo(transformedSource);
MITK_INFO << "target: " << *targetsIt << ", source: " << *sourcesIt << ", transformed source: " << transformedSource << ", dist: " << dist;
if (dist < minDistance )
{
minDistanceIterator = sourcesIt;
minDistance = dist;
}
}
if (minDistanceIterator == sources.end())
return false;
MITK_INFO << "minimum distance point is: " << *minDistanceIterator << " (dist: " << targetsIt->EuclideanDistanceTo(transform->TransformPoint(*minDistanceIterator)) << ", minDist: " << minDistance << ")";
sortedSources.push_back(*minDistanceIterator); // this point is assigned
sources.erase(minDistanceIterator); // erase it from sources to avoid duplicate assigns
}
//for (LandmarkPointContainer::const_iterator sortedSourcesIt = sortedSources.begin(); targetsIt != sortedSources.end(); ++targetsIt)
sources = sortedSources;
return true;
}
void mitk::NavigationDataLandmarkTransformFilter::UpdateLandmarkTransform(const LandmarkPointContainer &sources, const LandmarkPointContainer &targets)
{
try
{
/* calculate transform from landmarks */
m_LandmarkTransformInitializer->SetMovingLandmarks(targets);
m_LandmarkTransformInitializer->SetFixedLandmarks(sources); // itk registration always maps from fixed object space to moving object space
m_LandmarkTransform->SetIdentity();
m_LandmarkTransformInitializer->InitializeTransform();
/* Calculate error statistics for the transform */
TransformInitializerType::LandmarkPointType curData;
m_Errors.clear();
for (LandmarkPointContainer::size_type index = 0; index < sources.size(); index++)
{
curData = m_LandmarkTransform->TransformPoint(sources.at(index));
m_Errors.push_back(curData.EuclideanDistanceTo(targets.at(index)));
}
this->AccumulateStatistics(m_Errors);
this->Modified();
}
catch (std::exception& e)
{
m_Errors.clear();
m_LandmarkTransform->SetIdentity();
itkExceptionMacro("Initializing landmark-transform failed\n. " << e.what());
}
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.cpp
index 53c4823896..eddacc6619 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.cpp
@@ -1,550 +1,550 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataPlayer.h"
#include <itksys/SystemTools.hxx>
#include <mitkIGTTimeStamp.h>
#include <fstream>
//includes for exceptions
#include "mitkIGTException.h"
#include "mitkIGTIOException.h"
mitk::NavigationDataPlayer::NavigationDataPlayer() : mitk::NavigationDataPlayerBase()
{
m_NumberOfOutputs = 0;
m_Pause = false;
m_Playing = false;
m_Stream = NULL;
m_PlayerMode = NormalFile;
m_FileName = "";
m_FileVersion = 1;
m_Playing = false;
m_Pause = false;
m_NumberOfOutputs = 0;
m_StartPlayingTimeStamp = 0.0;
m_PauseTimeStamp = 0.0;
m_parentElement = NULL;
m_currentNode = NULL;
m_StreamEnd = false;
m_StreamSetOutsideFromClass = false;
//To get a start time
mitk::IGTTimeStamp::GetInstance()->Start(this);
}
mitk::NavigationDataPlayer::~NavigationDataPlayer()
{
StopPlaying();
delete m_parentElement;
}
void mitk::NavigationDataPlayer::GenerateData()
{
//Only produce new output if the player is started
if (!m_Playing) //m_Playing==true means player has started
{
//The output is not valid anymore
for (unsigned int index = 0; index < m_NumberOfOutputs; index++)
{
mitk::NavigationData* output = this->GetOutput(index);
assert(output);
mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
mitk::NavigationData::PositionType position;
mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
position.Fill(0.0);
nd->SetPosition(position);
nd->SetOrientation(orientation);
nd->SetDataValid(false);
output->Graft(nd);
}
return;
}
//first of all get current time
TimeStampType now = mitk::IGTTimeStamp::GetInstance()->GetElapsed();
//now we make a little time arithmetic
//to get the elapsed time since the start of the player
TimeStampType timeSinceStart = now - m_StartPlayingTimeStamp;
//init the vectors
std::vector< NavigationData::Pointer > nextCandidates;
std::vector< NavigationData::Pointer > lastCandidates;
std::vector< NavigationData::TimeStampType > currentTimeOfData;
for (unsigned int index=0; index < m_NumberOfOutputs; index++)
{
nextCandidates.push_back(m_NextToPlayNavigationData.at(index));
lastCandidates.push_back(m_NextToPlayNavigationData.at(index));
currentTimeOfData.push_back(timeSinceStart + m_StartTimeOfData.at(index));
}
if (m_NextToPlayNavigationData.size() != m_NumberOfOutputs)
{
MITK_ERROR << "Mismatch in data";
return;
}
// Now we try to find next NavigationData in the stream:
// This means we step through the stream of NavigationDatas until we find
// a NavigationData which has a current timestamp (currentTimeOfData) greater
// than the current playing time. Then we store the data in
// m_NextToPlayNavigationData and take the last data (lastCandidates) for the
// output of this filter.
//
// The loop will stop when a suitable NavigationData is found or we reach EOF.
// The timestamps of each recorded NavigationData should be equal
// therefore we take always the time from the first.
- while( nextCandidates[0]->GetTimeStamp() < currentTimeOfData[0])
+ while( nextCandidates[0]->GetIGTTimeStamp() < currentTimeOfData[0])
{
for (unsigned int index=0; index < m_NumberOfOutputs; index++)
{
lastCandidates[index] = nextCandidates.at(index);
switch(m_FileVersion) // m_FileVersion indicates which XML encoding is used
{
case 1:
nextCandidates[index] = ReadVersion1();
break;
default: //this case should not happen! therefore return at this point
MITK_ERROR << "File encoding format was not stored, aborting!";
return;
break;
}
//check if the input stream delivered a correct NavigationData object
for (unsigned int i = 0; i < m_NumberOfOutputs; i++)
{
if (nextCandidates.at(index).IsNull())
//Stops playing because there is now more nextCandidate, the file ended for all outputs
{
m_StreamEnd = true;
StopPlaying();
return; //the case if no NavigationData is found, e.g. EOF, bad stream
}
}
}
}
//Now lastCandidates stores the new output and nextCandidates is stored to the m_NextToPlay vector
for (unsigned int index = 0; index < m_NumberOfOutputs; index++)
{
mitk::NavigationData* output = this->GetOutput(index);
assert(output);
output->Graft(lastCandidates.at(index));
m_NextToPlayNavigationData[index] = nextCandidates.at(index);
}
}
void mitk::NavigationDataPlayer::UpdateOutputInformation()
{
this->Modified(); // make sure that we need to be updated
Superclass::UpdateOutputInformation();
}
void mitk::NavigationDataPlayer::InitPlayer()
{
if (m_Stream == NULL)
{
StreamInvalid("Playing not possible. Wrong file name or path?");
return;
}
if (!m_Stream->good())
{
StreamInvalid("Playing not possible. Stream is not good!");
return;
}
//first get the file version
m_FileVersion = GetFileVersion(m_Stream);
//check if we have a valid version: m_FileVersion has to be always bigger than 1 for playing
if (m_FileVersion < 1)
{
StreamInvalid("Playing not possible. Invalid file version!");
return;
}
if(m_NumberOfOutputs == 0) {m_NumberOfOutputs = GetNumberOfNavigationDatas(m_Stream);}
//with the information about the tracked tool number we can generate the output
if (m_NumberOfOutputs > 0)
{
//Generate the output only if there are changes to the amount of outputs
//This happens when the player is stopped and start again with different file
if (this->GetNumberOfOutputs() != m_NumberOfOutputs) {SetNumberOfOutputs(m_NumberOfOutputs);}
//initialize the player with first data
GetFirstData();
//set stream valid
m_ErrorMessage = "";
m_StreamValid = true;
}
else
{
StreamInvalid("The input stream seems to have NavigationData incompatible format");
return;
}
}
unsigned int mitk::NavigationDataPlayer::GetFileVersion(std::istream* stream)
{
if (stream==NULL)
{
MITK_ERROR << "No input stream set!";
mitkThrowException(mitk::IGTException)<<"No input stream set!";
}
if (!stream->good())
{
MITK_ERROR << "Stream is not good!";
mitkThrowException(mitk::IGTException)<<"Stream is not good!";
}
int version = 1;
TiXmlDeclaration* dec = new TiXmlDeclaration();
*stream >> *dec;
if(strcmp(dec->Version(),"") == 0)
{
MITK_ERROR << "The input stream seems to have XML incompatible format";
mitkThrowException(mitk::IGTIOException) << "The input stream seems to have XML incompatible format";
}
m_parentElement = new TiXmlElement("");
*stream >> *m_parentElement; //2nd line this is the file version
std::string tempValue = m_parentElement->Value();
if(tempValue != "Version")
{
if(tempValue == "Data"){
m_parentElement->QueryIntAttribute("version",&version);
}
}
else
{
m_parentElement->QueryIntAttribute("Ver",&version);
}
if (version > 0)
return version;
else
return 0;
}
unsigned int mitk::NavigationDataPlayer::GetNumberOfNavigationDatas(std::istream* stream)
{
if (stream == NULL)
{
MITK_ERROR << "No input stream set!";
mitkThrowException(mitk::IGTException)<<"No input stream set!";
}
if (!stream->good())
{
MITK_ERROR << "Stream not good!";
mitkThrowException(mitk::IGTException)<<"Stream not good!";
}
//If something has changed in a future version of the XML definition e.g. navigationcount or addional parameters
//catch this here with a select case block (see GenerateData() method)
int numberOfTools = 0;
std::string tempValue = m_parentElement->Value();
if(tempValue == "Version"){
*stream >> *m_parentElement;
}
m_parentElement->QueryIntAttribute("ToolCount",&numberOfTools);
if (numberOfTools > 0)
return numberOfTools;
return 0;
}
mitk::NavigationData::Pointer mitk::NavigationDataPlayer::ReadVersion1()
{
if (m_Stream == NULL)
{
m_Playing = false;
MITK_ERROR << "Playing not possible. Wrong file name or path? ";
mitkThrowException(mitk::IGTException) << "Playing not possible. Wrong file name or path? ";
}
if (!m_Stream->good())
{
m_Playing = false;
MITK_ERROR << "Playing not possible. Stream is not good!";
mitkThrowException(mitk::IGTException) << "Playing not possible. Stream is not good!";
}
/*TiXmlElement* elem = new TiXmlElement("");
m_currentNode = m_parentElement->IterateChildren(m_currentNode);
if(m_currentNode)
{
elem = m_currentNode->ToElement();
}*/
TiXmlElement* elem;
m_currentNode = m_parentElement->IterateChildren(m_currentNode);
bool delElem;
if(m_currentNode)
{
elem = m_currentNode->ToElement();
if(elem==NULL)
{
mitkThrowException(mitk::IGTException) << "Cannot find element: Is this file damaged?";
}
delElem = false;
}
else
{
elem = new TiXmlElement("");
delElem = true;
}
mitk::NavigationData::Pointer nd = this->ReadNavigationData(elem);
if(delElem)
delete elem;
return nd;
}
void mitk::NavigationDataPlayer::StartPlaying()
{
if (m_Stream == NULL)
{
m_Playing = false;
//Perhaps the SetStream method was not called so we do this when a FileName is set with SetStream(PlayerMode)
if (m_FileName != "")
{
//The PlayerMode is initialized with LastSetStream
//CreateStreamFromFilename also calls InitPlayer()
try
{
CreateStreamFromFilename();
}
catch(mitk::IGTIOException e)
{
MITK_ERROR << "Cannot create stream from filename, please check the stream";
throw e; //TODO replace by macro
}
catch(mitk::IGTException e2)
{
MITK_ERROR << "Cannot open the file, please check the file";
throw e2; //TODO replace by macro
}
}
//now check again
if (m_Stream == NULL)
{
StopPlaying();
MITK_ERROR << "Playing not possible. Wrong file name or path?";
mitkThrowException(mitk::IGTException) << "Playing not possible. Wrong file name or path?";
}
}
if (!m_Playing && m_Stream->good())
{
m_Playing = true;
m_StartPlayingTimeStamp = mitk::IGTTimeStamp::GetInstance()->GetElapsed();
}
else
{
MITK_ERROR << "Player already started or stream is not good!";
StopPlaying();
}
}
void mitk::NavigationDataPlayer::StopPlaying()
{
//re init all data!! for playing again with different data
//only PlayerMode and FileName are not changed
m_Pause = false;
m_Playing = false;
if (!m_StreamSetOutsideFromClass)
{delete m_Stream;}
m_Stream = NULL;
m_FileVersion = 1;
m_Playing = false;
m_Pause = false;
m_StartPlayingTimeStamp = 0.0;
m_PauseTimeStamp = 0.0;
m_NextToPlayNavigationData.clear();
m_StartTimeOfData.clear();
}
void mitk::NavigationDataPlayer::GetFirstData()
{
//Here we read the first lines of input (dependend on the number of inputs)
for (unsigned int index=0; index < m_NumberOfOutputs; index++)
{
//Here we init the vector for later use
m_NextToPlayNavigationData.push_back(NULL);
m_StartTimeOfData.push_back(0.0);
mitk::NavigationData::Pointer nd = this->GetOutput(index);
switch(m_FileVersion)
{
case 1:
m_NextToPlayNavigationData[index] = ReadVersion1();
//check if there is valid data in it
if (m_NextToPlayNavigationData[index].IsNull())
{
m_StreamEnd = true;
StopPlaying();
mitkThrowException(mitk::IGTIOException) << "XML File is corrupt or has no NavigationData.";
}
//Have a look it the output was set already without this check the pipline will disconnect after a start/stop cycle
if (nd.IsNull()) {this->SetNthOutput(index, m_NextToPlayNavigationData[index]);}
- m_StartTimeOfData[index] = m_NextToPlayNavigationData[index]->GetTimeStamp();
+ m_StartTimeOfData[index] = m_NextToPlayNavigationData[index]->GetIGTTimeStamp();
break;
default: //this case should not happen! therefore the return at this point
return;
break;
}
}
}
void mitk::NavigationDataPlayer::Pause()
{
//player runs and pause was called -> pause the player
if(m_Playing && !m_Pause)
{
m_Playing = false;
m_Pause = true;
m_PauseTimeStamp = mitk::IGTTimeStamp::GetInstance()->GetElapsed();
}
else
{
MITK_ERROR << "Player is either not started or already is paused" << std::endl;
}
}
void mitk::NavigationDataPlayer::Resume()
{
//player is in pause mode -> play at the last position
if(!m_Playing && m_Pause)
{
m_Playing = true;
m_Pause = false;
mitk::NavigationData::TimeStampType now = mitk::IGTTimeStamp::GetInstance()->GetElapsed();
// in this case m_StartPlayingTimeStamp is set to the total elapsed time with NO playback
m_StartPlayingTimeStamp = now - (m_PauseTimeStamp - m_StartPlayingTimeStamp);
}
else
{
MITK_ERROR << "Player is not paused!" << std::endl;
}
}
void mitk::NavigationDataPlayer::CreateStreamFromFilename()
{
m_Stream = NULL;
if (!itksys::SystemTools::FileExists(m_FileName.c_str()))
{
mitkThrowException(mitk::IGTIOException) << "File does not exist!";
}
switch(m_PlayerMode)
{
case NormalFile:
m_Stream = new std::ifstream(m_FileName.c_str());
m_StreamSetOutsideFromClass = false;
break;
case ZipFile:
m_Stream = NULL;
MITK_ERROR << "Sorry no ZipFile support yet";
break;
default:
m_Stream = NULL;
mitkThrowException(mitk::IGTException) << "The stream is NULL";
break;
}
this->Modified();
InitPlayer();
}
void mitk::NavigationDataPlayer::SetStream( std::istream* stream )
{
if ( (stream == NULL) || (!stream->good()))
{
// throw an exception for stream=NULL or it is not good
mitkThrowException(mitk::IGTException) << "The stream is NULL or it is not good";
m_StreamEnd = true;
return;
}
m_Stream = stream;
m_StreamSetOutsideFromClass = true;
this->Modified();
InitPlayer();
}
bool mitk::NavigationDataPlayer::IsAtEnd()
{
return this->m_StreamEnd;
}
void mitk::NavigationDataPlayer::StreamInvalid(std::string message)
{
m_StreamEnd = true;
StopPlaying();
m_ErrorMessage = message;
m_StreamValid = false;
mitkThrowException(mitk::IGTIOException) << "Invalid stream!";
}
\ No newline at end of file
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp
index d468b2ac34..e9adf664e5 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp
@@ -1,118 +1,118 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataPlayerBase.h"
mitk::NavigationDataPlayerBase::NavigationDataPlayerBase() : m_StreamValid(true), m_ErrorMessage("")
{
m_Name ="Navigation Data Player Source";
}
mitk::NavigationDataPlayerBase::~NavigationDataPlayerBase()
{
}
void mitk::NavigationDataPlayerBase::UpdateOutputInformation()
{
this->Modified(); // make sure that we need to be updated
Superclass::UpdateOutputInformation();
}
mitk::NavigationData::Pointer mitk::NavigationDataPlayerBase::ReadNavigationData(TiXmlElement* elem)
{
if (elem == NULL) {mitkThrow() << "Error: Element is NULL!";}
mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
mitk::NavigationData::PositionType position;
mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
mitk::NavigationData::TimeStampType timestamp = -1;
mitk::NavigationData::CovarianceMatrixType matrix;
bool hasPosition = true;
bool hasOrientation = true;
bool dataValid = false;
position.Fill(0.0);
matrix.SetIdentity();
elem->QueryDoubleAttribute("Time",&timestamp);
if (timestamp == -1)
{
return NULL; //the calling method should check the return value if it is valid/not NULL
}
elem->QueryFloatAttribute("X", &position[0]);
elem->QueryFloatAttribute("Y", &position[1]);
elem->QueryFloatAttribute("Z", &position[2]);
elem->QueryFloatAttribute("QX", &orientation[0]);
elem->QueryFloatAttribute("QY", &orientation[1]);
elem->QueryFloatAttribute("QZ", &orientation[2]);
elem->QueryFloatAttribute("QR", &orientation[3]);
elem->QueryFloatAttribute("C00", &matrix[0][0]);
elem->QueryFloatAttribute("C01", &matrix[0][1]);
elem->QueryFloatAttribute("C02", &matrix[0][2]);
elem->QueryFloatAttribute("C03", &matrix[0][3]);
elem->QueryFloatAttribute("C04", &matrix[0][4]);
elem->QueryFloatAttribute("C05", &matrix[0][5]);
elem->QueryFloatAttribute("C10", &matrix[1][0]);
elem->QueryFloatAttribute("C11", &matrix[1][1]);
elem->QueryFloatAttribute("C12", &matrix[1][2]);
elem->QueryFloatAttribute("C13", &matrix[1][3]);
elem->QueryFloatAttribute("C14", &matrix[1][4]);
elem->QueryFloatAttribute("C15", &matrix[1][5]);
int tmpval = 0;
elem->QueryIntAttribute("Valid", &tmpval);
if (tmpval == 0)
dataValid = false;
else
dataValid = true;
tmpval = 0;
elem->QueryIntAttribute("hO", &tmpval);
if (tmpval == 0)
hasOrientation = false;
else
hasOrientation = true;
tmpval = 0;
elem->QueryIntAttribute("hP", &tmpval);
if (tmpval == 0)
hasPosition = false;
else
hasPosition = true;
- nd->SetTimeStamp(timestamp);
+ nd->SetIGTTimeStamp(timestamp);
nd->SetPosition(position);
nd->SetOrientation(orientation);
nd->SetCovErrorMatrix(matrix);
nd->SetDataValid(dataValid);
nd->SetHasOrientation(hasOrientation);
nd->SetHasPosition(hasPosition);
return nd;
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataRecorder.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataRecorder.cpp
index fa07be141a..fb5fe23f1f 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataRecorder.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataRecorder.cpp
@@ -1,366 +1,366 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataRecorder.h"
#include <fstream>
#include <mitkIGTTimeStamp.h>
#include <tinyxml.h>
#include <itksys/SystemTools.hxx>
//headers for exceptions
#include "mitkIGTException.h"
#include "mitkIGTIOException.h"
mitk::NavigationDataRecorder::NavigationDataRecorder()
{
//set default values
m_NumberOfInputs = 0;
m_RecordingMode = NormalFile;
m_Recording = false;
m_NumberOfRecordedFiles = 0;
m_Stream = NULL;
m_FileName = "";
m_SystemTimeClock = RealTimeClock::New();
m_OutputFormat = mitk::NavigationDataRecorder::xml;
m_RecordCounter = 0;
m_RecordCountLimit = -1;
m_DoNotOverwriteFiles = false;
m_StreamMustBeDeleted = false;
//To get a start time
mitk::IGTTimeStamp::GetInstance()->Start(this);
}
mitk::NavigationDataRecorder::~NavigationDataRecorder()
{
}
void mitk::NavigationDataRecorder::GenerateData()
{
}
void mitk::NavigationDataRecorder::AddNavigationData( const NavigationData* nd )
{
// Process object is not const-correct so the const_cast is required here
this->SetNthInput(m_NumberOfInputs,
const_cast< mitk::NavigationData * >( nd ) );
m_NumberOfInputs++;
this->Modified();
}
void mitk::NavigationDataRecorder::SetRecordingMode( RecordingMode mode )
{
m_RecordingMode = mode;
this->Modified();
}
void mitk::NavigationDataRecorder::Update()
{
if (m_Recording)
{
DataObjectPointerArray inputs = this->GetInputs(); //get all inputs
mitk::NavigationData::TimeStampType timestamp=0.0; // timestamp for mitk time
timestamp = mitk::IGTTimeStamp::GetInstance()->GetElapsed();
mitk::NavigationData::TimeStampType sysTimestamp = 0.0; // timestamp for system time
sysTimestamp = m_SystemTimeClock->GetCurrentStamp();
// cast system time double value to stringstream to avoid low precision rounding
std::ostringstream strs;
strs.precision(15); // rounding precision for system time double value
strs << sysTimestamp;
std::string sysTimeStr = strs.str();
//if csv-mode: write csv header and timestamp at beginning
if (m_OutputFormat == mitk::NavigationDataRecorder::csv)
{
//write header only when it's the first line
if (m_firstLine)
{
m_firstLine = false;
*m_Stream << "TimeStamp";
for (unsigned int index = 0; index < inputs.size(); index++){ *m_Stream << ";Valid_Tool" << index <<
";X_Tool" << index <<
";Y_Tool" << index <<
";Z_Tool" << index <<
";QX_Tool" << index <<
";QY_Tool" << index <<
";QZ_Tool" << index <<
";QR_Tool" << index;}
*m_Stream << "\n";
}
//write timestamp (always)
*m_Stream << timestamp;
}
//write tool data for every tool
for (unsigned int index = 0; index < inputs.size(); index++)
{
mitk::NavigationData* nd = dynamic_cast<mitk::NavigationData*>(inputs[index].GetPointer());
nd->Update(); // call update to propagate update to previous filters
mitk::NavigationData::PositionType position;
mitk::NavigationData::OrientationType orientation(0.0, 0.0, 0.0, 0.0);
mitk::NavigationData::CovarianceMatrixType matrix;
bool hasPosition = true;
bool hasOrientation = true;
bool dataValid = false;
position.Fill(0.0);
matrix.SetIdentity();
position = nd->GetPosition();
orientation = nd->GetOrientation();
matrix = nd->GetCovErrorMatrix();
hasPosition = nd->GetHasPosition();
hasOrientation = nd->GetHasOrientation();
dataValid = nd->IsDataValid();
//use this one if you want the timestamps of the source
- //timestamp = nd->GetTimeStamp();
+ //timestamp = nd->GetIGTTimeStamp();
//a timestamp is never < 0! this case happens only if you are using the timestamp of the nd object instead of getting a new one
if (timestamp >= 0)
{
if (this->m_OutputFormat == mitk::NavigationDataRecorder::xml)
{
TiXmlElement* elem = new TiXmlElement("NavigationData");
elem->SetDoubleAttribute("Time", timestamp);
elem->SetAttribute("SystemTime", sysTimeStr); // tag for system time
elem->SetDoubleAttribute("Tool", index);
elem->SetDoubleAttribute("X", position[0]);
elem->SetDoubleAttribute("Y", position[1]);
elem->SetDoubleAttribute("Z", position[2]);
elem->SetDoubleAttribute("QX", orientation[0]);
elem->SetDoubleAttribute("QY", orientation[1]);
elem->SetDoubleAttribute("QZ", orientation[2]);
elem->SetDoubleAttribute("QR", orientation[3]);
elem->SetDoubleAttribute("C00", matrix[0][0]);
elem->SetDoubleAttribute("C01", matrix[0][1]);
elem->SetDoubleAttribute("C02", matrix[0][2]);
elem->SetDoubleAttribute("C03", matrix[0][3]);
elem->SetDoubleAttribute("C04", matrix[0][4]);
elem->SetDoubleAttribute("C05", matrix[0][5]);
elem->SetDoubleAttribute("C10", matrix[1][0]);
elem->SetDoubleAttribute("C11", matrix[1][1]);
elem->SetDoubleAttribute("C12", matrix[1][2]);
elem->SetDoubleAttribute("C13", matrix[1][3]);
elem->SetDoubleAttribute("C14", matrix[1][4]);
elem->SetDoubleAttribute("C15", matrix[1][5]);
if (dataValid)
elem->SetAttribute("Valid",1);
else
elem->SetAttribute("Valid",0);
if (hasOrientation)
elem->SetAttribute("hO",1);
else
elem->SetAttribute("hO",0);
if (hasPosition)
elem->SetAttribute("hP",1);
else
elem->SetAttribute("hP",0);
// set additional attribute?
std::map<const mitk::NavigationData*, std::pair<std::string, std::string> >::iterator
it = m_AdditionalAttributes.find( nd );
if( it != m_AdditionalAttributes.end() )
{
elem->SetAttribute(it->second.first, it->second.second);
}
*m_Stream << " " << *elem << std::endl;
delete elem;
}
else if (this->m_OutputFormat == mitk::NavigationDataRecorder::csv)
{
*m_Stream << ";" << dataValid << ";" << position[0] << ";" << position[1] << ";" << position[2] << ";" << orientation[0] << ";" << orientation[1] << ";" << orientation[2] << ";" << orientation[3];
}
}
}
if (this->m_OutputFormat == mitk::NavigationDataRecorder::csv)
{
*m_Stream << "\n";
}
}
m_RecordCounter++;
if ((m_RecordCountLimit<=m_RecordCounter)&&(m_RecordCountLimit != -1)) {StopRecording();}
}
void mitk::NavigationDataRecorder::SetAdditionalAttribute(const NavigationData* nd,
const std::string& attributeName
, const std::string& attributeValue )
{
std::map<const mitk::NavigationData*, std::pair<std::string, std::string> >::iterator
it = m_AdditionalAttributes.find( nd );
if( it == m_AdditionalAttributes.end() )
m_AdditionalAttributes[nd] = std::pair<std::string, std::string>(attributeName, attributeValue);
else
{
it->second.first = attributeName;
it->second.second = attributeValue;
}
}
void mitk::NavigationDataRecorder::RemoveAdditionalAttribute( const NavigationData* nd )
{
std::map<const mitk::NavigationData*, std::pair<std::string, std::string> >::iterator
it = m_AdditionalAttributes.find( nd );
if( it != m_AdditionalAttributes.end() )
m_AdditionalAttributes.erase(it);
}
void mitk::NavigationDataRecorder::StartRecording()
{
if(!m_Recording)
{
if (m_Stream == NULL)
{
std::stringstream ss;
std::ostream* stream;
//An existing extension will be cut and replaced with .xml
std::string tmpPath = itksys::SystemTools::GetFilenamePath(m_FileName);
m_FileName = itksys::SystemTools::GetFilenameWithoutExtension(m_FileName);
std::string extension = ".xml";
if (m_OutputFormat == mitk::NavigationDataRecorder::csv)
extension = ".csv";
ss << tmpPath << "/" << m_FileName << "-" << m_NumberOfRecordedFiles << extension;
if( m_DoNotOverwriteFiles )
{
unsigned int index = m_NumberOfRecordedFiles+1;
while( itksys::SystemTools::FileExists( ss.str().c_str() ) )
{
ss.str("");
ss << tmpPath << "/" << m_FileName << "-" << index << extension;
index++;
}
}
switch(m_RecordingMode)
{
case Console:
stream = &std::cout;
break;
case NormalFile:
if (m_FileName == "") //Check if there is a file name and path
{
std::string message = "No file name or file path set.";
MITK_ERROR << message;
mitkThrowException(mitk::IGTException) << message;
}
else
{
stream = new std::ofstream(ss.str().c_str());
}
break;
case ZipFile:
stream = &std::cout;
MITK_WARN << "Sorry no ZipFile support yet";
break;
default:
stream = &std::cout;
break;
}
m_Stream = stream;
m_StreamMustBeDeleted = true;
m_firstLine = true;
m_RecordCounter = 0;
StartRecording(stream);
}
}
else if (m_Recording)
{
MITK_WARN << "Already recording please stop before start new recording session";
return;
}
}
void mitk::NavigationDataRecorder::StartRecording(std::ostream* stream)
{
if (m_Recording)
{
MITK_WARN << "Already recording please stop before start new recording session";
return;
}
m_Stream = stream;
m_Stream->precision(10);
//TODO store date and GMT time
//cheking if the stream is good
if (m_Stream->good())
{
if (m_OutputFormat == mitk::NavigationDataRecorder::xml)
{
*m_Stream << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" << std::endl;
/**m_Stream << "<Version Ver=\"1\" />" << std::endl;*/
// should be a generic version, meaning a member variable, which has the actual version
*m_Stream << " " << "<Data ToolCount=\"" << (m_NumberOfInputs) << "\" version=\"1.0\">" << std::endl;
}
m_Recording = true;
}
else
{
m_Recording = false;
mitkThrowException(mitk::IGTException)<<"The stream is not good";
}
}
void mitk::NavigationDataRecorder::StopRecording()
{
if (!m_Recording)
{
std::cout << "You have to start a recording first" << std::endl;
return;
}
if ((m_Stream) && (m_OutputFormat == mitk::NavigationDataRecorder::xml))
{
*m_Stream << "</Data>" << std::endl;
}
m_NumberOfRecordedFiles++;
m_Recording = false;
m_Stream->flush();
if (m_StreamMustBeDeleted) //stream must only be deleted if it was created inside this class
{
m_StreamMustBeDeleted = false;
delete m_Stream;
}
m_Stream = NULL;
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp
index 2dcdc583dd..7e816cd56a 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp
@@ -1,225 +1,226 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataSequentialPlayer.h"
#include <itksys/SystemTools.hxx> //for the pause
#include <fstream>
#include <sstream>
//Exceptions
#include "mitkIGTException.h"
#include "mitkIGTIOException.h"
mitk::NavigationDataSequentialPlayer::NavigationDataSequentialPlayer()
: mitk::NavigationDataPlayerBase()
, m_Doc(new TiXmlDocument)
, m_DataElem(0)
, m_CurrentElem(0)
, m_Repeat(false)
, m_NumberOfSnapshots(0)
, m_LastGoTo(0)
{
}
mitk::NavigationDataSequentialPlayer::~NavigationDataSequentialPlayer()
{
delete m_Doc;
}
void mitk::NavigationDataSequentialPlayer::ReinitXML()
{
m_DataElem = m_Doc->FirstChildElement("Data");
int toolcount;
if(!m_DataElem)
{
MITK_WARN << "Data element not found";
mitkThrowException(mitk::IGTException) << "Data element not found";
}
else
{
m_DataElem->QueryIntAttribute("ToolCount", &toolcount);
- this->SetNumberOfOutputs(toolcount);
+ this->SetNumberOfRequiredOutputs(toolcount);
mitk::NavigationData::Pointer emptyNd = mitk::NavigationData::New();
mitk::NavigationData::PositionType position;
mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
position.Fill(0.0);
emptyNd->SetPosition(position);
emptyNd->SetOrientation(orientation);
emptyNd->SetDataValid(false);
mitk::NavigationData::Pointer tmp;
- for (unsigned int index = 0; index < this->GetNumberOfOutputs(); index++)
+
+ for (unsigned int index = 0; index < this->GetNumberOfRequiredOutputs(); index++)
{
tmp = mitk::NavigationData::New();
tmp->Graft(emptyNd);
- this->SetNthOutput(index, tmp);
+ this->SetNthOutput(index, tmp.GetPointer());
}
// find out _NumberOfSnapshots
m_NumberOfSnapshots = 0;
TiXmlElement* nextND = m_DataElem->FirstChildElement("NavigationData");
while(nextND)
{
++m_NumberOfSnapshots;
nextND = nextND->NextSiblingElement("NavigationData");
}
// e.g. 12 nd found and 2 tools used => number of snapshots is 12:2=6
m_NumberOfSnapshots = m_NumberOfSnapshots/toolcount;
}
}
void mitk::NavigationDataSequentialPlayer::GoToSnapshot(int i)
{
if(!m_Repeat && (this->GetNumberOfSnapshots()<i))
{
MITK_ERROR << "Snaphot " << i << " does not exist and repat is off: can't go to that snapshot!";
mitkThrowException(mitk::IGTException) << "Snaphot " << i << " does not exist and repat is off: can't go to that snapshot!";
}
assert(m_DataElem);
int numOfUpdateCalls = 0;
// i.e. number of snapshots 10
// goto(7), m_LastGoTo=3 => numOfUpdateCalls = 4
if(m_LastGoTo <= i)
numOfUpdateCalls = i - m_LastGoTo;
// goto(4), m_LastGoTo=7 => numOfUpdateCalls = 7
else
{
if(!m_Repeat)
{
std::stringstream message;
message <<"Cannot go back to snapshot " << i << " because the "
<< this->GetNameOfClass() << " is configured to not repeat the"
<< " navigation data.";
MITK_WARN << message.str();
mitkThrowException(mitk::IGTException) << message.str();
}
else
{
numOfUpdateCalls = (m_NumberOfSnapshots - m_LastGoTo) + i;
}
}
for(int j=0; j<numOfUpdateCalls; ++j)
this->Update();
m_LastGoTo = i;
}
void mitk::NavigationDataSequentialPlayer::
SetFileName(const std::string& _FileName)
{
m_FileName = _FileName;
if(!m_Doc->LoadFile(m_FileName))
{
this->SetNumberOfOutputs(0);
std::ostringstream s;
s << "File " << _FileName << " could not be loaded";
mitkThrowException(mitk::IGTIOException)<<s.str();
}
else
{
this->ReinitXML();
}
this->Modified();
}
void mitk::NavigationDataSequentialPlayer::
SetXMLString(const std::string& _XMLString)
{
m_XMLString = _XMLString;
if((m_Doc->Parse( m_XMLString.c_str()))== NULL)
{
this->ReinitXML();
}
else
{
//if the string is not an XML string
std::ostringstream s;
s << "String" << _XMLString << " is not an XML string";
mitkThrowException(mitk::IGTIOException)<<s.str();
}
this->Modified();
}
void mitk::NavigationDataSequentialPlayer::GenerateData()
{
assert(m_DataElem);
// very important: go through the tools (there could be more than one)
mitk::NavigationData::Pointer tmp;
- for (unsigned int index = 0; index < this->GetNumberOfOutputs(); index++)
+ for (unsigned int index = 0; index < this->GetNumberOfIndexedOutputs(); index++)
{
// go to the first element
if(!m_CurrentElem)
m_CurrentElem = m_DataElem->FirstChildElement("NavigationData");
// go to the next element
else
{
m_CurrentElem = m_CurrentElem->NextSiblingElement();
}
// if repeat is on: go back to the first element (prior calls delivered NULL
// elem)
if(!m_CurrentElem && m_Repeat)
m_CurrentElem = m_DataElem->FirstChildElement("NavigationData");
mitk::NavigationData* output = this->GetOutput(index);
tmp = this->ReadVersion1();
if(tmp.IsNotNull())
{
output->Graft(tmp);
m_StreamValid = true;
}
else // no valid output
{
output->SetDataValid(false);
m_StreamValid = false;
m_ErrorMessage = "Error: Cannot parse input file.";
mitkThrowException(mitk::IGTException)<<m_ErrorMessage;
}
}
}
mitk::NavigationData::Pointer mitk::NavigationDataSequentialPlayer::ReadVersion1()
{
TiXmlElement* elem = m_CurrentElem;
if(!elem)
return NULL;
return this->ReadNavigationData(elem);
}
void mitk::NavigationDataSequentialPlayer::UpdateOutputInformation()
{
this->Modified(); // make sure that we need to be updated
Superclass::UpdateOutputInformation();
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataSource.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataSource.cpp
index 646cac66ec..691591cf06 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataSource.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataSource.cpp
@@ -1,142 +1,153 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataSource.h"
#include "mitkUIDGenerator.h"
//Microservices
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usServiceProperties.h>
#include "mitkModuleContext.h"
const std::string mitk::NavigationDataSource::US_INTERFACE_NAME = "org.mitk.services.NavigationDataSource";
const std::string mitk::NavigationDataSource::US_PROPKEY_DEVICENAME = US_INTERFACE_NAME + ".devicename";
const std::string mitk::NavigationDataSource::US_PROPKEY_ID = US_INTERFACE_NAME + ".id";
const std::string mitk::NavigationDataSource::US_PROPKEY_ISACTIVE = US_INTERFACE_NAME + ".isActive";
mitk::NavigationDataSource::NavigationDataSource()
: itk::ProcessObject(), m_Name("NavigationDataSource (no defined type)")
{
}
mitk::NavigationDataSource::~NavigationDataSource()
{
}
mitk::NavigationData* mitk::NavigationDataSource::GetOutput()
{
- if (this->GetNumberOfOutputs() < 1)
+ if (this->GetNumberOfIndexedOutputs() < 1)
return NULL;
- return static_cast<NavigationData*>(this->ProcessObject::GetOutput(0));
+ return static_cast<NavigationData*>(this->ProcessObject::GetPrimaryOutput());
}
-mitk::NavigationData* mitk::NavigationDataSource::GetOutput(unsigned int idx)
+mitk::NavigationData* mitk::NavigationDataSource::GetOutput(DataObjectPointerArraySizeType idx)
{
- if (this->GetNumberOfOutputs() < 1)
- return NULL;
- return static_cast<NavigationData*>(this->ProcessObject::GetOutput(idx));
+ NavigationData* out = dynamic_cast<NavigationData*>( this->ProcessObject::GetOutput(idx) );
+ if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL )
+ {
+ itkWarningMacro (<< "Unable to convert output number " << idx << " to type " << typeid( NavigationData ).name () );
+ }
+ return out;
}
-mitk::NavigationData* mitk::NavigationDataSource::GetOutput(std::string navDataName)
+mitk::NavigationData* mitk::NavigationDataSource::GetOutput(const std::string& navDataName)
{
- DataObjectPointerArray& outputs = this->GetOutputs();
+ DataObjectPointerArray outputs = this->GetOutputs();
for (DataObjectPointerArray::iterator it = outputs.begin(); it != outputs.end(); ++it)
if (navDataName == (static_cast<NavigationData*>(it->GetPointer()))->GetName())
return static_cast<NavigationData*>(it->GetPointer());
return NULL;
}
itk::ProcessObject::DataObjectPointerArraySizeType mitk::NavigationDataSource::GetOutputIndex( std::string navDataName )
{
- DataObjectPointerArray& outputs = this->GetOutputs();
+ DataObjectPointerArray outputs = this->GetOutputs();
for (DataObjectPointerArray::size_type i = 0; i < outputs.size(); ++i)
if (navDataName == (static_cast<NavigationData*>(outputs.at(i).GetPointer()))->GetName())
return i;
throw std::invalid_argument("output name does not exist");
}
void mitk::NavigationDataSource::RegisterAsMicroservice(){
// Get Context
mitk::ModuleContext* context = GetModuleContext();
// Define ServiceProps
ServiceProperties props;
mitk::UIDGenerator uidGen = mitk::UIDGenerator ("org.mitk.services.NavigationDataSource.id_", 16);
props[ US_PROPKEY_ID ] = uidGen.GetUID();
props[ US_PROPKEY_DEVICENAME ] = m_Name;
m_ServiceRegistration = context->RegisterService<mitk::NavigationDataSource>(this, props);
}
void mitk::NavigationDataSource::UnRegisterMicroservice(){
m_ServiceRegistration.Unregister();
m_ServiceRegistration = 0;
}
std::string mitk::NavigationDataSource::GetMicroserviceID(){
return this->m_ServiceRegistration.GetReference().GetProperty(US_PROPKEY_ID).ToString();
}
void mitk::NavigationDataSource::GraftOutput(itk::DataObject *graft)
{
this->GraftNthOutput(0, graft);
}
void mitk::NavigationDataSource::GraftNthOutput(unsigned int idx, itk::DataObject *graft)
{
- if ( idx >= this->GetNumberOfOutputs() )
+ if ( idx >= this->GetNumberOfIndexedOutputs() )
{
itkExceptionMacro(<<"Requested to graft output " << idx <<
- " but this filter only has " << this->GetNumberOfOutputs() << " Outputs.");
+ " but this filter only has " << this->GetNumberOfIndexedOutputs() << " Outputs.");
}
if ( !graft )
{
itkExceptionMacro(<<"Requested to graft output with a NULL pointer object" );
}
itk::DataObject* output = this->GetOutput(idx);
if ( !output )
{
itkExceptionMacro(<<"Requested to graft output that is a NULL pointer" );
}
// Call Graft on NavigationData to copy member data
output->Graft( graft );
}
+itk::DataObject::Pointer mitk::NavigationDataSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
+{
+ return mitk::NavigationData::New().GetPointer();
+}
-itk::ProcessObject::DataObjectPointer mitk::NavigationDataSource::MakeOutput( unsigned int /*idx */)
+itk::DataObject::Pointer mitk::NavigationDataSource::MakeOutput( const DataObjectIdentifierType & name )
{
- mitk::NavigationData::Pointer p = mitk::NavigationData::New();
- return static_cast<itk::DataObject*>(p.GetPointer());
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
+ {
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
+ }
+ return static_cast<itk::DataObject *>(mitk::NavigationData::New().GetPointer());
}
mitk::PropertyList::ConstPointer mitk::NavigationDataSource::GetParameters() const
{
mitk::PropertyList::Pointer p = mitk::PropertyList::New();
// add properties to p like this:
//p->SetProperty("MyFilter_MyParameter", mitk::PropertyDataType::New(m_MyParameter));
return mitk::PropertyList::ConstPointer(p);
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataSource.h b/Modules/IGT/IGTFilters/mitkNavigationDataSource.h
index e9d2abf9fa..85e43dad2e 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataSource.h
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataSource.h
@@ -1,169 +1,171 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKNAVIGATIONDATASOURCE_H_HEADER_INCLUDED_
#define MITKNAVIGATIONDATASOURCE_H_HEADER_INCLUDED_
#include <itkProcessObject.h>
#include "mitkNavigationData.h"
#include "mitkPropertyList.h"
// Microservices
#include <usServiceInterface.h>
#include <usServiceRegistration.h>
namespace mitk {
/**Documentation
* \brief Navigation Data source
*
* Base class for all navigation filters that produce NavigationData objects as output.
* This class defines the output-interface for NavigationDataFilters.
* \warning: if Update() is called on any output object, all NavigationData filters will
* generate new output data for all outputs, not just the one on which Update() was called.
*
* \ingroup IGT
*/
class MitkIGT_EXPORT NavigationDataSource : public itk::ProcessObject
{
public:
mitkClassMacro(NavigationDataSource, itk::ProcessObject);
/** @return Returns a human readable name of this source. There will be a default name,
* or you can set the name with the method SetName() if you want to change it.
*/
itkGetMacro(Name,std::string);
/** @brief Sets the human readable name of this source. There is also a default name,
* but you can use this method if you need to define it on your own.
*/
itkSetMacro(Name,std::string);
/**
*\brief return the output (output with id 0) of the filter
*/
NavigationData* GetOutput(void);
/**
*\brief return the output with id idx of the filter
*/
- NavigationData* GetOutput(unsigned int idx);
+ NavigationData* GetOutput(DataObjectPointerArraySizeType idx);
/**
*\brief return the output with name navDataName of the filter
*/
- NavigationData* GetOutput(std::string navDataName);
+ NavigationData* GetOutput(const std::string& navDataName);
/**
*\brief return the index of the output with name navDataName, -1 if no output with that name was found
*
* \warning if a subclass has outputs that have different data type than mitk::NavigationData, they have to overwrite this method
*/
DataObjectPointerArraySizeType GetOutputIndex(std::string navDataName);
/**
*\brief Registers this object as a Microservice, making it available to every module and/or plugin.
* To unregister, call UnregisterMicroservice().
*/
virtual void RegisterAsMicroservice();
/**
*\brief Registers this object as a Microservice, making it available to every module and/or plugin.
*/
virtual void UnRegisterMicroservice();
/**
*\brief Returns the id that this device is registered with. The id will only be valid, if the
* NavigationDataSource has been registered using RegisterAsMicroservice().
*/
std::string GetMicroserviceID();
/**
*\brief These Constants are used in conjunction with Microservices
*/
static const std::string US_INTERFACE_NAME;
static const std::string US_PROPKEY_DEVICENAME;
static const std::string US_PROPKEY_ID;
static const std::string US_PROPKEY_ISACTIVE; //NOT IMPLEMENTED YET!
/**
*\brief Graft the specified DataObject onto this ProcessObject's output.
*
* See itk::ImageSource::GraftNthOutput for details
*/
virtual void GraftNthOutput(unsigned int idx, itk::DataObject *graft);
/**
* \brief Graft the specified DataObject onto this ProcessObject's output.
*
* See itk::ImageSource::Graft Output for details
*/
virtual void GraftOutput(itk::DataObject *graft);
/**
- * \brief Make a DataObject of the correct type to used as the specified output.
- *
- * This method is automatically called when DataObject::DisconnectPipeline()
- * is called. DataObject::DisconnectPipeline, disconnects a data object
- * from being an output of its current source. When the data object
- * is disconnected, the ProcessObject needs to construct a replacement
- * output data object so that the ProcessObject is in a valid state.
- * Subclasses of NavigationDataSource that have outputs of different
- * data types must overwrite this method so that proper output objects
- * are created.
- */
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ * Allocates a new output object and returns it. Currently the
+ * index idx is not evaluated.
+ * @param idx the index of the output for which an object should be created
+ * @returns the new object
+ */
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
+
+ /**
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
+ */
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
/**
* \brief Set all filter parameters as the PropertyList p
*
* This method allows to set all parameters of a filter with one
* method call. For the names of the parameters, take a look at
* the GetParameters method of the filter
* This method has to be overwritten by each MITK-IGT filter.
*/
virtual void SetParameters(const mitk::PropertyList*){};
/**
* \brief Get all filter parameters as a PropertyList
*
* This method allows to get all parameters of a filter with one
* method call. The returned PropertyList must be assigned to a
* SmartPointer immediately, or else it will get destroyed.
* Every filter must overwrite this method to create a filter-specific
* PropertyList. Note that property names must be unique over all
* MITK-IGT filters. Therefore each filter should use its name as a prefix
* for each property name.
* Secondly, each filter should list the property names and data types
* in the method documentation.
*/
virtual mitk::PropertyList::ConstPointer GetParameters() const;
protected:
NavigationDataSource();
virtual ~NavigationDataSource();
std::string m_Name;
private:
mitk::ServiceRegistration m_ServiceRegistration;
};
} // namespace mitk
// This is the microservice declaration. Do not meddle!
US_DECLARE_SERVICE_INTERFACE(mitk::NavigationDataSource, "org.mitk.services.NavigationDataSource")
#endif /* MITKNAVIGATIONDATASOURCE_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataToMessageFilter.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataToMessageFilter.cpp
index 67b884d8ae..5f9eb778ef 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataToMessageFilter.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataToMessageFilter.cpp
@@ -1,79 +1,79 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataToMessageFilter.h"
#include "mitkPropertyList.h"
#include "mitkProperties.h"
mitk::NavigationDataToMessageFilter::NavigationDataToMessageFilter()
: mitk::NavigationDataToNavigationDataFilter(),
m_PositionEpsilon(0.0f), m_OrientationEpsilon(0.0f), m_CovErrorEpsilon(0.0f), m_TimeStampEpsilon(0.0f)
{
this->SetNumberOfRequiredInputs(1);
}
mitk::NavigationDataToMessageFilter::~NavigationDataToMessageFilter()
{
}
//void mitk::NavigationDataToMessageFilter::SetInput( unsigned int idx, const NavigationData* nd )
//{
// if (idx > 0)
// throw std::invalid_argument("mitk::NavigationDataToMessageFilter: only one input is supported");
// // Process object is not const-correct so the const_cast is required here
// this->ProcessObject::SetNthInput(idx, const_cast<NavigationData*>(nd));
// this->CreateOutputsForAllInputs();
//}
//void mitk::NavigationDataToMessageFilter::SetInput( const NavigationData* nd )
//{
// // Process object is not const-correct so the const_cast is required here
// this->ProcessObject::SetNthInput(0, const_cast<NavigationData*>(nd));
// this->CreateOutputsForAllInputs();
//}
void mitk::NavigationDataToMessageFilter::GenerateData()
{
/* update outputs with tracking data from tools */
for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i)
{
mitk::NavigationData* output = this->GetOutput(i);
assert(output);
const mitk::NavigationData* input = this->GetInput(i);
assert(input);
/* check for differences, then send message. */
if ((output->GetPosition() - input->GetPosition()).GetNorm() > m_PositionEpsilon)
m_PositionChangedMessage.Send(input->GetPosition(), i);
if ((output->GetOrientation() - input->GetOrientation()).magnitude() > m_OrientationEpsilon)
m_OrientationChangedMessage.Send(input->GetOrientation(), i);
if ((output->GetCovErrorMatrix().GetVnlMatrix() - input->GetCovErrorMatrix().GetVnlMatrix()).absolute_value_max() > m_CovErrorEpsilon)
m_ErrorChangedMessage.Send(input->GetCovErrorMatrix(), i);
- if (fabs(output->GetTimeStamp() - input->GetTimeStamp()) > m_TimeStampEpsilon)
- m_TimeStampChangedMessage.Send(input->GetTimeStamp(), i);
+ if (fabs(output->GetIGTTimeStamp() - input->GetIGTTimeStamp()) > m_TimeStampEpsilon)
+ m_TimeStampChangedMessage.Send(input->GetIGTTimeStamp(), i);
if (input->IsDataValid() != output->IsDataValid())
m_DataValidChangedMessage.Send(input->IsDataValid(), i);
output->Graft(input); // Because this is a NavigationDataToNavigationData Filter, we need to copy the input to the output to provide up to date navigation data objects
}
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataToNavigationDataFilter.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataToNavigationDataFilter.cpp
index dfe0b8063b..184d68731a 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataToNavigationDataFilter.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataToNavigationDataFilter.cpp
@@ -1,96 +1,98 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataToNavigationDataFilter.h"
mitk::NavigationDataToNavigationDataFilter::NavigationDataToNavigationDataFilter()
: mitk::NavigationDataSource()
{
+mitk::NavigationData::Pointer output = mitk::NavigationData::New();
+this->SetNumberOfRequiredOutputs(1);
+this->SetNthOutput(0, output.GetPointer());
}
mitk::NavigationDataToNavigationDataFilter::~NavigationDataToNavigationDataFilter()
{
}
void mitk::NavigationDataToNavigationDataFilter::SetInput( const NavigationData* nd )
{
this->SetInput(0, nd);
}
void mitk::NavigationDataToNavigationDataFilter::SetInput( unsigned int idx, const NavigationData* nd )
{
- if ((nd == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one
- this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
+ if ( nd == NULL ) // if an input is set to NULL, remove it
+ this->RemoveInput(idx);
else
- this->ProcessObject::SetNthInput(idx, const_cast<NavigationData*>(nd)); // Process object is not const-correct so the const_cast is required here
-
+ this->ProcessObject::SetNthInput(idx, const_cast<NavigationData*>(nd)); // ProcessObject is not const-correct so a const_cast is required here
this->CreateOutputsForAllInputs();
}
const mitk::NavigationData* mitk::NavigationDataToNavigationDataFilter::GetInput( void ) const
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const NavigationData*>(this->ProcessObject::GetInput(0));
}
const mitk::NavigationData* mitk::NavigationDataToNavigationDataFilter::GetInput( unsigned int idx ) const
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const NavigationData*>(this->ProcessObject::GetInput(idx));
}
const mitk::NavigationData* mitk::NavigationDataToNavigationDataFilter::GetInput(std::string navDataName) const
{
const DataObjectPointerArray& inputs = const_cast<Self*>(this)->GetInputs();
for (DataObjectPointerArray::const_iterator it = inputs.begin(); it != inputs.end(); ++it)
if (std::string(navDataName) == (static_cast<NavigationData*>(it->GetPointer()))->GetName())
return static_cast<NavigationData*>(it->GetPointer());
return NULL;
}
itk::ProcessObject::DataObjectPointerArraySizeType mitk::NavigationDataToNavigationDataFilter::GetInputIndex( std::string navDataName )
{
- DataObjectPointerArray& outputs = this->GetInputs();
+ DataObjectPointerArray outputs = this->GetInputs();
for (DataObjectPointerArray::size_type i = 0; i < outputs.size(); ++i)
if (navDataName == (static_cast<NavigationData*>(outputs.at(i).GetPointer()))->GetName())
return i;
throw std::invalid_argument("output name does not exist");
}
void mitk::NavigationDataToNavigationDataFilter::CreateOutputsForAllInputs()
{
- this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create outputs for all inputs
- for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
+ this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs()); // create outputs for all inputs
+ for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
if (this->GetOutput(idx) == NULL)
{
- DataObjectPointer newOutput = this->MakeOutput(idx);
+ mitk::NavigationData::Pointer newOutput = mitk::NavigationData::New();
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataToPointSetFilter.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataToPointSetFilter.cpp
index 60445f9fc8..9ea1fd7a40 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataToPointSetFilter.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataToPointSetFilter.cpp
@@ -1,245 +1,248 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataToPointSetFilter.h"
#include <mitkPointOperation.h>
#include <mitkInteractionConst.h>
#include <itksys/SystemTools.hxx>
mitk::NavigationDataToPointSetFilter::NavigationDataToPointSetFilter()
{
+ mitk::PointSet::Pointer output = mitk::PointSet::New();
+ this->SetNumberOfRequiredOutputs(1);
+ this->SetNthOutput(0, output.GetPointer());
this->SetNumberOfRequiredInputs(1);
m_OperationMode = Mode3D;
m_CurrentTimeStep = 0;
m_RingBufferSize = 50; //the default ring buffer size
m_NumberForMean = 100;
}
mitk::NavigationDataToPointSetFilter::~NavigationDataToPointSetFilter()
{
}
void mitk::NavigationDataToPointSetFilter::GenerateData()
{
switch (m_OperationMode)
{
case Mode3D:
GenerateDataMode3D();
break;
case Mode3DMean:
GenerateDataMode3DMean();
break;
case Mode4D:
GenerateDataMode4D();
break;
default:
break;
}
}
void mitk::NavigationDataToPointSetFilter::SetInput(const NavigationData* nd)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(0, const_cast<NavigationData*>(nd));
this->CreateOutputsForAllInputs();
}
void mitk::NavigationDataToPointSetFilter::SetInput(unsigned int idx, const NavigationData* nd)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(idx, const_cast<NavigationData*>(nd));
this->CreateOutputsForAllInputs();
}
const mitk::NavigationData* mitk::NavigationDataToPointSetFilter::GetInput( void )
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const NavigationData*>(this->ProcessObject::GetInput(0));
}
const mitk::NavigationData* mitk::NavigationDataToPointSetFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const NavigationData*>(this->ProcessObject::GetInput(idx));
}
void mitk::NavigationDataToPointSetFilter::CreateOutputsForAllInputs()
{
switch (m_OperationMode)
{
case Mode3D:
- this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create one pointset output for each navigation data input
+ this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs()); // create one pointset output for each navigation data input
break;
case Mode3DMean:
- this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create one pointset output for each navigation data input
+ this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs()); // create one pointset output for each navigation data input
break;
case Mode4D:
- this->SetNumberOfOutputs(1); // create just one output pointset that will contain all input navigation data objects
+ this->SetNumberOfIndexedOutputs(1); // create just one output pointset that will contain all input navigation data objects
break;
default:
break;
}
- for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
+ for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
void mitk::NavigationDataToPointSetFilter::GenerateDataMode3D()
{
- for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i) // for each output PointSet
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs() ; ++i) // for each output PointSet
{
mitk::PointSet* output = this->GetOutput(i);
assert(output);
const mitk::NavigationData* input = this->GetInput(i);
assert(input);
if (input->IsDataValid() == false) // don't add point if input is invalid
continue;
mitk::PointSet::PointType pos = input->GetPosition(); // NavigationData::PositionType must be compatible with PointSet::PointType!
output->InsertPoint(output->GetSize(), pos); // add point with current position of input NavigationData to the output PointSet
// \TODO: regard ringbuffersize
}
}
/**
* @brief read n times all connected inputs and sum them into outputs. Finish with dividing each output by n.
**/
void mitk::NavigationDataToPointSetFilter::GenerateDataMode3DMean()
{
//make it editable through a Set method if needed
//check for outputs and inputs
- for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i) // for each output PointSet; change through pointsets to collect all navigation data in order
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs() ; ++i) // for each output PointSet; change through pointsets to collect all navigation data in order
{
assert(this->GetOutput(i));
assert(this->GetInput(i));
}
//vector of counters for each output
- std::vector<unsigned int> counterVec(this->GetNumberOfOutputs(),0);
+ std::vector<unsigned int> counterVec(this->GetNumberOfIndexedOutputs(),0);
//vector of old timesteps for each output
- std::vector<mitk::NavigationData::TimeStampType> vectorOldTime(this->GetNumberOfOutputs());
+ std::vector<mitk::NavigationData::TimeStampType> vectorOldTime(this->GetNumberOfIndexedOutputs());
//use first Output to get the size of the pointsets. All output pointssets have to have the same size!
- mitk::PointSet::PointIdentifier newPointId = this->GetOutput(0)->GetSize();
+ mitk::PointSet::PointIdentifier newPointId = this->GetOutput()->GetSize();
bool numberForMean_is_reached = false;
while (!numberForMean_is_reached)
{
- for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i) // for each output PointSet; change through pointsets to collect all navigation data in order
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs() ; ++i) // for each output PointSet; change through pointsets to collect all navigation data in order
{
mitk::PointSet* output = this->GetOutput(i);
const mitk::NavigationData* input = this->GetInput(i);
if (input->IsDataValid() == false) // don't add point if input is invalid
continue;//do not store
mitk::PointSet::PointType pos;
if (counterVec[i] == 0) //first Element must be inserted
{
- vectorOldTime[i] = input->GetTimeStamp();
+ vectorOldTime[i] = input->GetIGTTimeStamp();
//no need to call an update
pos = input->GetPosition(); // NavigationData::PositionType must be compatible with PointSet::PointType!
output->InsertPoint(newPointId, pos); // add point with current position of input NavigationData to the output PointSet
counterVec[i]++;
}
else
{
//manually call an update to track new positions
this->ProcessObject::GetInput(i)->Update();
input = this->GetInput(i);
- mitk::NavigationData::TimeStampType newTime = input->GetTimeStamp();
+ mitk::NavigationData::TimeStampType newTime = input->GetIGTTimeStamp();
if (vectorOldTime[i]<newTime)
{
pos = input->GetPosition(); // NavigationData::PositionType must be compatible with PointSet::PointType!
//calculate the summ of the old position and the current coordinate
mitk::Vector3D vec;
vec.SetVnlVector(pos.GetVnlVector());
mitk::PointSet::PointType oPoint = output->GetPoint(newPointId);
oPoint += vec;//summ up
output->SetPoint(newPointId, oPoint);
//store in counterVec to know how many have been added (and not skipped because of invalid data)
counterVec[i]++;
vectorOldTime[i] = newTime;
}
}
// \TODO: regard ringbuffersize
}
numberForMean_is_reached = true;
- for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i)
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs() ; ++i)
{
if (counterVec[i]<m_NumberForMean)
numberForMean_is_reached = false;
}
}
//divide with counterVec
- for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i) // for each output PointSet; change through pointsets to collect all navigation data in order
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs() ; ++i) // for each output PointSet; change through pointsets to collect all navigation data in order
{
mitk::PointSet* output = this->GetOutput(i);
mitk::PointSet::PointType oPoint = output->GetPoint(newPointId);
for (unsigned int index = 0; index < oPoint.Size(); index++)
oPoint[index] = oPoint[index] / counterVec[i];
output->SetPoint(newPointId, oPoint);
MBI_INFO << "For output # " << i << ", " << counterVec[i] << " tracked positions used for averaging";
}
}
void mitk::NavigationDataToPointSetFilter::GenerateDataMode4D()
{
- mitk::PointSet* output = GetOutput();
+ mitk::PointSet* output = this->GetOutput();
assert(output);
- for (unsigned int index = 0; index < this->GetNumberOfInputs(); index++)
+ for (unsigned int index = 0; index < this->GetNumberOfIndexedInputs(); index++)
{
const mitk::NavigationData* nd = GetInput(index);
assert(nd);
mitk::NavigationData::PositionType point = nd->GetPosition(); //get the position
output->SetPoint( index, point, m_CurrentTimeStep); //store it in the pointset always at the current time step
}
if (m_CurrentTimeStep == m_RingBufferSize - 1) // update ring buffer index
m_CurrentTimeStep = 0;
else
m_CurrentTimeStep++;
}
void mitk::NavigationDataToPointSetFilter::SetOperationMode( OperationMode mode )
{
m_OperationMode = mode;
//Initialize 4D Mode
if (m_OperationMode == Mode4D)
m_CurrentTimeStep = 0;
this->Modified();
this->CreateOutputsForAllInputs();
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataTransformFilter.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataTransformFilter.cpp
index aff000d4a9..ee78c11be7 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataTransformFilter.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataTransformFilter.cpp
@@ -1,107 +1,109 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataTransformFilter.h"
mitk::NavigationDataTransformFilter::NavigationDataTransformFilter()
: mitk::NavigationDataToNavigationDataFilter()
{
m_Transform = NULL;
//transform to rotate orientation
m_QuatOrgRigidTransform = itk::QuaternionRigidTransform<double>::New();
m_QuatTmpTransform = itk::QuaternionRigidTransform<double>::New();
}
mitk::NavigationDataTransformFilter::~NavigationDataTransformFilter()
{
m_Transform = NULL;
}
void mitk::NavigationDataTransformFilter::SetRigid3DTransform( TransformType::Pointer transform )
{
m_Transform = transform;
this->Modified();
}
void mitk::NavigationDataTransformFilter::GenerateData()
{
// only update data if m_Transform was set
if(m_Transform.IsNull())
{
itkExceptionMacro("Invalid parameter: Transform was not set! Use SetRigid3DTransform() before updating the filter.");
return;
}
else
{
this->CreateOutputsForAllInputs(); // make sure that we have the same number of outputs as inputs
/* update outputs with tracking data from tools */
for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i)
{
mitk::NavigationData* output = this->GetOutput(i);
assert(output);
const mitk::NavigationData* input = this->GetInput(i);
assert(input);
if (input->IsDataValid() == false)
{
output->SetDataValid(false);
continue;
}
mitk::NavigationData::PositionType tempCoordinateIn, tempCoordinateOut;
tempCoordinateIn = input->GetPosition();
itk::Point<float,3> itkPointIn, itkPointOut;
itkPointIn[0] = tempCoordinateIn[0];
itkPointIn[1] = tempCoordinateIn[1];
itkPointIn[2] = tempCoordinateIn[2];
//do the transform
itkPointOut = m_Transform->TransformPoint( itkPointIn );
tempCoordinateOut[0] = itkPointOut[0];
tempCoordinateOut[1] = itkPointOut[1];
tempCoordinateOut[2] = itkPointOut[2];
output->Graft(input); // First, copy all information from input to output
output->SetPosition(tempCoordinateOut);// Then change the member(s): add new position of navigation data after tranformation
output->SetDataValid(true); // operation was successful, therefore data of output is valid.
//---transform orientation
NavigationData::OrientationType quatIn = input->GetOrientation();
vnl_quaternion<double> const vnlQuatIn(quatIn.x(), quatIn.y(), quatIn.z(), quatIn.r());
TransformType::MatrixType rotMatrixD = m_Transform->GetMatrix();
- m_QuatOrgRigidTransform->SetRotationMatrix(rotMatrixD);
+ vnl_quaternion<double> vnlQ = vnl_quaternion<double>(rotMatrixD.GetVnlMatrix());
+
+ m_QuatOrgRigidTransform->SetRotation(vnlQ);
m_QuatTmpTransform->SetRotation(vnlQuatIn);
m_QuatTmpTransform->Compose(m_QuatOrgRigidTransform,false);
vnl_quaternion<double> vnlQuatOut = m_QuatTmpTransform->GetRotation();
NavigationData::OrientationType quatOut(vnlQuatOut[0], vnlQuatOut[1], vnlQuatOut[2], vnlQuatOut[3]);
output->SetOrientation(quatOut);
}
}
}
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataTransformFilter.h b/Modules/IGT/IGTFilters/mitkNavigationDataTransformFilter.h
index cbe711da00..5d85201e77 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataTransformFilter.h
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataTransformFilter.h
@@ -1,72 +1,73 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKNavigationDataTransformFilter_H_HEADER_INCLUDED_
#define MITKNavigationDataTransformFilter_H_HEADER_INCLUDED_
#include <mitkNavigationDataToNavigationDataFilter.h>
#include <itkQuaternionRigidTransform.h>
#include <itkTransform.h>
+#include <itkVersorRigid3DTransform.h>
namespace mitk {
/**Documentation
* \brief NavigationDataTransformFilter applies an user-defined rigid transformation on navigation data objects.
* Input navigation data are mapped 1:1 on output navigation data. To run the filter SetRigid3DTransform(TransformType::Pointer transform) has to be called first.
*
* \ingroup IGT
*/
class MitkIGT_EXPORT NavigationDataTransformFilter : public NavigationDataToNavigationDataFilter
{
public:
- typedef itk::Rigid3DTransform< double > TransformType;
+ typedef itk::VersorRigid3DTransform< double > TransformType;
mitkClassMacro(NavigationDataTransformFilter, NavigationDataToNavigationDataFilter);
itkNewMacro(Self);
/**Documentation
*\brief Set the rigid transform used to transform the input navigation data.
*
*/
void SetRigid3DTransform(TransformType::Pointer transform);
protected:
NavigationDataTransformFilter();
virtual ~NavigationDataTransformFilter();
itk::QuaternionRigidTransform<double>::Pointer m_QuatOrgRigidTransform; ///< transform needed to rotate orientation
itk::QuaternionRigidTransform<double>::Pointer m_QuatTmpTransform; ///< further transform needed to rotate orientation
/**Documentation
* \brief filter execute method
*
* transforms navigation data
*/
virtual void GenerateData();
TransformType::Pointer m_Transform; ///< transform which will be applied on navigation data(s)
};
} // namespace mitk
#endif /* MITKNavigationDataTransformFilter_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.cpp b/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.cpp
index 3a068bb2f7..49733efe0b 100644
--- a/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.cpp
+++ b/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.cpp
@@ -1,215 +1,217 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTrackingDeviceSource.h"
#include "mitkTrackingDevice.h"
#include "mitkTrackingTool.h"
#include "mitkIGTTimeStamp.h"
mitk::TrackingDeviceSource::TrackingDeviceSource()
: mitk::NavigationDataSource(), m_TrackingDevice(NULL)
{
}
mitk::TrackingDeviceSource::~TrackingDeviceSource()
{
if (m_TrackingDevice.IsNotNull())
{
if (m_TrackingDevice->GetState() == mitk::TrackingDevice::Tracking)
{
this->StopTracking();
}
if (m_TrackingDevice->GetState() == mitk::TrackingDevice::Ready)
{
this->Disconnect();
}
m_TrackingDevice = NULL;
}
}
void mitk::TrackingDeviceSource::GenerateData()
{
if (m_TrackingDevice.IsNull())
return;
if (m_TrackingDevice->GetToolCount() < 1)
return;
- if (this->GetNumberOfOutputs() != m_TrackingDevice->GetToolCount()) // mismatch between tools and outputs. What should we do? Were tools added to the tracking device after SetTrackingDevice() was called?
+ if (this->GetNumberOfIndexedOutputs() != m_TrackingDevice->GetToolCount()) // mismatch between tools and outputs. What should we do? Were tools added to the tracking device after SetTrackingDevice() was called?
{
//check this: TODO:
////this might happen if a tool is plugged into an aurora during tracking.
//this->CreateOutputs();
std::stringstream ss;
ss << "mitk::TrackingDeviceSource: not enough outputs available for all tools. "
<< this->GetNumberOfOutputs() << " outputs available, but "
<< m_TrackingDevice->GetToolCount() << " tools available in the tracking device.";
throw std::out_of_range(ss.str());
}
/* update outputs with tracking data from tools */
unsigned int toolCount = m_TrackingDevice->GetToolCount();
for (unsigned int i = 0; i < toolCount; ++i)
{
mitk::NavigationData* nd = this->GetOutput(i);
assert(nd);
mitk::TrackingTool* t = m_TrackingDevice->GetTool(i);
assert(t);
if ((t->IsEnabled() == false) || (t->IsDataValid() == false))
{
nd->SetDataValid(false);
continue;
}
nd->SetDataValid(true);
mitk::NavigationData::PositionType p;
t->GetPosition(p);
nd->SetPosition(p);
mitk::NavigationData::OrientationType o;
t->GetOrientation(o);
nd->SetOrientation(o);
nd->SetOrientationAccuracy(t->GetTrackingError());
nd->SetPositionAccuracy(t->GetTrackingError());
- nd->SetTimeStamp( mitk::IGTTimeStamp::GetInstance()->GetElapsed() );
+ nd->SetIGTTimeStamp( mitk::IGTTimeStamp::GetInstance()->GetElapsed() );
}
}
void mitk::TrackingDeviceSource::SetTrackingDevice( mitk::TrackingDevice* td )
{
MITK_DEBUG << "Setting TrackingDevice to " << td;
if (this->m_TrackingDevice.GetPointer() != td)
{
this->m_TrackingDevice = td;
this->CreateOutputs();
std::stringstream name; // create a human readable name for the source
name << td->GetData().Model << " Tracking Source";
this->SetName(name.str());
}
}
void mitk::TrackingDeviceSource::CreateOutputs(){
//if outputs are set then delete them
if (this->GetNumberOfOutputs() > 0)
{
for (unsigned int numOP = this->GetNumberOfOutputs(); numOP>0; numOP--)
this->RemoveOutput(this->GetOutput(numOP));
this->Modified();
}
//fill the outputs if a valid tracking device is set
if (m_TrackingDevice.IsNull())
return;
- this->SetNumberOfOutputs(m_TrackingDevice->GetToolCount()); // create outputs for all tools
- unsigned int numberOfOutputs = this->GetNumberOfOutputs();
+ this->SetNumberOfIndexedOutputs(m_TrackingDevice->GetToolCount()); // create outputs for all tools
+ unsigned int numberOfOutputs = this->GetNumberOfIndexedOutputs();
+ MITK_DEBUG << "Number of tools at start of method CreateOutputs(): " << m_TrackingDevice->GetToolCount();
+ MITK_DEBUG << "Number of outputs at start of method CreateOutputs(): " << numberOfOutputs;
for (unsigned int idx = 0; idx < numberOfOutputs; ++idx)
{
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
static_cast<mitk::NavigationData*>(newOutput.GetPointer())->SetName(m_TrackingDevice->GetTool(idx)->GetToolName()); // set NavigationData name to ToolName
this->SetNthOutput(idx, newOutput);
this->Modified();
}
}
}
void mitk::TrackingDeviceSource::Connect()
{
if (m_TrackingDevice.IsNull())
throw std::invalid_argument("mitk::TrackingDeviceSource: No tracking device set");
if (this->IsConnected())
return;
if (m_TrackingDevice->OpenConnection() == false)
throw std::runtime_error(std::string("mitk::TrackingDeviceSource: Could not open connection to tracking device. Error: ") + m_TrackingDevice->GetErrorMessage());
/* NDI Aurora needs a connection to discover tools that are connected to it.
Therefore we need to create outputs for these tools now */
//if (m_TrackingDevice->GetType() == mitk::NDIAurora)
//this->CreateOutputs();
}
void mitk::TrackingDeviceSource::StartTracking()
{
if (m_TrackingDevice.IsNull())
throw std::invalid_argument("mitk::TrackingDeviceSource: No tracking device set");
if (m_TrackingDevice->GetState() == mitk::TrackingDevice::Tracking)
return;
if (m_TrackingDevice->StartTracking() == false)
throw std::runtime_error("mitk::TrackingDeviceSource: Could not start tracking");
}
void mitk::TrackingDeviceSource::Disconnect()
{
if (m_TrackingDevice.IsNull())
throw std::invalid_argument("mitk::TrackingDeviceSource: No tracking device set");
if (m_TrackingDevice->CloseConnection() == false)
throw std::runtime_error("mitk::TrackingDeviceSource: Could not close connection to tracking device");
}
void mitk::TrackingDeviceSource::StopTracking()
{
if (m_TrackingDevice.IsNull())
throw std::invalid_argument("mitk::TrackingDeviceSource: No tracking device set");
if (m_TrackingDevice->StopTracking() == false)
throw std::runtime_error("mitk::TrackingDeviceSource: Could not stop tracking");
}
void mitk::TrackingDeviceSource::UpdateOutputInformation()
{
- if(this->GetTrackingDevice()->GetToolCount() != this->GetNumberOfOutputs())
+ if(this->GetTrackingDevice()->GetToolCount() != this->GetNumberOfIndexedOutputs())
this->CreateOutputs();
this->Modified(); // make sure that we need to be updated
Superclass::UpdateOutputInformation();
}
//unsigned int mitk::TrackingDeviceSource::GetToolCount()
//{
// if (m_TrackingDevice)
// return m_TrackingDevice->GetToolCount();
// return 0;
//}
bool mitk::TrackingDeviceSource::IsConnected()
{
if (m_TrackingDevice.IsNull())
return false;
return (m_TrackingDevice->GetState() == mitk::TrackingDevice::Ready) || (m_TrackingDevice->GetState() == mitk::TrackingDevice::Tracking);
}
bool mitk::TrackingDeviceSource::IsTracking()
{
if (m_TrackingDevice.IsNull())
return false;
return m_TrackingDevice->GetState() == mitk::TrackingDevice::Tracking;
}
diff --git a/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.h b/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.h
index b15d28eed3..86212a7f75 100644
--- a/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.h
+++ b/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.h
@@ -1,133 +1,133 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKTRACKINGDEVICESOURCE_H_HEADER_INCLUDED_
#define MITKTRACKINGDEVICESOURCE_H_HEADER_INCLUDED_
#include <mitkNavigationDataSource.h>
#include "mitkTrackingDevice.h"
namespace mitk {
/**Documentation
* \brief Connects a mitk::TrackingDevice to a MITK-IGT NavigationData-Filterpipeline
*
* This class is the source of most navigation pipelines. It encapsulates a mitk::TrackingDevice
* and provides the position and orientation of the connected mitk::TrackingTool objects
* as NavigationData objects. Note, that the number of outputs of TrackingDeviceSource
* is equal to the number of tools connected to the TrackingDevice at the time
* SetTrackingDevice() is called. If tools are added to the TrackingDevice later,
* there will not be additional outputs in TrackingDeviceSource. You have to call
* SetTrackingDevice() again to add the new tools as additional outputs of the filter.
* Otherwise TrackingDeviceSource will raise an std::out_of_range exception when the filter pipeline is executed.
* the tool number corresponds with the output number, e.g. trackingDevice-GetTool(0) is
- * the tool that will produce trackingDeviceSourceFilter->GetOutput(0).
+ * the tool that will produce trackingDeviceSourceFilter->GetOutput().
* \warning If a tool is removed from the tracking device, there will be a mismatch between
* the outputs and the tool number!
*
* \ingroup IGT
*/
class MitkIGT_EXPORT TrackingDeviceSource : public NavigationDataSource
{
public:
mitkClassMacro(TrackingDeviceSource, NavigationDataSource);
itkNewMacro(Self);
/**
* \brief sets the tracking device that will be used as a source for tracking data
*/
virtual void SetTrackingDevice(mitk::TrackingDevice* td);
/**
* \brief returns the tracking device that is used by this filter
*/
itkGetConstObjectMacro(TrackingDevice, mitk::TrackingDevice);
/**
* \brief Establishes a connection to the tracking device. If there is already a connection
* the method does nothing.
* \warning. Will throw a std::invalid_argument exception if no tracking device was
* set with SetTrackingDevice(). Will throw a std::runtime_error if the tracking device
* returns an error.
*/
void Connect();
/**
* \brief Closes the connection to the tracking device
* \warning. Will throw a std::invalid_argument exception if no tracking device was
* set with SetTrackingDevice(). Will throw a std::runtime_error if the tracking device
* returns an error.
*/
void Disconnect();
/**
* \brief starts tracking.
* This needs to be called before Update() or GetOutput()->Update(). If the device is already tracking
* the method does nothing.
* \warning. Will throw a std::invalid_argument exception if no tracking device was
* set with SetTrackingDevice(). Will throw a std::runtime_error if the tracking device
* returns an error.
*/
void StartTracking();
/**
* \brief stops tracking.
* \warning. Will throw a std::invalid_argument exception if no tracking device was
* set with SetTrackingDevice(). Will throw a std::runtime_error if the tracking device
* returns an error.
*/
void StopTracking();
/**
* \brief returns true if a connection to the tracking device is established
*
*/
virtual bool IsConnected();
/**
* \brief returns true if tracking is in progress
*
*/
virtual bool IsTracking();
/**
* \brief Used for pipeline update
*/
virtual void UpdateOutputInformation();
protected:
TrackingDeviceSource();
virtual ~TrackingDeviceSource();
/**
* \brief filter execute method
*
* queries the tracking device for new position and orientation data for all tools
* and updates its output NavigationData objects with it.
* \warning Will raise a std::out_of_range exception, if tools were added to the
* tracking device after it was set as input for this filter
*/
virtual void GenerateData();
/**
* \brief Create the necessary outputs for the TrackingTool objects in m_TrackingDevice
**/
void CreateOutputs();
mitk::TrackingDevice::Pointer m_TrackingDevice; ///< the tracking device that is used as a source for this filter object
};
} // namespace mitk
#endif /* MITKTrackingDeviceSource_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IGTFilters/mitkTrackingDeviceSourceConfigurator.cpp b/Modules/IGT/IGTFilters/mitkTrackingDeviceSourceConfigurator.cpp
index 87baf2a4f5..4a29c1877a 100644
--- a/Modules/IGT/IGTFilters/mitkTrackingDeviceSourceConfigurator.cpp
+++ b/Modules/IGT/IGTFilters/mitkTrackingDeviceSourceConfigurator.cpp
@@ -1,255 +1,259 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTrackingDeviceSourceConfigurator.h"
#include "mitkNDITrackingDevice.h"
#include "mitkClaronTrackingDevice.h"
mitk::TrackingDeviceSourceConfigurator::TrackingDeviceSourceConfigurator(mitk::NavigationToolStorage::Pointer NavigationTools, mitk::TrackingDevice::Pointer TrackingDevice)
{
//make a copy of the navigation tool storage because we will modify the storage
if (NavigationTools.IsNotNull())
{
m_NavigationTools = mitk::NavigationToolStorage::New();
for (int i=0; i<NavigationTools->GetToolCount(); i++)
{
m_NavigationTools->AddTool(NavigationTools->GetTool(i));
}
}
m_TrackingDevice = TrackingDevice;
m_ToolCorrespondencesInToolStorage = std::vector<int>();
m_ErrorMessage = "";
}
mitk::NavigationToolStorage::Pointer mitk::TrackingDeviceSourceConfigurator::GetUpdatedNavigationToolStorage()
{
return m_NavigationTools;
}
mitk::TrackingDeviceSourceConfigurator::~TrackingDeviceSourceConfigurator()
{
}
bool mitk::TrackingDeviceSourceConfigurator::IsCreateTrackingDeviceSourcePossible()
{
if (m_NavigationTools.IsNull())
{
m_ErrorMessage = "NavigationToolStorage is NULL!";
return false;
}
else if (m_TrackingDevice.IsNull())
{
m_ErrorMessage = "TrackingDevice is NULL!";
return false;
}
else
{
for (int i=0; i<m_NavigationTools->GetToolCount(); i++)
{
if (m_NavigationTools->GetTool(i)->GetTrackingDeviceType() != m_TrackingDevice->GetType())
{
m_ErrorMessage = "At least one tool is not of the same type like the tracking device.";
return false;
}
}
//TODO in case of Aurora: check if the tools are automatically detected by comparing the serial number
return true;
}
}
mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateTrackingDeviceSource()
{
-mitk::NavigationDataObjectVisualizationFilter::Pointer dummy;
+mitk::NavigationDataObjectVisualizationFilter::Pointer dummy; //this dummy is lost directly after creating the device
return this->CreateTrackingDeviceSource(dummy);
}
mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateTrackingDeviceSource(mitk::NavigationDataObjectVisualizationFilter::Pointer &visualizationFilter)
{
- if (!this->IsCreateTrackingDeviceSourcePossible()) return NULL;
+ if (!this->IsCreateTrackingDeviceSourcePossible()) {MITK_WARN << "Cannot create tracking decive: " << m_ErrorMessage; return NULL;}
+
mitk::TrackingDeviceSource::Pointer returnValue;
//create tracking device source
if (m_TrackingDevice->GetType()==mitk::NDIAurora) {returnValue = CreateNDIAuroraTrackingDeviceSource(m_TrackingDevice,m_NavigationTools);}
else if (m_TrackingDevice->GetType()==mitk::NDIPolaris) {returnValue = CreateNDIPolarisTrackingDeviceSource(m_TrackingDevice,m_NavigationTools);}
else if (m_TrackingDevice->GetType()==mitk::ClaronMicron) {returnValue = CreateMicronTrackerTrackingDeviceSource(m_TrackingDevice,m_NavigationTools);}
- //TODO: insert other tracking systems?
- if (returnValue.IsNull()) return NULL;
+ //TODO: insert other tracking systems?
+ if (returnValue.IsNull()) {MITK_WARN << "Cannot create tracking decive: " << m_ErrorMessage; return NULL;}
//create visualization filter
visualizationFilter = CreateNavigationDataObjectVisualizationFilter(returnValue,m_NavigationTools);
- if (visualizationFilter.IsNull()) return NULL;
+ if (visualizationFilter.IsNull()) {MITK_WARN << "Cannot create tracking decive: " << m_ErrorMessage; return NULL;}
return returnValue;
}
std::string mitk::TrackingDeviceSourceConfigurator::GetErrorMessage()
{
return this->m_ErrorMessage;
}
//############################ internal help methods ########################################
mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateNDIPolarisTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice, mitk::NavigationToolStorage::Pointer navigationTools)
{
mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
mitk::NDITrackingDevice::Pointer thisDevice = dynamic_cast<mitk::NDITrackingDevice*>(trackingDevice.GetPointer());
m_ToolCorrespondencesInToolStorage = std::vector<int>();
//add the tools to the tracking device
for (int i=0; i<navigationTools->GetToolCount(); i++)
{
mitk::NavigationTool::Pointer thisNavigationTool = m_NavigationTools->GetTool(i);
m_ToolCorrespondencesInToolStorage.push_back(i);
bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str(),thisNavigationTool->GetCalibrationFile().c_str());
if (!toolAddSuccess)
{
//todo: error handling
this->m_ErrorMessage = "Can't add tool, is the SROM-file valid?";
return NULL;
}
thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(),thisNavigationTool->GetToolTipOrientation());
}
returnValue->SetTrackingDevice(thisDevice);
return returnValue;
}
mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateNDIAuroraTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice, mitk::NavigationToolStorage::Pointer navigationTools)
{
+ MITK_DEBUG << "Creating Aurora tracking device.";
mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
mitk::NDITrackingDevice::Pointer thisDevice = dynamic_cast<mitk::NDITrackingDevice*>(trackingDevice.GetPointer());
//connect to aurora to dectect tools automatically
thisDevice->OpenConnection();
//now search for automatically detected tools in the tool storage and save them
mitk::NavigationToolStorage::Pointer newToolStorageInRightOrder = mitk::NavigationToolStorage::New();
std::vector<int> alreadyFoundTools = std::vector<int>();
m_ToolCorrespondencesInToolStorage = std::vector<int>();
for (int i=0; i<thisDevice->GetToolCount(); i++)
{
bool toolFound = false;
for (int j=0; j<navigationTools->GetToolCount(); j++)
{
//check if the serial number is the same to identify the tool
if ((dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i)))->GetSerialNumber() == navigationTools->GetTool(j)->GetSerialNumber())
{
//check if this tool was already added to make sure that every tool is only added once (in case of same serial numbers)
bool toolAlreadyAdded = false;
for(int k=0; k<alreadyFoundTools.size(); k++) if (alreadyFoundTools.at(k) == j) toolAlreadyAdded = true;
if(!toolAlreadyAdded)
{
//add tool in right order
newToolStorageInRightOrder->AddTool(navigationTools->GetTool(j));
m_ToolCorrespondencesInToolStorage.push_back(j);
//adapt name of tool
dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i))->SetToolName(navigationTools->GetTool(j)->GetToolName());
//set tip of tool
dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i))->SetToolTip(navigationTools->GetTool(j)->GetToolTipPosition(),navigationTools->GetTool(j)->GetToolTipOrientation());
//rember that this tool was already found
alreadyFoundTools.push_back(j);
toolFound = true;
break;
}
}
}
if (!toolFound)
{
this->m_ErrorMessage = "Error: did not find every automatically detected tool in the loaded tool storage: aborting initialization.";
return NULL;
}
}
//delete all tools from the tool storage
navigationTools->DeleteAllTools();
//and add only the detected tools in the right order
for (int i=0; i<newToolStorageInRightOrder->GetToolCount(); i++)
{
navigationTools->AddTool(newToolStorageInRightOrder->GetTool(i));
}
returnValue->SetTrackingDevice(thisDevice);
+ MITK_DEBUG << "Number of tools of created tracking device: " << thisDevice->GetToolCount();
+ MITK_DEBUG << "Number of outputs of created source: " << returnValue->GetNumberOfOutputs();
return returnValue;
}
mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateMicronTrackerTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice, mitk::NavigationToolStorage::Pointer navigationTools)
{
mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
mitk::ClaronTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::ClaronTrackingDevice*>(trackingDevice.GetPointer());
m_ToolCorrespondencesInToolStorage = std::vector<int>();
//add the tools to the tracking device
for (int i=0; i<navigationTools->GetToolCount(); i++)
{
mitk::NavigationTool::Pointer thisNavigationTool = m_NavigationTools->GetTool(i);
m_ToolCorrespondencesInToolStorage.push_back(i);
bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str(),thisNavigationTool->GetCalibrationFile().c_str());
if (!toolAddSuccess)
{
//todo error handling
this->m_ErrorMessage = "Can't add tool, is the toolfile valid?";
return NULL;
}
thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(),thisNavigationTool->GetToolTipOrientation());
}
returnValue->SetTrackingDevice(thisDevice);
return returnValue;
}
mitk::NavigationDataObjectVisualizationFilter::Pointer mitk::TrackingDeviceSourceConfigurator::CreateNavigationDataObjectVisualizationFilter(mitk::TrackingDeviceSource::Pointer trackingDeviceSource, mitk::NavigationToolStorage::Pointer navigationTools)
{
mitk::NavigationDataObjectVisualizationFilter::Pointer returnValue = mitk::NavigationDataObjectVisualizationFilter::New();
- for (int i=0; i<trackingDeviceSource->GetNumberOfOutputs(); i++)
+ for (int i=0; i<trackingDeviceSource->GetNumberOfIndexedOutputs(); i++)
{
mitk::NavigationTool::Pointer currentTool = navigationTools->GetToolByName(trackingDeviceSource->GetOutput(i)->GetName());
if (currentTool.IsNull())
{
this->m_ErrorMessage = "Error: did not find correspondig tool in tracking device after initialization.";
return NULL;
}
returnValue->SetInput(i,trackingDeviceSource->GetOutput(i));
returnValue->SetRepresentationObject(i,currentTool->GetDataNode()->GetData());
}
return returnValue;
}
int mitk::TrackingDeviceSourceConfigurator::GetToolNumberInToolStorage(int outputID)
{
if (outputID < m_ToolCorrespondencesInToolStorage.size()) return m_ToolCorrespondencesInToolStorage.at(outputID);
else return -1;
}
std::string mitk::TrackingDeviceSourceConfigurator::GetToolIdentifierInToolStorage(int outputID)
{
if (outputID < m_ToolCorrespondencesInToolStorage.size()) return m_NavigationTools->GetTool(m_ToolCorrespondencesInToolStorage.at(outputID))->GetIdentifier();
else return "";
}
std::vector<int> mitk::TrackingDeviceSourceConfigurator::GetToolNumbersInToolStorage()
{
return m_ToolCorrespondencesInToolStorage;
}
std::vector<std::string> mitk::TrackingDeviceSourceConfigurator::GetToolIdentifiersInToolStorage()
{
std::vector<std::string> returnValue = std::vector<std::string>();
for (int i=0; i<m_ToolCorrespondencesInToolStorage.size(); i++)
{returnValue.push_back(m_NavigationTools->GetTool(m_ToolCorrespondencesInToolStorage.at(i))->GetIdentifier());}
return returnValue;
}
diff --git a/Modules/IGT/IGTTrackingDevices/mitkItkNonUniformBSpline.h b/Modules/IGT/IGTTrackingDevices/mitkItkNonUniformBSpline.h
index f20b936946..84de4b636f 100644
--- a/Modules/IGT/IGTTrackingDevices/mitkItkNonUniformBSpline.h
+++ b/Modules/IGT/IGTTrackingDevices/mitkItkNonUniformBSpline.h
@@ -1,209 +1,209 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
/*********************************
This file was taken from ITK, CVS version 1.8 to circumvent a bug in ITK release 3.18 (see http://public.kitware.com/Bug/view.php?id=10633
*********************************/
#ifndef __itkNonUniformBSpline_h
#define __itkNonUniformBSpline_h
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
#include <vector>
#include "itkPoint.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
#include "itkArray.h"
namespace itk {
/**
* \class NonUniformBSpline
* \brief BSpline with nonuniform knot spacing.
*
* This class is a bspline with nonuniform knot spacing. The
* use can specify a set of points and a set of knots and the
* spline will attempt to find the control points which will
* cause the spline to interpolate the points.
*
* CAUTION: THIS CLASS IS STILL UNDER DEVELOPMENT.
*
*/
template < unsigned int TDimension = 3 >
class NonUniformBSpline
: public Object
{
public:
/**
Typedefs
*/
typedef NonUniformBSpline Self;
typedef Object Superclass;
typedef SmartPointer < Self > Pointer;
typedef SmartPointer < const Self > ConstPointer;
typedef double ScalarType;
typedef itk::Point< ScalarType, TDimension > PointType;
typedef std::vector < PointType > PointListType;
typedef PointListType * PointListPointer;
typedef std::vector < double > KnotListType;
typedef std::vector<double> CoordinateListType;
typedef itk::Point<double, TDimension > ControlPointType;
typedef std::vector< ControlPointType > ControlPointListType;
typedef ControlPointListType * ControlPointListPointer;
typedef std::vector<double> ChordLengthListType;
/** Method for creation through the object factory. */
itkNewMacro( Self );
/** Method for creation through the object factory. */
itkTypeMacro( NonUniformBSpline, Object );
/**
* Set points which the spline will attempt to interpolate.
*/
void SetPoints( PointListType & newPoints );
/**
* Get the points the spline is trying to interpolate.
*/
const PointListType & GetPoints() const;
/**
* Set the knot vector. Knots may be nonuniformly spaced.
* Knots will be rescaled to be between 0 and 1.
*/
void SetKnots( KnotListType & newKnots);
/**
* Get the knot vector.
*/
const KnotListType & GetKnots() const;
/**
* Computes the chord lengths based on the points.
*/
void ComputeChordLengths();
/**
* Methods for evaluating the spline.
* The parameterization is always between 0 and 1.
*/
PointType EvaluateSpline(const Array<double> & p) const;
PointType EvaluateSpline( double t ) const;
/**
* Compute the control points.
*/
void ComputeControlPoints();
/**
* Set the control points for the spline.
*/
void SetControlPoints( ControlPointListType& ctrlpts );
/**
* Get the control points for the spline
*/
const ControlPointListType & GetControlPoints() const;
/**
* Evaluate the basis functions directly.
* order - order of the basis function, i.e. 3 = cubic.
* i - basis function number, zero based.
* t - parameter of the spline.
*/
double NonUniformBSplineFunctionRecursive(unsigned int order, unsigned int i, double t) const;
/**
* Set the order of the spline.
*/
itkSetMacro( SplineOrder, unsigned int );
itkGetConstReferenceMacro( SplineOrder, unsigned int );
protected:
/**
* Constructor
*/
NonUniformBSpline();
/**
* Virtual destructor
*/
virtual ~NonUniformBSpline();
/**
* Method to print the object.
*/
virtual void PrintSelf( std::ostream& os, Indent indent ) const;
/**
* Points that the spline attempts to intepolate.
*/
PointListType m_Points;
/**
* The knots of spline.
*/
KnotListType m_Knots;
/**
* The control points of the spline.
*/
ControlPointListType m_ControlPoints;
/**
* The chord length computed from m_Points.
*/
ChordLengthListType m_ChordLength;
/**
* The cumulative chord length computed from m_Points
*/
ChordLengthListType m_CumulativeChordLength;
/**
* The order of the spline.
*/
unsigned int m_SplineOrder;
/**
* The spatial dimension. Saved from the template parameter.
*/
unsigned int m_SpatialDimension;
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
-#include "itkNonUniformBSpline.txx"
+#include "mitkItkNonUniformBSpline.txx"
#endif
#endif // __itkNonUniformBSpline_h
diff --git a/Modules/IGT/IGTTrackingDevices/mitkItkNonUniformBSpline.txx b/Modules/IGT/IGTTrackingDevices/mitkItkNonUniformBSpline.txx
index d8fd942dec..f9782b74cf 100644
--- a/Modules/IGT/IGTTrackingDevices/mitkItkNonUniformBSpline.txx
+++ b/Modules/IGT/IGTTrackingDevices/mitkItkNonUniformBSpline.txx
@@ -1,437 +1,437 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
/*********************************
This file was taken from ITK, CVS version 1.13 to circumvent a bug in ITK release 3.18 (see http://public.kitware.com/Bug/view.php?id=10633
*********************************/
#ifndef __itkNonUniformBSpline_txx
#define __itkNonUniformBSpline_txx
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
-#include "itkNonUniformBSpline.h"
+#include "mitkItkNonUniformBSpline.h"
#include "vnl/vnl_vector.h"
#include "vnl/vnl_matrix.h"
#include "vnl/algo/vnl_lsqr.h"
#include "vnl/vnl_linear_system.h"
// #define DEBUG_SPLINE
namespace itk
{
/** Constructor */
template< unsigned int TDimension >
NonUniformBSpline< TDimension >
::NonUniformBSpline()
{
// Cubic bspline => 4th order
m_SplineOrder = 3;
m_SpatialDimension = TDimension;
}
/** Destructor */
template< unsigned int TDimension >
NonUniformBSpline< TDimension >
::~NonUniformBSpline()
{
}
/** Print the object */
template< unsigned int TDimension >
void
NonUniformBSpline< TDimension >
::PrintSelf( std::ostream& os, Indent indent ) const
{
Superclass::PrintSelf( os, indent );
os << indent << "NonUniformBSpline(" << this << ")" << std::endl;
os << indent << "Chord lengths : " << std::endl;
for (ChordLengthListType::const_iterator iter = m_CumulativeChordLength.begin();
iter != m_CumulativeChordLength.end();
iter++)
{
os << indent << indent << *iter << std::endl;
}
os << indent << "Knots : " << std::endl;
for (KnotListType::const_iterator kiter = m_Knots.begin();
kiter != m_Knots.end();
kiter++)
{
os << indent << indent << *kiter << std::endl;
}
os << indent << "Control Points : " << std::endl;
for (typename ControlPointListType::const_iterator cpiter = m_ControlPoints.begin();
cpiter != m_ControlPoints.end();
cpiter++)
{
os << indent << indent << *cpiter << std::endl;
}
}
/** Set the list of points composing the tube */
template< unsigned int TDimension >
void
NonUniformBSpline< TDimension >
::SetPoints( PointListType & points )
{
m_Points.clear();
typename PointListType::iterator it,end;
it = points.begin();
end = points.end();
while(it != end)
{
m_Points.push_back(*it);
it++;
}
this->Modified();
}
/** Set the list of points composing the tube */
template< unsigned int TDimension >
void
NonUniformBSpline< TDimension >
::SetKnots( KnotListType & knots )
{
m_Knots.clear();
int len = knots.size();
double max_knot = knots[len - 1];
typename KnotListType::iterator it;
typename KnotListType::iterator end;
it = knots.begin();
end = knots.end();
while(it != end)
{
m_Knots.push_back(*it/max_knot);
it++;
}
this->Modified();
}
template< unsigned int TDimension >
double
NonUniformBSpline< TDimension >
::NonUniformBSplineFunctionRecursive(unsigned int order, unsigned int i, double t) const
{
if (order == 1)
{
if (m_Knots[i] <= t && t < m_Knots[i+1])
{
return 1;
}
else
{
return 0;
}
}
//
// Be careful, we must use the passed in parameter for the order since this
// function is recursive.
//
double numer1 = (t - m_Knots[i]) * NonUniformBSplineFunctionRecursive(order-1, i, t);
double denom1 = (m_Knots[i+order-1] - m_Knots[i]);
double val1 = numer1 / denom1;
if (denom1 == 0 && numer1 == 0)
val1 = 0;
else if (denom1 == 0)
std::cout << "Error : " << denom1 << ", " << numer1 << std::endl;
double numer2 = (m_Knots[i+order] - t) * NonUniformBSplineFunctionRecursive(order-1, i+1, t);
double denom2 = (m_Knots[i + order] - m_Knots[i+1]);
double val2 = numer2 / denom2;
if (denom2 == 0 && numer2 == 0)
val2 = 0;
else if (denom2 == 0)
std::cout << "Error : " << denom2 << ", " << numer2 << std::endl;
return val1 + val2;
}
template< unsigned int TDimension >
void
NonUniformBSpline< TDimension >
::ComputeChordLengths()
{
m_ChordLength.clear();
m_CumulativeChordLength.clear();
m_ChordLength.push_back(0);
m_CumulativeChordLength.push_back(0);
double total_chord_length = 0.0;
ChordLengthListType temp;
for (::size_t i = 0; i < m_Points.size()-1; i++)
{
PointType pt = m_Points[i];
PointType pt2 = m_Points[i+1];
double chord = pt.EuclideanDistanceTo(pt2);
m_ChordLength.push_back(chord);
total_chord_length = total_chord_length + chord;
temp.push_back(total_chord_length);
}
for (ChordLengthListType::iterator aiter = temp.begin();
aiter != temp.end();
aiter++)
{
m_CumulativeChordLength.push_back(*aiter/total_chord_length);
}
//
// Debug printouts
//
#ifdef DEBUG_SPLINE
std::cout << "Total chord length : " << total_chord_length << std::endl;
std::cout << "Chord length : " << std::endl;
for (ChordLengthListType::iterator aiter2 = m_ChordLength.begin();
aiter2 != m_ChordLength.end();
aiter2++)
{
std::cout << *aiter2 << std::endl;
}
std::cout << "Cumulative chord length : " << std::endl;
for (ChordLengthListType::iterator aiter3 = m_CumulativeChordLength.begin();
aiter3 != m_CumulativeChordLength.end();
aiter3++)
{
std::cout << *aiter3 << std::endl;
}
std::cout << std::endl;
#endif
}
template< unsigned int TDimension >
void
NonUniformBSpline< TDimension >
::SetControlPoints( ControlPointListType& ctrlpts )
{
m_ControlPoints.clear();
for (typename ControlPointListType::iterator iter = ctrlpts.begin();
iter != ctrlpts.end();
iter++)
{
m_ControlPoints.push_back(*iter);
}
this->Modified();
}
template< unsigned int TDimension >
const typename
NonUniformBSpline< TDimension >::ControlPointListType &
NonUniformBSpline< TDimension >::GetControlPoints() const
{
return this->m_ControlPoints;
}
template< unsigned int TDimension >
const typename
NonUniformBSpline< TDimension >::KnotListType &
NonUniformBSpline< TDimension >::GetKnots() const
{
return this->m_Knots;
}
template< unsigned int TDimension >
const typename
NonUniformBSpline< TDimension >::PointListType &
NonUniformBSpline< TDimension >::GetPoints() const
{
return this->m_Points;
}
template< unsigned int TDimension >
void
NonUniformBSpline< TDimension >::ComputeControlPoints()
{
unsigned int dim = m_Points[0].GetPointDimension();
#ifdef DEBUG_SPLINE
std::cout << "Points have dimension : " << dim << std::endl;
#endif
//
// +1 in cols for radius
//
vnl_matrix<double> data_matrix(m_Points.size(), dim);
//
// Form data point matrix
//
int rr = 0;
for (typename PointListType::iterator iter = m_Points.begin();
iter != m_Points.end();
iter++)
{
PointType pt = (*iter);
for (unsigned int i = 0; i < dim; i++)
{
data_matrix(rr, i) = pt.GetVnlVector()[i];
}
rr++;
}
#ifdef DEBUG_SPLINE
std::cout << std::endl << "Data matrix" << std::endl;
std::cout << data_matrix << std::endl;
#endif
//
// Form basis function matrix
//
//int num_basis_functions = 2 * m_SplineOrder - 1;
//int num_basis_functions = m_Points.size();
int num_rows = m_Points.size();
//
// Assumes multiplicity k (m_SplineOrder at the ends).
//
int num_cols = m_Knots.size() - m_SplineOrder;
vnl_matrix<double> N_matrix(num_rows, num_cols);
//N_matrix(0, 0) = 1.0;
for (int r = 0; r < num_rows; r++)
{
for (int c = 0; c < num_cols; c++)
{
double t = m_CumulativeChordLength[r];
N_matrix(r, c) = NonUniformBSplineFunctionRecursive(m_SplineOrder, c, t);
}
}
N_matrix(num_rows-1, num_cols-1) = 1.0;
#ifdef DEBUG_SPLINE
std::cout << "Basis function matrix : " << std::endl;
std::cout << N_matrix << std::endl;
#endif
//FIXME: Use the LSQR linear solver here:
vnl_matrix<double> B;
// = vnl_matrix_inverse<double>(N_matrix.transpose() * N_matrix) * N_matrix.transpose() * data_matrix;
// vnl_linear_system ls( N_matrix.rows(), N_matrix.cols() );
// vnl_lsqr solver( ls );
//#ifdef DEBUG_SPLINE
std::cout << "Control point matrix : " << std::endl;
std::cout << B << std::endl;
//#endif
m_ControlPoints.clear();
for ( unsigned int j = 0; j < B.rows(); j++ )
{
vnl_vector<double> v = B.get_row(j);
itk::Vector<double> iv;
iv.SetVnlVector(v);
itk::Point<double, TDimension> pt;
for ( unsigned int d = 0; d < dim; d++ )
{
pt[d] = v(d);
}
m_ControlPoints.push_back(pt);
}
return;
}
template< unsigned int TDimension >
typename NonUniformBSpline<TDimension>::PointType
NonUniformBSpline< TDimension >
::EvaluateSpline(const itk::Array<double> & p) const
{
double t = p[0];
return EvaluateSpline(t);
}
template< unsigned int TDimension >
typename NonUniformBSpline<TDimension>::PointType
NonUniformBSpline< TDimension >
::EvaluateSpline(double t) const
{
int i = 0;
vnl_vector<double> result(TDimension);
result.fill(0);
for (typename ControlPointListType::const_iterator cpiter = m_ControlPoints.begin();
cpiter != m_ControlPoints.end();
cpiter++)
{
ControlPointType pt = *cpiter;
vnl_vector<double> v = pt.GetVnlVector();
const double N = this->NonUniformBSplineFunctionRecursive(m_SplineOrder, i, t);
for( unsigned j = 0; j < TDimension; j++ )
{
result[j] += N * v[j];
}
i++;
}
double array[TDimension];
for ( unsigned int d = 0; d < TDimension; d++ )
{
array[d] = result[d];
}
ControlPointType sum(array);
#ifdef DEBUG_SPLINE
std::cout << "Result : " << result << std::endl;
std::cout << "Sum : " << sum << std::endl;
#endif
return sum;
}
} // end namespace itk
#endif
diff --git a/Modules/IGT/IGTTrackingDevices/mitkVirtualTrackingTool.h b/Modules/IGT/IGTTrackingDevices/mitkVirtualTrackingTool.h
index 07f790bc91..732044affd 100644
--- a/Modules/IGT/IGTTrackingDevices/mitkVirtualTrackingTool.h
+++ b/Modules/IGT/IGTTrackingDevices/mitkVirtualTrackingTool.h
@@ -1,72 +1,73 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKVirtualTrackingTool_H_HEADER_INCLUDED_
#define MITKVirtualTrackingTool_H_HEADER_INCLUDED_
#include <mitkInternalTrackingTool.h>
#include <MitkIGTExports.h>
#include <mitkVector.h>
#include <itkFastMutexLock.h>
-#if ITK_VERSION_MAJOR == 3 && ITK_VERSION_MINOR == 18 && ITK_VERSION_PATCH == 0
- #include <mitkItkNonUniformBSpline.h> // fixed version of a class that is defect in ITK 3.18
-#else
- #include <itkNonUniformBSpline.h>
-#endif
+//#if ITK_VERSION_MAJOR == 3 && ITK_VERSION_MINOR == 18 && ITK_VERSION_PATCH == 0
+// #include <mitkItkNonUniformBSpline.h> // fixed version of a class that is defect in ITK 3.18
+//#else
+// #include <itkNonUniformBSpline.h>
+//#endif
+#include <mitkItkNonUniformBSpline.h>
namespace mitk {
/**Documentation
* \brief implements TrackingTool interface
*
* This class is a complete TrackingTool implementation. It can either be used directly by
* TrackingDevices, or be subclassed for more specific implementations.
* mitk::MicroBirdTrackingDevice uses this class to manage its tools. Other tracking devices
* uses specialized versions of this class (e.g. mitk::NDITrackingTool)
*
* \ingroup IGT
*/
class MitkIGT_EXPORT VirtualTrackingTool : public InternalTrackingTool
{
public:
mitkClassMacro(VirtualTrackingTool, InternalTrackingTool);
friend class VirtualTrackingDevice;
typedef itk::NonUniformBSpline<3> SplineType; ///< spline type used for tool path interpolation
itkGetMacro(SplineLength, mitk::ScalarType);
itkSetMacro(SplineLength, mitk::ScalarType);
itkGetMacro(Velocity, mitk::ScalarType);
itkSetMacro(Velocity, mitk::ScalarType);
itkGetObjectMacro(Spline, SplineType);
protected:
itkNewMacro(Self);
VirtualTrackingTool();
virtual ~VirtualTrackingTool();
SplineType::Pointer m_Spline;
mitk::ScalarType m_SplineLength;
mitk::ScalarType m_Velocity;
};
} // namespace mitk
#endif /* MITKVirtualTrackingTool_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IGTTutorial/IGTTutorialStep1.cpp b/Modules/IGT/IGTTutorial/IGTTutorialStep1.cpp
index 8fae651cea..830308fa3f 100644
--- a/Modules/IGT/IGTTutorial/IGTTutorialStep1.cpp
+++ b/Modules/IGT/IGTTutorial/IGTTutorialStep1.cpp
@@ -1,195 +1,195 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkVirtualTrackingDevice.h>
#include <mitkInternalTrackingTool.h>
#include <mitkNavigationData.h>
#include <mitkTrackingDeviceSource.h>
#include "mitkNavigationDataDisplacementFilter.h"
#include <mitkNavigationDataRecorder.h>
#include <mitkNavigationDataPlayer.h>
#include <itksys/SystemTools.hxx>
//##Documentation
//## \brief A small console tutorial about MITK-IGT
int main(int /*argc*/, char* /*argv*/[])
{
//*************************************************************************
// What we will do...
//*************************************************************************
//In this tutorial we build up a small navigation pipeline with a virtual tracking device
//which produce random positions and orientation so no additional hardware is required.
//The source of the pipeline is a TrackingDeviceSource object. This we connect to a simple
//filter which just displaces the positions with an offset. After that we use a recorder
//to store this new positions and other information to disc in a XML file. After that we use
//another source (NavigationDataPlayer) to replay the recorded data.
//*************************************************************************
// Part I: Basic initialization of the source and tracking device
//*************************************************************************
//First of all create a tracking device object and two tools for this "device".
//Here we take the VirtualTrackingDevice. This is not a real tracking device it just delivers random
//positions and orientations. You can use other/real tracking devices if you replace the following
//code with different tracking devices, e.g. mitk::NDITrackingDevice. The tools represent the
//sensors of the tracking device. The TrackingDevice fills the tools with data.
std::cout << "Generating TrackingDevice ..." << std::endl;
mitk::VirtualTrackingDevice::Pointer tracker = mitk::VirtualTrackingDevice::New();
tracker->AddTool("tool1");
tracker->AddTool("tool2");
//The tracking device object is used for the physical connection to the device. To use the
//data inside of our tracking pipeline we need a source. This source encapsulate the tracking device
//and provides objects of the type mitk::NavigationData as output. The NavigationData objects stores
//position, orientation, if the data is valid or not and special error informations in a covariance
//matrix.
//
//Typically the start of our pipeline is a TrackingDeviceSource. To work correct we have to set a
//TrackingDevice object. Attention you have to set the tools before you set the whole TrackingDevice
//object to the TrackingDeviceSource because the source need to know how many outputs should be
//generated.
std::cout << "Generating Source ..." << std::endl;
mitk::TrackingDeviceSource::Pointer source = mitk::TrackingDeviceSource::New();
source->SetTrackingDevice(tracker); //here we set the device for the pipeline source
source->Connect(); //here we connect to the tracking system
//Note we do not call this on the TrackingDevice object
source->StartTracking(); //start the tracking
//Now the source generates outputs.
//*************************************************************************
// Part II: Create a NavigationDataToNavigationDataFilter
//*************************************************************************
//The next thing we do is using a NavigationDataToNavigationDataFilter. One of these filter is the
//very simple NavigationDataDisplacementFilter. This filter just changes the positions of the input
//NavigationData objects with an offset for each direction (X,Y,Z). The input of this filter is the
//source and the output of this filter is the "displaced" input.
std::cout << "Generating DisplacementFilter ..." << std::endl;
mitk::NavigationDataDisplacementFilter::Pointer displacer = mitk::NavigationDataDisplacementFilter::New();
mitk::Vector3D offset;
mitk::FillVector3D(offset, 10.0, 100.0, 1.0); //initialize the offset
displacer->SetOffset(offset); //now set the offset in the NavigationDataDisplacementFilter object
//now every output of the source object is connected to the displacer object
for (unsigned int i = 0; i < source->GetNumberOfOutputs(); i++)
{
displacer->SetInput(i, source->GetOutput(i)); //here we connect to the displacement filter
}
//*************************************************************************
// Part III: Record the data with the NavigationDataRecorder
//*************************************************************************
//The next part of our pipeline is the recorder. The recorder needs a filename. Otherwise the output
//is redirected to the console. The input of the recorder is the output of the displacement filter
//and the output is a XML file with the name "Test Output-0.xml".
std::cout << "Start Recording ..." << std::endl;
//we need the stringstream for building up our filename
std::stringstream filename;
//the .xml extension and an counter is added automatically
filename << itksys::SystemTools::GetCurrentWorkingDirectory() << "/Test Output";
std::cout << "Record to file: " << filename.str() << "-0.xml ..." << std::endl;
mitk::NavigationDataRecorder::Pointer recorder = mitk::NavigationDataRecorder::New();
recorder->SetFileName(filename.str());
//now every output of the displacer object is connected to the recorder object
for (unsigned int i = 0; i < displacer->GetNumberOfOutputs(); i++)
{
recorder->AddNavigationData(displacer->GetOutput(i)); // here we connect to the recorder
}
recorder->StartRecording(); //after finishing the settings you can start the recording mechanism
//now every update of the recorder stores one line into the file for
//each added NavigationData
for (unsigned int x = 0; x < 100; x++) //write 100 datasets
{
recorder->Update(); //the update causes one line in the XML file for every tool
//in this case two lines
itksys::SystemTools::Delay(100); //sleep a little
}
recorder->StopRecording(); //to get proper XML files you should stop recording
//if your application crashes during recording no data
//will be lost it is all stored to disc
//*************************************************************************
// Part IV: Play the data with the NavigationDataPlayer
//*************************************************************************
//The recording is finished now so now we can play the data. The NavigationDataPlayer is similar
//to the TrackingDevice source. It also derives from NavigationDataSource. So you can use a player
//instead of a TrackingDeviceSource. The input of this player is the filename and the output are
//NavigationData object.
filename << "-0.xml";
std::cout << "Start playing from file: " << filename.str() << " ..." << std::endl;
mitk::NavigationDataPlayer::Pointer player = mitk::NavigationDataPlayer::New();
//this is first part of the file name the .xml extension and an counter is added automatically
player->SetFileName(filename.str());
player->StartPlaying(); //this starts the player
//From now on the player provides NavigationDatas in the order and
//correct time as they were recorded
//this connects the outputs of the player to the NavigationData objects
- mitk::NavigationData::Pointer nd = player->GetOutput(0);
+ mitk::NavigationData::Pointer nd = player->GetOutput();
mitk::NavigationData::Pointer nd2 = player->GetOutput(1);
for (unsigned int x=0; x<100; x++)
{
if (nd.IsNotNull()) //check if the output is not null
{
//With this update the NavigationData object propagates through the pipeline to get a new value.
//In this case we only have a source (NavigationDataPlayer).
nd->Update();
std::cout << x << ": 1:" << nd->GetPosition() << std::endl;
std::cout << x << ": 2:" << nd2->GetPosition() << std::endl;
std::cout << x << ": 1:" << nd->GetOrientation() << std::endl;
std::cout << x << ": 2:" << nd2->GetOrientation() << std::endl;
itksys::SystemTools::Delay(100); //sleep a little like in the recorder part
}
}
player->StopPlaying(); //This stops the player
//With another call of StartPlaying the player will start again at the beginning of the file
itksys::SystemTools::Delay(2000);
std::cout << "finished" << std::endl;
}
diff --git a/Modules/IGT/Testing/files.cmake b/Modules/IGT/Testing/files.cmake
index b4b5aacf95..3d770dcc0f 100644
--- a/Modules/IGT/Testing/files.cmake
+++ b/Modules/IGT/Testing/files.cmake
@@ -1,49 +1,49 @@
set(MODULE_TESTS
mitkCameraVisualizationTest.cpp
mitkClaronInterfaceTest.cpp
mitkClaronToolTest.cpp
mitkClaronTrackingDeviceTest.cpp
mitkInternalTrackingToolTest.cpp
mitkNavigationDataDisplacementFilterTest.cpp
mitkNavigationDataLandmarkTransformFilterTest.cpp
mitkNavigationDataObjectVisualizationFilterTest.cpp
mitkNavigationDataTest.cpp
mitkNavigationDataRecorderTest.cpp
mitkNavigationDataReferenceTransformFilterTest.cpp
mitkNavigationDataSequentialPlayerTest.cpp
mitkNavigationDataSourceTest.cpp
mitkNavigationDataToMessageFilterTest.cpp
mitkNavigationDataToNavigationDataFilterTest.cpp
mitkNavigationDataToPointSetFilterTest.cpp
- mitkNavigationDataTransformFilterTest.cpp
+ # mitkNavigationDataTransformFilterTest.cpp commented out because of bug 15023
mitkNDIPassiveToolTest.cpp
mitkNDIProtocolTest.cpp
mitkNDITrackingDeviceTest.cpp
mitkTimeStampTest.cpp
mitkTrackingVolumeGeneratorTest.cpp
mitkTrackingDeviceTest.cpp
mitkTrackingToolTest.cpp
mitkVirtualTrackingDeviceTest.cpp
- mitkNavigationDataPlayerTest.cpp # see bug 11636
+ mitkNavigationDataPlayerTest.cpp # see bug 11636 (extend this test by microservices)
mitkTrackingDeviceSourceTest.cpp
mitkTrackingDeviceSourceConfiguratorTest.cpp
mitkNavigationDataEvaluationFilterTest.cpp
mitkTrackingTypesTest.cpp
# ------------------ Navigation Tool Management Tests -------------------
mitkNavigationToolStorageTest.cpp
mitkNavigationToolStorageSerializerAndDeserializerTest.cpp
mitkNavigationToolTest.cpp
mitkNavigationToolReaderAndWriterTest.cpp
# -----------------------------------------------------------------------
# ------------------ Deavtivated Tests ----------------------------------
# -----------------------------------------------------------------------
)
set(MODULE_CUSTOM_TESTS
mitkNDIAuroraHardwareTest.cpp
mitkNDIPolarisHardwareTest.cpp
mitkClaronTrackingDeviceHardwareTest.cpp
)
diff --git a/Modules/IGT/Testing/mitkNavigationDataDisplacementFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataDisplacementFilterTest.cpp
index 21faf75353..c117ffdc68 100644
--- a/Modules/IGT/Testing/mitkNavigationDataDisplacementFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataDisplacementFilterTest.cpp
@@ -1,162 +1,162 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataDisplacementFilter.h"
#include "mitkNavigationData.h"
#include "mitkTestingMacros.h"
#include <iostream>
#include "mitkPropertyList.h"
#include "mitkProperties.h"
/**Documentation
* test for the class "NavigationDataDisplacementFilter".
*/
int mitkNavigationDataDisplacementFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataDisplacementFilter")
// let's create an object of our class
mitk::NavigationDataDisplacementFilter::Pointer myFilter = mitk::NavigationDataDisplacementFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 0.0, 0.0, 0.0);
mitk::NavigationData::OrientationType initialOri(0.0, 0.0, 0.0, 0.0);
mitk::ScalarType initialError(0.0);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
myFilter->SetInput(nd1);
MITK_TEST_CONDITION(myFilter->GetInput() == nd1, "testing Set-/GetInput()");
/* create filter parameter */
mitk::Vector3D offset;
mitk::FillVector3D(offset, 1.0, 1.0, 1.0);
myFilter->SetOffset(offset);
MITK_TEST_CONDITION(myFilter->GetOffset() == offset, "testing Set-/GetOffset()");
mitk::NavigationData* output = myFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output != NULL, "Testing GetOutput()");
output->Update(); // execute filter
MITK_TEST_CONDITION(output->GetPosition() == (initialPos + offset), "Testing offset calculation");
MITK_TEST_CONDITION(output->GetOrientation() == initialOri, "Testing if Orientation remains unchanged");
MITK_TEST_CONDITION(output->IsDataValid() == initialValid, "Testing if DataValid remains unchanged");
/* now test the filter with multiple inputs */
mitk::NavigationData::PositionType initialPos2;
mitk::FillVector3D(initialPos2, -1000.0, 567.89, 0.0);
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri);
nd2->SetPositionAccuracy(initialError);
nd2->SetDataValid(initialValid);
myFilter = NULL;
myFilter = mitk::NavigationDataDisplacementFilter::New();
myFilter->SetOffset(offset);
myFilter->SetInput(0, nd1);
myFilter->SetInput(1, nd2);
MITK_TEST_CONDITION(((myFilter->GetInput(0) == nd1)
&& (myFilter->GetInput(1) == nd2)), "testing Set-/GetInput(index, data)");
- output = myFilter->GetOutput(0);
+ output = myFilter->GetOutput();
mitk::NavigationData* output2 = myFilter->GetOutput(1);
output2->Update(); // execute filter pipeline. this should update both outputs!
MITK_TEST_CONDITION(((output != NULL)
&& (output2 != NULL)), "testing GetOutput(index)");
MITK_TEST_CONDITION(output->GetPosition() == (initialPos + offset), "Testing offset calculation for output 0");
MITK_TEST_CONDITION(output2->GetPosition() == (initialPos2 + offset), "Testing offset calculation for output 1");
MITK_TEST_CONDITION(output2->GetOrientation() == initialOri, "Testing if Orientation remains unchanged for output 1");
MITK_TEST_CONDITION(output2->IsDataValid() == initialValid, "Testing if DataValid remains unchanged for output 1");
/* test if anything changes on second ->Update() */
output->Update(); // nothing should change, since inputs remain unchanged
MITK_TEST_CONDITION((output->GetPosition() == (initialPos + offset))
&&(output2->GetPosition() == (initialPos2 + offset)), "Testing offset calculation after second update()");
/* change an input, see if output changes too */
mitk::NavigationData::PositionType pos2;
mitk::FillVector3D(pos2, 123.456, -234.567, 789.987);
nd1->SetPosition(pos2); // nd1 is modified, but nothing should change until pipe gets updated
MITK_TEST_CONDITION((output->GetPosition() == (initialPos + offset))
&&(output2->GetPosition() == (initialPos2 + offset)), "Testing offset calculation after input change, before update()");
output->Update(); // update pipeline. should recalculate positions, because input has changed
MITK_TEST_CONDITION((output->GetPosition() == (pos2 + offset))
&&(output2->GetPosition() == (initialPos2 + offset)), "Testing offset calculation after input change, after update()");
/* now, change filter parameter and check if pipeline updates correctly */
mitk::Vector3D offset2;
mitk::FillVector3D(offset2, -1.2, 3.45, -6.789);
myFilter->SetOffset(offset2);
MITK_TEST_CONDITION((output->GetPosition() == (pos2 + offset))
&&(output2->GetPosition() == (initialPos2 + offset)), "Testing offset calculation after offset parameter change, before update()");
output->Update(); // update pipeline. should recalculate positions, because input has changed
MITK_TEST_CONDITION((output->GetPosition() == (pos2 + offset2))
&&(output2->GetPosition() == (initialPos2 + offset2)), "Testing offset calculation after offset parameter , after update()");
/* Now test the PropertyList handling of the GetParameters() and SetParameters() methods */
mitk::PropertyList::ConstPointer p = myFilter->GetParameters();
MITK_TEST_CONDITION(p.IsNotNull(), "Testing GetParameters() has valid return type");
mitk::Vector3D v;
MITK_TEST_CONDITION(p->GetPropertyValue<mitk::Vector3D>("NavigationDataDisplacementFilter_Offset", v) == true, "PropertyList contains correct key?");
MITK_TEST_CONDITION(v == offset2, "Offset Property contains correct value?");
MITK_TEST_CONDITION(p->GetMap()->size() == 1, "PropertyList contains correct number of items?");
mitk::PropertyList::Pointer p2 = mitk::PropertyList::New();
myFilter->SetParameters(p2);
MITK_TEST_CONDITION(myFilter->GetOffset() == offset2, "Offset unchanged on SetParameters() with empty PropertyList?");
p2->SetProperty("NavigationDataDisplacementFilter_WRONGNAME", mitk::Vector3DProperty::New(v)); // fill PropertyList with incorrect parameter
MITK_TEST_CONDITION(myFilter->GetOffset() == offset2, "Offset unchanged on SetParameters() with wrong propertyname?");
mitk::FillVector3D(v, -111.1, 0.0, 111.1);
p2->SetProperty("NavigationDataDisplacementFilter_Offset", mitk::Vector3DProperty::New(v)); // fill PropertyList with correct parameter
myFilter->SetParameters(p2);
MITK_TEST_CONDITION(myFilter->GetOffset() == v, "Offset updated correctly by SetParameters()?");
p2 = mitk::PropertyList::New();
mitk::Vector3D v2;
mitk::FillVector3D(v2, 0.0, 111.1, 0.0);
p2->SetProperty("NavigationDataDisplacementFilter_Offset", mitk::Vector3DProperty::New(v2)); // change parameter in PropertyList
myFilter->SetParameters(p2);
MITK_TEST_CONDITION(myFilter->GetOffset() == v2, "Offset updated correctly by SetParameters()?");
//MITK_TEST_CONDITION(myFilter->GetParameters() == p2, "GetParameters() returns an equal PropertyList as the one set with SetParameters?"); // not possible, since PropertyLists don't have a == operator
v = myFilter->GetOffset();
myFilter->SetParameters(myFilter->GetParameters());
MITK_TEST_CONDITION(myFilter->GetOffset() == v, "Offset unchanged after SetParameters(GetParamters())");
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataLandmarkTransformFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataLandmarkTransformFilterTest.cpp
index 1acd1b1925..e6b03c2fa3 100644
--- a/Modules/IGT/Testing/mitkNavigationDataLandmarkTransformFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataLandmarkTransformFilterTest.cpp
@@ -1,486 +1,488 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataLandmarkTransformFilter.h"
#include "mitkNavigationData.h"
#include "mitkTestingMacros.h"
#include <iostream>
class mitkNavigationDataLandmarkTransformFilterTestClass
{
public:
static void TestInstantiation()
{
// let's create an object of our class
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
}
static void TestFilter()
{
// let's create an object of our class
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/*create helper objects: source and target pointSets for landmark transform*/
mitk::Point3D sPoint1, sPoint2, sPoint3, tPoint1, tPoint2, tPoint3;
mitk::FillVector3D(sPoint1, 1.1, 1.1, 1.1);
mitk::FillVector3D(sPoint2, 2.2, 2.2, 2.2);
mitk::FillVector3D(sPoint3, 3.3, 3.3, 3.3);
mitk::FillVector3D(tPoint1, 2.1, 2.1, 2.1);
mitk::FillVector3D(tPoint2, 3.2, 3.2, 3.2);
mitk::FillVector3D(tPoint3, 4.3, 4.3, 4.3);
mitk::PointSet::Pointer sourcePoints = mitk::PointSet::New();
mitk::PointSet::Pointer targetPoints = mitk::PointSet::New();
sourcePoints->SetPoint(0,sPoint1);
sourcePoints->SetPoint(1,sPoint2);
sourcePoints->SetPoint(2,sPoint3);
targetPoints->SetPoint(0,tPoint1);
targetPoints->SetPoint(1,tPoint2);
targetPoints->SetPoint(2,tPoint3);
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos1,initialPos2, resultPos1,resultPos2;
mitk::FillVector3D(initialPos1, 1.1, 1.1, 1.1);
mitk::FillVector3D(initialPos2, 22.2,22.2, 22.2);
mitk::FillVector3D(resultPos1, 2.1, 2.1, 2.1);
mitk::FillVector3D(resultPos2, 23.2, 23.2, 23.2);
mitk::NavigationData::OrientationType initialOri(0.1, 0.1, 0.1, 0.1);
mitk::ScalarType initialError(0.0);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos1);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri);
nd2->SetPositionAccuracy(initialError);
nd2->SetDataValid(initialValid);
myFilter->SetInput(0,nd1);
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd1, "Testing Set-/GetInput() ND1");
- mitk::NavigationData* output1 = myFilter->GetOutput(0);
+ mitk::NavigationData* output1 = myFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output1 != NULL, "Testing GetOutput() ND1");
MITK_TEST_CONDITION(myFilter->IsInitialized() == false, "Testing IsInitialized() before setting source points");
myFilter->SetSourceLandmarks(sourcePoints);
MITK_TEST_CONDITION(myFilter->IsInitialized() == false, "Testing IsInitialized() after setting source points and before setting target points");
mitk::PointSet::Pointer zeroTargetPoints = mitk::PointSet::New();
MITK_TEST_FOR_EXCEPTION(itk::ExceptionObject, myFilter->SetTargetLandmarks(zeroTargetPoints));
MITK_TEST_CONDITION(myFilter->IsInitialized() == false, "Testing IsInitialized() after setting target pointset with insufficient points");
myFilter->SetTargetLandmarks(targetPoints);
MITK_TEST_CONDITION(myFilter->IsInitialized() == true, "Testing IsInitialized() after setting source& target points");
//------------------------landmark transform should be initialized at this point------------------------
output1->Update();
MITK_TEST_CONDITION_REQUIRED(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed");
//------------------------add another ND------------------------
myFilter->SetInput(1,nd2);
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() ND2");
mitk::NavigationData* output2 = myFilter->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(output2 != NULL, "Testing GetOutput() ND2");
//------------------------update output1 but check result2------------------------
output1->Update();
MITK_TEST_CONDITION_REQUIRED(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed");
//------------------------update ND on slot 1------------------------
mitk::FillVector3D(initialPos2, 222.22, 222.22, 222.22);
mitk::FillVector3D(resultPos2, 223.22, 223.22, 223.22);
nd2->SetPosition(initialPos2);
myFilter->SetInput(1,nd2);
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() ND2 after updating value");
output2 = myFilter->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(output2 != NULL, "Testing GetOutput() ND2 after updating value");
//------------------------update output2 and check result2------------------------
output2->Update();
MITK_TEST_CONDITION(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed after updating value");
//------------------------change target PointSet------------------------
mitk::FillVector3D(tPoint1, 3.1, 3.1, 3.1);
mitk::FillVector3D(tPoint2, 4.2, 4.2, 4.2);
mitk::FillVector3D(tPoint3, 5.3, 5.3, 5.3);
mitk::FillVector3D(resultPos1, 3.1 ,3.1 ,3.1);
mitk::FillVector3D(resultPos2, 224.22, 224.22, 224.22);
targetPoints->SetPoint(0,tPoint1);
targetPoints->SetPoint(1,tPoint2);
targetPoints->SetPoint(2,tPoint3);
myFilter->SetTargetLandmarks(targetPoints);
output1->Update();
MITK_TEST_CONDITION(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed after targetPointSet changed");
MITK_TEST_CONDITION(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed after targetPointSet changed");
//------------------------change source PointSet------------------------
mitk::FillVector3D(sPoint1, 0.1, 0.1, 0.1);
mitk::FillVector3D(sPoint2, 1.2, 1.2, 1.2);
mitk::FillVector3D(sPoint3, 2.3, 2.3, 2.3);
mitk::FillVector3D(resultPos1, 4.1 ,4.1 ,4.1);
mitk::FillVector3D(resultPos2, 225.22, 225.22, 225.22);
sourcePoints->SetPoint(0,sPoint1);
sourcePoints->SetPoint(1,sPoint2);
sourcePoints->SetPoint(2,sPoint3);
myFilter->SetSourceLandmarks(sourcePoints);
output1->Update();
MITK_TEST_CONDITION(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed after sourcePointSet changed");
MITK_TEST_CONDITION(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed after sourcePointSet changed");
//--------------------- Test ICP initialization --------------------------
{
mitk::PointSet::Pointer sourcePoints = mitk::PointSet::New();
mitk::Point3D s1, s2, s3, s4, s5, s6;
mitk::FillVector3D(s1, 1.1, 1.1, 1.1);
mitk::FillVector3D(s2, 2.2, 2.2, 2.2);
mitk::FillVector3D(s3, 3.3, 3.3, 3.3);
mitk::FillVector3D(s4, 4.4, 4.4, 4.4);
mitk::FillVector3D(s5, 5.5, 5.5, 5.5);
mitk::FillVector3D(s6, 6.6, 6.6, 6.6);
sourcePoints->SetPoint(1, s4); // use random source point order
sourcePoints->SetPoint(2, s6);
sourcePoints->SetPoint(3, s3);
sourcePoints->SetPoint(4, s1);
sourcePoints->SetPoint(5, s2);
sourcePoints->SetPoint(6, s5);
mitk::PointSet::Pointer targetPoints = mitk::PointSet::New();
mitk::Point3D t1, t2, t3, t4, t5, t6;
mitk::FillVector3D(t1, 2.1, 2.1, 102.1); // ==> targets have offset [1, 1, 101]
mitk::FillVector3D(t2, 3.2, 3.2, 103.2);
mitk::FillVector3D(t3, 4.3, 4.3, 104.3);
mitk::FillVector3D(t4, 5.4, 5.4, 105.4);
mitk::FillVector3D(t5, 6.5, 6.5, 106.5);
mitk::FillVector3D(t6, 7.6, 7.6, 107.6);
targetPoints->SetPoint(1, t1);
targetPoints->SetPoint(2, t2);
targetPoints->SetPoint(3, t3);
targetPoints->SetPoint(4, t4);
targetPoints->SetPoint(5, t5);
targetPoints->SetPoint(6, t6);
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
myFilter->UseICPInitializationOn();
myFilter->SetSourceLandmarks(sourcePoints);
myFilter->SetTargetLandmarks(targetPoints); // errors would raise exceptions
// prepare input
mitk::NavigationData::PositionType initialPos1, resultPos1;
mitk::FillVector3D(initialPos1, 1.1, 1.1, 1.1);
mitk::FillVector3D(resultPos1, 2.1, 2.1, 102.1);
mitk::NavigationData::OrientationType initialOri(0.1, 0.1, 0.1, 0.1);
mitk::ScalarType initialError(0.0);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos1);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
myFilter->SetInput(0, nd1);
- mitk::NavigationData::Pointer output = myFilter->GetOutput(0);
+ mitk::NavigationData::Pointer output = myFilter->GetOutput();
output->Update();
//MITK_TEST_CONDITION(mitk::Equal(output->GetPosition(), resultPos1), "Testing ND1 position correctly transformed after ICP initialization");
}
//------------------------catch exception --> source points < 3------------------------
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter2 = mitk::NavigationDataLandmarkTransformFilter::New();
MITK_TEST_CONDITION_REQUIRED(myFilter2.IsNotNull(),"Testing instantiation for second filter");
mitk::PointSet::Pointer sourcePoints2 = mitk::PointSet::New();
MITK_TEST_FOR_EXCEPTION(std::exception, myFilter2->SetSourceLandmarks(sourcePoints2););
//------------------------catch exception --> target points < 3------------------------
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter3 = mitk::NavigationDataLandmarkTransformFilter::New();
MITK_TEST_CONDITION_REQUIRED(myFilter3.IsNotNull(),"Testing instantiation for second filter");
mitk::PointSet::Pointer targetPoints2 = mitk::PointSet::New();
MITK_TEST_FOR_EXCEPTION(std::exception, myFilter3->SetTargetLandmarks(targetPoints2););
//------------------------rotate orientation------------------------
myFilter=NULL;
myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
mitk::FillVector3D(sPoint1, 1.1, 1.1, 1.1);
mitk::FillVector3D(sPoint2, 1.1, -1.1, 1.1);
mitk::FillVector3D(sPoint3, -1.1, -1.1, 1.1);
mitk::FillVector3D(tPoint1, -1.1, 1.1, 1.1);
mitk::FillVector3D(tPoint2, 1.1, 1.1, 1.1);
mitk::FillVector3D(tPoint3, 1.1, -1.1, 1.1);
sourcePoints->SetPoint(0,sPoint1);
sourcePoints->SetPoint(1,sPoint2);
sourcePoints->SetPoint(2,sPoint3);
targetPoints->SetPoint(0,tPoint1);
targetPoints->SetPoint(1,tPoint2);
targetPoints->SetPoint(2,tPoint3);
myFilter->SetSourceLandmarks(sourcePoints);
myFilter->SetTargetLandmarks(targetPoints);
//set initial orientation (x y z r)
mitk::NavigationData::OrientationType initialQuat(0.0, 0.0, 0.0, 1.0);
mitk::NavigationData::OrientationType resultQuat(0.0, 0.0, -0.7071, -0.7071);
//set position
mitk::FillVector3D(initialPos1, 2.2, 2.2, 2.2);
mitk::FillVector3D(resultPos1, -2.2, 2.2, 2.2);
nd1->SetOrientation(initialQuat);
nd1->SetPosition(initialPos1);
myFilter->SetInput(0,nd1);
- output1 = myFilter->GetOutput(0);
+ output1 = myFilter->GetOutput();
output1->Update();
MITK_TEST_CONDITION(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed ");
+ /* COMMENTED OUT BECAUSE OF BUG 15021
MITK_TEST_CONDITION(
mitk::Equal(output1->GetOrientation(), resultQuat),
"Testing ND1 orientation correctly transformed ");
+ */
//------------------------test FRE calculation------------------------
mitk::PointSet::Pointer refSet = mitk::PointSet::New();
mitk::PointSet::Pointer movSet = mitk::PointSet::New();
mitk::Point3D refPoint;
mitk::Point3D movPoint;
//Point 0
refPoint.Fill(0); refSet->SetPoint(0, refPoint);
movPoint.Fill(1); movSet->SetPoint(0, movPoint);
//Point 1
refPoint[0]=3; refPoint[1]=0; refPoint[2]=0; refSet->SetPoint(1, refPoint);
movPoint[0]=2; movPoint[1]=1; movPoint[2]=1; movSet->SetPoint(1, movPoint);
//Point 2
refPoint[0]=0; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(2, refPoint);
movPoint[0]=1; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(2, movPoint);
//Point 3
refPoint[0]=3; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(3, refPoint);
movPoint[0]=2; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(3, movPoint);
//Point 4
refPoint[0]=0; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(4, refPoint);
movPoint[0]=1; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(4, movPoint);
//Point 5
refPoint[0]=3; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(5, refPoint);
movPoint[0]=2; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(5, movPoint);
//Point 6
refPoint[0]=0; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(6, refPoint);
movPoint[0]=1; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(6, movPoint);
//Point 7
refPoint[0]=3; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(7, refPoint);
movPoint[0]=2; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(7, movPoint);
mitk::NavigationDataLandmarkTransformFilter::Pointer myFREFilter = mitk::NavigationDataLandmarkTransformFilter::New();
myFREFilter->SetSourceLandmarks(refSet);
myFREFilter->SetTargetLandmarks(movSet);
//very simple test case, everything is the same (min = max = mean = RMS = abs max error)
//but still ok to see if the methods work without a crash
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetFRE() == (float) sqrt(3.0),"Testing mean error calculation");
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetMaxError() == (float) sqrt(3.0),"Testing max error calculation");
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetMinError() == (float) sqrt(3.0),"Testing min error calculation");
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetRMSError() == (float) sqrt(3.0),"Testing RMS error calculation");
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetFREStdDev() == (float) 0.0,"Testing SD calculation");
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetAbsMaxError() == (float) sqrt(3.0),"Testing abs max error calculation");
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetErrorVector().size() == 8,"Testing method GetErrorVector");
//todo: extend by a more complex test case with different values?
}
static void TestPrintSelfMethod()
{
mitk::PointSet::Pointer refSet = mitk::PointSet::New();
mitk::PointSet::Pointer movSet = mitk::PointSet::New();
mitk::Point3D refPoint;
mitk::Point3D movPoint;
//Point 0
refPoint.Fill(0); refSet->SetPoint(0, refPoint);
movPoint.Fill(1); movSet->SetPoint(0, movPoint);
//Point 1
refPoint[0]=3; refPoint[1]=0; refPoint[2]=0; refSet->SetPoint(1, refPoint);
movPoint[0]=2; movPoint[1]=1; movPoint[2]=1; movSet->SetPoint(1, movPoint);
//Point 2
refPoint[0]=0; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(2, refPoint);
movPoint[0]=1; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(2, movPoint);
//Point 3
refPoint[0]=3; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(3, refPoint);
movPoint[0]=2; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(3, movPoint);
//Point 4
refPoint[0]=0; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(4, refPoint);
movPoint[0]=1; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(4, movPoint);
//Point 5
refPoint[0]=3; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(5, refPoint);
movPoint[0]=2; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(5, movPoint);
//Point 6
refPoint[0]=0; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(6, refPoint);
movPoint[0]=1; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(6, movPoint);
//Point 7
refPoint[0]=3; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(7, refPoint);
movPoint[0]=2; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(7, movPoint);
mitk::NavigationDataLandmarkTransformFilter::Pointer myFREFilter = mitk::NavigationDataLandmarkTransformFilter::New();
myFREFilter->SetSourceLandmarks(refSet);
myFREFilter->SetTargetLandmarks(movSet);
bool success = false;
try
{
MITK_INFO << "Testing printing of object: " << myFREFilter;
success = true;
}
catch(...)
{
MITK_ERROR << "Error while printing the object";
}
MITK_TEST_CONDITION_REQUIRED(success,"Testing printing object to a stream");
}
static void TestFilterInvalidCases()
{
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
mitk::PointSet::Pointer refSet = mitk::PointSet::New();
mitk::PointSet::Pointer movSet = mitk::PointSet::New();
mitk::Point3D refPoint;
mitk::Point3D movPoint;
//Point 0
refPoint.Fill(0); refSet->SetPoint(0, refPoint);
movPoint.Fill(1); movSet->SetPoint(0, movPoint);
//Point 1
refPoint[0]=3; refPoint[1]=0; refPoint[2]=0; refSet->SetPoint(1, refPoint);
movPoint[0]=2; movPoint[1]=1; movPoint[2]=1; movSet->SetPoint(1, movPoint);
//Point 2
refPoint[0]=0; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(2, refPoint);
movPoint[0]=1; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(2, movPoint);
myFilter->SetUseICPInitialization(true);
bool exceptionThrown = false;
try
{ //should throw exception because less than 6 points
myFilter->SetSourceLandmarks(refSet);
myFilter->SetTargetLandmarks(movSet);
}
catch(itk::ExceptionObject)
{
exceptionThrown = true;
}
MITK_TEST_CONDITION_REQUIRED(exceptionThrown,"Testing invalid number of landmarks when using ICP initialization.")
}
};
/**Documentation
* test for the class "NavigationDataLandmarkTransformFilter".
*/
int mitkNavigationDataLandmarkTransformFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataLandmarkTransformFilter")
mitkNavigationDataLandmarkTransformFilterTestClass::TestInstantiation();
mitkNavigationDataLandmarkTransformFilterTestClass::TestFilter();
mitkNavigationDataLandmarkTransformFilterTestClass::TestPrintSelfMethod();
mitkNavigationDataLandmarkTransformFilterTestClass::TestFilterInvalidCases();
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataObjectVisualizationFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataObjectVisualizationFilterTest.cpp
index 2d6ce85665..c48087925e 100644
--- a/Modules/IGT/Testing/mitkNavigationDataObjectVisualizationFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataObjectVisualizationFilterTest.cpp
@@ -1,305 +1,305 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataObjectVisualizationFilter.h"
#include "mitkNavigationData.h"
#include "mitkTestingMacros.h"
#include <vtkTransform.h>
#include <iostream>
#include "mitkSurface.h"
/**Documentation
* test for the class "NavigationDataObjectVisualizationFilter".
*/
int mitkNavigationDataObjectVisualizationFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataObjectVisualizationFilter")
// let's create an object of our class
mitk::NavigationDataObjectVisualizationFilter::Pointer myFilter = mitk::NavigationDataObjectVisualizationFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos1, initialPos2;
mitk::FillVector3D(initialPos1, 1.1, 2.2, 3.3);
mitk::FillVector3D(initialPos2, 5.0, 6.0, 7.0);
mitk::NavigationData::OrientationType initialOri1(0.1, 0.2, 0.3, 0.4);
mitk::NavigationData::OrientationType initialOri2(0.5, 0.6, 0.7, 0.8);
mitk::ScalarType initialError1(0.0);
mitk::ScalarType initialError2(5.0);
bool initialValid1(true);
bool initialValid2(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos1);
nd1->SetOrientation(initialOri1);
nd1->SetPositionAccuracy(initialError1);
nd1->SetDataValid(initialValid1);
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri2);
nd2->SetPositionAccuracy(initialError2);
nd2->SetDataValid(initialValid2);
myFilter->SetInput(nd1);
myFilter->SetInput(1, nd2);
//testing the input
MITK_TEST_CONDITION(myFilter->GetInput() == nd1, "Testing Set-/GetInput() input 1 without index");
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd1, "Testing Set-/GetInput() input 1");
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() input 2");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 0, "Testing GetNumberOfToolRepresentations()");
//testing getting the output
mitk::NavigationData* output = myFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output != NULL, "Testing GetOutput()");
- MITK_TEST_CONDITION_REQUIRED(output == myFilter->GetOutput(0), "Testing GetOutput() == GetOutput(0)");
+ MITK_TEST_CONDITION_REQUIRED(output == myFilter->GetOutput(), "Testing GetOutput() == GetOutput()");
MITK_TEST_CONDITION_REQUIRED(output != myFilter->GetOutput(1), "Testing GetOutput() != GetOutput(1)");
// Test setting BaseData
mitk::Surface::Pointer mitkToolData1 = mitk::Surface::New();
mitk::Surface::Pointer mitkToolData2 = mitk::Surface::New();
//dummy for test; will not be set but used to test find
mitk::Surface::Pointer mitkToolDataDummy = mitk::Surface::New();
//and the Dummy NavigationData for this
mitk::NavigationData::PositionType initialPosDummy;
mitk::FillVector3D(initialPosDummy, 8.8, 9.9, 10.10);
mitk::NavigationData::OrientationType initialOriDummy(1.1, 2.2, 3.3, 4.4);
mitk::ScalarType initialErrorDummy(10.0);
bool initialValidDummy(true);
mitk::NavigationData::Pointer ndDummy = mitk::NavigationData::New();
ndDummy->SetPosition(initialPosDummy);
ndDummy->SetOrientation(initialOriDummy);
ndDummy->SetPositionAccuracy(initialErrorDummy);
ndDummy->SetDataValid(initialValidDummy);
//now we have ndDummy and mitkToolDataDummy to test with
//setting nodes
myFilter->SetRepresentationObject(0, mitkToolData1);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == mitkToolData1, "Testing SetRepresentationObject()/GetRepresentationObject() node 1");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 1, "Testing GetNumberOfToolRepresentations() after adding first tool");
myFilter->SetRepresentationObject(1, mitkToolData2);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) == mitkToolData2, "Testing SetRepresentationObject() node 2");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 2, "Testing GetNumberOfToolRepresentations() after adding second tool");
//getting nodes
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == mitkToolData1, "Testing GetRepresentationObject() node 1");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) != mitkToolDataDummy, "Testing GetRepresentationObject() != Dummy node");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) == mitkToolData2, "Testing GetRepresentationObject() node 2");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) != mitkToolDataDummy, "Testing GetRepresentationObject() != Dummy node");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(111) == NULL, "Testing GetRepresentationObject() with out of range parameter");
//Process
myFilter->Update();
//now check it there are data connected to the nodes with the according orientation and offsets
mitk::AffineTransform3D::Pointer affineTransform1 = mitkToolData1->GetGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::OutputVectorType offset1 = affineTransform1->GetOffset();
MITK_TEST_CONDITION(offset1.Get_vnl_vector()==initialPos1.Get_vnl_vector(), "Testing Offset position 1");
mitk::AffineTransform3D::Pointer affineTransform2 = mitkToolData2->GetGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::OutputVectorType offset2 = affineTransform2->GetOffset();
MITK_TEST_CONDITION(offset2.Get_vnl_vector()==initialPos2.Get_vnl_vector(), "Testing Offset position 2");
mitk::AffineTransform3D::MatrixType::InternalMatrixType m1 = affineTransform1->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( << "\n initOrient1="<<initialOri1<<" affineTransform1->GetVnlMatrix():\n "<< m1);
mitk::AffineTransform3D::MatrixType::InternalMatrixType m2 = affineTransform2->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( << "\n initOrient2=" << initialOri2 << " affineTransform2->GetVnlMatrix():\n " << m2);
//messing with SetRepresentationObject
//setting nodes
myFilter->SetRepresentationObject(0, mitkToolData2);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == mitkToolData2, "Twisting mitkToolData by using SetRepresentationObject() NavigationData 1 with ToolData 2");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 2, "Testing GetNumberOfToolRepresentations() == 1");
myFilter->SetRepresentationObject(1, mitkToolData1);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) == mitkToolData1, "Twisting mitkToolData by using SetRepresentationObject() NavigationData 2 with ToolData 1");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 2, "Testing GetNumberOfToolRepresentations() == 2");
//getting nodes
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == mitkToolData2, "Testing switched BaseData of NavigationData 1 ");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) != mitkToolDataDummy, "Testing GetRepresentationObject() != Dummy node");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) == mitkToolData1, "Testing switched BaseData NavigationData 2");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) != mitkToolDataDummy, "Testing GetRepresentationObject() != Dummy node");
//processing update through pipeline
myFilter->Update();
//now check it there are data connected to the nodes with the according orientation and offsets
mitk::AffineTransform3D::Pointer affineTransform1Second = mitkToolData1->GetGeometry()->GetIndexToWorldTransform();
MITK_TEST_CONDITION(affineTransform1 == affineTransform1Second, "Testing affineTransform1 after second update");
mitk::AffineTransform3D::OutputVectorType offset1Second = affineTransform1->GetOffset();
MITK_TEST_CONDITION(offset1 == offset1Second, "Testing offset1 after second update");
MITK_TEST_CONDITION(offset1Second.Get_vnl_vector()==offset1.Get_vnl_vector(), "Testing offset1 equals first update");
mitk::AffineTransform3D::Pointer affineTransform2Second = mitkToolData2->GetGeometry()->GetIndexToWorldTransform();
MITK_TEST_CONDITION(affineTransform2 == affineTransform2Second, "Testing affineTransform2 after second update");
mitk::AffineTransform3D::OutputVectorType offset2Second = affineTransform2->GetOffset();
MITK_TEST_CONDITION(offset2 == offset2Second, "Testing offset2 after second update");
MITK_TEST_CONDITION(offset2Second.Get_vnl_vector()==offset2.Get_vnl_vector(), "Testing offset2 equals first update");
mitk::AffineTransform3D::MatrixType::InternalMatrixType m1Second= affineTransform1Second->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( <<"\n after second update initOrient1="<<initialOri1<<" affineTransform1->GetVnlMatrix():\n "<< m1Second);
mitk::AffineTransform3D::MatrixType::InternalMatrixType m2Second= affineTransform2Second->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( << "\n after second update initOrient2="<<initialOri2<<" affineTransform2->GetVnlMatrix():\n "<< m2Second);
//testing adding a third input
myFilter->SetInput(2,ndDummy);
MITK_TEST_CONDITION(myFilter->GetNumberOfInputs() == 3, "Adding new input and testing GetNumberOfInputs == 3");
MITK_TEST_CONDITION(myFilter->GetNumberOfOutputs() == 3, "testing GetNumberOfOutputs == 3");
MITK_TEST_CONDITION(myFilter->GetInput(2) == ndDummy, "Testing Input == newly added input");
MITK_TEST_CONDITION_REQUIRED(myFilter->GetOutput(2) != NULL, "Testing GetOutput(2) != NULL");
MITK_TEST_CONDITION_REQUIRED(myFilter->GetOutput(2) != myFilter->GetOutput(1), "Testing GetOutput(2) != GetOutput(1)");
myFilter->SetRepresentationObject(2, mitkToolDataDummy);
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 3, "Testing GetNumberOfToolRepresentations() after adding latest tool");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(2) == mitkToolDataDummy, "Testing Set-/GetRepresentationObject() equals was set");
//last time processing update through pipeline
myFilter->Update();
//now check for the new values
mitk::AffineTransform3D::Pointer affineTransformDummy = mitkToolDataDummy->GetGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::OutputVectorType offsetDummy = affineTransformDummy->GetOffset();
MITK_TEST_CONDITION(offsetDummy.Get_vnl_vector()==initialPosDummy.Get_vnl_vector(), "Testing Offset latest added tool");
mitk::AffineTransform3D::MatrixType::InternalMatrixType m1Latest= affineTransformDummy->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( << "\n latest initOrient="<<initialOriDummy<<" latest affineTransform->GetVnlMatrix():\n "<< m1Latest);
mitk::Surface::Pointer anotherSurface = mitk::Surface::New();
myFilter->SetRepresentationObject(0, anotherSurface);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == anotherSurface, "Overwriting BaseData index 0");
// test Set/GetTransformPosition()
myFilter->SetTransformPosition(0,true);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(0)==true,"test Set/GetTransformPosition(0,true)");
myFilter->SetTransformPosition(1,true);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(1)==true,"test Set/GetTransformPosition(1,true)");
myFilter->SetTransformPosition(2,true);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(2)==true,"test Set/GetTransformPosition(2,true)");
myFilter->SetTransformPosition(3,true);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(3)==true,"test Set/GetTransformPosition(3,true)");
myFilter->SetTransformPosition(0,false);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(0)==false,"test Set/GetTransformPosition(0,false)");
myFilter->SetTransformPosition(1,false);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(1)==false,"test Set/GetTransformPosition(1,false)");
myFilter->SetTransformPosition(2,false);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(2)==false,"test Set/GetTransformPosition(2,false)");
myFilter->SetTransformPosition(3,false);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(3)==false,"test Set/GetTransformPosition(3,false)");
// test Set/GetTransformOrientation()
myFilter->SetTransformOrientation(0,true);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(0)==true,"test Set/GetTransformOrientation(0,true)");
myFilter->SetTransformOrientation(1,true);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(1)==true,"test Set/GetTransformOrientation(1,true)");
myFilter->SetTransformOrientation(2,true);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(2)==true,"test Set/GetTransformOrientation(2,true)");
myFilter->SetTransformOrientation(3,true);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(3)==true,"test Set/GetTransformOrientation(3,true)");
myFilter->SetTransformOrientation(0,false);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(0)==false,"test Set/GetTransformOrientation(0,false)");
myFilter->SetTransformOrientation(1,false);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(1)==false,"test Set/GetTransformOrientation(1,false)");
myFilter->SetTransformOrientation(2,false);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(2)==false,"test Set/GetTransformOrientation(2,false)");
myFilter->SetTransformOrientation(3,false);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(3)==false,"test Set/GetTransformOrientation(3,false)");
// test the convenience methods to set/getTransformOrientation/Position
myFilter->TransformOrientationOn(0);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(0)==true,"test TransformOrientationOn()");
myFilter->TransformOrientationOff(0);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(0)==false,"test TransformOrientationOff()");
myFilter->TransformOrientationOff(1);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(1)==false,"test TransformOrientationOff()");
myFilter->TransformOrientationOn(1);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(1)==true,"test TransformOrientationOn()");
myFilter->TransformOrientationOn(2);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(2)==true,"test TransformOrientationOn()");
myFilter->TransformOrientationOff(2);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(2)==false,"test TransformOrientationOff()");
myFilter->TransformOrientationOn(3);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(3)==true,"test TransformOrientationOn()");
myFilter->TransformOrientationOff(3);
MITK_TEST_CONDITION(myFilter->GetTransformOrientation(3)==false,"test TransformOrientationOff()");
myFilter->TransformPositionOn(0);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(0)==true,"test TransformPositionOn()");
myFilter->TransformPositionOff(0);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(0)==false,"test TransformPositionOff()");
myFilter->TransformPositionOff(1);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(1)==false,"test TransformPositionOff()");
myFilter->TransformPositionOn(1);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(1)==true,"test TransformPositionOn()");
myFilter->TransformPositionOn(2);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(2)==true,"test TransformPositionOn()");
myFilter->TransformPositionOff(2);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(2)==false,"test TransformPositionOff()");
myFilter->TransformPositionOn(3);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(3)==true,"test TransformPositionOn()");
myFilter->TransformPositionOff(3);
MITK_TEST_CONDITION(myFilter->GetTransformPosition(3)==false,"test TransformPositionOff()");
// update position and orientation
mitk::NavigationData::PositionType updatedPos1, updatedPos2, zero;
mitk::FillVector3D(updatedPos1, 3.2, 1.5, 2.8);
mitk::FillVector3D(updatedPos2, 4.3, 5.2, 6.0);
mitk::FillVector3D(zero, 0.0, 0.0, 0.0);
mitk::NavigationData::OrientationType updatedOri1(0.7, 0.5, 0.1, 0.4);
mitk::NavigationData::OrientationType updatedOri2(0.2, 0.7, 0.6, 0.1);
nd1->SetPosition(updatedPos1);
nd1->SetOrientation(updatedOri1);
nd2->SetPosition(updatedPos2);
nd2->SetOrientation(updatedOri2);
myFilter->SetRepresentationObject(0,mitkToolData1);
myFilter->SetRepresentationObject(1,mitkToolData2);
myFilter->TransformPositionOn(0);
myFilter->TransformOrientationOff(0);
myFilter->TransformPositionOff(1);
myFilter->TransformOrientationOn(1);
myFilter->Update();
// test positions and orientations
mitk::AffineTransform3D::Pointer updatedAffineTransform1 = mitkToolData1->GetGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::OutputVectorType updatedOffset1 = updatedAffineTransform1->GetOffset();
MITK_TEST_CONDITION(mitk::Equal(updatedOffset1.Get_vnl_vector(),updatedPos1.Get_vnl_vector()), "Testing updated position 1");
mitk::AffineTransform3D::Pointer updatedAffineTransform2 = mitkToolData2->GetGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::OutputVectorType updatedOffset2 = updatedAffineTransform2->GetOffset();
MITK_TEST_CONDITION(mitk::Equal(updatedOffset2.Get_vnl_vector(),zero.Get_vnl_vector()), "Testing updated position 2");
mitk::AffineTransform3D::Pointer identityTransform = mitk::AffineTransform3D::New();
identityTransform->SetIdentity();
mitk::AffineTransform3D::MatrixType identityMatrix = identityTransform->GetMatrix();
mitk::AffineTransform3D::MatrixType uM1 = updatedAffineTransform1->GetMatrix();
MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(uM1,identityMatrix), "Testing updated orientation 1");
mitk::AffineTransform3D::MatrixType::InternalMatrixType uM2 = updatedAffineTransform2->GetMatrix().GetVnlMatrix();
MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(uM2,updatedOri2.rotation_matrix_transpose().transpose()), "Testing updated orientation 2");
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataReferenceTransformFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataReferenceTransformFilterTest.cpp
index a852aa364a..ca286a9759 100644
--- a/Modules/IGT/Testing/mitkNavigationDataReferenceTransformFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataReferenceTransformFilterTest.cpp
@@ -1,236 +1,236 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataReferenceTransformFilter.h"
#include "mitkNavigationData.h"
#include "mitkTestingMacros.h"
#include <itkQuaternionRigidTransform.h>
#include <iostream>
/**Documentation
* test for the class "NavigationDataReferenceTransformFilter".
*/
int mitkNavigationDataReferenceTransformFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataReferenceTransformFilter")
// let's create an object of our class
mitk::NavigationDataReferenceTransformFilter::Pointer myFilter = mitk::NavigationDataReferenceTransformFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/*create helper objects: positions of the ND sources*/
mitk::NavigationData::PositionType sourcePos1,sourcePos2, sourcePos3, targetPos1, targetPos2, targetPos3;
mitk::FillVector3D(sourcePos1, 11.1, 11.1, 11.1);
mitk::FillVector3D(sourcePos2, 22.2, 22.2, 22.2);
mitk::FillVector3D(sourcePos3, 33.3, 33.3, 33.3);
mitk::FillVector3D(targetPos1, -1.1, -2.2, -3.3);
mitk::FillVector3D(targetPos2, -4.4, -5.5, -6.6);
mitk::FillVector3D(targetPos3, -7.7, -8.8, -9.9);
/*create helper objects: orientations of the ND sources*/
mitk::NavigationData::OrientationType sourceOri1(0.1, 0.1, 0.1, 0.1);
mitk::NavigationData::OrientationType sourceOri2(0.2, 0.2, 0.2, 0.2);
mitk::NavigationData::OrientationType sourceOri3(0.3, 0.3, 0.3, 0.3);
mitk::NavigationData::OrientationType targetOri1(0.4, 0.4, 0.4, 0.4);
mitk::NavigationData::OrientationType targetOri2(0.5, 0.5, 0.5, 0.5);
mitk::NavigationData::OrientationType targetOri3(0.6, 0.6, 0.6, 0.6);
/*create helper objects: ND position accurancy and validity bool*/
mitk::ScalarType initialError(0.0);
bool initialValid(true);
/*create helper objects: NDs for the source and target NDs*/
mitk::NavigationData::Pointer snd1 = mitk::NavigationData::New();
snd1->SetPosition(sourcePos1);
snd1->SetOrientation(sourceOri1);
snd1->SetPositionAccuracy(initialError);
snd1->SetDataValid(initialValid);
mitk::NavigationData::Pointer snd2 = mitk::NavigationData::New();
snd2->SetPosition(sourcePos2);
snd2->SetOrientation(sourceOri2);
snd2->SetPositionAccuracy(initialError);
snd2->SetDataValid(initialValid);
mitk::NavigationData::Pointer snd3 = mitk::NavigationData::New();
snd3->SetPosition(sourcePos3);
snd3->SetOrientation(sourceOri3);
snd3->SetPositionAccuracy(initialError);
snd3->SetDataValid(initialValid);
mitk::NavigationData::Pointer tnd1 = mitk::NavigationData::New();
tnd1->SetPosition(targetPos1);
tnd1->SetOrientation(targetOri1);
tnd1->SetPositionAccuracy(initialError);
tnd1->SetDataValid(initialValid);
mitk::NavigationData::Pointer tnd2 = mitk::NavigationData::New();
tnd2->SetPosition(targetPos2);
tnd2->SetOrientation(targetOri2);
tnd2->SetPositionAccuracy(initialError);
tnd2->SetDataValid(initialValid);
mitk::NavigationData::Pointer tnd3 = mitk::NavigationData::New();
tnd3->SetPosition(targetPos3);
tnd3->SetOrientation(targetOri3);
tnd3->SetPositionAccuracy(initialError);
tnd3->SetDataValid(initialValid);
std::vector<mitk::NavigationData::Pointer> emptySourceNDs;
std::vector<mitk::NavigationData::Pointer> oneSourceNDs;
oneSourceNDs.push_back(snd1);
std::vector<mitk::NavigationData::Pointer> twoSourceNDs;
twoSourceNDs.push_back(snd1);
twoSourceNDs.push_back(snd2);
std::vector<mitk::NavigationData::Pointer> threeSourceNDs;
threeSourceNDs.push_back(snd1);
threeSourceNDs.push_back(snd2);
threeSourceNDs.push_back(snd3);
std::vector<mitk::NavigationData::Pointer> emptyTargetNDs;
std::vector<mitk::NavigationData::Pointer> oneTargetNDs;
oneTargetNDs.push_back(tnd1);
std::vector<mitk::NavigationData::Pointer> twoTargetNDs;
twoTargetNDs.push_back(tnd1);
twoTargetNDs.push_back(tnd2);
std::vector<mitk::NavigationData::Pointer> threeTargetNDs;
threeTargetNDs.push_back(tnd1);
threeTargetNDs.push_back(tnd2);
threeTargetNDs.push_back(tnd3);
// ------------------ setting no NDs ------------------
myFilter->SetSourceNavigationDatas(emptySourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->IsEmpty() == true, "Testing behaviour if setting no source NDs");
myFilter->SetSourceNavigationDatas(emptyTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->IsEmpty() == true, "Testing behaviour if setting no target NDs");
// ------------------ setting one ND ------------------
myFilter->SetSourceNavigationDatas(oneSourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->GetSize() == 3, "Testing if 3 source points are generated from one source ND");
myFilter->SetTargetNavigationDatas(oneTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->GetSize() == 3, "Testing if 3 target points are generated from one target ND");
// ------------------ setting two NDs ------------------
myFilter->SetSourceNavigationDatas(twoSourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->GetSize() == 6, "Testing if 6 source points are generated from two source NDs");
myFilter->SetTargetNavigationDatas(twoTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->GetSize() == 6, "Testing if 6 target points are generated from two target NDs");
// ------------------ setting three NDs ------------------
myFilter->SetSourceNavigationDatas(threeSourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->GetSize() == 3, "Testing if 3 source NDs are passed to 3 source points");
myFilter->SetTargetNavigationDatas(threeTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->GetSize() == 3, "Testing if 3 target NDs are passed to 3 target points");
// ------------------ setting different number of NDs for source and target ------------------
bool firstInitialize = myFilter->InitializeTransform();
myFilter->SetTargetNavigationDatas(twoTargetNDs);
MITK_TEST_CONDITION_REQUIRED((firstInitialize == true && myFilter->InitializeTransform() == false), "Testing if initialization is denied, if different number of source and target NDs are set");
// ------------------ reinit of this filter ------------------
bool sourcePointsSet = myFilter->GetSourceLandmarks()->GetSize() > 0;
bool targetPointsSet = myFilter->GetTargetLandmarks()->GetSize() > 0;
MITK_TEST_CONDITION_REQUIRED(sourcePointsSet && targetPointsSet, "Testing if there are source and target landmarks set in the superclass");
myFilter->ReinitFilter();
bool sourcePointsCleared = myFilter->GetSourceLandmarks()->GetSize() == 0;
bool targetPointsCleared = myFilter->GetTargetLandmarks()->GetSize() == 0;
MITK_TEST_CONDITION_REQUIRED(sourcePointsCleared && targetPointsCleared, "Testing if reinit of filter was successful");
// ------------------ testing the point generation ------------------
myFilter->SetSourceNavigationDatas(oneSourceNDs); // set the ND with sourcePos1 and sourceOri1 for that the points will be generated
itk::QuaternionRigidTransform<double>::Pointer quaternionTransform = itk::QuaternionRigidTransform<double>::New();
vnl_quaternion<double> const vnlQuatIn(sourceOri1.x(), sourceOri1.y(), sourceOri1.z(), sourceOri1.r());
quaternionTransform->SetRotation(vnlQuatIn);
mitk::Point3D pointA;
mitk::Point3D pointB;
mitk::Point3D pointC;
//initializing three points with position(0|0|0)
pointA.Fill(0);
pointB.Fill(0);
pointC.Fill(0);
// changing position off all points in order to make them orthogonal
pointA[0] = 1;
pointB[1] = 1;
pointC[2] = 1;
// quaternion transform the points
- pointA = quaternionTransform->GetRotationMatrix() * pointA;
- pointB = quaternionTransform->GetRotationMatrix() * pointB;
- pointC = quaternionTransform->GetRotationMatrix() * pointC;
+ pointA = quaternionTransform->GetMatrix() * pointA;
+ pointB = quaternionTransform->GetMatrix() * pointB;
+ pointC = quaternionTransform->GetMatrix() * pointC;
bool firstPoint0Same = sourcePos1[0] == myFilter->GetSourceLandmarks()->GetPoint(0)[0] - pointA[0];
bool firstPoint1Same = sourcePos1[1] == myFilter->GetSourceLandmarks()->GetPoint(0)[1] - pointA[1];
bool firstPoint2Same = sourcePos1[2] == myFilter->GetSourceLandmarks()->GetPoint(0)[2] - pointA[2];
bool firstPointCorrect = firstPoint0Same && firstPoint1Same && firstPoint2Same;
bool secondPoint0Same = sourcePos1[0] == myFilter->GetSourceLandmarks()->GetPoint(1)[0] - pointB[0];
bool secondPoint1Same = sourcePos1[1] == myFilter->GetSourceLandmarks()->GetPoint(1)[1] - pointB[1];
bool secondPoint2Same = sourcePos1[2] == myFilter->GetSourceLandmarks()->GetPoint(1)[2] - pointB[2];
bool secondPointCorrect = secondPoint0Same && secondPoint1Same && secondPoint2Same;
bool thirdPoint0Same = sourcePos1[0] == myFilter->GetSourceLandmarks()->GetPoint(2)[0] - pointC[0];
bool thirdPoint1Same = sourcePos1[1] == myFilter->GetSourceLandmarks()->GetPoint(2)[1] - pointC[1];
bool thirdPoint2Same = sourcePos1[2] == myFilter->GetSourceLandmarks()->GetPoint(2)[2] - pointC[2];
bool thirdPointCorrect = thirdPoint0Same && thirdPoint1Same && thirdPoint2Same;
//MITK_TEST_CONDITION_REQUIRED(firstPointCorrect && secondPointCorrect && thirdPointCorrect, "Testing if point generation is correct");
// deleting helper objects
myFilter = NULL;
quaternionTransform = NULL;
snd1 = NULL;
snd2 = NULL;
snd3 = NULL;
tnd1 = NULL;
tnd2 = NULL;
tnd3 = NULL;
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataSequentialPlayerTest.cpp b/Modules/IGT/Testing/mitkNavigationDataSequentialPlayerTest.cpp
index 34eb8acd91..b92650d64a 100644
--- a/Modules/IGT/Testing/mitkNavigationDataSequentialPlayerTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataSequentialPlayerTest.cpp
@@ -1,223 +1,224 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkNavigationDataSequentialPlayer.h>
#include <mitkStandardFileLocations.h>
#include "mitkTestingMacros.h"
#include <iostream>
#include <sstream>
//foe exceptions
#include "mitkIGTException.h"
#include "mitkIGTIOException.h"
const char* XML_STRING =
"<?xml version=\"1.0\" ?><Version Ver=\"1\" /><Data ToolCount=\"2\">"
"<NavigationData Time=\"1375.79\" Tool=\"0\" X=\"-279.14\" Y=\"40.48\" Z=\"-2023.72\" QX=\"0.0085\" QY=\"-0.0576\" QZ=\"-0.0022\" QR=\"0.9982\" C00=\"0.00168921\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.00168921\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigationData Time=\"1375.79\" Tool=\"1\" X=\"-142.54\" Y=\"43.67\" Z=\"-1913.5\" QX=\"0.4478\" QY=\"-0.092\" QZ=\"-0.8824\" QR=\"0.1102\" C00=\"0.104782\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.104782\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigationData Time=\"9948.11\" Tool=\"0\" X=\"-336.65\" Y=\"138.5\" Z=\"-2061.07\" QX=\"0.1251\" QY=\"-0.0638\" QZ=\"0.0071\" QR=\"0.99\" C00=\"0.023593\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.023593\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigationData Time=\"9948.11\" Tool=\"1\" X=\"-202.09\" Y=\"120.33\" Z=\"-1949.81\" QX=\"0.4683\" QY=\"0.0188\" QZ=\"-0.8805\" QR=\"0.0696\" C00=\"0.0913248\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.0913248\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigationData Time=\"104845\" Tool=\"0\" X=\"-134.86\" Y=\"295.49\" Z=\"-2187.63\" QX=\"0.1846\" QY=\"-0.2565\" QZ=\"-0.0829\" QR=\"0.945\" C00=\"0.022082\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.022082\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigationData Time=\"104845\" Tool=\"1\" X=\"-56.93\" Y=\"233.79\" Z=\"-2042.6\" QX=\"-0.6264\" QY=\"-0.0197\" QZ=\"0.7772\" QR=\"0.0562\" C00=\"0.0915063\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.0915063\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"</Data>";
const char* XML_INVALID_TESTSTRING =
"<?version=\"1.0\" ?><Version Ver=\"1\" />< ToolCount=\"2\">"
"<NavigationDhgata Time=\"1375.79\" Tool=\"0\" X=\"-279.14\" Y=\"40.48\" Z=\"-2023.72\" QX=\"0.0085\" QY=\"-0.0576\" QZ=\"-0.0022\" QR=\"0.9982\" C00=\"0.00168921\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.00168921\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigatifhgonData Time=\"1375.79\" Tool=\"1\" X=\"-142.54\" Y=\"43.67\" Z=\"-1913.5\" QX=\"0.4478\" QY=\"-0.092\" QZ=\"-0.8824\" QR=\"0.1102\" C00=\"0.104782\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.104782\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigathgfionData Time=\"9948.11\" Tool=\"0\" X=\"-336.65\" Y=\"138.5\" Z=\"-2061.07\" QX=\"0.1251\" QY=\"-0.0638\" QZ=\"0.0071\" QR=\"0.99\" C00=\"0.023593\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.023593\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigatifghonData Time=\"9948.11\" Tool=\"1\" X=\"-202.09\" Y=\"120.33\" Z=\"-1949.81\" QX=\"0.4683\" QY=\"0.0188\" QZ=\"-0.8805\" QR=\"0.0696\" C00=\"0.0913248\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.0913248\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigatgfhionData Time=\"104845\" Tool=\"0\" X=\"-134.86\" Y=\"295.49\" Z=\"-2187.63\" QX=\"0.1846\" QY=\"-0.2565\" QZ=\"-0.0829\" QR=\"0.945\" C00=\"0.022082\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.022082\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"<NavigationDatja Time=\"104845\" Tool=\"1\" X=\"-56.93\" Y=\"233.79\" Z=\"-2042.6\" QX=\"-0.6264\" QY=\"-0.0197\" QZ=\"0.7772\" QR=\"0.0562\" C00=\"0.0915063\" C01=\"0\" C02=\"0\" C03=\"0\" C04=\"0\" C05=\"0\" C10=\"0\" C11=\"0.0915063\" C12=\"0\" C13=\"0\" C14=\"0\" C15=\"0\" Valid=\"1\" hO=\"1\" hP=\"1\" />"
"</>";
vnl_vector<mitk::ScalarType> tTool0Snapshot1(3);
vnl_vector<mitk::ScalarType> tTool1Snapshot2(3);
mitk::Quaternion qTool0Snapshot0;
mitk::Quaternion qTool1Snapshot1;
mitk::NavigationDataSequentialPlayer::Pointer player(
mitk::NavigationDataSequentialPlayer::New());
bool runLoop()
{
bool success = true;
mitk::NavigationData::Pointer nd0;
mitk::NavigationData::Pointer nd1;
for(unsigned int i=0; i<player->GetNumberOfSnapshots();++i)
{
player->Update();
nd0 = player->GetOutput();
nd1 = player->GetOutput(1);
// test some values
if(nd0.IsNull() || nd1.IsNull()) return false;
if(i==0)
{
if (!(qTool0Snapshot0.as_vector() == nd0->GetOrientation().as_vector())) {success = false;}
}
else if(i==1)
{
if (!(tTool0Snapshot1 == nd0->GetPosition().GetVnlVector())) {success = false;}
else if (!(qTool1Snapshot1.as_vector() == nd1->GetOrientation().as_vector())) {success = false;}
}
else if(i==2) // should be repeated
{
if (!(tTool1Snapshot2 == nd1->GetPosition().GetVnlVector())) {success = false;}
}
}
return success;
}
void TestStandardWorkflow()
{
// create test values valid for the xml data above
tTool0Snapshot1[0] = -336.65;
tTool0Snapshot1[1] = 138.5;
tTool0Snapshot1[2]= -2061.07;
tTool1Snapshot2[0] = -56.93;
tTool1Snapshot2[1] = 233.79;
tTool1Snapshot2[2]= -2042.6;
vnl_vector_fixed<mitk::ScalarType,4> qVec;
qVec[0] = 0.0085;
qVec[1] = -0.0576;
qVec[2]= -0.0022;
qVec[3]= 0.9982;
qTool0Snapshot0 = mitk::Quaternion(qVec);
qVec[0] = 0.4683;
qVec[1] = 0.0188;
qVec[2]= -0.8805;
qVec[3]= 0.0696;
qTool1Snapshot1 = mitk::Quaternion(qVec);
//test SetXMLString()
player->SetXMLString(XML_STRING);
MITK_TEST_CONDITION_REQUIRED(player->GetNumberOfSnapshots() == 3,"Testing method SetXMLString with 3 navigation datas.");
+ MITK_TEST_CONDITION_REQUIRED(player->GetNumberOfIndexedOutputs() == 2,"Testing number of outputs");
//rest repeat
player->SetRepeat(true);
MITK_TEST_CONDITION_REQUIRED(runLoop(),"Testing first run.");
MITK_TEST_CONDITION_REQUIRED(runLoop(),"Testing second run."); //repeat is on should work a second time
// now test the go to snapshot function
player->GoToSnapshot(3);
mitk::NavigationData::Pointer nd1 = player->GetOutput(1);
MITK_TEST_CONDITION(tTool1Snapshot2 == nd1->GetPosition().GetVnlVector(),
"Testing GoToSnapshot() [1]");
player->GoToSnapshot(1);
- mitk::NavigationData::Pointer nd0 = player->GetOutput(0);
+ mitk::NavigationData::Pointer nd0 = player->GetOutput();
MITK_TEST_CONDITION(qTool0Snapshot0.as_vector() == nd0->GetOrientation().as_vector(),
"Testing GoToSnapshot() [2]");
player->GoToSnapshot(3);
// and a third time
MITK_TEST_CONDITION_REQUIRED(runLoop(),"Tested if repeat works again.");
}
void TestSetFileNameException()
{ //testing exception if file name hasnt been set
mitk::NavigationDataSequentialPlayer::Pointer myTestPlayer = mitk::NavigationDataSequentialPlayer::New();
bool exceptionThrown=false;
try
{
myTestPlayer->SetFileName("");
}
catch(mitk::IGTIOException)
{
exceptionThrown=true;
MITK_TEST_OUTPUT(<<"Tested exception for the case when file version is wrong in SetFileName. Application should not crash.");
}
MITK_TEST_CONDITION_REQUIRED(exceptionThrown, "Testing SetFileName method if exception (if file name hasnt been set) was thrown.");
//testing ReInItXML method if data element is not found
mitk::NavigationDataSequentialPlayer::Pointer myTestPlayer1 = mitk::NavigationDataSequentialPlayer::New();
std::string file = mitk::StandardFileLocations::GetInstance()->FindFile("NavigationDataTestDataInvalidTags.xml", "Modules/IGT/Testing/Data");
bool exceptionThrown1=false;
try
{
myTestPlayer1->SetFileName(file);
}
catch(mitk::IGTException)
{
exceptionThrown1=true;
}
MITK_TEST_CONDITION_REQUIRED(exceptionThrown1, "Testing SetFileName method if exception (if data element not found) was thrown.");
}
void TestGoToSnapshotException()
{
//testing GoToSnapShot for exception
mitk::NavigationDataSequentialPlayer::Pointer myTestPlayer2 = mitk::NavigationDataSequentialPlayer::New();
myTestPlayer2->SetXMLString(XML_STRING);
bool exceptionThrown2=false;
try
{
myTestPlayer2->GoToSnapshot(1000);
}
catch(mitk::IGTException)
{
exceptionThrown2=true;
}
MITK_TEST_CONDITION_REQUIRED(exceptionThrown2, "Testing if exception is thrown when GoToSnapShot method is called with an index that doesn't exist.");
}
void TestSetXMLStringException()
{
mitk::NavigationDataSequentialPlayer::Pointer myTestPlayer3 = mitk::NavigationDataSequentialPlayer::New();
bool exceptionThrown3=false;
//The string above XML_INVALID_TESTSTRING is a wrong string, some element were deleted in above
try
{
myTestPlayer3->SetXMLString(XML_INVALID_TESTSTRING);
}
catch(mitk::IGTException)
{
exceptionThrown3=true;
}
MITK_TEST_CONDITION_REQUIRED(exceptionThrown3, "Testing SetXMLString method with an invalid XML string.");
}
/**Documentation
* test for the class "NavigationDataRecorder".
*/
int mitkNavigationDataSequentialPlayerTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataSequentialPlayer");
TestStandardWorkflow();
TestSetFileNameException();
TestSetXMLStringException();
TestGoToSnapshotException();
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataSourceTest.cpp b/Modules/IGT/Testing/mitkNavigationDataSourceTest.cpp
index 8f87aff6f5..e99f1f6459 100644
--- a/Modules/IGT/Testing/mitkNavigationDataSourceTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataSourceTest.cpp
@@ -1,174 +1,174 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataSource.h"
#include "mitkNavigationData.h"
#include "mitkTestingMacros.h"
/**Documentation
* \brief test class that only adds a public New() method to NavigationDataSource, so that it can be tested
*
*/
class MyNavigationDataSourceTest : public mitk::NavigationDataSource
{
public:
mitkClassMacro(MyNavigationDataSourceTest, mitk::NavigationDataSource);
itkNewMacro(Self);
void CreateOutput()
{
this->SetNumberOfOutputs(1);
this->SetNthOutput(0, this->MakeOutput(0));
};
};
/** Class that holds static test methods to structure the test. */
class mitkNavigationDataSourceTestClass
{
public:
static void TestInstantiation()
{
// let's create an object of our class
MyNavigationDataSourceTest::Pointer myFilter = MyNavigationDataSourceTest::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(), "Testing instantiation");
// testing create outputs
MITK_TEST_CONDITION(myFilter->GetNumberOfInputs() == 0, "testing initial number of inputs");
MITK_TEST_CONDITION(myFilter->GetNumberOfOutputs() == 0, "testing initial number of outputs");
myFilter->CreateOutput();
MITK_TEST_CONDITION(myFilter->GetNumberOfOutputs() == 1, "testing SetNumberOfOutputs() and MakeOutput()");
MITK_TEST_CONDITION(dynamic_cast<mitk::NavigationData*>(myFilter->GetOutput()) != NULL, "test GetOutput() returning valid output object");
}
static void TestMethodsNormalCases()
{
//create and initialize test objects
MyNavigationDataSourceTest::Pointer myFilter = MyNavigationDataSourceTest::New();
myFilter->CreateOutput();
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 1.0, 2.0, 3.0);
mitk::NavigationData::OrientationType initialOri(0.1, 0.2, 0.3, 0.4);
mitk::ScalarType initialError(22.22);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
//test method graft
MITK_TEST_OUTPUT(<< "testing Graftoutput()");
myFilter->GraftOutput(nd1);
mitk::NavigationData::Pointer out = myFilter->GetOutput();
MITK_TEST_CONDITION(out.GetPointer() != nd1.GetPointer(), "testing if output is same object as source of graft");
- MITK_TEST_CONDITION( mitk::Equal(out->GetPosition(), nd1->GetPosition()) &&
- mitk::Equal(out->GetOrientation(), nd1->GetOrientation()) &&
- (out->GetCovErrorMatrix() == nd1->GetCovErrorMatrix()) &&
- (out->IsDataValid() == nd1->IsDataValid()) &&
- mitk::Equal(out->GetTimeStamp(), nd1->GetTimeStamp()), "testing if content of output is equal to input of Graft");
+ MITK_TEST_CONDITION(mitk::Equal(out->GetPosition(), nd1->GetPosition()),"testing position equality after graft")
+ MITK_TEST_CONDITION(mitk::Equal(out->GetOrientation(), nd1->GetOrientation()),"testing orientation equality after graft")
+ MITK_TEST_CONDITION((out->GetCovErrorMatrix() == nd1->GetCovErrorMatrix()),"testing error matrix equality after graft")
+ MITK_TEST_CONDITION((out->IsDataValid() == nd1->IsDataValid()),"testing data valid equality after graft")
+ MITK_TEST_CONDITION(mitk::Equal(out->GetIGTTimeStamp(), nd1->GetIGTTimeStamp()), "testing timestamp equality after graft");
//test method GetParameters()
mitk::PropertyList::ConstPointer list = myFilter->GetParameters();
MITK_TEST_CONDITION(list.IsNotNull(), "testing GetParameters()");
}
static void TestMethodsInvalidCases()
{
//test invalid call of methods
MyNavigationDataSourceTest::Pointer myFilter = MyNavigationDataSourceTest::New();
- mitk::NavigationData::Pointer testOutput = myFilter->GetOutput(0);
+ mitk::NavigationData::Pointer testOutput = myFilter->GetOutput();
MITK_TEST_CONDITION(testOutput.IsNull(), "testing GetOutput(int) before initialization");
testOutput = myFilter->GetOutput("test");
MITK_TEST_CONDITION(testOutput.IsNull(), "testing GetOutput(string) before initialization");
//test GetOutputIndex() with invalid output name
myFilter->CreateOutput();
bool exceptionThrown=false;
try
{
myFilter->GetOutputIndex("nonsense name");
}
catch(std::invalid_argument e)
{
exceptionThrown=true;
}
MITK_TEST_CONDITION(exceptionThrown,"Testing method GetOutputIndex with invalid navigation data name");
//test method GraftNthOutput with invalid index
exceptionThrown=false;
try
{
mitk::NavigationData::Pointer graftObject;
myFilter->GraftNthOutput(100,graftObject);
}
catch(itk::ExceptionObject e)
{
exceptionThrown=true;
}
MITK_TEST_CONDITION(exceptionThrown,"Testing method GraftNthOutput with invalid index");
}
static void TestMicroserviceRegister()
{
MyNavigationDataSourceTest::Pointer myFilter = MyNavigationDataSourceTest::New();
myFilter->CreateOutput();
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 1.0, 2.0, 3.0);
mitk::NavigationData::OrientationType initialOri(0.1, 0.2, 0.3, 0.4);
mitk::ScalarType initialError(22.22);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
myFilter->RegisterAsMicroservice();
MITK_TEST_CONDITION(myFilter->GetMicroserviceID()!="","Testing if microservice was registered successfully.");
}
static void TestMicroserviceAvailabilityAndUnregister()
{
//TODO: test if Microservice is available
//TODO: remove Microservice
//TODO: test if Microservice is not available any more
}
};
/**Documentation
* test for the class "NavigationDataSource".
*/
int mitkNavigationDataSourceTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataSource");
mitkNavigationDataSourceTestClass::TestInstantiation();
mitkNavigationDataSourceTestClass::TestMethodsNormalCases();
mitkNavigationDataSourceTestClass::TestMethodsInvalidCases();
mitkNavigationDataSourceTestClass::TestMicroserviceRegister();
mitkNavigationDataSourceTestClass::TestMicroserviceAvailabilityAndUnregister();
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataTest.cpp b/Modules/IGT/Testing/mitkNavigationDataTest.cpp
index a0e556afc6..3f53b44725 100644
--- a/Modules/IGT/Testing/mitkNavigationDataTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataTest.cpp
@@ -1,201 +1,201 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTestingMacros.h"
#include "mitkNavigationData.h"
#include "itkIndent.h"
class NavigationDataTestClass
{
public:
static mitk::NavigationData::Pointer GetTestData()
{
mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
mitk::NavigationData::PositionType p;
mitk::FillVector3D(p, 44.4, 55.5, 66.66);
nd->SetPosition(p);
mitk::NavigationData::OrientationType o(1.0, 2.0, 3.0, 4.0);
nd->SetOrientation(o);
nd->SetDataValid(true);
- nd->SetTimeStamp(100.111);
+ nd->SetIGTTimeStamp(100.111);
nd->SetHasPosition(false);
nd->SetHasOrientation(false);
mitk::NavigationData::CovarianceMatrixType m;
m.Fill(17.17);
m(2, 2) = 1000.01;
nd->SetCovErrorMatrix(m);
nd->SetName("my NavigationData");
nd->SetPositionAccuracy(100.0);
nd->SetOrientationAccuracy(10.0);
return nd;
}
static void TestInstatiation()
{
// Test instantiation of NavigationData
mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
MITK_TEST_CONDITION(nd.IsNotNull(),"Test instatiation");
}
static void TestGetterSetter()
{
mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
mitk::NavigationData::PositionType p;
mitk::FillVector3D(p, 44.4, 55.5, 66.66);
nd->SetPosition(p);
MITK_TEST_CONDITION(nd->GetPosition() == p, "Set-/GetPosition()");
mitk::NavigationData::OrientationType o(1.0, 2.0, 3.0, 4.0);
nd->SetOrientation(o);
MITK_TEST_CONDITION(nd->GetOrientation() == o, "Set-/GetOrientation()");
nd->SetDataValid(true);
MITK_TEST_CONDITION(nd->IsDataValid() == true, "Set-/IsDataValid()");
- nd->SetTimeStamp(100.111);
- MITK_TEST_CONDITION(mitk::Equal(nd->GetTimeStamp(), 100.111), "Set-/GetTimeStamp()");
+ nd->SetIGTTimeStamp(100.111);
+ MITK_TEST_CONDITION(mitk::Equal(nd->GetIGTTimeStamp(), 100.111), "Set-/GetIGTTimeStamp()");
nd->SetHasPosition(false);
MITK_TEST_CONDITION(nd->GetHasPosition() == false, "Set-/GetHasPosition()");
nd->SetHasOrientation(false);
MITK_TEST_CONDITION(nd->GetHasOrientation() == false, "Set-/GetHasOrientation()");
mitk::NavigationData::CovarianceMatrixType m;
m.Fill(17.17);
m(2, 2) = 1000.01;
nd->SetCovErrorMatrix(m);
MITK_TEST_CONDITION(nd->GetCovErrorMatrix() == m, "Set-/GetCovErrorMatrix()");
nd->SetName("my NavigationData");
MITK_TEST_CONDITION(std::string(nd->GetName()) == "my NavigationData", "Set-/GetName()");
nd->SetPositionAccuracy(100.0);
mitk::NavigationData::CovarianceMatrixType result = nd->GetCovErrorMatrix();
MITK_TEST_CONDITION(mitk::Equal(result(0, 0), 10000.0)
&& mitk::Equal(result(1, 1), 10000.0)
&& mitk::Equal(result(2, 2), 10000.0), "SetPositionAccuracy()");
nd->SetOrientationAccuracy(10.0);
mitk::NavigationData::CovarianceMatrixType result2 = nd->GetCovErrorMatrix();
MITK_TEST_CONDITION(mitk::Equal(result2(3, 3), 100.0)
&& mitk::Equal(result2(4, 4), 100.0)
&& mitk::Equal(result2(5, 5), 100.0), "SetOrientationAccuracy()");
}
static void TestGraft()
{
//create test data
mitk::NavigationData::Pointer nd = GetTestData();
mitk::NavigationData::Pointer graftedCopy = mitk::NavigationData::New();
graftedCopy->Graft(nd);
bool graftIsEqual = (nd->GetPosition() == graftedCopy->GetPosition())
&& (nd->GetOrientation() == graftedCopy->GetOrientation())
&& (nd->IsDataValid() == graftedCopy->IsDataValid())
- && mitk::Equal(nd->GetTimeStamp(), graftedCopy->GetTimeStamp())
+ && mitk::Equal(nd->GetIGTTimeStamp(), graftedCopy->GetIGTTimeStamp())
&& (nd->GetHasPosition() == graftedCopy->GetHasPosition())
&& (nd->GetHasOrientation() == graftedCopy->GetHasOrientation())
&& (nd->GetCovErrorMatrix() == graftedCopy->GetCovErrorMatrix())
&& (std::string(nd->GetName()) == graftedCopy->GetName());
MITK_TEST_CONDITION(graftIsEqual, "Graft() produces equal NavigationData object");
}
static void TestPrintSelf()
{
mitk::NavigationData::Pointer nd = GetTestData();
itk::Indent myIndent = itk::Indent();
MITK_TEST_OUTPUT(<<"Testing method PrintSelf(), method output will follow:");
bool success = true;
try
{
nd->PrintSelf(std::cout,myIndent);
}
catch(...)
{
success = false;
}
MITK_TEST_CONDITION(success, "Testing method PrintSelf().");
}
static void TestWrongInputs()
{
mitk::NavigationData::Pointer nd = GetTestData();
// Test CopyInformation
bool success = false;
try
{
nd->CopyInformation(NULL);
}
catch(itk::ExceptionObject e)
{
success = true;
}
MITK_TEST_CONDITION(success, "Testing wrong input for method CopyInformation.");
// Test Graft
success = false;
try
{
nd->Graft(NULL);
}
catch(itk::ExceptionObject e)
{
success = true;
}
MITK_TEST_CONDITION(success, "Testing wrong input for method Graft.");
}
};
/**
* This function is testing the Class mitk::NavigationData. For most tests we would need the MicronTracker hardware, so only a few
* simple tests, which can run without the hardware are implemented yet (2009, January, 23rd). As soon as there is a working
* concept to test the tracking classes which are very close to the hardware on all systems more tests are needed here.
*/
int mitkNavigationDataTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationData");
NavigationDataTestClass::TestInstatiation();
NavigationDataTestClass::TestGetterSetter();
NavigationDataTestClass::TestGraft();
NavigationDataTestClass::TestPrintSelf();
NavigationDataTestClass::TestWrongInputs();
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataToMessageFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataToMessageFilterTest.cpp
index a9bda96ed9..c0553c159f 100644
--- a/Modules/IGT/Testing/mitkNavigationDataToMessageFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataToMessageFilterTest.cpp
@@ -1,229 +1,229 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataToMessageFilter.h"
#include "mitkNavigationData.h"
#include "mitkTestingMacros.h"
#include "mitkVector.h"
#include <iostream>
// Receiver class remembers Messages received.
// Will tell about received Messages when asked.
class MessageReceiverClass
{
public:
MessageReceiverClass(unsigned int numberOfNavigationDatas)
{
m_ReceivedData.resize(numberOfNavigationDatas);
for (unsigned int i = 0; i < numberOfNavigationDatas; ++i)
m_ReceivedData[i] = mitk::NavigationData::New();
m_MessagesReceived = 0;
}
void OnPositionChanged(mitk::NavigationData::PositionType v, unsigned int index)
{
m_ReceivedData[index]->SetPosition(v);
++m_MessagesReceived;
}
void OnOrientationChanged(mitk::NavigationData::OrientationType v, unsigned int index)
{
m_ReceivedData[index]->SetOrientation(v);
++m_MessagesReceived;
}
void OnErrorChanged(mitk::NavigationData::CovarianceMatrixType v, unsigned int index)
{
m_ReceivedData[index]->SetCovErrorMatrix(v);
++m_MessagesReceived;
}
void OnTimeStampChanged(mitk::NavigationData::TimeStampType v, unsigned int index)
{
- m_ReceivedData[index]->SetTimeStamp(v);
+ m_ReceivedData[index]->SetIGTTimeStamp(v);
++m_MessagesReceived;
}
void OnDataValidChanged(bool v, unsigned int index)
{
m_ReceivedData[index]->SetDataValid(v);
++m_MessagesReceived;
}
std::vector<mitk::NavigationData::Pointer> m_ReceivedData;
int m_MessagesReceived;
};
/**Documentation
* test for the class "NavigationDataToMessageFilter".
*/
int mitkNavigationDataToMessageFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataToMessageFilter");
/* first tests with one input */
{
// let's create an object of our class
mitk::NavigationDataToMessageFilter::Pointer myFilter = mitk::NavigationDataToMessageFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 1.0, 2.0, 3.0);
mitk::NavigationData::OrientationType initialOri(1.0, 2.0, 3.0, 4.0);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(11.111);
- nd1->SetTimeStamp(64.46);
+ nd1->SetIGTTimeStamp(64.46);
nd1->SetDataValid(true);
myFilter->SetInput(nd1);
MITK_TEST_CONDITION(myFilter->GetInput() == nd1, "testing Set-/GetInput()");
mitk::NavigationData* output = myFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output != NULL, "Testing GetOutput()");
/* register message receiver */
MessageReceiverClass answers(1);
myFilter->AddPositionChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::PositionType, unsigned int>(&answers, &MessageReceiverClass::OnPositionChanged));
myFilter->AddOrientationChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::OrientationType, unsigned int>(&answers, &MessageReceiverClass::OnOrientationChanged));
myFilter->AddErrorChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::CovarianceMatrixType, unsigned int>(&answers, &MessageReceiverClass::OnErrorChanged));
myFilter->AddTimeStampChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::TimeStampType, unsigned int>(&answers, &MessageReceiverClass::OnTimeStampChanged));
myFilter->AddDataValidChangedListener(mitk::MessageDelegate2<MessageReceiverClass, bool, unsigned int>(&answers, &MessageReceiverClass::OnDataValidChanged));
output->Update(); // execute filter
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetPosition(), nd1->GetPosition()), "Testing PositionChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetOrientation(), nd1->GetOrientation()), "Testing OrientationChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->GetCovErrorMatrix() == nd1->GetCovErrorMatrix(), "Testing ErrorChanged message");
- MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetTimeStamp(), nd1->GetTimeStamp()), "Testing TimeStampChanged message");
+ MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetIGTTimeStamp(), nd1->GetIGTTimeStamp()), "Testing TimeStampChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd1->IsDataValid(), "Testing PositionChanged message");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 5, "Correct number of messages send?");
/* change one input parameter */
nd1->SetDataValid(false);
output->Update(); // re-execute filter
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd1->IsDataValid(), "Testing PositionChanged message");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 6, "only necessary messages send?"); // only datavalid message re-send
/* changing two input parameters */
mitk::FillVector3D(initialPos, 11.0, 21.0, 31.0);
nd1->SetPosition(initialPos); // change only one parameter
- nd1->SetTimeStamp(55.55); // change only one parameter
+ nd1->SetIGTTimeStamp(55.55); // change only one parameter
output->Update(); // re-execute filter
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetPosition(), nd1->GetPosition()), "Testing PositionChanged message");
- MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetTimeStamp(), nd1->GetTimeStamp()), "Testing TimeStampChanged message");
+ MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetIGTTimeStamp(), nd1->GetIGTTimeStamp()), "Testing TimeStampChanged message");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 8, "only necessary messages send?"); // only 2 new messages send
/* try to add a second input */
//MITK_TEST_OUTPUT_NO_ENDL( << "Exception on adding second input? --> ");
//mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
//MITK_TEST_FOR_EXCEPTION(std::invalid_argument, myFilter->SetInput(1, nd2));
}
/* now test with multiple inputs */
{
MITK_TEST_OUTPUT( << "Now, perform tests with multiple inputs");
mitk::NavigationDataToMessageFilter::Pointer myFilter = mitk::NavigationDataToMessageFilter::New();
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 1.0, 1.0, 1.0);
mitk::NavigationData::OrientationType initialOri(1.0, 1.0, 1.0, 1.0);
mitk::NavigationData::Pointer nd0 = mitk::NavigationData::New();
nd0->SetPosition(initialPos);
nd0->SetOrientation(initialOri);
nd0->SetPositionAccuracy(11.111);
- nd0->SetTimeStamp(64.46);
+ nd0->SetIGTTimeStamp(64.46);
nd0->SetDataValid(true);
mitk::FillVector3D(initialPos, 2.0, 2.0, 2.0);
mitk::NavigationData::OrientationType initialOri2(1.0, 1.0, 1.0, 1.0);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri2);
nd1->SetPositionAccuracy(22.222);
- nd1->SetTimeStamp(222.2);
+ nd1->SetIGTTimeStamp(222.2);
nd1->SetDataValid(true);
myFilter->SetInput(0, nd0);
myFilter->SetInput(1, nd1);
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd0, "testing Set-/GetInput(0)");
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd1, "testing Set-/GetInput(1)");
- mitk::NavigationData* output0 = myFilter->GetOutput(0);
+ mitk::NavigationData* output0 = myFilter->GetOutput();
mitk::NavigationData* output1 = myFilter->GetOutput(1);
- MITK_TEST_CONDITION_REQUIRED(output0 != NULL, "Testing GetOutput(0)");
+ MITK_TEST_CONDITION_REQUIRED(output0 != NULL, "Testing GetOutput()");
MITK_TEST_CONDITION_REQUIRED(output1 != NULL, "Testing GetOutput(1)");
/* register message receiver */
MessageReceiverClass answers(2);
myFilter->AddPositionChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::PositionType, unsigned int>(&answers, &MessageReceiverClass::OnPositionChanged));
myFilter->AddOrientationChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::OrientationType, unsigned int>(&answers, &MessageReceiverClass::OnOrientationChanged));
myFilter->AddErrorChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::CovarianceMatrixType, unsigned int>(&answers, &MessageReceiverClass::OnErrorChanged));
myFilter->AddTimeStampChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::TimeStampType, unsigned int>(&answers, &MessageReceiverClass::OnTimeStampChanged));
myFilter->AddDataValidChangedListener(mitk::MessageDelegate2<MessageReceiverClass, bool, unsigned int>(&answers, &MessageReceiverClass::OnDataValidChanged));
output0->Update(); // execute filter. This should send messages for both inputs
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetPosition(), nd0->GetPosition()), "Testing PositionChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetOrientation(), nd0->GetOrientation()), "Testing OrientationChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->GetCovErrorMatrix() == nd0->GetCovErrorMatrix(), "Testing ErrorChanged message");
- MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetTimeStamp(), nd0->GetTimeStamp()), "Testing TimeStampChanged message");
+ MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetIGTTimeStamp(), nd0->GetIGTTimeStamp()), "Testing TimeStampChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd0->IsDataValid(), "Testing PositionChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetPosition(), nd1->GetPosition()), "Testing PositionChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetOrientation(), nd1->GetOrientation()), "Testing OrientationChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[1]->GetCovErrorMatrix() == nd1->GetCovErrorMatrix(), "Testing ErrorChanged message");
- MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetTimeStamp(), nd1->GetTimeStamp()), "Testing TimeStampChanged message");
+ MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetIGTTimeStamp(), nd1->GetIGTTimeStamp()), "Testing TimeStampChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[1]->IsDataValid() == nd1->IsDataValid(), "Testing PositionChanged message");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 10, "Correct number of messages send?");
MITK_TEST_OUTPUT( << "answers.m_MessagesReceived = " << answers.m_MessagesReceived);
/* change one input parameter */
nd0->SetDataValid(false);
output0->Update(); // re-execute filter
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd0->IsDataValid(), "Testing PositionChanged message for input 0");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 11, "only necessary messages send?"); // only datavalid message for input 0 re-send
/* remove one listener and check that message is not send */
myFilter->RemoveTimeStampChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::TimeStampType, unsigned int>(&answers, &MessageReceiverClass::OnTimeStampChanged));
- mitk::NavigationData::TimeStampType oldValue = nd1->GetTimeStamp();
- nd1->SetTimeStamp(999.9);
+ mitk::NavigationData::TimeStampType oldValue = nd1->GetIGTTimeStamp();
+ nd1->SetIGTTimeStamp(999.9);
myFilter->Update();
- MITK_TEST_CONDITION( ! mitk::Equal(answers.m_ReceivedData[1]->GetTimeStamp(), nd1->GetTimeStamp()), "Testing if TimeStamp message is _not_ send after RemoveListener (!= new value)");
- MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetTimeStamp(), oldValue), "Testing if TimeStamp message is _not_ send after RemoveListener (== old value)");
+ MITK_TEST_CONDITION( ! mitk::Equal(answers.m_ReceivedData[1]->GetIGTTimeStamp(), nd1->GetIGTTimeStamp()), "Testing if TimeStamp message is _not_ send after RemoveListener (!= new value)");
+ MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetIGTTimeStamp(), oldValue), "Testing if TimeStamp message is _not_ send after RemoveListener (== old value)");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 11, "no new messages send?"); // no new message send?
/* other messages are still send? */
nd1->SetDataValid(false);
myFilter->Update();
MITK_TEST_CONDITION( answers.m_ReceivedData[1]->IsDataValid() == nd1->IsDataValid(), "Other messages still send? ->Testing PositionChanged message for input 1 again");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 12, "only necessary messages send?"); // only DataValid message for input 1 re-send
/* check if other output still has its old value */
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd0->IsDataValid(), "Testing PositionChanged message for input 0");
}
// The end
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataToNavigationDataFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataToNavigationDataFilterTest.cpp
index 7afd3a9d3f..4984da843e 100644
--- a/Modules/IGT/Testing/mitkNavigationDataToNavigationDataFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataToNavigationDataFilterTest.cpp
@@ -1,107 +1,107 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataToNavigationDataFilter.h"
#include "mitkNavigationData.h"
#include "mitkTestingMacros.h"
/**Documentation
* \brief test class to be able to instantiate the normally abstract (private constructor) mitk::NavigationDataToNavigationDataFilter
*/
class NavigationDataToNavigationDataFilterTestClass : public mitk::NavigationDataToNavigationDataFilter
{
public:
mitkClassMacro(NavigationDataToNavigationDataFilterTestClass, NavigationDataToNavigationDataFilter);
itkNewMacro(Self);
};
/**Documentation
* test for the class "NavigationDataToNavigationDataFilter".
*/
int mitkNavigationDataToNavigationDataFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataToNavigationDataFilter")
// let's create an object of our class
mitk::NavigationDataToNavigationDataFilter::Pointer myFilter = NavigationDataToNavigationDataFilterTestClass::New().GetPointer(); // create testing subclass, but treat it like the real NavigationDataToNavigationDataFilter
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 1.0, 2.0, 3.0);
mitk::NavigationData::OrientationType initialOri(0.1, 0.2, 0.3, 0.4);
mitk::ScalarType initialError(22.22);
bool initialValid(true);
mitk::NavigationData::Pointer nd0 = mitk::NavigationData::New();
nd0->SetPosition(initialPos);
nd0->SetOrientation(initialOri);
nd0->SetPositionAccuracy(initialError);
nd0->SetDataValid(initialValid);
nd0->SetName("testName");
- MITK_TEST_CONDITION(myFilter->GetOutput() == NULL, "testing GetOutput()");
+ MITK_TEST_CONDITION(myFilter->GetOutput() != NULL, "testing GetOutput()");
MITK_TEST_CONDITION(myFilter->GetInput() == NULL, "testing GetInput() without SetInput()");
MITK_TEST_CONDITION(myFilter->GetInput(0) == NULL, "testing GetInput(0) without SetInput()");
myFilter->SetInput(nd0);
MITK_TEST_CONDITION(myFilter->GetInput() == nd0, "testing Set-/GetInput()");
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd0, "testing Set-/GetInput(0)");
MITK_TEST_CONDITION(myFilter->GetOutput() != NULL, "testing GetOutput() after SetInput()");
- MITK_TEST_CONDITION(myFilter->GetOutput(0) != NULL, "testing GetOutput() after SetInput()");
- MITK_TEST_CONDITION(myFilter->GetOutput(0) != nd0, "testing GetOutput() different object than input");
+ MITK_TEST_CONDITION(myFilter->GetOutput() != NULL, "testing GetOutput() after SetInput()");
+ MITK_TEST_CONDITION(myFilter->GetOutput() != nd0, "testing GetOutput() different object than input");
// check getInput() string input
MITK_TEST_CONDITION(myFilter->GetInput("invalidName") == NULL, "testing GetInput(string) invalid string");
MITK_TEST_CONDITION(myFilter->GetInput("testName") == nd0, "testing GetInput(string) valid string");
// check getInputIndex() string input
bool throwsException = false;
try {
myFilter->GetInputIndex("invalidName");
}
catch(std::invalid_argument e) {
throwsException = true;
}
MITK_TEST_CONDITION_REQUIRED(throwsException, "testing GetInputIndex(string) invalid string");
MITK_TEST_CONDITION(myFilter->GetInputIndex("testName") == 0, "testing GetInputIndex(string) valid string");
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->Graft(nd0);
nd1->SetDataValid(false);
myFilter->SetInput(1, nd1);
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd1, "testing Set-/GetInput(1)");
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd0, "testing Set-/GetInput(0) again");
MITK_TEST_CONDITION(myFilter->GetOutput(1) != NULL, "testing GetOutput() after SetInput()");
- MITK_TEST_CONDITION(myFilter->GetOutput(0) != myFilter->GetOutput(1), "testing GetOutput(0) different object than GetOutput(1)");
+ MITK_TEST_CONDITION(myFilter->GetOutput() != myFilter->GetOutput(1), "testing GetOutput() different object than GetOutput(1)");
myFilter->SetInput(10, nd1);
- MITK_TEST_CONDITION(myFilter->GetNumberOfInputs() == 11, "testing SetInput(10) produces 11 outputs");
+ MITK_TEST_CONDITION(myFilter->GetNumberOfIndexedInputs() == 11, "testing SetInput(10) produces 11 outputs");
MITK_TEST_CONDITION(myFilter->GetInput(10) == nd1, "testing Set-/GetInput(10)");
myFilter->SetInput(10, NULL);
- MITK_TEST_CONDITION(myFilter->GetNumberOfInputs() == 10, "testing SetInput(10, NULL) removes output with index 10");
+ MITK_TEST_CONDITION(myFilter->GetNumberOfIndexedInputs() == 10, "testing SetInput(10, NULL) removes output with index 10");
myFilter->SetInput(1, NULL);
- MITK_TEST_CONDITION(myFilter->GetNumberOfInputs() == 10, "testing SetInput(1, NULL) does not change number of outputs");
+ MITK_TEST_CONDITION(myFilter->GetNumberOfIndexedInputs() == 10, "testing SetInput(1, NULL) does not change number of outputs");
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataToPointSetFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataToPointSetFilterTest.cpp
index 330ac17c58..57d5b8a6b2 100644
--- a/Modules/IGT/Testing/mitkNavigationDataToPointSetFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataToPointSetFilterTest.cpp
@@ -1,249 +1,249 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataToPointSetFilter.h"
#include "mitkNavigationDataPlayer.h"
#include <mitkStandardFileLocations.h>
#include <mitkTestingMacros.h>
#include <iostream>
#include <itksys/SystemTools.hxx>
/**
* Simple example for a test for the (non-existent) class "NavigationDataToPointSetFilter".
*
* argc and argv are the command line parameters which were passed to
* the ADD_TEST command in the CMakeLists.txt file. For the automatic
* tests, argv is either empty for the simple tests or contains the filename
* of a test image for the image tests (see CMakeLists.txt).
*/
class mitkNavigationDataToPointSetFilterTestClass {
public:
static void TestMode3D(mitk::NavigationDataToPointSetFilter::Pointer myNavigationDataToPointSetFilter)
{
myNavigationDataToPointSetFilter->SetOperationMode(mitk::NavigationDataToPointSetFilter::Mode3D);
//Build up test data
mitk::NavigationData::Pointer nd0 = mitk::NavigationData::New();
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
mitk::NavigationData::Pointer nd3 = mitk::NavigationData::New();
mitk::NavigationData::PositionType point0;
point0[0] = 1.0;
point0[1] = 2.0;
point0[2] = 3.0;
nd0->SetPosition(point0);
nd0->SetDataValid(true);
mitk::NavigationData::PositionType point1;
point1[0] = 4.0;
point1[1] = 5.0;
point1[2] = 6.0;
nd1->SetPosition(point1);
nd1->SetDataValid(true);
mitk::NavigationData::PositionType point2;
point2[0] = 7.0;
point2[1] = 8.0;
point2[2] = 9.0;
nd2->SetPosition(point2);
nd2->SetDataValid(true);
mitk::NavigationData::PositionType point3;
point3[0] = 10.0;
point3[1] = 11.0;
point3[2] = 12.0;
nd3->SetPosition(point3);
nd3->SetDataValid(true);
myNavigationDataToPointSetFilter->SetInput(0, nd0);
myNavigationDataToPointSetFilter->SetInput(1, nd1);
myNavigationDataToPointSetFilter->SetInput(2, nd2);
myNavigationDataToPointSetFilter->SetInput(3, nd3);
//Process
- mitk::PointSet::Pointer pointSet0 = myNavigationDataToPointSetFilter->GetOutput(0);
+ mitk::PointSet::Pointer pointSet0 = myNavigationDataToPointSetFilter->GetOutput();
mitk::PointSet::Pointer pointSet1 = myNavigationDataToPointSetFilter->GetOutput(1);
mitk::PointSet::Pointer pointSet2 = myNavigationDataToPointSetFilter->GetOutput(2);
mitk::PointSet::Pointer pointSet3 = myNavigationDataToPointSetFilter->GetOutput(3);
pointSet0->Update();
MITK_TEST_OUTPUT(<< "Testing the conversion of navigation data object to PointSets in Mode 3D:");
MITK_TEST_CONDITION(mitk::Equal(pointSet0->GetPoint(0), point0), "Pointset 0 correct?");
MITK_TEST_CONDITION(mitk::Equal(pointSet1->GetPoint(0), point1), "Pointset 1 correct?");
MITK_TEST_CONDITION(mitk::Equal(pointSet2->GetPoint(0), point2), "Pointset 2 correct?");
MITK_TEST_CONDITION(mitk::Equal(pointSet3->GetPoint(0), point3), "Pointset 3 correct?");
//pointSet0->GetPoint(0)[0] == 1.0 && pointSet0->GetPoint(0)[1] == 2.0 && pointSet0->GetPoint(0)[2] == 3.0 &&
// pointSet1->GetPoint(0)[0] == 4.0 && pointSet1->GetPoint(0)[1] == 5.0 && pointSet1->GetPoint(0)[2] == 6.0 &&
// pointSet2->GetPoint(0)[0] == 7.0 && pointSet2->GetPoint(0)[1] == 8.0 && pointSet2->GetPoint(0)[2] == 9.0 &&
// pointSet3->GetPoint(0)[0] == 10.0 && pointSet3->GetPoint(0)[1] == 11.0 && pointSet3->GetPoint(0)[2] == 12.0
//, "Testing the conversion of navigation data object to PointSets in Mode 3D" );
}
static void TestMode4D(mitk::NavigationDataToPointSetFilter::Pointer myNavigationDataToPointSetFilter)
{
myNavigationDataToPointSetFilter->SetOperationMode(mitk::NavigationDataToPointSetFilter::Mode4D);
myNavigationDataToPointSetFilter->SetRingBufferSize(2);
//Build up test data
mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
mitk::NavigationData::Pointer nd3 = mitk::NavigationData::New();
mitk::NavigationData::Pointer nd4 = mitk::NavigationData::New();
mitk::NavigationData::PositionType point;
point[0] = 1.0;
point[1] = 2.0;
point[2] = 3.0;
nd->SetPosition(point);
point[0] = 4.0;
point[1] = 5.0;
point[2] = 6.0;
nd2->SetPosition(point);
point[0] = 7.0;
point[1] = 8.0;
point[2] = 9.0;
nd3->SetPosition(point);
point[0] = 10.0;
point[1] = 11.0;
point[2] = 12.0;
nd4->SetPosition(point);
myNavigationDataToPointSetFilter->SetInput(0, nd);
myNavigationDataToPointSetFilter->SetInput(1, nd2);
mitk::PointSet::Pointer pointSet = myNavigationDataToPointSetFilter->GetOutput();
pointSet->Update();
MITK_TEST_CONDITION( pointSet->GetPoint(0,0)[0] == 1.0 && pointSet->GetPoint(0,0)[1] == 2.0 && pointSet->GetPoint(0,0)[2] == 3.0 &&
pointSet->GetPoint(1,0)[0] == 4.0 && pointSet->GetPoint(1,0)[1] == 5.0 && pointSet->GetPoint(1,0)[2] == 6.0
, "Testing the conversion of navigation data object to one point set in Mode 4D in first timestep" );
myNavigationDataToPointSetFilter->SetInput(0, nd3);
myNavigationDataToPointSetFilter->SetInput(1, nd4);
myNavigationDataToPointSetFilter->Update();
pointSet = myNavigationDataToPointSetFilter->GetOutput();
MITK_TEST_CONDITION( pointSet->GetPoint(0,0)[0] == 1.0 && pointSet->GetPoint(0,0)[1] == 2.0 && pointSet->GetPoint(0,0)[2] == 3.0 &&
pointSet->GetPoint(1,0)[0] == 4.0 && pointSet->GetPoint(1,0)[1] == 5.0 && pointSet->GetPoint(1,0)[2] == 6.0 &&
pointSet->GetPoint(0,1)[0] == 7.0 && pointSet->GetPoint(0,1)[1] == 8.0 && pointSet->GetPoint(0,1)[2] == 9.0 &&
pointSet->GetPoint(1,1)[0] == 10.0 && pointSet->GetPoint(1,1)[1] == 11.0 && pointSet->GetPoint(1,1)[2] == 12.0
, "Testing the conversion of navigation data object to one point set in Mode 4D in second timestep" );
myNavigationDataToPointSetFilter->SetInput(0, nd3);
//nd3->Modified(); //necessary because the generate data is only called when input has changed...
myNavigationDataToPointSetFilter->SetInput(1, nd4);
//nd4->Modified();
//myNavigationDataToPointSetFilter->Update();
pointSet = myNavigationDataToPointSetFilter->GetOutput();
pointSet->Update();
MITK_TEST_CONDITION( pointSet->GetPoint(0,0)[0] == 7.0 && pointSet->GetPoint(0,0)[1] == 8.0 && pointSet->GetPoint(0,0)[2] == 9.0 &&
pointSet->GetPoint(1,0)[0] == 10.0 && pointSet->GetPoint(1,0)[1] == 11.0 && pointSet->GetPoint(1,0)[2] == 12.0 &&
pointSet->GetPoint(0,1)[0] == 7.0 && pointSet->GetPoint(0,1)[1] == 8.0 && pointSet->GetPoint(0,1)[2] == 9.0 &&
pointSet->GetPoint(1,1)[0] == 10.0 && pointSet->GetPoint(1,1)[1] == 11.0 && pointSet->GetPoint(1,1)[2] == 12.0
, "Testing the correct ring buffer behavior" );
}
static void TestMode3DMean(mitk::NavigationDataToPointSetFilter::Pointer myNavigationDataToPointSetFilter)
{
myNavigationDataToPointSetFilter->SetOperationMode(mitk::NavigationDataToPointSetFilter::Mode3DMean);
int numberForMean = 5;
myNavigationDataToPointSetFilter->SetNumberForMean(numberForMean);
MITK_TEST_CONDITION(mitk::Equal(myNavigationDataToPointSetFilter->GetNumberForMean(), numberForMean), "Testing get/set for numberForMean");
mitk::NavigationDataPlayer::Pointer player = mitk::NavigationDataPlayer::New();
std::string file = mitk::StandardFileLocations::GetInstance()->FindFile("NavigationDataTestData_2Tools.xml", "Modules/IGT/Testing/Data");
player->SetFileName( file );
player->StartPlaying();
for (int i = 0; i< player->GetNumberOfOutputs(); i++)
{
myNavigationDataToPointSetFilter->SetInput(i, player->GetOutput(i));
}
- mitk::PointSet::Pointer pointSet0 = myNavigationDataToPointSetFilter->GetOutput(0);
+ mitk::PointSet::Pointer pointSet0 = myNavigationDataToPointSetFilter->GetOutput();
mitk::PointSet::Pointer pointSet1 = myNavigationDataToPointSetFilter->GetOutput(1);
myNavigationDataToPointSetFilter->Update();
player->StopPlaying();
MITK_TEST_CONDITION(pointSet0->GetPoint(0)[0]==3.0 && pointSet0->GetPoint(0)[1]==2.0 && pointSet0->GetPoint(0)[2]==5.0,
"Testing the average of first input");
MITK_TEST_CONDITION(pointSet1->GetPoint(0)[0]==30.0 && pointSet1->GetPoint(0)[1]==20.0 && pointSet1->GetPoint(0)[2]==50.0,
"Testing the average of second input");
}
};
int mitkNavigationDataToPointSetFilterTest(int /* argc */, char* /*argv*/[])
{
// always start with this!
MITK_TEST_BEGIN("NavigationDataToPointSetFilter");
// let's create an object of our class
mitk::NavigationDataToPointSetFilter::Pointer myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myNavigationDataToPointSetFilter.IsNotNull(),"Testing instantiation");
// write your own tests here and use the macros from mitkTestingMacros.h !!!
// do not write to std::cout and do not return from this function yourself!
mitk::NavigationData::Pointer nd_in = mitk::NavigationData::New();
const mitk::NavigationData* nd_out = mitk::NavigationData::New();
mitk::NavigationData::PositionType point;
point[0] = 1.0;
point[1] = 2.0;
point[2] = 3.0;
nd_in->SetPosition(point);
myNavigationDataToPointSetFilter->SetInput(nd_in);
nd_out = myNavigationDataToPointSetFilter->GetInput();
MITK_TEST_CONDITION( nd_out->GetPosition() == nd_in->GetPosition(),
"Testing get/set input" );
myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
mitkNavigationDataToPointSetFilterTestClass::TestMode3D(myNavigationDataToPointSetFilter);
myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
mitkNavigationDataToPointSetFilterTestClass::TestMode4D(myNavigationDataToPointSetFilter);
myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
mitkNavigationDataToPointSetFilterTestClass::TestMode3DMean(myNavigationDataToPointSetFilter);
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationDataTransformFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataTransformFilterTest.cpp
index 88c8a4f8f9..38d8152b88 100644
--- a/Modules/IGT/Testing/mitkNavigationDataTransformFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataTransformFilterTest.cpp
@@ -1,223 +1,223 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNavigationDataTransformFilter.h"
#include "mitkNavigationData.h"
#include "mitkTestingMacros.h"
#include <itkTransform.h>
#include <itkVector.h>
#include <iostream>
/**Documentation
* test for the class "NavigationDataTransformFilter".
*/
-typedef itk::Rigid3DTransform<mitk::ScalarType > TransformType;
+typedef itk::VersorRigid3DTransform<mitk::ScalarType > TransformType;
-typedef itk::Vector<mitk::ScalarType,3> VectorType;
+typedef itk::Vector<double,3> VectorType;
int mitkNavigationDataTransformFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataTransformFilter")
// let's create an object of our class
mitk::NavigationDataTransformFilter::Pointer myFilter = mitk::NavigationDataTransformFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos, resultPos;
mitk::FillVector3D(initialPos, 1.1, 2.2, 3.3);
mitk::FillVector3D(resultPos, 5.0, 5.0,5.0);
mitk::NavigationData::OrientationType initialOri(0.0, 0.0, -0.7071, 0.7071);
mitk::ScalarType initialError(0.0);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
myFilter->SetInput(nd1);
MITK_TEST_CONDITION(myFilter->GetInput() == nd1, "Testing Set-/GetInput()");
- mitk::NavigationData* output = myFilter->GetOutput(0);
+ mitk::NavigationData* output = myFilter->GetOutput();
/*test case no transform set*/
MITK_TEST_FOR_EXCEPTION(std::exception, output->Update(););
/* test transformation */
mitk::NavigationDataTransformFilter::TransformType::Pointer transform = mitk::NavigationDataTransformFilter::TransformType::New();
VectorType translationVector;
translationVector[0] = 3.9;
translationVector[1] = 2.8;
translationVector[2] = 1.7;
/* test translation */
- transform->Translate(translationVector);
+ transform->TransformVector(translationVector);
myFilter->SetRigid3DTransform(transform);
output = myFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output != NULL, "Testing GetOutput()");
output->Update(); // execute filter
MITK_TEST_CONDITION(output->GetPosition() == resultPos, "Testing if translation was calculated correct");
MITK_TEST_CONDITION( mitk::Equal(output->GetOrientation(),initialOri),"Testing if Orientation remains unchanged ");
MITK_TEST_CONDITION(output->IsDataValid() == initialValid, "Testing if DataValid remains unchanged");
// test rotation
mitk::NavigationDataTransformFilter::Pointer myFilter2 = mitk::NavigationDataTransformFilter::New();
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter2.IsNotNull(),"Testing instantiation");
mitk::FillVector3D(initialPos, 1.1, 1.1, 1.1);
mitk::FillVector3D(resultPos, 1.1, -1.1, 1.1);
mitk::NavigationData::OrientationType resultOri(0.0, 0.0, -0.7071, 0.7071);
initialOri[0] = 0;
initialOri[1] = 0;
initialOri[2] = 0;
initialOri[3] = 1;
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
myFilter2->SetInput(nd1);
mitk::NavigationDataTransformFilter::TransformType::MatrixType rotMatrix;
rotMatrix[0][0] = 0;
rotMatrix[0][1] = 1;
rotMatrix[0][2] = 0;
rotMatrix[1][0] = -1;
rotMatrix[1][1] = 0;
rotMatrix[1][2] = 0;
rotMatrix[2][0] = 0;
rotMatrix[2][1] = 0;
rotMatrix[2][2] = 1;
mitk::NavigationDataTransformFilter::TransformType::Pointer transform2 = mitk::NavigationDataTransformFilter::TransformType::New();
- transform2->SetRotationMatrix(rotMatrix);
+ transform2->SetMatrix(rotMatrix);
myFilter2->SetRigid3DTransform(transform2);
mitk::NavigationData* output2 = myFilter2->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output2 != NULL, "Testing GetOutput()");
output2->Update(); // execute filter
MITK_TEST_CONDITION(output2->GetPosition() == resultPos, "Testing if position after rotation is correctly calculated");
MITK_TEST_CONDITION( mitk::Equal(output2->GetOrientation(), resultOri),"Testing if orientation after rotation is correctly caclculated ");
MITK_TEST_CONDITION(output2->IsDataValid() == initialValid, "Testing if DataValid remains unchanged");
// test obscure rotation angle vs. ITK precision requirements
itk::QuaternionRigidTransform<mitk::NavigationDataTransformFilter::TransformType::ScalarType>::VnlQuaternionType obscureRotationQuat(37,29,71);
obscureRotationQuat.normalize(); // Just to demonstrate that even normalizing doesn't help
itk::QuaternionRigidTransform<mitk::NavigationDataTransformFilter::TransformType::ScalarType>::Pointer rotation =
itk::QuaternionRigidTransform<mitk::NavigationDataTransformFilter::TransformType::ScalarType>::New();
rotation->SetRotation(obscureRotationQuat);
mitk::NavigationDataTransformFilter::TransformType::Pointer transform3 = mitk::NavigationDataTransformFilter::TransformType::New();
// For lack of an MITK Test macro that tests for *no* exception
try
{
MITK_TEST_OUTPUT_NO_ENDL(<< "Testing whether NavigationDataTransformFilter's internal transform has sufficient precision for ITK ")
transform3->SetMatrix(rotation->GetMatrix());
MITK_TEST_OUTPUT(<< " [PASSED]")
mitk::TestManager::GetInstance()->TestPassed();
}
catch(std::exception&)
{
MITK_TEST_OUTPUT(<< " [FAILED]")
mitk::TestManager::GetInstance()->TestFailed();
}
//-----------------------------------------------------------------------------------------------------------
/* now test the filter with multiple inputs */
mitk::NavigationData::PositionType initialPos2, resultPos2;
mitk::FillVector3D(initialPos, 1.1, 2.2, 3.3);
mitk::FillVector3D(initialPos2, -1000.0, 567.89, 0.0);
mitk::FillVector3D(resultPos, 2.2,-1.1, 3.3);
mitk::FillVector3D(resultPos2, 567.89, 1000, 0.0);
mitk::NavigationData::OrientationType initialOri2(0.5,0.5,0.5,0.5);
mitk::NavigationData::OrientationType resultOri2(0.7071,0.0,0.0,0.7071);
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri2);
nd2->SetPositionAccuracy(initialError);
nd2->SetDataValid(initialValid);
myFilter = NULL;
myFilter = mitk::NavigationDataTransformFilter::New();
myFilter->SetRigid3DTransform(transform2);
myFilter->SetInput(0, nd1);
myFilter->SetInput(1, nd2);
MITK_TEST_CONDITION(((myFilter->GetInput(0) == nd1)
&& (myFilter->GetInput(1) == nd2)), "Testing Set-/GetInput(index, data)");
output = NULL;
output2 = NULL;
- output = myFilter->GetOutput(0);
+ output = myFilter->GetOutput();
output2 = myFilter->GetOutput(1);
output2->Update(); // execute filter pipeline. this should update both outputs!
MITK_TEST_CONDITION_REQUIRED(((output != NULL) && (output2 != NULL)), "Testing GetOutput(index)");
MITK_TEST_CONDITION(output->GetPosition() == resultPos, "Testing if position rotation was calculated correct [output 0]");
MITK_TEST_CONDITION(mitk::Equal(output->GetOrientation(), resultOri),"Testing if orientation rotation was calculated correct [output 0]");
MITK_TEST_CONDITION(output->IsDataValid() == initialValid, "Testing if DataValid remains unchanged for output 0");
MITK_TEST_CONDITION(output2->GetPosition() == resultPos2, "Testing if rotation was calculated correct [output 1]");
MITK_TEST_CONDITION(mitk::Equal(output2->GetOrientation(), resultOri2),"Testing if orientation rotation was calculated correct [output 1]");
MITK_TEST_CONDITION(output2->IsDataValid() == initialValid, "Testing if DataValid remains unchanged for output 1");
//
// /* test if anything changes on second ->Update() */
output->Update(); // nothing should change, since inputs remain unchanged
MITK_TEST_CONDITION((output->GetPosition() == (resultPos)) && (output2->GetPosition() == (resultPos2)), "Testing translation calculation after second update()");
/* change an input, see if output changes too */
mitk::NavigationData::PositionType pos3, resultPos3;
mitk::FillVector3D(pos3, 123.456, -234.567, 789.987);
mitk::FillVector3D(resultPos3, -234.567, -123.456, 789.987);
nd1->SetPosition(pos3); // nd1 is modified, but nothing should change until pipe gets updated
MITK_TEST_CONDITION((output->GetPosition() == (resultPos))
&&(output2->GetPosition() == (resultPos2)), "Testing transfomr calculation after input change, before update()");
output->Update(); // update pipeline. should recalculate positions, because input has changed
MITK_TEST_CONDITION((output->GetPosition() == (resultPos3)) && (output2->GetPosition() == (resultPos2)), "Testing transform calculation after input change, after update()");
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkNavigationToolStorageSerializerAndDeserializerTest.cpp b/Modules/IGT/Testing/mitkNavigationToolStorageSerializerAndDeserializerTest.cpp
index fe5239d78a..e956535c2b 100644
--- a/Modules/IGT/Testing/mitkNavigationToolStorageSerializerAndDeserializerTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationToolStorageSerializerAndDeserializerTest.cpp
@@ -1,510 +1,510 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//Poco headers
#include "Poco/Path.h"
#include <mitkNavigationToolStorageSerializer.h>
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkCommon.h>
#include <mitkTestingMacros.h>
#include <mitkStandaloneDataStorage.h>
#include <mitkStandardFileLocations.h>
#include <mitkSTLFileReader.h>
#include "mitkNavigationToolStorage.h"
//POCO
#include <Poco/Exception.h>
#include "mitkIGTException.h"
#include "mitkIGTIOException.h"
class NavigationToolStorageSerializerAndDeserializerTestClass
{
public:
static void TestInstantiationSerializer()
{
// let's create objects of our classes
mitk::NavigationToolStorageSerializer::Pointer testSerializer = mitk::NavigationToolStorageSerializer::New();
MITK_TEST_CONDITION_REQUIRED(testSerializer.IsNotNull(),"Testing instantiation of NavigationToolStorageSerializer");
}
static void TestInstantiationDeserializer()
{
mitk::DataStorage::Pointer tempStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer()); //needed for deserializer!
mitk::NavigationToolStorageDeserializer::Pointer testDeserializer = mitk::NavigationToolStorageDeserializer::New(tempStorage);
MITK_TEST_CONDITION_REQUIRED(testDeserializer.IsNotNull(),"Testing instantiation of NavigationToolStorageDeserializer")
}
static void TestWriteSimpleToolStorage()
{
//create Tool Storage
mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
//first tool
mitk::NavigationTool::Pointer myTool1 = mitk::NavigationTool::New();
myTool1->SetIdentifier("001");
myStorage->AddTool(myTool1);
//second tool
mitk::NavigationTool::Pointer myTool2 = mitk::NavigationTool::New();
myTool2->SetIdentifier("002");
myStorage->AddTool(myTool2);
//third tool
mitk::NavigationTool::Pointer myTool3 = mitk::NavigationTool::New();
myTool3->SetIdentifier("003");
myStorage->AddTool(myTool3);
//create Serializer
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
//create filename
std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorage.storage";
//test serialization
bool success = mySerializer->Serialize(filename,myStorage);
MITK_TEST_CONDITION_REQUIRED(success,"Testing serialization of simple tool storage");
}
static void TestWriteAndReadSimpleToolStorageWithToolLandmarks()
{
//create Tool Storage
mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
//first tool
mitk::NavigationTool::Pointer myTool1 = mitk::NavigationTool::New();
myTool1->SetIdentifier("001");
mitk::PointSet::Pointer CalLandmarks1 = mitk::PointSet::New();
mitk::Point3D testPt1;
mitk::FillVector3D(testPt1,1,2,3);
CalLandmarks1->SetPoint(0,testPt1);
mitk::PointSet::Pointer RegLandmarks1 = mitk::PointSet::New();
mitk::Point3D testPt2;
mitk::FillVector3D(testPt2,4,5,6);
RegLandmarks1->SetPoint(5,testPt2);
myTool1->SetToolCalibrationLandmarks(CalLandmarks1);
myTool1->SetToolRegistrationLandmarks(RegLandmarks1);
mitk::Point3D toolTipPos;
mitk::FillVector3D(toolTipPos,1.3423,2.323,4.332);
mitk::Quaternion toolTipRot = mitk::Quaternion(0.1,0.2,0.3,0.4);
myTool1->SetToolTipPosition(toolTipPos);
myTool1->SetToolTipOrientation(toolTipRot);
myStorage->AddTool(myTool1);
//create Serializer
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
//create filename
std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorageToolReg.storage";
//test serialization
bool success = mySerializer->Serialize(filename,myStorage);
MITK_TEST_CONDITION_REQUIRED(success,"Testing serialization of tool storage with tool registrations");
mitk::DataStorage::Pointer tempStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer()); //needed for deserializer!
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(tempStorage);
mitk::NavigationToolStorage::Pointer readStorage = myDeserializer->Deserialize(mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorageToolReg.storage");
MITK_TEST_CONDITION_REQUIRED(readStorage.IsNotNull(),"Testing deserialization of tool storage with tool registrations");
MITK_TEST_CONDITION_REQUIRED(readStorage->GetToolCount()==1," ..Testing number of tools in storage");
mitk::PointSet::Pointer readRegLandmarks = readStorage->GetTool(0)->GetToolRegistrationLandmarks();
mitk::PointSet::Pointer readCalLandmarks = readStorage->GetTool(0)->GetToolCalibrationLandmarks();
MITK_TEST_CONDITION_REQUIRED(((readRegLandmarks->GetPoint(5)[0] == 4)&&(readRegLandmarks->GetPoint(5)[1] == 5)&&(readRegLandmarks->GetPoint(5)[2] == 6)),"..Testing if tool registration landmarks have been stored and loaded correctly.");
MITK_TEST_CONDITION_REQUIRED(((readCalLandmarks->GetPoint(0)[0] == 1)&&(readCalLandmarks->GetPoint(0)[1] == 2)&&(readCalLandmarks->GetPoint(0)[2] == 3)),"..Testing if tool calibration landmarks have been stored and loaded correctly.");
mitk::Point3D readToolTipPos = readStorage->GetTool(0)->GetToolTipPosition();
mitk::Quaternion readToolTipRot = readStorage->GetTool(0)->GetToolTipOrientation();
MITK_TEST_CONDITION_REQUIRED(((float(readToolTipPos[0]) == float(1.3423))&&
(float(readToolTipPos[1]) == float(2.323))&&
(float(readToolTipPos[2]) == float(4.332))),
"..Testing if tool tip position has been stored and loaded correctly.");
MITK_TEST_CONDITION_REQUIRED(((float(readToolTipRot.x()) == float(0.1))&&
(float(readToolTipRot.y()) == float(0.2))&&
(float(readToolTipRot.z()) == float(0.3))&&
(float(readToolTipRot.r()) == float(0.4))),
"..Testing if tool tip orientation has been stored and loaded correctly.");
}
static void TestReadSimpleToolStorage()
{
mitk::DataStorage::Pointer tempStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer()); //needed for deserializer!
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(tempStorage);
mitk::NavigationToolStorage::Pointer readStorage = myDeserializer->Deserialize(mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorage.storage");
MITK_TEST_CONDITION_REQUIRED(readStorage.IsNotNull(),"Testing deserialization of simple tool storage");
MITK_TEST_CONDITION_REQUIRED(readStorage->GetToolCount()==3," ..Testing number of tools in storage");
//TODO: why is the order of tools changed is save/load process??
bool foundtool1 = false;
bool foundtool2 = false;
bool foundtool3 = false;
for(int i=0; i<3; i++)
{
if ((readStorage->GetTool(i)->GetIdentifier()=="001")) foundtool1 = true;
else if ((readStorage->GetTool(i)->GetIdentifier()=="002")) foundtool2 = true;
else if ((readStorage->GetTool(i)->GetIdentifier()=="003")) foundtool3 = true;
}
MITK_TEST_CONDITION_REQUIRED(foundtool1&&foundtool2&&foundtool3," ..Testing if identifiers of tools where saved / loaded successfully");
}
static void CleanUp()
{
try
{
std::remove((mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorage.storage").c_str());
std::remove((mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorageToolReg.storage").c_str());
std::remove((mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorage2.storage").c_str());
}
catch(...)
{
MITK_INFO << "Warning: Error occured when deleting test file!";
}
}
static void TestWriteComplexToolStorage()
{
//create first tool
mitk::Surface::Pointer testSurface;
std::string toolFileName = mitk::StandardFileLocations::GetInstance()->FindFile("ClaronTool", "Modules/IGT/Testing/Data");
MITK_TEST_CONDITION(toolFileName.empty() == false, "Check if tool calibration of claron tool file exists");
mitk::NavigationTool::Pointer myNavigationTool = mitk::NavigationTool::New();
myNavigationTool->SetCalibrationFile(toolFileName);
mitk::DataNode::Pointer myNode = mitk::DataNode::New();
myNode->SetName("ClaronTool");
//load an stl File
mitk::STLFileReader::Pointer stlReader = mitk::STLFileReader::New();
try
{
stlReader->SetFileName( mitk::StandardFileLocations::GetInstance()->FindFile("ClaronTool.stl", "Testing/Data/").c_str() );
stlReader->Update();
}
catch (...)
{
MITK_TEST_FAILED_MSG(<<"Cannot read stl file.");
}
- if ( stlReader->GetOutput() == NULL )
+ if ( stlReader->GetOutput(0) == NULL )
{
MITK_TEST_FAILED_MSG(<<"Cannot read stl file.");
}
else
{
- testSurface = stlReader->GetOutput();
+ testSurface = stlReader->GetOutput(0);
myNode->SetData(testSurface);
}
myNavigationTool->SetDataNode(myNode);
myNavigationTool->SetIdentifier("ClaronTool#1");
myNavigationTool->SetSerialNumber("0815");
myNavigationTool->SetTrackingDeviceType(mitk::ClaronMicron);
myNavigationTool->SetType(mitk::NavigationTool::Fiducial);
//create second tool
mitk::NavigationTool::Pointer myNavigationTool2 = mitk::NavigationTool::New();
mitk::Surface::Pointer testSurface2;
mitk::DataNode::Pointer myNode2 = mitk::DataNode::New();
myNode2->SetName("AuroraTool");
//load an stl File
try
{
stlReader->SetFileName( mitk::StandardFileLocations::GetInstance()->FindFile("EMTool.stl", "Testing/Data/").c_str() );
stlReader->Update();
}
catch (...)
{
MITK_TEST_FAILED_MSG(<<"Cannot read stl file.");
}
- if ( stlReader->GetOutput() == NULL )
+ if ( stlReader->GetOutput(0) == NULL )
{
MITK_TEST_FAILED_MSG(<<"Cannot read stl file.");
}
else
{
- testSurface2 = stlReader->GetOutput();
+ testSurface2 = stlReader->GetOutput(0);
myNode2->SetData(testSurface2);
}
myNavigationTool2->SetDataNode(myNode2);
myNavigationTool2->SetIdentifier("AuroraTool#1");
myNavigationTool2->SetSerialNumber("0816");
myNavigationTool2->SetTrackingDeviceType(mitk::NDIAurora);
myNavigationTool2->SetType(mitk::NavigationTool::Instrument);
//create navigation tool storage
mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
myStorage->AddTool(myNavigationTool);
myStorage->AddTool(myNavigationTool2);
//create Serializer
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
//create filename
std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorage2.storage";
//test serialization
bool success = mySerializer->Serialize(filename,myStorage);
MITK_TEST_CONDITION_REQUIRED(success,"Testing serialization of complex tool storage");
}
static void TestReadComplexToolStorage()
{
mitk::DataStorage::Pointer tempStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer()); //needed for deserializer!
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(tempStorage);
mitk::NavigationToolStorage::Pointer readStorage = myDeserializer->Deserialize(mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorage2.storage");
MITK_TEST_CONDITION_REQUIRED(readStorage.IsNotNull(),"Testing deserialization of complex tool storage");
MITK_TEST_CONDITION_REQUIRED(readStorage->GetToolCount()==2," ..Testing number of tools in storage");
}
static void TestReadNotExistingStorage()
{
mitk::DataStorage::Pointer tempStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer()); //needed for deserializer!
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(tempStorage);
bool exceptionThrown = false;
try
{
mitk::NavigationToolStorage::Pointer readStorage = myDeserializer->Deserialize("noStorage.tfl");
}
catch (mitk::IGTException e)
{
exceptionThrown = true;
}
MITK_TEST_CONDITION_REQUIRED(exceptionThrown,"Testing if exception is thrown if a non existing storage is given for deserialization.");
}
static void TestReadStorageWithUnknownFiletype()
{
mitk::DataStorage::Pointer tempStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer()); //needed for deserializer!
std::string toolFileName = mitk::StandardFileLocations::GetInstance()->FindFile("ClaronTool.stl", "Modules/IGT/Testing/Data");
MITK_TEST_CONDITION(toolFileName.empty() == false, "Check if tool calibration of claron tool file exists");
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(tempStorage);
bool exceptionThrown = false;
try
{
mitk::NavigationToolStorage::Pointer readStorage = myDeserializer->Deserialize(toolFileName);
}
catch (mitk::IGTException e)
{
exceptionThrown = true;
}
MITK_TEST_CONDITION_REQUIRED(exceptionThrown,"Testing if exception is thrown if a wrong file type is given for deserialization.");
}
static void TestReadZipFileWithNoToolstorage()
{
mitk::DataStorage::Pointer tempStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer()); //needed for deserializer!
std::string toolFileName = mitk::StandardFileLocations::GetInstance()->FindFile("Empty.zip", "Modules/IGT/Testing/Data");
MITK_TEST_CONDITION(toolFileName.empty() == false, "Check if tool calibration of claron tool file exists");
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(tempStorage);
bool exceptionThrown = false;
try
{
mitk::NavigationToolStorage::Pointer readStorage = myDeserializer->Deserialize(toolFileName);
}
catch (mitk::IGTException e)
{
exceptionThrown = true;
}
catch (std::exception& e)
{
MITK_ERROR << "Unexpected exception catched: " << e.what() << " / filename: " << toolFileName;
}
MITK_TEST_CONDITION_REQUIRED(exceptionThrown,"Testing if exception is thrown if a empty zip file is given for deserialization.");
}
static void TestWriteStorageToInvalidFile()
{
//create Tool Storage
mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
//first tool
mitk::NavigationTool::Pointer myTool1 = mitk::NavigationTool::New();
myTool1->SetIdentifier("001");
myStorage->AddTool(myTool1);
//second tool
mitk::NavigationTool::Pointer myTool2 = mitk::NavigationTool::New();
myTool2->SetIdentifier("002");
myStorage->AddTool(myTool2);
//third tool
mitk::NavigationTool::Pointer myTool3 = mitk::NavigationTool::New();
myTool3->SetIdentifier("003");
myStorage->AddTool(myTool3);
//create Serializer
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
//create filename
#ifdef WIN32
std::string filename = "C:\342INVALIDFILE<>.storage"; //invalid filename for windows
#else
std::string filename = "/dsfdsf:$§$342INVALIDFILE.storage"; //invalid filename for linux
#endif
//test serialization
bool exceptionThrown = false;
try
{
mySerializer->Serialize(filename,myStorage);
}
catch(mitk::IGTException e)
{
exceptionThrown = true;
}
MITK_TEST_CONDITION_REQUIRED(exceptionThrown,"Testing if an exception is thrown if an invalid file is used.");
}
static void TestWriteEmptyToolStorage()
{
//create Tool Storage
mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
//create Serializer
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
std::string filename;
std::string optionDirectory;
std::string separator;
try
{
//create filename
separator = Poco::Path::separator();
optionDirectory = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory();
filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestStorage.storage";
}
catch (std::exception& e) {
MITK_ERROR << "File access Exception: " << e.what();
MITK_INFO << "separator: " << separator;
MITK_INFO << "optionDirectory: " << optionDirectory;
MITK_TEST_FAILED_MSG(<<"Could not create filename for Exceptiontest");
}
//test serialization
bool success = mySerializer->Serialize(filename,myStorage);
MITK_TEST_CONDITION_REQUIRED(success,"Testing serialization of simple tool storage");
}
//new tests for exception throwing of NavigationToolStorageSerializer
static void TestSerializerForExceptions()
{
mitk::NavigationToolStorageSerializer::Pointer testSerializer = mitk::NavigationToolStorageSerializer::New();
mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
//create an invalid filename
std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"";
//now try to serialize an check if an exception is thrown
bool ExceptionThrown = false;
try
{
testSerializer->Serialize(filename,myStorage);
}
catch(mitk::IGTException)
{
ExceptionThrown = true;
}
MITK_TEST_CONDITION_REQUIRED(ExceptionThrown, "Testing serializer with invalid filename.");
}
//new tests for exception throwing of NavigationToolStorageDeserializer
static void TestDeserializerForExceptions()
{
// Desearializing file with invalid name
mitk::DataStorage::Pointer tempStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer());
mitk::NavigationToolStorageDeserializer::Pointer testDeseralizer= mitk::NavigationToolStorageDeserializer::New(tempStorage);
bool ExceptionThrown1 = false;
try
{
mitk::NavigationToolStorage::Pointer readStorage = testDeseralizer->Deserialize("InvalidName");
}
catch(mitk::IGTException)
{
ExceptionThrown1 = true;
}
MITK_TEST_CONDITION_REQUIRED(ExceptionThrown1, "Testing deserializer with invalid filename.");
bool ExceptionThrown2 = false;
// Deserializing of empty zip file
mitk::NavigationToolStorageDeserializer::Pointer testDeseralizer2= mitk::NavigationToolStorageDeserializer::New(tempStorage);
try
{
std::string filename = mitk::StandardFileLocations::GetInstance()->FindFile("EmptyZipFile.zip", "Modules/IGT/Testing/Data");
mitk::NavigationToolStorage::Pointer readStorage = testDeseralizer2->Deserialize(filename);
}
catch(mitk::IGTException)
{
ExceptionThrown2 = true;
}
MITK_TEST_CONDITION_REQUIRED(ExceptionThrown2, "Testing deserializer method with empty zip file.");
}
};
/** This function is testing the TrackingVolume class. */
int mitkNavigationToolStorageSerializerAndDeserializerTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationToolStorageSerializerAndDeserializer");
try{
NavigationToolStorageSerializerAndDeserializerTestClass::TestInstantiationSerializer();
NavigationToolStorageSerializerAndDeserializerTestClass::TestInstantiationDeserializer();
NavigationToolStorageSerializerAndDeserializerTestClass::TestWriteSimpleToolStorage();
NavigationToolStorageSerializerAndDeserializerTestClass::TestWriteAndReadSimpleToolStorageWithToolLandmarks();
NavigationToolStorageSerializerAndDeserializerTestClass::TestReadSimpleToolStorage();
NavigationToolStorageSerializerAndDeserializerTestClass::TestWriteComplexToolStorage();
NavigationToolStorageSerializerAndDeserializerTestClass::TestReadComplexToolStorage();
NavigationToolStorageSerializerAndDeserializerTestClass::TestReadNotExistingStorage();
NavigationToolStorageSerializerAndDeserializerTestClass::TestReadStorageWithUnknownFiletype();
NavigationToolStorageSerializerAndDeserializerTestClass::TestReadZipFileWithNoToolstorage();
NavigationToolStorageSerializerAndDeserializerTestClass::TestWriteStorageToInvalidFile();
NavigationToolStorageSerializerAndDeserializerTestClass::TestWriteEmptyToolStorage();
NavigationToolStorageSerializerAndDeserializerTestClass::TestSerializerForExceptions();
NavigationToolStorageSerializerAndDeserializerTestClass::TestDeserializerForExceptions();
}
catch (std::exception& e) {
MITK_ERROR << "exception:" << e.what();
MITK_TEST_FAILED_MSG(<<"Exception occured, test failed!");
}
catch (...) {
MITK_ERROR << "Unknown Exception?";
MITK_TEST_FAILED_MSG(<<"Exception occured, test failed!");
}
NavigationToolStorageSerializerAndDeserializerTestClass::CleanUp();
MITK_TEST_END();
}
diff --git a/Modules/IGT/Testing/mitkTrackingDeviceSourceTest.cpp b/Modules/IGT/Testing/mitkTrackingDeviceSourceTest.cpp
index da1ec15cb3..697d1f85cc 100644
--- a/Modules/IGT/Testing/mitkTrackingDeviceSourceTest.cpp
+++ b/Modules/IGT/Testing/mitkTrackingDeviceSourceTest.cpp
@@ -1,137 +1,137 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTrackingDeviceSource.h"
#include "mitkVirtualTrackingDevice.h"
#include "mitkTestingMacros.h"
#include <mitkReferenceCountWatcher.h>
#include "itksys/SystemTools.hxx"
/**Documentation
* test for the class "NavigationDataSource".
*/
int mitkTrackingDeviceSourceTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("TrackingDeviceSource");
// let's create an object of our class
mitk::TrackingDeviceSource::Pointer mySource = mitk::TrackingDeviceSource::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(mySource.IsNotNull(), "Testing instantiation");
mySource->SetTrackingDevice(NULL);
MITK_TEST_CONDITION(mySource->GetTrackingDevice() == NULL, "Testing Set/GetTrackingDevice(NULL)");
MITK_TEST_CONDITION(mySource->GetNumberOfOutputs() == 0, "Testing GetNumberOfOutputs with NULL td");
MITK_TEST_FOR_EXCEPTION(std::invalid_argument, mySource->Connect());
MITK_TEST_FOR_EXCEPTION(std::invalid_argument, mySource->StartTracking());
mitk::VirtualTrackingDevice::Pointer tracker = mitk::VirtualTrackingDevice::New();
tracker->SetRefreshRate(10);
mySource->SetTrackingDevice(tracker);
MITK_TEST_CONDITION(mySource->GetTrackingDevice() == tracker.GetPointer(), "Testing Set/GetTrackingDevice(tracker)");
MITK_TEST_CONDITION(mySource->GetNumberOfOutputs() == 0, "Testing GetNumberOfOutputs with no tool tracker");
tracker = mitk::VirtualTrackingDevice::New();
mitk::ReferenceCountWatcher::Pointer watch = new mitk::ReferenceCountWatcher(tracker);
tracker->AddTool("T0");
tracker->AddTool("T1");
mySource->SetTrackingDevice(tracker);
MITK_TEST_CONDITION(mySource->GetTrackingDevice() == tracker.GetPointer(), "Testing Set/GetTrackingDevice(tracker2)");
MITK_TEST_CONDITION(mySource->GetNumberOfOutputs() == 2, "Testing GetNumberOfOutputs with 2 tools tracker");
MITK_TEST_CONDITION(mySource->IsConnected() == false, "Testing IsConnected()");
mySource->Connect();
MITK_TEST_CONDITION(mySource->IsConnected() == true, "Testing Connect()/IsConnected()");
MITK_TEST_CONDITION(tracker->GetState() == mitk::TrackingDevice::Ready, "Testing Connect()/IsConnected() 2");
mySource->Disconnect();
MITK_TEST_CONDITION(mySource->IsConnected() == false, "Testing Disconnect()/IsConnected()");
MITK_TEST_CONDITION(tracker->GetState() == mitk::TrackingDevice::Setup, "Testing Disconnect()/IsConnected() 2");
mySource->Connect();
mySource->StartTracking();
MITK_TEST_CONDITION(mySource->IsConnected() == true, "Testing StartTracking()/IsConnected()");
MITK_TEST_CONDITION(mySource->IsTracking() == true, "Testing StartTracking()/IsTracking()");
MITK_TEST_CONDITION(tracker->GetState() == mitk::TrackingDevice::Tracking, "Testing StartTracking()/IsTracking() 2");
unsigned long modTime = mySource->GetMTime();
mySource->UpdateOutputInformation();
MITK_TEST_CONDITION(mySource->GetMTime() != modTime, "Testing if UpdateOutputInformation() modifies the object");
//test getOutput()
- mitk::NavigationData* nd0 = mySource->GetOutput(0);
+ mitk::NavigationData* nd0 = mySource->GetOutput();
MITK_TEST_CONDITION(nd0!=NULL,"Testing GetOutput() [1]");
nd0 = mySource->GetOutput(nd0->GetName());
MITK_TEST_CONDITION(nd0!=NULL,"Testing GetOutput() [2]");
//test getOutputIndex()
MITK_TEST_CONDITION(mySource->GetOutputIndex(nd0->GetName())==0,"Testing GetOutputIndex()");
//test GraftNthOutput()
mitk::NavigationData::Pointer ndCopy = mitk::NavigationData::New();
mySource->GraftNthOutput(1,nd0);
ndCopy = mySource->GetOutput(1);
MITK_TEST_CONDITION(std::string(ndCopy->GetName())==std::string(nd0->GetName()),"Testing GraftNthOutput()");
//test GetParameters()
mitk::PropertyList::ConstPointer p = mySource->GetParameters();
MITK_TEST_CONDITION(p.IsNotNull(),"Testing GetParameters()");
nd0->Update();
mitk::NavigationData::PositionType pos = nd0->GetPosition();
unsigned long tmpMTime0 = nd0->GetMTime();
itksys::SystemTools::Delay(500); // allow the tracking thread to advance the tool position
nd0->Update();
mitk::NavigationData::PositionType newPos = nd0->GetPosition();
if(nd0->GetMTime() == tmpMTime0) //tool not modified yet
{
MITK_TEST_CONDITION(mitk::Equal(newPos, pos) == true, "Testing if output changes on each update");
}
else
{
MITK_TEST_CONDITION(mitk::Equal(newPos, pos) == false, "Testing if output changes on each update");
}
mySource->StopTracking();
mySource->Disconnect();
tracker = mitk::VirtualTrackingDevice::New();
mySource->SetTrackingDevice(tracker);
MITK_TEST_CONDITION(watch->GetReferenceCount() == 0, "Testing if reference to previous tracker object is released");
watch = NULL;
MITK_TEST_FOR_EXCEPTION(std::runtime_error, mySource->StartTracking()); // new tracker, needs Connect() before StartTracking()
mySource->Connect();
mySource->StartTracking();
// itksys::SystemTools::Delay(800); // wait for tracking thread to start properly //DEBUG ONLY --> race condition. will the thread start before the object is destroyed? --> maybe hold a smartpointer?
try
{
mySource = NULL; // delete source
tracker = NULL; // delete tracker --> both should not result in any exceptions or deadlocks
}
catch (...)
{
MITK_TEST_FAILED_MSG(<< "exception during destruction of source or tracker!");
}
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.cpp
index d0a8e4d4fb..5443cc39c9 100644
--- a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.cpp
@@ -1,225 +1,247 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkFiducialRegistrationWidget.h"
#define FRW_LOG MITK_INFO("Fiducial Registration Widget")
#define FRW_WARN MITK_WARN("Fiducial Registration Widget")
#define FRW_DEBUG MITK_DEBUG("Fiducial Registration Widget")
/* VIEW MANAGEMENT */
QmitkFiducialRegistrationWidget::QmitkFiducialRegistrationWidget(QWidget* parent)
: QWidget(parent), m_Controls(NULL),m_MultiWidget(NULL), m_ImageFiducialsNode(NULL), m_TrackerFiducialsNode(NULL)
{
CreateQtPartControl(this);
}
QmitkFiducialRegistrationWidget::~QmitkFiducialRegistrationWidget()
{
m_Controls = NULL;
}
void QmitkFiducialRegistrationWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkFiducialRegistrationWidget;
m_Controls->setupUi(parent);
// hide additional image fiducial button
m_Controls->m_AddImageFiducialBtn->setHidden(true);
m_Controls->m_spaceHolderGroupBox->setStyleSheet("QGroupBox {border: 0px transparent;}");
m_Controls->m_spaceHolderGroupBox2->setStyleSheet("QGroupBox {border: 0px transparent;}");
this->CreateConnections();
}
}
void QmitkFiducialRegistrationWidget::CreateConnections()
{
connect( (QObject*)(m_Controls->m_AddTrackingFiducialBtn), SIGNAL(clicked()), this, SIGNAL(AddedTrackingFiducial()) );
connect( (QObject*)(m_Controls->m_AddImageFiducialBtn), SIGNAL(clicked()), this, SIGNAL(AddedImageFiducial()) );
connect( (QObject*)(m_Controls->m_RegisterFiducialsBtn), SIGNAL(clicked()), this, SIGNAL(PerformFiducialRegistration()) );
connect( (QObject*)(m_Controls->m_UseICPRegistration), SIGNAL(toggled(bool)), this, SIGNAL(FindFiducialCorrespondences(bool)) );
//unselects the edit button of the other widget if one is selected
connect( (QObject*)(m_Controls->m_RegistrationImagePoints), SIGNAL(EditPointSets(bool)), this, SLOT(DisableEditButtonRegistrationTrackingPoints(bool)));
connect( (QObject*)(m_Controls->m_RegistrationTrackingPoints), SIGNAL(EditPointSets(bool)), this, SLOT(DisableEditButtonRegistrationImagePoints(bool)));
}
void QmitkFiducialRegistrationWidget::DisableEditButtonRegistrationImagePoints(bool activated)
{
if (activated) m_Controls->m_RegistrationImagePoints->UnselectEditButton();
}
void QmitkFiducialRegistrationWidget::DisableEditButtonRegistrationTrackingPoints(bool activated)
{
if (activated) m_Controls->m_RegistrationTrackingPoints->UnselectEditButton();
}
void QmitkFiducialRegistrationWidget::SetWidgetAppearanceMode(WidgetAppearanceMode widgetMode)
{
if (widgetMode==LANDMARKMODE)
{
this->HideContinousRegistrationRadioButton(true);
this->HideStaticRegistrationRadioButton(true);
this->HideFiducialRegistrationGroupBox();
this->HideUseICPRegistrationCheckbox(true);
this->HideImageFiducialButton(false);
this->m_Controls->sourceLandmarksGroupBox->setTitle("Target/Reference landmarks");
this->m_Controls->targetLandmarksGroupBox->setTitle("Source Landmarks");
this->m_Controls->m_AddImageFiducialBtn->setText("Add target landmark");
this->m_Controls->m_AddTrackingFiducialBtn->setText("Add source landmark");
}
else if (widgetMode==FIDUCIALMODE)
{
this->HideContinousRegistrationRadioButton(false);
this->HideStaticRegistrationRadioButton(false);
this->HideFiducialRegistrationGroupBox();
this->HideUseICPRegistrationCheckbox(false);
this->HideImageFiducialButton(true);
this->m_Controls->sourceLandmarksGroupBox->setTitle("Image fiducials");
this->m_Controls->targetLandmarksGroupBox->setTitle("OR fiducials");
this->m_Controls->m_AddImageFiducialBtn->setText("Add image fiducial");
this->m_Controls->m_AddTrackingFiducialBtn->setText("Add current instrument position");
}
}
void QmitkFiducialRegistrationWidget::SetQualityDisplayText( QString text )
{
if (text == NULL)
return;
m_Controls->m_RegistrationQualityDisplay->setText(text); // set text on the QLabel
}
bool QmitkFiducialRegistrationWidget::UseICPIsChecked()
{
if(m_Controls->m_UseICPRegistration->isChecked())
return true;
else
return false;
}
void QmitkFiducialRegistrationWidget::SetImageFiducialsNode( mitk::DataNode::Pointer imageFiducialsNode )
{
if(imageFiducialsNode.IsNull())
{
FRW_WARN<< "tracker fiducial node is NULL";
return;
}
if(m_MultiWidget == NULL)
{
FRW_WARN<< "stdMultiWidget is NULL";
return;
}
m_Controls->m_RegistrationImagePoints->SetMultiWidget(m_MultiWidget); // pass multiWidget to pointListWidget
m_Controls->m_RegistrationImagePoints->SetPointSetNode(imageFiducialsNode); // pass node to pointListWidget
}
void QmitkFiducialRegistrationWidget::SetTrackerFiducialsNode( mitk::DataNode::Pointer trackerFiducialsNode )
{
if(trackerFiducialsNode.IsNull())
{
FRW_WARN<< "tracker fiducial node is NULL";
return;
}
if(m_MultiWidget == NULL)
{
FRW_WARN<< "stdMultiWidget is NULL";
return;
}
m_Controls->m_RegistrationTrackingPoints->SetMultiWidget(m_MultiWidget); // pass multiWidget to pointListWidget
m_Controls->m_RegistrationTrackingPoints->SetPointSetNode(trackerFiducialsNode); // pass node to pointListWidget
}
void QmitkFiducialRegistrationWidget::SetMultiWidget( QmitkStdMultiWidget* multiWidget )
{
m_MultiWidget=multiWidget;
}
mitk::DataNode::Pointer QmitkFiducialRegistrationWidget::GetImageFiducialsNode()
{
return m_ImageFiducialsNode;
}
mitk::DataNode::Pointer QmitkFiducialRegistrationWidget::GetTrackerFiducialsNode()
{
return m_TrackerFiducialsNode;
}
void QmitkFiducialRegistrationWidget::HideStaticRegistrationRadioButton( bool on )
{
m_Controls->m_rbStaticRegistration->setHidden(on);
HideFiducialRegistrationGroupBox();
}
void QmitkFiducialRegistrationWidget::HideContinousRegistrationRadioButton( bool on )
{
m_Controls->m_rbContinousRegistration->setHidden(on);
HideFiducialRegistrationGroupBox();
}
void QmitkFiducialRegistrationWidget::HideFiducialRegistrationGroupBox()
{
if (m_Controls->m_rbStaticRegistration->isHidden() && m_Controls->m_rbContinousRegistration->isHidden())
{
m_Controls->m_gbFiducialRegistration->setHidden(true);
}
else
{
m_Controls->m_gbFiducialRegistration->setHidden(false);
}
}
void QmitkFiducialRegistrationWidget::HideUseICPRegistrationCheckbox( bool on )
{
m_Controls->m_UseICPRegistration->setHidden(on);
}
void QmitkFiducialRegistrationWidget::HideImageFiducialButton( bool on )
{
m_Controls->m_AddImageFiducialBtn->setHidden(on);
AdjustButtonSpacing();
}
void QmitkFiducialRegistrationWidget::HideTrackingFiducialButton( bool on )
{
m_Controls->m_AddTrackingFiducialBtn->setHidden(on);
AdjustButtonSpacing();
}
void QmitkFiducialRegistrationWidget::AdjustButtonSpacing()
{
if (m_Controls->m_AddImageFiducialBtn->isHidden() && m_Controls->m_AddTrackingFiducialBtn->isHidden())
{
m_Controls->m_spaceHolderGroupBox->setHidden(true);
m_Controls->m_spaceHolderGroupBox2->setHidden(true);
}
else
{
m_Controls->m_spaceHolderGroupBox->setHidden(false);
m_Controls->m_spaceHolderGroupBox2->setHidden(false);
}
}
+
+void QmitkFiducialRegistrationWidget::SetSourceLandmarkName(QString sourceLandmarkName)
+{
+ QString groupBoxTitle = sourceLandmarkName;
+ groupBoxTitle.append(" Landmarks");
+ m_Controls->sourceLandmarksGroupBox->setTitle(groupBoxTitle);
+ QString buttonText = "Add ";
+ buttonText.append(sourceLandmarkName);
+ buttonText.append(" Landmark");
+ m_Controls->m_AddImageFiducialBtn->setText(buttonText);
+}
+
+void QmitkFiducialRegistrationWidget::SetTargetLandmarkName(QString targetLandmarkName)
+{
+ QString groupBoxTitle = targetLandmarkName;
+ groupBoxTitle.append(" Landmarks");
+ m_Controls->targetLandmarksGroupBox->setTitle(groupBoxTitle);
+ QString buttonText = "Add ";
+ buttonText.append(targetLandmarkName);
+ buttonText.append(" Landmark");
+ m_Controls->m_AddTrackingFiducialBtn->setText(buttonText);
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.h b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.h
index 0b6faa1a83..ce45ae2d9c 100644
--- a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.h
@@ -1,98 +1,110 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _QmitkFiducialRegistrationWidget_H_INCLUDED
#define _QmitkFiducialRegistrationWidget_H_INCLUDED
#include "ui_QmitkFiducialRegistrationWidget.h"
#include "QmitkStdMultiWidget.h"
#include "MitkIGTUIExports.h"
/*!
* \brief IGT Fiducial Registration Widget
*
* Widget used to set fiducial landmarks in the image and to confirm the corresponding landmarks on the world object (patient/phantom).
*
* SetImageFiducialsNode(), SetTrackerFiducialsNode() and SetMultiWidget() must be called, otherwise QmitkPointListWidget can not work.
*
*
*
* \sa IGT
*/
class MitkIGTUI_EXPORT QmitkFiducialRegistrationWidget : public QWidget
{
Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
public:
QmitkFiducialRegistrationWidget(QWidget* parent);
virtual ~QmitkFiducialRegistrationWidget();
/*!
\brief enumeration to specify the appearance of the widget.
'FIDUCIALMODE' is likely to be used for (tracking) fiducial based registration purposes
'LANDMARKMODE' can be used for any kind of landmark based registration (source landmarks -> target/reference landmarks)
*/
enum WidgetAppearanceMode
{
FIDUCIALMODE,
LANDMARKMODE
};
/*!
\brief set the appearance mode of this widget
'FIDUCIALMODE' adapts the widget for (tracking) fiducial based registration purposes
'LANDMARKMODE' adapts the widget for landmark based registration (source landmarks -> target/reference landmarks)
*/
void SetWidgetAppearanceMode(WidgetAppearanceMode widgetMode);
void SetMultiWidget(QmitkStdMultiWidget* multiWidget); ///< Set the default stdMultiWidget (needed for the PointListwidget)
void SetImageFiducialsNode(mitk::DataNode::Pointer imageFiducialsNode); ///< specify data tree node for the image fiducials
void SetTrackerFiducialsNode(mitk::DataNode::Pointer trackerFiducialsNode); ///< specify data tree node for the tracker fiducials
mitk::DataNode::Pointer GetImageFiducialsNode(); ///< returns data tree node for the image fiducials
mitk::DataNode::Pointer GetTrackerFiducialsNode(); ///< returns data tree node for the tracker fiducials
void SetQualityDisplayText(QString text); ///< sets specific text on the UI (useful to display FRE/TRE...)
+ /*!
+ \brief Specify the name of the source landmarks. Will be used for label and button.
+
+ Example: sourceLandmarkName="CT" will result in group box title "CT landmarks" and button text "Add CT landmark".
+ */
+ void SetSourceLandmarkName(QString sourceLandmarkName);
+ /*!
+ \brief Specify the name of the source landmarks. Will be used for label and button.
+
+ Example: targetLandmarkName="CT" will result in group box title "CT landmarks" and button text "Add CT landmark".
+ */
+ void SetTargetLandmarkName(QString targetLandmarkName);
bool UseICPIsChecked(); ///< returns true if automatic correspondences search is activated else false
void HideStaticRegistrationRadioButton(bool on); ///< show or hide "static Fiducial Registration" radio button in the UI
void HideContinousRegistrationRadioButton(bool on); ///< show or hide "hybrid continuous Fiducial Registration" radio button in the UI
void HideFiducialRegistrationGroupBox(); ///< show or hide "Fiducial Registration method" groupbox in the UI, depending on the visibility of the radio buttons
void HideUseICPRegistrationCheckbox(bool on); ///< show or hide "Find fiducial correspondences (needs 6+ fiducial pairs)" check box in the UI
void HideImageFiducialButton(bool on); ///< show or hide "Add image fiducial" button in the UI
void HideTrackingFiducialButton(bool on); ///< show or hide "Add tracking fiducial" button in the UI
void AdjustButtonSpacing(); ///< Rearrange spacing when buttons are turned on or off
signals:
void AddedTrackingFiducial(); ///< signal if a world instrument position was added to a tracking space fiducial
void AddedImageFiducial(); ///< signal if an image position was added to a image space fiducial
void PerformFiducialRegistration(); ///< signal if all fiducial were added and registration can be performed
void FindFiducialCorrespondences(bool on); ///< signal if automatic correspondences search is toggled
protected slots:
void DisableEditButtonRegistrationImagePoints(bool);///< Disables the edit button of the widget RegistrationImagePoints if the activated variable is true.
void DisableEditButtonRegistrationTrackingPoints(bool);///< Disables the edit button of the widget RegistrationTrackingPoints if the activated variable is true.
protected:
void CreateQtPartControl(QWidget *parent);
void CreateConnections();
Ui::QmitkFiducialRegistrationWidget* m_Controls; ///< gui widget
QmitkStdMultiWidget* m_MultiWidget;
mitk::DataNode::Pointer m_ImageFiducialsNode;
mitk::DataNode::Pointer m_TrackerFiducialsNode;
};
#endif // _QmitkFiducialRegistrationWidget_H_INCLUDED
diff --git a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.ui b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.ui
old mode 100644
new mode 100755
index ebf96a766e..e5444eadeb
--- a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.ui
+++ b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.ui
@@ -1,321 +1,315 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkFiducialRegistrationWidget</class>
<widget class="QWidget" name="QmitkFiducialRegistrationWidget">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>568</width>
<height>388</height>
</rect>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QGroupBox" name="m_gbFiducialRegistration">
<property name="title">
<string>Fiducial Registration method</string>
</property>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QRadioButton" name="m_rbStaticRegistration">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string>Static</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QRadioButton" name="m_rbContinousRegistration">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string>Hybrid Continuous</string>
</property>
<property name="checked">
<bool>false</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="0" column="1">
<widget class="QCheckBox" name="m_UseICPRegistration">
<property name="minimumSize">
<size>
<width>0</width>
<height>40</height>
</size>
</property>
<property name="toolTip">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Find fiducial correspondences (needs 6+ fiducial pairs)&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
<property name="text">
- <string> Find fiducial
+ <string> Find fiducial
correspondences</string>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QPushButton" name="m_RegisterFiducialsBtn">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>40</height>
</size>
</property>
<property name="text">
- <string> Register
- Fiducials</string>
+ <string> Register</string>
</property>
</widget>
</item>
<item row="1" column="0" colspan="3">
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QGroupBox" name="sourceLandmarksGroupBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="title">
<string> Image fiducials</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="margin">
<number>6</number>
</property>
<item>
<widget class="QmitkPointListWidget" name="m_RegistrationImagePoints">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_spaceHolderGroupBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>37</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>16777215</width>
<height>37</height>
</size>
</property>
<property name="title">
<string/>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="flat">
<bool>false</bool>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<property name="spacing">
<number>0</number>
</property>
<property name="margin">
<number>0</number>
</property>
<item>
<widget class="QPushButton" name="m_AddImageFiducialBtn">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>35</height>
</size>
</property>
<property name="text">
<string>Add image fiducial</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="targetLandmarksGroupBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Real world fiducials </string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<property name="margin">
<number>6</number>
</property>
<item>
<widget class="QmitkPointListWidget" name="m_RegistrationTrackingPoints">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_spaceHolderGroupBox2">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>37</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>16777215</width>
<height>37</height>
</size>
</property>
<property name="title">
<string/>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="flat">
<bool>false</bool>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<property name="spacing">
<number>0</number>
</property>
<property name="margin">
<number>0</number>
</property>
<item>
<widget class="QPushButton" name="m_AddTrackingFiducialBtn">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>35</height>
</size>
</property>
<property name="text">
- <string>&amp;Add current
+ <string>&amp;Add current
instrument position</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</item>
<item row="2" column="0" colspan="3">
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<widget class="QLabel" name="statusLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Status:</string>
</property>
<property name="alignment">
<set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_RegistrationQualityDisplay">
<property name="text">
<string/>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
</layout>
</item>
</layout>
<zorder>m_RegisterFiducialsBtn</zorder>
<zorder>m_UseICPRegistration</zorder>
<zorder>m_gbFiducialRegistration</zorder>
- <zorder>sourceLandmarksGroupBox</zorder>
- <zorder>targetLandmarksGroupBox</zorder>
- <zorder>statusLabel</zorder>
- <zorder>m_RegistrationQualityDisplay</zorder>
- <zorder>statusLabel</zorder>
</widget>
<customwidgets>
<customwidget>
<class>QmitkPointListWidget</class>
<extends>QListWidget</extends>
<header>QmitkPointListWidget.h</header>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
index b53afa7950..45438a4e01 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
@@ -1,573 +1,573 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkIGTPlayerWidget.h"
//mitk headers
#include "mitkTrackingTypes.h"
#include <mitkSTLFileReader.h>
#include <mitkSurface.h>
#include <mitkNavigationToolReader.h>
#include <mitkNavigationToolWriter.h>
#include <mitkNavigationToolStorage.h>
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkNavigationToolStorageSerializer.h>
#include <mitkIGTException.h>
//qt headers
#include <qfiledialog.h>
#include <qmessagebox.h>
#include <qtimer.h>
QmitkIGTPlayerWidget::QmitkIGTPlayerWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f)
,m_RealTimePlayer(NULL)
,m_SequentialPlayer(NULL)
,m_StartTime(-1.0)
,m_CurrentSequentialPointNumber(0)
{
m_Controls = NULL;
CreateQtPartControl(this);
CreateConnections();
m_Controls->samplePositionHorizontalSlider->setVisible(false);
this->ResetLCDNumbers(); // reset lcd numbers at start
}
QmitkIGTPlayerWidget::~QmitkIGTPlayerWidget()
{
m_PlayingTimer->stop();
m_RealTimePlayer = NULL;
m_PlayingTimer = NULL;
}
void QmitkIGTPlayerWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkIGTPlayerWidgetControls;
m_Controls->setupUi(parent);
m_PlayingTimer = new QTimer(this); // initialize update timer
}
}
void QmitkIGTPlayerWidget::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->selectPushButton), SIGNAL(clicked()), this, SLOT(OnSelectPressed()) ); // open file dialog
connect( (QObject*)(m_Controls->playPushButton), SIGNAL(clicked(bool)), this, SLOT(OnPlayButtonClicked(bool)) ); // play button
connect( (QObject*)(m_PlayingTimer), SIGNAL(timeout()), this, SLOT(OnPlaying()) ); // update timer
connect( (QObject*) (m_Controls->beginPushButton), SIGNAL(clicked()), this, SLOT(OnGoToBegin()) ); // reset player and go to begin
connect( (QObject*) (m_Controls->stopPushButton), SIGNAL(clicked()), this, SLOT(OnGoToEnd()) ); // reset player
// pass this widgets protected combobox signal to public signal
connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
// pass this widgets protected checkbox signal to public signal
connect( m_Controls->splineModeCheckBox, SIGNAL(toggled(bool)), this, SIGNAL(SignalSplineModeToggled(bool)) );
connect( m_Controls->sequencialModeCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnSequencialModeToggled(bool)) );
connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderPressed()), this, SLOT(OnSliderPressed()) );
connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderReleased()), this, SLOT(OnSliderReleased()) );
}
}
bool QmitkIGTPlayerWidget::IsTrajectoryInSplineMode()
{
return m_Controls->splineModeCheckBox->isChecked();
}
bool QmitkIGTPlayerWidget::CheckInputFileValid()
{
QFile file(m_CmpFilename);
// check if file exists
if(!file.exists())
{
QMessageBox::warning(NULL, "IGTPlayer: Error", "No valid input file was loaded. Please load input file first!");
return false;
}
return true;
}
unsigned int QmitkIGTPlayerWidget::GetNumberOfTools()
{
unsigned int result = 0;
if(this->GetCurrentPlaybackMode() == RealTimeMode)
{
if(m_RealTimePlayer.IsNotNull())
result = m_RealTimePlayer->GetNumberOfOutputs();
}
else if(this->GetCurrentPlaybackMode() == SequentialMode)
{
if(m_SequentialPlayer.IsNotNull())
result = m_SequentialPlayer->GetNumberOfOutputs();
}
// at the moment this works only if player is initialized
return result;
}
void QmitkIGTPlayerWidget::SetUpdateRate(unsigned int msecs)
{
m_PlayingTimer->setInterval((int) msecs); // set update timer update rate
}
void QmitkIGTPlayerWidget::OnPlayButtonClicked(bool checked)
{
if(CheckInputFileValid()) // no playing possible without valid input file
{
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
if(checked) // play
{
if( (isRealTimeMode && m_RealTimePlayer.IsNull()) || (isSequentialMode && m_SequentialPlayer.IsNull())) // start play
{
if(isRealTimeMode)
{
m_RealTimePlayer = mitk::NavigationDataPlayer::New();
m_RealTimePlayer->SetFileName(m_CmpFilename.toStdString());
try
{
m_RealTimePlayer->StartPlaying();
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start playing. Invalid or wrong file?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_Controls->playPushButton->setChecked(false);
m_RealTimePlayer = NULL;
return;
}
}
else if(isSequentialMode)
{
m_SequentialPlayer = mitk::NavigationDataSequentialPlayer::New();
try
{
m_SequentialPlayer->SetFileName(m_CmpFilename.toStdString());
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start playing. Invalid or wrong file type?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_Controls->playPushButton->setChecked(false);
m_RealTimePlayer = NULL;
return;
}
m_Controls->samplePositionHorizontalSlider->setMinimum(0);
m_Controls->samplePositionHorizontalSlider->setMaximum(m_SequentialPlayer->GetNumberOfSnapshots());
m_Controls->samplePositionHorizontalSlider->setEnabled(true);
}
m_PlayingTimer->start(100);
emit SignalPlayingStarted();
}
else // resume play
{
if(isRealTimeMode)
m_RealTimePlayer->Resume();
m_PlayingTimer->start(100);
emit SignalPlayingResumed();
}
}
else // pause
{
if(isRealTimeMode)
m_RealTimePlayer->Pause();
m_PlayingTimer->stop();
emit SignalPlayingPaused();
}
}
else
m_Controls->playPushButton->setChecked(false); // uncheck play button if file unvalid
}
QmitkIGTPlayerWidget::PlaybackMode QmitkIGTPlayerWidget::GetCurrentPlaybackMode()
{
if(m_Controls->sequencialModeCheckBox->isChecked())
return SequentialMode;
else
return RealTimeMode;
}
QTimer* QmitkIGTPlayerWidget::GetPlayingTimer()
{
return m_PlayingTimer;
}
void QmitkIGTPlayerWidget::OnStopPlaying()
{
this->StopPlaying();
}
void QmitkIGTPlayerWidget::StopPlaying()
{
m_PlayingTimer->stop();
emit SignalPlayingStopped();
if(m_RealTimePlayer.IsNotNull())
m_RealTimePlayer->StopPlaying();
m_RealTimePlayer = NULL;
m_SequentialPlayer = NULL;
m_StartTime = -1; // set starttime back
m_CurrentSequentialPointNumber = 0;
m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber);
m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
this->ResetLCDNumbers();
m_Controls->playPushButton->setChecked(false); // set play button unchecked
}
void QmitkIGTPlayerWidget::OnPlaying()
{
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
if(isRealTimeMode && m_RealTimePlayer.IsNull())
return;
else if(isSequentialMode && m_SequentialPlayer.IsNull())
return;
if(isRealTimeMode && m_StartTime < 0)
m_StartTime = m_RealTimePlayer->GetOutput()->GetTimeStamp(); // get playback start time
if(isRealTimeMode && !m_RealTimePlayer->IsAtEnd())
{
m_RealTimePlayer->Update(); // update player
int msc = (int) (m_RealTimePlayer->GetOutput()->GetTimeStamp() - m_StartTime);
// calculation for playing time display
int ms = msc % 1000;
msc = (msc - ms) / 1000;
int s = msc % 60;
int min = (msc-s) / 60;
// set lcd numbers
m_Controls->msecLCDNumber->display(ms);
m_Controls->secLCDNumber->display(s);
m_Controls->minLCDNumber->display(min);
emit SignalPlayerUpdated(); // player successfully updated
}
else if(isSequentialMode && (m_CurrentSequentialPointNumber < m_SequentialPlayer->GetNumberOfSnapshots()))
{
m_SequentialPlayer->Update(); // update sequential player
m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber++); // refresh slider position
m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
//for debugging purposes
- //std::cout << "Sample: " << m_CurrentSequentialPointNumber << " X: " << m_SequentialPlayer->GetOutput(0)->GetPosition()[0] << " Y: " << m_SequentialPlayer->GetOutput(0)->GetPosition()[1] << " Y: " << m_SequentialPlayer->GetOutput(0)->GetPosition()[2] << std::endl;
+ //std::cout << "Sample: " << m_CurrentSequentialPointNumber << " X: " << m_SequentialPlayer->GetOutput()->GetPosition()[0] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[1] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[2] << std::endl;
emit SignalPlayerUpdated(); // player successfully updated
}
else
this->StopPlaying(); // if player is at EOF
}
const std::vector<mitk::NavigationData::Pointer> QmitkIGTPlayerWidget::GetNavigationDatas()
{
std::vector<mitk::NavigationData::Pointer> navDatas;
if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
{
for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
{
navDatas.push_back(m_RealTimePlayer->GetOutput(i)); // push back current navigation data for each tool
}
}
else if(this->GetCurrentPlaybackMode() == SequentialMode && m_SequentialPlayer.IsNotNull())
{
for(unsigned int i=0; i < m_SequentialPlayer->GetNumberOfOutputs(); ++i)
{
navDatas.push_back(m_SequentialPlayer->GetOutput(i)); // push back current navigation data for each tool
}
}
return navDatas;
}
const mitk::PointSet::Pointer QmitkIGTPlayerWidget::GetNavigationDatasPointSet()
{
mitk::PointSet::Pointer result = mitk::PointSet::New();
mitk::PointSet::PointType pointType;
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
{
int numberOfOutputs = 0;
if(isRealTimeMode)
numberOfOutputs = m_RealTimePlayer->GetNumberOfOutputs();
else if(isSequentialMode)
numberOfOutputs = m_SequentialPlayer->GetNumberOfOutputs();
for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
{
mitk::NavigationData::PositionType position;
if(isRealTimeMode)
position = m_RealTimePlayer->GetOutput(i)->GetPosition();
else if(isSequentialMode)
position = m_SequentialPlayer->GetOutput(i)->GetPosition();
pointType[0] = position[0];
pointType[1] = position[1];
pointType[2] = position[2];
result->InsertPoint(i,pointType); // insert current ND as Pointtype in PointSet for return
}
}
return result;
}
const mitk::PointSet::PointType QmitkIGTPlayerWidget::GetNavigationDataPoint(unsigned int index)
{
if( index > this->GetNumberOfTools() || index < 0 )
throw std::out_of_range("Tool Index out of range!");
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
// create return PointType from current ND for tool index
mitk::PointSet::PointType result;
if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
{
mitk::NavigationData::PositionType position;
if(isRealTimeMode)
position = m_RealTimePlayer->GetOutput(index)->GetPosition();
else if(isSequentialMode)
position = m_SequentialPlayer->GetOutput(index)->GetPosition();
result[0] = position[0];
result[1] = position[1];
result[2] = position[2];
}
return result;
}
void QmitkIGTPlayerWidget::SetInputFileName(const QString& inputFileName)
{
this->OnGoToEnd(); /// stops playing and resets lcd numbers
QString oldName = m_CmpFilename;
m_CmpFilename.clear();
m_CmpFilename = inputFileName;
QFile file(m_CmpFilename);
if(m_CmpFilename.isEmpty() || !file.exists())
{
QMessageBox::warning(NULL, "Warning", QString("Please enter valid path! Using previous path again."));
m_CmpFilename=oldName;
m_Controls->inputFileLineEdit->setText(m_CmpFilename);
}
}
void QmitkIGTPlayerWidget::SetRealTimePlayer( mitk::NavigationDataPlayer::Pointer player )
{
if(player.IsNotNull())
m_RealTimePlayer = player;
}
void QmitkIGTPlayerWidget::SetSequentialPlayer( mitk::NavigationDataSequentialPlayer::Pointer player )
{
if(player.IsNotNull())
m_SequentialPlayer = player;
}
void QmitkIGTPlayerWidget::OnSelectPressed()
{
QString oldName = m_CmpFilename;
m_CmpFilename.clear();
m_CmpFilename = QFileDialog::getOpenFileName(this, "Load tracking data", QDir::currentPath(),"XML files (*.xml)");
if (m_CmpFilename.isEmpty())//if something went wrong or user pressed cancel in the save dialog
m_CmpFilename=oldName;
else
{
this->OnGoToEnd(); /// stops playing and resets lcd numbers
emit SignalInputFileChanged();
}
m_Controls->inputFileLineEdit->setText(m_CmpFilename);
}
void QmitkIGTPlayerWidget::OnGoToEnd()
{
this->StopPlaying();
// reset lcd numbers
this->ResetLCDNumbers();
}
void QmitkIGTPlayerWidget::OnGoToBegin()
{
// stop player manual so no PlayingStopped()
m_PlayingTimer->stop();
if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
{
m_RealTimePlayer->StopPlaying();
m_RealTimePlayer = NULL; // set player to NULL so it can be initialized again if playback is called afterwards
}
m_StartTime = -1; // set starttime back
//reset view elements
m_Controls->playPushButton->setChecked(false);
this->ResetLCDNumbers();
}
void QmitkIGTPlayerWidget::ResetLCDNumbers()
{
m_Controls->minLCDNumber->display(QString("00"));
m_Controls->secLCDNumber->display(QString("00"));
m_Controls->msecLCDNumber->display(QString("000"));
}
void QmitkIGTPlayerWidget::SetTrajectoryNames(const QStringList toolNames)
{
QComboBox* cBox = m_Controls->trajectorySelectComboBox;
if(cBox->count() > 0)
this->ClearTrajectorySelectCombobox();
// before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
if(!toolNames.isEmpty())
m_Controls->trajectorySelectComboBox->insertItems(0, toolNames); // adding current tool names to combobox
// reconnect after performed changes
connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
}
int QmitkIGTPlayerWidget::GetResolution()
{
return m_Controls->resolutionSpinBox->value(); // return currently selected trajectory resolution
}
void QmitkIGTPlayerWidget::ClearTrajectorySelectCombobox()
{
// before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
m_Controls->trajectorySelectComboBox->clear();
// reconnect after performed changes
connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
}
void QmitkIGTPlayerWidget::OnSequencialModeToggled(bool toggled)
{
this->StopPlaying(); // stop playing when mode is changed
if(toggled)
{
m_Controls->samplePositionHorizontalSlider->setEnabled(true); // enable slider if sequential mode
}
else if(!toggled)
{
m_Controls->samplePositionHorizontalSlider->setSliderPosition(0); // set back and disable slider
m_Controls->samplePositionHorizontalSlider->setDisabled(true);
}
}
void QmitkIGTPlayerWidget::OnSliderReleased()
{
int currentSliderValue = m_Controls->samplePositionHorizontalSlider->value(); // current slider value selected through user movement
if(currentSliderValue > m_CurrentSequentialPointNumber) // at the moment only forward scrolling is possible
{
m_SequentialPlayer->GoToSnapshot(currentSliderValue); // move player to selected snapshot
m_CurrentSequentialPointNumber = currentSliderValue;
m_Controls->sampleLCDNumber->display(currentSliderValue); // update lcdnumber in widget
}
else
m_Controls->samplePositionHorizontalSlider->setValue(m_CurrentSequentialPointNumber);
}
void QmitkIGTPlayerWidget::OnSliderPressed()
{
if(m_Controls->playPushButton->isChecked()) // check if widget is playing
m_Controls->playPushButton->click(); // perform click to pause the play
}
\ No newline at end of file
diff --git a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
index df38f85e76..68c2a59a8c 100644
--- a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
+++ b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
@@ -1,511 +1,511 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkExtractDirectedPlaneImageFilter.h"
#include "mitkAbstractTransformGeometry.h"
//#include "mitkImageMapperGL2D.h"
#include <mitkProperties.h>
#include <mitkDataNode.h>
#include <mitkDataNodeFactory.h>
#include <mitkResliceMethodProperty.h>
#include "vtkMitkThickSlicesFilter.h"
#include <vtkTransform.h>
#include <vtkGeneralTransform.h>
#include <vtkImageData.h>
#include <vtkImageChangeInformation.h>
#include <vtkPoints.h>
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
#include "pic2vtk.h"
mitk::ExtractDirectedPlaneImageFilter::ExtractDirectedPlaneImageFilter()
: m_WorldGeometry(NULL)
{
MITK_WARN << "Class ExtractDirectedPlaneImageFilter is deprecated! Use ExtractSliceFilter instead.";
m_Reslicer = vtkImageReslice::New();
m_TargetTimestep = 0;
m_InPlaneResampleExtentByGeometry = true;
m_ResliceInterpolationProperty = NULL;//VtkResliceInterpolationProperty::New(); //TODO initial with value
m_ThickSlicesMode = 0;
m_ThickSlicesNum = 1;
}
mitk::ExtractDirectedPlaneImageFilter::~ExtractDirectedPlaneImageFilter()
{
if(m_ResliceInterpolationProperty!=NULL)m_ResliceInterpolationProperty->Delete();
m_Reslicer->Delete();
}
void mitk::ExtractDirectedPlaneImageFilter::GenerateData()
{
// A world geometry must be set...
if ( m_WorldGeometry == NULL )
{
itkWarningMacro(<<"No world geometry has been set. Returning.");
return;
}
Image *input = const_cast< ImageToImageFilter::InputImageType* >( this->GetInput() );
input->Update();
if ( input == NULL )
{
itkWarningMacro(<<"No input set.");
return;
}
const TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
if ( ( inputTimeGeometry == NULL )
|| ( inputTimeGeometry->GetTimeSteps() == 0 ) )
{
itkWarningMacro(<<"Error reading input image geometry.");
return;
}
// Get the target timestep; if none is set, use the lowest given.
unsigned int timestep = 0;
if ( ! m_TargetTimestep )
{
ScalarType time = m_WorldGeometry->GetTimeBounds()[0];
if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
{
timestep = inputTimeGeometry->MSToTimeStep( time );
}
}
else timestep = m_TargetTimestep;
if ( inputTimeGeometry->IsValidTime( timestep ) == false )
{
itkWarningMacro(<<"This is not a valid timestep: "<<timestep);
return;
}
// check if there is something to display.
if ( ! input->IsVolumeSet( timestep ) )
{
itkWarningMacro(<<"No volume data existent at given timestep "<<timestep);
return;
}
Image::RegionType requestedRegion = input->GetLargestPossibleRegion();
requestedRegion.SetIndex( 3, timestep );
requestedRegion.SetSize( 3, 1 );
requestedRegion.SetSize( 4, 1 );
input->SetRequestedRegion( &requestedRegion );
input->Update();
vtkImageData* inputData = input->GetVtkImageData( timestep );
if ( inputData == NULL )
{
itkWarningMacro(<<"Could not extract vtk image data for given timestep"<<timestep);
return;
}
vtkFloatingPointType spacing[3];
inputData->GetSpacing( spacing );
// how big the area is in physical coordinates: widthInMM x heightInMM pixels
mitk::ScalarType widthInMM, heightInMM;
// where we want to sample
Point3D origin;
Vector3D right, bottom, normal;
Vector3D rightInIndex, bottomInIndex;
assert( input->GetTimeSlicedGeometry() == inputTimeGeometry );
// take transform of input image into account
Geometry3D* inputGeometry = inputTimeGeometry->GetGeometry3D( timestep );
if ( inputGeometry == NULL )
{
itkWarningMacro(<<"There is no Geometry3D at given timestep "<<timestep);
return;
}
ScalarType mmPerPixel[2];
// Bounds information for reslicing (only required if reference geometry
// is present)
vtkFloatingPointType bounds[6];
bool boundsInitialized = false;
for ( int i = 0; i < 6; ++i )
{
bounds[i] = 0.0;
}
Vector2D extent; extent.Fill( 0.0 );
// Do we have a simple PlaneGeometry?
if ( dynamic_cast< const PlaneGeometry * >( m_WorldGeometry ) != NULL )
{
const PlaneGeometry *planeGeometry =
static_cast< const PlaneGeometry * >( m_WorldGeometry );
origin = planeGeometry->GetOrigin();
right = planeGeometry->GetAxisVector( 0 );
bottom = planeGeometry->GetAxisVector( 1 );
normal = planeGeometry->GetNormal();
if ( m_InPlaneResampleExtentByGeometry )
{
// Resampling grid corresponds to the current world geometry. This
// means that the spacing of the output 2D image depends on the
// currently selected world geometry, and *not* on the image itself.
extent[0] = m_WorldGeometry->GetExtent( 0 );
extent[1] = m_WorldGeometry->GetExtent( 1 );
}
else
{
// Resampling grid corresponds to the input geometry. This means that
// the spacing of the output 2D image is directly derived from the
// associated input image, regardless of the currently selected world
// geometry.
inputGeometry->WorldToIndex( right, rightInIndex );
inputGeometry->WorldToIndex( bottom, bottomInIndex );
extent[0] = rightInIndex.GetNorm();
extent[1] = bottomInIndex.GetNorm();
}
// Get the extent of the current world geometry and calculate resampling
// spacing therefrom.
widthInMM = m_WorldGeometry->GetExtentInMM( 0 );
heightInMM = m_WorldGeometry->GetExtentInMM( 1 );
mmPerPixel[0] = widthInMM / extent[0];
mmPerPixel[1] = heightInMM / extent[1];
right.Normalize();
bottom.Normalize();
normal.Normalize();
//origin += right * ( mmPerPixel[0] * 0.5 );
//origin += bottom * ( mmPerPixel[1] * 0.5 );
//widthInMM -= mmPerPixel[0];
//heightInMM -= mmPerPixel[1];
// Use inverse transform of the input geometry for reslicing the 3D image
m_Reslicer->SetResliceTransform(
inputGeometry->GetVtkTransform()->GetLinearInverse() );
// Set background level to TRANSLUCENT (see Geometry2DDataVtkMapper3D)
m_Reslicer->SetBackgroundLevel( -32768 );
// Check if a reference geometry does exist (as would usually be the case for
// PlaneGeometry).
// Note: this is currently not strictly required, but could facilitate
// correct plane clipping.
if ( m_WorldGeometry->GetReferenceGeometry() )
{
// Calculate the actual bounds of the transformed plane clipped by the
// dataset bounding box; this is required for drawing the texture at the
// correct position during 3D mapping.
boundsInitialized = this->CalculateClippedPlaneBounds(
m_WorldGeometry->GetReferenceGeometry(), planeGeometry, bounds );
}
}
// Do we have an AbstractTransformGeometry?
else if ( dynamic_cast< const AbstractTransformGeometry * >( m_WorldGeometry ) )
{
const mitk::AbstractTransformGeometry* abstractGeometry =
dynamic_cast< const AbstractTransformGeometry * >(m_WorldGeometry);
extent[0] = abstractGeometry->GetParametricExtent(0);
extent[1] = abstractGeometry->GetParametricExtent(1);
widthInMM = abstractGeometry->GetParametricExtentInMM(0);
heightInMM = abstractGeometry->GetParametricExtentInMM(1);
mmPerPixel[0] = widthInMM / extent[0];
mmPerPixel[1] = heightInMM / extent[1];
origin = abstractGeometry->GetPlane()->GetOrigin();
right = abstractGeometry->GetPlane()->GetAxisVector(0);
right.Normalize();
bottom = abstractGeometry->GetPlane()->GetAxisVector(1);
bottom.Normalize();
normal = abstractGeometry->GetPlane()->GetNormal();
normal.Normalize();
// Use a combination of the InputGeometry *and* the possible non-rigid
// AbstractTransformGeometry for reslicing the 3D Image
vtkGeneralTransform *composedResliceTransform = vtkGeneralTransform::New();
composedResliceTransform->Identity();
composedResliceTransform->Concatenate(
inputGeometry->GetVtkTransform()->GetLinearInverse() );
composedResliceTransform->Concatenate(
abstractGeometry->GetVtkAbstractTransform()
);
m_Reslicer->SetResliceTransform( composedResliceTransform );
// Set background level to BLACK instead of translucent, to avoid
// boundary artifacts (see Geometry2DDataVtkMapper3D)
m_Reslicer->SetBackgroundLevel( -1023 );
composedResliceTransform->Delete();
}
else
{
itkWarningMacro(<<"World Geometry has to be a PlaneGeometry or an AbstractTransformGeometry.");
return;
}
// Make sure that the image to be resliced has a certain minimum size.
if ( (extent[0] <= 2) && (extent[1] <= 2) )
{
itkWarningMacro(<<"Image is too small to be resliced...");
return;
}
vtkImageChangeInformation * unitSpacingImageFilter = vtkImageChangeInformation::New() ;
unitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
unitSpacingImageFilter->SetInput( inputData );
m_Reslicer->SetInput( unitSpacingImageFilter->GetOutput() );
unitSpacingImageFilter->Delete();
//m_Reslicer->SetInput( inputData );
m_Reslicer->SetOutputDimensionality( 2 );
m_Reslicer->SetOutputOrigin( 0.0, 0.0, 0.0 );
Vector2D pixelsPerMM;
pixelsPerMM[0] = 1.0 / mmPerPixel[0];
pixelsPerMM[1] = 1.0 / mmPerPixel[1];
//calulate the originArray and the orientations for the reslice-filter
double originArray[3];
itk2vtk( origin, originArray );
m_Reslicer->SetResliceAxesOrigin( originArray );
double cosines[9];
// direction of the X-axis of the sampled result
- vnl2vtk( right.Get_vnl_vector(), cosines );
+ vnl2vtk( right.GetVnlVector(), cosines );
// direction of the Y-axis of the sampled result
- vnl2vtk( bottom.Get_vnl_vector(), cosines + 3 );
+ vnl2vtk( bottom.GetVnlVector(), cosines + 3 );
// normal of the plane
- vnl2vtk( normal.Get_vnl_vector(), cosines + 6 );
+ vnl2vtk( normal.GetVnlVector(), cosines + 6 );
m_Reslicer->SetResliceAxesDirectionCosines( cosines );
int xMin, xMax, yMin, yMax;
if ( boundsInitialized )
{
xMin = static_cast< int >( bounds[0] / mmPerPixel[0] );//+ 0.5 );
xMax = static_cast< int >( bounds[1] / mmPerPixel[0] );//+ 0.5 );
yMin = static_cast< int >( bounds[2] / mmPerPixel[1] );//+ 0.5);
yMax = static_cast< int >( bounds[3] / mmPerPixel[1] );//+ 0.5 );
}
else
{
// If no reference geometry is available, we also don't know about the
// maximum plane size; so the overlap is just ignored
xMin = yMin = 0;
xMax = static_cast< int >( extent[0] - pixelsPerMM[0] );//+ 0.5 );
yMax = static_cast< int >( extent[1] - pixelsPerMM[1] );//+ 0.5 );
}
m_Reslicer->SetOutputSpacing( mmPerPixel[0], mmPerPixel[1], 1.0 );
// xMax and yMax are meant exclusive until now, whereas
// SetOutputExtent wants an inclusive bound. Thus, we need
// to subtract 1.
m_Reslicer->SetOutputExtent( xMin, xMax-1, yMin, yMax-1, 0, 1 );
// Do the reslicing. Modified() is called to make sure that the reslicer is
// executed even though the input geometry information did not change; this
// is necessary when the input /em data, but not the /em geometry changes.
m_Reslicer->Modified();
m_Reslicer->ReleaseDataFlagOn();
m_Reslicer->Update();
// 1. Check the result
vtkImageData* reslicedImage = m_Reslicer->GetOutput();
//mitkIpPicDescriptor *pic = Pic2vtk::convert( reslicedImage );
if((reslicedImage == NULL) || (reslicedImage->GetDataDimension() < 1))
{
itkWarningMacro(<<"Reslicer returned empty image");
return;
}
unsigned int dimensions[2];
dimensions[0] = (unsigned int)extent[0]; dimensions[1] = (unsigned int)extent[1];
Vector3D spacingVector;
FillVector3D(spacingVector, mmPerPixel[0], mmPerPixel[1], 1.0);
mitk::Image::Pointer resultImage = this->GetOutput();
resultImage->Initialize(input->GetPixelType(), 2, dimensions );
//resultImage->Initialize( pic );
resultImage->SetSpacing( spacingVector );
//resultImage->SetPicVolume( pic );
//mitkIpPicFree(pic);
/*unsigned int dimensions[2];
dimensions[0] = (unsigned int)extent[0]; dimensions[1] = (unsigned int)extent[1];
Vector3D spacingVector;
FillVector3D(spacingVector, mmPerPixel[0], mmPerPixel[1], 1.0);
mitk::Image::Pointer resultImage = this->GetOutput();
resultImage->Initialize(m_Reslicer->GetOutput());
resultImage->Initialize(inputImage->GetPixelType(), 2, dimensions);
resultImage->SetSpacing(spacingVector);
resultImage->SetSlice(m_Reslicer->GetOutput());*/
}
void mitk::ExtractDirectedPlaneImageFilter::GenerateOutputInformation()
{
Superclass::GenerateOutputInformation();
}
bool mitk::ExtractDirectedPlaneImageFilter
::CalculateClippedPlaneBounds( const Geometry3D *boundingGeometry,
const PlaneGeometry *planeGeometry, vtkFloatingPointType *bounds )
{
// Clip the plane with the bounding geometry. To do so, the corner points
// of the bounding box are transformed by the inverse transformation
// matrix, and the transformed bounding box edges derived therefrom are
// clipped with the plane z=0. The resulting min/max values are taken as
// bounds for the image reslicer.
const BoundingBox *boundingBox = boundingGeometry->GetBoundingBox();
BoundingBox::PointType bbMin = boundingBox->GetMinimum();
BoundingBox::PointType bbMax = boundingBox->GetMaximum();
vtkPoints *points = vtkPoints::New();
if(boundingGeometry->GetImageGeometry())
{
points->InsertPoint( 0, bbMin[0]-0.5, bbMin[1]-0.5, bbMin[2]-0.5 );
points->InsertPoint( 1, bbMin[0]-0.5, bbMin[1]-0.5, bbMax[2]-0.5 );
points->InsertPoint( 2, bbMin[0]-0.5, bbMax[1]-0.5, bbMax[2]-0.5 );
points->InsertPoint( 3, bbMin[0]-0.5, bbMax[1]-0.5, bbMin[2]-0.5 );
points->InsertPoint( 4, bbMax[0]-0.5, bbMin[1]-0.5, bbMin[2]-0.5 );
points->InsertPoint( 5, bbMax[0]-0.5, bbMin[1]-0.5, bbMax[2]-0.5 );
points->InsertPoint( 6, bbMax[0]-0.5, bbMax[1]-0.5, bbMax[2]-0.5 );
points->InsertPoint( 7, bbMax[0]-0.5, bbMax[1]-0.5, bbMin[2]-0.5 );
}
else
{
points->InsertPoint( 0, bbMin[0], bbMin[1], bbMin[2] );
points->InsertPoint( 1, bbMin[0], bbMin[1], bbMax[2] );
points->InsertPoint( 2, bbMin[0], bbMax[1], bbMax[2] );
points->InsertPoint( 3, bbMin[0], bbMax[1], bbMin[2] );
points->InsertPoint( 4, bbMax[0], bbMin[1], bbMin[2] );
points->InsertPoint( 5, bbMax[0], bbMin[1], bbMax[2] );
points->InsertPoint( 6, bbMax[0], bbMax[1], bbMax[2] );
points->InsertPoint( 7, bbMax[0], bbMax[1], bbMin[2] );
}
vtkPoints *newPoints = vtkPoints::New();
vtkTransform *transform = vtkTransform::New();
transform->Identity();
transform->Concatenate(
planeGeometry->GetVtkTransform()->GetLinearInverse()
);
transform->Concatenate( boundingGeometry->GetVtkTransform() );
transform->TransformPoints( points, newPoints );
transform->Delete();
bounds[0] = bounds[2] = 10000000.0;
bounds[1] = bounds[3] = -10000000.0;
bounds[4] = bounds[5] = 0.0;
this->LineIntersectZero( newPoints, 0, 1, bounds );
this->LineIntersectZero( newPoints, 1, 2, bounds );
this->LineIntersectZero( newPoints, 2, 3, bounds );
this->LineIntersectZero( newPoints, 3, 0, bounds );
this->LineIntersectZero( newPoints, 0, 4, bounds );
this->LineIntersectZero( newPoints, 1, 5, bounds );
this->LineIntersectZero( newPoints, 2, 6, bounds );
this->LineIntersectZero( newPoints, 3, 7, bounds );
this->LineIntersectZero( newPoints, 4, 5, bounds );
this->LineIntersectZero( newPoints, 5, 6, bounds );
this->LineIntersectZero( newPoints, 6, 7, bounds );
this->LineIntersectZero( newPoints, 7, 4, bounds );
// clean up vtk data
points->Delete();
newPoints->Delete();
if ( (bounds[0] > 9999999.0) || (bounds[2] > 9999999.0)
|| (bounds[1] < -9999999.0) || (bounds[3] < -9999999.0) )
{
return false;
}
else
{
// The resulting bounds must be adjusted by the plane spacing, since we
// we have so far dealt with index coordinates
const float *planeSpacing = planeGeometry->GetFloatSpacing();
bounds[0] *= planeSpacing[0];
bounds[1] *= planeSpacing[0];
bounds[2] *= planeSpacing[1];
bounds[3] *= planeSpacing[1];
bounds[4] *= planeSpacing[2];
bounds[5] *= planeSpacing[2];
return true;
}
}
bool mitk::ExtractDirectedPlaneImageFilter
::LineIntersectZero( vtkPoints *points, int p1, int p2,
vtkFloatingPointType *bounds )
{
vtkFloatingPointType point1[3];
vtkFloatingPointType point2[3];
points->GetPoint( p1, point1 );
points->GetPoint( p2, point2 );
if ( (point1[2] * point2[2] <= 0.0) && (point1[2] != point2[2]) )
{
double x, y;
x = ( point1[0] * point2[2] - point1[2] * point2[0] ) / ( point2[2] - point1[2] );
y = ( point1[1] * point2[2] - point1[2] * point2[1] ) / ( point2[2] - point1[2] );
if ( x < bounds[0] ) { bounds[0] = x; }
if ( x > bounds[1] ) { bounds[1] = x; }
if ( y < bounds[2] ) { bounds[2] = y; }
if ( y > bounds[3] ) { bounds[3] = y; }
bounds[4] = bounds[5] = 0.0;
return true;
}
return false;
}
diff --git a/Modules/ImageExtraction/mitkExtractImageFilter.cpp b/Modules/ImageExtraction/mitkExtractImageFilter.cpp
index eab7781dd2..4300630420 100644
--- a/Modules/ImageExtraction/mitkExtractImageFilter.cpp
+++ b/Modules/ImageExtraction/mitkExtractImageFilter.cpp
@@ -1,245 +1,246 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkExtractImageFilter.h"
#include "mitkImageCast.h"
#include "mitkPlaneGeometry.h"
#include "mitkITKImageImport.h"
#include "mitkImageTimeSelector.h"
#include <mitkImageAccessByItk.h>
#include <itkExtractImageFilter.h>
mitk::ExtractImageFilter::ExtractImageFilter()
:m_SliceIndex(0),
m_SliceDimension(0),
m_TimeStep(0)
{
MITK_WARN << "Class ExtractImageFilter is deprecated! Use ExtractSliceFilter instead.";
}
mitk::ExtractImageFilter::~ExtractImageFilter()
{
}
void mitk::ExtractImageFilter::GenerateData()
{
Image::ConstPointer input = ImageToImageFilter::GetInput(0);
if ( (input->GetDimension() > 4) || (input->GetDimension() < 2) )
{
MITK_ERROR << "mitk::ExtractImageFilter:GenerateData works only with 3D and 3D+t images, sorry." << std::endl;
itkExceptionMacro("mitk::ExtractImageFilter works only with 3D and 3D+t images, sorry.");
return;
}
else if (input->GetDimension() == 4)
{
- ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
+ mitk::ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( input );
timeSelector->SetTimeNr( m_TimeStep );
timeSelector->UpdateLargestPossibleRegion();
input = timeSelector->GetOutput();
}
else if (input->GetDimension() == 2)
{
Image::Pointer resultImage = ImageToImageFilter::GetOutput();
resultImage = const_cast<Image*>(input.GetPointer());
ImageToImageFilter::SetNthOutput( 0, resultImage );
return;
}
if ( m_SliceDimension >= input->GetDimension() )
{
MITK_ERROR << "mitk::ExtractImageFilter:GenerateData m_SliceDimension == " << m_SliceDimension << " makes no sense with an " << input->GetDimension() << "D image." << std::endl;
itkExceptionMacro("This is not a sensible value for m_SliceDimension.");
return;
}
AccessFixedDimensionByItk( input, ItkImageProcessing, 3 );
// set a nice geometry for display and point transformations
Geometry3D* inputImageGeometry = ImageToImageFilter::GetInput(0)->GetGeometry();
if (!inputImageGeometry)
{
MITK_ERROR << "In ExtractImageFilter::ItkImageProcessing: Input image has no geometry!" << std::endl;
return;
}
PlaneGeometry::PlaneOrientation orientation = PlaneGeometry::Axial;
switch ( m_SliceDimension )
{
default:
case 2:
orientation = PlaneGeometry::Axial;
break;
case 1:
orientation = PlaneGeometry::Frontal;
break;
case 0:
orientation = PlaneGeometry::Sagittal;
break;
}
PlaneGeometry::Pointer planeGeometry = PlaneGeometry::New();
planeGeometry->InitializeStandardPlane( inputImageGeometry, orientation, (ScalarType)m_SliceIndex, true, false );
Image::Pointer resultImage = ImageToImageFilter::GetOutput();
planeGeometry->ChangeImageGeometryConsideringOriginOffset(true);
resultImage->SetGeometry( planeGeometry );
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::ExtractImageFilter::ItkImageProcessing( itk::Image<TPixel,VImageDimension>* itkImage )
{
// use the itk::ExtractImageFilter to get a 2D image
typedef itk::Image< TPixel, VImageDimension > ImageType3D;
typedef itk::Image< TPixel, VImageDimension-1 > ImageType2D;
typename ImageType3D::RegionType inSliceRegion = itkImage->GetLargestPossibleRegion();
inSliceRegion.SetSize( m_SliceDimension, 0 );
typedef itk::ExtractImageFilter<ImageType3D, ImageType2D> ExtractImageFilterType;
typename ExtractImageFilterType::Pointer sliceExtractor = ExtractImageFilterType::New();
+ sliceExtractor->SetDirectionCollapseToSubmatrix();
sliceExtractor->SetInput( itkImage );
inSliceRegion.SetIndex( m_SliceDimension, m_SliceIndex );
sliceExtractor->SetExtractionRegion( inSliceRegion );
// calculate the output
sliceExtractor->UpdateLargestPossibleRegion();
typename ImageType2D::Pointer slice = sliceExtractor->GetOutput();
// re-import to MITK
Image::Pointer resultImage = ImageToImageFilter::GetOutput();
GrabItkImageMemory(slice, resultImage, NULL, false);
}
/*
* What is the input requested region that is required to produce the output
* requested region? By default, the largest possible region is always
* required but this is overridden in many subclasses. For instance, for an
* image processing filter where an output pixel is a simple function of an
* input pixel, the input requested region will be set to the output
* requested region. For an image processing filter where an output pixel is
* a function of the pixels in a neighborhood of an input pixel, then the
* input requested region will need to be larger than the output requested
* region (to avoid introducing artificial boundary conditions). This
* function should never request an input region that is outside the the
* input largest possible region (i.e. implementations of this method should
* crop the input requested region at the boundaries of the input largest
* possible region).
*/
void mitk::ExtractImageFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
ImageToImageFilter::InputImagePointer input = const_cast< ImageToImageFilter::InputImageType* > ( this->GetInput() );
Image::Pointer output = this->GetOutput();
if (input->GetDimension() == 2)
{
input->SetRequestedRegionToLargestPossibleRegion();
return;
}
Image::RegionType requestedRegion;
requestedRegion = output->GetRequestedRegion();
requestedRegion.SetIndex(0, 0);
requestedRegion.SetIndex(1, 0);
requestedRegion.SetIndex(2, 0);
requestedRegion.SetSize(0, input->GetDimension(0));
requestedRegion.SetSize(1, input->GetDimension(1));
requestedRegion.SetSize(2, input->GetDimension(2));
requestedRegion.SetIndex( m_SliceDimension, m_SliceIndex ); // only one slice needed
requestedRegion.SetSize( m_SliceDimension, 1 );
input->SetRequestedRegion( &requestedRegion );
}
/*
* Generate the information decribing the output data. The default
* implementation of this method will copy information from the input to the
* output. A filter may override this method if its output will have different
* information than its input. For instance, a filter that shrinks an image will
* need to provide an implementation for this method that changes the spacing of
* the pixels. Such filters should call their superclass' implementation of this
* method prior to changing the information values they need (i.e.
* GenerateOutputInformation() should call
* Superclass::GenerateOutputInformation() prior to changing the information.
*/
void mitk::ExtractImageFilter::GenerateOutputInformation()
{
Image::Pointer output = this->GetOutput();
Image::ConstPointer input = this->GetInput();
if (input.IsNull()) return;
if ( m_SliceDimension >= input->GetDimension() && input->GetDimension() != 2 )
{
MITK_ERROR << "mitk::ExtractImageFilter:GenerateOutputInformation m_SliceDimension == " << m_SliceDimension << " makes no sense with an " << input->GetDimension() << "D image." << std::endl;
itkExceptionMacro("This is not a sensible value for m_SliceDimension.");
return;
}
unsigned int sliceDimension( m_SliceDimension );
if ( input->GetDimension() == 2)
{
sliceDimension = 2;
}
unsigned int tmpDimensions[2];
switch ( sliceDimension )
{
default:
case 2:
// orientation = PlaneGeometry::Axial;
tmpDimensions[0] = input->GetDimension(0);
tmpDimensions[1] = input->GetDimension(1);
break;
case 1:
// orientation = PlaneGeometry::Frontal;
tmpDimensions[0] = input->GetDimension(0);
tmpDimensions[1] = input->GetDimension(2);
break;
case 0:
// orientation = PlaneGeometry::Sagittal;
tmpDimensions[0] = input->GetDimension(1);
tmpDimensions[1] = input->GetDimension(2);
break;
}
output->Initialize(input->GetPixelType(), 2, tmpDimensions, 1 /*input->GetNumberOfChannels()*/);
// initialize the spacing of the output
/*
Vector3D spacing = input->GetSlicedGeometry()->GetSpacing();
if(input->GetDimension()>=2)
spacing[2]=spacing[1];
else
spacing[2] = 1.0;
output->GetSlicedGeometry()->SetSpacing(spacing);
*/
output->SetPropertyList(input->GetPropertyList()->Clone());
}
diff --git a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
index 6aefa6ee3c..31dabfb6ef 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
+++ b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
@@ -1,1215 +1,1217 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImageStatisticsCalculator.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkExtractImageFilter.h"
#include <itkScalarImageToHistogramGenerator.h>
#include <itkChangeInformationImageFilter.h>
#include <itkExtractImageFilter.h>
#include <itkMinimumMaximumImageCalculator.h>
#include <itkStatisticsImageFilter.h>
#include <itkLabelStatisticsImageFilter.h>
#include <itkMaskImageFilter.h>
#include <itkCastImageFilter.h>
#include <itkImageFileWriter.h>
#include <itkVTKImageImport.h>
#include <itkVTKImageExport.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkPolyData.h>
#include <vtkLinearExtrusionFilter.h>
#include <vtkPolyDataToImageStencil.h>
#include <vtkImageStencil.h>
#include <vtkImageImport.h>
#include <vtkImageExport.h>
#include <vtkImageData.h>
#include <itkImageFileWriter.h>
#include <itkRescaleIntensityImageFilter.h>
#include <list>
#if ( ( VTK_MAJOR_VERSION <= 5 ) && ( VTK_MINOR_VERSION<=8) )
#include "mitkvtkLassoStencilSource.h"
#else
#include "vtkLassoStencilSource.h"
#endif
#include <vtkMetaImageWriter.h>
#include <exception>
namespace mitk
{
ImageStatisticsCalculator::ImageStatisticsCalculator()
: m_MaskingMode( MASKING_MODE_NONE ),
m_MaskingModeChanged( false ),
m_IgnorePixelValue(0.0),
m_DoIgnorePixelValue(false),
m_IgnorePixelValueChanged(false),
m_PlanarFigureAxis (0),
m_PlanarFigureSlice (0),
m_PlanarFigureCoordinate0 (0),
m_PlanarFigureCoordinate1 (0)
{
m_EmptyHistogram = HistogramType::New();
- HistogramType::SizeType histogramSize;
+ m_EmptyHistogram->SetMeasurementVectorSize(1);
+ HistogramType::SizeType histogramSize(1);
histogramSize.Fill( 256 );
m_EmptyHistogram->Initialize( histogramSize );
m_EmptyStatistics.Reset();
}
ImageStatisticsCalculator::~ImageStatisticsCalculator()
{
}
void ImageStatisticsCalculator::SetImage( const mitk::Image *image )
{
if ( m_Image != image )
{
m_Image = image;
this->Modified();
unsigned int numberOfTimeSteps = image->GetTimeSteps();
// Initialize vectors to time-size of this image
m_ImageHistogramVector.resize( numberOfTimeSteps );
m_MaskedImageHistogramVector.resize( numberOfTimeSteps );
m_PlanarFigureHistogramVector.resize( numberOfTimeSteps );
m_ImageStatisticsVector.resize( numberOfTimeSteps );
m_MaskedImageStatisticsVector.resize( numberOfTimeSteps );
m_PlanarFigureStatisticsVector.resize( numberOfTimeSteps );
m_ImageStatisticsTimeStampVector.resize( numberOfTimeSteps );
m_MaskedImageStatisticsTimeStampVector.resize( numberOfTimeSteps );
m_PlanarFigureStatisticsTimeStampVector.resize( numberOfTimeSteps );
m_ImageStatisticsCalculationTriggerVector.resize( numberOfTimeSteps );
m_MaskedImageStatisticsCalculationTriggerVector.resize( numberOfTimeSteps );
m_PlanarFigureStatisticsCalculationTriggerVector.resize( numberOfTimeSteps );
for ( unsigned int t = 0; t < image->GetTimeSteps(); ++t )
{
m_ImageStatisticsTimeStampVector[t].Modified();
m_ImageStatisticsCalculationTriggerVector[t] = true;
}
}
}
void ImageStatisticsCalculator::SetImageMask( const mitk::Image *imageMask )
{
if ( m_Image.IsNull() )
{
itkExceptionMacro( << "Image needs to be set first!" );
}
if ( m_Image->GetTimeSteps() != imageMask->GetTimeSteps() )
{
itkExceptionMacro( << "Image and image mask need to have equal number of time steps!" );
}
if ( m_ImageMask != imageMask )
{
m_ImageMask = imageMask;
this->Modified();
for ( unsigned int t = 0; t < m_Image->GetTimeSteps(); ++t )
{
m_MaskedImageStatisticsTimeStampVector[t].Modified();
m_MaskedImageStatisticsCalculationTriggerVector[t] = true;
}
}
}
void ImageStatisticsCalculator::SetPlanarFigure( mitk::PlanarFigure *planarFigure )
{
if ( m_Image.IsNull() )
{
itkExceptionMacro( << "Image needs to be set first!" );
}
if ( m_PlanarFigure != planarFigure )
{
m_PlanarFigure = planarFigure;
this->Modified();
for ( unsigned int t = 0; t < m_Image->GetTimeSteps(); ++t )
{
m_PlanarFigureStatisticsTimeStampVector[t].Modified();
m_PlanarFigureStatisticsCalculationTriggerVector[t] = true;
}
}
}
void ImageStatisticsCalculator::SetMaskingMode( unsigned int mode )
{
if ( m_MaskingMode != mode )
{
m_MaskingMode = mode;
m_MaskingModeChanged = true;
this->Modified();
}
}
void ImageStatisticsCalculator::SetMaskingModeToNone()
{
if ( m_MaskingMode != MASKING_MODE_NONE )
{
m_MaskingMode = MASKING_MODE_NONE;
m_MaskingModeChanged = true;
this->Modified();
}
}
void ImageStatisticsCalculator::SetMaskingModeToImage()
{
if ( m_MaskingMode != MASKING_MODE_IMAGE )
{
m_MaskingMode = MASKING_MODE_IMAGE;
m_MaskingModeChanged = true;
this->Modified();
}
}
void ImageStatisticsCalculator::SetMaskingModeToPlanarFigure()
{
if ( m_MaskingMode != MASKING_MODE_PLANARFIGURE )
{
m_MaskingMode = MASKING_MODE_PLANARFIGURE;
m_MaskingModeChanged = true;
this->Modified();
}
}
void ImageStatisticsCalculator::SetIgnorePixelValue(double value)
{
if ( m_IgnorePixelValue != value )
{
m_IgnorePixelValue = value;
if(m_DoIgnorePixelValue)
{
m_IgnorePixelValueChanged = true;
}
this->Modified();
}
}
double ImageStatisticsCalculator::GetIgnorePixelValue()
{
return m_IgnorePixelValue;
}
void ImageStatisticsCalculator::SetDoIgnorePixelValue(bool value)
{
if ( m_DoIgnorePixelValue != value )
{
m_DoIgnorePixelValue = value;
m_IgnorePixelValueChanged = true;
this->Modified();
}
}
bool ImageStatisticsCalculator::GetDoIgnorePixelValue()
{
return m_DoIgnorePixelValue;
}
bool ImageStatisticsCalculator::ComputeStatistics( unsigned int timeStep )
{
if (m_Image.IsNull() )
{
mitkThrow() << "Image not set!";
}
if (!m_Image->IsInitialized())
{
mitkThrow() << "Image not initialized!";
}
if ( m_Image->GetReferenceCount() == 1 )
{
// Image no longer valid; we are the only ones to still hold a reference on it
return false;
}
if ( timeStep >= m_Image->GetTimeSteps() )
{
throw std::runtime_error( "Error: invalid time step!" );
}
// If a mask was set but we are the only ones to still hold a reference on
// it, delete it.
if ( m_ImageMask.IsNotNull() && (m_ImageMask->GetReferenceCount() == 1) )
{
m_ImageMask = NULL;
}
// Check if statistics is already up-to-date
unsigned long imageMTime = m_ImageStatisticsTimeStampVector[timeStep].GetMTime();
unsigned long maskedImageMTime = m_MaskedImageStatisticsTimeStampVector[timeStep].GetMTime();
unsigned long planarFigureMTime = m_PlanarFigureStatisticsTimeStampVector[timeStep].GetMTime();
bool imageStatisticsCalculationTrigger = m_ImageStatisticsCalculationTriggerVector[timeStep];
bool maskedImageStatisticsCalculationTrigger = m_MaskedImageStatisticsCalculationTriggerVector[timeStep];
bool planarFigureStatisticsCalculationTrigger = m_PlanarFigureStatisticsCalculationTriggerVector[timeStep];
if ( !m_IgnorePixelValueChanged
&& ((m_MaskingMode != MASKING_MODE_NONE) || (imageMTime > m_Image->GetMTime() && !imageStatisticsCalculationTrigger))
&& ((m_MaskingMode != MASKING_MODE_IMAGE) || (maskedImageMTime > m_ImageMask->GetMTime() && !maskedImageStatisticsCalculationTrigger))
&& ((m_MaskingMode != MASKING_MODE_PLANARFIGURE) || (planarFigureMTime > m_PlanarFigure->GetMTime() && !planarFigureStatisticsCalculationTrigger)) )
{
// Statistics is up to date!
if ( m_MaskingModeChanged )
{
m_MaskingModeChanged = false;
return true;
}
else
{
return false;
}
}
// Reset state changed flag
m_MaskingModeChanged = false;
m_IgnorePixelValueChanged = false;
// Depending on masking mode, extract and/or generate the required image
// and mask data from the user input
this->ExtractImageAndMask( timeStep );
StatisticsContainer *statisticsContainer;
HistogramContainer *histogramContainer;
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
default:
if(!m_DoIgnorePixelValue)
{
statisticsContainer = &m_ImageStatisticsVector[timeStep];
histogramContainer = &m_ImageHistogramVector[timeStep];
m_ImageStatisticsTimeStampVector[timeStep].Modified();
m_ImageStatisticsCalculationTriggerVector[timeStep] = false;
}
else
{
statisticsContainer = &m_MaskedImageStatisticsVector[timeStep];
histogramContainer = &m_MaskedImageHistogramVector[timeStep];
m_MaskedImageStatisticsTimeStampVector[timeStep].Modified();
m_MaskedImageStatisticsCalculationTriggerVector[timeStep] = false;
}
break;
case MASKING_MODE_IMAGE:
statisticsContainer = &m_MaskedImageStatisticsVector[timeStep];
histogramContainer = &m_MaskedImageHistogramVector[timeStep];
m_MaskedImageStatisticsTimeStampVector[timeStep].Modified();
m_MaskedImageStatisticsCalculationTriggerVector[timeStep] = false;
break;
case MASKING_MODE_PLANARFIGURE:
statisticsContainer = &m_PlanarFigureStatisticsVector[timeStep];
histogramContainer = &m_PlanarFigureHistogramVector[timeStep];
m_PlanarFigureStatisticsTimeStampVector[timeStep].Modified();
m_PlanarFigureStatisticsCalculationTriggerVector[timeStep] = false;
break;
}
// Calculate statistics and histogram(s)
if ( m_InternalImage->GetDimension() == 3 )
{
if ( m_MaskingMode == MASKING_MODE_NONE && !m_DoIgnorePixelValue )
{
AccessFixedDimensionByItk_2(
m_InternalImage,
InternalCalculateStatisticsUnmasked,
3,
statisticsContainer,
histogramContainer );
}
else
{
AccessFixedDimensionByItk_3(
m_InternalImage,
InternalCalculateStatisticsMasked,
3,
m_InternalImageMask3D.GetPointer(),
statisticsContainer,
histogramContainer );
}
}
else if ( m_InternalImage->GetDimension() == 2 )
{
if ( m_MaskingMode == MASKING_MODE_NONE && !m_DoIgnorePixelValue )
{
AccessFixedDimensionByItk_2(
m_InternalImage,
InternalCalculateStatisticsUnmasked,
2,
statisticsContainer,
histogramContainer );
}
else
{
AccessFixedDimensionByItk_3(
m_InternalImage,
InternalCalculateStatisticsMasked,
2,
m_InternalImageMask2D.GetPointer(),
statisticsContainer,
histogramContainer );
}
}
else
{
MITK_ERROR << "ImageStatistics: Image dimension not supported!";
}
// Release unused image smart pointers to free memory
m_InternalImage = mitk::Image::ConstPointer();
m_InternalImageMask3D = MaskImage3DType::Pointer();
m_InternalImageMask2D = MaskImage2DType::Pointer();
return true;
}
const ImageStatisticsCalculator::HistogramType *
ImageStatisticsCalculator::GetHistogram( unsigned int timeStep, unsigned int label ) const
{
if ( m_Image.IsNull() || (timeStep >= m_Image->GetTimeSteps()) )
{
return NULL;
}
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
default:
{
if(m_DoIgnorePixelValue)
return m_MaskedImageHistogramVector[timeStep][label];
return m_ImageHistogramVector[timeStep][label];
}
case MASKING_MODE_IMAGE:
return m_MaskedImageHistogramVector[timeStep][label];
case MASKING_MODE_PLANARFIGURE:
return m_PlanarFigureHistogramVector[timeStep][label];
}
}
const ImageStatisticsCalculator::HistogramContainer &
ImageStatisticsCalculator::GetHistogramVector( unsigned int timeStep ) const
{
if ( m_Image.IsNull() || (timeStep >= m_Image->GetTimeSteps()) )
{
return m_EmptyHistogramContainer;
}
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
default:
{
if(m_DoIgnorePixelValue)
return m_MaskedImageHistogramVector[timeStep];
return m_ImageHistogramVector[timeStep];
}
case MASKING_MODE_IMAGE:
return m_MaskedImageHistogramVector[timeStep];
case MASKING_MODE_PLANARFIGURE:
return m_PlanarFigureHistogramVector[timeStep];
}
}
const ImageStatisticsCalculator::Statistics &
ImageStatisticsCalculator::GetStatistics( unsigned int timeStep, unsigned int label ) const
{
if ( m_Image.IsNull() || (timeStep >= m_Image->GetTimeSteps()) )
{
return m_EmptyStatistics;
}
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
default:
{
if(m_DoIgnorePixelValue)
return m_MaskedImageStatisticsVector[timeStep][label];
return m_ImageStatisticsVector[timeStep][label];
}
case MASKING_MODE_IMAGE:
return m_MaskedImageStatisticsVector[timeStep][label];
case MASKING_MODE_PLANARFIGURE:
return m_PlanarFigureStatisticsVector[timeStep][label];
}
}
const ImageStatisticsCalculator::StatisticsContainer &
ImageStatisticsCalculator::GetStatisticsVector( unsigned int timeStep ) const
{
if ( m_Image.IsNull() || (timeStep >= m_Image->GetTimeSteps()) )
{
return m_EmptyStatisticsContainer;
}
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
default:
{
if(m_DoIgnorePixelValue)
return m_MaskedImageStatisticsVector[timeStep];
return m_ImageStatisticsVector[timeStep];
}
case MASKING_MODE_IMAGE:
return m_MaskedImageStatisticsVector[timeStep];
case MASKING_MODE_PLANARFIGURE:
return m_PlanarFigureStatisticsVector[timeStep];
}
}
void ImageStatisticsCalculator::ExtractImageAndMask( unsigned int timeStep )
{
if ( m_Image.IsNull() )
{
throw std::runtime_error( "Error: image empty!" );
}
if ( timeStep >= m_Image->GetTimeSteps() )
{
throw std::runtime_error( "Error: invalid time step!" );
}
ImageTimeSelector::Pointer imageTimeSelector = ImageTimeSelector::New();
imageTimeSelector->SetInput( m_Image );
imageTimeSelector->SetTimeNr( timeStep );
imageTimeSelector->UpdateLargestPossibleRegion();
mitk::Image *timeSliceImage = imageTimeSelector->GetOutput();
switch ( m_MaskingMode )
{
case MASKING_MODE_NONE:
{
m_InternalImage = timeSliceImage;
m_InternalImageMask2D = NULL;
m_InternalImageMask3D = NULL;
if(m_DoIgnorePixelValue)
{
if( m_InternalImage->GetDimension() == 3 )
{
CastToItkImage( timeSliceImage, m_InternalImageMask3D );
m_InternalImageMask3D->FillBuffer(1);
}
if( m_InternalImage->GetDimension() == 2 )
{
CastToItkImage( timeSliceImage, m_InternalImageMask2D );
m_InternalImageMask2D->FillBuffer(1);
}
}
break;
}
case MASKING_MODE_IMAGE:
{
if ( m_ImageMask.IsNotNull() && (m_ImageMask->GetReferenceCount() > 1) )
{
if ( timeStep < m_ImageMask->GetTimeSteps() )
{
ImageTimeSelector::Pointer maskedImageTimeSelector = ImageTimeSelector::New();
maskedImageTimeSelector->SetInput( m_ImageMask );
maskedImageTimeSelector->SetTimeNr( timeStep );
maskedImageTimeSelector->UpdateLargestPossibleRegion();
mitk::Image *timeSliceMaskedImage = maskedImageTimeSelector->GetOutput();
m_InternalImage = timeSliceImage;
CastToItkImage( timeSliceMaskedImage, m_InternalImageMask3D );
}
else
{
throw std::runtime_error( "Error: image mask has not enough time steps!" );
}
}
else
{
throw std::runtime_error( "Error: image mask empty!" );
}
break;
}
case MASKING_MODE_PLANARFIGURE:
{
m_InternalImageMask2D = NULL;
if ( m_PlanarFigure.IsNull() )
{
throw std::runtime_error( "Error: planar figure empty!" );
}
if ( !m_PlanarFigure->IsClosed() )
{
throw std::runtime_error( "Masking not possible for non-closed figures" );
}
const Geometry3D *imageGeometry = timeSliceImage->GetGeometry();
if ( imageGeometry == NULL )
{
throw std::runtime_error( "Image geometry invalid!" );
}
const Geometry2D *planarFigureGeometry2D = m_PlanarFigure->GetGeometry2D();
if ( planarFigureGeometry2D == NULL )
{
throw std::runtime_error( "Planar-Figure not yet initialized!" );
}
const PlaneGeometry *planarFigureGeometry =
dynamic_cast< const PlaneGeometry * >( planarFigureGeometry2D );
if ( planarFigureGeometry == NULL )
{
throw std::runtime_error( "Non-planar planar figures not supported!" );
}
// Find principal direction of PlanarFigure in input image
unsigned int axis;
if ( !this->GetPrincipalAxis( imageGeometry,
planarFigureGeometry->GetNormal(), axis ) )
{
throw std::runtime_error( "Non-aligned planar figures not supported!" );
}
m_PlanarFigureAxis = axis;
// Find slice number corresponding to PlanarFigure in input image
MaskImage3DType::IndexType index;
imageGeometry->WorldToIndex( planarFigureGeometry->GetOrigin(), index );
unsigned int slice = index[axis];
m_PlanarFigureSlice = slice;
// Extract slice with given position and direction from image
ExtractImageFilter::Pointer imageExtractor = ExtractImageFilter::New();
imageExtractor->SetInput( timeSliceImage );
imageExtractor->SetSliceDimension( axis );
imageExtractor->SetSliceIndex( slice );
imageExtractor->Update();
m_InternalImage = imageExtractor->GetOutput();
// Compute mask from PlanarFigure
AccessFixedDimensionByItk_1(
m_InternalImage,
InternalCalculateMaskFromPlanarFigure,
2, axis );
}
}
if(m_DoIgnorePixelValue)
{
if ( m_InternalImage->GetDimension() == 3 )
{
AccessFixedDimensionByItk_1(
m_InternalImage,
InternalMaskIgnoredPixels,
3,
m_InternalImageMask3D.GetPointer() );
}
else if ( m_InternalImage->GetDimension() == 2 )
{
AccessFixedDimensionByItk_1(
m_InternalImage,
InternalMaskIgnoredPixels,
2,
m_InternalImageMask2D.GetPointer() );
}
}
}
bool ImageStatisticsCalculator::GetPrincipalAxis(
const Geometry3D *geometry, Vector3D vector,
unsigned int &axis )
{
vector.Normalize();
for ( unsigned int i = 0; i < 3; ++i )
{
Vector3D axisVector = geometry->GetAxisVector( i );
axisVector.Normalize();
if ( fabs( fabs( axisVector * vector ) - 1.0) < mitk::eps )
{
axis = i;
return true;
}
}
return false;
}
template < typename TPixel, unsigned int VImageDimension >
void ImageStatisticsCalculator::InternalCalculateStatisticsUnmasked(
const itk::Image< TPixel, VImageDimension > *image,
StatisticsContainer *statisticsContainer,
HistogramContainer* histogramContainer )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
typedef typename ImageType::IndexType IndexType;
typedef itk::Statistics::ScalarImageToHistogramGenerator< ImageType >
HistogramGeneratorType;
statisticsContainer->clear();
histogramContainer->clear();
// Progress listening...
typedef itk::SimpleMemberCommand< ImageStatisticsCalculator > ITKCommandType;
ITKCommandType::Pointer progressListener;
progressListener = ITKCommandType::New();
progressListener->SetCallbackFunction( this,
&ImageStatisticsCalculator::UnmaskedStatisticsProgressUpdate );
// Issue 100 artificial progress events since ScalarIMageToHistogramGenerator
// does not (yet?) support progress reporting
this->InvokeEvent( itk::StartEvent() );
for ( unsigned int i = 0; i < 100; ++i )
{
this->UnmaskedStatisticsProgressUpdate();
}
// Calculate statistics (separate filter)
typedef itk::StatisticsImageFilter< ImageType > StatisticsFilterType;
typename StatisticsFilterType::Pointer statisticsFilter = StatisticsFilterType::New();
statisticsFilter->SetInput( image );
unsigned long observerTag = statisticsFilter->AddObserver( itk::ProgressEvent(), progressListener );
statisticsFilter->Update();
statisticsFilter->RemoveObserver( observerTag );
this->InvokeEvent( itk::EndEvent() );
// Calculate minimum and maximum
typedef itk::MinimumMaximumImageCalculator< ImageType > MinMaxFilterType;
typename MinMaxFilterType::Pointer minMaxFilter = MinMaxFilterType::New();
minMaxFilter->SetImage( image );
unsigned long observerTag2 = minMaxFilter->AddObserver( itk::ProgressEvent(), progressListener );
minMaxFilter->Compute();
minMaxFilter->RemoveObserver( observerTag2 );
this->InvokeEvent( itk::EndEvent() );
Statistics statistics; statistics.Reset();
statistics.Label = 1;
statistics.N = image->GetBufferedRegion().GetNumberOfPixels();
statistics.Min = statisticsFilter->GetMinimum();
statistics.Max = statisticsFilter->GetMaximum();
statistics.Mean = statisticsFilter->GetMean();
statistics.Median = 0.0;
statistics.Sigma = statisticsFilter->GetSigma();
statistics.RMS = sqrt( statistics.Mean * statistics.Mean + statistics.Sigma * statistics.Sigma );
statistics.MinIndex.set_size(image->GetImageDimension());
statistics.MaxIndex.set_size(image->GetImageDimension());
for (int i=0; i<statistics.MaxIndex.size(); i++)
{
statistics.MaxIndex[i] = minMaxFilter->GetIndexOfMaximum()[i];
statistics.MinIndex[i] = minMaxFilter->GetIndexOfMinimum()[i];
}
statisticsContainer->push_back( statistics );
// Calculate histogram
typename HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New();
histogramGenerator->SetInput( image );
histogramGenerator->SetMarginalScale( 100 );
histogramGenerator->SetNumberOfBins( 768 );
histogramGenerator->SetHistogramMin( statistics.Min );
histogramGenerator->SetHistogramMax( statistics.Max );
histogramGenerator->Compute();
histogramContainer->push_back( histogramGenerator->GetOutput() );
}
template < typename TPixel, unsigned int VImageDimension >
void ImageStatisticsCalculator::InternalMaskIgnoredPixels(
const itk::Image< TPixel, VImageDimension > *image,
itk::Image< unsigned short, VImageDimension > *maskImage )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
itk::ImageRegionIterator<MaskImageType>
itmask(maskImage, maskImage->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<ImageType>
itimage(image, image->GetLargestPossibleRegion());
- itmask = itmask.Begin();
- itimage = itimage.Begin();
+ itmask.GoToBegin();
+ itimage.GoToBegin();
while( !itmask.IsAtEnd() )
{
if(m_IgnorePixelValue == itimage.Get())
{
itmask.Set(0);
}
++itmask;
++itimage;
}
}
template < typename TPixel, unsigned int VImageDimension >
void ImageStatisticsCalculator::InternalCalculateStatisticsMasked(
const itk::Image< TPixel, VImageDimension > *image,
itk::Image< unsigned short, VImageDimension > *maskImage,
StatisticsContainer* statisticsContainer,
HistogramContainer* histogramContainer )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
typedef typename ImageType::IndexType IndexType;
typedef typename ImageType::PointType PointType;
typedef typename ImageType::SpacingType SpacingType;
typedef itk::LabelStatisticsImageFilter< ImageType, MaskImageType > LabelStatisticsFilterType;
typedef itk::ChangeInformationImageFilter< MaskImageType > ChangeInformationFilterType;
typedef itk::ExtractImageFilter< ImageType, ImageType > ExtractImageFilterType;
statisticsContainer->clear();
histogramContainer->clear();
// Make sure that mask is set
if ( maskImage == NULL )
{
itkExceptionMacro( << "Mask image needs to be set!" );
}
// Make sure that spacing of mask and image are the same
SpacingType imageSpacing = image->GetSpacing();
SpacingType maskSpacing = maskImage->GetSpacing();
PointType zeroPoint; zeroPoint.Fill( 0.0 );
if ( (zeroPoint + imageSpacing).SquaredEuclideanDistanceTo( (zeroPoint + maskSpacing) ) > mitk::eps )
{
itkExceptionMacro( << "Mask needs to have same spacing as image! (Image spacing: " << imageSpacing << "; Mask spacing: " << maskSpacing << ")" );
}
// Make sure that orientation of mask and image are the same
typedef typename ImageType::DirectionType DirectionType;
DirectionType imageDirection = image->GetDirection();
DirectionType maskDirection = maskImage->GetDirection();
for( int i = 0; i < imageDirection.ColumnDimensions; ++i )
{
for( int j = 0; j < imageDirection.ColumnDimensions; ++j )
{
double differenceDirection = imageDirection[i][j] - maskDirection[i][j];
if ( fabs( differenceDirection ) > mitk::eps )
{
itkExceptionMacro( << "Mask needs to have same direction as image! (Image direction: " << imageDirection << "; Mask direction: " << maskDirection << ")" );
}
}
}
// Make sure that the voxels of mask and image are correctly "aligned", i.e., voxel boundaries are the same in both images
PointType imageOrigin = image->GetOrigin();
PointType maskOrigin = maskImage->GetOrigin();
long offset[ImageType::ImageDimension];
typedef itk::ContinuousIndex<double, VImageDimension> ContinousIndexType;
ContinousIndexType maskOriginContinousIndex, imageOriginContinousIndex;
image->TransformPhysicalPointToContinuousIndex(maskOrigin, maskOriginContinousIndex);
image->TransformPhysicalPointToContinuousIndex(imageOrigin, imageOriginContinousIndex);
for ( unsigned int i = 0; i < ImageType::ImageDimension; ++i )
{
double misalignment = maskOriginContinousIndex[i] - floor( maskOriginContinousIndex[i] + 0.5 );
if ( fabs( misalignment ) > mitk::eps )
{
itkExceptionMacro( << "Pixels/voxels of mask and image are not sufficiently aligned! (Misalignment: " << misalignment << ")" );
}
double indexCoordDistance = maskOriginContinousIndex[i] - imageOriginContinousIndex[i];
offset[i] = (int) indexCoordDistance + image->GetBufferedRegion().GetIndex()[i];
}
// Adapt the origin and region (index/size) of the mask so that the origin of both are the same
typename ChangeInformationFilterType::Pointer adaptMaskFilter;
adaptMaskFilter = ChangeInformationFilterType::New();
adaptMaskFilter->ChangeOriginOn();
adaptMaskFilter->ChangeRegionOn();
adaptMaskFilter->SetInput( maskImage );
adaptMaskFilter->SetOutputOrigin( image->GetOrigin() );
adaptMaskFilter->SetOutputOffset( offset );
adaptMaskFilter->Update();
typename MaskImageType::Pointer adaptedMaskImage = adaptMaskFilter->GetOutput();
// Make sure that mask region is contained within image region
if ( !image->GetLargestPossibleRegion().IsInside( adaptedMaskImage->GetLargestPossibleRegion() ) )
{
itkExceptionMacro( << "Mask region needs to be inside of image region! (Image region: "
<< image->GetLargestPossibleRegion() << "; Mask region: " << adaptedMaskImage->GetLargestPossibleRegion() << ")" );
}
// If mask region is smaller than image region, extract the sub-sampled region from the original image
typename ImageType::SizeType imageSize = image->GetBufferedRegion().GetSize();
typename ImageType::SizeType maskSize = maskImage->GetBufferedRegion().GetSize();
bool maskSmallerImage = false;
for ( unsigned int i = 0; i < ImageType::ImageDimension; ++i )
{
if ( maskSize[i] < imageSize[i] )
{
maskSmallerImage = true;
}
}
typename ImageType::ConstPointer adaptedImage;
if ( maskSmallerImage )
{
typename ExtractImageFilterType::Pointer extractImageFilter = ExtractImageFilterType::New();
extractImageFilter->SetInput( image );
extractImageFilter->SetExtractionRegion( adaptedMaskImage->GetBufferedRegion() );
extractImageFilter->Update();
adaptedImage = extractImageFilter->GetOutput();
}
else
{
adaptedImage = image;
}
// Initialize Filter
typedef itk::StatisticsImageFilter< ImageType > StatisticsFilterType;
typename StatisticsFilterType::Pointer statisticsFilter = StatisticsFilterType::New();
statisticsFilter->SetInput( adaptedImage );
statisticsFilter->Update();
int numberOfBins = ( m_DoIgnorePixelValue && (m_MaskingMode == MASKING_MODE_NONE) ) ? 768 : 384;
typename LabelStatisticsFilterType::Pointer labelStatisticsFilter;
labelStatisticsFilter = LabelStatisticsFilterType::New();
labelStatisticsFilter->SetInput( adaptedImage );
labelStatisticsFilter->SetLabelInput( adaptedMaskImage );
labelStatisticsFilter->UseHistogramsOn();
labelStatisticsFilter->SetHistogramParameters( numberOfBins, statisticsFilter->GetMinimum(), statisticsFilter->GetMaximum() );
// Add progress listening
typedef itk::SimpleMemberCommand< ImageStatisticsCalculator > ITKCommandType;
ITKCommandType::Pointer progressListener;
progressListener = ITKCommandType::New();
progressListener->SetCallbackFunction( this,
&ImageStatisticsCalculator::MaskedStatisticsProgressUpdate );
unsigned long observerTag = labelStatisticsFilter->AddObserver(
itk::ProgressEvent(), progressListener );
// Execute filter
this->InvokeEvent( itk::StartEvent() );
// Make sure that only the mask region is considered (otherwise, if the mask region is smaller
// than the image region, the Update() would result in an exception).
labelStatisticsFilter->GetOutput()->SetRequestedRegion( adaptedMaskImage->GetLargestPossibleRegion() );
+
// Execute the filter
labelStatisticsFilter->Update();
this->InvokeEvent( itk::EndEvent() );
labelStatisticsFilter->RemoveObserver( observerTag );
// Find all relevant labels of mask (other than 0)
std::list< int > relevantLabels;
bool maskNonEmpty = false;
unsigned int i;
for ( i = 1; i < 4096; ++i )
{
if ( labelStatisticsFilter->HasLabel( i ) )
{
relevantLabels.push_back( i );
maskNonEmpty = true;
}
}
if ( maskNonEmpty )
{
std::list< int >::iterator it;
for ( it = relevantLabels.begin(), i = 0;
it != relevantLabels.end();
++it, ++i )
{
histogramContainer->push_back( HistogramType::ConstPointer( labelStatisticsFilter->GetHistogram( (*it) ) ) );
Statistics statistics;
statistics.Label = (*it);
statistics.N = labelStatisticsFilter->GetCount( *it );
statistics.Min = labelStatisticsFilter->GetMinimum( *it );
statistics.Max = labelStatisticsFilter->GetMaximum( *it );
statistics.Mean = labelStatisticsFilter->GetMean( *it );
statistics.Median = labelStatisticsFilter->GetMedian( *it );
statistics.Sigma = labelStatisticsFilter->GetSigma( *it );
statistics.RMS = sqrt( statistics.Mean * statistics.Mean
+ statistics.Sigma * statistics.Sigma );
// restrict image to mask area for min/max index calculation
typedef itk::MaskImageFilter< ImageType, MaskImageType, ImageType > MaskImageFilterType;
typename MaskImageFilterType::Pointer masker = MaskImageFilterType::New();
masker->SetOutsideValue( (statistics.Min+statistics.Max)/2 );
masker->SetInput1(adaptedImage);
masker->SetInput2(adaptedMaskImage);
masker->Update();
// get index of minimum and maximum
typedef itk::MinimumMaximumImageCalculator< ImageType > MinMaxFilterType;
typename MinMaxFilterType::Pointer minMaxFilter = MinMaxFilterType::New();
minMaxFilter->SetImage( masker->GetOutput() );
unsigned long observerTag2 = minMaxFilter->AddObserver( itk::ProgressEvent(), progressListener );
minMaxFilter->Compute();
minMaxFilter->RemoveObserver( observerTag2 );
this->InvokeEvent( itk::EndEvent() );
statistics.MinIndex.set_size(adaptedImage->GetImageDimension());
statistics.MaxIndex.set_size(adaptedImage->GetImageDimension());
typename MinMaxFilterType::IndexType tempMaxIndex = minMaxFilter->GetIndexOfMaximum();
typename MinMaxFilterType::IndexType tempMinIndex = minMaxFilter->GetIndexOfMinimum();
// FIX BUG 14644
//If a PlanarFigure is used for segmentation the
//adaptedImage is a single slice (2D). Adding the
// 3. dimension.
if (m_MaskingMode == MASKING_MODE_PLANARFIGURE && m_Image->GetDimension()==3)
{
statistics.MaxIndex.set_size(m_Image->GetDimension());
statistics.MaxIndex[m_PlanarFigureCoordinate0]=tempMaxIndex[0];
statistics.MaxIndex[m_PlanarFigureCoordinate1]=tempMaxIndex[1];
statistics.MaxIndex[m_PlanarFigureAxis]=m_PlanarFigureSlice;
statistics.MinIndex.set_size(m_Image->GetDimension());
statistics.MinIndex[m_PlanarFigureCoordinate0]=tempMinIndex[0];
statistics.MinIndex[m_PlanarFigureCoordinate1]=tempMinIndex[1];
statistics.MinIndex[m_PlanarFigureAxis]=m_PlanarFigureSlice;
} else
{
for (int i = 0; i<statistics.MaxIndex.size(); i++)
{
statistics.MaxIndex[i] = tempMaxIndex[i];
statistics.MinIndex[i] = tempMinIndex[i];
}
}
// FIX END
statisticsContainer->push_back( statistics );
}
}
else
{
histogramContainer->push_back( HistogramType::ConstPointer( m_EmptyHistogram ) );
statisticsContainer->push_back( Statistics() );;
}
}
template < typename TPixel, unsigned int VImageDimension >
void ImageStatisticsCalculator::InternalCalculateMaskFromPlanarFigure(
const itk::Image< TPixel, VImageDimension > *image, unsigned int axis )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::CastImageFilter< ImageType, MaskImage2DType > CastFilterType;
// Generate mask image as new image with same header as input image and
// initialize with "1".
typename CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput( image );
castFilter->Update();
castFilter->GetOutput()->FillBuffer( 1 );
// all PolylinePoints of the PlanarFigure are stored in a vtkPoints object.
// These points are used by the vtkLassoStencilSource to create
// a vtkImageStencil.
const mitk::Geometry2D *planarFigureGeometry2D = m_PlanarFigure->GetGeometry2D();
const typename PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
const mitk::Geometry3D *imageGeometry3D = m_Image->GetGeometry( 0 );
// Determine x- and y-dimensions depending on principal axis
int i0, i1;
switch ( axis )
{
case 0:
i0 = 1;
i1 = 2;
break;
case 1:
i0 = 0;
i1 = 2;
break;
case 2:
default:
i0 = 0;
i1 = 1;
break;
}
m_PlanarFigureCoordinate0= i0;
m_PlanarFigureCoordinate1= i1;
// store the polyline contour as vtkPoints object
bool outOfBounds = false;
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
typename PlanarFigure::PolyLineType::const_iterator it;
for ( it = planarFigurePolyline.begin();
it != planarFigurePolyline.end();
++it )
{
Point3D point3D;
// Convert 2D point back to the local index coordinates of the selected
// image
planarFigureGeometry2D->Map( it->Point, point3D );
// Polygons (partially) outside of the image bounds can not be processed
// further due to a bug in vtkPolyDataToImageStencil
if ( !imageGeometry3D->IsInside( point3D ) )
{
outOfBounds = true;
}
imageGeometry3D->WorldToIndex( point3D, point3D );
points->InsertNextPoint( point3D[i0], point3D[i1], 0 );
}
// mark a malformed 2D planar figure ( i.e. area = 0 ) as out of bounds
// this can happen when all control points of a rectangle lie on the same line = two of the three extents are zero
double bounds[6] = {0, 0, 0, 0, 0, 0};
points->GetBounds( bounds );
bool extent_x = (fabs(bounds[0] - bounds[1])) < mitk::eps;
bool extent_y = (fabs(bounds[2] - bounds[3])) < mitk::eps;
bool extent_z = (fabs(bounds[4] - bounds[5])) < mitk::eps;
// throw an exception if a closed planar figure is deformed, i.e. has only one non-zero extent
if ( m_PlanarFigure->IsClosed() &&
((extent_x && extent_y) || (extent_x && extent_z) || (extent_y && extent_z)))
{
mitkThrow() << "Figure has a zero area and cannot be used for masking.";
}
if ( outOfBounds )
{
throw std::runtime_error( "Figure at least partially outside of image bounds!" );
}
// create a vtkLassoStencilSource and set the points of the Polygon
vtkSmartPointer<vtkLassoStencilSource> lassoStencil = vtkSmartPointer<vtkLassoStencilSource>::New();
lassoStencil->SetShapeToPolygon();
lassoStencil->SetPoints( points );
// Export from ITK to VTK (to use a VTK filter)
typedef itk::VTKImageImport< MaskImage2DType > ImageImportType;
typedef itk::VTKImageExport< MaskImage2DType > ImageExportType;
typename ImageExportType::Pointer itkExporter = ImageExportType::New();
itkExporter->SetInput( castFilter->GetOutput() );
vtkSmartPointer<vtkImageImport> vtkImporter = vtkSmartPointer<vtkImageImport>::New();
this->ConnectPipelines( itkExporter, vtkImporter );
// Apply the generated image stencil to the input image
vtkSmartPointer<vtkImageStencil> imageStencilFilter = vtkSmartPointer<vtkImageStencil>::New();
imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
imageStencilFilter->SetStencil( lassoStencil->GetOutput() );
imageStencilFilter->ReverseStencilOff();
imageStencilFilter->SetBackgroundValue( 0 );
imageStencilFilter->Update();
// Export from VTK back to ITK
vtkSmartPointer<vtkImageExport> vtkExporter = vtkImageExport::New(); // TODO: this is WRONG, should be vtkSmartPointer<vtkImageExport>::New(), but bug # 14455
vtkExporter->SetInputConnection( imageStencilFilter->GetOutputPort() );
vtkExporter->Update();
typename ImageImportType::Pointer itkImporter = ImageImportType::New();
this->ConnectPipelines( vtkExporter, itkImporter );
itkImporter->Update();
// Store mask
m_InternalImageMask2D = itkImporter->GetOutput();
}
void ImageStatisticsCalculator::UnmaskedStatisticsProgressUpdate()
{
// Need to throw away every second progress event to reach a final count of
// 100 since two consecutive filters are used in this case
static int updateCounter = 0;
if ( updateCounter++ % 2 == 0 )
{
this->InvokeEvent( itk::ProgressEvent() );
}
}
void ImageStatisticsCalculator::MaskedStatisticsProgressUpdate()
{
this->InvokeEvent( itk::ProgressEvent() );
}
}
diff --git a/Modules/IpPicSupport/mitkPicFileReader.cpp b/Modules/IpPicSupport/mitkPicFileReader.cpp
index f280ee4f29..e841ad852d 100644
--- a/Modules/IpPicSupport/mitkPicFileReader.cpp
+++ b/Modules/IpPicSupport/mitkPicFileReader.cpp
@@ -1,373 +1,373 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPicFileReader.h"
#include "mitkPicHelper.h"
#include <itkImageFileReader.h>
extern "C"
{
mitkIpPicDescriptor * MITKipPicGet( char *infile_name, mitkIpPicDescriptor *pic );
mitkIpPicDescriptor * MITKipPicGetTags( char *infile_name, mitkIpPicDescriptor *pic );
}
void mitk::PicFileReader::GenerateOutputInformation()
{
Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_ReadHeaderTime.GetMTime()))
return;
itkDebugMacro(<<"Reading file for GenerateOutputInformation()" << m_FileName);
// Check to see if we can read the file given the name or prefix
//
if ( m_FileName == "" && m_FilePrefix == "" )
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "One of FileName or FilePrefix must be non-empty");
}
if( m_FileName != "")
{
mitkIpPicDescriptor* header=mitkIpPicGetHeader(const_cast<char *>(m_FileName.c_str()), NULL);
if ( !header )
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "File could not be read.");
}
header=MITKipPicGetTags(const_cast<char *>(m_FileName.c_str()), header);
int channels = 1;
mitkIpPicTSV_t *tsv;
if ( (tsv = mitkIpPicQueryTag( header, "SOURCE HEADER" )) != NULL)
{
if(tsv->n[0]>1e+06)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag( header, "SOURCE HEADER" );
mitkIpPicFreeTag(tsvSH);
}
}
if ( (tsv = mitkIpPicQueryTag( header, "ICON80x80" )) != NULL)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag( header, "ICON80x80" );
mitkIpPicFreeTag(tsvSH);
}
if ( (tsv = mitkIpPicQueryTag( header, "VELOCITY" )) != NULL)
{
++channels;
mitkIpPicDelTag( header, "VELOCITY" );
}
if( header == NULL || header->bpe == 0)
{
itk::ImageFileReaderException e(__FILE__, __LINE__);
- itk::OStringStream msg;
+ std::ostringstream msg;
msg << " Could not read file "
<< m_FileName.c_str();
e.SetDescription(msg.str().c_str());
throw e;
return;
}
// if pic image only 2D, the n[2] value is not initialized
unsigned int slices = 1;
if( header->dim == 2 )
header->n[2] = slices;
// First initialize the geometry of the output image by the pic-header
SlicedGeometry3D::Pointer slicedGeometry = mitk::SlicedGeometry3D::New();
PicHelper::InitializeEvenlySpaced(header, header->n[2], slicedGeometry);
// if pic image only 3D, the n[3] value is not initialized
unsigned int timesteps = 1;
if( header->dim > 3 )
timesteps = header->n[3];
TimeSlicedGeometry::Pointer timeSliceGeometry = TimeSlicedGeometry::New();
timeSliceGeometry->InitializeEvenlyTimed(slicedGeometry, timesteps);
timeSliceGeometry->ImageGeometryOn();
// Cast the pic descriptor to ImageDescriptor and initialize the output
output->Initialize( CastToImageDescriptor(header));
output->SetGeometry( timeSliceGeometry );
mitkIpPicFree ( header );
}
else
{
int numberOfImages=0;
m_StartFileIndex=0;
mitkIpPicDescriptor* header=NULL;
char fullName[1024];
while(m_StartFileIndex<10)
{
sprintf(fullName, m_FilePattern.c_str(), m_FilePrefix.c_str(), m_StartFileIndex+numberOfImages);
FILE * f=fopen(fullName,"r");
if(f==NULL)
{
//already found an image?
if(numberOfImages>0)
break;
//no? let's increase start
++m_StartFileIndex;
}
else
{
fclose(f);
//only open the header of the first file found,
//@warning what to do when images do not have the same size??
if(header==NULL)
{
header=mitkIpPicGetHeader(fullName, NULL);
header=MITKipPicGetTags(fullName, header);
}
++numberOfImages;
}
}
printf("\n numberofimages %d\n",numberOfImages);
if(numberOfImages==0)
{
itk::ImageFileReaderException e(__FILE__, __LINE__);
- itk::OStringStream msg;
+ std::ostringstream msg;
msg << "no images found";
e.SetDescription(msg.str().c_str());
throw e;
return;
}
//@FIXME: was ist, wenn die Bilder nicht alle gleich gross sind?
if(numberOfImages>1)
{
printf("\n numberofimages %d > 1\n",numberOfImages);
header->dim=3;
header->n[2]=numberOfImages;
}
printf(" \ninitialisize output\n");
output->Initialize( CastToImageDescriptor(header) );
mitkIpPicFree ( header );
}
m_ReadHeaderTime.Modified();
}
void mitk::PicFileReader::ConvertHandedness(mitkIpPicDescriptor* pic)
{
//left to right handed conversion
if(pic->dim>=3)
{
mitkIpPicDescriptor* slice=mitkIpPicCopyHeader(pic, NULL);
slice->dim=2;
size_t size=_mitkIpPicSize(slice);
slice->data=malloc(size);
size_t v, volumes = (pic->dim>3? pic->n[3] : 1);
size_t volume_size = size*pic->n[2];
for(v=0; v<volumes; ++v)
{
unsigned char *p_first=(unsigned char *)pic->data;
unsigned char *p_last=(unsigned char *)pic->data;
p_first+=v*volume_size;
p_last+=size*(pic->n[2]-1)+v*volume_size;
size_t i, smid=pic->n[2]/2;
for(i=0; i<smid;++i,p_last-=size, p_first+=size)
{
memcpy(slice->data, p_last, size);
memcpy(p_last, p_first, size);
memcpy(p_first, slice->data, size);
}
}
mitkIpPicFree(slice);
}
}
void mitk::PicFileReader::GenerateData()
{
Image::Pointer output = this->GetOutput();
// Check to see if we can read the file given the name or prefix
//
if ( m_FileName == "" && m_FilePrefix == "" )
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "One of FileName or FilePrefix must be non-empty");
}
if( m_FileName != "")
{
mitkIpPicDescriptor* outputPic = mitkIpPicNew();
outputPic = CastToIpPicDescriptor(output, outputPic);
mitkIpPicDescriptor* pic=MITKipPicGet(const_cast<char *>(m_FileName.c_str()),
outputPic);
// comes upside-down (in MITK coordinates) from PIC file
ConvertHandedness(pic);
mitkIpPicTSV_t *tsv;
if ( (tsv = mitkIpPicQueryTag( pic, "SOURCE HEADER" )) != NULL)
{
if(tsv->n[0]>1e+06)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag( pic, "SOURCE HEADER" );
mitkIpPicFreeTag(tsvSH);
}
}
if ( (tsv = mitkIpPicQueryTag( pic, "ICON80x80" )) != NULL)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag( pic, "ICON80x80" );
mitkIpPicFreeTag(tsvSH);
}
if ( (tsv = mitkIpPicQueryTag( pic, "VELOCITY" )) != NULL)
{
mitkIpPicDescriptor* header = mitkIpPicCopyHeader(pic, NULL);
header->data = tsv->value;
ConvertHandedness(header);
output->SetChannel(header->data, 1);
header->data = NULL;
mitkIpPicFree(header);
mitkIpPicDelTag( pic, "VELOCITY" );
}
//slice-wise reading
//currently much too slow.
//else
//{
// int sstart, smax;
// int tstart, tmax;
// sstart=output->GetRequestedRegion().GetIndex(2);
// smax=sstart+output->GetRequestedRegion().GetSize(2);
// tstart=output->GetRequestedRegion().GetIndex(3);
// tmax=tstart+output->GetRequestedRegion().GetSize(3);
// int s,t;
// for(s=sstart; s<smax; ++s)
// {
// for(t=tstart; t<tmax; ++t)
// {
// mitkIpPicDescriptor* pic=mitkIpPicGetSlice(const_cast<char *>(m_FileName.c_str()), NULL, t*smax+s+1);
// output->SetPicSlice(pic,s,t);
// }
// }
//}
}
else
{
int position;
mitkIpPicDescriptor* pic=NULL;
int zDim=(output->GetDimension()>2?output->GetDimensions()[2]:1);
printf("\n zdim is %u \n",zDim);
for (position = 0; position < zDim; ++position)
{
char fullName[1024];
sprintf(fullName, m_FilePattern.c_str(), m_FilePrefix.c_str(), m_StartFileIndex+position);
pic=MITKipPicGet(fullName, pic);
if(pic==NULL)
{
itkDebugMacro("Pic file '" << fullName << "' does not exist.");
}
/* FIXME else
if(output->SetPicSlice(pic, position)==false)
{
itkDebugMacro("Image '" << fullName << "' could not be added to Image.");
}*/
}
if(pic!=NULL)
mitkIpPicFree(pic);
}
}
void mitk::PicFileReader::EnlargeOutputRequestedRegion(itk::DataObject *output)
{
output->SetRequestedRegionToLargestPossibleRegion();
}
bool mitk::PicFileReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
// First check the extension
if( filename == "" )
{
//MITK_INFO<<"No filename specified."<<std::endl;
return false;
}
// check if image is serie
if( filePattern != "" && filePrefix != "" )
return false;
bool extensionFound = false;
std::string::size_type PICPos = filename.rfind(".pic");
if ((PICPos != std::string::npos)
&& (PICPos == filename.length() - 4))
{
extensionFound = true;
}
PICPos = filename.rfind(".PIC");
if ((PICPos != std::string::npos)
&& (PICPos == filename.length() - 4))
{
extensionFound = true;
}
PICPos = filename.rfind(".pic.gz");
if ((PICPos != std::string::npos)
&& (PICPos == filename.length() - 7))
{
extensionFound = true;
}
PICPos = filename.rfind(".seq");
if ((PICPos != std::string::npos)
&& (PICPos == filename.length() - 4))
{
extensionFound = true;
}
if( !extensionFound )
{
//MITK_INFO<<"The filename extension is not recognized."<<std::endl;
return false;
}
return true;
}
mitk::PicFileReader::PicFileReader()
: m_FileName(""), m_FilePrefix(""), m_FilePattern("")
{
}
mitk::PicFileReader::~PicFileReader()
{
}
diff --git a/Modules/IpPicSupport/mitkPicHelper.cpp b/Modules/IpPicSupport/mitkPicHelper.cpp
index a1c4f69456..0907e2aeba 100644
--- a/Modules/IpPicSupport/mitkPicHelper.cpp
+++ b/Modules/IpPicSupport/mitkPicHelper.cpp
@@ -1,296 +1,296 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkConfig.h"
#include "mitkPicHelper.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkPlaneGeometry.h"
#ifdef HAVE_IPDICOM
#include "ipDicom/ipDicom.h"
#endif /* HAVE_IPDICOM */
bool mitk::PicHelper::GetSpacing(const mitkIpPicDescriptor* aPic, Vector3D & spacing)
{
mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
mitkIpPicTSV_t *tsv;
bool pixelSize = false;
tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZE" );
if(tsv==NULL)
{
tsv = mitkIpPicQueryTag( pic, "PIXEL SIZE" );
pixelSize = true;
}
if(tsv)
{
bool tagFound = false;
if((tsv->dim*tsv->n[0]>=3) && (tsv->type==mitkIpPicFloat))
{
if(tsv->bpe==32)
{
FillVector3D(spacing,((mitkIpFloat4_t*)tsv->value)[0], ((mitkIpFloat4_t*)tsv->value)[1],((mitkIpFloat4_t*)tsv->value)[2]);
tagFound = true;
}
else
if(tsv->bpe==64)
{
FillVector3D(spacing,((mitkIpFloat8_t*)tsv->value)[0], ((mitkIpFloat8_t*)tsv->value)[1],((mitkIpFloat8_t*)tsv->value)[2]);
tagFound = true;
}
}
if(tagFound && pixelSize)
{
tsv = mitkIpPicQueryTag( pic, "PIXEL SPACING" );
if(tsv)
{
mitk::ScalarType zSpacing = 0;
if((tsv->dim*tsv->n[0]>=3) && (tsv->type==mitkIpPicFloat))
{
if(tsv->bpe==32)
{
zSpacing = ((mitkIpFloat4_t*)tsv->value)[2];
}
else
if(tsv->bpe==64)
{
zSpacing = ((mitkIpFloat8_t*)tsv->value)[2];
}
if(zSpacing != 0)
{
spacing[2] = zSpacing;
}
}
}
}
if(tagFound) return true;
}
#ifdef HAVE_IPDICOM
tsv = mitkIpPicQueryTag( pic, "SOURCE HEADER" );
if( tsv )
{
void *data;
mitkIpUInt4_t len;
mitkIpFloat8_t spacing_z = 0;
mitkIpFloat8_t thickness = 1;
mitkIpFloat8_t fx = 1;
mitkIpFloat8_t fy = 1;
bool ok=false;
if( dicomFindElement( (unsigned char *) tsv->value, 0x0018, 0x0088, &data, &len ) )
{
ok=true;
sscanf( (char *) data, "%lf", &spacing_z );
// itkGenericOutputMacro( "spacing: " << spacing_z << " mm");
}
if( dicomFindElement( (unsigned char *) tsv->value, 0x0018, 0x0050, &data, &len ) )
{
ok=true;
sscanf( (char *) data, "%lf", &thickness );
// itkGenericOutputMacro( "thickness: " << thickness << " mm");
if( thickness == 0 )
thickness = 1;
}
if( dicomFindElement( (unsigned char *) tsv->value, 0x0028, 0x0030, &data, &len )
&& len>0 && ((char *)data)[0] )
{
sscanf( (char *) data, "%lf\\%lf", &fy, &fx ); // row / column value
// itkGenericOutputMacro( "fx, fy: " << fx << "/" << fy << " mm");
}
else
ok=false;
if(ok)
FillVector3D(spacing, fx, fy,( spacing_z > 0 ? spacing_z : thickness));
return ok;
}
#endif /* HAVE_IPDICOM */
if(spacing[0]<=0 || spacing[1]<=0 || spacing[2]<=0)
{
itkGenericOutputMacro(<< "illegal spacing by pic tag: " << spacing << ". Setting spacing to (1,1,1).");
spacing.Fill(1);
}
return false;
}
bool mitk::PicHelper::GetTimeSpacing(const mitkIpPicDescriptor* aPic, float& timeSpacing)
{
mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
mitkIpPicTSV_t *tsv;
tsv = mitkIpPicQueryTag( pic, "PIXEL SIZE" );
if(tsv)
{
timeSpacing = ((mitkIpFloat4_t*)tsv->value)[3];
if( timeSpacing <=0 ) timeSpacing = 1;
}
else timeSpacing = 1;
return true;
}
bool mitk::PicHelper::SetSpacing(const mitkIpPicDescriptor* aPic, SlicedGeometry3D* slicedgeometry)
{
mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
Vector3D spacing(slicedgeometry->GetSpacing());
mitkIpPicTSV_t *tsv;
if ( (tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZES" )) != NULL)
{
int count = tsv->n[1];
float* value = (float*) tsv->value;
mitk::Vector3D pixelSize;
spacing.Fill(0);
for ( int s=0; s < count; s++ )
{
pixelSize[0] = (ScalarType) *value++;
pixelSize[1] = (ScalarType) *value++;
pixelSize[2] = (ScalarType) *value++;
spacing += pixelSize;
}
spacing *= 1.0f/count;
slicedgeometry->SetSpacing(spacing);
itkGenericOutputMacro(<< "the slices are inhomogeneous" );
}
else
if(GetSpacing(pic, spacing))
{
slicedgeometry->SetSpacing(spacing);
return true;
}
return false;
}
void mitk::PicHelper::InitializeEvenlySpaced(const mitkIpPicDescriptor* pic, unsigned int slices, SlicedGeometry3D* slicedgeometry)
{
assert(pic!=NULL);
assert(slicedgeometry!=NULL);
mitk::PlaneGeometry::Pointer planegeometry=mitk::PlaneGeometry::New();
mitkIpPicTSV_t *geometryTag;
if ( (geometryTag = mitkIpPicQueryTag( const_cast<mitkIpPicDescriptor*>(pic), "ISG" )) != NULL)
{
mitk::Point3D origin;
mitk::Vector3D rightVector;
mitk::Vector3D downVector;
mitk::Vector3D spacing;
mitk::vtk2itk(((float*)geometryTag->value+0), origin);
mitk::vtk2itk(((float*)geometryTag->value+3), rightVector);
mitk::vtk2itk(((float*)geometryTag->value+6), downVector);
mitk::vtk2itk(((float*)geometryTag->value+9), spacing);
mitk::PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightVector, downVector, &spacing);
planegeometry->SetOrigin(origin);
slicedgeometry->InitializeEvenlySpaced(planegeometry, slices);
}
else
{
Vector3D spacing;
spacing.Fill(1);
GetSpacing(pic, spacing);
planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], spacing);
slicedgeometry->InitializeEvenlySpaced(planegeometry, spacing[2], slices);
}
if(pic->dim>=4)
{
float ts = 0;
GetTimeSpacing(pic, ts);
TimeBounds timebounds;
timebounds[0] = 0.0;
timebounds[1] = ts;
slicedgeometry->SetTimeBounds(timebounds);
}
}
bool mitk::PicHelper::SetGeometry2D(const mitkIpPicDescriptor* aPic, int s, SlicedGeometry3D* slicedgeometry)
{
mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
if((pic!=NULL) && (slicedgeometry->IsValidSlice(s)))
{
//construct standard view
mitk::Point3D origin;
mitk::Vector3D rightDV, bottomDV;
mitkIpPicTSV_t *tsv;
if ( (tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZES" )) != NULL)
{
unsigned int count = (unsigned int) tsv->n[1];
float* value = (float*) tsv->value;
mitk::Vector3D pixelSize;
ScalarType zPosition = 0.0f;
if(s >= 0)
{
if(count < (unsigned int) s)
return false;
count = s;
}
else
{
if(count < slicedgeometry->GetSlices())
return false;
count = slicedgeometry->GetSlices();
}
unsigned int slice;
for (slice=0; slice < count; ++slice )
{
pixelSize[0] = (ScalarType) *value++;
pixelSize[1] = (ScalarType) *value++;
pixelSize[2] = (ScalarType) *value++;
zPosition += pixelSize[2] / 2.0f; // first half slice thickness
if((s==-1) || (slice== (unsigned int) s))
{
Vector3D spacing;
spacing = pixelSize;
FillVector3D(origin, 0, 0, zPosition);
FillVector3D(rightDV, pic->n[0], 0, 0);
FillVector3D(bottomDV, 0, pic->n[1], 0);
mitk::PlaneGeometry::Pointer planegeometry=mitk::PlaneGeometry::New();
- planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightDV.Get_vnl_vector(), bottomDV.Get_vnl_vector(), &spacing);
+ planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &spacing);
planegeometry->SetOrigin(origin);
slicedgeometry->SetGeometry2D(planegeometry, s);
}
zPosition += pixelSize[2] / 2.0f; // second half slice thickness
}
}
else
{
FillVector3D(origin,0,0,s); slicedgeometry->IndexToWorld(origin, origin);
FillVector3D(rightDV,pic->n[0],0,0);
FillVector3D(bottomDV,0,pic->n[1],0);
mitk::PlaneGeometry::Pointer planegeometry=mitk::PlaneGeometry::New();
- planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightDV.Get_vnl_vector(), bottomDV.Get_vnl_vector(), &slicedgeometry->GetSpacing());
+ planegeometry->InitializeStandardPlane(pic->n[0], pic->n[1], rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &slicedgeometry->GetSpacing());
planegeometry->SetOrigin(origin);
slicedgeometry->SetGeometry2D(planegeometry, s);
}
return true;
}
return false;
}
diff --git a/Modules/IpPicSupport/mitkPicVolumeTimeSeriesReader.cpp b/Modules/IpPicSupport/mitkPicVolumeTimeSeriesReader.cpp
index fc2755ba8c..c8bf0892ce 100644
--- a/Modules/IpPicSupport/mitkPicVolumeTimeSeriesReader.cpp
+++ b/Modules/IpPicSupport/mitkPicVolumeTimeSeriesReader.cpp
@@ -1,176 +1,176 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPicVolumeTimeSeriesReader.h"
#include "mitkPicFileReader.h"
#include <itkImageFileReader.h>
#include <string>
extern "C"
{
mitkIpPicDescriptor * MITKipPicGet( char *infile_name, mitkIpPicDescriptor *pic );
mitkIpPicDescriptor * MITKipPicGetTags( char *infile_name, mitkIpPicDescriptor *pic );
}
void mitk::PicVolumeTimeSeriesReader::GenerateOutputInformation()
{
mitk::Image::Pointer output = this->GetOutput();
if ( ( output->IsInitialized() ) && ( this->GetMTime() <= m_ReadHeaderTime.GetMTime() ) )
return ;
itkDebugMacro( << "Reading file for GenerateOutputInformation()" << m_FileName );
if ( ! this->GenerateFileList() )
{
itkWarningMacro( "Sorry, file list could not be generated!" );
return ;
}
//
// Read the first file of the image sequence. Assume equal size and spacings for all
// other volumes. @TODO Integrate support for different sizes and spacings
//
char* filename = const_cast<char *> ( m_MatchedFileNames[ 0 ].c_str() );
mitkIpPicDescriptor * header = mitkIpPicGetHeader( filename, NULL );
header = MITKipPicGetTags( filename, header );
if ( header == NULL )
{
itk::ImageFileReaderException e( __FILE__, __LINE__ );
- itk::OStringStream msg;
+ std::ostringstream msg;
msg << " Could not read file " << m_FileName.c_str();
e.SetDescription( msg.str().c_str() );
throw e;
return ;
}
if ( header->dim != 3 )
{
itk::ImageFileReaderException e( __FILE__, __LINE__ , "Only 3D-pic volumes are supported! " );
throw e;
return ;
}
//
// modify the header to match the real temporal extent
//
header->dim = 4;
header->n[ 3 ] = m_MatchedFileNames.size();
output->Initialize( CastToImageDescriptor( header) );
mitkIpPicFree( header );
m_ReadHeaderTime.Modified();
}
void mitk::PicVolumeTimeSeriesReader::GenerateData()
{
mitk::Image::Pointer output = this->GetOutput();
//
// Check to see if we can read the file given the name or prefix
//
if ( m_FilePrefix == "" || m_FilePattern == "" )
{
throw itk::ImageFileReaderException( __FILE__, __LINE__, "Both FilePattern and FilePrefix must be non-empty" );
}
if ( m_MatchedFileNames.size() == 0 )
{
throw itk::ImageFileReaderException( __FILE__, __LINE__, "Sorry, there are no files to read!" );
}
//
// read 3d volumes and copy them to the 4d volume
//
mitkIpPicDescriptor* volume3d = NULL;
for ( unsigned int t = 0 ; t < m_MatchedFileNames.size() ; ++t )
{
char* filename = const_cast< char* >( m_MatchedFileNames[ t ].c_str() );
MITK_INFO << "Reading file " << filename << "..." << std::endl;
volume3d = MITKipPicGet( filename, NULL );
if ( volume3d == NULL )
{
- ::itk::OStringStream message;
+ std::ostringstream message;
message << "mitk::ERROR: " << this->GetNameOfClass() << "(" << this << "): "
<< "File (" << filename << ") of time frame " << t << " could not be read!";
throw itk::ImageFileReaderException( __FILE__, __LINE__, message.str().c_str() );
}
//
// @TODO do some error checking
//
//
// copy the 3d data volume to the 4d volume
//
// \todo use memory of Image as in PicFileReader (or integrate everything into the PicFileReader!)
PicFileReader::ConvertHandedness(volume3d);
bool result = false;
// FIXME
//result = output->SetPicVolume( volume3d, t );
if(result==false)
{
- ::itk::OStringStream message;
+ std::ostringstream message;
message << "mitk::ERROR: " << this->GetNameOfClass() << "(" << this << "): "
<< "Volume of time frame " << t << " did not match size of other time frames.";
throw itk::ImageFileReaderException( __FILE__, __LINE__, message.str().c_str() );
}
mitkIpPicFree ( volume3d );
}
}
bool mitk::PicVolumeTimeSeriesReader::CanReadFile(const std::string /*filename*/, const std::string filePrefix, const std::string filePattern)
{
if( filePattern == "" && filePrefix == "" )
return false;
bool extensionFound = false;
std::string::size_type PICPos = filePattern.rfind(".pic");
if ((PICPos != std::string::npos)
&& (PICPos == filePattern.length() - 4))
{
extensionFound = true;
}
PICPos = filePattern.rfind(".pic.gz");
if ((PICPos != std::string::npos)
&& (PICPos == filePattern.length() - 7))
{
extensionFound = true;
}
if( !extensionFound )
return false;
return true;
}
mitk::PicVolumeTimeSeriesReader::PicVolumeTimeSeriesReader()
{
//this->DebugOn();
}
mitk::PicVolumeTimeSeriesReader::~PicVolumeTimeSeriesReader()
{}
diff --git a/Modules/LegacyAdaptors/mitkLegacyAdaptors.cpp b/Modules/LegacyAdaptors/mitkLegacyAdaptors.cpp
index b6bea9e987..b18d02f9a5 100644
--- a/Modules/LegacyAdaptors/mitkLegacyAdaptors.cpp
+++ b/Modules/LegacyAdaptors/mitkLegacyAdaptors.cpp
@@ -1,185 +1,185 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLegacyAdaptors.h"
#include <mitkImageWriteAccessor.h>
mitkIpPicDescriptor* mitk::CastToIpPicDescriptor(mitk::Image::Pointer refImg, mitk::ImageWriteAccessor* imageAccess, mitkIpPicDescriptor* picDesc)
{
const mitk::ImageDescriptor::Pointer imDesc = refImg->GetImageDescriptor();
// initialize dimension information
for (unsigned int i=0; i<8; i++)
{
picDesc->n[i] = 1;
}
// set dimension information
picDesc->dim = refImg->GetDimension();
memcpy( picDesc->n, imDesc->GetDimensions(), picDesc->dim * sizeof(unsigned int) );
- picDesc->type = CastToIpPicType( refImg->GetPixelType().GetTypeId() );
+ picDesc->type = CastToIpPicType( refImg->GetPixelType().GetComponentType() );
picDesc->bpe = refImg->GetPixelType().GetBpe();
picDesc->data = imageAccess->GetData();
return picDesc;
}
mitkIpPicDescriptor* mitk::CastToIpPicDescriptor(itk::SmartPointer<mitk::ImageDataItem> refItem, mitk::ImageWriteAccessor* imageAccess, mitkIpPicDescriptor *picDesc)
{
// initialize dimension information
for (unsigned int i=0; i<8; i++)
{
picDesc->n[i] = 1;
}
// get the dimensionality information from image item
picDesc->dim = refItem->GetDimension();
for( unsigned int i=0; i<picDesc->dim; i++)
{
picDesc->n[i] = refItem->GetDimension(i);
}
- picDesc->type = CastToIpPicType( refItem->GetPixelType().GetTypeId() );
+ picDesc->type = CastToIpPicType( refItem->GetPixelType().GetComponentType() );
picDesc->bpe = refItem->GetPixelType().GetBpe();
picDesc->data = imageAccess->GetData();
return picDesc;
}
mitkIpPicDescriptor* mitk::CastToIpPicDescriptor(mitk::Image::Pointer refImg, mitkIpPicDescriptor* picDesc)
{
const mitk::ImageDescriptor::Pointer imDesc = refImg->GetImageDescriptor();
// initialize dimension information
for (unsigned int i=0; i<8; i++)
{
picDesc->n[i] = 1;
}
// set dimension information
picDesc->dim = refImg->GetDimension();
memcpy( picDesc->n, imDesc->GetDimensions(), picDesc->dim * sizeof(unsigned int) );
- picDesc->type = CastToIpPicType( refImg->GetPixelType().GetTypeId() );
+ picDesc->type = CastToIpPicType( refImg->GetPixelType().GetComponentType() );
picDesc->bpe = refImg->GetPixelType().GetBpe();
picDesc->data = refImg->GetData();
return picDesc;
}
mitkIpPicDescriptor* mitk::CastToIpPicDescriptor(itk::SmartPointer<mitk::ImageDataItem> refItem, mitkIpPicDescriptor *picDesc)
{
// initialize dimension information
for (unsigned int i=0; i<8; i++)
{
picDesc->n[i] = 1;
}
// get the dimensionality information from image item
picDesc->dim = refItem->GetDimension();
for( unsigned int i=0; i<picDesc->dim; i++)
{
picDesc->n[i] = refItem->GetDimension(i);
}
- picDesc->type = CastToIpPicType( refItem->GetPixelType().GetTypeId() );
+ picDesc->type = CastToIpPicType( refItem->GetPixelType().GetComponentType() );
picDesc->bpe = refItem->GetPixelType().GetBpe();
picDesc->data = refItem->GetData();
return picDesc;
}
mitk::ImageDescriptor::Pointer mitk::CastToImageDescriptor(mitkIpPicDescriptor *desc)
{
mitk::ImageDescriptor::Pointer imDescriptor = mitk::ImageDescriptor::New();
imDescriptor->Initialize( desc->n, desc->dim );
mitk::PixelType ptype = CastToPixelType( desc->type, (desc->bpe/8) );
imDescriptor->AddNewChannel(ptype, "imported by pic");
return imDescriptor;
}
-mitkIpPicType_t mitk::CastToIpPicType( const std::type_info& intype )
+mitkIpPicType_t mitk::CastToIpPicType( int intype )
{
//const std::type_info& intype = ptype.GetTypeId();
//MITK_INFO << "Casting to PicType from " << intype.name() << std::endl;
- const bool isSignedIntegralType = ( intype == typeid(int)
- || intype == typeid(short)
- || intype == typeid(char)
- || intype == typeid(long int) );
+ const bool isSignedIntegralType = ( intype == itk::ImageIOBase::INT
+ || intype == itk::ImageIOBase::SHORT
+ || intype == itk::ImageIOBase::CHAR
+ || intype == itk::ImageIOBase::LONG );
- const bool isUnsignedIntegralType = ( intype == typeid(unsigned int)
- || intype == typeid(unsigned short)
- || intype == typeid(unsigned char)
- || intype == typeid(unsigned long int) );
+ const bool isUnsignedIntegralType = ( intype == itk::ImageIOBase::UINT
+ || intype == itk::ImageIOBase::USHORT
+ || intype == itk::ImageIOBase::UCHAR
+ || intype == itk::ImageIOBase::ULONG );
- const bool isFloatingPointType = ( intype == typeid(float)
- || intype == typeid(double) );
+ const bool isFloatingPointType = ( intype == itk::ImageIOBase::FLOAT
+ || intype == itk::ImageIOBase::DOUBLE );
if( isSignedIntegralType ) return mitkIpPicInt;
if( isUnsignedIntegralType ) return mitkIpPicUInt;
if( isFloatingPointType ) return mitkIpPicFloat;
return mitkIpPicUnknown;
}
mitk::PixelType mitk::CastToPixelType(mitkIpPicType_t pictype, size_t bpe)
{
const bool isSignedIntegralType = (pictype == mitkIpPicInt );
const bool isUnsignedIntegralType = (pictype == mitkIpPicUInt );
if(isSignedIntegralType)
{
switch(bpe)
{
case sizeof(char):
return MakeScalarPixelType<char>();
case sizeof(short):
return MakeScalarPixelType<short>();
default:
return MakeScalarPixelType<int>();
}
}
else if( isUnsignedIntegralType )
{
switch(bpe)
{
case sizeof(unsigned char):
return MakeScalarPixelType<unsigned char>();
case sizeof(unsigned short):
return MakeScalarPixelType<unsigned short>();
default:
return MakeScalarPixelType<unsigned int>();
}
}
else // is floating point type
{
switch(bpe)
{
case sizeof(float):
return MakeScalarPixelType<float>();
default:
return MakeScalarPixelType<double>();
}
}
}
diff --git a/Modules/LegacyAdaptors/mitkLegacyAdaptors.h b/Modules/LegacyAdaptors/mitkLegacyAdaptors.h
index 7fbae1528c..c464e22985 100644
--- a/Modules/LegacyAdaptors/mitkLegacyAdaptors.h
+++ b/Modules/LegacyAdaptors/mitkLegacyAdaptors.h
@@ -1,97 +1,97 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _mitkLegacyAdaptors_h
#define _mitkLegacyAdaptors_h_
#include "mitkCommon.h"
#include "LegacyAdaptorsExports.h"
#include <mitkIpPic.h>
#include "mitkImage.h"
#include "mitkImageWriteAccessor.h"
/** \file mitkLegacyAdaptors.h
*
* The LegacyAdaptors module is intended to provide an interface to deprecated types/objects/methods as part of backward compatibility
* Currently the module offers methods for casting an Image or an ImageDataItem respectively to a mitkIpPicDescriptor object since several Algorigthms
* in MITK Modules still use the deprecated IpPic format and algorithms.
*
* \warning The IpPic-related classes are no more accessible through the Core Module. The dependencies needs to be set directly for the affected module. Furthermore,
* if you want to cast information between mitk::Image and mitkIpPicDescriptor, also the dependency to the LegacyAdaptors module needs to be set.
*/
namespace mitk
{
/**
\brief Constructs a legacy mitkIpPicDescriptor from mitk::Image
Meant to support legacy code, which was base on mitkIpPicDescriptor types. Please remind that such code should be migrated towards ITK/VTK solutions.
*/
LegacyAdaptors_EXPORT mitkIpPicDescriptor* CastToIpPicDescriptor(mitk::Image::Pointer, mitk::ImageWriteAccessor*, mitkIpPicDescriptor* picDesc);
/**
\brief Constructs a legacy mitkIpPicDescriptor from mitk::ImageDataItem
\warning The returned IpPicDescriptor is only referencing the memory block with the data managed by the given ImageDataItem parameter.
Simply calling ipPicFree( desc ) will delete the data and so will the ImageDataItem try when it get deleted. Simplest way to avoid the duplicate
deletion attempt is to set the desc->data manually to NULL before calling the ipPicFree() on the descriptor
*/
LegacyAdaptors_EXPORT mitkIpPicDescriptor* CastToIpPicDescriptor(itk::SmartPointer<mitk::ImageDataItem>, mitk::ImageWriteAccessor*, mitkIpPicDescriptor *picDesc );
/**
\brief Constructs a deprecated legacy mitkIpPicDescriptor from mitk::Image
Meant to support legacy code, which was base on mitkIpPicDescriptor types. Please remind that such code should be migrated towards ITK/VTK solutions.
\deprecatedSince{2012_09} Please use image accessors instead! An image accessor (ImageWriteAccessor) can be commited to CastToIpPicDescriptor.
*/
LegacyAdaptors_EXPORT DEPRECATED(mitkIpPicDescriptor* CastToIpPicDescriptor(mitk::Image::Pointer, mitkIpPicDescriptor* picDesc));
/**
\brief Constructs a deprecated legacy mitkIpPicDescriptor from mitk::ImageDataItem
\warning The returned IpPicDescriptor is only referencing the memory block with the data managed by the given ImageDataItem parameter.
Simply calling ipPicFree( desc ) will delete the data and so will the ImageDataItem try when it get deleted. Simplest way to avoid the duplicate
deletion attempt is to set the desc->data manually to NULL before calling the ipPicFree() on the descriptor
\deprecatedSince{2012_09} Please use image accessors instead! An image accessor (ImageWriteAccessor) can be commited to CastToIpPicDescriptor.
*/
LegacyAdaptors_EXPORT DEPRECATED(mitkIpPicDescriptor* CastToIpPicDescriptor(itk::SmartPointer<mitk::ImageDataItem>, mitkIpPicDescriptor *picDesc));
/**
\brief Constructs an ImageDescriptor from legacy mitkIpPicDescriptor
Performs the oposite cast direction to \sa CastToIpPicDescriptor
*/
LegacyAdaptors_EXPORT DEPRECATED(mitk::ImageDescriptor::Pointer CastToImageDescriptor(mitkIpPicDescriptor* desc));
/**
\brief Constructs a legacy type information from mitk::PixelType
The IpPicDescriptor uses own notations for different pixel types. This casting is needed e.g. by the CastToIpPicDescriptor method.
*/
- LegacyAdaptors_EXPORT DEPRECATED(mitkIpPicType_t CastToIpPicType( const std::type_info& intype ) );
+ LegacyAdaptors_EXPORT DEPRECATED(mitkIpPicType_t CastToIpPicType( int componentType ) );
/**
\brief Returns a mitk::PixelType object corresponding to given mitkIpPicType_t
The method needs the mitkIpPicType_t and the bits per element (bpe) information to be able to create the correct corresponding PixelType
\sa PixelType
*/
LegacyAdaptors_EXPORT DEPRECATED(PixelType CastToPixelType( mitkIpPicType_t pictype, size_t bpe ) );
} // end namespace mitk
#endif
diff --git a/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp b/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp
index 4d91f7438c..78c532ee3c 100644
--- a/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp
@@ -1,222 +1,223 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkAngleCorrectByPointFilter.h"
#include "mitkIpPic.h"
#include "mitkImageTimeSelector.h"
#include "mitkProperties.h"
mitk::AngleCorrectByPointFilter::AngleCorrectByPointFilter() : m_PreferTransducerPositionFromProperty(true)
{
m_Center.Fill(0);
m_TransducerPosition.Fill(0);
}
mitk::AngleCorrectByPointFilter::~AngleCorrectByPointFilter()
{
}
void mitk::AngleCorrectByPointFilter::GenerateOutputInformation()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int i;
unsigned int *tmpDimensions = new unsigned int[input->GetDimension()];
for(i=0;i<input->GetDimension();++i)
tmpDimensions[i]=input->GetDimension(i);
//@todo maybe we should shift the following somehow in ImageToImageFilter
mitk::PixelType scalarPType = MakeScalarPixelType<ScalarType>();
output->Initialize(scalarPType,
input->GetDimension(),
tmpDimensions,
input->GetNumberOfChannels());
output->GetSlicedGeometry()->SetSpacing(input->GetSlicedGeometry()->GetSpacing());
//output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
//output->GetSlicedGeometry()->SetEvenlySpaced();
//set the timebounds - after SetGeometry2D, so that the already created PlaneGeometry will also receive this timebounds.
//@fixme!!! will not work for not evenly timed data!
output->GetSlicedGeometry()->SetTimeBounds(input->GetSlicedGeometry()->GetTimeBounds());
output->GetTimeSlicedGeometry()->InitializeEvenlyTimed(output->GetSlicedGeometry(), output->GetTimeSlicedGeometry()->GetTimeSteps());
output->SetPropertyList(input->GetPropertyList()->Clone());
delete [] tmpDimensions;
m_TimeOfHeaderInitialization.Modified();
}
void mitk::AngleCorrectByPointFilter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if(m_PreferTransducerPositionFromProperty)
{
mitk::Point3iProperty::Pointer pointProp;
pointProp = dynamic_cast<mitk::Point3iProperty*>(input->GetProperty("ORIGIN").GetPointer());
if (pointProp.IsNotNull() )
{
const itk::Point<int, 3> & p = pointProp->GetValue();
m_TransducerPosition[0] = p[0];
m_TransducerPosition[1] = p[1];
m_TransducerPosition[2] = p[2];
}
}
itkDebugMacro( << "compute angle corrected image .... " );
itkDebugMacro( << " Center[0]=" << m_Center[0] << " Center[1]=" << m_Center[1] << " Center[2]=" << m_Center[2] );
itkDebugMacro( << " TransducerPosition[0]=" << m_TransducerPosition[0] << " TransducerPosition[1]=" << m_TransducerPosition[1] << " TransducerPosition[2]=" << m_TransducerPosition[2] );
const Vector3D & spacing = input->GetSlicedGeometry()->GetSpacing();
// MITK_INFO << " in: xres=" << spacing[0] << " yres=" << spacing[1] << " zres=" << spacing[2] << std::endl;
if((spacing[0]!=spacing[1]) || (spacing[0]!=spacing[2]))
{
itkExceptionMacro("filter does not work for uninsotropic data: spacing: ("<< spacing[0] << "," << spacing[1] << "," << spacing[2] << ")");
}
Vector3D p;
Vector3D tx_direction;
Vector3D tx_position = m_TransducerPosition.GetVectorFromOrigin();
Vector3D center = m_Center.GetVectorFromOrigin();
Vector3D assumed_direction;
ScalarType &x=p[0];
ScalarType &y=p[1];
ScalarType &z=p[2];
Vector3D down;
FillVector3D(down,0.0,0.0,-1.0);
int xDim = input->GetDimension(0);
int yDim = input->GetDimension(1);
int zDim = input->GetDimension(2);
mitkIpPicDescriptor* pic_out;
pic_out = mitkIpPicNew();
pic_out->dim = 3;
pic_out->bpe = output->GetPixelType().GetBpe();
//pic_out->type = output->GetPixelType().GetType();
pic_out->n[0] = xDim;
pic_out->n[1] = yDim;
pic_out->n[2] = zDim;
pic_out->data = malloc(_mitkIpPicSize(pic_out));
//go!
mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New();
timeSelector->SetInput(input);
int nstart, nmax;
int tstart, tmax;
tstart=output->GetRequestedRegion().GetIndex(3);
nstart=output->GetRequestedRegion().GetIndex(4);
tmax=tstart+output->GetRequestedRegion().GetSize(3);
nmax=nstart+output->GetRequestedRegion().GetSize(4);
int n,t;
for(n=nstart;n<nmax;++n)//output->GetNumberOfChannels();++n)
{
timeSelector->SetChannelNr(n);
for(t=tstart;t<tmax;++t)
{
timeSelector->SetTimeNr(t);
timeSelector->Update();
typedef unsigned char InputImagePixelType;
typedef ScalarType OutputImagePixelType;
- if(input->GetPixelType().GetTypeId()!=typeid(InputImagePixelType))
+ if(input->GetPixelType().GetPixelType() != itk::ImageIOBase::SCALAR ||
+ input->GetPixelType().GetComponentType()!= MapPixelComponentType<InputImagePixelType>::value)
{
itkExceptionMacro("only implemented for " << typeid(PixelType).name() );
}
InputImagePixelType *in;
OutputImagePixelType *out;
in = (InputImagePixelType *)timeSelector->GetOutput()->GetData();
out = (OutputImagePixelType*)pic_out->data;
for (z=0 ; z<zDim ; ++z)
{
for (y=0; y<yDim; ++y)
{
for (x=0; x<xDim; ++x, ++in, ++out)
{
tx_direction = tx_position-p;
tx_direction.Normalize();
//are we within the acquisition cone?
// if(-tx_direction*down>vnl_math::pi_over_4)
{
assumed_direction = center-p;
assumed_direction.Normalize();
ScalarType cos_factor = tx_direction*assumed_direction;
if(fabs(cos_factor)>eps)
*out=((ScalarType)(*in)-128.0)/cos_factor;
else
*out=((ScalarType)(*in)-128.0)/eps;
}
//else
// *out=0;
}
}
}
//output->SetPicVolume(pic_out, t, n);
}
}
}
void mitk::AngleCorrectByPointFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::ImageToImageFilter::InputImagePointer input =
const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput() );
mitk::Image::Pointer output = this->GetOutput();
Image::RegionType requestedRegion;
requestedRegion = output->GetRequestedRegion();
requestedRegion.SetIndex(0, 0);
requestedRegion.SetIndex(1, 0);
requestedRegion.SetIndex(2, 0);
//requestedRegion.SetIndex(3, 0);
//requestedRegion.SetIndex(4, 0);
requestedRegion.SetSize(0, input->GetDimension(0));
requestedRegion.SetSize(1, input->GetDimension(1));
requestedRegion.SetSize(2, input->GetDimension(2));
//requestedRegion.SetSize(3, output->GetDimension(3));
//requestedRegion.SetSize(4, output->GetNumberOfChannels());
input->SetRequestedRegion( & requestedRegion );
}
diff --git a/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp b/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp
index b13cf0477b..b1476eaa09 100644
--- a/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp
@@ -1,235 +1,236 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#if(_MSC_VER==1200)
#include <itkFixedCenterOfRotationAffineTransform.h>
#include <itkIndex.h>
#include <itkConceptChecking.h>
#endif
#include "mitkBoundingObjectCutter.h"
#include "mitkBoundingObjectCutter.txx"
#include "mitkTimeHelper.h"
#include "mitkImageAccessByItk.h"
#include "mitkBoundingObject.h"
#include "mitkGeometry3D.h"
+#include <math.h>
//#include "itkImageRegionIteratorWithIndex.h"
namespace mitk
{
void BoundingObjectCutter::SetBoundingObject( const mitk::BoundingObject* boundingObject )
{
m_BoundingObject = const_cast<mitk::BoundingObject*>(boundingObject);
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(1,
const_cast< mitk::BoundingObject * >( boundingObject ) );
}
const mitk::BoundingObject* BoundingObjectCutter::GetBoundingObject() const
{
return m_BoundingObject.GetPointer();
}
BoundingObjectCutter::BoundingObjectCutter()
: m_BoundingObject(NULL), m_InsideValue(1), m_OutsideValue(0), m_AutoOutsideValue(false),
m_UseInsideValue(false), m_OutsidePixelCount(0), m_InsidePixelCount(0), m_UseWholeInputRegion(false)
{
- this->SetNumberOfInputs(2);
+ this->SetNumberOfIndexedInputs(2);
this->SetNumberOfRequiredInputs(2);
m_InputTimeSelector = mitk::ImageTimeSelector::New();
m_OutputTimeSelector = mitk::ImageTimeSelector::New();
}
BoundingObjectCutter::~BoundingObjectCutter()
{
}
const mitk::PixelType BoundingObjectCutter::GetOutputPixelType()
{
return this->GetInput()->GetPixelType();
}
void BoundingObjectCutter::GenerateInputRequestedRegion()
{
mitk::Image* output = this->GetOutput();
if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
return;
// we have already calculated the spatial part of the
// input-requested-region in m_InputRequestedRegion in
// GenerateOutputInformation (which is called before
// GenerateInputRequestedRegion).
GenerateTimeInInputRegion(output, const_cast< mitk::Image * > ( this->GetInput() ));
GenerateTimeInInputRegion(output, m_BoundingObject.GetPointer());
}
void BoundingObjectCutter::GenerateOutputInformation()
{
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
mitk::Image::Pointer input = const_cast< mitk::Image * > ( this->GetInput() );
if(input.IsNull())
{
MITK_WARN << "Input is not a mitk::Image";
return;
}
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int dimension = input->GetDimension();
if (dimension < 3)
{
MITK_WARN << "ImageCropper cannot handle 1D or 2D Objects. Operation aborted.";
return;
}
if((m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
return;
mitk::Geometry3D* boGeometry = m_BoundingObject->GetGeometry();
mitk::Geometry3D* inputImageGeometry = input->GetSlicedGeometry();
// calculate bounding box of bounding-object relative to the geometry
// of the input image. The result is in pixel coordinates of the input
// image (because the m_IndexToWorldTransform includes the spacing).
mitk::BoundingBox::Pointer boBoxRelativeToImage = boGeometry->CalculateBoundingBoxRelativeToTransform( inputImageGeometry->GetIndexToWorldTransform() );
// PART I: initialize input requested region. We do this already here (and not
// later when GenerateInputRequestedRegion() is called), because we
// also need the information to setup the output.
// pre-initialize input-requested-region to largest-possible-region
// and correct time-region; spatial part will be cropped by
// bounding-box of bounding-object below
m_InputRequestedRegion = input->GetLargestPossibleRegion();
// build region out of bounding-box of bounding-object
mitk::SlicedData::IndexType index=m_InputRequestedRegion.GetIndex(); //init times and channels
mitk::BoundingBox::PointType min = boBoxRelativeToImage->GetMinimum();
- index[0] = (mitk::SlicedData::IndexType::IndexValueType)(min[0]);
- index[1] = (mitk::SlicedData::IndexType::IndexValueType)(min[1]);
- index[2] = (mitk::SlicedData::IndexType::IndexValueType)(min[2]);
+ index[0] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[0]));
+ index[1] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[1]));
+ index[2] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[2]));
mitk::SlicedData::SizeType size = m_InputRequestedRegion.GetSize(); //init times and channels
mitk::BoundingBox::PointType max = boBoxRelativeToImage->GetMaximum();
- size[0] = (mitk::SlicedData::SizeType::SizeValueType)(max[0])-index[0];
- size[1] = (mitk::SlicedData::SizeType::SizeValueType)(max[1])-index[1];
- size[2] = (mitk::SlicedData::SizeType::SizeValueType)(max[2])-index[2];
+ size[0] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[0])-index[0]);
+ size[1] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[1])-index[1]);
+ size[2] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[2])-index[2]);
mitk::SlicedData::RegionType boRegion(index, size);
if(m_UseWholeInputRegion == false)
{
// crop input-requested-region with region of bounding-object
if(m_InputRequestedRegion.Crop(boRegion)==false)
{
// crop not possible => do nothing: set time size to 0.
size.Fill(0);
m_InputRequestedRegion.SetSize(size);
boRegion.SetSize(size);
m_BoundingObject->SetRequestedRegion(&boRegion);
return;
}
}
// set input-requested-region, because we access it later in
// GenerateInputRequestedRegion (there we just set the time)
input->SetRequestedRegion(&m_InputRequestedRegion);
// PART II: initialize output image
unsigned int *dimensions = new unsigned int [dimension];
itk2vtk(m_InputRequestedRegion.GetSize(), dimensions);
if(dimension>3)
memcpy(dimensions+3, input->GetDimensions()+3, (dimension-3)*sizeof(unsigned int));
output->Initialize(mitk::PixelType(GetOutputPixelType()), dimension, dimensions);
delete [] dimensions;
// now we have everything to initialize the transform of the output
mitk::SlicedGeometry3D* slicedGeometry = output->GetSlicedGeometry();
// set the transform: use the transform of the input;
// the origin will be replaced afterwards
AffineTransform3D::Pointer indexToWorldTransform = AffineTransform3D::New();
indexToWorldTransform->SetParameters(input->GetSlicedGeometry()->GetIndexToWorldTransform()->GetParameters());
slicedGeometry->SetIndexToWorldTransform(indexToWorldTransform);
// Position the output Image to match the corresponding region of the input image
const mitk::SlicedData::IndexType& start = m_InputRequestedRegion.GetIndex();
mitk::Point3D origin; vtk2itk(start, origin);
inputImageGeometry->IndexToWorld(origin, origin);
slicedGeometry->SetOrigin(origin);
mitk::TimeSlicedGeometry* timeSlicedGeometry = output->GetTimeSlicedGeometry();
timeSlicedGeometry->InitializeEvenlyTimed(slicedGeometry, output->GetDimension(3));
timeSlicedGeometry->CopyTimes(input->GetTimeSlicedGeometry());
m_TimeOfHeaderInitialization.Modified();
}
void BoundingObjectCutter::ComputeData(mitk::Image* input3D, int boTimeStep)
{
AccessFixedDimensionByItk_2(input3D, CutImage, 3, this, boTimeStep);
}
void BoundingObjectCutter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if(input.IsNull())
return;
if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
return;
m_InputTimeSelector->SetInput(input);
m_OutputTimeSelector->SetInput(this->GetOutput());
mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
const mitk::TimeSlicedGeometry *boundingObjectTimeGeometry = m_BoundingObject->GetTimeSlicedGeometry();
ScalarType timeInMS;
int timestep=0;
int tstart=outputRegion.GetIndex(3);
int tmax=tstart+outputRegion.GetSize(3);
int t;
for(t=tstart;t<tmax;++t)
{
timeInMS = outputTimeGeometry->TimeStepToMS( t );
timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
m_InputTimeSelector->SetTimeNr(timestep);
m_InputTimeSelector->UpdateLargestPossibleRegion();
m_OutputTimeSelector->SetTimeNr(t);
m_OutputTimeSelector->UpdateLargestPossibleRegion();
timestep = boundingObjectTimeGeometry->MSToTimeStep( timeInMS );
ComputeData(m_InputTimeSelector->GetOutput(), timestep);
}
m_InputTimeSelector->SetInput(NULL);
m_OutputTimeSelector->SetInput(NULL);
m_TimeOfHeaderInitialization.Modified();
}
} // of namespace mitk
diff --git a/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.txx b/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.txx
index f10c0474a7..9c602b2a60 100644
--- a/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.txx
+++ b/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.txx
@@ -1,152 +1,151 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKBOUNDINGOBJECTCUTTER_TXX
#define MITKBOUNDINGOBJECTCUTTER_TXX
#include "mitkStatusBar.h"
#include "mitkImageToItk.h"
#include "itkImageRegionIteratorWithIndex.h"
namespace mitk
{
template < typename TPixel, unsigned int VImageDimension, typename TOutputPixel >
void CutImageWithOutputTypeSelect
( itk::Image<TPixel, VImageDimension>* inputItkImage, mitk::BoundingObjectCutter* cutter, int /* boTimeStep */, TOutputPixel* /* dummy */)
{
typedef itk::Image<TPixel, VImageDimension> ItkInputImageType;
typedef itk::Image<TOutputPixel, VImageDimension> ItkOutputImageType;
typedef typename itk::ImageBase<VImageDimension>::RegionType ItkRegionType;
typedef itk::ImageRegionIteratorWithIndex< ItkInputImageType > ItkInputImageIteratorType;
typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;
if(cutter->m_BoundingObject.IsNull())
return;
if (inputItkImage == NULL)
{
mitk::StatusBar::GetInstance()->DisplayErrorText ("An internal error occurred. Can't convert Image. Please report to bugs@mitk.org");
std::cout << " image is NULL...returning" << std::endl;
return;
}
- // PART 1: convert m_InputRequestedRegion (type mitk::SlicedData::RegionType)
+ // PART 1: convert m_InputRequestedReg ion (type mitk::SlicedData::RegionType)
// into ITK-image-region (ItkImageType::RegionType)
// unfortunately, we cannot use input->GetRequestedRegion(), because it
// has been destroyed by the mitk::CastToItkImage call of PART 1
// (which sets the m_RequestedRegion to the LargestPossibleRegion).
// Thus, use our own member m_InputRequestedRegion insead.
// first convert the index
typename ItkRegionType::IndexType::IndexValueType tmpIndex[3];
itk2vtk(cutter->m_InputRequestedRegion.GetIndex(), tmpIndex);
typename ItkRegionType::IndexType index;
index.SetIndex(tmpIndex);
// then convert the size
typename ItkRegionType::SizeType::SizeValueType tmpSize[3];
itk2vtk(cutter->m_InputRequestedRegion.GetSize(), tmpSize);
typename ItkRegionType::SizeType size;
size.SetSize(tmpSize);
//create the ITK-image-region out of index and size
ItkRegionType inputRegionOfInterest(index, size);
// PART 2: get access to the MITK output image via an ITK image
typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk = mitk::ImageToItk<ItkOutputImageType>::New();
outputimagetoitk->SetInput(cutter->m_OutputTimeSelector->GetOutput());
outputimagetoitk->Update();
typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
// PART 3: iterate over input and output using ITK iterators
// create the iterators
ItkInputImageIteratorType inputIt( inputItkImage, inputRegionOfInterest );
ItkOutputImageIteratorType outputIt( outputItkImage, outputItkImage->GetLargestPossibleRegion() );
// Cut the boundingbox out of the image by iterating through
// all pixels and checking if they are inside using IsInside()
cutter->m_OutsidePixelCount = 0;
cutter->m_InsidePixelCount = 0;
mitk::Point3D p;
mitk::Geometry3D* inputGeometry = cutter->GetInput()->GetGeometry();
TOutputPixel outsideValue;
if(cutter->m_AutoOutsideValue)
{
outsideValue = itk::NumericTraits<TOutputPixel>::min();
}
else
{
outsideValue = (TOutputPixel) cutter->m_OutsideValue;
}
-
//shall we use a fixed value for each inside pixel?
if (cutter->GetUseInsideValue())
{
TOutputPixel insideValue = (TOutputPixel) cutter->m_InsideValue;
// yes, use a fixed value for each inside pixel (create a binary mask of the bounding object)
for ( inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt)
{
vtk2itk(inputIt.GetIndex(), p);
inputGeometry->IndexToWorld(p, p);
if(cutter->m_BoundingObject->IsInside(p))
{
outputIt.Set(insideValue);
++cutter->m_InsidePixelCount;
}
else
{
outputIt.Set(outsideValue);
++cutter->m_OutsidePixelCount;
}
}
}
else
{
// no, use the pixel value of the original image (normal cutting)
for ( inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt)
{
vtk2itk(inputIt.GetIndex(), p);
inputGeometry->IndexToWorld(p, p);
if(cutter->m_BoundingObject->IsInside(p))
{
outputIt.Set( (TOutputPixel) inputIt.Value() );
++cutter->m_InsidePixelCount;
}
else
{
outputIt.Set( outsideValue );
++cutter->m_OutsidePixelCount;
}
}
}
}
template < typename TPixel, unsigned int VImageDimension >
void CutImage( itk::Image< TPixel, VImageDimension >* inputItkImage, mitk::BoundingObjectCutter* cutter, int boTimeStep )
{
TPixel* dummy = NULL;
CutImageWithOutputTypeSelect<TPixel, VImageDimension, TPixel>(inputItkImage, cutter, boTimeStep, dummy);
}
} // of namespace mitk
#include "mitkImageCast.h"
#endif // of MITKBOUNDINGOBJECTCUTTER_TXX
diff --git a/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.cpp b/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.cpp
index eb6b8546a4..fb35a8e338 100644
--- a/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkGeometryClipImageFilter.cpp
@@ -1,253 +1,253 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkGeometryClipImageFilter.h"
#include "mitkImageTimeSelector.h"
#include "mitkTimeHelper.h"
#include "mitkProperties.h"
#include "mitkImageToItk.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionIteratorWithIndex.h"
#include <limits>
mitk::GeometryClipImageFilter::GeometryClipImageFilter()
: m_ClippingGeometry(NULL),
m_ClipPartAboveGeometry(true),
m_OutsideValue(0),
m_AutoOutsideValue(false),
m_LabelBothSides(false),
m_AutoOrientLabels(false),
m_AboveGeometryLabel(1),
m_BelowGeometryLabel(2)
{
- this->SetNumberOfInputs(2);
+ this->SetNumberOfIndexedInputs(2);
this->SetNumberOfRequiredInputs(2);
m_InputTimeSelector = mitk::ImageTimeSelector::New();
m_OutputTimeSelector = mitk::ImageTimeSelector::New();
m_ClippingGeometryData = mitk::GeometryData::New();
}
mitk::GeometryClipImageFilter::~GeometryClipImageFilter()
{
}
void mitk::GeometryClipImageFilter::SetClippingGeometry(const mitk::Geometry3D* aClippingGeometry)
{
if(aClippingGeometry != m_ClippingGeometry.GetPointer())
{
m_ClippingGeometry = aClippingGeometry;
m_TimeSlicedClippingGeometry = dynamic_cast<const TimeSlicedGeometry*>(aClippingGeometry);
m_ClippingGeometryData->SetGeometry(const_cast<mitk::Geometry3D*>(aClippingGeometry));
SetNthInput(1, m_ClippingGeometryData);
Modified();
}
}
const mitk::Geometry3D* mitk::GeometryClipImageFilter::GetClippingGeometry() const
{
return m_ClippingGeometry;
}
void mitk::GeometryClipImageFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::Image* output = this->GetOutput();
mitk::Image* input = const_cast< mitk::Image * > ( this->GetInput() );
if((output->IsInitialized()==false) || (m_ClippingGeometry.IsNull()))
return;
input->SetRequestedRegionToLargestPossibleRegion();
GenerateTimeInInputRegion(output, input);
}
void mitk::GeometryClipImageFilter::GenerateOutputInformation()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int i;
unsigned int *tmpDimensions = new unsigned int[input->GetDimension()];
for(i=0;i<input->GetDimension();++i)
tmpDimensions[i]=input->GetDimension(i);
output->Initialize(input->GetPixelType(),
input->GetDimension(),
tmpDimensions,
input->GetNumberOfChannels());
delete [] tmpDimensions;
output->SetGeometry(static_cast<mitk::Geometry3D*>(input->GetGeometry()->Clone().GetPointer()));
output->SetPropertyList(input->GetPropertyList()->Clone());
m_TimeOfHeaderInitialization.Modified();
}
template < typename TPixel, unsigned int VImageDimension >
void mitk::_InternalComputeClippedImage(itk::Image<TPixel, VImageDimension>* inputItkImage, mitk::GeometryClipImageFilter* geometryClipper, const mitk::Geometry2D* clippingGeometry2D)
{
typedef itk::Image<TPixel, VImageDimension> ItkInputImageType;
typedef itk::Image<TPixel, VImageDimension> ItkOutputImageType;
typedef itk::ImageRegionConstIteratorWithIndex< ItkInputImageType > ItkInputImageIteratorType;
typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;
typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk = mitk::ImageToItk<ItkOutputImageType>::New();
outputimagetoitk->SetInput(geometryClipper->m_OutputTimeSelector->GetOutput());
outputimagetoitk->Update();
typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
// create the iterators
typename ItkInputImageType::RegionType inputRegionOfInterest = inputItkImage->GetLargestPossibleRegion();
ItkInputImageIteratorType inputIt( inputItkImage, inputRegionOfInterest );
ItkOutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
typename ItkOutputImageType::PixelType outsideValue;
if(geometryClipper->m_AutoOutsideValue)
outsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
else
outsideValue = (typename ItkOutputImageType::PixelType) geometryClipper->m_OutsideValue;
mitk::Geometry3D* inputGeometry = geometryClipper->m_InputTimeSelector->GetOutput()->GetGeometry();
typedef itk::Index<VImageDimension> IndexType;
Point3D indexPt; indexPt.Fill(0);
int i, dim=IndexType::GetIndexDimension();
Point3D pointInMM;
bool above = geometryClipper->m_ClipPartAboveGeometry;
bool labelBothSides = geometryClipper->GetLabelBothSides();
if (geometryClipper->GetAutoOrientLabels())
{
Point3D leftMostPoint;
leftMostPoint.Fill( std::numeric_limits<float>::min() / 2.0 );
if(clippingGeometry2D->IsAbove(pointInMM) != above)
{
// invert meaning of above --> left is always the "above" side
above = !above;
MITK_INFO << leftMostPoint << " is BELOW geometry. Inverting meaning of above" << std::endl;
}
else
MITK_INFO << leftMostPoint << " is above geometry" << std::endl;
}
typename ItkOutputImageType::PixelType aboveLabel = (typename ItkOutputImageType::PixelType)geometryClipper->GetAboveGeometryLabel();
typename ItkOutputImageType::PixelType belowLabel = (typename ItkOutputImageType::PixelType)geometryClipper->GetBelowGeometryLabel();
for ( inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt)
{
if((typename ItkOutputImageType::PixelType)inputIt.Get() == outsideValue)
{
outputIt.Set(outsideValue);
}
else
{
for(i=0;i<dim;++i)
indexPt[i]=(mitk::ScalarType)inputIt.GetIndex()[i];
inputGeometry->IndexToWorld(indexPt, pointInMM);
if(clippingGeometry2D->IsAbove(pointInMM) == above)
{
if ( labelBothSides )
outputIt.Set( aboveLabel );
else
outputIt.Set( outsideValue );
}
else
{
if ( labelBothSides)
outputIt.Set( belowLabel );
else
outputIt.Set( inputIt.Get() );
}
}
}
}
#include "mitkImageAccessByItk.h"
void mitk::GeometryClipImageFilter::GenerateData()
{
Image::ConstPointer input = this->GetInput();
Image::Pointer output = this->GetOutput();
if((output->IsInitialized()==false) || (m_ClippingGeometry.IsNull()))
return;
const Geometry2D * clippingGeometryOfCurrentTimeStep = NULL;
if(m_TimeSlicedClippingGeometry.IsNull())
{
clippingGeometryOfCurrentTimeStep = dynamic_cast<const Geometry2D*>(m_ClippingGeometry.GetPointer());
}
else
{
clippingGeometryOfCurrentTimeStep = dynamic_cast<const Geometry2D*>(m_TimeSlicedClippingGeometry->GetGeometry3D(0));
}
if(clippingGeometryOfCurrentTimeStep == NULL)
return;
m_InputTimeSelector->SetInput(input);
m_OutputTimeSelector->SetInput(this->GetOutput());
mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
ScalarType timeInMS;
int timestep=0;
int tstart=outputRegion.GetIndex(3);
int tmax=tstart+outputRegion.GetSize(3);
int t;
for(t=tstart;t<tmax;++t)
{
timeInMS = outputTimeGeometry->TimeStepToMS( t );
timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
m_InputTimeSelector->SetTimeNr(timestep);
m_InputTimeSelector->UpdateLargestPossibleRegion();
m_OutputTimeSelector->SetTimeNr(t);
m_OutputTimeSelector->UpdateLargestPossibleRegion();
if(m_TimeSlicedClippingGeometry.IsNotNull())
{
timestep = m_TimeSlicedClippingGeometry->MSToTimeStep( timeInMS );
if(m_TimeSlicedClippingGeometry->IsValidTime(timestep) == false)
continue;
clippingGeometryOfCurrentTimeStep = dynamic_cast<const Geometry2D*>(m_TimeSlicedClippingGeometry->GetGeometry3D(timestep));
}
AccessByItk_2(m_InputTimeSelector->GetOutput(),_InternalComputeClippedImage,this,clippingGeometryOfCurrentTimeStep);
}
m_TimeOfHeaderInitialization.Modified();
}
diff --git a/Modules/MitkExt/Algorithms/mitkGeometryDataSource.cpp b/Modules/MitkExt/Algorithms/mitkGeometryDataSource.cpp
index f7a406a2c8..f4fc140e50 100644
--- a/Modules/MitkExt/Algorithms/mitkGeometryDataSource.cpp
+++ b/Modules/MitkExt/Algorithms/mitkGeometryDataSource.cpp
@@ -1,90 +1,48 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkGeometryDataSource.h"
#include "mitkGeometryData.h"
mitk::GeometryDataSource::GeometryDataSource()
{
- // Create the output. We use static_cast<> here because we know the default
- // output must be of type TOutputImage
- mitk::GeometryData::Pointer output
- = static_cast<mitk::GeometryData*>(this->MakeOutput(0).GetPointer());
- output->Initialize();
-
+ // Create the output.
+ itk::DataObject::Pointer output = this->MakeOutput(0);
Superclass::SetNumberOfRequiredOutputs(1);
- Superclass::SetNthOutput(0, output.GetPointer());
+ Superclass::SetNthOutput(0, output);
}
mitk::GeometryDataSource::~GeometryDataSource()
{
}
-mitk::GeometryDataSource::DataObjectPointer mitk::GeometryDataSource::MakeOutput(unsigned int /*idx*/)
+itk::DataObject::Pointer mitk::GeometryDataSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
- return static_cast<itk::DataObject*>(mitk::GeometryData::New().GetPointer());
+ return OutputType::New().GetPointer();
}
-mitk::GeometryData* mitk::GeometryDataSource::GetOutput()
+itk::DataObject::Pointer mitk::GeometryDataSource::MakeOutput( const DataObjectIdentifierType & name )
{
- if (this->GetNumberOfOutputs() < 1)
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
{
- return 0;
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
}
-
- return static_cast<mitk::GeometryData*>
- (this->BaseProcess::GetOutput(0));
-}
-
-mitk::GeometryData* mitk::GeometryDataSource::GetOutput(unsigned int idx)
-{
- return static_cast<mitk::GeometryData*>
- (this->itk::ProcessObject::GetOutput(idx));
-}
-
-void mitk::GeometryDataSource::SetOutput(mitk::GeometryData* output)
-{
- itkWarningMacro(<< "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead." );
- BaseProcess::SetNthOutput(0, output);
-}
-
-void mitk::GeometryDataSource::GraftOutput(mitk::GeometryData* graft)
-{
- this->GraftNthOutput(0, graft);
+ return OutputType::New().GetPointer();
}
-void mitk::GeometryDataSource::GraftNthOutput(unsigned int idx, mitk::GeometryData *graft)
-{
- if (idx < this->GetNumberOfOutputs())
- {
- mitk::GeometryData * output = this->GetOutput(idx);
-
- if (output && graft)
- {
- // grab a handle to the bulk data of the specified data object
- // output->SetPixelContainer( graft->GetPixelContainer() ); @FIXME!!!!
-
- // copy the region ivars of the specified data object
- output->SetRequestedRegion( graft );//graft->GetRequestedRegion() );
- // output->SetLargestPossibleRegion( graft->GetLargestPossibleRegion() ); @FIXME!!!!
- // output->SetBufferedRegion( graft->GetBufferedRegion() ); @FIXME!!!!
-
- // copy the meta-information
- output->CopyInformation( graft );
- }
- }
-}
+mitkBaseDataSourceGetOutputDefinitions(mitk::GeometryDataSource)
diff --git a/Modules/MitkExt/Algorithms/mitkGeometryDataSource.h b/Modules/MitkExt/Algorithms/mitkGeometryDataSource.h
index f467158d45..c58912a42e 100644
--- a/Modules/MitkExt/Algorithms/mitkGeometryDataSource.h
+++ b/Modules/MitkExt/Algorithms/mitkGeometryDataSource.h
@@ -1,70 +1,76 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKGEOMETRYDATASOURCE_H_HEADER_INCLUDED_C10B4740
#define MITKGEOMETRYDATASOURCE_H_HEADER_INCLUDED_C10B4740
-#include "mitkBaseProcess.h"
+#include "mitkBaseDataSource.h"
#include "MitkExtExports.h"
-#include "mitkGeometryDataSource.h"
namespace mitk {
class GeometryData;
-//##Documentation
-//## @brief Superclass of all classes generating GeometryData (instances of class
-//## GeometryData) as output.
-//##
-//## In itk and vtk the generated result of a ProcessObject is only guaranteed
-//## to be up-to-date, when Update() of the ProcessObject or the generated
-//## DataObject is called immediately before access of the data stored in the
-//## DataObject. This is also true for subclasses of mitk::BaseProcess and thus
-//## for mitk::GeometryDataSource.
-//## @ingroup Process
-class MitkExt_EXPORT GeometryDataSource : public BaseProcess
+/**
+ * @brief Superclass of all classes generating GeometryData (instances of class
+ * GeometryData) as output.
+ *
+ * In itk and vtk the generated result of a ProcessObject is only guaranteed
+ * to be up-to-date, when Update() of the ProcessObject or the generated
+ * DataObject is called immediately before access of the data stored in the
+ * DataObject. This is also true for subclasses of mitk::BaseProcess and thus
+ * for mitk::GeometryDataSource.
+ * @ingroup Process
+ */
+class MitkExt_EXPORT GeometryDataSource : public BaseDataSource
{
public:
- mitkClassMacro(GeometryDataSource, BaseProcess);
- itkNewMacro(Self);
+ mitkClassMacro(GeometryDataSource, BaseDataSource)
+ itkNewMacro(Self)
- typedef itk::DataObject::Pointer DataObjectPointer;
+ typedef mitk::GeometryData OutputType;
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ mitkBaseDataSourceGetOutputDeclarations
- void SetOutput(mitk::GeometryData* output);
+ /**
+ * Allocates a new output object and returns it. Currently the
+ * index idx is not evaluated.
+ * @param idx the index of the output for which an object should be created
+ * @returns the new object
+ */
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
- mitk::GeometryData* GetOutput();
-
- mitk::GeometryData* GetOutput(unsigned int idx);
-
- virtual void GraftOutput(mitk::GeometryData* graft);
-
- virtual void GraftNthOutput(unsigned int idx, mitk::GeometryData *graft);
+ /**
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
+ */
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
protected:
- GeometryDataSource();
+ GeometryDataSource();
virtual ~GeometryDataSource();
};
} // namespace mitk
#endif /* MITKGEOMETRYDATASOURCE_H_HEADER_INCLUDED_C10B4740 */
diff --git a/Modules/MitkExt/Algorithms/mitkHeightFieldSurfaceClipImageFilter.cpp b/Modules/MitkExt/Algorithms/mitkHeightFieldSurfaceClipImageFilter.cpp
index d4b7599a9b..55502a4ff6 100644
--- a/Modules/MitkExt/Algorithms/mitkHeightFieldSurfaceClipImageFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkHeightFieldSurfaceClipImageFilter.cpp
@@ -1,471 +1,471 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkHeightFieldSurfaceClipImageFilter.h"
#include "mitkImageTimeSelector.h"
#include "mitkTimeHelper.h"
#include "mitkProperties.h"
#include "mitkImageToItk.h"
#include "mitkImageAccessByItk.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkImageSliceConstIteratorWithIndex.h>
#include <vtkPolyData.h>
#include <vtkCellLocator.h>
#include <limits>
namespace mitk
{
HeightFieldSurfaceClipImageFilter::HeightFieldSurfaceClipImageFilter()
: m_ClippingMode( CLIPPING_MODE_CONSTANT ),
m_ClippingConstant( 0.0 ),
m_MultiplicationFactor( 2.0 ),
m_HeightFieldResolutionX( 256 ),
m_HeightFieldResolutionY( 256 ),
m_MaxHeight( 1024.0 ),
m_MultiPlaneValue(2)
{
- this->SetNumberOfInputs(8);
+ this->SetNumberOfIndexedInputs(8);
this->SetNumberOfRequiredInputs(2);
m_InputTimeSelector = ImageTimeSelector::New();
m_OutputTimeSelector = ImageTimeSelector::New();
}
HeightFieldSurfaceClipImageFilter::~HeightFieldSurfaceClipImageFilter()
{
}
void HeightFieldSurfaceClipImageFilter::SetClippingSurface(
Surface *clippingSurface )
{
this->SetNthInput( 1, clippingSurface );
}
void HeightFieldSurfaceClipImageFilter::SetClippingSurfaces(ClippingPlaneList planeList)
{
if(planeList.size() > 7)
{
MITK_WARN<<"Only 7 clipping planes are allowed!";
}
for (unsigned int i = 0; i < planeList.size(); ++i)
{
this->SetNthInput(i+1, planeList.at(i));
}
}
const Surface* HeightFieldSurfaceClipImageFilter::GetClippingSurface() const
{
return dynamic_cast< const Surface * >( itk::ProcessObject::GetInput( 1 ) );
}
void HeightFieldSurfaceClipImageFilter::SetClippingMode( int mode )
{
m_ClippingMode = mode;
}
int HeightFieldSurfaceClipImageFilter::GetClippingMode()
{
return m_ClippingMode;
}
void HeightFieldSurfaceClipImageFilter::SetClippingModeToConstant()
{
m_ClippingMode = CLIPPING_MODE_CONSTANT;
}
void HeightFieldSurfaceClipImageFilter::SetClippingModeToMultiplyByFactor()
{
m_ClippingMode = CLIPPING_MODE_MULTIPLYBYFACTOR;
}
void HeightFieldSurfaceClipImageFilter::SetClippingModeToMultiPlaneValue()
{
m_ClippingMode = CLIPPING_MODE_MULTIPLANE;
}
void HeightFieldSurfaceClipImageFilter::GenerateInputRequestedRegion()
{
Image *outputImage = this->GetOutput();
Image *inputImage = const_cast< Image * >( this->GetInput( 0 ) );
const Surface *inputSurface = dynamic_cast< const Surface * >( this->GetInput( 1 ) );
if ( !outputImage->IsInitialized() || inputSurface == NULL )
{
return;
}
inputImage->SetRequestedRegionToLargestPossibleRegion();
GenerateTimeInInputRegion( outputImage, inputImage );
}
void HeightFieldSurfaceClipImageFilter::GenerateOutputInformation()
{
const Image *inputImage = this->GetInput( 0 );
Image *outputImage = this->GetOutput();
if ( outputImage->IsInitialized()
&& (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()) )
{
return;
}
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int i;
unsigned int *tmpDimensions = new unsigned int[inputImage->GetDimension()];
for ( i = 0; i < inputImage->GetDimension(); ++i )
{
tmpDimensions[i] = inputImage->GetDimension( i );
}
outputImage->Initialize( inputImage->GetPixelType(),
inputImage->GetDimension(),
tmpDimensions,
inputImage->GetNumberOfChannels() );
delete[] tmpDimensions;
outputImage->SetGeometry(
static_cast< Geometry3D * >( inputImage->GetGeometry()->Clone().GetPointer() ) );
outputImage->SetPropertyList( inputImage->GetPropertyList()->Clone() );
m_TimeOfHeaderInitialization.Modified();
}
template < typename TPixel, unsigned int VImageDimension >
void HeightFieldSurfaceClipImageFilter::_InternalComputeClippedImage(
itk::Image< TPixel, VImageDimension > *inputItkImage,
HeightFieldSurfaceClipImageFilter *clipImageFilter,
vtkPolyData *clippingPolyData,
AffineTransform3D *imageToPlaneTransform )
{
typedef itk::Image< TPixel, VImageDimension > ItkInputImageType;
typedef itk::Image< TPixel, VImageDimension > ItkOutputImageType;
typedef itk::ImageSliceConstIteratorWithIndex< ItkInputImageType > ItkInputImageIteratorType;
typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;
typename ImageToItk<ItkOutputImageType >::Pointer outputimagetoitk =
ImageToItk<ItkOutputImageType>::New();
outputimagetoitk->SetInput( clipImageFilter->m_OutputTimeSelector->GetOutput() );
outputimagetoitk->Update();
typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
std::vector< double > test;
// create the iterators
typename ItkInputImageType::RegionType inputRegionOfInterest =
inputItkImage->GetLargestPossibleRegion();
ItkInputImageIteratorType inputIt( inputItkImage, inputRegionOfInterest );
ItkOutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
// Get bounds of clipping data
clippingPolyData->ComputeBounds();
vtkFloatingPointType *bounds = clippingPolyData->GetBounds();
double xWidth = bounds[1] - bounds[0];
double yWidth = bounds[3] - bounds[2];
// Create vtkCellLocator for clipping poly data
vtkCellLocator *cellLocator = vtkCellLocator::New();
cellLocator->SetDataSet( clippingPolyData );
cellLocator->CacheCellBoundsOn();
cellLocator->AutomaticOn();
cellLocator->BuildLocator();
// Allocate memory for 2D image to hold the height field generated by
// projecting the clipping data onto the plane
double *heightField = new double[m_HeightFieldResolutionX * m_HeightFieldResolutionY];
// Walk through height field and for each entry calculate height of the
// clipping poly data at this point by means of vtkCellLocator. The
// clipping data x/y bounds are used for converting from poly data space to
// image (height-field) space.
MITK_INFO << "Calculating Height Field..." << std::endl;
for ( unsigned int y = 0; y < m_HeightFieldResolutionY; ++y )
{
for ( unsigned int x = 0; x < m_HeightFieldResolutionX; ++x )
{
vtkFloatingPointType p0[3], p1[3], surfacePoint[3], pcoords[3];
p0[0] = bounds[0] + xWidth * x / (double) m_HeightFieldResolutionX;
p0[1] = bounds[2] + yWidth * y / (double) m_HeightFieldResolutionY;
p0[2] = -m_MaxHeight;
p1[0] = p0[0];
p1[1] = p0[1];
p1[2] = m_MaxHeight;
double t, distance;
int subId;
if ( cellLocator->IntersectWithLine( p0, p1, 0.1, t, surfacePoint, pcoords, subId ) )
{
distance = (2.0 * t - 1.0) * m_MaxHeight;
}
else
{
distance = -65536.0;
}
heightField[y * m_HeightFieldResolutionX + x] = distance;
itk::Image<double,2>::IndexType index;
index[0] = x;
index[1] = y;
}
}
// Walk through entire input image and for each point determine its distance
// from the x/y plane.
MITK_INFO << "Performing clipping..." << std::endl;
TPixel factor = static_cast< TPixel >( clipImageFilter->m_MultiplicationFactor );
TPixel clippingConstant = clipImageFilter->m_ClippingConstant;
inputIt.SetFirstDirection( 0 );
inputIt.SetSecondDirection( 1 );
//through all slices
for ( inputIt.GoToBegin(), outputIt.GoToBegin();
!inputIt.IsAtEnd();
inputIt.NextSlice() )
{
//through all lines of a slice
for ( ; !inputIt.IsAtEndOfSlice(); inputIt.NextLine() )
{
//Transform the start(line) point from the image to the plane
Point3D imageP0, planeP0;
imageP0[0] = inputIt.GetIndex()[0];
imageP0[1] = inputIt.GetIndex()[1];
imageP0[2] = inputIt.GetIndex()[2];
planeP0 = imageToPlaneTransform->TransformPoint( imageP0 );
//Transform the end point (line) from the image to the plane
Point3D imageP1, planeP1;
imageP1[0] = imageP0[0] + inputRegionOfInterest.GetSize( 0 );
imageP1[1] = imageP0[1];
imageP1[2] = imageP0[2];
planeP1 = imageToPlaneTransform->TransformPoint( imageP1 );
//calculate the step size (if the plane is rotate, you go "crossway" through the image)
Vector3D step = (planeP1 - planeP0) / (double) inputRegionOfInterest.GetSize( 0 );
//over all pixel
for ( ; !inputIt.IsAtEndOfLine(); ++inputIt, ++outputIt, planeP0 += step )
{
//Only ConstantMode: if image pixel value == constant mode value-->set output pixel value directly
if ( (clipImageFilter->m_ClippingMode == CLIPPING_MODE_CONSTANT)
&& ((TPixel)inputIt.Get() == clippingConstant ) )
{
outputIt.Set( clippingConstant );
}
else
{
int x0 = (int) ((double)(m_HeightFieldResolutionX) * (planeP0[0] - bounds[0]) / xWidth);
int y0 = (int) ((double)(m_HeightFieldResolutionY) * (planeP0[1] - bounds[2]) / yWidth);
bool clip;
//if the current point is outside of the plane region (RegionOfInterest)-->clip the pixel allways
if ( (x0 < 0) || (x0 >= (int)m_HeightFieldResolutionX)
|| (y0 < 0) || (y0 >= (int)m_HeightFieldResolutionY) )
{
clip = true;
}
else
{
// Calculate bilinearly interpolated height field value at plane point
int x1 = x0 + 1;
int y1 = y0 + 1;
if ( x1 >= (int)m_HeightFieldResolutionX ) { x1 = x0; }
if ( y1 >= (int)m_HeightFieldResolutionY ) { y1 = y0; }
//Get the neighbour points for the interpolation
ScalarType q00, q01, q10, q11;
q00 = heightField[y0 * m_HeightFieldResolutionX + x0];
q01 = heightField[y0 * m_HeightFieldResolutionX + x1];
q10 = heightField[y1 * m_HeightFieldResolutionX + x0];
q11 = heightField[y1 * m_HeightFieldResolutionX + x1];
/*
!!!!!The bilinear interpolation doesn't work at the moment: If the plane is deformed there are some strange artefacts!!!
The problem is the scaling of the planeP0 and the x/y values
ScalarType q =
q00 * ((double) x1 - planeP0[0]) * ((double) y1 - planeP0[1])
+ q01 * (planeP0[0] - (double) x0) * ((double) y1 - planeP0[1])
+ q10 * ((double) x1 - planeP0[0]) * (planeP0[1] - (double) y0)
+ q11 * (planeP0[0] - (double) x0) * (planeP0[1] - (double) y0);
*/
//ATM: set the value direct, without interpolation: stepped view (only by the deformed plane)
ScalarType q = heightField[y0 * m_HeightFieldResolutionX + x0];
//decide, whether the point is on the one side of the plane or on the other
if ( q - planeP0[2] < 0 )
{
clip = true;
}
else
{
clip = false;
}
}
//different modes: differnt values for the clipped pixel
if ( clip )
{
if ( clipImageFilter->m_ClippingMode == CLIPPING_MODE_CONSTANT )
{
outputIt.Set( clipImageFilter->m_ClippingConstant );
}
else if ( clipImageFilter->m_ClippingMode == CLIPPING_MODE_MULTIPLYBYFACTOR )
{
outputIt.Set( inputIt.Get() * factor );
}
else if ( clipImageFilter->m_ClippingMode == CLIPPING_MODE_MULTIPLANE )
{
if(inputIt.Get() != 0)
outputIt.Set( inputIt.Get() + m_MultiPlaneValue);
else
outputIt.Set( inputIt.Get() );
}
}
// the non-clipped pixel keeps his value
else
{
outputIt.Set( inputIt.Get() );
}
}
}
}
}
MITK_INFO << "DONE!" << std::endl;
// Clean-up
cellLocator->Delete();
}
void HeightFieldSurfaceClipImageFilter::GenerateData()
{
const Image *inputImage = this->GetInput( 0 );
const Image *outputImage = this->GetOutput();
m_InputTimeSelector->SetInput( inputImage );
m_OutputTimeSelector->SetInput( outputImage );
Image::RegionType outputRegion = outputImage->GetRequestedRegion();
const TimeSlicedGeometry *outputTimeGeometry = outputImage->GetTimeSlicedGeometry();
const TimeSlicedGeometry *inputTimeGeometry = inputImage->GetTimeSlicedGeometry();
ScalarType timeInMS;
int timestep = 0;
int tstart = outputRegion.GetIndex( 3 );
int tmax = tstart + outputRegion.GetSize( 3 );
for (unsigned int i = 1; i < this->GetNumberOfInputs(); ++i)
{
Surface *inputSurface = const_cast< Surface * >(
dynamic_cast< Surface * >( itk::ProcessObject::GetInput( i ) ) );
if ( !outputImage->IsInitialized() || inputSurface == NULL )
return;
MITK_INFO<<"Plane: "<<i;
MITK_INFO << "Clipping: Start\n";
//const Geometry2D *clippingGeometryOfCurrentTimeStep = NULL;
int t;
for( t = tstart; t < tmax; ++t )
{
timeInMS = outputTimeGeometry->TimeStepToMS( t );
timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
m_InputTimeSelector->SetTimeNr( timestep );
m_InputTimeSelector->UpdateLargestPossibleRegion();
m_OutputTimeSelector->SetTimeNr( t );
m_OutputTimeSelector->UpdateLargestPossibleRegion();
// Compose IndexToWorld transform of image with WorldToIndexTransform of
// clipping data for conversion from image index space to plane index space
AffineTransform3D::Pointer planeWorldToIndexTransform = AffineTransform3D::New();
inputSurface->GetGeometry( t )->GetIndexToWorldTransform()
->GetInverse( planeWorldToIndexTransform );
AffineTransform3D::Pointer imageToPlaneTransform =
AffineTransform3D::New();
imageToPlaneTransform->SetIdentity();
imageToPlaneTransform->Compose(
inputTimeGeometry->GetGeometry3D( t )->GetIndexToWorldTransform() );
imageToPlaneTransform->Compose( planeWorldToIndexTransform );
MITK_INFO << "Accessing ITK function...\n";
if(i==1)
{
AccessByItk_3(
m_InputTimeSelector->GetOutput(),
_InternalComputeClippedImage,
this,
inputSurface->GetVtkPolyData( t ),
imageToPlaneTransform );
}
else
{
mitk::Image::Pointer extensionImage = m_OutputTimeSelector->GetOutput()->Clone();
AccessByItk_3(
extensionImage,
_InternalComputeClippedImage,
this,
inputSurface->GetVtkPolyData( t ),
imageToPlaneTransform );
}
if (m_ClippingMode == CLIPPING_MODE_MULTIPLANE)
m_MultiPlaneValue = m_MultiPlaneValue*2;
}
}
m_TimeOfHeaderInitialization.Modified();
}
} // namespace
diff --git a/Modules/MitkExt/Algorithms/mitkImageToLookupTableFilter.cpp b/Modules/MitkExt/Algorithms/mitkImageToLookupTableFilter.cpp
index 3acd893fcb..db7a3b7f05 100644
--- a/Modules/MitkExt/Algorithms/mitkImageToLookupTableFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkImageToLookupTableFilter.cpp
@@ -1,143 +1,143 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImageToLookupTableFilter.h"
#include "mitkImageToItk.h"
#include "itkImage.h"
#include "itkVector.h"
#include "itkImageRegionIterator.h"
#include "itkNumericTraits.h"
#include <algorithm>
mitk::ImageToLookupTableFilter::ImageToLookupTableFilter()
{
this->SetNumberOfRequiredInputs(1);
}
mitk::ImageToLookupTableFilter::~ImageToLookupTableFilter()
{
}
void mitk::ImageToLookupTableFilter::SetInput( const mitk::ImageToLookupTableFilter::InputImageType *input)
{
// Process object is not const-correct so the const_cast is required here
this->itk::ProcessObject::SetNthInput( 0, const_cast< InputImageType * >( input ) );
}
void mitk::ImageToLookupTableFilter::SetInput( unsigned int index, const mitk::ImageToLookupTableFilter::InputImageType * input)
{
if ( index + 1 > this->GetNumberOfInputs() )
{
this->SetNumberOfRequiredInputs( index + 1 );
}
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput( index, const_cast< InputImageType *>( input ) );
}
const mitk::ImageToLookupTableFilter::InputImageType * mitk::ImageToLookupTableFilter::GetInput(void)
{
if ( this->GetNumberOfInputs() < 1 )
{
return 0;
}
return static_cast<const InputImageType * >( this->ProcessObject::GetInput( 0 ) );
}
const mitk::ImageToLookupTableFilter::InputImageType * mitk::ImageToLookupTableFilter::GetInput(unsigned int idx)
{
return static_cast< const InputImageType * >( this->ProcessObject::GetInput( idx ) );
}
void mitk::ImageToLookupTableFilter::GenerateData()
{
- this->SetNumberOfOutputs( this->GetNumberOfInputs() );
+ this->SetNumberOfIndexedOutputs( this->GetNumberOfInputs() );
for (unsigned int inputIdx = 0; inputIdx < this->GetNumberOfInputs() ; ++inputIdx)
{
InputImagePointer image = const_cast<mitk::Image*>(this->GetInput( inputIdx ));
OutputTypePointer output = dynamic_cast<OutputType*>(this->MakeOutput( inputIdx ).GetPointer());
this->ProcessObject::SetNthOutput( inputIdx, output.GetPointer() );
if (image.IsNull())
{
itkWarningMacro(<< inputIdx<<"'th input image is null!");
return;
}
// the default vtkLookupTable has range=[0,1]; and hsv ranges set
// up for rainbow color table (from red to blue).
vtkLookupTable* vtkLut = vtkLookupTable::New();
/*
if ( ( image->GetPixelType().GetNumberOfComponents() == 3 ) && ( image->GetDimension() == 3 ) )
{
// some typedefs for conversion to an iterable itk image
const unsigned int VectorDimension = 3;
typedef float VectorComponentType;
typedef itk::Vector< VectorComponentType, VectorDimension > VectorType;
typedef itk::Image< VectorType, VectorDimension > VectorFieldType;
typedef itk::ImageRegionIterator< VectorFieldType > VectorFieldIteratorType;
typedef mitk::ImageToItk<VectorFieldType> ImageConverterType;
// some local variables
float minValue = itk::NumericTraits<float>::max();
float maxValue = itk::NumericTraits<float>::NonpositiveMin();
float norm = 0.0f;
//determine the range of the vector magnitudes in the image
ImageConverterType::Pointer imageConverter = ImageConverterType::New();
imageConverter->SetInput(image);
VectorFieldType::Pointer itkImage = imageConverter->GetOutput();
VectorFieldIteratorType it( itkImage, itkImage->GetRequestedRegion() );
it.GoToBegin();
while ( !it.IsAtEnd() )
{
norm = it.Get().GetNorm();
minValue = std::min(norm, minValue);
maxValue = std::max(norm, maxValue);
}
MITK_INFO << "Range of vector magnitudes: [" << minValue << ", "<< maxValue << "]." << std::endl;
vtkLut->SetRange(minValue, maxValue);
}
else
{
itkWarningMacro(<< "Sorry, only 3d vector images are currently supported!");
}*/
vtkLut->SetRange(0, 10);
output->SetVtkLookupTable( vtkLut );
vtkLut->Delete();
}
}
diff --git a/Modules/MitkExt/Algorithms/mitkInterpolateLinesFilter.cpp b/Modules/MitkExt/Algorithms/mitkInterpolateLinesFilter.cpp
index 2473d9ec47..e498b84d8e 100644
--- a/Modules/MitkExt/Algorithms/mitkInterpolateLinesFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkInterpolateLinesFilter.cpp
@@ -1,211 +1,211 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkInterpolateLinesFilter.h"
#include "mitkMesh.h"
#include "mitkSurface.h"
#include <vtkPolyData.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkCardinalSpline.h>
#include <vector>
mitk::InterpolateLinesFilter::InterpolateLinesFilter()
: m_SplineResolution(10), m_GeometryForInterpolation(NULL), m_Length(0.0)
{
m_SpX=vtkCardinalSpline::New();
m_SpY=vtkCardinalSpline::New();
m_SpZ=vtkCardinalSpline::New();
}
mitk::InterpolateLinesFilter::~InterpolateLinesFilter()
{
m_SpX->Delete();
m_SpY->Delete();
m_SpZ->Delete();
}
void mitk::InterpolateLinesFilter::GenerateOutputInformation()
{
mitk::Mesh::ConstPointer input = this->GetInput();
- mitk::Surface::Pointer output = this->GetOutput();
+ mitk::Surface::Pointer output = this->GetOutput(0);
itkDebugMacro(<<"GenerateOutputInformation()");
if(input.IsNull()) return;
if(m_GeometryForInterpolation.IsNotNull())
output->SetGeometry(static_cast<Geometry3D*>(m_GeometryForInterpolation->Clone().GetPointer()));
else
output->SetGeometry(static_cast<Geometry3D*>(input->GetGeometry()->Clone().GetPointer()));
}
void mitk::InterpolateLinesFilter::GenerateData()
{
mitk::Mesh::ConstPointer input = this->GetInput();
- mitk::Surface::Pointer output = this->GetOutput();
+ mitk::Surface::Pointer output = this->GetOutput(0);
vtkPolyData *polyData = vtkPolyData::New();
vtkPoints *points = vtkPoints::New();
vtkCellArray *cellarray = vtkCellArray::New();
mitk::Mesh::PointType thisPoint;
m_Length = 0.0;
//iterate through all cells and build tubes
Mesh::ConstCellIterator cellIt, cellEnd;
cellEnd = input->GetMesh()->GetCells()->End();
for( cellIt = input->GetMesh()->GetCells()->Begin(); cellIt != cellEnd; ++cellIt )
{
if(((*cellIt->Value()).GetType()==mitk::Mesh::CellType::POLYGON_CELL)
&& ((*cellIt->Value()).GetNumberOfPoints()>=2))
BuildPointAndVectorList(*cellIt->Value(), points, cellarray);
}
polyData->SetPoints( points );
points->Delete();
polyData->SetLines( cellarray );
cellarray->Delete();
output->SetVtkPolyData(polyData);
polyData->Delete();
}
void mitk::InterpolateLinesFilter::BuildPointAndVectorList(mitk::Mesh::CellType& cell, vtkPoints* points, vtkCellArray* cellarray)
{
const mitk::Mesh* input = GetInput();
Mesh::PointIdIterator ptIt;
Mesh::PointIdIterator ptEnd;
ptEnd = cell.PointIdsEnd();
Point3D pt;
int i, size=cell.GetNumberOfPoints();
int closed_loop_pre_load=0;//m_SplineResolution;
if(m_GeometryForInterpolation.IsNull())
{
//bei geschlossener Kontur: vor dem ersten Punkt die zwei letzten einfügen für glatten Übergang
ptIt = ptEnd; ptIt-=closed_loop_pre_load+1;
for(i=0;i<closed_loop_pre_load;++i, ++ptIt)
{
pt = input->GetPoint(*ptIt);
m_SpX->AddPoint(i, pt[0]); m_SpY->AddPoint(i, pt[1]); m_SpZ->AddPoint(i, pt[2]);
}
//Punkte einfügen
for(ptIt = cell.PointIdsBegin();i<size+closed_loop_pre_load;++i, ++ptIt)
{
pt = input->GetPoint(*ptIt);
m_SpX->AddPoint(i, pt[0]); m_SpY->AddPoint(i, pt[1]); m_SpZ->AddPoint(i, pt[2]);
}
//bei geschlossener Kontur: nach dem letzten Punkt die zwei ersten einfügen für glatten Übergang
int j;
for(j=0,ptIt = cell.PointIdsBegin();j<closed_loop_pre_load;++j,++i, ++ptIt)
{
pt = input->GetPoint(*ptIt);
m_SpX->AddPoint(i, pt[0]); m_SpY->AddPoint(i, pt[1]); m_SpZ->AddPoint(i, pt[2]);
}
//bool first = true;
Point3D lastPt, firstPt;
Vector3D vec;
float t, step=1.0f/m_SplineResolution;
size=(size-1)*m_SplineResolution;
i=closed_loop_pre_load;
cellarray->InsertNextCell(size);
for(t=closed_loop_pre_load;i<size+closed_loop_pre_load;++i, t+=step)
{
float pt[3];
FillVector3D(pt, m_SpX->Evaluate(t), m_SpY->Evaluate(t), m_SpZ->Evaluate(t));
cellarray->InsertCellPoint(points->InsertNextPoint(pt));
}
}
else //m_GeometryForInterpolation!=NULL
{
Point2D pt2d;
//bei geschlossener Kontur: vor dem ersten Punkt die zwei letzten einfügen für glatten Übergang
ptIt = ptEnd; ptIt-=closed_loop_pre_load+1;
for(i=0;i<closed_loop_pre_load;++i, ++ptIt)
{
m_GeometryForInterpolation->Map(input->GetPoint(*ptIt), pt2d);
m_SpX->AddPoint(i, pt2d[0]); m_SpY->AddPoint(i, pt2d[1]);
}
//Punkte einfügen
for(ptIt = cell.PointIdsBegin();i<size+closed_loop_pre_load;++i, ++ptIt)
{
m_GeometryForInterpolation->Map(input->GetPoint(*ptIt), pt2d);
m_SpX->AddPoint(i, pt2d[0]); m_SpY->AddPoint(i, pt2d[1]);
}
//bei geschlossener Kontur: nach dem letzten Punkt die zwei ersten einfügen für glatten Übergang
int j;
for(j=0,ptIt = cell.PointIdsBegin();j<closed_loop_pre_load;++j,++i, ++ptIt)
{
m_GeometryForInterpolation->Map(input->GetPoint(*ptIt), pt2d);
m_SpX->AddPoint(i, pt2d[0]); m_SpY->AddPoint(i, pt2d[1]);
}
bool first = true;
Point3D lastPt; lastPt.Fill(0);
Vector3D vec;
float t, step=1.0f/m_SplineResolution;
size=(size-1)*m_SplineResolution;
i=closed_loop_pre_load;
cellarray->InsertNextCell(size);
for(t=closed_loop_pre_load;i<size+closed_loop_pre_load;++i, t+=step)
{
pt2d[0] = m_SpX->Evaluate(t); pt2d[1] = m_SpY->Evaluate(t);
m_GeometryForInterpolation->Map(pt2d, pt);
if(first==false)
{
vec=pt-lastPt;
m_Length+=vec.GetNorm();
}
first=false;
float pvtk[3];
itk2vtk(pt, pvtk);
cellarray->InsertCellPoint(points->InsertNextPoint(pvtk));
lastPt = pt;
}
}
}
const mitk::Mesh *mitk::InterpolateLinesFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return static_cast<const mitk::Mesh * >
(this->ProcessObject::GetInput(0) );
}
void mitk::InterpolateLinesFilter::SetInput(const mitk::Mesh *input)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(0,
const_cast< mitk::Mesh * >( input ) );
}
diff --git a/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp b/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
index c2005dfad9..1775573d36 100644
--- a/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
@@ -1,364 +1,364 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkLabeledImageToSurfaceFilter.h>
#include <vtkImageChangeInformation.h>
#include <vtkImageThreshold.h>
#include <vtkImageGaussianSmooth.h>
#include <vtkImageMarchingCubes.h>
#include <vtkPolyData.h>
#include <vtkSmoothPolyDataFilter.h>
#include <vtkDecimatePro.h>
#include <vtkLinearTransform.h>
#include <vtkMatrix4x4.h>
#include <mitkImageAccessByItk.h>
#include <mitkInstantiateAccessFunctions.h>
#include <itkImageRegionIterator.h>
#include <itkNumericTraits.h>
mitk::LabeledImageToSurfaceFilter::LabeledImageToSurfaceFilter() :
m_GaussianStandardDeviation(1.5),
m_GenerateAllLabels(true),
m_Label(1),
m_BackgroundLabel(0)
{
}
mitk::LabeledImageToSurfaceFilter::~LabeledImageToSurfaceFilter()
{
}
void mitk::LabeledImageToSurfaceFilter::GenerateOutputInformation()
{
Superclass::GenerateOutputInformation();
//
// check which labels are available in the image
//
m_AvailableLabels = this->GetAvailableLabels();
m_IdxToLabels.clear();
//
// if we don't want to generate surfaces for all labels
// we have to remove all labels except m_Label and m_BackgroundLabel
// from the list of available labels
//
if ( ! m_GenerateAllLabels )
{
LabelMapType tmp;
LabelMapType::iterator it;
it = m_AvailableLabels.find( m_Label );
if ( it != m_AvailableLabels.end() )
tmp[m_Label] = it->second;
else
tmp[m_Label] = 0;
it = m_AvailableLabels.find( m_BackgroundLabel );
if ( it != m_AvailableLabels.end() )
tmp[m_BackgroundLabel] = it->second;
else
tmp[m_BackgroundLabel] = 0;
m_AvailableLabels = tmp;
}
//
// check for the number of labels: if the whole image is filled, no
// background is available and thus the numberOfOutpus is equal to the
// number of available labels in the image (which is a special case).
// If we have background voxels, the number of outputs is one less than
// then number of available labels.
//
unsigned int numberOfOutputs = 0;
if ( m_AvailableLabels.find( m_BackgroundLabel ) == m_AvailableLabels.end() )
numberOfOutputs = m_AvailableLabels.size();
else
numberOfOutputs = m_AvailableLabels.size() - 1;
if ( numberOfOutputs == 0 )
{
itkWarningMacro("Number of outputs == 0");
}
//
// determine the number of time steps of the input image
//
mitk::Image* image = ( mitk::Image* )GetInput();
unsigned int numberOfTimeSteps = image->GetTimeSlicedGeometry()->GetTimeSteps();
//
// set the number of outputs to the number of labels used.
// initialize the output surfaces accordingly (incl. time steps)
//
- this->SetNumberOfOutputs( numberOfOutputs );
+ this->SetNumberOfIndexedOutputs( numberOfOutputs );
this->SetNumberOfRequiredOutputs( numberOfOutputs );
for ( unsigned int i = 0 ; i < numberOfOutputs; ++i )
{
if ( ! this->GetOutput( i ) )
{
mitk::Surface::Pointer output = static_cast<mitk::Surface*>( this->MakeOutput(0).GetPointer() );
assert ( output.IsNotNull() );
output->Expand( numberOfTimeSteps );
this->SetNthOutput( i, output.GetPointer() );
}
}
}
void mitk::LabeledImageToSurfaceFilter::GenerateData()
{
mitk::Image* image = ( mitk::Image* )GetInput();
if ( image == NULL )
{
itkWarningMacro("Image is NULL");
return;
}
mitk::Image::RegionType outputRegion = image->GetRequestedRegion();
m_IdxToLabels.clear();
if ( this->GetNumberOfOutputs() == 0 )
return;
//
// traverse the known labels and create surfaces for them.
//
unsigned int currentOutputIndex = 0;
for ( LabelMapType::iterator it = m_AvailableLabels.begin() ; it != m_AvailableLabels.end() ; ++it )
{
if ( it->first == m_BackgroundLabel )
continue;
if ( ( it->second == 0 ) && m_GenerateAllLabels )
continue;
assert ( currentOutputIndex < this->GetNumberOfOutputs() );
mitk::Surface::Pointer surface = this->GetOutput( currentOutputIndex );
assert( surface.IsNotNull() );
int tstart=outputRegion.GetIndex(3);
int tmax=tstart+outputRegion.GetSize(3); //GetSize()==1 - will aber 0 haben, wenn nicht zeitaufgeloet
int t;
for( t=tstart; t < tmax; ++t)
{
vtkImageData *vtkimagedata = image->GetVtkImageData( t );
CreateSurface( t,vtkimagedata,surface.GetPointer(), it->first );
}
m_IdxToLabels[ currentOutputIndex ] = it->first;
currentOutputIndex++;
}
}
void mitk::LabeledImageToSurfaceFilter::CreateSurface( int time, vtkImageData *vtkimage, mitk::Surface * surface, mitk::LabeledImageToSurfaceFilter::LabelType label )
{
vtkImageChangeInformation *indexCoordinatesImageFilter = vtkImageChangeInformation::New();
indexCoordinatesImageFilter->SetInput(vtkimage);
indexCoordinatesImageFilter->SetOutputOrigin(0.0,0.0,0.0);
vtkImageThreshold* threshold = vtkImageThreshold::New();
threshold->SetInput( indexCoordinatesImageFilter->GetOutput() );
//indexCoordinatesImageFilter->Delete();
threshold->SetInValue( 100 );
threshold->SetOutValue( 0 );
threshold->ThresholdBetween( label, label );
threshold->SetOutputScalarTypeToUnsignedChar();
threshold->ReleaseDataFlagOn();
vtkImageGaussianSmooth *gaussian = vtkImageGaussianSmooth::New();
gaussian->SetInput( threshold->GetOutput() );
//threshold->Delete();
gaussian->SetDimensionality( 3 );
gaussian->SetRadiusFactor( 0.49 );
gaussian->SetStandardDeviation( GetGaussianStandardDeviation() );
gaussian->ReleaseDataFlagOn();
gaussian->UpdateInformation();
gaussian->Update();
//MarchingCube -->create Surface
vtkMarchingCubes *skinExtractor = vtkMarchingCubes::New();
skinExtractor->ReleaseDataFlagOn();
skinExtractor->SetInput(gaussian->GetOutput());//RC++
indexCoordinatesImageFilter->Delete();
skinExtractor->SetValue(0, 50);
vtkPolyData *polydata;
polydata = skinExtractor->GetOutput();
polydata->Register(NULL);//RC++
skinExtractor->Delete();
if (m_Smooth)
{
vtkSmoothPolyDataFilter *smoother = vtkSmoothPolyDataFilter::New();
//read poly1 (poly1 can be the original polygon, or the decimated polygon)
smoother->SetInput(polydata);//RC++
smoother->SetNumberOfIterations( m_SmoothIteration );
smoother->SetRelaxationFactor( m_SmoothRelaxation );
smoother->SetFeatureAngle( 60 );
smoother->FeatureEdgeSmoothingOff();
smoother->BoundarySmoothingOff();
smoother->SetConvergence( 0 );
polydata->Delete();//RC--
polydata = smoother->GetOutput();
polydata->Register(NULL);//RC++
smoother->Delete();
}
//decimate = to reduce number of polygons
if(m_Decimate==DecimatePro)
{
vtkDecimatePro *decimate = vtkDecimatePro::New();
decimate->SplittingOff();
decimate->SetErrorIsAbsolute(5);
decimate->SetFeatureAngle(30);
decimate->PreserveTopologyOn();
decimate->BoundaryVertexDeletionOff();
decimate->SetDegree(10); //std-value is 25!
decimate->SetInput(polydata);//RC++
decimate->SetTargetReduction(m_TargetReduction);
decimate->SetMaximumError(0.002);
polydata->Delete();//RC--
polydata = decimate->GetOutput();
polydata->Register(NULL);//RC++
decimate->Delete();
}
polydata->Update();
polydata->SetSource(NULL);
if(polydata->GetNumberOfPoints() > 0)
{
mitk::Vector3D spacing = GetInput()->GetGeometry(time)->GetSpacing();
vtkPoints * points = polydata->GetPoints();
vtkMatrix4x4 *vtkmatrix = vtkMatrix4x4::New();
GetInput()->GetGeometry(time)->GetVtkTransform()->GetMatrix(vtkmatrix);
double (*matrix)[4] = vtkmatrix->Element;
unsigned int i,j;
for(i=0;i<3;++i)
for(j=0;j<3;++j)
matrix[i][j]/=spacing[j];
unsigned int n = points->GetNumberOfPoints();
vtkFloatingPointType point[3];
for (i = 0; i < n; i++)
{
points->GetPoint(i, point);
mitkVtkLinearTransformPoint(matrix,point,point);
points->SetPoint(i, point);
}
vtkmatrix->Delete();
}
surface->SetVtkPolyData(polydata, time);
polydata->UnRegister(NULL);
gaussian->Delete();
threshold->Delete();
}
template < typename TPixel, unsigned int VImageDimension >
void GetAvailableLabelsInternal( itk::Image<TPixel, VImageDimension>* image, mitk::LabeledImageToSurfaceFilter::LabelMapType& availableLabels )
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::ImageRegionIterator< ImageType > ImageRegionIteratorType;
availableLabels.clear();
ImageRegionIteratorType it( image, image->GetLargestPossibleRegion() );
it.GoToBegin();
mitk::LabeledImageToSurfaceFilter::LabelMapType::iterator labelIt;
while( ! it.IsAtEnd() )
{
labelIt = availableLabels.find( ( mitk::LabeledImageToSurfaceFilter::LabelType ) ( it.Get() ) );
if ( labelIt == availableLabels.end() )
{
availableLabels[ ( mitk::LabeledImageToSurfaceFilter::LabelType ) ( it.Get() ) ] = 1;
}
else
{
labelIt->second += 1;
}
++it;
}
}
#define InstantiateAccessFunction_GetAvailableLabelsInternal(pixelType, dim) \
template void GetAvailableLabelsInternal(itk::Image<pixelType, dim>*, mitk::LabeledImageToSurfaceFilter::LabelMapType&);
InstantiateAccessFunctionForFixedDimension(GetAvailableLabelsInternal, 3);
mitk::LabeledImageToSurfaceFilter::LabelMapType mitk::LabeledImageToSurfaceFilter::GetAvailableLabels()
{
mitk::Image::Pointer image = ( mitk::Image* )GetInput();
LabelMapType availableLabels;
AccessFixedDimensionByItk_1( image, GetAvailableLabelsInternal, 3, availableLabels );
return availableLabels;
}
void mitk::LabeledImageToSurfaceFilter::CreateSurface(int, vtkImageData*, mitk::Surface*, const ScalarType)
{
itkWarningMacro( "This function should never be called!" );
assert(false);
}
mitk::LabeledImageToSurfaceFilter::LabelType mitk::LabeledImageToSurfaceFilter::GetLabelForNthOutput( const unsigned int& idx )
{
IdxToLabelMapType::iterator it = m_IdxToLabels.find( idx );
if ( it != m_IdxToLabels.end() )
{
return it->second;
}
else
{
itkWarningMacro( "Unknown index encountered: " << idx << ". There are " << this->GetNumberOfOutputs() << " outputs available." );
return itk::NumericTraits<LabelType>::max();
}
}
mitk::ScalarType mitk::LabeledImageToSurfaceFilter::GetVolumeForNthOutput( const unsigned int& i )
{
return GetVolumeForLabel( GetLabelForNthOutput( i ) );
}
mitk::ScalarType mitk::LabeledImageToSurfaceFilter::GetVolumeForLabel( const mitk::LabeledImageToSurfaceFilter::LabelType& label )
{
// get the image spacing
mitk::Image* image = ( mitk::Image* )GetInput();
const float* spacing = image->GetSlicedGeometry()->GetFloatSpacing();
// get the number of voxels encountered for the given label,
// calculate the volume and return it.
LabelMapType::iterator it = m_AvailableLabels.find( label );
if ( it != m_AvailableLabels.end() )
{
return static_cast<float>(it->second) * ( spacing[0] * spacing[1] * spacing[2] / 1000.0f );
}
else
{
itkWarningMacro( "Unknown label encountered: " << label );
return 0.0;
}
}
diff --git a/Modules/MitkExt/Algorithms/mitkLookupTableSource.cpp b/Modules/MitkExt/Algorithms/mitkLookupTableSource.cpp
index 1c45ea0dac..9a732c852a 100644
--- a/Modules/MitkExt/Algorithms/mitkLookupTableSource.cpp
+++ b/Modules/MitkExt/Algorithms/mitkLookupTableSource.cpp
@@ -1,113 +1,102 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLookupTableSource.h"
mitk::LookupTableSource::LookupTableSource()
{
- // Create the output. We use static_cast<> here because we know the default
- // output must be of type TOutputImage
- OutputType::Pointer output = static_cast<OutputType*>( this->MakeOutput( 0 ).GetPointer() );
-
- if ( output.GetPointer() == NULL )
- {
- itkWarningMacro(<<"Output could not be created!");
- }
-
- this->ProcessObject::SetNumberOfRequiredOutputs( 1 );
- this->ProcessObject::SetNthOutput( 0, output.GetPointer() );
+ // Create the output.
+ itk::DataObject::Pointer output = this->MakeOutput(0);
+ Superclass::SetNumberOfRequiredOutputs(1);
+ Superclass::SetNthOutput(0, output);
}
mitk::LookupTableSource::~LookupTableSource()
{}
-
-
-
-mitk::LookupTableSource::DataObjectPointer
-mitk::LookupTableSource::MakeOutput ( unsigned int )
-{
- return OutputType::New().GetPointer();
-}
-
-
-
-
-void
-mitk::LookupTableSource::SetOutput( OutputType* output )
+itk::DataObject::Pointer mitk::LookupTableSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
- itkWarningMacro( << "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead." );
- this->SetNthOutput( 0, output );
+ return OutputType::New().GetPointer();
}
-
-
-mitk::LookupTableSource::OutputType*
-mitk::LookupTableSource::GetOutput()
+itk::DataObject::Pointer mitk::LookupTableSource::MakeOutput( const DataObjectIdentifierType & name )
{
- if ( this->GetNumberOfOutputs() < 1 )
- {
- return 0;
- }
-
- if ( static_cast<OutputType*> ( this->ProcessObject::GetOutput( 0 ) ) == NULL )
- itkWarningMacro(<<"Output is NULL!");
- return static_cast<OutputType*> ( this->ProcessObject::GetOutput( 0 ) );
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
+ {
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
+ }
+ return OutputType::New().GetPointer();
}
-
-
-
-mitk::LookupTableSource::OutputType*
-mitk::LookupTableSource::GetOutput ( unsigned int idx )
-{
- return static_cast<OutputType*> ( this->ProcessObject::GetOutput( idx ) );
-}
-
-
-
-
void
mitk::LookupTableSource::GenerateInputRequestedRegion()
{
this->ProcessObject::GenerateInputRequestedRegion();
}
-
-
-
void
mitk::LookupTableSource::GraftOutput( OutputType* graft )
{
OutputType * output = this->GetOutput();
if ( output && graft )
{
// grab a handle to the bulk data of the specified data object
// output->SetPixelContainer( graft->GetPixelContainer() );
// copy the region ivars of the specified data object
// output->SetRequestedRegion( graft->GetRequestedRegion() );
// output->SetLargestPossibleRegion( graft->GetLargestPossibleRegion() );
// output->SetBufferedRegion( graft->GetBufferedRegion() );
// copy the meta-information
output->CopyInformation( graft );
}
}
+
+mitk::LookupTableSource::OutputType* mitk::LookupTableSource::GetOutput()
+{
+ return itkDynamicCastInDebugMode<OutputType*>( this->GetPrimaryOutput() );
+}
+
+const mitk::LookupTableSource::OutputType* mitk::LookupTableSource::GetOutput() const
+{
+ return itkDynamicCastInDebugMode<const OutputType*>( this->GetPrimaryOutput() );
+}
+
+mitk::LookupTableSource::OutputType* mitk::LookupTableSource::GetOutput(itk::ProcessObject::DataObjectPointerArraySizeType idx)
+{
+ OutputType* out = dynamic_cast<OutputType*>( this->ProcessObject::GetOutput(idx) );
+ if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL )
+ {
+ itkWarningMacro (<< "Unable to convert output number " << idx << " to type " << typeid( OutputType ).name () );
+ }
+ return out;
+}
+
+const mitk::LookupTableSource::OutputType* mitk::LookupTableSource::GetOutput(itk::ProcessObject::DataObjectPointerArraySizeType idx) const
+{
+ const OutputType* out = dynamic_cast<const OutputType*>( this->ProcessObject::GetOutput(idx) );
+ if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL )
+ {
+ itkWarningMacro (<< "Unable to convert output number " << idx << " to type " << typeid( OutputType ).name () );
+ }
+ return out;
+}
diff --git a/Modules/MitkExt/Algorithms/mitkLookupTableSource.h b/Modules/MitkExt/Algorithms/mitkLookupTableSource.h
index fa09ca9a32..f351d27ea6 100644
--- a/Modules/MitkExt/Algorithms/mitkLookupTableSource.h
+++ b/Modules/MitkExt/Algorithms/mitkLookupTableSource.h
@@ -1,108 +1,98 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKLOOKUPTABLESOURCE_H_HEADER_INCLUDED
#define MITKLOOKUPTABLESOURCE_H_HEADER_INCLUDED
#include "mitkLookupTable.h"
#include "MitkExtExports.h"
#include "mitkCommon.h"
-#include "mitkBaseProcess.h"
+
+#include "itkProcessObject.h"
namespace mitk
{
/**
* @brief Base class for all objects which have an object of type
* mitkLookupTable as output
*
* Base class for all objects which have an object of type mitkLookupTable
* as output. It is assumed, that mitkLookupTableSources do not provide support
* for streaming, that is, that the requested region is always the largest
* possible region.
* @ingroup Process
*/
class MitkExt_EXPORT LookupTableSource : public itk::ProcessObject
{
public:
- mitkClassMacro( LookupTableSource, BaseProcess );
-
- itkNewMacro( Self );
+ mitkClassMacro( LookupTableSource, itk::ProcessObject )
+ itkNewMacro( Self )
typedef mitk::LookupTable OutputType;
typedef OutputType::Pointer OutputTypePointer;
typedef itk::DataObject::Pointer DataObjectPointer;
/**
* Allocates a new output object and returns it. Currently the
* index idx is not evaluated.
* @param idx the index of the output for which an object should be created
* @returns the new object
*/
- virtual DataObjectPointer MakeOutput ( unsigned int idx );
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
/**
- * Generates the input requested region simply by calling the equivalent
- * method of the superclass.
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
*/
- void GenerateInputRequestedRegion();
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
/**
- * Allows to set the output of the lookup-table source. According to the itk documentation
- * this method is outdated and should not be used. Instead GraftOutput(...)
- * should be used.
- * @param output the intended output of the lookup table source
+ * Generates the input requested region simply by calling the equivalent
+ * method of the superclass.
*/
- void SetOutput( OutputType* output );
+ void GenerateInputRequestedRegion();
/**
* Replacement of the SetOutput method. I think it is not yet correcly
* implemented, so you should better not use it.
* @todo provide a more usefule implementation
* @param output the intended output of the lookup table source.
*/
virtual void GraftOutput( OutputType* output );
- /**
- * Returns the output with index 0 of the lookup table source
- * @returns the output
- */
- OutputType* GetOutput();
-
- /**
- * Returns the n'th output of the lookup table source
- * @param idx the index of the wanted output
- * @returns the output with index idx.
- */
- OutputType* GetOutput ( unsigned int idx );
+ virtual OutputType* GetOutput();
+ virtual const OutputType* GetOutput() const;
+ virtual OutputType* GetOutput(DataObjectPointerArraySizeType idx);
+ virtual const OutputType* GetOutput(DataObjectPointerArraySizeType idx) const;
protected:
LookupTableSource();
virtual ~LookupTableSource();
};
} // namespace mitk
#endif
-
-
diff --git a/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp b/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp
index b506ae7ab4..39e803abc2 100644
--- a/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp
@@ -1,185 +1,185 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkMaskImageFilter.h"
#include "mitkImageTimeSelector.h"
#include "mitkTimeHelper.h"
#include "mitkProperties.h"
#include "mitkImageToItk.h"
#include "mitkImageAccessByItk.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionIteratorWithIndex.h"
#include <limits>
mitk::MaskImageFilter::MaskImageFilter() : m_Mask(NULL)
{
- this->SetNumberOfInputs(2);
+ this->SetNumberOfIndexedInputs(2);
this->SetNumberOfRequiredInputs(2);
m_InputTimeSelector = mitk::ImageTimeSelector::New();
m_MaskTimeSelector = mitk::ImageTimeSelector::New();
m_OutputTimeSelector = mitk::ImageTimeSelector::New();
m_OverrideOutsideValue = false;
m_OutsideValue = 0;
}
mitk::MaskImageFilter::~MaskImageFilter()
{
}
void mitk::MaskImageFilter::SetMask( const mitk::Image* mask )
{
// Process object is not const-correct so the const_cast is required here
m_Mask = const_cast< mitk::Image * >( mask );
this->ProcessObject::SetNthInput(1, m_Mask );
}
const mitk::Image* mitk::MaskImageFilter::GetMask() const
{
return m_Mask;
}
void mitk::MaskImageFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::Image* output = this->GetOutput();
mitk::Image* input = const_cast< mitk::Image * > ( this->GetInput() );
mitk::Image* mask = m_Mask ;
if((output->IsInitialized()==false) || (mask == NULL) || (mask->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
return;
input->SetRequestedRegionToLargestPossibleRegion();
mask->SetRequestedRegionToLargestPossibleRegion();
GenerateTimeInInputRegion(output, input);
GenerateTimeInInputRegion(output, mask);
}
void mitk::MaskImageFilter::GenerateOutputInformation()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
itkDebugMacro(<<"GenerateOutputInformation()");
output->Initialize(input->GetPixelType(), *input->GetTimeSlicedGeometry());
output->SetPropertyList(input->GetPropertyList()->Clone());
m_TimeOfHeaderInitialization.Modified();
}
template < typename TPixel, unsigned int VImageDimension >
void mitk::MaskImageFilter::InternalComputeMask(itk::Image<TPixel, VImageDimension>* inputItkImage)
{
typedef itk::Image<TPixel, VImageDimension> ItkInputImageType;
typedef itk::Image<unsigned char, VImageDimension> ItkMaskImageType;
typedef itk::Image<TPixel, VImageDimension> ItkOutputImageType;
typedef itk::ImageRegionConstIterator< ItkInputImageType > ItkInputImageIteratorType;
typedef itk::ImageRegionConstIterator< ItkMaskImageType > ItkMaskImageIteratorType;
typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;
typename mitk::ImageToItk<ItkMaskImageType>::Pointer maskimagetoitk = mitk::ImageToItk<ItkMaskImageType>::New();
maskimagetoitk->SetInput(m_MaskTimeSelector->GetOutput());
maskimagetoitk->Update();
typename ItkMaskImageType::Pointer maskItkImage = maskimagetoitk->GetOutput();
typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk = mitk::ImageToItk<ItkOutputImageType>::New();
outputimagetoitk->SetInput(m_OutputTimeSelector->GetOutput());
outputimagetoitk->Update();
typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
// create the iterators
typename ItkInputImageType::RegionType inputRegionOfInterest = inputItkImage->GetLargestPossibleRegion();
ItkInputImageIteratorType inputIt( inputItkImage, inputRegionOfInterest );
ItkMaskImageIteratorType maskIt ( maskItkImage, inputRegionOfInterest );
ItkOutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
//typename ItkOutputImageType::PixelType outsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
if ( !m_OverrideOutsideValue )
m_OutsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
m_MinValue = std::numeric_limits<mitk::ScalarType>::max();
m_MaxValue = std::numeric_limits<mitk::ScalarType>::min();
for ( inputIt.GoToBegin(), maskIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd() && !maskIt.IsAtEnd(); ++inputIt, ++maskIt, ++outputIt)
{
if ( maskIt.Get() > itk::NumericTraits<typename ItkMaskImageType::PixelType>::Zero )
{
outputIt.Set(inputIt.Get());
m_MinValue = vnl_math_min((float)inputIt.Get(), (float)m_MinValue);
m_MaxValue = vnl_math_max((float)inputIt.Get(), (float)m_MaxValue);
}
else
{
outputIt.Set(m_OutsideValue);
}
}
}
void mitk::MaskImageFilter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer mask = m_Mask;
mitk::Image::Pointer output = this->GetOutput();
if((output->IsInitialized()==false) || (mask.IsNull()) || (mask->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
return;
m_InputTimeSelector->SetInput(input);
m_MaskTimeSelector->SetInput(mask);
m_OutputTimeSelector->SetInput(this->GetOutput());
mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
const mitk::TimeSlicedGeometry *maskTimeGeometry = mask->GetTimeSlicedGeometry();
ScalarType timeInMS;
int timestep=0;
int tstart=outputRegion.GetIndex(3);
int tmax=tstart+outputRegion.GetSize(3);
int t;
for(t=tstart;t<tmax;++t)
{
timeInMS = outputTimeGeometry->TimeStepToMS( t );
timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
m_InputTimeSelector->SetTimeNr(timestep);
m_InputTimeSelector->UpdateLargestPossibleRegion();
m_OutputTimeSelector->SetTimeNr(t);
m_OutputTimeSelector->UpdateLargestPossibleRegion();
timestep = maskTimeGeometry->MSToTimeStep( timeInMS );
m_MaskTimeSelector->SetTimeNr(timestep);
m_MaskTimeSelector->UpdateLargestPossibleRegion();
AccessByItk(m_InputTimeSelector->GetOutput(),InternalComputeMask);
}
m_TimeOfHeaderInitialization.Modified();
}
diff --git a/Modules/MitkExt/Algorithms/mitkMeshSource.cpp b/Modules/MitkExt/Algorithms/mitkMeshSource.cpp
index 6a54e0cdf7..474790fa86 100644
--- a/Modules/MitkExt/Algorithms/mitkMeshSource.cpp
+++ b/Modules/MitkExt/Algorithms/mitkMeshSource.cpp
@@ -1,85 +1,69 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkMeshSource.h"
mitk::MeshSource::MeshSource()
{
// Create the output.
OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
assert (output.IsNotNull());
this->SetNumberOfRequiredInputs(0);
- this->SetNumberOfOutputs( 1 );
+ this->SetNumberOfIndexedOutputs( 1 );
this->SetOutput(0, output.GetPointer());
}
-
-
-
mitk::MeshSource::~MeshSource()
{
}
-
-
-
-itk::DataObject::Pointer mitk::MeshSource::MakeOutput ( unsigned int /*idx */)
+itk::DataObject::Pointer mitk::MeshSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
return OutputType::New().GetPointer();
}
-
-
-void mitk::MeshSource::SetOutput( OutputType* output )
+itk::DataObject::Pointer mitk::MeshSource::MakeOutput( const DataObjectIdentifierType & name )
{
- this->ProcessObject::SetNthOutput( 0, output );
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
+ {
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
+ }
+ return static_cast<itk::DataObject *>(OutputType::New().GetPointer());
}
-
-
-
-void mitk::MeshSource::SetOutput( unsigned int idx, OutputType* output )
+mitk::MeshSource::OutputType* mitk::MeshSource::GetOutput(const itk::ProcessObject::DataObjectIdentifierType &key)
{
- this->ProcessObject::SetNthOutput(idx, output);
+ return static_cast<mitk::MeshSource::OutputType*>(Superclass::GetOutput(key));
}
-
-
-
-mitk::MeshSource::OutputType* mitk::MeshSource::GetOutput()
+const mitk::MeshSource::OutputType* mitk::MeshSource::GetOutput(const itk::ProcessObject::DataObjectIdentifierType &key) const
{
- if ( this->GetNumberOfOutputs() < 1 )
- {
- return 0;
- }
- else
- {
- return dynamic_cast<OutputType*> ( this->GetOutput( 0 ) );
- }
+ return static_cast<const mitk::MeshSource::OutputType*>(Superclass::GetOutput(key));
}
-
-
-
-mitk::MeshSource::OutputType* mitk::MeshSource::GetOutput ( unsigned int idx )
+mitk::MeshSource::OutputType* mitk::MeshSource::GetOutput(itk::ProcessObject::DataObjectPointerArraySizeType idx)
{
- return dynamic_cast<OutputType*> ( this->ProcessObject::GetOutput( idx ) );
+ return static_cast<mitk::MeshSource::OutputType*>(Superclass::GetOutput(idx));
}
-
+const mitk::MeshSource::OutputType* mitk::MeshSource::GetOutput(itk::ProcessObject::DataObjectPointerArraySizeType idx) const
+{
+ return static_cast<const mitk::MeshSource::OutputType*>(Superclass::GetOutput(idx));
+}
diff --git a/Modules/MitkExt/Algorithms/mitkMeshSource.h b/Modules/MitkExt/Algorithms/mitkMeshSource.h
index fcd20134b6..9041253841 100644
--- a/Modules/MitkExt/Algorithms/mitkMeshSource.h
+++ b/Modules/MitkExt/Algorithms/mitkMeshSource.h
@@ -1,91 +1,78 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITKMESHSOURCE_H
#define _MITKMESHSOURCE_H
#include "itkProcessObject.h"
#include "MitkExtExports.h"
#include "mitkMesh.h"
namespace mitk
{
/**
* @brief Superclass of all classes generating point sets (instances of class
* mitk::Mesh) as output.
*
* In itk and vtk the generated result of a ProcessObject is only guaranteed
* to be up-to-date, when Update() of the ProcessObject or the generated
* DataObject is called immediately before access of the data stored in the
* DataObject.
* @ingroup Process
*/
class MitkExt_EXPORT MeshSource : public itk::ProcessObject
{
public:
mitkClassMacro( MeshSource, itk::ProcessObject );
itkNewMacro( Self );
typedef mitk::Mesh OutputType;
typedef OutputType::Pointer OutputTypePointer;
/**
* Allocates a new output object and returns it. Currently the
* index idx is not evaluated.
* @param idx the index of the output for which an object should be created
* @returns the new object
*/
- virtual itk::DataObject::Pointer MakeOutput ( unsigned int idx );
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
/**
- * Allows to set the output of the point set source.
- * @param output the intended output of the point set source
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
*/
- virtual void SetOutput( OutputType* output );
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
- /**
- * Allows to set the n-th output of the point set source.
- * @param idx The index of the output
- * @param output The intended output of the point set source
- */
- virtual void SetOutput( unsigned int idx, OutputType* output );
-
- /**
- * Returns the output with index 0 of the point set source
- * @returns the output
- */
- virtual OutputType* GetOutput();
-
- /**
- * Returns the n'th output of the point set source
- * @param idx the index of the wanted output
- * @returns the output with index idx.
- */
- virtual OutputType* GetOutput ( unsigned int idx );
+ OutputType* GetOutput(const DataObjectIdentifierType & key);
+ const OutputType* GetOutput(const DataObjectIdentifierType & key) const;
+ OutputType* GetOutput(DataObjectPointerArraySizeType idx);
+ const OutputType* GetOutput(DataObjectPointerArraySizeType idx) const;
protected:
MeshSource();
virtual ~MeshSource();
};
}
#endif // #define _MITKMESHSOURCE_H
diff --git a/Modules/MitkExt/Algorithms/mitkPadImageFilter.cpp b/Modules/MitkExt/Algorithms/mitkPadImageFilter.cpp
index 18bad80c39..c90e0d1966 100644
--- a/Modules/MitkExt/Algorithms/mitkPadImageFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkPadImageFilter.cpp
@@ -1,115 +1,115 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPadImageFilter.h"
#include "mitkImageCast.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkConstantPadImageFilter.h"
mitk::PadImageFilter::PadImageFilter()
{
- this->SetNumberOfInputs(2);
+ this->SetNumberOfIndexedInputs(2);
this->SetNumberOfRequiredInputs(2);
m_BinaryFilter = false;
m_PadConstant = -32766;
m_LowerThreshold = -32766;
m_UpperThreshold = -32765;
}
mitk::PadImageFilter::~PadImageFilter()
{
}
void mitk::PadImageFilter::GenerateData()
{
mitk::Image::ConstPointer image = this->GetInput( 0 );
mitk::Image::ConstPointer referenceImage = this->GetInput( 1 );
typedef itk::Image< short, 3 > ImageType;
ImageType::Pointer itkImage = ImageType::New();
mitk::CastToItkImage( image, itkImage );
mitk::Geometry3D *imageGeometry = image->GetGeometry();
mitk::Point3D origin = imageGeometry->GetOrigin();
mitk::Vector3D spacing = imageGeometry->GetSpacing();
mitk::Geometry3D *referenceImageGeometry = referenceImage->GetGeometry();
mitk::Point3D referenceOrigin = referenceImageGeometry->GetOrigin();
mitk::Vector3D referenceSpacing = referenceImageGeometry->GetSpacing();
double outputOrigin[3];
unsigned long padLowerBound[3];
unsigned long padUpperBound[3];
int i;
for ( i = 0; i < 3; ++i )
{
outputOrigin[i] = referenceOrigin[i];
padLowerBound[i] = static_cast< unsigned long >
((origin[i] - referenceOrigin[i]) / spacing[i] + 0.5);
padUpperBound[i] = referenceImage->GetDimension( i )
- image->GetDimension( i ) - padLowerBound[i];
}
// The origin of the input image is passed through the filter and used as
// output origin as well. Hence, it needs to be overwritten accordingly.
itkImage->SetOrigin( outputOrigin );
typedef itk::ConstantPadImageFilter< ImageType, ImageType > PadFilterType;
PadFilterType::Pointer padFilter = PadFilterType::New();
padFilter->SetInput( itkImage );
padFilter->SetConstant( m_PadConstant );
padFilter->SetPadLowerBound( padLowerBound );
padFilter->SetPadUpperBound( padUpperBound );
mitk::Image::Pointer outputImage = this->GetOutput();
// If the Binary flag is set, use an additional binary threshold filter after
// padding.
if ( m_BinaryFilter )
{
typedef itk::Image< unsigned char, 3 > BinaryImageType;
typedef itk::BinaryThresholdImageFilter< ImageType, BinaryImageType >
BinaryFilterType;
BinaryFilterType::Pointer binaryFilter = BinaryFilterType::New();
binaryFilter->SetInput( padFilter->GetOutput() );
binaryFilter->SetLowerThreshold( m_LowerThreshold );
binaryFilter->SetUpperThreshold( m_UpperThreshold );
binaryFilter->SetInsideValue( 1 );
binaryFilter->SetOutsideValue( 0 );
binaryFilter->Update();
mitk::CastToMitkImage( binaryFilter->GetOutput(), outputImage );
}
else
{
padFilter->Update();
mitk::CastToMitkImage( padFilter->GetOutput(), outputImage );
}
outputImage->SetRequestedRegionToLargestPossibleRegion();
}
diff --git a/Modules/MitkExt/Algorithms/mitkPlanesPerpendicularToLinesFilter.cpp b/Modules/MitkExt/Algorithms/mitkPlanesPerpendicularToLinesFilter.cpp
index fdb0ea8b87..26b8115c35 100644
--- a/Modules/MitkExt/Algorithms/mitkPlanesPerpendicularToLinesFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkPlanesPerpendicularToLinesFilter.cpp
@@ -1,212 +1,212 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlanesPerpendicularToLinesFilter.h"
#include <vnl/vnl_cross.h>
#include <vnl/vnl_quaternion.h>
#include <vnl/vnl_quaternion.txx>
mitk::PlanesPerpendicularToLinesFilter::PlanesPerpendicularToLinesFilter()
: m_Plane(NULL), m_UseAllPoints(false), m_CreatedGeometries(NULL), normal(3), targetRight(3)
{
m_CreatedGeometries = mitk::SlicedGeometry3D::New();
}
mitk::PlanesPerpendicularToLinesFilter::~PlanesPerpendicularToLinesFilter()
{
}
void mitk::PlanesPerpendicularToLinesFilter::GenerateOutputInformation()
{
mitk::Mesh::ConstPointer input = this->GetInput();
mitk::GeometryData::Pointer output = this->GetOutput();
itkDebugMacro(<<"GenerateOutputInformation()");
if(input.IsNull()) return;
output->SetGeometry(m_CreatedGeometries);
}
void mitk::PlanesPerpendicularToLinesFilter::CreatePlane(const mitk::Point3D& curr)
{
int j;
for(j=0;j<3;++j)
normal[j] = last[j]-curr[j]; //@todo globally define normal direction of display xxx
normal.normalize();
down = vnl_cross_3d(normal, targetRight);
down.normalize();
right = vnl_cross_3d(down, normal);
right.normalize();
- itk2vtk(last.Get_vnl_vector()-right*halfWidthInMM-down*halfHeightInMM, origin);
+ itk2vtk(last.GetVnlVector()-right*halfWidthInMM-down*halfHeightInMM, origin);
right *= targetSpacing[0];
down *= targetSpacing[1];
normal *= targetSpacing[2];
mitk::Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, right);
matrix.GetVnlMatrix().set_column(1, down);
matrix.GetVnlMatrix().set_column(2, normal);
PlaneGeometry::Pointer plane = PlaneGeometry::New();
plane->GetIndexToWorldTransform()->SetMatrix(matrix);
plane->SetOrigin(origin);
plane->SetBounds(bounds);
planes.push_back(plane);
last = curr;
}
void mitk::PlanesPerpendicularToLinesFilter::GenerateData()
{
mitk::Mesh::ConstPointer input = this->GetInput();
mitk::GeometryData::Pointer output = this->GetOutput();
if(m_Plane.IsNotNull())
{
targetRight = m_Plane->GetMatrixColumn(0);
targetSpacing = m_Plane->GetSpacing();
bounds = m_Plane->GetBoundingBox()->GetBounds();
halfWidthInMM = m_Plane->GetExtentInMM(0)*0.5;
halfHeightInMM = m_Plane->GetExtentInMM(1)*0.5;
}
else
{
FillVector3D(targetRight, 1.0, 0.0, 0.0);
targetSpacing.Fill(1.0);
halfWidthInMM=halfHeightInMM=100.0;
ScalarType stdBounds[6] = {0.0, 2.0*halfWidthInMM, 0.0, 2.0*halfHeightInMM, 0.0, 0.0};
bounds = stdBounds;
}
if(m_UseAllPoints==false)
{
int i, size;
//iterate through all cells and build planes
Mesh::ConstCellIterator cellIt, cellEnd;
cellEnd = input->GetMesh()->GetCells()->End();
for( cellIt = input->GetMesh()->GetCells()->Begin(); cellIt != cellEnd; ++cellIt )
{
Mesh::CellType& cell = *cellIt->Value();
Mesh::PointIdIterator ptIt, ptEnd;
ptEnd = cell.PointIdsEnd();
size=cell.GetNumberOfPoints();
if(size<=1)
continue;
ptIt = cell.PointIdsBegin();
last = input->GetPoint(*ptIt);
++ptIt;
for(i=1;i<size;++i, ++ptIt)
{
CreatePlane(input->GetPoint(*ptIt));
}
}
}
else //m_UseAllPoints==true
{
//iterate through all points and build planes
mitk::PointSet::PointsConstIterator it, pend = input->GetPointSet()->GetPoints()->End();
it=input->GetPointSet()->GetPoints()->Begin();
last = it.Value();
++it;
for(;it!=pend;++it)
{
CreatePlane(it.Value());
}
}
if(planes.size()>0)
{
//initialize sliced-geometry for the number of created planes
m_CreatedGeometries->InitializeSlicedGeometry(planes.size()+1);
//set last plane at last point with same normal as the one before the last
PlaneGeometry::Pointer plane = static_cast<PlaneGeometry*>((*planes.rbegin())->Clone().GetPointer());
- itk2vtk(last.Get_vnl_vector()-right*halfWidthInMM-down*halfHeightInMM, origin);
+ itk2vtk(last.GetVnlVector()-right*halfWidthInMM-down*halfHeightInMM, origin);
plane->SetOrigin(origin);
m_CreatedGeometries->SetGeometry2D(plane, planes.size());
//add all planes to sliced-geometry
int s;
for(s=0; planes.empty()==false; planes.pop_front(), ++s)
{
m_CreatedGeometries->SetGeometry2D(planes.front(), s);
}
m_CreatedGeometries->SetEvenlySpaced(false);
if(m_FrameGeometry.IsNotNull())
{
m_CreatedGeometries->SetIndexToWorldTransform(m_FrameGeometry->GetIndexToWorldTransform());
m_CreatedGeometries->SetBounds(m_FrameGeometry->GetBounds());
m_CreatedGeometries->SetReferenceGeometry(m_FrameGeometry);
}
}
output->SetGeometry(m_CreatedGeometries);
}
void mitk::PlanesPerpendicularToLinesFilter::SetPlane(const mitk::PlaneGeometry* aPlane)
{
if(aPlane!=NULL)
{
m_Plane = static_cast<mitk::PlaneGeometry*>(aPlane->Clone().GetPointer());
}
else
{
if(m_Plane.IsNull())
return;
m_Plane=NULL;
}
Modified();
}
const mitk::Mesh *mitk::PlanesPerpendicularToLinesFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return static_cast<const mitk::Mesh * >
(this->ProcessObject::GetInput(0) );
}
void mitk::PlanesPerpendicularToLinesFilter::SetInput(const mitk::Mesh *input)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(0,
const_cast< mitk::Mesh * >( input ) );
}
void mitk::PlanesPerpendicularToLinesFilter::SetFrameGeometry(const mitk::Geometry3D* frameGeometry)
{
if((frameGeometry != NULL) && (frameGeometry->IsValid()))
{
m_FrameGeometry = static_cast<mitk::Geometry3D*>(frameGeometry->Clone().GetPointer());
}
else
{
m_FrameGeometry = NULL;
}
}
diff --git a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
index 65f76425d8..ab13046819 100644
--- a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
@@ -1,186 +1,181 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetToCurvedGeometryFilter.h"
#include "mitkThinPlateSplineCurvedGeometry.h"
#include "mitkPlaneGeometry.h"
#include "mitkImage.h"
#include "mitkTimeSlicedGeometry.h"
#include "mitkDataNode.h"
#include "mitkGeometryData.h"
#include "mitkGeometry2DData.h"
#include "mitkProperties.h"
#include "itkMesh.h"
#include "itkPointSet.h"
mitk::PointSetToCurvedGeometryFilter::PointSetToCurvedGeometryFilter()
{
m_ProjectionMode = YZPlane;
m_PCAPlaneCalculator = mitk::PlaneFit::New();
m_ImageToBeMapped = NULL;
m_Sigma = 1000;
mitk::Geometry2DData::Pointer output = static_cast<mitk::Geometry2DData*> ( this->MakeOutput ( 0 ).GetPointer() );
output->Initialize();
Superclass::SetNumberOfRequiredOutputs ( 1 );
Superclass::SetNthOutput ( 0, output.GetPointer() );
}
mitk::PointSetToCurvedGeometryFilter::~PointSetToCurvedGeometryFilter()
{}
void mitk::PointSetToCurvedGeometryFilter::GenerateOutputInformation()
{
mitk::PointSet::ConstPointer input = this->GetInput();
mitk::Geometry2DData::Pointer output = dynamic_cast<mitk::Geometry2DData*> ( this->GetOutput() );
if ( input.IsNull() )
itkGenericExceptionMacro ( "Input point set is NULL!" );
if ( input->GetTimeSlicedGeometry()->GetTimeSteps() != 1 )
itkWarningMacro ( "More than one time step is not yet supported!" );
if ( output.IsNull() )
itkGenericExceptionMacro ( "Output is NULL!" );
if ( m_ImageToBeMapped.IsNull() )
itkGenericExceptionMacro ( "Image to be mapped is NULL!" );
bool update = false;
if ( output->GetGeometry() == NULL || output->GetGeometry2D() == NULL || output->GetTimeSlicedGeometry() == NULL )
update = true;
if ( ( ! update ) && ( output->GetTimeSlicedGeometry()->GetTimeSteps() != input->GetTimeSlicedGeometry()->GetTimeSteps() ) )
update = true;
if ( update )
{
mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
output->SetGeometry(curvedGeometry);
/*
mitk::TimeSlicedGeometry::Pointer timeGeometry = mitk::TimeSlicedGeometry::New();
mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
timeGeometry->InitializeEvenlyTimed ( curvedGeometry, input->GetPointSetSeriesSize() );
for ( unsigned int t = 1; t < input->GetPointSetSeriesSize(); ++t )
{
mitk::ThinPlateSplineCurvedGeometry::Pointer tmpCurvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
timeGeometry->SetGeometry3D ( tmpCurvedGeometry.GetPointer(), t );
}
output->SetGeometry ( timeGeometry );
output->SetGeometry2D ( curvedGeometry ); // @FIXME SetGeometry2D of mitk::Geometry2DData reinitializes the TimeSlicedGeometry to 1 time step
*/
}
}
void mitk::PointSetToCurvedGeometryFilter::GenerateData()
{
mitk::PointSet::ConstPointer input = this->GetInput();
mitk::GeometryData::Pointer output = this->GetOutput();
//
// check preconditions
//
if ( input.IsNull() )
itkGenericExceptionMacro ( "Input point set is NULL!" );
if ( output.IsNull() )
itkGenericExceptionMacro ( "output geometry data is NULL!" );
if ( output->GetTimeSlicedGeometry() == NULL )
itkGenericExceptionMacro ( "Output time sliced geometry is NULL!" );
if ( output->GetTimeSlicedGeometry()->GetGeometry3D ( 0 ) == NULL )
itkGenericExceptionMacro ( "Output geometry3d is NULL!" );
mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = dynamic_cast<mitk::ThinPlateSplineCurvedGeometry*> ( output->GetTimeSlicedGeometry()->GetGeometry3D ( 0 ) );
if ( curvedGeometry.IsNull() )
itkGenericExceptionMacro ( "Output geometry3d is not an instance of mitk::ThinPlateSPlineCurvedGeometry!" );
if ( m_ImageToBeMapped.IsNull() )
itkGenericExceptionMacro ( "Image to be mapped is NULL!" );
//
// initialize members if needed
//
if ( m_XYPlane.IsNull() || m_XZPlane.IsNull() || m_YZPlane.IsNull() )
{
m_ImageToBeMapped->UpdateOutputInformation();
const mitk::Geometry3D* imageGeometry = m_ImageToBeMapped->GetUpdatedGeometry();
imageGeometry = m_ImageToBeMapped->GetUpdatedGeometry();
m_XYPlane = mitk::PlaneGeometry::New();
m_XZPlane = mitk::PlaneGeometry::New();
m_YZPlane = mitk::PlaneGeometry::New();
m_XYPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Axial );
m_YZPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Sagittal );
m_XZPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Frontal );
}
if ( m_PlaneLandmarkProjector.IsNull() )
{
m_PlaneLandmarkProjector = mitk::PlaneLandmarkProjector::New();
m_SphereLandmarkProjector = mitk::SphereLandmarkProjector::New();
}
//
// set up geometry according to the current settings
//
if ( m_ProjectionMode == Sphere )
{
curvedGeometry->SetLandmarkProjector ( m_SphereLandmarkProjector );
}
else
{
if ( m_ProjectionMode == XYPlane )
m_PlaneLandmarkProjector->SetProjectionPlane ( m_XYPlane );
else if ( m_ProjectionMode == XZPlane )
m_PlaneLandmarkProjector->SetProjectionPlane ( m_XZPlane );
else if ( m_ProjectionMode == YZPlane )
m_PlaneLandmarkProjector->SetProjectionPlane ( m_YZPlane );
else if ( m_ProjectionMode == PCAPlane )
{
itkExceptionMacro ( "PCAPlane not yet implemented!" );
m_PCAPlaneCalculator->SetInput ( input );
m_PCAPlaneCalculator->Update();
m_PlaneLandmarkProjector->SetProjectionPlane ( dynamic_cast<mitk::PlaneGeometry*> ( m_PCAPlaneCalculator->GetOutput() ) );
}
else
itkExceptionMacro ( "Unknown projection mode" );
curvedGeometry->SetLandmarkProjector ( m_PlaneLandmarkProjector );
}
//curvedGeometry->SetReferenceGeometry( m_ImageToBeMapped->GetGeometry() );
curvedGeometry->SetTargetLandmarks ( input->GetPointSet ( 0 )->GetPoints() );
curvedGeometry->SetSigma ( m_Sigma );
curvedGeometry->ComputeGeometry();
curvedGeometry->SetOversampling ( 1.0 );
}
-mitk::GeometryDataSource::DataObjectPointer mitk::PointSetToCurvedGeometryFilter::MakeOutput ( unsigned int )
-{
- return static_cast<itk::DataObject*> ( mitk::Geometry2DData::New().GetPointer() );
-}
-
void mitk::PointSetToCurvedGeometryFilter::SetDefaultCurvedGeometryProperties ( mitk::DataNode* node )
{
if ( node == NULL )
{
itkGenericOutputMacro ( "Warning: node is NULL!" );
return;
}
node->SetIntProperty ( "xresolution", 50 );
node->SetIntProperty ( "yresolution", 50 );
node->SetProperty ( "name", mitk::StringProperty::New ( "Curved Plane" ) );
// exclude extent of this plane when calculating DataStorage bounding box
node->SetProperty ( "includeInBoundingBox", mitk::BoolProperty::New ( false ) );
}
diff --git a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.h b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.h
index 7366072160..07c6fd39f7 100644
--- a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.h
+++ b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.h
@@ -1,115 +1,113 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_POINT_SET_TO_CURVED_GEOMETRY_FILTER_H__
#define _MITK_POINT_SET_TO_CURVED_GEOMETRY_FILTER_H__
#include "mitkPointSetToGeometryDataFilter.h"
#include "MitkExtExports.h"
#include <mitkPlaneGeometry.h>
#include <mitkSphereLandmarkProjector.h>
#include <mitkPlaneLandmarkProjector.h>
#include <mitkPlaneFit.h>
#include <mitkDataNode.h>
#include <mitkImage.h>
namespace mitk
{
class MitkExt_EXPORT PointSetToCurvedGeometryFilter : public PointSetToGeometryDataFilter
{
public:
/**
* Standard mitk class macro
*/
mitkClassMacro ( PointSetToCurvedGeometryFilter, PointSetToGeometryDataFilter );
itkNewMacro ( Self );
/**
* Defines the geometry, onto which the input landmarks are
* projected. Currently, Plane and Sphere are supported, whilest plane
* is differentiated into 4 different planes, the xy, xz, and yz plane,
* as well a plane which is calculated by a principal component analysis
* of the input point set.
*/
enum ProjectionMode {Sphere, XYPlane, XZPlane, YZPlane, PCAPlane};
/**
* Fills a data tree node with appropriate properties
* for mapping the output geometry surface
*/
static void SetDefaultCurvedGeometryProperties( mitk::DataNode* node );
/**
* Sets / Gets whether the input land marks are projected onto a plane
* or sphere
*/
itkSetMacro ( ProjectionMode, ProjectionMode );
/**
* Sets / Gets whether the input land marks are projected onto a plane
* or sphere
*/
itkGetMacro ( ProjectionMode, ProjectionMode );
itkSetObjectMacro( ImageToBeMapped, mitk::Image );
itkGetObjectMacro( ImageToBeMapped, mitk::Image );
itkSetMacro( Sigma, float);
itkGetMacro( Sigma, float);
protected:
/**
* Protected constructor. Use ::New instead()
*/
PointSetToCurvedGeometryFilter();
/**
* Protected destructor. Instances are destroyed when reference count is zero
*/
virtual ~PointSetToCurvedGeometryFilter();
virtual void GenerateOutputInformation();
virtual void GenerateData();
- virtual GeometryDataSource::DataObjectPointer MakeOutput(unsigned int idx);
-
ProjectionMode m_ProjectionMode;
mitk::PlaneGeometry::Pointer m_XYPlane;
mitk::PlaneGeometry::Pointer m_XZPlane;
mitk::PlaneGeometry::Pointer m_YZPlane;
mitk::PlaneFit::Pointer m_PCAPlaneCalculator;
mitk::Image::Pointer m_ImageToBeMapped;
mitk::PlaneLandmarkProjector::Pointer m_PlaneLandmarkProjector;
mitk::SphereLandmarkProjector::Pointer m_SphereLandmarkProjector;
float m_Sigma;
};
}
#endif
diff --git a/Modules/MitkExt/Algorithms/mitkPolygonToRingFilter.cpp b/Modules/MitkExt/Algorithms/mitkPolygonToRingFilter.cpp
index 059170135e..09c2cce12b 100644
--- a/Modules/MitkExt/Algorithms/mitkPolygonToRingFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkPolygonToRingFilter.cpp
@@ -1,341 +1,341 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPolygonToRingFilter.h"
#include "mitkMesh.h"
#include "mitkSurface.h"
#include "mitkPlaneGeometry.h"
#include <vnl/vnl_cross.h>
#include <vnl/vnl_quaternion.h>
#include <vnl/vnl_quaternion.txx>
#include <vtkPolyData.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkCardinalSpline.h>
#include <vector>
mitk::PolygonToRingFilter::PolygonToRingFilter()
: m_RingRadius(3.5f), m_RingResolution(30), m_SplineResolution(20)
{
m_SplineX = vtkCardinalSpline::New();
m_SplineY = vtkCardinalSpline::New();
m_SplineZ = vtkCardinalSpline::New();
}
mitk::PolygonToRingFilter::~PolygonToRingFilter()
{
m_SplineX->Delete();
m_SplineY->Delete();
m_SplineZ->Delete();
}
void mitk::PolygonToRingFilter::GenerateOutputInformation()
{
mitk::Mesh::ConstPointer input = this->GetInput();
- mitk::Surface::Pointer output = this->GetOutput();
+ mitk::Surface::Pointer output = this->GetOutput(0);
itkDebugMacro(<<"GenerateOutputInformation()");
if(input.IsNull()) return;
output->SetGeometry(static_cast<Geometry3D*>(input->GetGeometry()->Clone().GetPointer()));
output->Expand( input->GetPointSetSeriesSize() );
}
void mitk::PolygonToRingFilter::GenerateData()
{
mitk::Mesh::ConstPointer input = this->GetInput();
- mitk::Surface::Pointer output = this->GetOutput();
+ mitk::Surface::Pointer output = this->GetOutput(0);
unsigned int t;
for ( t = 0; t < input->GetPointSetSeriesSize(); ++t )
{
vtkPolyData *polyData = vtkPolyData::New();
vtkPoints *vPoints = vtkPoints::New();
vtkCellArray *polys = vtkCellArray::New();
mitk::Mesh::PointType thisPoint;
// iterate through all cells and build tubes
Mesh::ConstCellIterator cellIt, cellEnd;
cellEnd = input->GetMesh( t )->GetCells()->End();
for ( cellIt = input->GetMesh( t )->GetCells()->Begin();
cellIt != cellEnd;
++cellIt )
{
m_PointList.clear();
m_VectorList.clear();
this->BuildPointAndVectorList(
*cellIt->Value(), m_PointList, m_VectorList, t );
this->BuildVtkTube( vPoints, polys, m_PointList, m_VectorList );
}
polyData->SetPoints( vPoints );
vPoints->Delete();
polyData->SetPolys( polys );
polys->Delete();
output->SetVtkPolyData( polyData, t );
polyData->Delete();
}
}
//sl: Stern Letzter
//sc: Stern Current=aktueller Stern
//idmax: Id des Strahls des aktuellen Sterns (sc), der am besten zum ersten Strahl vom letzten Stern (sl) passt.
//last_p: Mittelpunkt des letzten Sterns
//cur_p: Mittelpunkt des aktuellen Sterns
void mitk::PolygonToRingFilter::DrawCyl(vtkPoints *vPoints, vtkCellArray *polys,
VectorListType &sl, VectorListType &sc, int idmax, Point3D & last_p, Point3D & cur_p)
{
unsigned int i;
//jetzt haben wir alles: sl0 wird mit sc->at(idmax) verbunden usw.
VectorListType::iterator slit=sl.begin(), scit=sc.begin(), scend=sc.end();
scit+=idmax;
Point3D a,b;
Point3D a_first,b_first;
int a_firstID = 0, b_firstID = 0;
vtkIdType front[4];
for(i=0;i<m_RingResolution;++i)
{
VnlVector v0,v1,v2,v3,normal;
- v0=a.Get_vnl_vector(); v1=b.Get_vnl_vector();
+ v0=a.GetVnlVector(); v1=b.GetVnlVector();
a=last_p+*slit*m_RingRadius; b=cur_p+*scit*m_RingRadius;
- v2=b.Get_vnl_vector(); v3=a.Get_vnl_vector();
+ v2=b.GetVnlVector(); v3=a.GetVnlVector();
normal=vnl_cross_3d(v1-v0,v3-v0);
if(i!=0)
{
front[3]=vPoints->InsertNextPoint(v0[0],v0[1],v0[2]);
front[2]=vPoints->InsertNextPoint(v1[0],v1[1],v1[2]);
front[1]=vPoints->InsertNextPoint(v2[0],v2[1],v2[2]);
front[0]=vPoints->InsertNextPoint(v3[0],v3[1],v3[2]);
polys->InsertNextCell( (vtkIdType) 4, front );
if(i==1)
{
a_firstID=front[3]; b_firstID=front[2]; //continue;
}
}
++slit; ++scit; if(scit==scend) scit=sc.begin();
}
front[3]=front[0];
front[2]=front[1];
front[1]=b_firstID;
front[0]=a_firstID;
polys->InsertNextCell( 4, front );
}
void mitk::PolygonToRingFilter::BuildVtkTube(vtkPoints *vPoints, vtkCellArray *polys, PointListType& ptList, VectorListType& vecList)
{
PointListType::iterator pit = ptList.begin(), pend = ptList.end();
VectorListType::iterator vit = vecList.begin();
Vector3D axis, last_v, next_v, s;
Point3D cur_p,last_p;
//Listen für den Stern
VectorListType *sl, *sc, *swp, sfirst, buf1, buf2;
sl=&buf1; sc=&buf2;
Vector3D a,b;
Matrix3D m;
//Initialisierung für ersten Punkt
//alternative1:
// last_v=*(vl.getLast()); next_v=*vit.current(); axis=last_v+next_v; s.cross(last_v,next_v); s.normalize();
//alternative2:
// last_v=*(vl.getLast()); next_v=*vit.current(); s.cross(last_v,next_v); s.normalize();
// axis=next_v-last_v; axis.normalize(); aa.set(s, M_PI/2.0); m.set(aa); m.transform(&axis);
//alternative3:
- last_v=vecList.back(); next_v=*vit; s.Set_vnl_vector( vnl_cross_3d(last_v.Get_vnl_vector(),next_v.Get_vnl_vector()) ); s.Normalize();
+ last_v=vecList.back(); next_v=*vit; s.SetVnlVector( vnl_cross_3d(last_v.GetVnlVector(),next_v.GetVnlVector()) ); s.Normalize();
a=last_v; b=next_v; a.Normalize(); b.Normalize(); axis=a+b; axis.Normalize();
//Stern am ersten Punkt aufbauen
- m = vnl_quaternion<mitk::ScalarType>(axis.Get_vnl_vector(),2*vnl_math::pi/(double)m_RingResolution).rotation_matrix_transpose();
+ m = vnl_quaternion<mitk::ScalarType>(axis.GetVnlVector(),2*vnl_math::pi/(double)m_RingResolution).rotation_matrix_transpose();
unsigned int i;
for(i=0;i<m_RingResolution;++i)
{
sfirst.push_back(s);
s=m*s;
}
*sl=sfirst;
last_p=*pit;
++pit; ++vit;
//nun die Hauptschleife über alle Punkte
for ( ; pit != pend; ++pit, ++vit )
{
// cur_p=*pit.current(); last_v=next_v; next_v=*vit.current(); axis=last_v+next_v; s.cross(last_v,next_v); s.normalize();
- cur_p=*pit; last_v=next_v; next_v=*vit; s.Set_vnl_vector( vnl_cross_3d(last_v.Get_vnl_vector(),next_v.Get_vnl_vector()) ); s.Normalize();
+ cur_p=*pit; last_v=next_v; next_v=*vit; s.SetVnlVector( vnl_cross_3d(last_v.GetVnlVector(),next_v.GetVnlVector()) ); s.Normalize();
// axis=next_v-last_v; axis.normalize(); aa.set(s, M_PI/2.0); m.set(aa); m.transform(&axis);
a=last_v; b=next_v; a.Normalize(); b.Normalize(); axis=a+b; axis.Normalize();
//neuen Stern sc (SternCurrent) bauen und dabei Start für neuen Stern suchen
double max=0; int idmax=0; Vector3D sl0=*(sl->begin());
- m = vnl_quaternion<mitk::ScalarType>(axis.Get_vnl_vector(),2*vnl_math::pi/(double)m_RingResolution).rotation_matrix_transpose();
+ m = vnl_quaternion<mitk::ScalarType>(axis.GetVnlVector(),2*vnl_math::pi/(double)m_RingResolution).rotation_matrix_transpose();
for(i=0;i<m_RingResolution;++i)
{
sc->push_back(s);
double tmp=s*sl0;
if(tmp>max)
{
max=tmp;
idmax=i;
}
s=m*s;
}
//sl: Stern Letzter
//sc: Stern Current=aktueller Stern
//idmax: Id des Strahls des aktuellen Sterns (sc), der am besten zum ersten Strahl vom letzten Stern (sl) passt.
//last_p: Mittelpunkt des letzten Sterns
//cur_p: Mittelpunkt des aktuellen Sterns
DrawCyl(vPoints, polys, *sl, *sc, idmax, last_p, cur_p);
//Übergang zum nächsten
last_p=cur_p;
swp=sl; sl=sc; sc=swp; sc->clear();
}
//idmax für Verbindung ersten mit letztem ausrechnen:
double max=0; int idmax=0; Vector3D sl0=*(sl->begin());
for(i=0;i<m_RingResolution;++i)
{
s=sfirst[i];
double tmp=s*sl0;
if(tmp>max)
{
max=tmp;
idmax=i;
}
}
cur_p=*ptList.begin();
DrawCyl(vPoints, polys, *sl, sfirst, idmax, last_p, cur_p);
}
void
mitk::PolygonToRingFilter
::BuildPointAndVectorList( mitk::Mesh::CellType& cell,
PointListType& ptList, VectorListType& vecList, int timeStep )
{
// This method constructs a spline from the given point list and retrieves
// a number of interpolated points from it to form a ring-like structure.
//
// To make the spline "closed", the end point is connected to the start
// point. For ensuring smoothness at the start-end-point transition, the
// (intrinsically non-circular) spline array is extended on both sides
// by wrapping a number of points from the respective other side.
//
// The used VTK filters do principally support this kind of "closed" spline,
// but it does not produce results as consistent as with the method used
// here. Also, the spline class of VTK 4.4 has only poor support for
// arbitrary parametric coordinates (t values in vtkSpline). VTK 5.0 has
// better support, and also provides a new class vtkParametricSpline for
// directly calculating 3D splines.
// Remove points from previous call of this method
m_SplineX->RemoveAllPoints();
m_SplineY->RemoveAllPoints();
m_SplineZ->RemoveAllPoints();
int numberOfPoints = cell.GetNumberOfPoints();
Mesh::PointType inputPoint;
vtkFloatingPointType t, tStart(0), tEnd(0);
// Add input points to the spline and assign each the parametric value t
// derived from the point euclidean distances.
int i;
Mesh::PointIdIterator pit = cell.PointIdsEnd() - 3;
for ( i = -3, t = 0.0; i < numberOfPoints + 3; ++i )
{
if ( i == 0 ) { tStart = t; }
if ( i == numberOfPoints ) { tEnd = t; }
inputPoint = this->GetInput()->GetPoint( *pit, timeStep );
m_SplineX->AddPoint( t, inputPoint[0] );
m_SplineY->AddPoint( t, inputPoint[1] );
m_SplineZ->AddPoint( t, inputPoint[2] );
++pit;
if ( pit == cell.PointIdsEnd() )
{
pit = cell.PointIdsBegin();
}
t += inputPoint.EuclideanDistanceTo(
this->GetInput()->GetPoint( *pit, timeStep ) );
}
// Evaluate the spline for the desired number of points
// (number of input points) * (spline resolution)
Point3D point, firstPoint, lastPoint;
firstPoint.Fill(0);
lastPoint.Fill(0);
int numberOfSegments = numberOfPoints * m_SplineResolution;
vtkFloatingPointType step = (tEnd - tStart) / numberOfSegments;
for ( i = 0, t = tStart; i < numberOfSegments; ++i, t += step )
{
FillVector3D( point,
m_SplineX->Evaluate(t), m_SplineY->Evaluate(t), m_SplineZ->Evaluate(t)
);
ptList.push_back( point );
if ( i == 0 )
{
firstPoint = point;
}
else
{
vecList.push_back( point - lastPoint );
}
lastPoint = point;
}
vecList.push_back( firstPoint - lastPoint );
}
const mitk::Mesh *mitk::PolygonToRingFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return static_cast<const mitk::Mesh * >
(this->ProcessObject::GetInput(0) );
}
void mitk::PolygonToRingFilter::SetInput(const mitk::Mesh *input)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(0,
const_cast< mitk::Mesh * >( input ) );
}
diff --git a/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp b/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
index f579891f4c..b6f7ea710a 100644
--- a/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
@@ -1,218 +1,215 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkProbeFilter.h"
#include "mitkSurface.h"
#include "mitkImage.h"
#include "mitkTimeSlicedGeometry.h"
#include <vtkPolyDataSource.h>
#include <vtkProbeFilter.h>
#include <itkImageRegion.h>
#include <vtkDataSet.h>
#include <vtkPolyData.h>
#include <vtkImageData.h>
-#include <itkSmartPointerForwardReference.txx>
-
-
mitk::ProbeFilter::ProbeFilter()
{
}
mitk::ProbeFilter::~ProbeFilter()
{
}
const mitk::Surface *mitk::ProbeFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return static_cast< const mitk::Surface * >(this->ProcessObject::GetInput(0) );
}
const mitk::Image *mitk::ProbeFilter::GetSource(void)
{
return static_cast< const mitk::Image * >(this->ProcessObject::GetInput(1));
}
void mitk::ProbeFilter::SetInput(const mitk::Surface *input)
{
this->ProcessObject::SetNthInput( 0, const_cast< mitk::Surface * >( input ) );
}
void mitk::ProbeFilter::SetSource(const mitk::Image *source)
{
this->ProcessObject::SetNthInput( 1, const_cast< mitk::Image * >( source ) );
}
void mitk::ProbeFilter::GenerateOutputInformation()
{
mitk::Surface::ConstPointer input = this->GetInput();
mitk::Image::ConstPointer source = this->GetSource();
mitk::Surface::Pointer output = this->GetOutput();
if(input.IsNull()) return;
if(source.IsNull()) return;
if(input->GetGeometry()==NULL) return;
if(source->GetGeometry()==NULL) return;
if( (input->GetTimeSlicedGeometry()->GetTimeSteps()==1) && (source->GetTimeSlicedGeometry()->GetTimeSteps()>1) )
{
Geometry3D::Pointer geometry3D = Geometry3D::New();
geometry3D->Initialize();
geometry3D->SetBounds(source->GetTimeSlicedGeometry()->GetBounds());
geometry3D->SetTimeBounds(source->GetTimeSlicedGeometry()->GetGeometry3D(0)->GetTimeBounds());
TimeSlicedGeometry::Pointer outputTimeSlicedGeometry = TimeSlicedGeometry::New();
outputTimeSlicedGeometry->InitializeEvenlyTimed(geometry3D, source->GetTimeSlicedGeometry()->GetTimeSteps());
output->Expand(outputTimeSlicedGeometry->GetTimeSteps());
output->SetGeometry( outputTimeSlicedGeometry );
}
else
output->SetGeometry( static_cast<Geometry3D*>(input->GetGeometry()->Clone().GetPointer()) );
itkDebugMacro(<<"GenerateOutputInformation()");
}
void mitk::ProbeFilter::GenerateData()
{
mitk::Surface *input = const_cast< mitk::Surface * >(this->GetInput());
mitk::Image *source = const_cast< mitk::Image * >(this->GetSource());
mitk::Surface::Pointer output = this->GetOutput();
itkDebugMacro(<<"Generating Data");
if(output.IsNull())
{
itkDebugMacro(<<"Output is NULL.");
return;
}
mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
const mitk::TimeSlicedGeometry *sourceTimeGeometry = source->GetTimeSlicedGeometry();
ScalarType timeInMS;
int timestep=0;
int tstart, tmax;
tstart=outputRegion.GetIndex(3);
tmax=tstart+outputRegion.GetSize(3);
int t;
for(t=tstart;t<tmax;++t)
{
timeInMS = outputTimeGeometry->TimeStepToMS( t );
vtkProbeFilter* probe = vtkProbeFilter::New();
timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
probe->SetInput( input->GetVtkPolyData(timestep) );
timestep = sourceTimeGeometry->MSToTimeStep( timeInMS );
probe->SetSource( source->GetVtkImageData(timestep) );
output->SetVtkPolyData( probe->GetPolyDataOutput(), t );
probe->Update();
probe->Delete();
}
}
void mitk::ProbeFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::Surface *input = const_cast< mitk::Surface * >( this->GetInput() );
mitk::Image *source = const_cast< mitk::Image * >( this->GetSource() );
if(input==NULL) return;
if(source==NULL) return;
mitk::Surface::Pointer output = this->GetOutput();
mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
mitk::Surface::RegionType inputSurfaceRegion = outputRegion;
Image::RegionType sourceImageRegion = source->GetLargestPossibleRegion();
if(outputRegion.GetSize(3)<1)
{
mitk::Surface::RegionType::SizeType surfacesize;
surfacesize.Fill(0);
inputSurfaceRegion.SetSize(surfacesize);
input->SetRequestedRegion( &inputSurfaceRegion );
mitk::Image::RegionType::SizeType imagesize;
imagesize.Fill(0);
sourceImageRegion.SetSize(imagesize);
source->SetRequestedRegion( &sourceImageRegion );
return;
}
//create and set input requested region for the input surface
const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
ScalarType timeInMS;
int timestep=0;
// convert the start-index-time of output in start-index-time of input via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3));
timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( inputTimeGeometry->IsValidTime( timestep ) ) )
inputSurfaceRegion.SetIndex( 3, timestep );
else
inputSurfaceRegion.SetIndex( 3, 0 );
// convert the end-index-time of output in end-index-time of input via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
timestep = inputTimeGeometry->MSToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTime( timestep ) ) )
inputSurfaceRegion.SetSize( 3, timestep - inputSurfaceRegion.GetIndex(3) + 1 );
else
inputSurfaceRegion.SetSize( 3, 1 );
input->SetRequestedRegion( &inputSurfaceRegion );
//create and set input requested region for the source image
const mitk::TimeSlicedGeometry *sourceTimeGeometry = source->GetTimeSlicedGeometry();
// convert the start-index-time of output in start-index-time of source via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3));
timestep = sourceTimeGeometry->MSToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( sourceTimeGeometry->IsValidTime( timestep ) ) )
sourceImageRegion.SetIndex( 3, timestep );
else
sourceImageRegion.SetIndex( 3, 0 );
// convert the end-index-time of output in end-index-time of source via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToMS(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
timestep = sourceTimeGeometry->MSToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTime( timestep ) ) )
sourceImageRegion.SetSize( 3, timestep - sourceImageRegion.GetIndex(3) + 1 );
else
sourceImageRegion.SetSize( 3, 1 );
sourceImageRegion.SetIndex( 4, 0 );
sourceImageRegion.SetSize( 4, 1 );
source->SetRequestedRegion( &sourceImageRegion );
}
diff --git a/Modules/MitkExt/Algorithms/mitkSimpleHistogram.cpp b/Modules/MitkExt/Algorithms/mitkSimpleHistogram.cpp
index 564d395010..9ce9c0b662 100644
--- a/Modules/MitkExt/Algorithms/mitkSimpleHistogram.cpp
+++ b/Modules/MitkExt/Algorithms/mitkSimpleHistogram.cpp
@@ -1,246 +1,246 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSimpleHistogram.h"
#include "mitkSimpleUnstructuredGridHistogram.h"
#include "mitkUnstructuredGrid.h"
namespace mitk {
void SimpleImageHistogram::ComputeFromBaseData( BaseData* src )
{
valid = false;
//check if input is valid
if (src==NULL) return;
Image* source = dynamic_cast<Image*>(src);
if (source==NULL) return;
else if (source->IsEmpty()) return;
// dummy histogram
{
min=0;
max=1;
first=0;
last=1;
}
{
int typInt=0;
{
- const std::type_info& typ=source->GetPixelType().GetTypeId();
- if (typ == typeid(unsigned char )) typInt=0;
- else if(typ == typeid(signed char )) typInt=1;
- else if(typ == typeid(unsigned short)) typInt=2;
- else if(typ == typeid(signed short )) typInt=3;
+ const int typ=source->GetPixelType().GetComponentType();
+ if (typ == itk::ImageIOBase::UCHAR) typInt=0;
+ else if(typ == itk::ImageIOBase::CHAR) typInt=1;
+ else if(typ == itk::ImageIOBase::USHORT) typInt=2;
+ else if(typ == itk::ImageIOBase::SHORT) typInt=3;
else
{
MITK_WARN << "SimpleImageHistogram currently only supports un/signed char/short";
return;
}
}
first=-32768; last=65535; // support at least full signed and unsigned short range
if(histogram)
delete histogram;
histogram = new CountType[last-first+1];
memset(histogram,0,sizeof(CountType)*(last-first+1));
highest = 0;
max = first - 1;
min = last + 1;
unsigned int num=1;
for(unsigned int r=0;r<source->GetDimension();r++)
num*=source->GetDimension(r);
// MITK_INFO << "building histogramm of integer image: 0=" << source->GetDimension(0) << " 1=" << source->GetDimension(1) << " 2=" << source->GetDimension(2) << " 3=" << source->GetDimension(3);
void *src=source->GetData();
do
{
int value;
switch(typInt)
{
case 0: { unsigned char *t=(unsigned char *)src; value=*t++; src=(void*)t; } break;
case 1: { signed char *t=( signed char *)src; value=*t++; src=(void*)t; } break;
case 2: { unsigned short *t=(unsigned short*)src; value=*t++; src=(void*)t; } break;
case 3: { signed short *t=( signed short*)src; value=*t++; src=(void*)t; } break;
}
if(value >= first && value <= last)
{
if(value < min) min = value;
if(value > max) max = value;
CountType tmp = ++histogram[value-first];
if(tmp > highest) highest = tmp;
}
}
while(--num);
MITK_INFO << "histogramm computed: min=" << min << " max=" << max << " highestBin=" << highest << " samples=" << num;
}
invLogHighest = 1.0/log(double(highest));
valid = true;
}
bool SimpleImageHistogram::GetValid()
{
return valid;
}
float SimpleImageHistogram::GetRelativeBin( double left, double right ) const
{
if( !valid )
return 0.0f;
int iLeft = floorf(left);
int iRight = ceilf(right);
/*
double sum = 0;
for( int r = 0 ; r < 256 ; r++)
{
int pos = left + (right-left) * r/255.0;
int posInArray = floorf(pos+0.5f) - first;
sum += float(log(double(histogram[posInArray])));
}
sum /= 256.0;
return float(sum*invLogHighest);
*/
CountType maximum = 0;
for( int i = iLeft; i <= iRight ; i++)
{
int posInArray = i - first;
if( histogram[posInArray] > maximum ) maximum = histogram[posInArray];
}
return float(log(double(maximum))*invLogHighest);
}
class ImageHistogramCacheElement : public SimpleHistogramCache::Element
{
public:
void ComputeFromBaseData(BaseData* baseData)
{
histogram.ComputeFromBaseData(baseData);
}
SimpleHistogram* GetHistogram()
{
return &histogram;
}
SimpleImageHistogram histogram;
};
class UnstructuredGridHistogramCacheElement : public SimpleHistogramCache::Element
{
public:
void ComputeFromBaseData(BaseData* baseData)
{
histogram.ComputeFromBaseData(baseData);
}
SimpleHistogram* GetHistogram()
{
return &histogram;
}
SimpleUnstructuredGridHistogram histogram;
};
SimpleHistogram* SimpleHistogramCache::operator[](BaseData::Pointer sp_BaseData)
{
BaseData *p_BaseData = sp_BaseData.GetPointer();
if(!p_BaseData)
{
MITK_WARN << "SimpleHistogramCache::operator[] with null base data called";
return 0;
}
Element *elementToUpdate = 0;
bool first = true;
for(CacheContainer::iterator iter = cache.begin(); iter != cache.end(); iter++)
{
Element *e = *iter;
BaseData *p_tmp = e->baseData.GetPointer();
if(p_tmp == p_BaseData)
{
if(!first)
{
cache.erase(iter);
cache.push_front(e);
}
if( p_BaseData->GetMTime() > e->m_LastUpdateTime.GetMTime())
{
elementToUpdate = e;
goto recomputeElement;
}
//MITK_INFO << "using a cached histogram";
return e->GetHistogram();
}
first = false;
}
if (dynamic_cast<Image*>(p_BaseData))
{
elementToUpdate = new ImageHistogramCacheElement();
}
else if (dynamic_cast<UnstructuredGrid*>(p_BaseData))
{
elementToUpdate = new UnstructuredGridHistogramCacheElement();
}
else
{
MITK_WARN << "not supported: " << p_BaseData->GetNameOfClass();
}
elementToUpdate->baseData = p_BaseData;
cache.push_front(elementToUpdate);
TrimCache();
recomputeElement:
//MITK_INFO << "computing a new histogram";
elementToUpdate->ComputeFromBaseData(p_BaseData);
elementToUpdate->m_LastUpdateTime.Modified();
return elementToUpdate->GetHistogram();
}
}
diff --git a/Modules/MitkExt/Algorithms/mitkSimpleUnstructuredGridHistogram.cpp b/Modules/MitkExt/Algorithms/mitkSimpleUnstructuredGridHistogram.cpp
index 0092db7b8f..477cb374a9 100644
--- a/Modules/MitkExt/Algorithms/mitkSimpleUnstructuredGridHistogram.cpp
+++ b/Modules/MitkExt/Algorithms/mitkSimpleUnstructuredGridHistogram.cpp
@@ -1,157 +1,163 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSimpleUnstructuredGridHistogram.h"
#include <mitkUnstructuredGrid.h>
-#include <itkListSampleToHistogramFilter.h>
+#include <itkSampleToHistogramFilter.h>
#include <vtkDataArray.h>
#include <vtkPointData.h>
#include <vtkUnstructuredGrid.h>
namespace mitk {
SimpleUnstructuredGridHistogram::SimpleUnstructuredGridHistogram()
: m_UGHistogram(HistogramType::New()), m_InvMaxFrequency(1)
{
//MITK_INFO << "####### Created a SimpleUnstructuredGridHistogram";
}
double SimpleUnstructuredGridHistogram::GetMin() const
{
return m_UGHistogram->GetBinMin(0, 0);
}
double SimpleUnstructuredGridHistogram::GetMax() const
{
return m_UGHistogram->GetBinMax(0, m_UGHistogram->GetSize(0)-1);
}
void SimpleUnstructuredGridHistogram::ComputeFromBaseData( BaseData* source )
{
UnstructuredGrid* grid = dynamic_cast<UnstructuredGrid*>(source);
//m_UGHistogram->Initialize(grid);
vtkUnstructuredGrid* vtkUGrid = grid->GetVtkUnstructuredGrid();
ListSampleType::Pointer listSample = ListSampleType::New();
listSample->SetMeasurementVectorSize(1);
MeasurementVectorType v;
MeasurementVectorType lowerBound;
MeasurementVectorType upperBound;
int numberOfBins = 1;
HistogramType::SizeType size;
vtkDataArray* data;
/*if (m_UsePointData)*/ data = vtkUGrid->GetPointData()->GetScalars();
//else data = vtkUGrid->GetCellData()->GetScalars();
if (data == 0)
{
listSample->Resize(1);
v[0] = 0;
listSample->PushBack(v);
lowerBound[0] = 0;
upperBound[0] = 0;
size.Fill(numberOfBins);
}
else
{
listSample->Resize(data->GetNumberOfTuples());
for (vtkIdType i = 0; i < data->GetNumberOfTuples(); ++i)
{
v[0] = data->GetComponent(i, 0);
//if (v[0] != 0) MITK_INFO << "ug scalar: " << v[0];
listSample->PushBack(v);
}
vtkIdType numberOfTuples = data->GetNumberOfTuples();
if (numberOfTuples < 1000)
numberOfBins = 250;
else if (numberOfTuples < 30000)
numberOfBins = 100;
else if (numberOfTuples < 100000)
numberOfBins = 50;
else
numberOfBins = 20;
size.Fill(numberOfBins);
double range[2];
data->GetRange(range);
lowerBound[0] = range[0];
upperBound[0] = range[1];
}
- m_UGHistogram->Initialize(size, lowerBound, upperBound);
-
- typedef itk::Statistics::ListSampleToHistogramFilter<ListSampleType, HistogramType> FilterType;
+ typedef itk::Statistics::SampleToHistogramFilter<ListSampleType, HistogramType> FilterType;
FilterType::Pointer histoFilter = FilterType::New();
- histoFilter->SetListSample(listSample);
- histoFilter->SetHistogram(m_UGHistogram);
+ FilterType::HistogramMeasurementVectorType binMin;
+ FilterType::HistogramMeasurementVectorType binMax;
+
+ binMin[0] = lowerBound[0];
+ binMax[0] = upperBound[0];
+
+ histoFilter->SetInput(listSample);
+ histoFilter->SetHistogramSize(size);
+ histoFilter->SetHistogramBinMinimum(binMin);
+ histoFilter->SetHistogramBinMaximum(binMax);
histoFilter->Update();
+ m_UGHistogram = histoFilter->GetOutput()->Clone();
+
m_BinSize = (GetMax() - GetMin())/(double)numberOfBins;
m_Mins = m_UGHistogram->GetMins();
m_Maxs = m_UGHistogram->GetMaxs();
- HistogramType::FrequencyType maxFrequency = 0;
+ HistogramType::AbsoluteFrequencyType maxFrequency = 0;
HistogramType::SizeValueType histoSize = m_UGHistogram->GetSize(0);
for (HistogramType::SizeValueType i = 0; i < histoSize; ++i)
{
- HistogramType::FrequencyType f = m_UGHistogram->GetFrequency(i);
+ HistogramType::AbsoluteFrequencyType f = m_UGHistogram->GetFrequency(i);
if (f > maxFrequency)
{
maxFrequency = f;
}
//MITK_INFO << "Bin #" << i << ": " << m_UGHistogram->GetMeasurement(i,0);
}
if (maxFrequency)
{
m_InvMaxFrequency = 1.0/log((double)maxFrequency);
}
//MITK_INFO << "UGHistogramm size: " << m_UGHistogram->GetSize(0) << ", maxF: " << maxFrequency
// << " min count: " << m_Mins.size() << " max count: " << m_Maxs.size();
}
float SimpleUnstructuredGridHistogram::GetRelativeBin( double start, double end ) const
{
//MITK_INFO << "GetRelativeBin start: " << start << ", end: " << end;
- HistogramType::FrequencyType maxf = 0;
- MeasurementVectorType v;
+ HistogramType::AbsoluteFrequencyType maxf = 0;
for(double pos = start; pos < end; pos += m_BinSize)
{
- v[0] = pos;
- HistogramType::FrequencyType f = m_UGHistogram->GetFrequency(m_UGHistogram->GetIndex(v));
+ HistogramType::AbsoluteFrequencyType f = m_UGHistogram->GetFrequency(m_UGHistogram->GetIndex(pos));
if (f > maxf) maxf = f;
}
- return log(maxf)*m_InvMaxFrequency;
+ return log(static_cast<double>(maxf))*m_InvMaxFrequency;
}
}
diff --git a/Modules/MitkExt/Algorithms/mitkSimpleUnstructuredGridHistogram.h b/Modules/MitkExt/Algorithms/mitkSimpleUnstructuredGridHistogram.h
index 1311f9abc9..82e072db95 100644
--- a/Modules/MitkExt/Algorithms/mitkSimpleUnstructuredGridHistogram.h
+++ b/Modules/MitkExt/Algorithms/mitkSimpleUnstructuredGridHistogram.h
@@ -1,62 +1,62 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKSIMPLEUNSTRUCTUREDGRIDHISTOGRAM_H
#define MITKSIMPLEUNSTRUCTUREDGRIDHISTOGRAM_H
#include <MitkExtExports.h>
#include "mitkSimpleHistogram.h"
//#include "mitkUnstructuredGridHistogram.h"
#include <itkListSample.h>
namespace mitk {
class MitkExt_EXPORT SimpleUnstructuredGridHistogram : public SimpleHistogram
{
public:
SimpleUnstructuredGridHistogram();
virtual double GetMin() const;
virtual double GetMax() const;
virtual void ComputeFromBaseData( BaseData* source );
virtual float GetRelativeBin( double start, double end ) const;
private:
typedef double MeasurementType;
typedef itk::Vector<MeasurementType, 1> MeasurementVectorType;
typedef itk::Statistics::ListSample<MeasurementVectorType> ListSampleType;
- typedef itk::Statistics::Histogram<MeasurementType, 1> HistogramType;
+ typedef itk::Statistics::Histogram<MeasurementType> HistogramType;
HistogramType::Pointer m_UGHistogram;
//UnstructuredGridHistogram::Pointer m_UGHistogram;
HistogramType::BinMinContainerType m_Mins;
HistogramType::BinMaxContainerType m_Maxs;
double m_InvMaxFrequency;
double m_BinSize;
};
}
#endif // MITKSIMPLEUNSTRUCTUREDGRIDHISTOGRAM_H
diff --git a/Modules/MitkExt/Algorithms/mitkSurfaceToImageFilter.h b/Modules/MitkExt/Algorithms/mitkSurfaceToImageFilter.h
index 591ac897ee..43860bfeeb 100644
--- a/Modules/MitkExt/Algorithms/mitkSurfaceToImageFilter.h
+++ b/Modules/MitkExt/Algorithms/mitkSurfaceToImageFilter.h
@@ -1,96 +1,97 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _mitkSurfaceToImageFilter_h__
#define _mitkSurfaceToImageFilter_h__
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkImageSource.h"
#include "mitkSurface.h"
//#include "mitkImage.h"
class vtkPolyData;
namespace mitk {
//class Mesh;
//class VectorOfContourLines;
/**
*
* @brief Converts surface data to pixel data. Requires a surface and an
* image, which header information defines the output image.
*
* The resulting image has the same dimension, size, and Geometry3D
* as the input image. The image is cut using a vtkStencil.
* The user can decide if he wants to keep the original values or create a
* binary image by setting MakeBinaryOutputOn (default is \a false). If
* set to \a true all voxels inside the surface are set to one and all
* outside voxel are set to zero.
*
* NOTE: Since the reference input image is passed to the vtkStencil in
* any case, the image needs to be initialized with pixel values greater than
* the numerical minimum of the used pixel type (e.g. at least -127 for
* unsigned char images, etc.) to produce a correct binary image
* representation of the surface in MakeOutputBinary mode.
*
* @ingroup SurfaceFilters
* @ingroup Process
*/
class MitkExt_EXPORT SurfaceToImageFilter : public ImageSource
{
public:
mitkClassMacro(SurfaceToImageFilter, ImageSource);
itkNewMacro(Self);
itkSetMacro(MakeOutputBinary, bool);
itkGetMacro(MakeOutputBinary, bool);
itkBooleanMacro(MakeOutputBinary);
itkGetConstMacro(BackgroundValue,float);
itkSetMacro(BackgroundValue,float);
virtual void GenerateInputRequestedRegion();
virtual void GenerateOutputInformation();
virtual void GenerateData();
const mitk::Surface *GetInput(void);
+ using itk::ProcessObject::SetInput;
virtual void SetInput(const mitk::Surface *surface);
void SetImage(const mitk::Image *source);
const mitk::Image *GetImage(void);
protected:
SurfaceToImageFilter();
virtual ~SurfaceToImageFilter();
void Stencil3DImage(int time = 0);
bool m_MakeOutputBinary;
float m_BackgroundValue;
};
} // namespace mitk
#endif /* MITKCOONSPATCHFILTER_H_HEADER_INCLUDED_C10B22CD */
diff --git a/Modules/MitkExt/Algorithms/mitkUnstructuredGridSource.cpp b/Modules/MitkExt/Algorithms/mitkUnstructuredGridSource.cpp
index 7fcd0a9f30..3c722fea67 100644
--- a/Modules/MitkExt/Algorithms/mitkUnstructuredGridSource.cpp
+++ b/Modules/MitkExt/Algorithms/mitkUnstructuredGridSource.cpp
@@ -1,91 +1,48 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkUnstructuredGridSource.h"
#include "mitkUnstructuredGrid.h"
mitk::UnstructuredGridSource::UnstructuredGridSource()
{
- // Create the output. We use static_cast<> here because we know the default
- // output must be of type UnstructuredGrid
- mitk::UnstructuredGrid::Pointer output
- = static_cast<mitk::UnstructuredGrid*>(this->MakeOutput(0).GetPointer());
-
+ // Create the output.
+ itk::DataObject::Pointer output = this->MakeOutput(0);
Superclass::SetNumberOfRequiredOutputs(1);
- Superclass::SetNthOutput(0, output.GetPointer());
+ Superclass::SetNthOutput(0, output);
}
mitk::UnstructuredGridSource::~UnstructuredGridSource()
{
}
-mitk::UnstructuredGridSource::DataObjectPointer mitk::UnstructuredGridSource::MakeOutput(unsigned int /*idx*/)
-{
- return static_cast<itk::DataObject*>(mitk::UnstructuredGrid::New().GetPointer());
-}
-
-
-mitk::UnstructuredGrid* mitk::UnstructuredGridSource::GetOutput()
-{
- if (this->GetNumberOfOutputs() < 1)
- {
- return 0;
- }
-
- return static_cast<mitk::UnstructuredGrid*>
- (this->BaseProcess::GetOutput(0));
-}
-
-mitk::UnstructuredGrid* mitk::UnstructuredGridSource::GetOutput(unsigned int idx)
-{
- return static_cast<mitk::UnstructuredGrid*>
- (this->ProcessObject::GetOutput(idx));
-}
-
-void mitk::UnstructuredGridSource::SetOutput(mitk::UnstructuredGrid* output)
-{
- itkWarningMacro(<< "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead." );
- BaseProcess::SetNthOutput(0, output);
-}
-
-void mitk::UnstructuredGridSource::GraftOutput(mitk::UnstructuredGrid* graft)
+itk::DataObject::Pointer mitk::UnstructuredGridSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
- this->GraftNthOutput(0, graft);
+ return OutputType::New().GetPointer();
}
-void mitk::UnstructuredGridSource::GraftNthOutput(unsigned int idx, mitk::UnstructuredGrid *graft)
+itk::DataObject::Pointer mitk::UnstructuredGridSource::MakeOutput( const DataObjectIdentifierType & name )
{
- if (idx < this->GetNumberOfOutputs())
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
{
- mitk::UnstructuredGrid * output = this->GetOutput(idx);
-
- if (output && graft)
- {
- // grab a handle to the bulk data of the specified data object
- // output->SetPixelContainer( graft->GetPixelContainer() ); @FIXME!!!!
-
- // copy the region ivars of the specified data object
- output->SetRequestedRegion( graft );//graft->GetRequestedRegion() );
- // output->SetLargestPossibleRegion( graft->GetLargestPossibleRegion() ); @FIXME!!!!
- // output->SetBufferedRegion( graft->GetBufferedRegion() ); @FIXME!!!!
-
- // copy the meta-information
- output->CopyInformation( graft );
- }
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
}
+ return static_cast<itk::DataObject *>(OutputType::New().GetPointer());
}
+mitkBaseDataSourceGetOutputDefinitions(mitk::UnstructuredGridSource)
diff --git a/Modules/MitkExt/Algorithms/mitkUnstructuredGridSource.h b/Modules/MitkExt/Algorithms/mitkUnstructuredGridSource.h
index a3cc9a3d80..2ec3768c8b 100644
--- a/Modules/MitkExt/Algorithms/mitkUnstructuredGridSource.h
+++ b/Modules/MitkExt/Algorithms/mitkUnstructuredGridSource.h
@@ -1,68 +1,73 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_UNSTRUCTURED_GRID_DATA_SOURCE_H_HEADER_
#define _MITK_UNSTRUCTURED_GRID_DATA_SOURCE_H_HEADER_
-#include "mitkBaseProcess.h"
+#include "mitkBaseDataSource.h"
#include "MitkExtExports.h"
namespace mitk {
class UnstructuredGrid;
//##Documentation
//## @brief Superclass of all classes generating unstructured grids (instances of class
//## UnstructuredGrid) as output.
//##
//## In itk and vtk the generated result of a ProcessObject is only guaranteed
//## to be up-to-date, when Update() of the ProcessObject or the generated
//## DataObject is called immediately before access of the data stored in the
//## DataObject. This is also true for subclasses of mitk::BaseProcess and thus
//## for mitk::UnstructuredGridSource.
//## @ingroup Process
-class MitkExt_EXPORT UnstructuredGridSource : public BaseProcess
+class MitkExt_EXPORT UnstructuredGridSource : public BaseDataSource
{
public:
- mitkClassMacro(UnstructuredGridSource, BaseProcess);
- itkNewMacro(Self);
+ mitkClassMacro(UnstructuredGridSource, BaseDataSource)
+ itkNewMacro(Self)
- typedef itk::DataObject::Pointer DataObjectPointer;
+ typedef mitk::UnstructuredGrid OutputType;
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+ mitkBaseDataSourceGetOutputDeclarations
+ /**
+ * Allocates a new output object and returns it. Currently the
+ * index idx is not evaluated.
+ * @param idx the index of the output for which an object should be created
+ * @returns the new object
+ */
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
- void SetOutput(mitk::UnstructuredGrid* output);
-
- mitk::UnstructuredGrid* GetOutput();
-
- mitk::UnstructuredGrid* GetOutput(unsigned int idx);
-
- virtual void GraftOutput(mitk::UnstructuredGrid* graft);
-
- virtual void GraftNthOutput(unsigned int idx, mitk::UnstructuredGrid *graft);
+ /**
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
+ */
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
protected:
UnstructuredGridSource();
virtual ~UnstructuredGridSource();
};
} // namespace mitk
#endif /* _MITK_UNSTRUCTURED_GRID_DATA_SOURCE_H_HEADER_ */
diff --git a/Modules/MitkExt/DataManagement/itkAffineGeometryFrame.h.dox b/Modules/MitkExt/DataManagement/itkAffineGeometryFrame.h.dox
index 883893b4cc..53ef0adfbf 100644
--- a/Modules/MitkExt/DataManagement/itkAffineGeometryFrame.h.dox
+++ b/Modules/MitkExt/DataManagement/itkAffineGeometryFrame.h.dox
@@ -1,129 +1,126 @@
// copied here for documentation purposes
#ifdef DOXYGEN_SKIP
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkAffineGeometryFrame.h,v $
Language: C++
Date: $Date$
Version: $Revision: 1.7 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
- This software is distributed WITHOUT ANY WARRANTY; without even
- the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ 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 __itkAffineGeometryFrame_h
#define __itkAffineGeometryFrame_h
#include "itkObject.h"
#include "itkMacro.h"
#include "itkScalableAffineTransform.h"
#include "itkBoundingBox.h"
-namespace itk
+namespace itk
{
/** \class AffineGeometryFrame
- * \brief Describes the geometry of a data object
+ * \brief Describes the geometry of a data object
*/
template <class TScalarType = double, unsigned int NDimensions = 3>
class AffineGeometryFrame : public itk::Object
{
public:
typedef AffineGeometryFrame Self;
typedef itk::Object Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ScalableAffineTransform<TScalarType, NDimensions> TransformType;
typedef BoundingBox<unsigned long, NDimensions, TScalarType> BoundingBoxType;
typedef typename BoundingBoxType::BoundsArrayType BoundsArrayType;
typedef typename BoundingBoxType::Pointer BoundingBoxPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \brief Method for creation through the object factory. */
itkTypeMacro(AffineGeometryFrame, Object);
/** \brief Get the bounding box */
itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
-
+
const BoundsArrayType GetBounds() const
{
assert(m_BoundingBox.IsNotNull());
return m_BoundingBox->GetBounds();
}
- /** \brief Set the bounding box Only possible via the BoundsArray
- * to make clear that a copy of the bounding-box is stored,
+ /** \brief Set the bounding box Only possible via the BoundsArray
+ * to make clear that a copy of the bounding-box is stored,
* not a reference to it.*/
virtual void SetBounds(const BoundsArrayType& bounds);
/** \brief Get the extent of the bounding box */
TScalarType GetExtent(unsigned int direction) const
{
assert(direction<NDimensions);
assert(m_BoundingBox.IsNotNull());
BoundsArrayType bounds = m_BoundingBox->GetBounds();
return bounds[direction*2+1]-bounds[direction*2];
}
/** \brief Set/Get the IndexToObjectTransform */
itkGetConstObjectMacro(IndexToObjectTransform, TransformType);
itkGetObjectMacro(IndexToObjectTransform, TransformType);
itkSetObjectMacro(IndexToObjectTransform, TransformType);
-
+
/** \brief Set/Get the ObjectToNodeTransform */
itkGetConstObjectMacro(ObjectToNodeTransform, TransformType);
itkGetObjectMacro(ObjectToNodeTransform, TransformType);
itkSetObjectMacro(ObjectToNodeTransform, TransformType);
/** \brief Set/Get the IndexToWorldTransform */
itkGetConstObjectMacro(IndexToWorldTransform, TransformType);
itkGetObjectMacro(IndexToWorldTransform, TransformType);
itkSetObjectMacro(IndexToWorldTransform, TransformType);
- /** \brief Get the IndexToNodeTransform
+ /** \brief Get the IndexToNodeTransform
* This Transform cannot be set, and is just computed internally */
itkGetConstObjectMacro(IndexToNodeTransform, TransformType);
-
+
/** \brief Initialize the geometry frame */
virtual void Initialize();
- /** Clone the geometry frame */
- virtual Pointer Clone() const;
-
protected:
AffineGeometryFrame();
virtual ~AffineGeometryFrame();
/** \brief used in clone to initialize the newly created geometry */
virtual void InitializeGeometry(Self * newGeometry) const;
- void SetBoundsArray(const BoundsArrayType& bounds,
+ void SetBoundsArray(const BoundsArrayType& bounds,
BoundingBoxPointer& boundingBox);
mutable BoundingBoxPointer m_BoundingBox;
/** \brief Transform from unit coordinates to object coordinates */
typename TransformType::Pointer m_IndexToObjectTransform;
typename TransformType::Pointer m_ObjectToNodeTransform;
typename TransformType::Pointer m_IndexToNodeTransform;
typename TransformType::Pointer m_IndexToWorldTransform;
-
+
private:
AffineGeometryFrame(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
} // namespace itk
#endif /* __itkAffineGeometryFrame_h */
-#endif
\ No newline at end of file
+#endif
diff --git a/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp b/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp
index ef0d53c989..83584911da 100644
--- a/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp
+++ b/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp
@@ -1,214 +1,212 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBoundingObjectGroup.h"
#include "mitkBaseProcess.h"
#include <vtkLinearTransform.h>
-#include <itkSmartPointerForwardReference.txx>
-
mitk::BoundingObjectGroup::BoundingObjectGroup()
:m_BoundingObjects(0),
m_Counter(0),
m_CSGMode(Union)// m_CSGMode(Difference) //m_CSGMode(Intersection)
{
GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
GetGeometry(0)->SetIndexToWorldTransform(GetTimeSlicedGeometry()->GetIndexToWorldTransform());
SetVtkPolyData(NULL);
}
mitk::BoundingObjectGroup::~BoundingObjectGroup()
{
}
void mitk::BoundingObjectGroup::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
// calculate global bounding box
if(m_BoundingObjects.size() < 1 ) // if there is no BoundingObject, the bounding box is zero
{
mitk::BoundingBox::BoundsArrayType boundsArray;
boundsArray.Fill(0);
GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
GetGeometry()->SetBounds(boundsArray);
GetTimeSlicedGeometry()->UpdateInformation();
return;
}
// initialize container
mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
mitk::BoundingBox::PointIdentifier pointid=0;
mitk::Point3D point;
mitk::AffineTransform3D* transform = GetTimeSlicedGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
transform->GetInverse(inverse);
// calculate a bounding box that includes all BoundingObjects
// \todo probably we should do this additionally for each time-step
//while (boundingObjectsIterator != boundingObjectsIteratorEnd)
for(unsigned int j = 0; j<m_BoundingObjects.size();j++)
{
const Geometry3D* geometry = m_BoundingObjects.at(j)->GetUpdatedTimeSlicedGeometry();
unsigned char i;
for(i=0; i<8; ++i)
{
point = inverse->TransformPoint(geometry->GetCornerPoint(i));
if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < mitk::large)
pointscontainer->InsertElement( pointid++, point);
else
{
itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. BoundingObject: " << m_BoundingObjects.at(j) );
}
}
}
mitk::BoundingBox::Pointer boundingBox = mitk::BoundingBox::New();
boundingBox->SetPoints(pointscontainer);
boundingBox->ComputeBoundingBox();
/* BoundingBox is centered around the center of all sub bounding objects */
//Point3D center = boundingBox->GetCenter();
//Point3D minimum, maximum;
//minimum.Fill(0); maximum.Fill(0);
//minimum += boundingBox->GetMinimum() - center;
//maximum += boundingBox->GetMaximum() - center;
//boundingBox->SetMinimum(minimum);
//boundingBox->SetMaximum(maximum);
Geometry3D* geometry3d = GetGeometry(0);
geometry3d->SetIndexToWorldTransform(transform);
geometry3d->SetBounds(boundingBox->GetBounds());
/* the objects position is the center of all sub bounding objects */
//geometry3d->SetOrigin(center);
GetTimeSlicedGeometry()->InitializeEvenlyTimed(geometry3d, GetTimeSlicedGeometry()->GetTimeSteps());
}
void mitk::BoundingObjectGroup::AddBoundingObject(mitk::BoundingObject::Pointer boundingObject)
{
if (boundingObject->GetPositive())
m_BoundingObjects.push_front(boundingObject);
else
m_BoundingObjects.push_back(boundingObject);
++m_Counter;
UpdateOutputInformation();
}
void mitk::BoundingObjectGroup::RemoveBoundingObject(mitk::BoundingObject::Pointer boundingObject)
{
std::deque<mitk::BoundingObject::Pointer>::iterator it = m_BoundingObjects.begin();
for (unsigned int i=0 ; i<m_BoundingObjects.size();i++)
{
if (m_BoundingObjects.at(i) == boundingObject)
m_BoundingObjects.erase(it);
++it;
}
--m_Counter;
UpdateOutputInformation();
}
bool mitk::BoundingObjectGroup::IsInside(const mitk::Point3D& p) const
{
bool inside = false; // initialize with true for intersection, with false for union
bool posInside = false;
bool negInside = false;
for (unsigned int i = 0; i<m_BoundingObjects.size();i++)
{
switch(m_CSGMode)
{
case Intersection:
inside = true;
// calculate intersection: each point, that is inside each BoundingObject is considered inside the group
inside = m_BoundingObjects.at(i)->IsInside(p) && inside;
if (!inside) // shortcut, it is enough to find one object that does not contain the point
i=m_BoundingObjects.size();
break;
case Union:
case Difference:
posInside = false;
negInside = false;
// calculate union: each point, that is inside least one BoundingObject is considered inside the group
if (m_BoundingObjects.at(i)->GetPositive())
posInside = m_BoundingObjects.at(i)->IsInside(p) || posInside;
else
negInside = m_BoundingObjects.at(i)->IsInside(p) || negInside;
if (posInside && !negInside)
inside = true;
else
inside = false;
break;
default:
inside = false;
// calculate union: each point, that is inside least one BoundingObject is considered inside the group
inside = m_BoundingObjects.at(i)->IsInside(p) || inside;
if (inside) // shortcut, it is enough to find one object that contains the point
i=m_BoundingObjects.size();
break;
}
}
return inside;
}
unsigned int mitk::BoundingObjectGroup::GetCount() const
{
return m_Counter;
}
bool mitk::BoundingObjectGroup::VerifyRequestedRegion()
{
return m_Counter > 0;
}
mitk::Geometry3D * mitk::BoundingObjectGroup::GetGeometry (int t) const
{
//if ( m_BoundingObjects == NULL )
return Superclass::GetGeometry(t);
//mitk::BoundingObjectGroup::BoundingObjectContainer::ConstIterator boI = m_BoundingObjects->Begin();
//const mitk::BoundingObjectGroup::BoundingObjectContainer::ConstIterator boIEnd = m_BoundingObjects->End();
//mitk::Geometry3D* currentGeometry = NULL;
//while ( boI != boIEnd )
//{
// currentGeometry = boI.Value()->GetGeometry( t );
// boI++;
//}
//return currentGeometry;
}
void mitk::BoundingObjectGroup::SetBoundingObjects(const std::deque<mitk::BoundingObject::Pointer> boundingObjects)
{
m_BoundingObjects = boundingObjects;
}
std::deque<mitk::BoundingObject::Pointer> mitk::BoundingObjectGroup::GetBoundingObjects()
{
return m_BoundingObjects;
}
diff --git a/Modules/MitkExt/DataManagement/mitkCompressedImageContainer.cpp b/Modules/MitkExt/DataManagement/mitkCompressedImageContainer.cpp
index c6620cb64a..dcb43ab4a9 100644
--- a/Modules/MitkExt/DataManagement/mitkCompressedImageContainer.cpp
+++ b/Modules/MitkExt/DataManagement/mitkCompressedImageContainer.cpp
@@ -1,180 +1,179 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkCompressedImageContainer.h"
-#include "itkSmartPointerForwardReference.txx"
#include "itk_zlib.h"
#include <stdlib.h>
mitk::CompressedImageContainer::CompressedImageContainer()
: m_PixelType(NULL)
{
}
mitk::CompressedImageContainer::~CompressedImageContainer()
{
for (std::vector< std::pair<unsigned char*, unsigned long> >::iterator iter = m_ByteBuffers.begin();
iter != m_ByteBuffers.end();
++iter)
{
free( iter->first );
}
}
void mitk::CompressedImageContainer::SetImage( Image* image )
{
for (std::vector< std::pair<unsigned char*, unsigned long> >::iterator iter = m_ByteBuffers.begin();
iter != m_ByteBuffers.end();
++iter)
{
free( iter->first );
}
m_ByteBuffers.clear();
// Compress diff image using zlib (will be restored on demand)
// determine memory size occupied by voxel data
m_ImageDimension = image->GetDimension();
m_ImageDimensions.clear();
m_PixelType = new mitk::PixelType( image->GetPixelType());
m_OneTimeStepImageSizeInBytes = m_PixelType->GetSize(); // bits per element divided by 8
for (unsigned int i = 0; i < m_ImageDimension; ++i)
{
unsigned int currentImageDimension = image->GetDimension(i);
m_ImageDimensions.push_back( currentImageDimension );
if (i < 3)
{
m_OneTimeStepImageSizeInBytes *= currentImageDimension; // only the 3D memory size
}
}
m_ImageGeometry = image->GetGeometry();
m_NumberOfTimeSteps = 1;
if (m_ImageDimension > 3)
{
m_NumberOfTimeSteps = image->GetDimension(3);
}
for (unsigned int timestep = 0; timestep < m_NumberOfTimeSteps; ++timestep)
{
// allocate a buffer as specified by zlib
unsigned long bufferSize = m_OneTimeStepImageSizeInBytes + static_cast<unsigned long>(m_OneTimeStepImageSizeInBytes * 0.2) + 12;
unsigned char* byteBuffer = (unsigned char*) malloc(bufferSize);
if (itk::Object::GetDebug())
{
// compress image here into a buffer
MITK_INFO << "Using ZLib version: '" << zlibVersion() << "'" << std::endl
<< "Attempting to compress " << m_OneTimeStepImageSizeInBytes << " image bytes into a buffer of size " << bufferSize << std::endl;
}
::Bytef* dest(byteBuffer);
::uLongf destLen(bufferSize);
::Bytef* source( static_cast<unsigned char*>(image->GetVolumeData(timestep)->GetData()) );
::uLongf sourceLen( m_OneTimeStepImageSizeInBytes );
int zlibRetVal = ::compress(dest, &destLen, source, sourceLen);
if (itk::Object::GetDebug())
{
if (zlibRetVal == Z_OK)
{
MITK_INFO << "Success, using " << destLen << " bytes of the buffer (ratio " << ((double)destLen / (double)sourceLen) << ")" << std::endl;
}
else
{
switch ( zlibRetVal )
{
case Z_MEM_ERROR:
MITK_ERROR << "not enough memory" << std::endl;
break;
case Z_BUF_ERROR:
MITK_ERROR << "output buffer too small" << std::endl;
break;
default:
MITK_ERROR << "other, unspecified error" << std::endl;
break;
}
}
}
// only use the neccessary amount of memory, realloc the buffer!
byteBuffer = (unsigned char*) realloc( byteBuffer, destLen );
bufferSize = destLen;
//MITK_INFO << "Using " << bufferSize << " bytes to store compressed image (" << destLen << " needed)" << std::endl;
m_ByteBuffers.push_back( std::pair<unsigned char*, unsigned long>( byteBuffer, bufferSize ) );
}
}
mitk::Image::Pointer mitk::CompressedImageContainer::GetImage()
{
if (m_ByteBuffers.empty()) return NULL;
// uncompress image data, create an Image
Image::Pointer image = Image::New();
unsigned int dims[20]; // more than 20 dimensions and bang
for (unsigned int dim = 0; dim < m_ImageDimension; ++dim)
dims[dim] = m_ImageDimensions[dim];
image->Initialize( *m_PixelType, m_ImageDimension, dims ); // this IS needed, right ?? But it does allocate memory -> does create one big lump of memory (also in windows)
unsigned int timeStep(0);
for (std::vector< std::pair<unsigned char*, unsigned long> >::iterator iter = m_ByteBuffers.begin();
iter != m_ByteBuffers.end();
++iter, ++timeStep)
{
::Bytef* dest( static_cast<unsigned char*>(image->GetVolumeData(timeStep)->GetData()) );
::uLongf destLen(m_OneTimeStepImageSizeInBytes);
::Bytef* source( iter->first );
::uLongf sourceLen( iter->second );
int zlibRetVal = ::uncompress(dest, &destLen, source, sourceLen);
if (itk::Object::GetDebug())
{
if (zlibRetVal == Z_OK)
{
MITK_INFO << "Success, destLen now " << destLen << " bytes" << std::endl;
}
else
{
switch ( zlibRetVal )
{
case Z_DATA_ERROR:
MITK_ERROR << "compressed data corrupted" << std::endl;
break;
case Z_MEM_ERROR:
MITK_ERROR << "not enough memory" << std::endl;
break;
case Z_BUF_ERROR:
MITK_ERROR << "output buffer too small" << std::endl;
break;
default:
MITK_ERROR << "other, unspecified error" << std::endl;
break;
}
}
}
}
image->SetGeometry( m_ImageGeometry );
image->Modified();
return image;
}
diff --git a/Modules/MitkExt/DataManagement/mitkExternAbstractTransformGeometry.cpp b/Modules/MitkExt/DataManagement/mitkExternAbstractTransformGeometry.cpp
index 8bc3c2c7a3..a0dd3e6949 100644
--- a/Modules/MitkExt/DataManagement/mitkExternAbstractTransformGeometry.cpp
+++ b/Modules/MitkExt/DataManagement/mitkExternAbstractTransformGeometry.cpp
@@ -1,61 +1,61 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkExternAbstractTransformGeometry.h"
#include <vtkAbstractTransform.h>
mitk::ExternAbstractTransformGeometry::ExternAbstractTransformGeometry()
{
}
mitk::ExternAbstractTransformGeometry::ExternAbstractTransformGeometry(const ExternAbstractTransformGeometry& other) : Superclass(other)
{
}
mitk::ExternAbstractTransformGeometry::~ExternAbstractTransformGeometry()
{
}
void mitk::ExternAbstractTransformGeometry::SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform)
{
Superclass::SetVtkAbstractTransform(aVtkAbstractTransform);
}
void mitk::ExternAbstractTransformGeometry::SetPlane(const mitk::PlaneGeometry* aPlane)
{
Superclass::SetPlane(aPlane);
}
void mitk::ExternAbstractTransformGeometry::SetParametricBounds(const BoundingBox::BoundsArrayType& bounds)
{
Superclass::SetParametricBounds(bounds);
//@warning affine-transforms and bounding-box should be set by specific sub-classes!
SetBounds(bounds);
if(m_Plane.IsNotNull())
{
m_Plane->SetSizeInUnits(bounds[1]-bounds[0], bounds[3]-bounds[2]);
m_Plane->SetBounds(bounds);
}
}
-mitk::AffineGeometryFrame3D::Pointer mitk::ExternAbstractTransformGeometry::Clone() const
+itk::LightObject::Pointer mitk::ExternAbstractTransformGeometry::InternalClone() const
{
Self::Pointer newGeometry = new ExternAbstractTransformGeometry(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
diff --git a/Modules/MitkExt/DataManagement/mitkExternAbstractTransformGeometry.h b/Modules/MitkExt/DataManagement/mitkExternAbstractTransformGeometry.h
index d56305ad8a..375f2bb361 100644
--- a/Modules/MitkExt/DataManagement/mitkExternAbstractTransformGeometry.h
+++ b/Modules/MitkExt/DataManagement/mitkExternAbstractTransformGeometry.h
@@ -1,70 +1,70 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKEXTERNABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define MITKEXTERNABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkAbstractTransformGeometry.h"
namespace mitk {
//##Documentation
//## @brief Identical with AbstractTransformGeometry, except that
//## it can be externally configured.
//##
//## In contrast to its superclass (AbstractTransformGeometry), this class
//## provides write access to the vtkAbstractTransform and m_Plane.
//## @note The PlaneGeometry is cloned, @em not linked/referenced.
//## @note The bounds of the PlaneGeometry are used as the parametric bounds.
//## @sa AbstractTransformGeometry
//## @ingroup Geometry
class MitkExt_EXPORT ExternAbstractTransformGeometry : public AbstractTransformGeometry
{
public:
mitkClassMacro(ExternAbstractTransformGeometry, AbstractTransformGeometry);
itkNewMacro(Self);
//##Documentation
//## @brief Set the vtkAbstractTransform (stored in m_VtkAbstractTransform)
virtual void SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform);
//##Documentation
//## @brief Set the rectangular area that is used for transformation by
//## m_VtkAbstractTransform and therewith defines the 2D manifold described by
//## ExternAbstractTransformGeometry
//##
//## @note The bounds of the PlaneGeometry are used as the parametric bounds.
//## @note The PlaneGeometry is cloned, @em not linked/referenced.
virtual void SetPlane(const mitk::PlaneGeometry* aPlane);
virtual void SetParametricBounds(const BoundingBox::BoundsArrayType& bounds);
- virtual AffineGeometryFrame3D::Pointer Clone() const;
+ virtual itk::LightObject::Pointer InternalClone() const;
protected:
ExternAbstractTransformGeometry();
ExternAbstractTransformGeometry(const ExternAbstractTransformGeometry& other);
virtual ~ExternAbstractTransformGeometry();
};
} // namespace mitk
#endif /* MITKEXTERNABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Modules/MitkExt/DataManagement/mitkGridRepresentationProperty.cpp b/Modules/MitkExt/DataManagement/mitkGridRepresentationProperty.cpp
index f0018e2c22..e8215d37ea 100644
--- a/Modules/MitkExt/DataManagement/mitkGridRepresentationProperty.cpp
+++ b/Modules/MitkExt/DataManagement/mitkGridRepresentationProperty.cpp
@@ -1,109 +1,103 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <vtkProperty.h>
#include "mitkGridRepresentationProperty.h"
mitk::GridRepresentationProperty::GridRepresentationProperty( )
{
AddRepresentationTypes();
SetValue( WIREFRAME );
}
mitk::GridRepresentationProperty::GridRepresentationProperty(const mitk::GridRepresentationProperty& other)
: mitk::EnumerationProperty(other)
{
}
mitk::GridRepresentationProperty::GridRepresentationProperty( const IdType& value )
{
AddRepresentationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetValue( WIREFRAME );
}
}
mitk::GridRepresentationProperty::GridRepresentationProperty( const std::string& value )
{
AddRepresentationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetValue( WIREFRAME );
}
}
void mitk::GridRepresentationProperty::SetRepresentationToPoints()
{
SetValue( POINTS );
}
void mitk::GridRepresentationProperty::SetRepresentationToWireframe()
{
SetValue( WIREFRAME );
}
void mitk::GridRepresentationProperty::SetRepresentationToSurface()
{
SetValue( SURFACE );
}
void mitk::GridRepresentationProperty::SetRepresentationToWireframeSurface()
{
//SetValue( WIREFRAME_SURFACE );
}
void mitk::GridRepresentationProperty::AddRepresentationTypes()
{
AddEnum( "Points", POINTS );
AddEnum( "Wireframe", WIREFRAME );
AddEnum( "Surface", SURFACE );
//AddEnum( "WireframeSurface", WIREFRAME_SURFACE );
}
bool mitk::GridRepresentationProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
-mitk::GridRepresentationProperty::Pointer mitk::GridRepresentationProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::GridRepresentationProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Modules/MitkExt/DataManagement/mitkGridRepresentationProperty.h b/Modules/MitkExt/DataManagement/mitkGridRepresentationProperty.h
index bb89f68295..6d66d8fb12 100644
--- a/Modules/MitkExt/DataManagement/mitkGridRepresentationProperty.h
+++ b/Modules/MitkExt/DataManagement/mitkGridRepresentationProperty.h
@@ -1,114 +1,112 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_GRID_REPRESENTATION_PROPERTY__H_
#define _MITK_GRID_REPRESENTATION_PROPERTY__H_
#include "mitkEnumerationProperty.h"
#include "MitkExtExports.h"
namespace mitk
{
/**
* Extends the enumeration prop mitkEnumerationPropery. Adds the value
* (constant / Id / string representation):
* <ul>
* <li>POINTS / 0 / Points</li>
* <li>WIREFRAME / 1 / Wireframe</li>
* <li>SURFACE / 2 / Surface</li>
* <li>WIREFRAME_SURFACE / 3 / WireframeSurface</li>
* </ul>
* Default is the Wireframe representation
*/
class MitkExt_EXPORT GridRepresentationProperty : public EnumerationProperty
{
public:
enum RepresentationType {POINTS = 0, WIREFRAME = 1, SURFACE = 2}; //, WIREFRAME_SURFACE = 3};
mitkClassMacro( GridRepresentationProperty, EnumerationProperty );
itkNewMacro(GridRepresentationProperty);
mitkNewMacro1Param(GridRepresentationProperty, const IdType& );
mitkNewMacro1Param(GridRepresentationProperty, const std::string& );
- Pointer Clone() const;
-
/**
* Sets the representation type to POINTS.
*/
virtual void SetRepresentationToPoints();
/**
* Sets the representation type to WIREFRAME.
*/
virtual void SetRepresentationToWireframe();
/**
* Sets the representation type to SURFACE.
*/
virtual void SetRepresentationToSurface();
/**
* Sets the representation type to WIREFRAME_SURFACE.
*/
virtual void SetRepresentationToWireframeSurface();
protected:
/**
* Constructor. Sets the representation to a default value of Wireframe(1)
*/
GridRepresentationProperty( );
GridRepresentationProperty(const GridRepresentationProperty& other);
/**
* Constructor. Sets the representation to the given value. If it is not
* valid, the representation is set to Wireframe(1)
* @param value the integer representation of the representation
*/
GridRepresentationProperty( const IdType& value );
/**
* Constructor. Sets the representation to the given value. If it is not
* valid, the representation is set to Wireframe(1)
* @param value the string representation of the representation
*/
GridRepresentationProperty( const std::string& value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid representation types.
*/
virtual bool AddEnum( const std::string& name, const IdType& id );
/**
* Adds the enumeration types as defined by vtk to the list of known
* enumeration values.
*/
virtual void AddRepresentationTypes();
private:
virtual itk::LightObject::Pointer InternalClone() const;
};
} // end of namespace mitk
#endif // _MITK_GRID_REPRESENTATION_PROPERTY__H_
diff --git a/Modules/MitkExt/DataManagement/mitkGridVolumeMapperProperty.cpp b/Modules/MitkExt/DataManagement/mitkGridVolumeMapperProperty.cpp
index 444acf833a..588ec4c20f 100644
--- a/Modules/MitkExt/DataManagement/mitkGridVolumeMapperProperty.cpp
+++ b/Modules/MitkExt/DataManagement/mitkGridVolumeMapperProperty.cpp
@@ -1,97 +1,91 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <vtkProperty.h>
#include "mitkGridVolumeMapperProperty.h"
mitk::GridVolumeMapperProperty::GridVolumeMapperProperty( )
{
AddRepresentationTypes();
SetValue( PT );
}
mitk::GridVolumeMapperProperty::GridVolumeMapperProperty( const IdType& value )
{
AddRepresentationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetValue( PT );
}
}
mitk::GridVolumeMapperProperty::GridVolumeMapperProperty( const std::string& value )
{
AddRepresentationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetValue( PT );
}
}
void mitk::GridVolumeMapperProperty::SetVolumeMapperToPT()
{
SetValue( PT );
}
void mitk::GridVolumeMapperProperty::SetVolumeMapperToZSweep()
{
SetValue( ZSWEEP );
}
void mitk::GridVolumeMapperProperty::SetVolumeMapperToRayCast()
{
SetValue( RAYCAST );
}
void mitk::GridVolumeMapperProperty::AddRepresentationTypes()
{
AddEnum( "Ray Cast", RAYCAST );
AddEnum( "Projected Tetrahedra", PT );
AddEnum( "ZSweep", ZSWEEP );
}
bool mitk::GridVolumeMapperProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
-mitk::GridVolumeMapperProperty::Pointer mitk::GridVolumeMapperProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::GridVolumeMapperProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Modules/MitkExt/DataManagement/mitkGridVolumeMapperProperty.h b/Modules/MitkExt/DataManagement/mitkGridVolumeMapperProperty.h
index 21a9884a51..90fcd67576 100644
--- a/Modules/MitkExt/DataManagement/mitkGridVolumeMapperProperty.h
+++ b/Modules/MitkExt/DataManagement/mitkGridVolumeMapperProperty.h
@@ -1,107 +1,105 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_GRID_VOLUME_MAPPER_PROPERTY__H_
#define _MITK_GRID_VOLUME_MAPPER_PROPERTY__H_
#include "mitkEnumerationProperty.h"
#include "MitkExtExports.h"
namespace mitk
{
/**
* Extends the enumeration prop mitkEnumerationPropery. Adds the value
* (constant/Id/string representation):
* PT/0/Projected Tetrahedra, ZSWEEP/1/ZSweep, RAYCAST/2/Ray Cast
* Default is the Wireframe representation
*/
class MitkExt_EXPORT GridVolumeMapperProperty : public EnumerationProperty
{
public:
enum MapperType {
RAYCAST = 0,
PT = 1,
ZSWEEP = 2
};
mitkClassMacro( GridVolumeMapperProperty, EnumerationProperty );
itkNewMacro(GridVolumeMapperProperty);
mitkNewMacro1Param(GridVolumeMapperProperty, const IdType&);
mitkNewMacro1Param(GridVolumeMapperProperty, const std::string&);
- Pointer Clone() const;
-
/**
* Sets the mapper to projected tetrahedra.
*/
virtual void SetVolumeMapperToPT();
/**
* Sets the mapper to zsweep.
*/
virtual void SetVolumeMapperToZSweep();
/**
* Sets the mapper to ray casting.
*/
virtual void SetVolumeMapperToRayCast();
protected:
/**
* Constructor. Sets the representation to a default value of Wireframe(1)
*/
GridVolumeMapperProperty( );
/**
* Constructor. Sets the representation to the given value. If it is not
* valid, the representation is set to Wireframe(1)
* @param value the integer representation of the representation
*/
GridVolumeMapperProperty( const IdType& value );
/**
* Constructor. Sets the representation to the given value. If it is not
* valid, the representation is set to Wireframe(1)
* @param value the string representation of the representation
*/
GridVolumeMapperProperty( const std::string& value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid representation types.
*/
virtual bool AddEnum( const std::string& name, const IdType& id );
/**
* Adds the enumeration types as defined by vtk to the list of known
* enumeration values.
*/
virtual void AddRepresentationTypes();
private:
virtual itk::LightObject::Pointer InternalClone() const;
};
} // end of namespace mitk
#endif // _MITK_GRID_VOLUME_MAPPER_PROPERTY__H_
diff --git a/Modules/MitkExt/DataManagement/mitkItkBaseDataAdapter.h b/Modules/MitkExt/DataManagement/mitkItkBaseDataAdapter.h
index 7a7ca091c1..b63dad0002 100644
--- a/Modules/MitkExt/DataManagement/mitkItkBaseDataAdapter.h
+++ b/Modules/MitkExt/DataManagement/mitkItkBaseDataAdapter.h
@@ -1,56 +1,56 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBaseData.h"
#include "MitkExtExports.h"
#include <itkDataObject.h>
namespace mitk {
/**
* \brief Small class to store itk::DataObjects in the mitk::DataStorage.
*
* This class can used to store any itk::DataObject in the DataStorage.
* Please be aware that these objects cannot be visualized via mappers.
* The user of this class must care himself for type safety.
**/
class MitkExt_EXPORT ItkBaseDataAdapter : public BaseData
{
public:
mitkClassMacro(ItkBaseDataAdapter, BaseData);
itkNewMacro(Self);
/** Typedef for the data object */
typedef itk::DataObject DataType;
/** Returns the data object. **/
itkGetObjectMacro(ItkDataObject, DataType);
/** Sets the data object. **/
itkSetObjectMacro(ItkDataObject, DataType);
virtual void SetRequestedRegionToLargestPossibleRegion() {}
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() { return false; }
virtual bool VerifyRequestedRegion() { return true; }
- virtual void SetRequestedRegion(itk::DataObject*) {}
+ virtual void SetRequestedRegion( const itk::DataObject*) {}
protected:
DataType::Pointer m_ItkDataObject;
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
};
}
diff --git a/Modules/MitkExt/DataManagement/mitkLabeledImageLookupTable.cpp b/Modules/MitkExt/DataManagement/mitkLabeledImageLookupTable.cpp
index 6ced0f5170..81b15a7286 100644
--- a/Modules/MitkExt/DataManagement/mitkLabeledImageLookupTable.cpp
+++ b/Modules/MitkExt/DataManagement/mitkLabeledImageLookupTable.cpp
@@ -1,126 +1,138 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLabeledImageLookupTable.h"
#include <vtkLookupTable.h>
#include <cstdlib>
/**
* Default constructor. Protected to prevent "normal" creation
*/
mitk::LabeledImageLookupTable::LabeledImageLookupTable()
: m_LevelWindow(128,256)
{
if ( m_LookupTable == NULL )
{
itkWarningMacro("LookupTable is NULL, it should have been initialized by the default constructor of mitk::LookupTable");
m_LookupTable = vtkLookupTable::New();
}
m_LookupTable->SetNumberOfTableValues(256);
// set the background to black and fully transparent
m_LookupTable->SetTableValue( 0, 0.0, 0.0, 0.0, 0.0 );
// initialize the remaining 255 colors with random values and
// an alpha value of 1.0
vtkFloatingPointType r, g, b;
//
// Initialize the random number generator with an arbitrary seed.
// This way, the generated colors are random, but always the same...
std::srand( 2 );
for ( vtkIdType index = 1 ; index < 256 ; ++index )
{
GenerateRandomColor(r, g, b);
m_LookupTable->SetTableValue(index, r, g, b);
}
// initialize the default level/window settings,
// which can be accessed via GetLevelWindow();
m_LevelWindow.SetRangeMinMax(0,255);
m_LevelWindow.SetWindowBounds(0,255);
m_LevelWindow.SetFixed(true);
}
+mitk::LabeledImageLookupTable::LabeledImageLookupTable(const mitk::LabeledImageLookupTable &other)
+ : LookupTable(other)
+ , m_LevelWindow(other.m_LevelWindow)
+{
+}
+
/**
* Virtual destructor
*/
mitk::LabeledImageLookupTable::~LabeledImageLookupTable()
{
}
/**
* Sets the color for a given label
* @param label The pixel value used as a label in the image
* @param r The red component of the rgba color value. Values sould be given in the range [0,1]
* @param g The green component of the rgba color value. Values sould be given in the range [0,1]
* @param b The blue component of the rgba color value. Values sould be given in the range [0,1]
* @param a The alpha component of the rgba color value. Values sould be given in the range [0,1]. Default is 1.
*/
void mitk::LabeledImageLookupTable::SetColorForLabel ( const mitk::LabeledImageLookupTable::LabelType& label, const vtkFloatingPointType& r, const vtkFloatingPointType& g, const vtkFloatingPointType& b, const vtkFloatingPointType a )
{
if ( m_LookupTable == NULL )
{
itkWarningMacro("LookupTable is NULL, but it should have been initialized by the constructor");
return;
}
m_LookupTable->SetTableValue(label, r, g, b, a);
}
/**
* Determines the color which will be used for coloring a given label.
* @param label the label for which the color should be returned
* @returns an rgba array containing the color information for the given label
* Color components are expressed as [0,1] double values.
*/
vtkFloatingPointType* mitk::LabeledImageLookupTable::GetColorForLabel ( const mitk::LabeledImageLookupTable::LabelType& label )
{
if ( m_LookupTable == NULL )
{
itkWarningMacro("LookupTable is NULL, but it should have been initialized by the constructor");
return NULL;
}
return m_LookupTable->GetTableValue( label );
}
/**
* Generates a random rgb color value. Values for rgb are in the range
* [0,1]
*/
void mitk::LabeledImageLookupTable::GenerateRandomColor ( vtkFloatingPointType& r, vtkFloatingPointType& g, vtkFloatingPointType& b )
{
r = GenerateRandomNumber();
g = GenerateRandomNumber();
b = GenerateRandomNumber();
}
/**
* Generates a radnom number drawn from a uniform
* distribution in the range [0,1].
*/
vtkFloatingPointType mitk::LabeledImageLookupTable::GenerateRandomNumber()
{
return ( ( ( vtkFloatingPointType ) ( std::rand( ) ) ) / ( ( vtkFloatingPointType ) ( RAND_MAX ) ) );
}
+
+itk::LightObject::Pointer mitk::LabeledImageLookupTable::InternalClone() const
+{
+ itk::LightObject::Pointer result(new Self(*this));
+ return result;
+}
diff --git a/Modules/MitkExt/DataManagement/mitkLabeledImageLookupTable.h b/Modules/MitkExt/DataManagement/mitkLabeledImageLookupTable.h
index caa6f3ea9d..439edf79cd 100644
--- a/Modules/MitkExt/DataManagement/mitkLabeledImageLookupTable.h
+++ b/Modules/MitkExt/DataManagement/mitkLabeledImageLookupTable.h
@@ -1,111 +1,117 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKMITKLABELEDIMAGELOOKUPTABLE_H
#define MITKMITKLABELEDIMAGELOOKUPTABLE_H
#include "mitkLookupTable.h"
#include "MitkExtExports.h"
#include "mitkLevelWindow.h"
#include <iostream>
#include <string>
namespace mitk
{
/**
* A lookup table for 2D mapping of labeled images. The lookup table supports
* images with up to 256 unsigned labels. Negative labels are not supported.
* Please use the level/window settings as given by the GetLevelWindow() method
* to make sure, that the colors are rendered correctly.
* The colors are initialized with random colors as default. As background
* the label 0 is assumed. The color for the background is set to fully transparent
* as default.
*/
class MitkExt_EXPORT LabeledImageLookupTable : public LookupTable
{
public:
/**
* Standard mitk typedefs are generated by the mitkClassMacro
*/
mitkClassMacro(LabeledImageLookupTable, LookupTable);
/**
* Make this object constructable by the ::New() Method.
*/
itkNewMacro(Self);
/**
* The data type for a label. Currently only images with labels
* in the range [0,255] are supported.
*/
typedef unsigned char LabelType;
/**
* Sets the color for a given label
* @param label The pixel value used as a label in the image
* @param r The red component of the rgba color value. Values sould be given in the range [0,1]
* @param g The green component of the rgba color value. Values sould be given in the range [0,1]
* @param b The blue component of the rgba color value. Values sould be given in the range [0,1]
* @param a The alpha component of the rgba color value. Values sould be given in the range [0,1]. Default is 1.
*/
virtual void SetColorForLabel( const LabelType& label, const vtkFloatingPointType& r, const vtkFloatingPointType& g, const vtkFloatingPointType& b, const vtkFloatingPointType a = 1.0 );
/**
* Determines the color which will be used for coloring a given label.
* @param label the label for which the color should be returned
* @returns an rgba array containing the color information for the given label.
* Color components are expressed as [0,1] double values.
*/
virtual vtkFloatingPointType* GetColorForLabel(const LabelType& label);
/**
* Provides access to level window settings, which should be used
* in combination with the LUTs generated by this filter (at lease for
* 2D visualization. If you use other level/window settings, it is not
* guaranteed, that scalar values are mapped to the correct colors.
*/
mitk::LevelWindow GetLevelWindow(){return m_LevelWindow;}
protected:
/**
* Default constructor. Protected to prevent "normal" creation
*/
LabeledImageLookupTable();
+ LabeledImageLookupTable(const LabeledImageLookupTable& other);
+
/**
* Virtual destructor
*/
virtual ~LabeledImageLookupTable();
/**
* Generates a random rgb color value. Values for rgb are in the range
* [0,1]
*/
virtual void GenerateRandomColor( vtkFloatingPointType& r, vtkFloatingPointType& g, vtkFloatingPointType& b);
/**
* Generates a radnom number drawn from a uniform
* distribution in the range [0,1].
*/
virtual vtkFloatingPointType GenerateRandomNumber();
mitk::LevelWindow m_LevelWindow;
+
+private:
+
+ itk::LightObject::Pointer InternalClone() const;
};
}
#endif
diff --git a/Modules/MitkExt/DataManagement/mitkOrganTypeProperty.cpp b/Modules/MitkExt/DataManagement/mitkOrganTypeProperty.cpp
index c291630c84..2fa7041f0e 100644
--- a/Modules/MitkExt/DataManagement/mitkOrganTypeProperty.cpp
+++ b/Modules/MitkExt/DataManagement/mitkOrganTypeProperty.cpp
@@ -1,127 +1,121 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkOrganTypeProperty.h"
mitk::OrganTypeProperty::OrganTypeProperty()
{
AddEnumerationTypes();
}
mitk::OrganTypeProperty::OrganTypeProperty( const IdType& value )
{
AddEnumerationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value ) ;
}
else
{
SetValue( 0 );
}
}
mitk::OrganTypeProperty::OrganTypeProperty( const std::string& value )
{
AddEnumerationTypes();
if ( IsValidEnumerationValue( value ) )
{
SetValue( value );
}
else
{
SetValue( "undefined" );
}
}
mitk::OrganTypeProperty::~OrganTypeProperty()
{
}
void mitk::OrganTypeProperty::AddEnumerationTypes()
{
IdType newId = static_cast<IdType>(EnumerationProperty::Size());
// On changes, please also change mitk::DataNodeFactory::DefaultColorForOrgan()
AddEnum( "undefined", newId++ );
AddEnum( "Ankle", newId++ );
AddEnum( "Appendix", newId++ );
AddEnum( "Blood vessels", newId++ );
AddEnum( "Bone", newId++ );
AddEnum( "Brain", newId++ );
AddEnum( "Bronchial tree", newId++ );
AddEnum( "Coccyx", newId++ );
AddEnum( "Colon", newId++ );
AddEnum( "Cyst", newId++ );
AddEnum( "Elbow", newId++ );
AddEnum( "Eye", newId++ );
AddEnum( "Fallopian tube", newId++ );
AddEnum( "Fat", newId++ );
AddEnum( "Gall bladder", newId++ );
AddEnum( "Hand", newId++ );
AddEnum( "Heart", newId++ );
AddEnum( "Hip", newId++ );
AddEnum( "Hippocampus", newId++ );
AddEnum( "Kidney", newId++ );
AddEnum( "Knee", newId++ );
AddEnum( "Larynx", newId++ );
AddEnum( "Liver", newId++ );
AddEnum( "Lung", newId++ );
AddEnum( "Lymph node", newId++ );
AddEnum( "Muscle", newId++ );
AddEnum( "Nerve", newId++ );
AddEnum( "Nose", newId++ );
AddEnum( "Oesophagus", newId++ );
AddEnum( "Ovaries", newId++ );
AddEnum( "Pancreas", newId++ );
AddEnum( "Pelvis", newId++ );
AddEnum( "Penis", newId++ );
AddEnum( "Pharynx", newId++ );
AddEnum( "Prostate", newId++ );
AddEnum( "Rectum", newId++ );
AddEnum( "Sacrum", newId++ );
AddEnum( "Seminal vesicle", newId++ );
AddEnum( "Shoulder", newId++ );
AddEnum( "Spinal cord", newId++ );
AddEnum( "Spleen", newId++ );
AddEnum( "Stomach", newId++ );
AddEnum( "Teeth", newId++ );
AddEnum( "Testicles", newId++ );
AddEnum( "Thyroid", newId++ );
AddEnum( "Tongue", newId++ );
AddEnum( "Tumor", newId++ );
AddEnum( "Urethra", newId++ );
AddEnum( "Urinary bladder", newId++ );
AddEnum( "Uterus", newId++ );
AddEnum( "Vagina", newId++ );
AddEnum( "Vertebra", newId++ );
AddEnum( "Wrist", newId++ );
}
-mitk::OrganTypeProperty::Pointer mitk::OrganTypeProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::OrganTypeProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Modules/MitkExt/DataManagement/mitkOrganTypeProperty.h b/Modules/MitkExt/DataManagement/mitkOrganTypeProperty.h
index 43f80890f2..82cb94077e 100644
--- a/Modules/MitkExt/DataManagement/mitkOrganTypeProperty.h
+++ b/Modules/MitkExt/DataManagement/mitkOrganTypeProperty.h
@@ -1,79 +1,77 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkOrganTypeProperty_h_Included
#define mitkOrganTypeProperty_h_Included
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkEnumerationProperty.h"
#include <itkObjectFactory.h>
namespace mitk
{
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4522)
#endif
/**
\brief Enumerates all known organs :-)
\sa QmitkInteractiveSegmentation
\ingroup ToolManagerEtAl
\ingroup DataManagement
Last contributor $Author$
*/
class MitkExt_EXPORT OrganTypeProperty : public EnumerationProperty
{
public:
mitkClassMacro(OrganTypeProperty, EnumerationProperty);
itkNewMacro(OrganTypeProperty);
mitkNewMacro1Param(OrganTypeProperty, const IdType&);
mitkNewMacro1Param(OrganTypeProperty, const std::string&);
- Pointer Clone() const;
-
using BaseProperty::operator=;
protected:
OrganTypeProperty();
OrganTypeProperty( const IdType& value );
OrganTypeProperty( const std::string& value );
virtual ~OrganTypeProperty();
virtual void AddEnumerationTypes();
private:
// purposely not implemented
OrganTypeProperty& operator=(const OrganTypeProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
#ifdef _MSC_VER
# pragma warning(pop)
#endif
} // namespace
#endif
diff --git a/Modules/MitkExt/DataManagement/mitkSeedsImage.cpp b/Modules/MitkExt/DataManagement/mitkSeedsImage.cpp
index b6bf7fff0c..4ccc3d39b1 100644
--- a/Modules/MitkExt/DataManagement/mitkSeedsImage.cpp
+++ b/Modules/MitkExt/DataManagement/mitkSeedsImage.cpp
@@ -1,269 +1,269 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSeedsImage.h"
#include "mitkOperation.h"
#include "mitkOperationActor.h"
#include "mitkDrawOperation.h"
#include "mitkImageAccessByItk.h"
#include "mitkInteractionConst.h"
#include "mitkRenderingManager.h"
#include <itkNeighborhoodIterator.h>
#include <itkLineConstIterator.h>
mitk::SeedsImage::SeedsImage()
{
m_GaussianFunction3D = GaussianFunction3DType::New();
m_GaussianFunction2D = GaussianFunction2DType::New();
}
mitk::SeedsImage::~SeedsImage()
{
}
void mitk::SeedsImage::Initialize()
{
Superclass::Initialize();
m_Radius = 1;
}
void mitk::SeedsImage::ExecuteOperation(mitk::Operation* operation)
{
//mitkCheckOperationTypeMacro(SeedsOperation, operation, seedsOp);
m_Spacing = this->GetGeometry()->GetSpacing();
for(unsigned int i=0; i<this->GetDimension(); i++)
orig_size[i] = this->GetDimension(i);
mitk::DrawOperation * seedsOp =
dynamic_cast< mitk::DrawOperation * >( operation );
if ( seedsOp != NULL )
{
m_DrawState = seedsOp->GetDrawState();
if (m_Radius != seedsOp->GetRadius())
{
m_Radius = seedsOp->GetRadius();
}
switch (operation->GetOperationType())
{
case mitk::OpADD:
{
m_Point = seedsOp->GetPoint();
m_LastPoint = m_Point;
AccessByItk(this, AddSeedPoint);
break;
}
case mitk::OpMOVE:
{
m_Point = seedsOp->GetPoint();
AccessByItk(this, AddSeedPoint);
AccessByItk(this, PointInterpolation);
m_LastPoint = m_Point;
break;
}
case mitk::OpUNDOADD:
{
m_Point = seedsOp->GetPoint();
m_LastPoint = m_Point;
m_DrawState = 0;
// todo - operation is not equal with its inverse operation - possible
// approximation problems in the function PointInterpolation()
m_Radius = m_Radius+4;
AccessByItk(this, AddSeedPoint);
break;
}
case mitk::OpUNDOMOVE:
{
m_Point = seedsOp->GetPoint();
m_DrawState = 0;
// todo - operation is not equal with its inverse operation - possible
// approximation problems in the function PointInterpolation()
m_Radius = m_Radius+4;
AccessByItk(this, AddSeedPoint);
AccessByItk(this, PointInterpolation);
m_LastPoint = m_Point;
break;
}
}
//*todo has to be done here, cause of update-pipeline not working yet
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
//mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
this->Modified();
}
}
template < typename SeedsImageType >
void mitk::SeedsImage::AddSeedPoint(SeedsImageType* itkImage)
{
typedef itk::NeighborhoodIterator< SeedsImageType >
NeighborhoodIteratorType;
typedef typename NeighborhoodIteratorType::IndexType IndexType;
NeighborhoodIteratorType& nit = this->GetNit< SeedsImageType >( itkImage );
const unsigned int dimension =
- ::itk::GetImageDimension<SeedsImageType>::ImageDimension;
+ SeedsImageType::ImageDimension;
mitk::Point3D index;
this->GetGeometry()->WorldToIndex( m_Point, index );
IndexType itkIndex;
unsigned int d;
for ( d = 0; d < dimension; ++d )
{
itkIndex[d] = (int)(index[d] + 0.5);
}
nit.SetLocation( itkIndex );
unsigned int i;
for ( i = 0; i < nit.Size(); ++i )
{
if ( nit[i] != 0 )
{
try
{
nit.SetPixel( i, m_DrawState );
}
catch( itk::RangeError & )
{
}
}
}
}
template < typename SeedsImageType >
void mitk::SeedsImage::PointInterpolation(SeedsImageType* itkImage)
{
typedef itk::NeighborhoodIterator< SeedsImageType >
NeighborhoodIteratorType;
typedef typename NeighborhoodIteratorType::IndexType IndexType;
NeighborhoodIteratorType& nit = this->GetNit< SeedsImageType >( itkImage );
const unsigned int dimension =
- ::itk::GetImageDimension<SeedsImageType>::ImageDimension;
+ SeedsImageType::ImageDimension;
mitk::Point3D indexBegin, indexEnd;
this->GetGeometry()->WorldToIndex( m_Point, indexBegin );
this->GetGeometry()->WorldToIndex( m_LastPoint, indexEnd );
IndexType itkIndexBegin, itkIndexEnd;
unsigned int d;
for ( d = 0; d < dimension; ++d )
{
itkIndexBegin[d] = (int)(indexBegin[d] + 0.5);
itkIndexEnd[d] = (int)(indexEnd[d] + 0.5);
}
typedef itk::LineConstIterator< SeedsImageType > LineIteratorType;
LineIteratorType lit( itkImage, itkIndexBegin, itkIndexEnd );
// Disable warnings (which would otherwise be displayed if line leaves the
// region).
bool warningDisplay = itk::Object::GetGlobalWarningDisplay();
itk::Object::GlobalWarningDisplayOff();
for ( lit.GoToBegin(); !lit.IsAtEnd(); ++lit )
{
nit.SetLocation( lit.GetIndex() );
unsigned int i;
for ( i = 0; i < nit.Size(); ++i )
{
if ( nit[i] != 0 )
{
try
{
nit.SetPixel( i, m_DrawState );
}
catch( itk::RangeError & )
{
}
}
}
}
itk::Object::SetGlobalWarningDisplay( warningDisplay );
}
void mitk::SeedsImage::ClearBuffer()
{
AccessByItk(this, ClearBuffer);
}
template < typename SeedsImageType >
void mitk::SeedsImage::ClearBuffer(SeedsImageType* itkImage)
{
itkImage->FillBuffer(0);
}
template < typename SeedsImageType >
itk::NeighborhoodIterator< SeedsImageType >&
mitk::SeedsImage::GetNit( SeedsImageType* image )
{
typedef itk::NeighborhoodIterator< SeedsImageType >
NeighborhoodIteratorType;
typedef typename NeighborhoodIteratorType::OffsetType OffsetType;
typedef typename NeighborhoodIteratorType::SizeType SizeType;
typedef itk::GaussianSpatialFunction< int, SeedsImageType::ImageDimension >
GaussianFunctionType;
static SeedsImageType* iteratedImage = 0;
static NeighborhoodIteratorType nit;
static typename GaussianFunctionType::Pointer gaussianFunction
= GaussianFunctionType::New();
if ( iteratedImage != image )
{
SizeType radius;
radius.Fill( m_Radius);
nit.Initialize( radius, image, image->GetBufferedRegion() );
iteratedImage = image;
}
nit.SetRadius( m_Radius );
unsigned int i;
for ( i = 0; i < nit.GetCenterNeighborhoodIndex()*2+1; ++i )
{
OffsetType offset = nit.GetOffset( i );
typename GaussianFunctionType::InputType point;
double dist = 0;
unsigned int d;
for ( d = 0; d < SeedsImageType::ImageDimension; ++d )
{
point[d] = offset[d];
dist += offset[d] * offset[d];
}
}
return nit;
}
diff --git a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
index c8acb0388b..86f1bb1866 100644
--- a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
+++ b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
@@ -1,250 +1,248 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkUnstructuredGrid.h"
#include <vtkUnstructuredGrid.h>
-#include <itkSmartPointerForwardReference.txx>
-
void mitk::UnstructuredGrid::SetVtkUnstructuredGrid( vtkUnstructuredGrid* grid, unsigned int t )
{
this->Expand(t);
if(m_GridSeries[ t ] != NULL)
{
m_GridSeries[ t ]->Delete();
}
m_GridSeries[ t ] = grid;
// call m_VtkPolyData->Register(NULL) to tell the reference counting that we
// want to keep a reference on the object
if (m_GridSeries[t] != 0)
m_GridSeries[t]->Register(grid);
this->Modified();
m_CalculateBoundingBox = true;
}
void mitk::UnstructuredGrid::Expand(unsigned int timeSteps)
{
// check if the vector is long enough to contain the new element
// at the given position. If not, expand it with sufficient zero-filled elements.
if(timeSteps > m_GridSeries.size())
{
Superclass::Expand(timeSteps);
vtkUnstructuredGrid* pdnull = 0;
m_GridSeries.resize( timeSteps, pdnull );
m_CalculateBoundingBox = true;
}
}
void mitk::UnstructuredGrid::ClearData()
{
for ( VTKUnstructuredGridSeries::iterator it = m_GridSeries.begin(); it != m_GridSeries.end(); ++it )
{
if ( ( *it ) != 0 )
( *it )->Delete();
}
m_GridSeries.clear();
Superclass::ClearData();
}
void mitk::UnstructuredGrid::InitializeEmpty()
{
vtkUnstructuredGrid* pdnull = 0;
m_GridSeries.resize( 1, pdnull );
Superclass::InitializeTimeSlicedGeometry(1);
m_Initialized = true;
}
vtkUnstructuredGrid* mitk::UnstructuredGrid::GetVtkUnstructuredGrid(unsigned int t)
{
if ( t < m_GridSeries.size() )
{
vtkUnstructuredGrid* grid = m_GridSeries[ t ];
if((grid == 0) && (GetSource().GetPointer() != 0))
{
RegionType requestedregion;
requestedregion.SetIndex(3, t);
requestedregion.SetSize(3, 1);
SetRequestedRegion(&requestedregion);
GetSource()->Update();
}
grid = m_GridSeries[ t ];
return grid;
}
else
return 0;
}
mitk::UnstructuredGrid::UnstructuredGrid() : m_CalculateBoundingBox( false )
{
this->InitializeEmpty();
}
mitk::UnstructuredGrid::UnstructuredGrid(const mitk::UnstructuredGrid &other) :
BaseData(other),
m_CalculateBoundingBox( other.m_CalculateBoundingBox ),
m_LargestPossibleRegion(other.m_LargestPossibleRegion)
{
if(!other.m_Initialized)
{
this->InitializeEmpty();
}
else
{
m_GridSeries = other.m_GridSeries;
m_Initialized = other.m_Initialized;
}
this->SetRequestedRegion( const_cast<mitk::UnstructuredGrid*>(&other) );
}
mitk::UnstructuredGrid::~UnstructuredGrid()
{
this->ClearData();
}
void mitk::UnstructuredGrid::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if ( ( m_CalculateBoundingBox ) && ( m_GridSeries.size() > 0 ) )
CalculateBoundingBox();
else
GetTimeSlicedGeometry()->UpdateInformation();
}
void mitk::UnstructuredGrid::CalculateBoundingBox()
{
//
// first make sure, that the associated time sliced geometry has
// the same number of geometry 3d's as vtkUnstructuredGrids are present
//
mitk::TimeSlicedGeometry* timeGeometry = GetTimeSlicedGeometry();
if ( timeGeometry->GetTimeSteps() != m_GridSeries.size() )
{
itkExceptionMacro(<<"timeGeometry->GetTimeSteps() != m_GridSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
}
//
// Iterate over the vtkUnstructuredGrids and update the Geometry
// information of each of the items.
//
for ( unsigned int i = 0 ; i < m_GridSeries.size() ; ++i )
{
vtkUnstructuredGrid* grid = m_GridSeries[ i ];
vtkFloatingPointType bounds[ ] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
if ( ( grid != 0 ) && ( grid->GetNumberOfCells() > 0 ) )
{
grid->Update();
grid->ComputeBounds();
grid->GetBounds( bounds );
}
mitk::Geometry3D::Pointer g3d = timeGeometry->GetGeometry3D( i );
assert( g3d.IsNotNull() );
g3d->SetFloatBounds( bounds );
}
timeGeometry->UpdateInformation();
mitk::BoundingBox::Pointer bb = const_cast<mitk::BoundingBox*>( timeGeometry->GetBoundingBox() );
itkDebugMacro( << "boundingbox min: "<< bb->GetMinimum());
itkDebugMacro( << "boundingbox max: "<< bb->GetMaximum());
m_CalculateBoundingBox = false;
}
void mitk::UnstructuredGrid::SetRequestedRegionToLargestPossibleRegion()
{
m_RequestedRegion = GetLargestPossibleRegion();
}
bool mitk::UnstructuredGrid::RequestedRegionIsOutsideOfTheBufferedRegion()
{
RegionType::IndexValueType end = m_RequestedRegion.GetIndex(3)+m_RequestedRegion.GetSize(3);
if(((RegionType::IndexValueType)m_GridSeries.size()) < end)
return true;
for( RegionType::IndexValueType t=m_RequestedRegion.GetIndex(3); t < end; ++t )
if(m_GridSeries[t] == 0)
return true;
return false;
}
bool mitk::UnstructuredGrid::VerifyRequestedRegion()
{
if( (m_RequestedRegion.GetIndex(3)>=0) &&
(m_RequestedRegion.GetIndex(3)+m_RequestedRegion.GetSize(3)<=m_GridSeries.size()) )
return true;
return false;
}
-void mitk::UnstructuredGrid::SetRequestedRegion( itk::DataObject *data )
+void mitk::UnstructuredGrid::SetRequestedRegion(const itk::DataObject *data )
{
- mitk::UnstructuredGrid *gridData;
+ const mitk::UnstructuredGrid *gridData;
- gridData = dynamic_cast<mitk::UnstructuredGrid*>(data);
+ gridData = dynamic_cast<const mitk::UnstructuredGrid*>(data);
if (gridData)
{
m_RequestedRegion = gridData->GetRequestedRegion();
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::UnstructuredGrid::SetRequestedRegion(DataObject*) cannot cast " << typeid(data).name() << " to " << typeid(UnstructuredGrid*).name() );
}
}
void mitk::UnstructuredGrid::SetRequestedRegion(UnstructuredGrid::RegionType *region) //by arin
{
if(region != 0)
{
m_RequestedRegion = *region;
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::UnstructuredGrid::SetRequestedRegion(UnstructuredGrid::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(UnstructuredGrid*).name() );
}
}
void mitk::UnstructuredGrid::CopyInformation( const itk::DataObject * data )
{
Superclass::CopyInformation(data);
}
void mitk::UnstructuredGrid::Update()
{
if ( GetSource().IsNull() )
{
for ( VTKUnstructuredGridSeries::iterator it = m_GridSeries.begin() ; it != m_GridSeries.end() ; ++it )
{
if ( ( *it ) != 0 )
( *it )->Update();
}
}
Superclass::Update();
}
diff --git a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h
index 2c6efcf248..5c4b5f310d 100644
--- a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h
+++ b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h
@@ -1,112 +1,112 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_UNSTRUCTURED_GRID_H_
#define _MITK_UNSTRUCTURED_GRID_H_
#include "mitkBaseData.h"
#include "MitkExtExports.h"
#include "itkImageRegion.h"
class vtkUnstructuredGrid;
namespace mitk {
//##Documentation
//## @brief Class for storing unstructured grids (vtkUnstructuredGrid)
//## @ingroup Data
class MitkExt_EXPORT UnstructuredGrid : public BaseData
{
public:
// not yet the best choice of a region-type for surfaces, but it works for the time being
typedef itk::ImageRegion< 5 > RegionType;
mitkClassMacro(UnstructuredGrid, BaseData);
itkNewMacro(Self);
mitkCloneMacro(UnstructuredGrid);
virtual void SetVtkUnstructuredGrid(vtkUnstructuredGrid* grid, unsigned int t = 0);
virtual vtkUnstructuredGrid* GetVtkUnstructuredGrid(unsigned int t = 0);
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion( const itk::DataObject *data);
virtual void SetRequestedRegion(UnstructuredGrid::RegionType *region);
virtual void CopyInformation(const itk::DataObject *data);
virtual void Update();
// Initialize should not be called manually;
// The polydata vector is initialized automatically when enlarged;
virtual void Expand( unsigned int timeSteps = 1 );
const RegionType& GetLargestPossibleRegion() const
{
m_LargestPossibleRegion.SetIndex(3, 0);
m_LargestPossibleRegion.SetSize(3, GetTimeSlicedGeometry()->GetTimeSteps());
return m_LargestPossibleRegion;
}
//##Documentation
//## Get the region object that defines the size and starting index
//## for the region of the image requested (i.e., the region of the
//## image to be operated on by a filter).
virtual const RegionType& GetRequestedRegion() const
{
return m_RequestedRegion;
}
void CalculateBoundingBox();
protected:
typedef std::vector< vtkUnstructuredGrid* > VTKUnstructuredGridSeries;
UnstructuredGrid();
UnstructuredGrid(const mitk::UnstructuredGrid & other);
virtual ~UnstructuredGrid();
virtual void ClearData();
virtual void InitializeEmpty();
VTKUnstructuredGridSeries m_GridSeries;
mutable RegionType m_LargestPossibleRegion;
RegionType m_RequestedRegion;
bool m_CalculateBoundingBox;
};
} // namespace mitk
#endif /* _MITK_UNSTRUCTURED_GRID_H_ */
diff --git a/Modules/MitkExt/IO/mitkParRecFileReader.cpp b/Modules/MitkExt/IO/mitkParRecFileReader.cpp
index 6f9ff394e4..c2d98807a4 100644
--- a/Modules/MitkExt/IO/mitkParRecFileReader.cpp
+++ b/Modules/MitkExt/IO/mitkParRecFileReader.cpp
@@ -1,292 +1,292 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkParRecFileReader.h"
#include <itkImageFileReader.h>
#ifdef __GNUC__
#define stricmp strcasecmp
#endif
void mitk::ParRecFileReader::GenerateOutputInformation()
{
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_ReadHeaderTime.GetMTime()))
return;
itkDebugMacro(<<"Reading PAR file for GenerateOutputInformation()" << m_FileName);
// Check to see if we can read the file given the name or prefix
//
if ( m_FileName == "" && m_FilePrefix == "" )
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "One of FileName or FilePrefix must be non-empty");
}
m_RecFileName = "";
if( m_FileName != "")
{
int extPos=m_FileName.find_last_of(".");
if(extPos>=-1)
{
const char *ext=m_FileName.c_str()+extPos+1;
if(stricmp(ext,"par")==0)
m_RecFileName = m_FileName.substr(0,extPos);
else
m_RecFileName = m_FileName;
}
else
m_RecFileName = m_FileName;
m_RecFileName.append(".rec");
bool headerRead = false;
bool signedCharType = true;
unsigned int dimension=0;
unsigned int dimensions[4]={0,0,1,1};
float sliceThickness=0.0;
float sliceGap=0.0;
float sliceSpacing=0.0;
mitk::Vector3D thickness; thickness.Fill(1.0);
mitk::Vector3D gap; gap.Fill(0.0);
mitk::Vector3D spacing;
FILE *f;
f=fopen(m_FileName.c_str(), "r");
if(f!=NULL)
{
while(!feof(f))
{
char s[300], *p;
char* ignored = fgets(s,200,f);
++ignored;
if(strstr(s,"Max. number of cardiac phases"))
{
p=strchr(s,':')+1;
dimensions[3]=atoi(p);
if(dimensions[3]>1)
dimension=4;
}
else
if(strstr(s,"Max. number of slices/locations"))
{
p=strchr(s,':')+1;
dimensions[2]=atoi(p);
if(dimension==0)
{
if(dimensions[2]>1)
dimension=3;
else
dimension=2;
}
}
else
if(strstr(s,"Image pixel size"))
{
p=strchr(s,':')+1;
int bpe=atoi(p);
if(bpe!=8)
signedCharType = false;
}
else
if(strstr(s,"Recon resolution"))
{
p=s+strcspn(s,"0123456789");
sscanf(p,"%u %u", dimensions, dimensions+1);
}
else
if(strstr(s,"FOV (ap,fh,rl) [mm]"))
{
p=s+strcspn(s,"0123456789");
char *oldLocale = setlocale(LC_ALL, 0);
sscanf(p,"%f %f %f", &thickness[0], &thickness[1], &thickness[2]);
setlocale(LC_ALL, oldLocale);
}
else
if(strstr(s,"Slice thickness [mm]"))
{
p=s+strcspn(s,"0123456789");
char *oldLocale = setlocale(LC_ALL, 0);
sscanf(p,"%f", &sliceThickness);
setlocale(LC_ALL, oldLocale);
}
else
if(strstr(s,"Slice gap [mm]"))
{
p=s+strcspn(s,"-0123456789");
char *oldLocale = setlocale(LC_ALL, 0);
sscanf(p,"%f", &sliceGap);
setlocale(LC_ALL, oldLocale);
}
}
fclose(f);
//C:\home\ivo\data\coronaries\ucsf-wholeheart-2.par
sliceSpacing = sliceThickness+sliceGap;
if((dimension>0) && (dimensions[0]>0) && (dimensions[1]>0) && (sliceThickness>0) && (sliceSpacing>0))
{
headerRead = true;
if(fabs(thickness[0]/dimensions[2]-sliceSpacing)<0.0001)
thickness[0]=thickness[1];
else
if(fabs(thickness[1]/dimensions[2]-sliceSpacing)<0.0001)
thickness[1]=thickness[0];
thickness[2]=sliceSpacing;
thickness[0]/=dimensions[0];
thickness[1]/=dimensions[1];
spacing=thickness+gap;
}
}
if( headerRead == false)
{
itk::ImageFileReaderException e(__FILE__, __LINE__);
- itk::OStringStream msg;
+ std::ostringstream msg;
msg << " Could not read file "
<< m_FileName.c_str();
e.SetDescription(msg.str().c_str());
throw e;
return;
}
// define types
mitk::PixelType SCType = mitk::MakeScalarPixelType<signed char>();
mitk::PixelType SSType = mitk::MakeScalarPixelType<signed short>();
if( signedCharType )
output->Initialize(SCType, dimension, dimensions);
else
output->Initialize(SSType, dimension, dimensions);
output->GetSlicedGeometry()->SetSpacing(spacing);
//output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), dimensions).GetPointer(), 0);
output->GetSlicedGeometry()->SetEvenlySpaced();
}
m_ReadHeaderTime.Modified();
}
void mitk::ParRecFileReader::GenerateData()
{
mitk::Image::Pointer output = this->GetOutput();
// Check to see if we can read the file given the name or prefix
//
if ( m_RecFileName == "" )
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "FileName for rec-file empty");
}
if( m_RecFileName != "")
{
FILE *f = fopen(m_RecFileName.c_str(), "r");
if(f==NULL)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Could not open rec-file.");
}
int zstart, zmax;
int tstart, tmax;
zstart=output->GetRequestedRegion().GetIndex(2);
tstart=output->GetRequestedRegion().GetIndex(3);
zmax=zstart+output->GetRequestedRegion().GetSize(2);
tmax=tstart+output->GetRequestedRegion().GetSize(3);
int sliceSize=output->GetDimension(0)*output->GetDimension(1)*output->GetPixelType().GetBpe()/8;
void *data = malloc(sliceSize);
bool ignore4Dtopogram=false;
{
int slicePlusTimeSize=output->GetDimension(0)*output->GetDimension(1)*output->GetDimension(3)*output->GetPixelType().GetBpe()/8;
if(output->GetDimension(3)>1)
ignore4Dtopogram=true;
int z,t;
for(t=tstart;t<tmax;++t)
for(z=zstart;z<zmax;++z)
{
if(ignore4Dtopogram)
fseek(f,slicePlusTimeSize*z+(sliceSize+1)*t,SEEK_SET);
else
fseek(f,slicePlusTimeSize*z+sliceSize*t,SEEK_SET);
size_t ignored = fread(data, sliceSize, 1, f);
++ignored;
output->SetSlice(data,z,t,0);
}
}
//else
//{
// for(;z<zmax;++z)
// {
// fseek(f,sliceSize*z,SEEK_SET);
// fread(data, sliceSize, 1, f);
// output->SetSlice(data,z,0,0);
// }
//}
free(data);
fclose(f);
}
}
bool mitk::ParRecFileReader::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
{
// First check the extension
if( filename == "" )
{
//MITK_INFO<<"No filename specified."<<std::endl;
return false;
}
bool extensionFound = false;
std::string::size_type PARPos = filename.rfind(".par");
if ((PARPos != std::string::npos)
&& (PARPos == filename.length() - 4))
{
extensionFound = true;
}
PARPos = filename.rfind(".PAR");
if ((PARPos != std::string::npos)
&& (PARPos == filename.length() - 4))
{
extensionFound = true;
}
if( !extensionFound )
{
//MITK_INFO<<"The filename extension is not recognized."<<std::endl;
return false;
}
return true;
}
mitk::ParRecFileReader::ParRecFileReader()
: m_FileName(""), m_FilePrefix(""), m_FilePattern("")
{
}
mitk::ParRecFileReader::~ParRecFileReader()
{
}
diff --git a/Modules/MitkExt/IO/mitkPropertyListExportToXmlFile.cpp b/Modules/MitkExt/IO/mitkPropertyListExportToXmlFile.cpp
new file mode 100644
index 0000000000..0e7e807ef3
--- /dev/null
+++ b/Modules/MitkExt/IO/mitkPropertyListExportToXmlFile.cpp
@@ -0,0 +1,175 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+#include "mitkPropertyListExportToXmlFile.h"
+#include <itkObject.h>
+#include <tinyxml.h>
+#include "mitkProperties.h"
+#include "mitkStringProperty.h"
+#include "mitkEnumerationProperty.h"
+#include <usModuleContext.h>
+#include <usGetModuleContext.h>
+#include <usModule.h>
+#include "usServiceReference.h"
+#include <mitkLogMacros.h>
+#include <string>
+
+namespace mitk
+{
+ struct PropertyListExportToXmlFileData
+ {
+ const std::string* m_FileName;
+ const PropertyList* m_PropertyList;
+ };
+
+ PropertyListExportToXmlFile::PropertyListExportToXmlFile(const std::string* _FileName,
+ const PropertyList* _PropertyList)
+ : d( new PropertyListExportToXmlFileData )
+ {
+ d->m_FileName = _FileName;
+ d->m_PropertyList = _PropertyList;
+ }
+
+ PropertyListExportToXmlFile::~PropertyListExportToXmlFile()
+ {
+ delete d;
+ }
+
+ void PropertyListExportToXmlFile::Update()
+ {
+ std::string _FileName = *d->m_FileName;
+ PropertyList::Pointer propList = PropertyList::New();
+
+ TiXmlDocument doc( _FileName.c_str() );
+ TiXmlElement* root = 0;
+ TiXmlElement* elem = 0;
+
+ std::string className;
+ d->m_PropertyList->GetStringProperty("ClassName", className);
+ // check if element is already available
+ if(doc.LoadFile())
+ {
+ root = doc.FirstChildElement();
+ if(!root)
+ {
+ MITK_WARN("PropertyListExportToXml") << "No root element found";
+ return;
+ }
+ elem = root->FirstChildElement( className );
+ std::string id;
+ d->m_PropertyList->GetStringProperty("Id", id);
+ if( !id.empty() )
+ {
+ std::string foundId;
+ while(elem)
+ {
+ elem->QueryStringAttribute("Id", &foundId);
+ if( foundId == id )
+ break;
+ elem = elem->NextSiblingElement( className );
+ }
+ }
+ }
+ else
+ {
+ // document did not exist, create new one with declration
+ TiXmlDeclaration * decl = new TiXmlDeclaration( "1.0", "", "" );
+ doc.LinkEndChild( decl );
+ // create root
+ root = new TiXmlElement( "data" );
+ doc.LinkEndChild( root );
+ }
+
+ // create elem if not existent
+ TiXmlElement* newElem = 0;
+ if(!elem)
+ {
+ elem = new TiXmlElement( className );
+ newElem = elem;
+ }
+
+ const std::map< std::string, BaseProperty::Pointer>* propMap = d->m_PropertyList->GetMap();
+ std::map< std::string, BaseProperty::Pointer>::const_iterator propMapIt = propMap->begin();
+ while( propMapIt != propMap->end() )
+ {
+ if( propMapIt->first.find_first_of(".") != std::string::npos )
+ {
+ MITK_DEBUG << "meta property found. will not write.";
+ ++propMapIt;
+ continue;
+ }
+ mitk::IntProperty* intProp = 0;
+ mitk::FloatProperty* floatProp = 0;
+ mitk::DoubleProperty* doubleProp = 0;
+ mitk::BoolProperty* boolProp = 0;
+ mitk::StringProperty* stringProp = 0;
+ mitk::EnumerationProperty* enumProp = 0;
+
+ if( (boolProp = dynamic_cast<BoolProperty*>( propMapIt->second.GetPointer() ) ) )
+ {
+ elem->SetAttribute( propMapIt->first, boolProp->GetValue() ? 1 : 0 );
+ }
+ else if( (stringProp = dynamic_cast<StringProperty*>( propMapIt->second.GetPointer() ) ) )
+ {
+ elem->SetAttribute( propMapIt->first, stringProp->GetValue() );
+ }
+ else if( (intProp = dynamic_cast<IntProperty*>( propMapIt->second.GetPointer() ) ) )
+ {
+ elem->SetAttribute( propMapIt->first, intProp->GetValue() );
+ }
+ else if( (enumProp = dynamic_cast<EnumerationProperty*>( propMapIt->second.GetPointer() ) ) )
+ {
+ elem->SetAttribute( propMapIt->first, enumProp->GetValueAsId() );
+ }
+ else if( (doubleProp = dynamic_cast<DoubleProperty*>( propMapIt->second.GetPointer() ) ) )
+ {
+ elem->SetDoubleAttribute( propMapIt->first, doubleProp->GetValue() );
+ }
+ else if( (floatProp = dynamic_cast<FloatProperty*>( propMapIt->second.GetPointer() ) ) )
+ {
+ elem->SetDoubleAttribute( propMapIt->first, static_cast<double>( floatProp->GetValue() ) );
+ }
+ else
+ {
+ MITK_DEBUG << "trying to look up serializer for baseproperty in AlgorithmRegistry";
+
+ {
+ MITK_WARN("PropertyListExportToXmlFile") << "Base property " << propMapIt->first << " is unknown";
+ }
+ }
+ ++propMapIt;
+ }
+
+ // add the element node as child
+ if( newElem )
+ root->LinkEndChild(elem);
+
+ if( !doc.SaveFile( _FileName ) )
+ {
+ MITK_DEBUG << "File " << _FileName << " could not be written. Please check permissions.";
+ MITK_WARN("PropertyListExportToXmlFile") << "Cannot write file";
+ }
+ }
+
+ void PropertyListExportToXmlFile::SetFileName(const std::string* _FileName)
+ {
+ d->m_FileName = _FileName;
+ }
+
+ void PropertyListExportToXmlFile::SetPropertyList(const PropertyList* _PropertyList)
+ {
+ d->m_PropertyList = _PropertyList;
+ }
+} // namespace mitk
diff --git a/Modules/MitkExt/IO/mitkPropertyListExportToXmlFile.h b/Modules/MitkExt/IO/mitkPropertyListExportToXmlFile.h
new file mode 100644
index 0000000000..6bc4ef6d87
--- /dev/null
+++ b/Modules/MitkExt/IO/mitkPropertyListExportToXmlFile.h
@@ -0,0 +1,63 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+#ifndef mitkPropertyListExportToXmlFile_h
+#define mitkPropertyListExportToXmlFile_h
+
+#include "MitkExtExports.h"
+#include <mitkPropertyList.h>
+
+namespace mitk
+{
+ ///
+ /// d pointer forward declaration
+ ///
+ struct PropertyListExportToXmlFileData;
+ ///
+ /// writes a 2d cv point to an xml file
+ ///
+ class MitkExt_EXPORT PropertyListExportToXmlFile
+ {
+ public:
+ ///
+ /// init default values and save references
+ ///
+ PropertyListExportToXmlFile( const std::string* _FileName = 0,
+ const PropertyList* _PropertyList = 0);
+ ///
+ /// executes the algorithm if inputs changed
+ ///
+ void Update();
+ ///
+ /// delete d pointer
+ ///
+ virtual ~PropertyListExportToXmlFile();
+ ///
+ /// setter for field FileName
+ ///
+ void SetFileName(const std::string* _FileName);
+ ///
+ /// setter for field PropertyList
+ ///
+ void SetPropertyList(const PropertyList* _PropertyList);
+ private:
+ ///
+ /// d pointer
+ ///
+ PropertyListExportToXmlFileData* d;
+ };
+} // namespace mitk
+
+#endif // mitkPropertyListExportToXmlFile_h
diff --git a/Modules/MitkExt/IO/mitkPropertyListImportFromXmlFile.cpp b/Modules/MitkExt/IO/mitkPropertyListImportFromXmlFile.cpp
new file mode 100644
index 0000000000..aa70e625e1
--- /dev/null
+++ b/Modules/MitkExt/IO/mitkPropertyListImportFromXmlFile.cpp
@@ -0,0 +1,203 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+#include "mitkPropertyListImportFromXmlFile.h"
+#include <itkObject.h>
+#include <itksys/SystemTools.hxx>
+#include <tinyxml.h>
+#include "mitkProperties.h"
+#include "mitkStringProperty.h"
+#include "mitkEnumerationProperty.h"
+#include "mitkGenericProperty.h"
+//#include "mitkBasePropertyFromString.h"
+#include <usModuleContext.h>
+#include <usGetModuleContext.h>
+#include <usModule.h>
+#include "usServiceReference.h"
+
+namespace mitk
+{
+ struct PropertyListImportFromXmlFileData
+ {
+ const std::string* m_FileName;
+ PropertyList* m_PropertyList;
+
+ //private
+ long int m_FileModifiedTime;
+ };
+
+ PropertyListImportFromXmlFile::PropertyListImportFromXmlFile(
+ const std::string* _FileName,
+ PropertyList* _PropertyList)
+ : d( new PropertyListImportFromXmlFileData )
+ {
+ d->m_FileName = _FileName;
+ d->m_PropertyList = _PropertyList;
+ d->m_FileModifiedTime = 0;
+ }
+
+ PropertyListImportFromXmlFile::~PropertyListImportFromXmlFile()
+ {
+ delete d;
+ }
+
+ void GetPropertyListFromXMLFile ( const TiXmlElement* elem, const std::string* _FileName, PropertyList* _PropertyList )
+ {
+ const std::map< std::string, BaseProperty::Pointer>* propMap = _PropertyList->GetMap();
+ std::map< std::string, BaseProperty::Pointer>::const_iterator propMapIt = propMap->begin();
+ while( propMapIt != propMap->end() )
+ {
+ std::string key = propMapIt->first;
+ mitk::BaseProperty* prop = propMapIt->second.GetPointer();
+ mitk::IntProperty* intProp = 0;
+ mitk::FloatProperty* floatProp = 0;
+ mitk::DoubleProperty* doubleProp = 0;
+ mitk::BoolProperty* boolProp = 0;
+ mitk::StringProperty* stringProp = 0;
+ mitk::EnumerationProperty* enumProp = 0;
+ bool found = false;
+
+ if( (boolProp = dynamic_cast<BoolProperty*>( prop ) ) )
+ {
+ int val = false;
+ found = elem->QueryIntAttribute(key, &val) == TIXML_SUCCESS;
+ if( found )
+ boolProp->SetValue( val==0 ? false : true );
+ }
+ else if( (stringProp = dynamic_cast<StringProperty*>( prop ) ) )
+ {
+ std::string val = "";
+ found = elem->QueryStringAttribute(key.c_str(), &val) == TIXML_SUCCESS;
+ if( found )
+ stringProp->SetValue( val );
+ }
+ else if( (intProp = dynamic_cast<IntProperty*>( prop ) ) )
+ {
+ int val = 0;
+ found = elem->QueryIntAttribute(key, &val) == TIXML_SUCCESS;
+ if( found )
+ intProp->SetValue( val );
+ }
+ else if( (enumProp = dynamic_cast<EnumerationProperty*>( prop ) ) )
+ {
+ int val = 0;
+ found = elem->QueryIntAttribute(key, &val) == TIXML_SUCCESS;
+ if( found && enumProp->IsValidEnumerationValue( val ) )
+ enumProp->SetValue( static_cast<unsigned int> ( val ) );
+ else
+ {
+ std::string strval = "";
+ found = elem->QueryStringAttribute(key.c_str(), &strval);
+ if( found && enumProp->IsValidEnumerationValue( strval ) )
+ enumProp->SetValue( strval );
+ }
+ }
+ else if( (doubleProp = dynamic_cast<DoubleProperty*>( prop ) ) )
+ {
+ double val = 0;
+ found = elem->QueryDoubleAttribute(key, &val) == TIXML_SUCCESS;
+ doubleProp->SetValue( val );
+ }
+ else if( (floatProp = dynamic_cast<FloatProperty*>( prop ) ) )
+ {
+ double val = 0;
+ found = elem->QueryDoubleAttribute(key, &val) == TIXML_SUCCESS;
+ floatProp->SetValue( static_cast<float>( val ) );
+ }
+ else
+ {
+ MITK_WARN("PropertyListImportFromXmlFile") << "Base property " << key << " is unknown";
+ }
+
+ if(!found)
+ {
+ MITK_DEBUG << "Attribute " << key << " not found";
+ }
+
+ ++propMapIt;
+ }
+ }
+
+ void PropertyListImportFromXmlFile::Update()
+ {
+
+ std::string _FileName = *d->m_FileName;
+
+ MITK_DEBUG << "extracting real path (complete path)";
+ _FileName = itksys::SystemTools::GetRealPath( _FileName.c_str() );
+
+ if( !itksys::SystemTools::FileExists(_FileName.c_str()) )
+ {
+ MITK_WARN("PropertyListFromXml") << " Cannot open file";
+ }
+
+ long int _FileModifiedTime = itksys::SystemTools::ModifiedTime( _FileName.c_str() );
+ // file has not changed: we know that version... -> do nothing
+ if( d->m_FileModifiedTime >= _FileModifiedTime )
+ return;
+
+ // reread
+ TiXmlDocument doc( _FileName );
+ doc.LoadFile();
+
+ MITK_DEBUG << "searching for element with classname";
+ std::string className;
+ d->m_PropertyList->GetStringProperty("ClassName", className);
+
+ TiXmlHandle docHandle( &doc );
+ TiXmlElement* elem = docHandle.FirstChildElement().FirstChildElement( className ).ToElement();
+
+ if(!elem)
+ {
+ MITK_WARN("PropertyListFromXml") << "Cannot find element";
+ return;
+ }
+
+ std::string id;
+ d->m_PropertyList->GetStringProperty("Id", id);
+ if( !id.empty() )
+ {
+ std::string foundId;
+ while(elem)
+ {
+ elem->QueryStringAttribute("Id", &foundId);
+ if( foundId == id )
+ break;
+ elem = elem->NextSiblingElement( className );
+ }
+ if(!elem)
+ {
+ MITK_WARN("PropertyListFromXml") << "Cannot find element by id";
+ return;
+ }
+ }
+
+ MITK_DEBUG << "element found. now reading attributes into propertylist";
+ GetPropertyListFromXMLFile( elem, &_FileName, d->m_PropertyList );
+
+ MITK_DEBUG << "save that modified time";
+ d->m_FileModifiedTime = _FileModifiedTime;
+ }
+
+ void PropertyListImportFromXmlFile::SetFileName(const std::string* _FileName)
+ {
+ d->m_FileName = _FileName;
+ }
+
+ void PropertyListImportFromXmlFile::SetPropertyList(PropertyList* _PropertyList)
+ {
+ d->m_PropertyList = _PropertyList;
+ }
+} // namespace mitk
diff --git a/Modules/MitkExt/IO/mitkPropertyListImportFromXmlFile.h b/Modules/MitkExt/IO/mitkPropertyListImportFromXmlFile.h
new file mode 100644
index 0000000000..e4e983876e
--- /dev/null
+++ b/Modules/MitkExt/IO/mitkPropertyListImportFromXmlFile.h
@@ -0,0 +1,64 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+#ifndef mitkPropertyListImportFromXmlFile_h
+#define mitkPropertyListImportFromXmlFile_h
+
+#include <mitkPropertyList.h>
+#include "MitkExtExports.h"
+
+namespace mitk
+{
+ ///
+ /// d pointer forward declaration
+ ///
+ struct PropertyListImportFromXmlFileData;
+ ///
+ /// DOCUMENTATION
+ ///
+ class MitkExt_EXPORT PropertyListImportFromXmlFile
+ {
+ public:
+ ///
+ /// init default values and save references
+ ///
+ PropertyListImportFromXmlFile( const std::string* _FileName = 0,
+ PropertyList* _PropertyList = 0 );
+
+ ///
+ /// executes the algorithm if inputs changed
+ ///
+ void Update();
+ ///
+ /// delete d pointer
+ ///
+ virtual ~PropertyListImportFromXmlFile();
+ ///
+ /// setter for field FileName
+ ///
+ void SetFileName(const std::string* _FileName);
+ ///
+ /// setter for field PropertyList
+ ///
+ void SetPropertyList(PropertyList* _PropertyList);
+ private:
+ ///
+ /// d pointer
+ ///
+ PropertyListImportFromXmlFileData* d;
+ };
+} // namespace mitk
+
+#endif // mitkPropertyListImportFromXmlFile_h
diff --git a/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx b/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx
index ad17dd7941..9479f2d3bd 100644
--- a/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx
+++ b/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx
@@ -1,205 +1,205 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
#define _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
#include <itkLightObject.h>
#include <vtkUnstructuredGrid.h>
#include <vtkLinearTransform.h>
#include <vtkTransformFilter.h>
#include <vtkUnstructuredGridWriter.h>
#include <vtkXMLUnstructuredGridWriter.h>
#include <vtkXMLPUnstructuredGridWriter.h>
#include <sstream>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
namespace mitk {
template<class VTKWRITER>
UnstructuredGridVtkWriter<VTKWRITER>::UnstructuredGridVtkWriter()
: m_Success(false)
{
this->SetNumberOfRequiredInputs(1);
}
template<class VTKWRITER>
UnstructuredGridVtkWriter<VTKWRITER>::~UnstructuredGridVtkWriter()
{
}
template<class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::GenerateData()
{
m_Success = false;
if ( m_FileName == "" )
{
itkWarningMacro( << "Sorry, filename has not been set!" );
return ;
}
mitk::UnstructuredGrid::Pointer input = const_cast<mitk::UnstructuredGrid*>(this->GetInput());
if (input.IsNull())
{
itkWarningMacro( << "Sorry, input to mitk::UnstructuredGridVtkWriter is NULL");
return;
}
VTKWRITER* unstructuredGridWriter = VTKWRITER::New();
vtkTransformFilter* transformPointSet = vtkTransformFilter::New();
vtkUnstructuredGrid * unstructuredGrid;
Geometry3D* geometry;
if(input->GetTimeSlicedGeometry()->GetTimeSteps()>1)
{
int t, timesteps;
timesteps = input->GetTimeSlicedGeometry()->GetTimeSteps();
for(t = 0; t < timesteps; ++t)
{
- ::itk::OStringStream filename;
+ std::ostringstream filename;
geometry = input->GetGeometry(t);
if(input->GetTimeSlicedGeometry()->IsValidTime(t))
{
const mitk::TimeBounds& timebounds = geometry->GetTimeBounds();
filename << m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << GetDefaultExtension();
}
else
{
itkWarningMacro(<<"Error on write: TimeSlicedGeometry invalid of unstructured grid " << filename << ".");
filename << m_FileName.c_str() << "_T" << t << GetDefaultExtension();
}
geometry->TransferItkToVtkTransform();
transformPointSet->SetInput(input->GetVtkUnstructuredGrid(t));
transformPointSet->SetTransform(geometry->GetVtkTransform());
transformPointSet->UpdateWholeExtent();
unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
unstructuredGridWriter->SetFileName(filename.str().c_str());
unstructuredGridWriter->SetInput(unstructuredGrid);
ExecuteWrite( unstructuredGridWriter );
}
}
else
{
geometry = input->GetGeometry();
geometry->TransferItkToVtkTransform();
transformPointSet->SetInput(input->GetVtkUnstructuredGrid());
transformPointSet->SetTransform(geometry->GetVtkTransform());
transformPointSet->UpdateWholeExtent();
unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
unstructuredGridWriter->SetFileName(m_FileName.c_str());
unstructuredGridWriter->SetInput(unstructuredGrid);
ExecuteWrite( unstructuredGridWriter );
}
transformPointSet->Delete();
unstructuredGridWriter->Delete();
m_Success = true;
}
template<class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::ExecuteWrite( VTKWRITER* vtkWriter )
{
struct stat fileStatus;
time_t timeBefore=0;
if (!stat(vtkWriter->GetFileName(), &fileStatus))
{
timeBefore = fileStatus.st_mtime;
}
if (!vtkWriter->Write())
{
itkExceptionMacro( << "Error during unstructured grid writing.");
}
// check if file can be written because vtkWriter doesn't check that
if (stat(vtkWriter->GetFileName(), &fileStatus) || (timeBefore == fileStatus.st_mtime))
{
itkExceptionMacro(<<"Error during unstructured grid writing: file could not be written");
}
}
template<class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::SetInput(BaseData *input)
{
this->ProcessObject::SetNthInput(0, input);
}
template<class VTKWRITER>
const UnstructuredGrid* UnstructuredGridVtkWriter<VTKWRITER>::GetInput()
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
else
{
return dynamic_cast<UnstructuredGrid*>(this->ProcessObject::GetInput(0));
}
}
template<class VTKWRITER>
bool UnstructuredGridVtkWriter<VTKWRITER>::CanWriteBaseDataType(BaseData::Pointer data)
{
return (dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()) != 0);
}
template<class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::DoWrite(BaseData::Pointer data)
{
if (CanWriteBaseDataType(data))
{
this->SetInput(dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()));
this->Update();
}
}
template<class VTKWRITER>
std::vector<std::string> UnstructuredGridVtkWriter<VTKWRITER>::GetPossibleFileExtensions()
{
throw std::exception(); // no specialization available!
}
template<class VTKWRITER>
const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultFilename()
{
throw std::exception(); // no specialization available!
}
template<class VTKWRITER>
const char* UnstructuredGridVtkWriter<VTKWRITER>::GetFileDialogPattern()
{
throw std::exception(); // no specialization available!
}
template<class VTKWRITER>
const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultExtension()
{
throw std::exception(); // no specialization available!
}
}
#endif
diff --git a/Modules/MitkExt/Interactions/mitkInteractionDebugger.cpp b/Modules/MitkExt/Interactions/mitkInteractionDebugger.cpp
index 90955f43e2..8378d71266 100644
--- a/Modules/MitkExt/Interactions/mitkInteractionDebugger.cpp
+++ b/Modules/MitkExt/Interactions/mitkInteractionDebugger.cpp
@@ -1,57 +1,57 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkInteractionDebugger.h"
#include <itkMacro.h>
const char* mitk::InteractionDebugger::m_CurrentSender = "";
bool mitk::InteractionDebugger::m_Active = false;
mitk::InteractionDebugger::InteractionDebugger()
{}
void mitk::InteractionDebugger::Activate()
{
m_Active = true;
}
void mitk::InteractionDebugger::Deactivate()
{
m_Active = false;
}
mitk::InteractionDebugger::~InteractionDebugger()
{}
void mitk::InteractionDebugger::Set(const char* sender, const char* text)
{
if (m_Active)
{
- itk::OStringStream itkmsg;
+ std::ostringstream itkmsg;
if (! itk::Object::GetGlobalWarningDisplay())
return;
if (sender != m_CurrentSender)
{
itkmsg << sender <<" :\n"<<text<<"\n";
m_CurrentSender = sender;
}
else
itkmsg<<text<<"\n";
itk::OutputWindowDisplayDebugText(itkmsg.str().c_str());
}
}
diff --git a/Modules/MitkExt/Interactions/mitkTool.cpp b/Modules/MitkExt/Interactions/mitkTool.cpp
index ba23cf28cd..8db3fb311d 100644
--- a/Modules/MitkExt/Interactions/mitkTool.cpp
+++ b/Modules/MitkExt/Interactions/mitkTool.cpp
@@ -1,181 +1,180 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTool.h"
#include "mitkDataNodeFactory.h"
#include "mitkProperties.h"
#include "mitkLevelWindowProperty.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include <itkObjectFactory.h>
mitk::Tool::Tool(const char* type)
: StateMachine(type),
m_SupportRoi(false),
// for reference images
m_PredicateImages(NodePredicateDataType::New("Image")),
m_PredicateDim3(NodePredicateDimension::New(3, 1)),
m_PredicateDim4(NodePredicateDimension::New(4, 1)),
m_PredicateDimension( mitk::NodePredicateOr::New(m_PredicateDim3, m_PredicateDim4) ),
m_PredicateImage3D( NodePredicateAnd::New(m_PredicateImages, m_PredicateDimension) ),
m_PredicateBinary(NodePredicateProperty::New("binary", BoolProperty::New(true))),
m_PredicateNotBinary( NodePredicateNot::New(m_PredicateBinary) ),
m_PredicateSegmentation(NodePredicateProperty::New("segmentation", BoolProperty::New(true))),
m_PredicateNotSegmentation( NodePredicateNot::New(m_PredicateSegmentation) ),
m_PredicateHelper(NodePredicateProperty::New("helper object", BoolProperty::New(true))),
m_PredicateNotHelper( NodePredicateNot::New(m_PredicateHelper) ),
m_PredicateImageColorful( NodePredicateAnd::New(m_PredicateNotBinary, m_PredicateNotSegmentation) ),
m_PredicateImageColorfulNotHelper( NodePredicateAnd::New(m_PredicateImageColorful, m_PredicateNotHelper) ),
m_PredicateReference( NodePredicateAnd::New(m_PredicateImage3D, m_PredicateImageColorfulNotHelper) ),
// for working image
m_IsSegmentationPredicate(NodePredicateAnd::New(NodePredicateOr::New(m_PredicateBinary, m_PredicateSegmentation), m_PredicateNotHelper))
{
}
mitk::Tool::~Tool()
{
}
const char* mitk::Tool::GetGroup() const
{
return "default";
}
void mitk::Tool::SetToolManager(ToolManager* manager)
{
m_ToolManager = manager;
}
void mitk::Tool::Activated()
{
}
void mitk::Tool::Deactivated()
{
StateMachine::ResetStatemachineToStartState(); // forget about the past
}
itk::Object::Pointer mitk::Tool::GetGUI(const std::string& toolkitPrefix, const std::string& toolkitPostfix)
{
itk::Object::Pointer object;
std::string classname = this->GetNameOfClass();
std::string guiClassname = toolkitPrefix + classname + toolkitPostfix;
std::list<itk::LightObject::Pointer> allGUIs = itk::ObjectFactoryBase::CreateAllInstance(guiClassname.c_str());
for( std::list<itk::LightObject::Pointer>::iterator iter = allGUIs.begin();
iter != allGUIs.end();
++iter )
{
if (object.IsNull())
{
object = dynamic_cast<itk::Object*>( iter->GetPointer() );
}
else
{
MITK_ERROR << "There is more than one GUI for " << classname << " (several factories claim ability to produce a " << guiClassname << " ) " << std::endl;
return NULL; // people should see and fix this error
}
}
return object;
}
mitk::NodePredicateBase::ConstPointer mitk::Tool::GetReferenceDataPreference() const
{
return m_PredicateReference.GetPointer();
}
mitk::NodePredicateBase::ConstPointer mitk::Tool::GetWorkingDataPreference() const
{
return m_IsSegmentationPredicate.GetPointer();
}
mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode( Image* original, const std::string& organName, const mitk::Color& color )
{
// we NEED a reference image for size etc.
if (!original) return NULL;
// actually create a new empty segmentation
PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>() );
Image::Pointer segmentation = Image::New();
if (original->GetDimension() == 2)
{
const unsigned int dimensions[] = { original->GetDimension(0), original->GetDimension(1), 1 };
segmentation->Initialize(pixelType, 3, dimensions);
}
else
{
segmentation->Initialize(pixelType, original->GetDimension(), original->GetDimensions());
}
unsigned int byteSize = sizeof(DefaultSegmentationDataType);
for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
memset( segmentation->GetData(), 0, byteSize );
if (original->GetTimeSlicedGeometry() )
{
- AffineGeometryFrame3D::Pointer originalGeometryAGF = original->GetTimeSlicedGeometry()->Clone();
- TimeSlicedGeometry::Pointer originalGeometry = dynamic_cast<TimeSlicedGeometry*>( originalGeometryAGF.GetPointer() );
+ TimeSlicedGeometry::Pointer originalGeometry = original->GetTimeSlicedGeometry()->Clone();
segmentation->SetGeometry( originalGeometry );
}
else
{
Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
return NULL;
}
return CreateSegmentationNode( segmentation, organName, color );
}
mitk::DataNode::Pointer mitk::Tool::CreateSegmentationNode( Image* image, const std::string& organName, const mitk::Color& color )
{
if (!image) return NULL;
// decorate the datatreenode with some properties
DataNode::Pointer segmentationNode = DataNode::New();
segmentationNode->SetData( image );
// name
segmentationNode->SetProperty( "name", StringProperty::New( organName ) );
// visualization properties
segmentationNode->SetProperty( "binary", BoolProperty::New(true) );
segmentationNode->SetProperty( "color", ColorProperty::New(color) );
segmentationNode->SetProperty( "texture interpolation", BoolProperty::New(false) );
segmentationNode->SetProperty( "layer", IntProperty::New(10) );
segmentationNode->SetProperty( "levelwindow", LevelWindowProperty::New( LevelWindow(0.5, 1) ) );
segmentationNode->SetProperty( "opacity", FloatProperty::New(0.3) );
segmentationNode->SetProperty( "segmentation", BoolProperty::New(true) );
segmentationNode->SetProperty( "reslice interpolation", VtkResliceInterpolationProperty::New() ); // otherwise -> segmentation appears in 2 slices sometimes (only visual effect, not different data)
// For MITK-3M3 release, the volume of all segmentations should be shown
segmentationNode->SetProperty( "showVolume", BoolProperty::New( true ) );
return segmentationNode;
}
diff --git a/Modules/MitkExt/Rendering/mitkEnhancedPointSetVtkMapper3D.cpp b/Modules/MitkExt/Rendering/mitkEnhancedPointSetVtkMapper3D.cpp
index cde313ed90..4beb25e5db 100644
--- a/Modules/MitkExt/Rendering/mitkEnhancedPointSetVtkMapper3D.cpp
+++ b/Modules/MitkExt/Rendering/mitkEnhancedPointSetVtkMapper3D.cpp
@@ -1,434 +1,444 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkEnhancedPointSetVtkMapper3D.h"
//#include <sstream>
#include <algorithm>
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include "mitkLookupTables.h"
#include "mitkColorProperty.h"
//#include "mitkVtkPropRenderer.h"
#include <vtkActor.h>
#include <vtkAssembly.h>
#include <vtkProp3DCollection.h>
#include <vtkTubeFilter.h>
#include <vtkSphereSource.h>
#include <vtkCubeSource.h>
#include <vtkConeSource.h>
#include <vtkCylinderSource.h>
#include <vtkProperty.h>
#include <vtkPolyDataMapper.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkPolyDataAlgorithm.h>
#include <mitkLookupTableProperty.h>
const mitk::PointSet* mitk::EnhancedPointSetVtkMapper3D::GetInput()
{
return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
}
mitk::EnhancedPointSetVtkMapper3D::EnhancedPointSetVtkMapper3D()
{
m_Contour = vtkActor::New();
m_ContourSource = vtkTubeFilter::New();
m_PropAssembly = vtkAssembly::New();
}
vtkProp* mitk::EnhancedPointSetVtkMapper3D::GetVtkProp(mitk::BaseRenderer* /*renderer*/)
{
return m_PropAssembly;
}
mitk::EnhancedPointSetVtkMapper3D::~EnhancedPointSetVtkMapper3D()
{
m_Contour->Delete();
m_ContourSource->Delete();
m_PropAssembly->Delete();
// TODO: do cleanup correctly
// Clean up all remaining actors and poly-data sources
//std::for_each(m_PointActors.begin(), m_PointActors.end(), &mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject);
// std::for_each(m_SphereSources.begin(), m_SphereSources.end(), &mitk::EnhancedPointSetVtgkMapper3D::DeleteVtkObject);
// std::for_each(m_CubeSources.begin(), m_CubeSources.end(), &mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject);
// std::for_each(m_ConeSources.begin(), m_ConeSources.end(), &mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject);
// std::for_each(m_CylinderSources.begin(), m_CylinderSources.end(), &mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject);
//
}
void mitk::EnhancedPointSetVtkMapper3D::ReleaseGraphicsResources(vtkWindow * /*renWin*/)
{
// TODO: Do we have to call this for all actors??
//m_Actor->ReleaseGraphicsResources(renWin);
}
void mitk::EnhancedPointSetVtkMapper3D::UpdateVtkObjects()
{
// get and update the PointSet
const mitk::PointSet* pointset = this->GetInput();
//pointset->Update();
int timestep = this->GetTimestep();
mitk::PointSet::DataType* itkPointSet = pointset->GetPointSet( timestep );
mitk::PointSet::PointsContainer* points = itkPointSet->GetPoints();
mitk::PointSet::PointDataContainer* pointData = itkPointSet->GetPointData();
assert(points->Size() == pointData->Size());
mitk::PointSet::PointsIterator pIt;
mitk::PointSet::PointDataIterator pdIt;
/* search removed points and delete the corresponding source/actor/mapper objects */
for (ActorMap::iterator it = m_PointActors.begin(); it != m_PointActors.end(); )
{
PointIdentifier id = it->first;
if (!points->IndexExists(id))
{
this->RemoveEntryFromSourceMaps(id);
m_PropAssembly->GetParts()->RemoveItem(it->second.first); // remove from prop assembly
if (it->second.first != NULL)
it->second.first->Delete(); // Delete actor, which deletes mapper too (reference count)
ActorMap::iterator er = it; // save iterator for deleting
++it; // advance iterator to next object
m_PointActors.erase(er); // erase element from map. This invalidates er, therefore we had to advance it before deletion.
}
else
++it;
}
/* iterate over each point in the pointset and create corresponding vtk objects */
for (pIt = points->Begin(), pdIt = pointData->Begin(); pIt != itkPointSet->GetPoints()->End(); ++pIt, ++pdIt)
{
PointIdentifier pointID = pIt->Index();
assert (pointID == pdIt->Index());
mitk::PointSet::PointType point = pIt->Value();
mitk::PointSet::PointDataType data = pdIt->Value();
ActorMap::iterator aIt = m_PointActors.find(pointID); // Does an actor exist for the point?
/* Create/Update sources for the point */
vtkActor* a = NULL;
bool newPoint = (aIt == m_PointActors.end()); // current point is new
bool specChanged = (!newPoint && data.pointSpec != aIt->second.second); // point spec of current point has changed
if (newPoint) // point did not exist before, we have to create vtk objects for it
{ // create actor and mapper for the new point
a = vtkActor::New();
vtkPolyDataMapper* m = vtkPolyDataMapper::New();
a->SetMapper(m);
m->UnRegister( NULL );
aIt = m_PointActors.insert(std::make_pair(pointID, std::make_pair(a, data.pointSpec))).first; // insert element and update actormap iterator to point to new element
m_PropAssembly->AddPart(a);
}
else
{
a = aIt->second.first;
if (specChanged) // point exists, but point spec has changed
{
this->RemoveEntryFromSourceMaps( pointID );
}
}
if ( newPoint || specChanged ) // new point OR existing point but point spec changed
{
vtkPolyDataAlgorithm* source = NULL; // works only in VTK 5+
switch (data.pointSpec) // add to new map
{ //TODO: look up representation in a representationlookuptable
case PTSTART: //cube
m_CubeSources[pointID] = vtkCubeSource::New();
source = m_CubeSources[pointID];
break;
case PTCORNER: //cone
m_ConeSources[pointID] = vtkConeSource::New();
source = m_ConeSources[pointID];
break;
case PTEDGE: // cylinder
m_CylinderSources[pointID] = vtkCylinderSource::New();
source = m_CylinderSources[pointID];
break;
case PTUNDEFINED: // sphere
case PTEND:
default:
m_SphereSources[pointID] = vtkSphereSource::New();
source = m_SphereSources[pointID];
break;
}
vtkPolyDataMapper* m = dynamic_cast<vtkPolyDataMapper*>(a->GetMapper());
assert(m != NULL);
m->SetInput(source->GetOutput());
aIt->second.second = data.pointSpec; // update point spec in actormap
}
} // for each point
}
void mitk::EnhancedPointSetVtkMapper3D::ApplyProperties( mitk::BaseRenderer * renderer )
{
this->UpdateVtkObjects();
/* iterate over all points in pointset and apply properties to corresponding vtk objects */
// get and update the PointSet
const mitk::PointSet* pointset = this->GetInput();
int timestep = this->GetTimestep();
mitk::PointSet::DataType* itkPointSet = pointset->GetPointSet( timestep );
mitk::PointSet::PointsContainer* points = itkPointSet->GetPoints();
mitk::PointSet::PointDataContainer* pointData = itkPointSet->GetPointData();
assert(points->Size() == pointData->Size());
mitk::PointSet::PointsIterator pIt;
mitk::PointSet::PointDataIterator pdIt;
mitk::DataNode* n = this->GetDataNode();
assert(n != NULL);
for (pIt = points->Begin(), pdIt = pointData->Begin(); pIt != itkPointSet->GetPoints()->End(); ++pIt, ++pdIt) // for each point in the pointset
{
PointIdentifier pointID = pIt->Index();
assert (pointID == pdIt->Index());
mitk::PointSet::PointType point = pIt->Value();
mitk::PointSet::PointDataType data = pdIt->Value();
ActorMap::iterator aIt = m_PointActors.find(pointID); // Does an actor exist for the point?
assert(aIt != m_PointActors.end()); // UpdateVtkObjects() must ensure that actor exists
vtkActor* a = aIt->second.first;
assert(a != NULL);
SetVtkMapperImmediateModeRendering(a->GetMapper());
/* update properties */
// visibility
bool pointVisibility = true;
bool visValueFound = false;
mitk::BaseProperty* visProp = n->GetProperty("visibility", renderer);
mitk::BoolLookupTableProperty* visLTProp = dynamic_cast<mitk::BoolLookupTableProperty*>(visProp);
if (visLTProp != NULL)
{
mitk::BoolLookupTable visLookupTable = visLTProp->GetValue();
//if (visLookupTable != NULL)
//{
try
{
pointVisibility = visLookupTable.GetTableValue(pointID);
visValueFound = true;
}
catch (...)
{
}
//}
}
if (visValueFound == false)
{
pointVisibility = n->IsVisible(renderer, "show points"); // use BoolProperty instead
}
a->SetVisibility(pointVisibility);
// opacity
float opacity = 1.0;
bool opValueFound = false;
mitk::BaseProperty* opProp = n->GetProperty("opacity", renderer);
mitk::FloatLookupTableProperty* opLTProp = dynamic_cast<mitk::FloatLookupTableProperty*>(opProp);
if (opLTProp != NULL)
{
mitk::FloatLookupTable opLookupTable = opLTProp->GetValue();
//if (opLookupTable != NULL)
//{
try
{
opacity = opLookupTable.GetTableValue(pointID);
opValueFound = true;
}
catch (...)
{
}
//}
}
if (opValueFound == false)
{
n->GetOpacity(opacity, renderer);
}
a->GetProperty()->SetOpacity(opacity);
////////////////////// continue here ///////////////////
// pointsize & point position
float pointSize = 1.0;
n->GetFloatProperty( "pointsize", pointSize, renderer);
switch (data.pointSpec)
{ //TODO: look up representation in a representationlookuptable
case PTSTART: //cube
m_CubeSources[pointID]->SetXLength(pointSize);
m_CubeSources[pointID]->SetYLength(pointSize);
m_CubeSources[pointID]->SetZLength(pointSize);
//m_CubeSources[pointID]->SetCenter(pos[0], pos[1], pos[2]);
break;
case PTCORNER: //cone
m_ConeSources[pointID]->SetRadius(pointSize/2);
m_ConeSources[pointID]->SetHeight(pointSize);
m_ConeSources[pointID]->SetResolution(2); // two crossed triangles. Maybe introduce an extra property for
//m_ConeSources[pointID]->SetCenter(pos[0], pos[1], pos[2]);
break;
case PTEDGE: // cylinder
m_CylinderSources[pointID]->SetRadius(pointSize/2);
m_CylinderSources[pointID]->SetHeight(pointSize);
m_CylinderSources[pointID]->CappingOn();
m_CylinderSources[pointID]->SetResolution(6);
//m_CylinderSources[pointID]->SetCenter(pos[0], pos[1], pos[2]);
break;
case PTUNDEFINED: // sphere
case PTEND:
default:
m_SphereSources[pointID]->SetRadius(pointSize/2);
m_SphereSources[pointID]->SetThetaResolution(10);
m_SphereSources[pointID]->SetPhiResolution(10);
//m_SphereSources[pointID]->SetCenter(pos[0], pos[1], pos[2]);
break;
}
// set position
mitk::Point3D pos = pIt->Value();
aIt->second.first->SetPosition(pos[0], pos[1], pos[2]);
// selectedcolor & color
float color[3];
if (data.selected)
{
if(!n->GetColor(color, renderer, "selectedcolor"))
n->GetColor(color, renderer);
}
else
{
mitk::BaseProperty* a = n->GetProperty("colorLookupTable", renderer);
mitk::LookupTableProperty* b = dynamic_cast<mitk::LookupTableProperty*>(a);
if (b != NULL)
{
mitk::LookupTable::Pointer c = b->GetLookupTable();
vtkLookupTable *d = c->GetVtkLookupTable();
double *e=d->GetTableValue(pointID);
color[0]=e[0];
color[1]=e[1];
color[2]=e[2];
}
else
{
if(!n->GetColor(color, renderer, "unselectedcolor"))
n->GetColor(color, renderer);
}
}
// TODO: What about "color" property? 2D Mapper only uses unselected and selected color properties
a->GetProperty()->SetColor(color[0], color[1], color[2]);
// TODO: label property
}
//TODO test different pointSpec
// TODO "line width" "show contour" "contourcolor" "contoursize" "close contour" "show label", "label"
// TODO "show points" vs "visibility" - is visibility evaluated at all? in a superclass maybe?
// TODO create lookup tables for all properties that should be evaluated per point. also create editor widgets for these lookup tables!
// TODO check if property changes and pointset changes are reflected in the render window immediately.
// TODO check behavior with large PointSets
// TODO check for memory leaks on adding/deleting points
}
void mitk::EnhancedPointSetVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer * renderer )
{
+
+ BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+ bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
+
+ if(needGenerateData)
+ {
+ ls->UpdateGenerateDataTime();
+ this->UpdateVtkObjects();
+ }
+
ApplyProperties(renderer);
}
void mitk::EnhancedPointSetVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
{
// TODO: apply new transform if time step changed
//vtkLinearTransform * vtktransform =
// this->GetDataNode()->GetVtkTransform(this->GetTimestep());
//m_SelectedActor->SetUserTransform(vtktransform);
//m_UnselectedActor->SetUserTransform(vtktransform);
//m_ContourActor->SetUserTransform(vtktransform);
}
void mitk::EnhancedPointSetVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite );
node->AddProperty( "pointsize", mitk::FloatProperty::New(1.0), renderer, overwrite);
node->AddProperty( "selectedcolor", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite); //yellow for selected
node->AddProperty( "unselectedcolor", mitk::ColorProperty::New(0.5f, 1.0f, 0.5f), renderer, overwrite); // middle green for unselected
node->AddProperty( "color", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite); // red as standard
node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "contourcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);
node->AddProperty( "contoursize", mitk::FloatProperty::New(0.5), renderer, overwrite );
node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite );
node->AddProperty( "show label", mitk::BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "label", mitk::StringProperty::New("P"), renderer, overwrite );
node->AddProperty( "opacity", mitk::FloatProperty::New(1.0), renderer, overwrite );
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
void mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject( vtkObject* o)
{
if (o != NULL)
o->Delete();
}
void mitk::EnhancedPointSetVtkMapper3D::RemoveEntryFromSourceMaps( mitk::PointSet::PointIdentifier pointID )
{
ActorMap::iterator aIt = m_PointActors.find(pointID);
if (aIt == m_PointActors.end())
return;
switch (aIt->second.second) // erase in old map
{ //TODO: look up representation in a representationlookuptable
case PTSTART: //cube
m_CubeSources[pointID]->Delete();
m_CubeSources.erase(pointID);
break;
case PTCORNER: //cone
m_ConeSources[pointID]->Delete();
m_ConeSources.erase(pointID);
break;
case PTEDGE: // cylinder
m_CylinderSources[pointID]->Delete();
m_CylinderSources.erase(pointID);
break;
case PTUNDEFINED: // sphere
case PTEND:
default:
m_SphereSources[pointID]->Delete();
m_SphereSources.erase(pointID);
break;
}
}
diff --git a/Modules/MitkExt/Rendering/mitkEnhancedPointSetVtkMapper3D.h b/Modules/MitkExt/Rendering/mitkEnhancedPointSetVtkMapper3D.h
index 84ebcf36c2..c72e8899e8 100644
--- a/Modules/MitkExt/Rendering/mitkEnhancedPointSetVtkMapper3D.h
+++ b/Modules/MitkExt/Rendering/mitkEnhancedPointSetVtkMapper3D.h
@@ -1,123 +1,125 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKEnhancedPointSetVtkMapper3D_H_HEADER_INCLUDED_C1907273
#define MITKEnhancedPointSetVtkMapper3D_H_HEADER_INCLUDED_C1907273
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkVtkMapper.h"
#include "mitkBaseRenderer.h"
#include "mitkPointSet.h"
#include "mitkVector.h"
class vtkActor;
class vtkAssembly;
class vtkSphereSource;
class vtkCubeSource;
class vtkConeSource;
class vtkCylinderSource;
class vtkTubeFilter;
class vtkProp;
namespace mitk {
/**
* \brief Alternative Vtk-based 3D mapper for mitk::PointSet
*
* This class renders mitk::PointSet objects in 3D views. It resembles the
* standard mitk::PointSetVtkMapper3D, but is designed to enable single
* points to be rendered with individual appearances.
*
* Instead of assembling one vtkPolyData object containing all points,
* a list of VTK source objects (spheres, cubes, cones, ...) is maintained.
* Therefore, the application can change the appearance and/or type of a
* specific point at runtime, without having to rebuild the
*
* You should use this class instead of the standard mapper if you
*
* - change the PointSet very often (by adding or removing points)
* - need different representations for points (+++)
* - want to change the point representation frequently (+++)
*
* Note: the class is still in experimental stage, and the points above
* marked with (+++) are not yet working correctly. Also, drawing lines
* between points (contour mode) is not yet supported. The class will be
* extended so that point representations are stored in a lookup table,
* which is indexed by point data from the rendered PointSet.
*
* \warn This mapper requires the PointData container to be the same size
* as the point container.
*
* \sa PointSetVtkMapper3D
*/
class MitkExt_EXPORT EnhancedPointSetVtkMapper3D : public VtkMapper
{
public:
mitkClassMacro(EnhancedPointSetVtkMapper3D, VtkMapper);
itkNewMacro(Self);
virtual const mitk::PointSet* GetInput();
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer);
static void SetDefaultProperties(mitk::DataNode* node,
mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
void ReleaseGraphicsResources(vtkWindow *renWin);
+ LocalStorageHandler<BaseLocalStorage> m_LSH;
+
protected:
EnhancedPointSetVtkMapper3D();
virtual ~EnhancedPointSetVtkMapper3D();
void RemoveEntryFromSourceMaps( mitk::PointSet::PointIdentifier pointID );
void DeleteVtkObject(vtkObject* o); // functor for stl_each in destructor
// update all vtk sources, mappers, actors with current data and properties
void UpdateVtkObjects();
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
virtual void ApplyProperties(mitk::BaseRenderer* renderer);
typedef mitk::PointSet::PointIdentifier PointIdentifier;
typedef std::map<PointIdentifier, vtkSphereSource*> SphereSourceMap;
typedef std::map<PointIdentifier, vtkCubeSource*> CubeSourceMap;
typedef std::map<PointIdentifier, vtkConeSource*> ConeSourceMap;
typedef std::map<PointIdentifier, vtkCylinderSource*> CylinderSourceMap;
typedef std::pair<vtkActor*, mitk::PointSpecificationType> ActorAndPointType;
typedef std::map<PointIdentifier, ActorAndPointType> ActorMap;
SphereSourceMap m_SphereSources; // stores all sphere sources
CubeSourceMap m_CubeSources; // stores all cube sources
ConeSourceMap m_ConeSources; // stores all cone sources
CylinderSourceMap m_CylinderSources; // stores all cylinder sources
ActorMap m_PointActors; // stores an actor for each point(referenced by its ID) and the currently used pointspec = which source type is generating the polydata
vtkActor* m_Contour;
vtkTubeFilter* m_ContourSource;
vtkAssembly* m_PropAssembly; // this contains everything, this will be returned by GetVtkProp()
};
} // namespace mitk
#endif /* MITKEnhancedPointSetVtkMapper3D_H_HEADER_INCLUDED_C1907273 */
diff --git a/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.cpp b/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.cpp
index 8a8b215a5d..9b4d92388b 100644
--- a/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.cpp
+++ b/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.cpp
@@ -1,710 +1,706 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#define GPU_INFO MITK_INFO("mapper.vr")
#define GPU_WARN MITK_WARN("mapper.vr")
#define GPU_ERROR MITK_ERROR("mapper.vr")
#include "mitkGPUVolumeMapper3D.h"
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include "mitkLevelWindow.h"
#include "mitkColorProperty.h"
#include "mitkLevelWindowProperty.h"
#include "mitkLookupTableProperty.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkTransferFunctionInitializer.h"
#include "mitkColorProperty.h"
#include "mitkVtkPropRenderer.h"
#include "mitkRenderingManager.h"
#include <vtkActor.h>
#include <vtkProperty.h>
#include <vtkVolumeTextureMapper2D.h>
#include <vtkVolume.h>
#include <vtkVolumeProperty.h>
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
#include <vtkVolumeRayCastCompositeFunction.h>
#include <vtkVolumeRayCastMIPFunction.h>
#include <vtkFiniteDifferenceGradientEstimator.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkImageWriter.h>
#include <vtkImageData.h>
#include <vtkLODProp3D.h>
#include <vtkImageResample.h>
#include <vtkPlane.h>
#include <vtkImplicitPlaneWidget.h>
#include <vtkAssembly.h>
#include <vtkCubeSource.h>
#include <vtkPolyDataMapper.h>
-#include <itkMultiThreader.h>
-
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
#include "vtkMitkGPUVolumeRayCastMapper.h"
#endif
#include "vtkOpenGLGPUVolumeRayCastMapper.h"
#include "vtkMitkOpenGLVolumeTextureMapper3D.h"
const mitk::Image* mitk::GPUVolumeMapper3D::GetInput()
{
return static_cast<const mitk::Image*> ( GetDataNode()->GetData() );
}
void mitk::GPUVolumeMapper3D::MitkRenderVolumetricGeometry(mitk::BaseRenderer* renderer)
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
VtkMapper::MitkRenderVolumetricGeometry(renderer);
if(ls->m_gpuInitialized)
ls->m_MapperGPU->UpdateMTime();
}
bool mitk::GPUVolumeMapper3D::InitGPU(mitk::BaseRenderer* renderer)
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
if(ls->m_gpuInitialized)
return ls->m_gpuSupported;
GPU_INFO << "initializing gpu-slicing-vr (vtkMitkOpenGLVolumeTextureMapper3D)";
ls->m_MapperGPU = vtkSmartPointer<vtkMitkOpenGLVolumeTextureMapper3D>::New();
ls->m_MapperGPU->SetUseCompressedTexture(false);
ls->m_MapperGPU->SetSampleDistance(1.0);
ls->m_VolumePropertyGPU = vtkSmartPointer<vtkVolumeProperty>::New();
ls->m_VolumePropertyGPU->ShadeOn();
ls->m_VolumePropertyGPU->SetAmbient (0.25f); //0.05f
ls->m_VolumePropertyGPU->SetDiffuse (0.50f); //0.45f
ls->m_VolumePropertyGPU->SetSpecular(0.40f); //0.50f
ls->m_VolumePropertyGPU->SetSpecularPower(16.0f);
ls->m_VolumePropertyGPU->SetInterpolationTypeToLinear();
ls->m_VolumeGPU = vtkSmartPointer<vtkVolume>::New();
ls->m_VolumeGPU->SetMapper( ls->m_MapperGPU );
ls->m_VolumeGPU->SetProperty( ls->m_VolumePropertyGPU );
ls->m_VolumeGPU->VisibilityOn();
ls->m_MapperGPU->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
ls->m_gpuSupported = ls->m_MapperGPU->IsRenderSupported(renderer->GetVtkRenderer(),ls->m_VolumePropertyGPU);
ls->m_gpuInitialized = true;
return ls->m_gpuSupported;
}
void mitk::GPUVolumeMapper3D::InitCPU(mitk::BaseRenderer* renderer)
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
if(ls->m_cpuInitialized)
return;
- int numThreads = itk::MultiThreader::GetGlobalDefaultNumberOfThreads();
+ ls->m_MapperCPU = vtkSmartPointer<vtkFixedPointVolumeRayCastMapper>::New();
+ int numThreads = ls->m_MapperCPU->GetNumberOfThreads( );
GPU_INFO << "initializing cpu-raycast-vr (vtkFixedPointVolumeRayCastMapper) (" << numThreads << " threads)";
- ls->m_MapperCPU = vtkSmartPointer<vtkFixedPointVolumeRayCastMapper>::New();
ls->m_MapperCPU->SetSampleDistance(1.0);
// ls->m_MapperCPU->LockSampleDistanceToInputSpacingOn();
ls->m_MapperCPU->SetImageSampleDistance(1.0);
ls->m_MapperCPU->IntermixIntersectingGeometryOn();
ls->m_MapperCPU->SetAutoAdjustSampleDistances(0);
- ls->m_MapperCPU->SetNumberOfThreads( numThreads );
-
ls->m_VolumePropertyCPU = vtkSmartPointer<vtkVolumeProperty>::New();
ls->m_VolumePropertyCPU->ShadeOn();
ls->m_VolumePropertyCPU->SetAmbient (0.10f); //0.05f
ls->m_VolumePropertyCPU->SetDiffuse (0.50f); //0.45f
ls->m_VolumePropertyCPU->SetSpecular(0.40f); //0.50f
ls->m_VolumePropertyCPU->SetSpecularPower(16.0f);
ls->m_VolumePropertyCPU->SetInterpolationTypeToLinear();
ls->m_VolumeCPU = vtkSmartPointer<vtkVolume>::New();
ls->m_VolumeCPU->SetMapper( ls->m_MapperCPU );
ls->m_VolumeCPU->SetProperty( ls->m_VolumePropertyCPU );
ls->m_VolumeCPU->VisibilityOn();
ls->m_MapperCPU->SetInput( m_UnitSpacingImageFilter->GetOutput() );//m_Resampler->GetOutput());
ls->m_cpuInitialized=true;
}
void mitk::GPUVolumeMapper3D::DeinitGPU(mitk::BaseRenderer* renderer)
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
if(ls->m_gpuInitialized)
{
GPU_INFO << "deinitializing gpu-slicing-vr";
// deinit renderwindow, this is needed to release the memory allocated on the gpu
// to prevent leaking memory on the gpu
ls->m_MapperGPU->ReleaseGraphicsResources(renderer->GetVtkRenderer()->GetVTKWindow());
ls->m_VolumePropertyGPU = NULL;
ls->m_MapperGPU = NULL;
ls->m_VolumeGPU = NULL;
ls->m_gpuInitialized=false;
}
}
void mitk::GPUVolumeMapper3D::DeinitCPU(mitk::BaseRenderer* renderer)
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
if(!ls->m_cpuInitialized)
return;
GPU_INFO << "deinitializing cpu-raycast-vr";
ls->m_VolumePropertyCPU = NULL;
ls->m_MapperCPU = NULL;
ls->m_VolumeCPU = NULL;
ls->m_cpuInitialized=false;
}
mitk::GPUVolumeMapper3D::GPUVolumeMapper3D()
{
m_VolumeNULL=0;
m_commonInitialized=false;
}
mitk::GPUVolumeMapper3D::~GPUVolumeMapper3D()
{
DeinitCommon();
}
void mitk::GPUVolumeMapper3D::InitCommon()
{
if(m_commonInitialized)
return;
m_UnitSpacingImageFilter = vtkSmartPointer<vtkImageChangeInformation>::New();
m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
CreateDefaultTransferFunctions();
m_commonInitialized=true;
}
void mitk::GPUVolumeMapper3D::DeinitCommon()
{
if(!m_commonInitialized)
return;
m_commonInitialized=false;
}
bool mitk::GPUVolumeMapper3D::IsRenderable(mitk::BaseRenderer* renderer)
{
if(!GetDataNode())
return false;
DataNode* node = GetDataNode();
bool visible = true;
node->GetVisibility(visible, renderer, "visible");
if(!visible) return false;
bool value = false;
if(!node->GetBoolProperty("volumerendering",value,renderer))
return false;
if(!value)
return false;
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
if ( !input || !input->IsInitialized() )
return false;
vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
if(inputData==NULL)
return false;
return true;
}
void mitk::GPUVolumeMapper3D::InitVtkMapper(mitk::BaseRenderer* renderer)
{
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
if(IsRAYEnabled(renderer))
{
DeinitCPU(renderer);
DeinitGPU(renderer);
if(!InitRAY(renderer))
{
GPU_WARN << "hardware renderer can't initialize ... falling back to software renderer";
goto fallback;
}
}
else
#endif
if(IsGPUEnabled(renderer))
{
DeinitCPU(renderer);
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
DeinitRAY(renderer);
#endif
if(!InitGPU(renderer))
{
GPU_WARN << "hardware renderer can't initialize ... falling back to software renderer";
goto fallback;
}
}
else
{
fallback:
DeinitGPU(renderer);
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
DeinitRAY(renderer);
#endif
InitCPU(renderer);
}
}
vtkProp *mitk::GPUVolumeMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
if(!IsRenderable(renderer))
{
if(!m_VolumeNULL)
{
m_VolumeNULL = vtkSmartPointer<vtkVolume>::New();
m_VolumeNULL->VisibilityOff();
}
return m_VolumeNULL;
}
InitCommon();
InitVtkMapper( renderer );
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
if(ls->m_rayInitialized)
return ls->m_VolumeRAY;
#endif
if(ls->m_gpuInitialized)
return ls->m_VolumeGPU;
return ls->m_VolumeCPU;
}
void mitk::GPUVolumeMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
if(!IsRenderable(renderer))
return;
InitCommon();
InitVtkMapper( renderer );
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
m_UnitSpacingImageFilter->SetInput( inputData );
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
if(ls->m_rayInitialized)
{
GenerateDataRAY(renderer);
}
else
#endif
if(ls->m_gpuInitialized)
{
GenerateDataGPU(renderer);
}
else
{
GenerateDataCPU(renderer);
}
// UpdateTransferFunctions
UpdateTransferFunctions( renderer );
}
void mitk::GPUVolumeMapper3D::GenerateDataGPU( mitk::BaseRenderer *renderer )
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
bool useCompression = false;
GetDataNode()->GetBoolProperty("volumerendering.gpu.usetexturecompression",useCompression,renderer);
ls->m_MapperGPU->SetUseCompressedTexture(useCompression);
if( IsLODEnabled(renderer) && mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 )
ls->m_MapperGPU->SetSampleDistance(2.0);
else
ls->m_MapperGPU->SetSampleDistance(1.0);
// Updating shadings
{
float value=0;
if(GetDataNode()->GetFloatProperty("volumerendering.gpu.ambient",value,renderer))
ls->m_VolumePropertyGPU->SetAmbient(value);
if(GetDataNode()->GetFloatProperty("volumerendering.gpu.diffuse",value,renderer))
ls->m_VolumePropertyGPU->SetDiffuse(value);
if(GetDataNode()->GetFloatProperty("volumerendering.gpu.specular",value,renderer))
ls->m_VolumePropertyGPU->SetSpecular(value);
if(GetDataNode()->GetFloatProperty("volumerendering.gpu.specular.power",value,renderer))
ls->m_VolumePropertyGPU->SetSpecularPower(value);
}
}
void mitk::GPUVolumeMapper3D::GenerateDataCPU( mitk::BaseRenderer *renderer )
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
int nextLod = mitk::RenderingManager::GetInstance()->GetNextLOD( renderer );
if( IsLODEnabled(renderer) && nextLod == 0 )
{
ls->m_MapperCPU->SetImageSampleDistance(3.5);
ls->m_MapperCPU->SetSampleDistance(1.25);
ls->m_VolumePropertyCPU->SetInterpolationTypeToNearest();
}
else
{
ls->m_MapperCPU->SetImageSampleDistance(1.0);
ls->m_MapperCPU->SetSampleDistance(1.0);
ls->m_VolumePropertyCPU->SetInterpolationTypeToLinear();
}
// Check raycasting mode
if(IsMIPEnabled(renderer))
ls->m_MapperCPU->SetBlendModeToMaximumIntensity();
else
ls->m_MapperCPU->SetBlendModeToComposite();
// Updating shadings
{
float value=0;
if(GetDataNode()->GetFloatProperty("volumerendering.cpu.ambient",value,renderer))
ls->m_VolumePropertyCPU->SetAmbient(value);
if(GetDataNode()->GetFloatProperty("volumerendering.cpu.diffuse",value,renderer))
ls->m_VolumePropertyCPU->SetDiffuse(value);
if(GetDataNode()->GetFloatProperty("volumerendering.cpu.specular",value,renderer))
ls->m_VolumePropertyCPU->SetSpecular(value);
if(GetDataNode()->GetFloatProperty("volumerendering.cpu.specular.power",value,renderer))
ls->m_VolumePropertyCPU->SetSpecularPower(value);
}
}
void mitk::GPUVolumeMapper3D::CreateDefaultTransferFunctions()
{
m_DefaultOpacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
m_DefaultOpacityTransferFunction->AddPoint( 0.0, 0.0 );
m_DefaultOpacityTransferFunction->AddPoint( 255.0, 0.8 );
m_DefaultOpacityTransferFunction->ClampingOn();
m_DefaultGradientTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
m_DefaultGradientTransferFunction->AddPoint( 0.0, 0.0 );
m_DefaultGradientTransferFunction->AddPoint( 255.0, 0.8 );
m_DefaultGradientTransferFunction->ClampingOn();
m_DefaultColorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
m_DefaultColorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
m_DefaultColorTransferFunction->AddRGBPoint( 127.5, 1, 1, 0.0 );
m_DefaultColorTransferFunction->AddRGBPoint( 255.0, 0.8, 0.2, 0 );
m_DefaultColorTransferFunction->ClampingOn();
m_BinaryOpacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
m_BinaryOpacityTransferFunction->AddPoint( 0, 0.0 );
m_BinaryOpacityTransferFunction->AddPoint( 1, 1.0 );
m_BinaryGradientTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
m_BinaryGradientTransferFunction->AddPoint( 0.0, 1.0 );
m_BinaryColorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
}
void mitk::GPUVolumeMapper3D::UpdateTransferFunctions( mitk::BaseRenderer * renderer )
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
vtkPiecewiseFunction *opacityTransferFunction = m_DefaultOpacityTransferFunction;
vtkPiecewiseFunction *gradientTransferFunction = m_DefaultGradientTransferFunction;
vtkColorTransferFunction *colorTransferFunction = m_DefaultColorTransferFunction;
bool isBinary = false;
GetDataNode()->GetBoolProperty("binary", isBinary, renderer);
if(isBinary)
{
opacityTransferFunction = m_BinaryOpacityTransferFunction;
gradientTransferFunction = m_BinaryGradientTransferFunction;
colorTransferFunction = m_BinaryColorTransferFunction;
colorTransferFunction->RemoveAllPoints();
float rgb[3];
if( !GetDataNode()->GetColor( rgb,renderer ) )
rgb[0]=rgb[1]=rgb[2]=1;
colorTransferFunction->AddRGBPoint( 0,rgb[0],rgb[1],rgb[2] );
colorTransferFunction->Modified();
}
else
{
mitk::TransferFunctionProperty *transferFunctionProp =
dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("TransferFunction",renderer));
if( transferFunctionProp )
{
opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
}
}
if(ls->m_gpuInitialized)
{
ls->m_VolumePropertyGPU->SetColor( colorTransferFunction );
ls->m_VolumePropertyGPU->SetScalarOpacity( opacityTransferFunction );
ls->m_VolumePropertyGPU->SetGradientOpacity( gradientTransferFunction );
}
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
if(ls->m_rayInitialized)
{
ls->m_VolumePropertyRAY->SetColor( colorTransferFunction );
ls->m_VolumePropertyRAY->SetScalarOpacity( opacityTransferFunction );
ls->m_VolumePropertyRAY->SetGradientOpacity( gradientTransferFunction );
}
#endif
if(ls->m_cpuInitialized)
{
ls->m_VolumePropertyCPU->SetColor( colorTransferFunction );
ls->m_VolumePropertyCPU->SetScalarOpacity( opacityTransferFunction );
ls->m_VolumePropertyCPU->SetGradientOpacity( gradientTransferFunction );
}
}
void mitk::GPUVolumeMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* /*renderer*/)
{
//GPU_INFO << "ApplyProperties";
}
void mitk::GPUVolumeMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
//GPU_INFO << "SetDefaultProperties";
node->AddProperty( "volumerendering", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "volumerendering.usemip", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "volumerendering.uselod", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "volumerendering.cpu.ambient", mitk::FloatProperty::New( 0.10f ), renderer, overwrite );
node->AddProperty( "volumerendering.cpu.diffuse", mitk::FloatProperty::New( 0.50f ), renderer, overwrite );
node->AddProperty( "volumerendering.cpu.specular", mitk::FloatProperty::New( 0.40f ), renderer, overwrite );
node->AddProperty( "volumerendering.cpu.specular.power", mitk::FloatProperty::New( 16.0f ), renderer, overwrite );
bool usegpu = true;
#ifdef __APPLE__
usegpu = false;
node->AddProperty( "volumerendering.uselod", mitk::BoolProperty::New( true ), renderer, overwrite );
#endif
node->AddProperty( "volumerendering.usegpu", mitk::BoolProperty::New( usegpu ), renderer, overwrite );
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
node->AddProperty( "volumerendering.useray", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "volumerendering.ray.ambient", mitk::FloatProperty::New( 0.25f ), renderer, overwrite );
node->AddProperty( "volumerendering.ray.diffuse", mitk::FloatProperty::New( 0.50f ), renderer, overwrite );
node->AddProperty( "volumerendering.ray.specular", mitk::FloatProperty::New( 0.40f ), renderer, overwrite );
node->AddProperty( "volumerendering.ray.specular.power", mitk::FloatProperty::New( 16.0f ), renderer, overwrite );
#endif
node->AddProperty( "volumerendering.gpu.ambient", mitk::FloatProperty::New( 0.25f ), renderer, overwrite );
node->AddProperty( "volumerendering.gpu.diffuse", mitk::FloatProperty::New( 0.50f ), renderer, overwrite );
node->AddProperty( "volumerendering.gpu.specular", mitk::FloatProperty::New( 0.40f ), renderer, overwrite );
node->AddProperty( "volumerendering.gpu.specular.power", mitk::FloatProperty::New( 16.0f ), renderer, overwrite );
node->AddProperty( "volumerendering.gpu.usetexturecompression", mitk::BoolProperty ::New( false ), renderer, overwrite );
node->AddProperty( "volumerendering.gpu.reducesliceartifacts" , mitk::BoolProperty ::New( false ), renderer, overwrite );
node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
if(image.IsNotNull() && image->IsInitialized())
{
if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
{
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelwindow;
levelwindow.SetAuto( image );
levWinProp->SetLevelWindow( levelwindow );
node->SetProperty( "levelwindow", levWinProp, renderer );
}
if((overwrite) || (node->GetProperty("TransferFunction", renderer)==NULL))
{
// add a default transfer function
mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
tfInit->SetTransferFunctionMode(0);
node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
}
}
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
bool mitk::GPUVolumeMapper3D::IsLODEnabled( mitk::BaseRenderer * renderer ) const
{
bool value = false;
return GetDataNode()->GetBoolProperty("volumerendering.uselod",value,renderer) && value;
}
bool mitk::GPUVolumeMapper3D::IsMIPEnabled( mitk::BaseRenderer * renderer )
{
bool value = false;
return GetDataNode()->GetBoolProperty("volumerendering.usemip",value,renderer) && value;
}
bool mitk::GPUVolumeMapper3D::IsGPUEnabled( mitk::BaseRenderer * renderer )
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
bool value = false;
return ls->m_gpuSupported && GetDataNode()->GetBoolProperty("volumerendering.usegpu",value,renderer) && value;
}
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
bool mitk::GPUVolumeMapper3D::InitRAY(mitk::BaseRenderer* renderer)
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
if(ls->m_rayInitialized)
return ls->m_raySupported;
GPU_INFO << "initializing gpu-raycast-vr (vtkOpenGLGPUVolumeRayCastMapper)";
ls->m_MapperRAY = vtkSmartPointer<vtkOpenGLGPUVolumeRayCastMapper>::New();
ls->m_MapperRAY->SetAutoAdjustSampleDistances(0);
ls->m_MapperRAY->SetSampleDistance(1.0);
ls->m_VolumePropertyRAY = vtkSmartPointer<vtkVolumeProperty>::New();
ls->m_VolumePropertyRAY->ShadeOn();
ls->m_VolumePropertyRAY->SetAmbient (0.25f); //0.05f
ls->m_VolumePropertyRAY->SetDiffuse (0.50f); //0.45f
ls->m_VolumePropertyRAY->SetSpecular(0.40f); //0.50f
ls->m_VolumePropertyRAY->SetSpecularPower(16.0f);
ls->m_VolumePropertyRAY->SetInterpolationTypeToLinear();
ls->m_VolumeRAY = vtkSmartPointer<vtkVolume>::New();
ls->m_VolumeRAY->SetMapper( ls->m_MapperRAY );
ls->m_VolumeRAY->SetProperty( ls->m_VolumePropertyRAY );
ls->m_VolumeRAY->VisibilityOn();
ls->m_MapperRAY->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
ls->m_raySupported = ls->m_MapperRAY->IsRenderSupported(renderer->GetRenderWindow(),ls->m_VolumePropertyRAY);
ls->m_rayInitialized = true;
return ls->m_raySupported;
}
void mitk::GPUVolumeMapper3D::DeinitRAY(mitk::BaseRenderer* renderer)
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
if(ls->m_rayInitialized)
{
GPU_INFO << "deinitializing gpu-raycast-vr";
ls->m_MapperRAY = NULL;
ls->m_VolumePropertyRAY = NULL;
//Here ReleaseGraphicsResources has to be called to avoid VTK error messages.
//This seems like a VTK bug, because ReleaseGraphicsResources() is ment for internal use,
//but you cannot just delete the object (last smartpointer reference) without getting the
//VTK error.
ls->m_VolumeRAY->ReleaseGraphicsResources(renderer->GetVtkRenderer()->GetRenderWindow());
ls->m_VolumeRAY = NULL;
ls->m_rayInitialized=false;
}
}
void mitk::GPUVolumeMapper3D::GenerateDataRAY( mitk::BaseRenderer *renderer )
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
if( IsLODEnabled(renderer) && mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 )
ls->m_MapperRAY->SetImageSampleDistance(4.0);
else
ls->m_MapperRAY->SetImageSampleDistance(1.0);
// Check raycasting mode
if(IsMIPEnabled(renderer))
ls->m_MapperRAY->SetBlendModeToMaximumIntensity();
else
ls->m_MapperRAY->SetBlendModeToComposite();
// Updating shadings
{
float value=0;
if(GetDataNode()->GetFloatProperty("volumerendering.ray.ambient",value,renderer))
ls->m_VolumePropertyRAY->SetAmbient(value);
if(GetDataNode()->GetFloatProperty("volumerendering.ray.diffuse",value,renderer))
ls->m_VolumePropertyRAY->SetDiffuse(value);
if(GetDataNode()->GetFloatProperty("volumerendering.ray.specular",value,renderer))
ls->m_VolumePropertyRAY->SetSpecular(value);
if(GetDataNode()->GetFloatProperty("volumerendering.ray.specular.power",value,renderer))
ls->m_VolumePropertyRAY->SetSpecularPower(value);
}
}
bool mitk::GPUVolumeMapper3D::IsRAYEnabled( mitk::BaseRenderer * renderer )
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
bool value = false;
return ls->m_raySupported && GetDataNode()->GetBoolProperty("volumerendering.useray",value,renderer) && value;
}
#endif
diff --git a/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.h b/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.h
index 7622549925..5e1f2547ad 100644
--- a/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.h
+++ b/Modules/MitkExt/Rendering/mitkGPUVolumeMapper3D.h
@@ -1,197 +1,197 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKGPUVOLUMEMAPPER3D_H_HEADER_INCLUDED
#define MITKGPUVOLUMEMAPPER3D_H_HEADER_INCLUDED
//MITK
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkBaseRenderer.h"
#include "mitkImage.h"
#include "mitkVtkMapper.h"
#include "vtkMitkVolumeTextureMapper3D.h"
//VTK
#include <vtkFixedPointVolumeRayCastMapper.h>
#include <vtkGPUVolumeRayCastMapper.h>
#include <vtkVolumeProperty.h>
#include <vtkImageChangeInformation.h>
#include <vtkSmartPointer.h>
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
#include "vtkMitkGPUVolumeRayCastMapper.h"
#endif
namespace mitk {
/************************************************************************/
/* Properties that influence the mapper are:
*
* - \b "level window": for the level window of the volume data
* - \b "LookupTable" : for the lookup table of the volume data
* - \b "TransferFunction" (mitk::TransferFunctionProperty): for the used transfer function of the volume data
************************************************************************/
//##Documentation
//## @brief Vtk-based mapper for VolumeData
//##
//## @ingroup Mapper
class MitkExt_EXPORT GPUVolumeMapper3D : public VtkMapper
{
public:
mitkClassMacro(GPUVolumeMapper3D, VtkMapper);
itkNewMacro(Self);
virtual const mitk::Image* GetInput();
virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer);
virtual void ApplyProperties(vtkActor* actor, mitk::BaseRenderer* renderer);
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
/** Returns true if this Mapper currently allows for Level-of-Detail rendering.
* This reflects whether this Mapper currently invokes StartEvent, EndEvent, and
* ProgressEvent on BaseRenderer. */
virtual bool IsLODEnabled( BaseRenderer *renderer = NULL ) const;
bool IsMIPEnabled( BaseRenderer *renderer = NULL );
bool IsGPUEnabled( BaseRenderer *renderer = NULL );
bool IsRAYEnabled( BaseRenderer *renderer = NULL );
virtual void MitkRenderVolumetricGeometry(mitk::BaseRenderer* renderer);
protected:
GPUVolumeMapper3D();
virtual ~GPUVolumeMapper3D();
bool IsRenderable(mitk::BaseRenderer* renderer);
void InitCommon();
void DeinitCommon();
void InitCPU(mitk::BaseRenderer* renderer);
void DeinitCPU(mitk::BaseRenderer* renderer);
void GenerateDataCPU(mitk::BaseRenderer* renderer);
bool InitGPU(mitk::BaseRenderer* renderer);
void DeinitGPU(mitk::BaseRenderer* renderer);
void GenerateDataGPU(mitk::BaseRenderer* renderer);
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
bool InitRAY(mitk::BaseRenderer* renderer);
void DeinitRAY(mitk::BaseRenderer* renderer);
void GenerateDataRAY(mitk::BaseRenderer* renderer);
#endif
void InitVtkMapper(mitk::BaseRenderer* renderer);
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
void CreateDefaultTransferFunctions();
void UpdateTransferFunctions( mitk::BaseRenderer *renderer );
vtkSmartPointer<vtkVolume> m_VolumeNULL;
bool m_commonInitialized;
vtkSmartPointer<vtkImageChangeInformation> m_UnitSpacingImageFilter;
vtkSmartPointer<vtkPiecewiseFunction> m_DefaultOpacityTransferFunction;
vtkSmartPointer<vtkPiecewiseFunction> m_DefaultGradientTransferFunction;
vtkSmartPointer<vtkColorTransferFunction> m_DefaultColorTransferFunction;
vtkSmartPointer<vtkPiecewiseFunction> m_BinaryOpacityTransferFunction;
vtkSmartPointer<vtkPiecewiseFunction> m_BinaryGradientTransferFunction;
vtkSmartPointer<vtkColorTransferFunction> m_BinaryColorTransferFunction;
class LocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
bool m_cpuInitialized;
vtkSmartPointer<vtkVolume> m_VolumeCPU;
vtkSmartPointer<vtkFixedPointVolumeRayCastMapper> m_MapperCPU;
vtkSmartPointer<vtkVolumeProperty> m_VolumePropertyCPU;
bool m_gpuSupported;
bool m_gpuInitialized;
vtkSmartPointer<vtkVolume> m_VolumeGPU;
vtkSmartPointer<vtkMitkVolumeTextureMapper3D> m_MapperGPU;
vtkSmartPointer<vtkVolumeProperty> m_VolumePropertyGPU;
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
bool m_raySupported;
bool m_rayInitialized;
vtkSmartPointer<vtkVolume> m_VolumeRAY;
vtkSmartPointer<vtkGPUVolumeRayCastMapper> m_MapperRAY;
vtkSmartPointer<vtkVolumeProperty> m_VolumePropertyRAY;
#endif
LocalStorage()
{
m_cpuInitialized = false;
m_gpuInitialized = false;
m_gpuSupported = true; // assume initially gpu slicing is supported
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
m_rayInitialized = false;
m_raySupported = true; // assume initially gpu raycasting is supported
#endif
}
~LocalStorage()
{
if(m_cpuInitialized)
{
m_cpuInitialized=false;
}
if(m_gpuInitialized)
{
m_gpuInitialized=false;
}
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
if(m_rayInitialized)
{
m_rayInitialized=false;
}
#endif
}
};
- mitk::Mapper::LocalStorageHandler<LocalStorage> m_LSH;
+ mitk::LocalStorageHandler<LocalStorage> m_LSH;
};
} // namespace mitk
#endif /* MITKVOLUMEDATAVTKMAPPER3D_H_HEADER_INCLUDED */
diff --git a/Modules/MitkExt/Rendering/mitkLineMapper2D.h b/Modules/MitkExt/Rendering/mitkLineMapper2D.h
index 522422e51c..feaabf8e0a 100644
--- a/Modules/MitkExt/Rendering/mitkLineMapper2D.h
+++ b/Modules/MitkExt/Rendering/mitkLineMapper2D.h
@@ -1,56 +1,58 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKLINEMAPPER2D_H_HEADER_INCLUDED
#define MITKLINEMAPPER2D_H_HEADER_INCLUDED
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkPointSetGLMapper2D.h"
namespace mitk {
class BaseRenderer;
class PointSet;
//##Documentation
//## @brief OpenGL-based mapper to display Lines
//##
//## uses the information from the PointSet to build up the lines.
//## Only lines in 2D in one Slice are drawn, not between slices!
//## @ingroup Mapper
-class MitkExt_EXPORT LineMapper2D : public PointSetGLMapper2D
+
+/** \deprecatedSince{2013_06} This mapper is deprecated. */
+class DEPRECATED() MitkExt_EXPORT LineMapper2D : public PointSetGLMapper2D
{
public:
mitkClassMacro(LineMapper2D, PointSetGLMapper2D);
itkNewMacro(Self);
//##Documentation
//## @brief Get the PointDataList to map
const PointSet * GetInput(void);
virtual void Paint(mitk::BaseRenderer * renderer);
protected:
LineMapper2D();
virtual ~LineMapper2D();
};
} // namespace mitk
#endif /* MITKLINEMAPPER2D_H_HEADER_INCLUDED */
diff --git a/Modules/MitkExt/Rendering/mitkMeshVtkMapper3D.cpp b/Modules/MitkExt/Rendering/mitkMeshVtkMapper3D.cpp
index b1cfd0a309..67625fb791 100644
--- a/Modules/MitkExt/Rendering/mitkMeshVtkMapper3D.cpp
+++ b/Modules/MitkExt/Rendering/mitkMeshVtkMapper3D.cpp
@@ -1,228 +1,237 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkMeshVtkMapper3D.h"
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include "mitkVtkPropRenderer.h"
#ifndef VCL_VC60
#include "mitkMeshUtil.h"
#endif
#include <vtkActor.h>
#include <vtkFollower.h>
#include <vtkAssembly.h>
#include <vtkProp3DCollection.h>
#include <vtkRenderer.h>
#include <vtkPropAssembly.h>
#include <vtkProperty.h>
#include <vtkPolyDataMapper.h>
#include <stdlib.h>
const mitk::Mesh* mitk::MeshVtkMapper3D::GetInput()
{
return static_cast<const mitk::Mesh * > ( GetDataNode()->GetData() );
}
vtkProp* mitk::MeshVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
{
return m_PropAssembly;
}
void mitk::MeshVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
{
vtkLinearTransform * vtktransform =
- this->GetDataNode()->GetVtkTransform(this->GetTimestep());
+ this->GetDataNode()->GetVtkTransform(this->GetTimestep());
m_SpheresActor->SetUserTransform(vtktransform);
m_ContourActor->SetUserTransform(vtktransform);
}
mitk::MeshVtkMapper3D::MeshVtkMapper3D()
-: m_PropAssembly(NULL)
+ : m_PropAssembly(NULL)
{
m_Spheres = vtkAppendPolyData::New();
m_Contour = vtkPolyData::New();
m_SpheresActor = vtkActor::New();
m_SpheresMapper = vtkPolyDataMapper::New();
m_SpheresActor->SetMapper(m_SpheresMapper);
m_ContourActor = vtkActor::New();
m_ContourMapper = vtkPolyDataMapper::New();
m_ContourActor->SetMapper(m_ContourMapper);
m_ContourActor->GetProperty()->SetAmbient(1.0);
m_PropAssembly = vtkPropAssembly::New();
// a vtkPropAssembly is not a sub-class of vtkProp3D, so
// we cannot use m_Prop3D.
}
mitk::MeshVtkMapper3D::~MeshVtkMapper3D()
{
m_ContourActor->Delete();
m_SpheresActor->Delete();
m_ContourMapper->Delete();
m_SpheresMapper->Delete();
m_PropAssembly->Delete();
m_Spheres->Delete();
m_Contour->Delete();
}
void mitk::MeshVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer* renderer )
{
- m_PropAssembly->VisibilityOn();
+ BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+ bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
- if(m_PropAssembly->GetParts()->IsItemPresent(m_SpheresActor))
- m_PropAssembly->RemovePart(m_SpheresActor);
- if(m_PropAssembly->GetParts()->IsItemPresent(m_ContourActor))
- m_PropAssembly->RemovePart(m_ContourActor);
+ if(needGenerateData)
+ {
+ ls->UpdateGenerateDataTime();
- m_Spheres->RemoveAllInputs();
- m_Contour->Initialize();
+ m_PropAssembly->VisibilityOn();
- mitk::Mesh::Pointer input = const_cast<mitk::Mesh*>(this->GetInput());
- input->Update();
+ if(m_PropAssembly->GetParts()->IsItemPresent(m_SpheresActor))
+ m_PropAssembly->RemovePart(m_SpheresActor);
+ if(m_PropAssembly->GetParts()->IsItemPresent(m_ContourActor))
+ m_PropAssembly->RemovePart(m_ContourActor);
- mitk::Mesh::DataType::Pointer itkMesh = input->GetMesh( this->GetTimestep() );
+ m_Spheres->RemoveAllInputs();
+ m_Contour->Initialize();
- if ( itkMesh.GetPointer() == NULL)
- {
- m_PropAssembly->VisibilityOff();
- return;
- }
+ mitk::Mesh::Pointer input = const_cast<mitk::Mesh*>(this->GetInput());
+ input->Update();
+ mitk::Mesh::DataType::Pointer itkMesh = input->GetMesh( this->GetTimestep() );
- mitk::Mesh::PointsContainer::Iterator i;
+ if ( itkMesh.GetPointer() == NULL)
+ {
+ m_PropAssembly->VisibilityOff();
+ return;
+ }
- int j;
- float floatRgba[4] = {1.0f,1.0f,1.0f,1.0f};
- vtkFloatingPointType doubleRgba[4]={1.0f,1.0f,1.0f,1.0f};
- mitk::Color tmpColor;
+ mitk::Mesh::PointsContainer::Iterator i;
- // check for color prop and use it for rendering if it exists
- m_DataNode->GetColor(floatRgba, NULL);
+ int j;
- if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetProperty("unselectedcolor")) != NULL)
- {
- tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetProperty("unselectedcolor"))->GetValue();
- floatRgba[0] = tmpColor[0];
- floatRgba[1] = tmpColor[1];
- floatRgba[2] = tmpColor[2];
- floatRgba[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
- doubleRgba[0] = floatRgba[0];
- doubleRgba[1] = floatRgba[1];
- doubleRgba[2] = floatRgba[2];
- doubleRgba[3] = floatRgba[3];
- }
+ float floatRgba[4] = {1.0f,1.0f,1.0f,1.0f};
+ vtkFloatingPointType doubleRgba[4]={1.0f,1.0f,1.0f,1.0f};
+ mitk::Color tmpColor;
- if(itkMesh->GetNumberOfPoints()>0)
- {
- // build m_Spheres->GetOutput() vtkPolyData
- float pointSize = 2.0;
- mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
- if (pointSizeProp.IsNotNull())
- pointSize = pointSizeProp->GetValue();
+ // check for color prop and use it for rendering if it exists
+ m_DataNode->GetColor(floatRgba, NULL);
+
+ if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetProperty("unselectedcolor")) != NULL)
+ {
+ tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetProperty("unselectedcolor"))->GetValue();
+ floatRgba[0] = tmpColor[0];
+ floatRgba[1] = tmpColor[1];
+ floatRgba[2] = tmpColor[2];
+ floatRgba[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
+ doubleRgba[0] = floatRgba[0];
+ doubleRgba[1] = floatRgba[1];
+ doubleRgba[2] = floatRgba[2];
+ doubleRgba[3] = floatRgba[3];
+ }
- for (j=0, i=itkMesh->GetPoints()->Begin(); i!=itkMesh->GetPoints()->End() ; i++,j++)
+ if(itkMesh->GetNumberOfPoints()>0)
{
- vtkSphereSource *sphere = vtkSphereSource::New();
+ // build m_Spheres->GetOutput() vtkPolyData
+ float pointSize = 2.0;
+ mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
+ if (pointSizeProp.IsNotNull())
+ pointSize = pointSizeProp->GetValue();
- sphere->SetRadius(pointSize);
- sphere->SetCenter(i.Value()[0],i.Value()[1],i.Value()[2]);
+ for (j=0, i=itkMesh->GetPoints()->Begin(); i!=itkMesh->GetPoints()->End() ; i++,j++)
+ {
+ vtkSphereSource *sphere = vtkSphereSource::New();
- m_Spheres->AddInput(sphere->GetOutput());
- sphere->Delete();
- }
+ sphere->SetRadius(pointSize);
+ sphere->SetCenter(i.Value()[0],i.Value()[1],i.Value()[2]);
- // setup mapper, actor and add to assembly
- m_SpheresMapper->SetInput(m_Spheres->GetOutput());
- m_SpheresActor->GetProperty()->SetColor(doubleRgba);
- m_PropAssembly->AddPart(m_SpheresActor);
- }
+ m_Spheres->AddInput(sphere->GetOutput());
+ sphere->Delete();
+ }
- if(itkMesh->GetNumberOfCells()>0)
- {
- // build m_Contour vtkPolyData
+ // setup mapper, actor and add to assembly
+ m_SpheresMapper->SetInput(m_Spheres->GetOutput());
+ m_SpheresActor->GetProperty()->SetColor(doubleRgba);
+ m_PropAssembly->AddPart(m_SpheresActor);
+ }
+
+ if(itkMesh->GetNumberOfCells()>0)
+ {
+ // build m_Contour vtkPolyData
#ifdef VCL_VC60
- itkExceptionMacro(<<"MeshVtkMapper3D currently not working for MS Visual C++ 6.0, because MeshUtils are currently not supported.");
+ itkExceptionMacro(<<"MeshVtkMapper3D currently not working for MS Visual C++ 6.0, because MeshUtils are currently not supported.");
#else
- m_Contour = MeshUtil<mitk::Mesh::MeshType>::MeshToPolyData(itkMesh.GetPointer(), false, false, 0, NULL, m_Contour);
+ m_Contour = MeshUtil<mitk::Mesh::MeshType>::MeshToPolyData(itkMesh.GetPointer(), false, false, 0, NULL, m_Contour);
#endif
- if(m_Contour->GetNumberOfCells()>0)
- {
- // setup mapper, actor and add to assembly
- m_ContourMapper->SetInput(m_Contour);
- bool wireframe=true;
- GetDataNode()->GetVisibility(wireframe, NULL, "wireframe");
- if(wireframe)
- m_ContourActor->GetProperty()->SetRepresentationToWireframe();
- else
- m_ContourActor->GetProperty()->SetRepresentationToSurface();
- m_ContourActor->GetProperty()->SetColor(doubleRgba);
- m_PropAssembly->AddPart(m_ContourActor);
+ if(m_Contour->GetNumberOfCells()>0)
+ {
+ // setup mapper, actor and add to assembly
+ m_ContourMapper->SetInput(m_Contour);
+ bool wireframe=true;
+ GetDataNode()->GetVisibility(wireframe, NULL, "wireframe");
+ if(wireframe)
+ m_ContourActor->GetProperty()->SetRepresentationToWireframe();
+ else
+ m_ContourActor->GetProperty()->SetRepresentationToSurface();
+ m_ContourActor->GetProperty()->SetColor(doubleRgba);
+ m_PropAssembly->AddPart(m_ContourActor);
+ }
}
+
}
SetVtkMapperImmediateModeRendering(m_ContourMapper);
SetVtkMapperImmediateModeRendering(m_SpheresMapper);
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if(!visible)
{
m_SpheresActor->VisibilityOff();
m_ContourActor->VisibilityOff();
return;
}
bool makeContour = false;
this->GetDataNode()->GetBoolProperty("show contour", makeContour);
if (makeContour)
{
m_ContourActor->VisibilityOn();
}
else
{
m_ContourActor->VisibilityOff();
}
bool showPoints = true;
this->GetDataNode()->GetBoolProperty("show points", showPoints);
if(showPoints)
{
m_SpheresActor->VisibilityOn();
}
else
{
m_SpheresActor->VisibilityOff();
}
}
void mitk::MeshVtkMapper3D::ResetMapper( BaseRenderer* /*renderer*/ )
{
m_PropAssembly->VisibilityOff();
}
diff --git a/Modules/MitkExt/Rendering/mitkMeshVtkMapper3D.h b/Modules/MitkExt/Rendering/mitkMeshVtkMapper3D.h
index 3d1d18bd77..dbe3d69c33 100644
--- a/Modules/MitkExt/Rendering/mitkMeshVtkMapper3D.h
+++ b/Modules/MitkExt/Rendering/mitkMeshVtkMapper3D.h
@@ -1,90 +1,92 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKMESHVTKMAPPER3D_H_HEADER_INCLUDED
#define MITKMESHVTKMAPPER3D_H_HEADER_INCLUDED
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkVtkMapper.h"
#include "mitkMesh.h"
#include "mitkBaseRenderer.h"
#include <vtkSphereSource.h>
#include <vtkAppendPolyData.h>
#include <vtkPolyData.h>
#include <vtkPoints.h>
#include <vtkPointData.h>
#include <vtkCellArray.h>
#include <vtkFloatArray.h>
#include <vtkTubeFilter.h>
#include <vtkVectorText.h>
#include <vtkTextSource.h>
#include <vtkLinearTransform.h>
#include <vtkTransformPolyDataFilter.h>
class vtkActor;
class vtkAssembly;
class vtkFollower;
class vtkPolyDataMapper;
class vtkPropAssembly;
namespace mitk {
/**
* \brief Vtk-based mapper for PointList
* \ingroup Mapper
*/
class MitkExt_EXPORT MeshVtkMapper3D : public VtkMapper
{
public:
mitkClassMacro(MeshVtkMapper3D, VtkMapper);
itkNewMacro(Self);
virtual const mitk::Mesh* GetInput();
virtual vtkProp* GetVtkProp(mitk::BaseRenderer *renderer);
virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer);
+ LocalStorageHandler<BaseLocalStorage> m_LSH;
+
protected:
MeshVtkMapper3D();
virtual ~MeshVtkMapper3D();
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
virtual void ResetMapper( BaseRenderer* renderer );
vtkPropAssembly* m_PropAssembly;
vtkActor *m_SpheresActor;
vtkActor *m_ContourActor;
vtkPolyDataMapper* m_ContourMapper;
vtkPolyDataMapper* m_SpheresMapper;
vtkPolyDataMapper* m_TextVtkPolyDataMapper;
vtkAppendPolyData *m_Spheres;
vtkPolyData *m_Contour;
};
} // namespace mitk
#endif /* MITKMESHVTKMAPPER3D_H_HEADER_INCLUDED*/
diff --git a/Modules/MitkExt/Rendering/mitkSplineMapper2D.cpp b/Modules/MitkExt/Rendering/mitkSplineMapper2D.cpp
index f81f3c4a35..18d1f35445 100755
--- a/Modules/MitkExt/Rendering/mitkSplineMapper2D.cpp
+++ b/Modules/MitkExt/Rendering/mitkSplineMapper2D.cpp
@@ -1,193 +1,193 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSplineMapper2D.h"
#include "mitkSplineVtkMapper3D.h"
#include <mitkPlaneGeometry.h>
#include <mitkVector.h>
#include <mitkGeometry2D.h>
#include <mitkGL.h>
#include <vtkLinearTransform.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkPolyData.h>
void mitk::SplineMapper2D::Paint ( mitk::BaseRenderer * renderer )
{
Superclass::Paint ( renderer );
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible )
return;
//
// get the poly data of the splines in 3D
//
mitk::SplineVtkMapper3D::Pointer mapper3D = dynamic_cast<mitk::SplineVtkMapper3D*> ( this->GetDataNode()->GetMapper ( 2 ) );
if ( mapper3D.IsNull() )
{
itkWarningMacro ( "Mapper used for 3D mapping is not a mitk::SplineVtkMapper3D!" );
return;
}
//
// update the 3D spline, if the accoring mapper has not been updated yet
//
- if ( mapper3D->GetLastUpdateTime() < GetDataNode()->GetData()->GetMTime() )
+ //if ( mapper3D->GetLastUpdateTime() < GetDataNode()->GetData()->GetMTime() )
mapper3D->UpdateSpline();
vtkPolyData* spline3D = NULL;
if ( mapper3D->SplinesAreAvailable() )
spline3D = mapper3D->GetSplinesPolyData();
else
return;
if ( spline3D == NULL )
{
itkWarningMacro ( "3D spline is not available!" );
return;
}
//
// get the transform associated with the data tree node
//
vtkLinearTransform* transform = this->GetDataNode()->GetVtkTransform();
if ( transform == NULL )
{
itkWarningMacro("transfrom is NULL");
}
//
// get the plane geometry of the current renderer
//
mitk::Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
if ( worldGeometry.IsNull() )
{
itkWarningMacro("worldGeometry is NULL!");
return;
}
PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const mitk::PlaneGeometry*> ( worldGeometry.GetPointer() );
if ( worldPlaneGeometry.IsNull() )
{
itkWarningMacro("worldPlaneGeometry is NULL!");
return;
}
//
// determine color of the spline
//
float color[3];
this->GetDataNode()->GetColor ( color, renderer );
//
// iterate over the points
//
vtkPoints *vpoints = spline3D->GetPoints();
vtkCellArray *vlines = spline3D->GetLines();
if (vpoints == NULL)
{
itkWarningMacro("points are NULL!");
return;
}
if (vlines == NULL)
{
itkWarningMacro("lines are NULL!");
return;
}
mitk::Point3D currentPoint3D;
mitk::Point2D currentPoint2D;
vtkFloatingPointType currentPoint3DVtk[3];
vlines->InitTraversal();
int numberOfLines = vlines->GetNumberOfCells();
vtkFloatingPointType currentPointDistance;
for ( int i = 0;i < numberOfLines; ++i )
{
bool previousPointOnPlane = false;
bool currentPointOnPlane = false;
vtkIdType* cell ( NULL );
vtkIdType cellSize ( 0 );
vlines->GetNextCell ( cellSize, cell );
for ( int j = 0 ; j < cellSize; ++j )
{
vpoints->GetPoint ( cell[j], currentPoint3DVtk );
// take transformation via vtktransform into account
transform->TransformPoint ( currentPoint3DVtk, currentPoint3DVtk );
vtk2itk ( currentPoint3DVtk, currentPoint3D );
// check if the point has a distance to the plane
// which is smaller than m_MaxProjectionDistance
currentPointDistance = worldPlaneGeometry->DistanceFromPlane ( currentPoint3D );
if ( currentPointDistance < m_MaxProjectionDistance )
{
currentPointOnPlane = true;
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map ( currentPoint3D, currentPoint2D );
//convert point (until now mm and in worldcoordinates) to display coordinates (units )
renderer->GetDisplayGeometry()->WorldToDisplay ( currentPoint2D, currentPoint2D );
}
else
currentPointOnPlane = false;
//
// check if we have to begin or end a GL_LINE
//
if ( ( previousPointOnPlane == false ) && ( currentPointOnPlane == true ) )
{
glLineWidth ( m_LineWidth );
glColor3f ( color[0], color[1], color[2] );
glBegin ( GL_LINE_STRIP );
}
else if ( ( previousPointOnPlane == true ) && ( currentPointOnPlane == false ) )
{
glEnd ();
glLineWidth ( 1.0 );
}
// the current ponit is on the plane, add it as point to the
// line segment
if ( currentPointOnPlane == true )
{
glVertex2f ( currentPoint2D[0], currentPoint2D[1] );
}
previousPointOnPlane = currentPointOnPlane;
}
// the last point of the spline segment is on the plane, thus we have to
// close the GL_LINE
if ( previousPointOnPlane == true )
{
glEnd ();
glLineWidth ( 1.0 );
}
previousPointOnPlane = false;
}
}
void mitk::SplineMapper2D::ApplyProperties ( mitk::BaseRenderer* renderer )
{
ApplyColorAndOpacityProperties ( renderer );
}
mitk::SplineMapper2D::SplineMapper2D()
{
m_MaxProjectionDistance = 1;
m_ShowDistantLines = false ;
m_LineWidth = 1;
}
mitk::SplineMapper2D::~SplineMapper2D()
{}
diff --git a/Modules/MitkExt/Rendering/mitkSplineMapper2D.h b/Modules/MitkExt/Rendering/mitkSplineMapper2D.h
index 30c6d704fa..6743f83f85 100755
--- a/Modules/MitkExt/Rendering/mitkSplineMapper2D.h
+++ b/Modules/MitkExt/Rendering/mitkSplineMapper2D.h
@@ -1,83 +1,85 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKSplineMapper2D_H_HEADER_INCLUDED
#define MITKSplineMapper2D_H_HEADER_INCLUDED
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkGLMapper.h"
#include "mitkPointSetGLMapper2D.h"
#include <vtkSystemIncludes.h>
namespace mitk
{
class BaseRenderer;
class PointSet;
//##Documentation
//## @brief OpenGL-based mapper to display a spline based on a mitk::PointSet in a 2D window.
//##
/** This mapper can actually more than just draw a number of points of a
* mitk::PointSet. If you set the right properties of the mitk::DataNode,
* which contains the point set, then this mapper will also draw lines
* connecting the points, and calculate and display distances and angles
* between adjacent points. Here is a complete list of boolean properties,
* which might be of interest:
*
* - \b "show contour": Draw not only the points but also the connections between
* them (default false)
* - \b "line width": IntProperty which gives the width of the contour lines
* - \b "show points": Wheter or not to draw the actual points (default true)
* - \b "show distances": Wheter or not to calculate and print the distance
* between adjacent points (default false)
* - \b "show angles": Wheter or not to calculate and print the angle between
* adjacent points (default false)
* - \b "show distant lines": When true, the mapper will also draw contour
* lines that are far away form the current slice (default true)
* - \b "label": StringProperty with a label for this point set
*/
//## @ingroup Mapper
-class MitkExt_EXPORT SplineMapper2D : public PointSetGLMapper2D
+
+/** \deprecatedSince{2013_06} This mapper is deprecated. */
+class DEPRECATED() MitkExt_EXPORT SplineMapper2D : public PointSetGLMapper2D
{
public:
mitkClassMacro ( SplineMapper2D, PointSetGLMapper2D );
itkNewMacro ( Self );
virtual void Paint ( mitk::BaseRenderer * renderer );
virtual void ApplyProperties ( mitk::BaseRenderer* renderer );
itkSetMacro ( MaxProjectionDistance, vtkFloatingPointType );
itkGetMacro ( MaxProjectionDistance, vtkFloatingPointType );
protected:
SplineMapper2D();
virtual ~SplineMapper2D();
vtkFloatingPointType m_MaxProjectionDistance;
};
} // namespace mitk
#endif /* MITKSplineMapper2D_H_HEADER_INCLUDED */
diff --git a/Modules/MitkExt/Rendering/mitkSplineVtkMapper3D.cpp b/Modules/MitkExt/Rendering/mitkSplineVtkMapper3D.cpp
index 9c311a3227..a7108fceaf 100644
--- a/Modules/MitkExt/Rendering/mitkSplineVtkMapper3D.cpp
+++ b/Modules/MitkExt/Rendering/mitkSplineVtkMapper3D.cpp
@@ -1,234 +1,231 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSplineVtkMapper3D.h"
#include <vtkProp.h>
#include <vtkPropAssembly.h>
#include <vtkCardinalSpline.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkProperty.h>
#include <vtkTubeFilter.h>
#include <vtkPropCollection.h>
#include <mitkProperties.h>
#include <mitkPointSet.h>
mitk::SplineVtkMapper3D::SplineVtkMapper3D()
: m_SplinesAvailable (false), m_SplinesAddedToAssembly(false)
{
m_SplinesActor = vtkActor::New();
m_SplineAssembly = vtkPropAssembly::New();
m_SplineResolution = 500;
}
mitk::SplineVtkMapper3D::~SplineVtkMapper3D()
{
m_SplinesActor->Delete();
m_SplineAssembly->Delete();
}
vtkProp*
mitk::SplineVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
{
return m_SplineAssembly;
}
void mitk::SplineVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
{
vtkLinearTransform * vtktransform =
this->GetDataNode()->GetVtkTransform(this->GetTimestep());
m_SplinesActor->SetUserTransform(vtktransform);
}
void mitk::SplineVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer* renderer )
{
+ BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
// only update spline if UpdateSpline has not been called from
// external, e.g. by the SplineMapper2D. But call it the first time when m_SplineUpdateTime = 0 and m_LastUpdateTime = 0.
- if ( m_SplineUpdateTime < m_LastUpdateTime || m_SplineUpdateTime == 0)
+ if ( m_SplineUpdateTime < ls->GetLastGenerateDataTime() || m_SplineUpdateTime == 0)
{
this->UpdateSpline();
this->ApplyAllProperties(renderer, m_SplinesActor);
}
if ( m_SplinesAvailable )
{
if ( ! m_SplinesAddedToAssembly )
{
m_SplineAssembly->AddPart( m_SplinesActor );
m_SplinesAddedToAssembly = true;
}
}
else
{
if ( m_SplinesAddedToAssembly )
{
m_SplineAssembly->RemovePart( m_SplinesActor );
m_SplinesAddedToAssembly = false;
}
}
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if(!visible)
{
m_SplinesActor->VisibilityOff();
m_SplineAssembly->VisibilityOff();
}
else
{
m_SplinesActor->VisibilityOn();
m_SplineAssembly->VisibilityOn();
//remove the PointsAssembly if it was added in superclass. No need to display points and spline!
if(m_SplineAssembly->GetParts()->IsItemPresent(m_PointsAssembly))
m_SplineAssembly->RemovePart(m_PointsAssembly);
}
//if the properties have been changed, then refresh the properties
if ( (m_SplineUpdateTime < this->m_DataNode->GetPropertyList()->GetMTime() ) ||
(m_SplineUpdateTime < this->m_DataNode->GetPropertyList(renderer)->GetMTime() ) )
this->ApplyAllProperties(renderer, m_SplinesActor);
}
void mitk::SplineVtkMapper3D::ApplyAllProperties(BaseRenderer *renderer, vtkActor *actor)
{
Superclass::ApplyColorAndOpacityProperties(renderer, actor);
//vtk changed the type of rgba during releases. Due to that, the following convert is done
vtkFloatingPointType rgba[ 4 ] = {1.0f, 1.0f, 1.0f, 1.0f};//white
//getting the color from DataNode
float temprgba[4];
this->GetDataNode()->GetColor( &temprgba[0], NULL );
//convert to rgba, what ever type it has!
rgba[0] = temprgba[0]; rgba[1] = temprgba[1]; rgba[2] = temprgba[2]; rgba[3] = temprgba[3];
//finaly set the color inside the actor
m_SplinesActor->GetProperty()->SetColor( rgba );
float lineWidth;
if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("line width")) == NULL)
lineWidth = 1.0;
else
lineWidth = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("line width"))->GetValue();
m_SplinesActor->GetProperty()->SetLineWidth(lineWidth);
m_SplineUpdateTime.Modified();
}
bool mitk::SplineVtkMapper3D::SplinesAreAvailable()
{
return m_SplinesAvailable;
}
vtkPolyData* mitk::SplineVtkMapper3D::GetSplinesPolyData()
{
if ( m_SplinesAvailable )
return ( dynamic_cast<vtkPolyDataMapper*>( m_SplinesActor->GetMapper() ) )->GetInput();
else
return NULL;
}
vtkActor* mitk::SplineVtkMapper3D::GetSplinesActor()
{
if ( m_SplinesAvailable )
return m_SplinesActor;
else
return vtkActor::New();
}
-unsigned long mitk::SplineVtkMapper3D::GetLastUpdateTime() const
-{
- return m_LastUpdateTime.GetMTime();
-}
void mitk::SplineVtkMapper3D::UpdateSpline()
{
mitk::PointSet::Pointer input = const_cast<mitk::PointSet*>( this->GetInput( ) );
// input->Update();//already done in superclass
// Number of points on the spline
unsigned int numberOfOutputPoints = m_SplineResolution;
unsigned int numberOfInputPoints = input->GetSize();
if ( numberOfInputPoints >= 2 )
{
m_SplinesAvailable = true;
vtkCardinalSpline* splineX = vtkCardinalSpline::New();
vtkCardinalSpline* splineY = vtkCardinalSpline::New();
vtkCardinalSpline* splineZ = vtkCardinalSpline::New();
unsigned int index = 0;
mitk::PointSet::DataType::PointsContainer::Pointer pointsContainer = input->GetPointSet()->GetPoints();
for ( mitk::PointSet::DataType::PointsContainer::Iterator it = pointsContainer->Begin(); it != pointsContainer->End(); ++it, ++index )
//for ( unsigned int i = 0 ; i < numberOfInputPoints; ++i )
{
mitk::PointSet::PointType point = it->Value();
splineX->AddPoint( index, point[ 0 ] );
splineY->AddPoint( index, point[ 1 ] );
splineZ->AddPoint( index, point[ 2 ] );
}
vtkPoints* points = vtkPoints::New();
vtkPolyData* profileData = vtkPolyData::New();
// Interpolate x, y and z by using the three spline filters and
// create new points
double t = 0.0f;
for ( unsigned int i = 0; i < numberOfOutputPoints; ++i )
{
t = ( ( ( ( double ) numberOfInputPoints ) - 1.0f ) / ( ( ( double ) numberOfOutputPoints ) - 1.0f ) ) * ( ( double ) i );
points->InsertPoint( i, splineX->Evaluate( t ), splineY->Evaluate( t ), splineZ->Evaluate( t ) ) ;
}
// Create the polyline.
vtkCellArray* lines = vtkCellArray::New();
lines->InsertNextCell( numberOfOutputPoints );
for ( unsigned int i = 0; i < numberOfOutputPoints; ++i )
lines->InsertCellPoint( i );
profileData->SetPoints( points );
profileData->SetLines( lines );
// Add thickness to the resulting line.
//vtkTubeFilter* profileTubes = vtkTubeFilter::New();
//profileTubes->SetNumberOfSides(8);
//profileTubes->SetInput(profileData);
//profileTubes->SetRadius(.005);
vtkPolyDataMapper* profileMapper = vtkPolyDataMapper::New();
profileMapper->SetInput( profileData );
m_SplinesActor->SetMapper( profileMapper );
}
else
{
m_SplinesAvailable = false;
}
m_SplineUpdateTime.Modified();
}
diff --git a/Modules/MitkExt/Rendering/mitkSplineVtkMapper3D.h b/Modules/MitkExt/Rendering/mitkSplineVtkMapper3D.h
index dd9a41691b..2ce020e977 100644
--- a/Modules/MitkExt/Rendering/mitkSplineVtkMapper3D.h
+++ b/Modules/MitkExt/Rendering/mitkSplineVtkMapper3D.h
@@ -1,96 +1,94 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_SPLINE_VTK_MAPPER_3D__H
#define _MITK_SPLINE_VTK_MAPPER_3D__H
#include "mitkPointSetVtkMapper3D.h"
#include "MitkExtExports.h"
class vtkActor;
class vtkAssembly;
namespace mitk
{
//##Documentation
//## @brief Vtk-based mapper for Splines
//##
//## properties looked for:
//## "line width" = with of the spline
//## @ingroup Mapper
/************************************************************************/
/*
* - \b "line width": (FloatProperty) line width of the spline
*/
/************************************************************************/
class MitkExt_EXPORT SplineVtkMapper3D : public PointSetVtkMapper3D
{
public:
mitkClassMacro( SplineVtkMapper3D, PointSetVtkMapper3D );
itkNewMacro( Self );
virtual vtkProp* GetVtkProp(mitk::BaseRenderer *renderer);
virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer);
bool SplinesAreAvailable();
vtkPolyData* GetSplinesPolyData();
vtkActor* GetSplinesActor();
- unsigned long GetLastUpdateTime() const;
-
virtual void UpdateSpline();
itkSetMacro( SplineResolution, unsigned int );
itkGetMacro( SplineResolution, unsigned int );
protected:
SplineVtkMapper3D();
virtual ~SplineVtkMapper3D();
virtual void GenerateDataForRenderer(mitk::BaseRenderer * renderer);
virtual void ApplyAllProperties(BaseRenderer *renderer, vtkActor *actor);
vtkActor* m_SplinesActor;
vtkPropAssembly* m_SplineAssembly;
bool m_SplinesAvailable;
bool m_SplinesAddedToAssembly;
unsigned int m_SplineResolution;
itk::TimeStamp m_SplineUpdateTime;
};
} //namespace mitk
#endif
diff --git a/Modules/MitkExt/Rendering/mitkUnstructuredGridMapper2D.cpp b/Modules/MitkExt/Rendering/mitkUnstructuredGridMapper2D.cpp
index 8ce7980bee..11c4748d44 100644
--- a/Modules/MitkExt/Rendering/mitkUnstructuredGridMapper2D.cpp
+++ b/Modules/MitkExt/Rendering/mitkUnstructuredGridMapper2D.cpp
@@ -1,567 +1,575 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkGL.h>
#include "mitkUnstructuredGridMapper2D.h"
#include "mitkBaseRenderer.h"
#include "mitkPlaneGeometry.h"
#include "mitkUnstructuredGrid.h"
#include "mitkTransferFunction.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkColorProperty.h"
#include "mitkVtkScalarModeProperty.h"
#include "mitkProperties.h"
#include "mitkAbstractTransformGeometry.h"
#include "mitkVtkMapper3D.h"
#include <vtkPointSetSlicer.h>
#include <vtkUnstructuredGrid.h>
#include <vtkPlane.h>
#include <vtkCellArray.h>
#include <vtkLookupTable.h>
#include <vtkPointData.h>
#include <vtkCellData.h>
#include <vtkLinearTransform.h>
#include <vtkVolume.h>
#include <vtkAssembly.h>
#include <vtkVolumeProperty.h>
#include <vtkAbstractMapper3D.h>
#include <vtkAbstractVolumeMapper.h>
#include <vtkScalarsToColors.h>
#include <vtkPiecewiseFunction.h>
#include <vtkColorTransferFunction.h>
#include <vtkProp3DCollection.h>
void mitk::UnstructuredGridMapper2D::GenerateDataForRenderer( mitk::BaseRenderer* renderer )
{
- mitk::DataNode::ConstPointer node = this->GetDataNode();
- if ( node.IsNull() )
- return;
+ BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+ bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
- if (!node->GetProperty(m_ScalarMode, "scalar mode"))
+ if(needGenerateData)
{
- m_ScalarMode = mitk::VtkScalarModeProperty::New(0);
- }
+ ls->UpdateGenerateDataTime();
- if (!node->GetProperty(m_ScalarVisibility, "scalar visibility"))
- {
- m_ScalarVisibility = mitk::BoolProperty::New(true);
- }
+ mitk::DataNode::ConstPointer node = this->GetDataNode();
+ if ( node.IsNull() )
+ return;
- if (!node->GetProperty(m_Outline, "outline polygons"))
- {
- m_Outline = mitk::BoolProperty::New(false);
- }
+ if (!node->GetProperty(m_ScalarMode, "scalar mode"))
+ {
+ m_ScalarMode = mitk::VtkScalarModeProperty::New(0);
+ }
- if (!node->GetProperty(m_Color, "color"))
- {
- m_Color = mitk::ColorProperty::New(1.0f, 1.0f, 1.0f);
- }
+ if (!node->GetProperty(m_ScalarVisibility, "scalar visibility"))
+ {
+ m_ScalarVisibility = mitk::BoolProperty::New(true);
+ }
- if (!node->GetProperty(m_LineWidth, "line width"))
- {
- m_LineWidth = mitk::IntProperty::New(1);
- }
+ if (!node->GetProperty(m_Outline, "outline polygons"))
+ {
+ m_Outline = mitk::BoolProperty::New(false);
+ }
+ if (!node->GetProperty(m_Color, "color"))
+ {
+ m_Color = mitk::ColorProperty::New(1.0f, 1.0f, 1.0f);
+ }
+
+ if (!node->GetProperty(m_LineWidth, "line width"))
+ {
+ m_LineWidth = mitk::IntProperty::New(1);
+ }
+
+ }
mitk::BaseData::Pointer input = const_cast<mitk::BaseData*>( GetDataNode()->GetData() );
assert( input );
input->Update();
if (m_VtkPointSet) m_VtkPointSet->UnRegister(0);
m_VtkPointSet = this->GetVtkPointSet(renderer);
assert(m_VtkPointSet);
m_VtkPointSet->Register(0);
if (m_ScalarVisibility->GetValue())
{
mitk::DataNode::ConstPointer node = this->GetDataNode();
mitk::TransferFunctionProperty::Pointer transferFuncProp;
node->GetProperty(transferFuncProp, "TransferFunction", renderer);
if (transferFuncProp.IsNotNull())
{
mitk::TransferFunction::Pointer tf = transferFuncProp->GetValue();
if (m_ScalarsToColors) m_ScalarsToColors->UnRegister(0);
m_ScalarsToColors = static_cast<vtkScalarsToColors*>(tf->GetColorTransferFunction());
m_ScalarsToColors->Register(0);
if (m_ScalarsToOpacity) m_ScalarsToOpacity->UnRegister(0);
m_ScalarsToOpacity = tf->GetScalarOpacityFunction();
m_ScalarsToOpacity->Register(0);
}
else
{
if (m_ScalarsToColors) m_ScalarsToColors->UnRegister(0);
m_ScalarsToColors = this->GetVtkLUT(renderer);
assert(m_ScalarsToColors);
m_ScalarsToColors->Register(0);
float opacity;
node->GetOpacity(opacity, renderer);
if (m_ScalarsToOpacity) m_ScalarsToOpacity->UnRegister(0);
m_ScalarsToOpacity = vtkPiecewiseFunction::New();
double range[2];
m_VtkPointSet->GetScalarRange(range);
m_ScalarsToOpacity->AddSegment(range[0], opacity, range[1], opacity);
}
}
}
void mitk::UnstructuredGridMapper2D::Paint( mitk::BaseRenderer* renderer )
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if(!visible) return;
vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform();
vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
Point3D point;
Vector3D normal;
if(worldPlaneGeometry.IsNotNull())
{
// set up vtkPlane according to worldGeometry
point=worldPlaneGeometry->GetOrigin();
normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
m_Plane->SetTransform((vtkAbstractTransform*)NULL);
}
else
{
//@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "plane plane" into a "curved plane"?
return;
AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldGeometry2D());
if(worldAbstractGeometry.IsNotNull())
{
// set up vtkPlane according to worldGeometry
point=const_cast<mitk::BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
FillVector3D(normal, 0, 0, 1);
m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
}
else
return;
}
vtkFloatingPointType vp[ 3 ], vnormal[ 3 ];
vnl2vtk(point.Get_vnl_vector(), vp);
vnl2vtk(normal.Get_vnl_vector(), vnormal);
//normally, we would need to transform the surface and cut the transformed surface with the cutter.
//This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
//@todo It probably does not work for scaling operations yet:scaling operations have to be
//dealed with after the cut is performed by scaling the contour.
inversetransform->TransformPoint( vp, vp );
inversetransform->TransformNormalAtPoint( vp, vnormal, vnormal );
m_Plane->SetOrigin( vp );
m_Plane->SetNormal( vnormal );
// set data into cutter
m_Slicer->SetInput( m_VtkPointSet );
// m_Cutter->GenerateCutScalarsOff();
// m_Cutter->SetSortByToSortByCell();
// calculate the cut
m_Slicer->Update();
// fetch geometry
mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
assert( displayGeometry );
// float toGL=displayGeometry->GetSizeInDisplayUnits()[1];
//apply color and opacity read from the PropertyList
ApplyColorAndOpacityProperties( renderer );
// traverse the cut contour
vtkPolyData * contour = m_Slicer->GetOutput();
vtkPoints *vpoints = contour->GetPoints();
vtkCellArray *vlines = contour->GetLines();
vtkCellArray *vpolys = contour->GetPolys();
vtkPointData *vpointdata = contour->GetPointData();
vtkDataArray* vscalars = vpointdata->GetScalars();
vtkCellData *vcelldata = contour->GetCellData();
vtkDataArray* vcellscalars = vcelldata->GetScalars();
const int numberOfLines = contour->GetNumberOfLines();
const int numberOfPolys = contour->GetNumberOfPolys();
const bool useCellData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT ||
- m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA;
+ m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA;
const bool usePointData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA;
Point3D p;
Point2D p2d;
vlines->InitTraversal();
vpolys->InitTraversal();
mitk::Color outlineColor = m_Color->GetColor();
glLineWidth((float)m_LineWidth->GetValue());
for (int i = 0;i < numberOfLines;++i )
{
vtkIdType *cell(0);
vtkIdType cellSize(0);
vlines->GetNextCell( cellSize, cell );
float rgba[4] = {outlineColor[0], outlineColor[1], outlineColor[2], 1.0f};
if (m_ScalarVisibility->GetValue() && vcellscalars)
{
if ( useCellData )
{ // color each cell according to cell data
double scalar = vcellscalars->GetComponent( i, 0 );
double rgb[3] = { 1.0f, 1.0f, 1.0f };
m_ScalarsToColors->GetColor(scalar, rgb);
rgba[0] = (float)rgb[0];
rgba[1] = (float)rgb[1];
rgba[2] = (float)rgb[2];
rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
}
else if ( usePointData )
{
double scalar = vscalars->GetComponent( i, 0 );
double rgb[3] = { 1.0f, 1.0f, 1.0f };
m_ScalarsToColors->GetColor(scalar, rgb);
rgba[0] = (float)rgb[0];
rgba[1] = (float)rgb[1];
rgba[2] = (float)rgb[2];
rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
}
}
glColor4fv( rgba );
glBegin ( GL_LINE_LOOP );
for ( int j = 0;j < cellSize;++j )
{
vpoints->GetPoint( cell[ j ], vp );
//take transformation via vtktransform into account
vtktransform->TransformPoint( vp, vp );
vtk2itk( vp, p );
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map( p, p2d );
//convert point (until now mm and in worldcoordinates) to display coordinates (units )
displayGeometry->WorldToDisplay( p2d, p2d );
//convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
//p2d[1]=toGL-p2d[1];
//add the current vertex to the line
glVertex2f( p2d[0], p2d[1] );
}
glEnd ();
}
bool polyOutline = m_Outline->GetValue();
bool scalarVisibility = m_ScalarVisibility->GetValue();
// cache the transformed points
// a fixed size array is way faster than 'new'
// slices through 3d cells usually do not generated
// polygons with more than 6 vertices
const int maxPolySize = 10;
Point2D* cachedPoints = new Point2D[maxPolySize*numberOfPolys];
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// only draw polygons if there are cell scalars
// or the outline property is set to true
if (scalarVisibility && vcellscalars)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
for (int i = 0;i < numberOfPolys;++i )
{
vtkIdType *cell(0);
vtkIdType cellSize(0);
vpolys->GetNextCell( cellSize, cell );
float rgba[4] = {1.0f, 1.0f, 1.0f, 0};
if (scalarVisibility && vcellscalars)
{
if ( useCellData )
{ // color each cell according to cell data
double scalar = vcellscalars->GetComponent( i+numberOfLines, 0 );
double rgb[3] = { 1.0f, 1.0f, 1.0f };
m_ScalarsToColors->GetColor(scalar, rgb);
rgba[0] = (float)rgb[0];
rgba[1] = (float)rgb[1];
rgba[2] = (float)rgb[2];
rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
}
else if ( usePointData )
{
double scalar = vscalars->GetComponent( i, 0 );
double rgb[3] = { 1.0f, 1.0f, 1.0f };
m_ScalarsToColors->GetColor(scalar, rgb);
rgba[0] = (float)rgb[0];
rgba[1] = (float)rgb[1];
rgba[2] = (float)rgb[2];
rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
}
}
glColor4fv( rgba );
glBegin( GL_POLYGON );
for (int j = 0; j < cellSize; ++j)
{
vpoints->GetPoint( cell[ j ], vp );
//take transformation via vtktransform into account
vtktransform->TransformPoint( vp, vp );
vtk2itk( vp, p );
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map( p, p2d );
//convert point (until now mm and in worldcoordinates) to display coordinates (units )
displayGeometry->WorldToDisplay( p2d, p2d );
//convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
//p2d[1]=toGL-p2d[1];
cachedPoints[i*10+j][0] = p2d[0];
cachedPoints[i*10+j][1] = p2d[1];
//add the current vertex to the line
glVertex2f( p2d[0], p2d[1] );
}
glEnd();
}
if (polyOutline)
{
vpolys->InitTraversal();
glColor4f(outlineColor[0], outlineColor[1], outlineColor[2], 1.0f);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
for (int i = 0;i < numberOfPolys;++i)
{
vtkIdType *cell(0);
vtkIdType cellSize(0);
vpolys->GetNextCell( cellSize, cell );
glBegin( GL_POLYGON );
//glPolygonOffset(1.0, 1.0);
for (int j = 0; j < cellSize; ++j)
{
//add the current vertex to the line
glVertex2f( cachedPoints[i*10+j][0], cachedPoints[i*10+j][1] );
}
glEnd();
}
}
}
glDisable(GL_BLEND);
delete cachedPoints;
}
vtkAbstractMapper3D*
mitk::UnstructuredGridMapper2D
::GetVtkAbstractMapper3D(mitk::BaseRenderer * renderer)
{
//MITK_INFO << "GETVTKABSTRACTMAPPER3D\n";
mitk::DataNode::ConstPointer node = this->GetDataNode();
if ( node.IsNull() )
return 0;
mitk::VtkMapper::Pointer mitkMapper = dynamic_cast< mitk::VtkMapper* > ( node->GetMapper( 2 ) );
if ( mitkMapper.IsNull() )
{
return 0;
}
mitkMapper->Update(renderer);
vtkAssembly* assembly = dynamic_cast<vtkAssembly*>(mitkMapper->GetVtkProp(renderer));
if (assembly)
{
- vtkProp3DCollection* collection = assembly->GetParts();
- collection->InitTraversal();
- vtkProp3D* prop3d = 0;
- do
- {
- prop3d = collection->GetNextProp3D();
+ vtkProp3DCollection* collection = assembly->GetParts();
+ collection->InitTraversal();
+ vtkProp3D* prop3d = 0;
+ do
+ {
+ prop3d = collection->GetNextProp3D();
vtkActor* actor = dynamic_cast<vtkActor*>( prop3d );
if (actor)
{
return dynamic_cast<vtkAbstractMapper3D*>( actor->GetMapper() );
}
vtkVolume* volume = dynamic_cast<vtkVolume*>( prop3d );
if (volume)
{
return dynamic_cast<vtkAbstractMapper3D*>( volume->GetMapper() );
}
} while (prop3d != collection->GetLastProp3D());
}
else
{
vtkActor* actor = dynamic_cast<vtkActor*>( mitkMapper->GetVtkProp(renderer) );
if (actor)
{
return dynamic_cast<vtkAbstractMapper3D*>( actor->GetMapper() );
}
vtkVolume* volume = dynamic_cast<vtkVolume*>( mitkMapper->GetVtkProp(renderer) );
if (volume)
{
return dynamic_cast<vtkAbstractMapper3D*>( volume->GetMapper() );
}
}
return 0;
}
vtkPointSet*
mitk::UnstructuredGridMapper2D
::GetVtkPointSet(mitk::BaseRenderer* renderer)
{
//MITK_INFO << "GETVTKPOINTSET\n";
vtkAbstractMapper3D * abstractMapper = GetVtkAbstractMapper3D(renderer);
if ( abstractMapper == 0 )
{
// try to get data from the node
mitk::DataNode::ConstPointer node = this->GetDataNode();
if ( node.IsNull() )
return 0;
mitk::BaseData::Pointer data = node->GetData();
mitk::UnstructuredGrid::Pointer grid = dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer());
if (!grid.IsNull())
return static_cast<vtkPointSet*>(grid->GetVtkUnstructuredGrid());
- return 0;
+ return 0;
}
else
{
vtkMapper* mapper = dynamic_cast<vtkMapper*>(abstractMapper);
if (mapper)
{
return dynamic_cast<vtkPointSet*>(mapper->GetInput());
}
vtkAbstractVolumeMapper* volMapper = dynamic_cast<vtkAbstractVolumeMapper*>(abstractMapper);
if (volMapper)
{
return dynamic_cast<vtkPointSet*>(volMapper->GetDataSetInput());
}
}
return 0;
}
vtkScalarsToColors* mitk::UnstructuredGridMapper2D::GetVtkLUT(mitk::BaseRenderer* renderer)
{
//MITK_INFO << "GETVTKLUT\n";
vtkMapper * mapper = dynamic_cast<vtkMapper*>(GetVtkAbstractMapper3D(renderer));
if (mapper)
return mapper->GetLookupTable();
else
{
mitk::DataNode::ConstPointer node = this->GetDataNode();
if ( node.IsNull() )
return 0;
mitk::VtkMapper::Pointer mitkMapper = dynamic_cast< mitk::VtkMapper* > ( node->GetMapper( 2 ) );
if ( mitkMapper.IsNull() )
{
//MITK_INFO << "mitkMapper is null\n";
return 0;
}
mitkMapper->Update(renderer);
vtkVolume* volume = dynamic_cast<vtkVolume*>( mitkMapper->GetVtkProp(renderer) );
if (volume)
{
//MITK_INFO << "found volume prop\n";
return static_cast<vtkScalarsToColors*>(volume->GetProperty()->GetRGBTransferFunction());
}
vtkAssembly* assembly = dynamic_cast<vtkAssembly*>(mitkMapper->GetVtkProp(renderer));
if (assembly)
{
//MITK_INFO << "found assembly prop\n";
mitk::TransferFunctionProperty::Pointer transferFuncProp;
node->GetProperty(transferFuncProp, "TransferFunction", 0);
if (transferFuncProp.IsNotNull())
{
MITK_INFO << "return colortransferfunction\n";
return static_cast<vtkScalarsToColors*>(transferFuncProp->GetValue()->GetColorTransferFunction());
}
}
return 0;
}
}
bool mitk::UnstructuredGridMapper2D::IsConvertibleToVtkPointSet(mitk::BaseRenderer * renderer)
{
- return ( GetVtkPointSet(renderer) != 0 );
+ return ( GetVtkPointSet(renderer) != 0 );
}
mitk::UnstructuredGridMapper2D::UnstructuredGridMapper2D()
{
- m_Plane = vtkPlane::New();
- m_Slicer = vtkPointSetSlicer::New();
+ m_Plane = vtkPlane::New();
+ m_Slicer = vtkPointSetSlicer::New();
- m_Slicer->SetSlicePlane( m_Plane );
+ m_Slicer->SetSlicePlane( m_Plane );
- m_ScalarsToColors = 0;
- m_ScalarsToOpacity = 0;
- m_VtkPointSet = 0;
+ m_ScalarsToColors = 0;
+ m_ScalarsToOpacity = 0;
+ m_VtkPointSet = 0;
- //m_LUT = vtkLookupTable::New();
- //m_LUT->SetTableRange( 0, 255 );
- //m_LUT->SetNumberOfColors( 255 );
- //m_LUT->SetRampToLinear ();
- //m_LUT->Build();
+ //m_LUT = vtkLookupTable::New();
+ //m_LUT->SetTableRange( 0, 255 );
+ //m_LUT->SetNumberOfColors( 255 );
+ //m_LUT->SetRampToLinear ();
+ //m_LUT->Build();
}
mitk::UnstructuredGridMapper2D::~UnstructuredGridMapper2D()
{
m_Slicer->Delete();
m_Plane->Delete();
if (m_ScalarsToOpacity != 0) m_ScalarsToOpacity->UnRegister(0);
if (m_ScalarsToColors != 0) m_ScalarsToColors->UnRegister(0);
if (m_VtkPointSet != 0) m_VtkPointSet->UnRegister(0);
}
diff --git a/Modules/MitkExt/Rendering/mitkUnstructuredGridMapper2D.h b/Modules/MitkExt/Rendering/mitkUnstructuredGridMapper2D.h
index 6e8dd546b3..498d40aec8 100644
--- a/Modules/MitkExt/Rendering/mitkUnstructuredGridMapper2D.h
+++ b/Modules/MitkExt/Rendering/mitkUnstructuredGridMapper2D.h
@@ -1,111 +1,113 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MitkPointSetSliceLMapper2D_H
#define MitkPointSetSliceLMapper2D_H
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkGLMapper.h"
#include "mitkTransferFunction.h"
#include "mitkProperties.h"
#include "mitkColorProperty.h"
#include "mitkVtkScalarModeProperty.h"
class vtkPointSetSlicer;
class vtkPlane;
class vtkLookupTable;
class vtkPointSet;
class vtkScalarsToColors;
class vtkPiecewiseFunction;
class vtkAbstractMapper3D;
namespace mitk
{
class BaseRenderer;
/**
* @brief OpenGL-based mapper to display a 2d cut through a poly data
* OpenGL-based mapper to display a 2D cut through a poly data. The result is
* normally a line. This class can be added to any data object, which is
* rendered in 3D via a vtkPolyData.
*/
class MitkExt_EXPORT UnstructuredGridMapper2D : public GLMapper
{
public:
mitkClassMacro( UnstructuredGridMapper2D, GLMapper );
itkNewMacro( Self );
/**
* Renders a cut through a pointset by cutting trough the n-cells,
* producing (n-1)-cells.
* @param renderer the render to render in.
*/
virtual void Paint( mitk::BaseRenderer* renderer );
+ LocalStorageHandler<BaseLocalStorage> m_LSH;
+
protected:
UnstructuredGridMapper2D();
virtual ~UnstructuredGridMapper2D();
virtual void GenerateDataForRenderer(BaseRenderer*);
/**
* Determines, if the associated BaseData is mapped three-dimensionally (mapper-slot id 2)
* with a class convertable to vtkAbstractMapper3D().
* @returns NULL if it is not convertable or the appropriate Mapper otherwise
*/
virtual vtkAbstractMapper3D* GetVtkAbstractMapper3D(BaseRenderer* renderer);
/**
* Determines the pointset object to be cut.
* returns the pointset if possible, otherwise NULL.
*/
virtual vtkPointSet* GetVtkPointSet(BaseRenderer* renderer );
/**
* Determines the LookupTable used by the associated vtkMapper.
* returns the LUT if possible, otherwise NULL.
*/
virtual vtkScalarsToColors* GetVtkLUT(BaseRenderer* renderer );
/**
* Checks if this mapper can be used to generate cuts through the associated
* base data.
* @return true if yes or false if not.
*/
virtual bool IsConvertibleToVtkPointSet(BaseRenderer* renderer);
vtkPlane* m_Plane;
vtkPointSetSlicer* m_Slicer;
vtkPointSet* m_VtkPointSet;
vtkScalarsToColors* m_ScalarsToColors;
vtkPiecewiseFunction* m_ScalarsToOpacity;
mitk::ColorProperty::Pointer m_Color;
mitk::IntProperty::Pointer m_LineWidth;
mitk::BoolProperty::Pointer m_Outline;
mitk::BoolProperty::Pointer m_ScalarVisibility;
mitk::VtkScalarModeProperty::Pointer m_ScalarMode;
};
} // namespace mitk
#endif /* MitkPointSetSliceLMapper2D_H */
diff --git a/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.cpp b/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.cpp
index 1a955caeb7..aa9111be24 100644
--- a/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.cpp
+++ b/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.cpp
@@ -1,416 +1,425 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkUnstructuredGridVtkMapper3D.h"
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkColorProperty.h"
//#include "mitkLookupTableProperty.h"
#include "mitkGridRepresentationProperty.h"
#include "mitkGridVolumeMapperProperty.h"
#include "mitkVtkInterpolationProperty.h"
#include "mitkVtkScalarModeProperty.h"
#include "mitkDataStorage.h"
#include "mitkSurfaceVtkMapper3D.h"
#include <vtkUnstructuredGrid.h>
#include <vtkVolume.h>
#include <vtkVolumeProperty.h>
#include <vtkProperty.h>
#include <vtkPlanes.h>
const mitk::UnstructuredGrid* mitk::UnstructuredGridVtkMapper3D::GetInput()
{
return static_cast<const mitk::UnstructuredGrid * > ( GetDataNode()->GetData() );
}
mitk::UnstructuredGridVtkMapper3D::UnstructuredGridVtkMapper3D()
{
m_VtkTriangleFilter = vtkDataSetTriangleFilter::New();
m_Assembly = vtkAssembly::New();
m_Volume = vtkVolume::New();
m_Actor = vtkActor::New();
m_ActorWireframe = vtkActor::New();
m_VtkDataSetMapper = vtkUnstructuredGridMapper::New();
m_VtkDataSetMapper->SetResolveCoincidentTopologyToPolygonOffset();
m_VtkDataSetMapper->SetResolveCoincidentTopologyPolygonOffsetParameters(0,1);
m_Actor->SetMapper(m_VtkDataSetMapper);
m_VtkDataSetMapper2 = vtkUnstructuredGridMapper::New();
m_VtkDataSetMapper2->SetResolveCoincidentTopologyToPolygonOffset();
m_VtkDataSetMapper2->SetResolveCoincidentTopologyPolygonOffsetParameters(1,1);
m_ActorWireframe->SetMapper(m_VtkDataSetMapper2);
m_ActorWireframe->GetProperty()->SetRepresentationToWireframe();
m_Assembly->AddPart(m_Actor);
m_Assembly->AddPart(m_ActorWireframe);
m_Assembly->AddPart(m_Volume);
m_VtkVolumeRayCastMapper = 0;
m_VtkPTMapper = 0;
m_VtkVolumeZSweepMapper = 0;
//m_GenerateNormals = false;
}
mitk::UnstructuredGridVtkMapper3D::~UnstructuredGridVtkMapper3D()
{
if (m_VtkTriangleFilter != 0)
m_VtkTriangleFilter->Delete();
if (m_VtkVolumeRayCastMapper != 0)
m_VtkVolumeRayCastMapper->Delete();
if (m_VtkVolumeZSweepMapper != 0)
m_VtkVolumeZSweepMapper->Delete();
if (m_VtkPTMapper != 0)
m_VtkPTMapper->Delete();
if (m_VtkDataSetMapper != 0)
m_VtkDataSetMapper->Delete();
if (m_VtkDataSetMapper2 != 0)
m_VtkDataSetMapper2->Delete();
if (m_Assembly != 0)
m_Assembly->Delete();
if (m_Actor != 0)
m_Actor->Delete();
if (m_ActorWireframe != 0)
m_ActorWireframe->Delete();
if (m_Volume != 0)
m_Volume->Delete();
}
vtkProp* mitk::UnstructuredGridVtkMapper3D::GetVtkProp(mitk::BaseRenderer* /*renderer*/)
{
return m_Assembly;
}
void mitk::UnstructuredGridVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
{
- m_Assembly->VisibilityOn();
+ mitk::DataNode::ConstPointer node = this->GetDataNode();
- m_ActorWireframe->GetProperty()->SetAmbient(1.0);
- m_ActorWireframe->GetProperty()->SetDiffuse(0.0);
- m_ActorWireframe->GetProperty()->SetSpecular(0.0);
+ BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+ bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
- mitk::DataNode::ConstPointer node = this->GetDataNode();
- mitk::TransferFunctionProperty::Pointer transferFuncProp;
- if (node->GetProperty(transferFuncProp, "TransferFunction"))
+ if(needGenerateData)
{
- mitk::TransferFunction::Pointer transferFunction = transferFuncProp->GetValue();
- if (transferFunction->GetColorTransferFunction()->GetSize() < 2)
+ ls->UpdateGenerateDataTime();
+
+ m_Assembly->VisibilityOn();
+
+ m_ActorWireframe->GetProperty()->SetAmbient(1.0);
+ m_ActorWireframe->GetProperty()->SetDiffuse(0.0);
+ m_ActorWireframe->GetProperty()->SetSpecular(0.0);
+
+ mitk::TransferFunctionProperty::Pointer transferFuncProp;
+ if (node->GetProperty(transferFuncProp, "TransferFunction"))
{
- mitk::UnstructuredGrid::Pointer input = const_cast< mitk::UnstructuredGrid* >(this->GetInput());
- if (input.IsNull()) return;
-
- vtkUnstructuredGrid * grid = input->GetVtkUnstructuredGrid(this->GetTimestep());
- if (grid == 0) return;
-
- double* scalarRange = grid->GetScalarRange();
- vtkColorTransferFunction* colorFunc = transferFunction->GetColorTransferFunction();
- colorFunc->RemoveAllPoints();
- colorFunc->AddRGBPoint(scalarRange[0], 1, 0, 0);
- colorFunc->AddRGBPoint((scalarRange[0] + scalarRange[1])/2.0, 0, 1, 0);
- colorFunc->AddRGBPoint(scalarRange[1], 0, 0, 1);
+ mitk::TransferFunction::Pointer transferFunction = transferFuncProp->GetValue();
+ if (transferFunction->GetColorTransferFunction()->GetSize() < 2)
+ {
+ mitk::UnstructuredGrid::Pointer input = const_cast< mitk::UnstructuredGrid* >(this->GetInput());
+ if (input.IsNull()) return;
+
+ vtkUnstructuredGrid * grid = input->GetVtkUnstructuredGrid(this->GetTimestep());
+ if (grid == 0) return;
+
+ double* scalarRange = grid->GetScalarRange();
+ vtkColorTransferFunction* colorFunc = transferFunction->GetColorTransferFunction();
+ colorFunc->RemoveAllPoints();
+ colorFunc->AddRGBPoint(scalarRange[0], 1, 0, 0);
+ colorFunc->AddRGBPoint((scalarRange[0] + scalarRange[1])/2.0, 0, 1, 0);
+ colorFunc->AddRGBPoint(scalarRange[1], 0, 0, 1);
+ }
}
}
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if(!visible)
{
m_Assembly->VisibilityOff();
return;
}
//
// get the TimeSlicedGeometry of the input object
//
mitk::UnstructuredGrid::Pointer input = const_cast< mitk::UnstructuredGrid* >( this->GetInput() );
//
// set the input-object at time t for the mapper
//
vtkUnstructuredGrid * grid = input->GetVtkUnstructuredGrid( this->GetTimestep() );
if(grid == 0)
{
m_Assembly->VisibilityOff();
return;
}
m_Assembly->VisibilityOn();
m_VtkTriangleFilter->SetInput(grid);
m_VtkDataSetMapper->SetInput(grid);
m_VtkDataSetMapper2->SetInput(grid);
bool clip = false;
node->GetBoolProperty("enable clipping", clip);
mitk::DataNode::Pointer bbNode = renderer->GetDataStorage()->GetNamedDerivedNode("Clipping Bounding Object", node);
if (clip && bbNode.IsNotNull())
{
m_VtkDataSetMapper->SetBoundingObject(dynamic_cast<mitk::BoundingObject*>(bbNode->GetData()));
m_VtkDataSetMapper2->SetBoundingObject(dynamic_cast<mitk::BoundingObject*>(bbNode->GetData()));
}
else
{
m_VtkDataSetMapper->SetBoundingObject(0);
m_VtkDataSetMapper2->SetBoundingObject(0);
}
//
// apply properties read from the PropertyList
//
ApplyProperties(0, renderer);
}
void mitk::UnstructuredGridVtkMapper3D::ResetMapper( BaseRenderer* /*renderer*/ )
{
m_Assembly->VisibilityOff();
}
void mitk::UnstructuredGridVtkMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* renderer)
{
mitk::DataNode::Pointer node = this->GetDataNode();
ApplyColorAndOpacityProperties(renderer, m_Actor);
ApplyColorAndOpacityProperties(renderer, m_ActorWireframe);
vtkVolumeProperty* volProp = m_Volume->GetProperty();
vtkProperty* property = m_Actor->GetProperty();
vtkProperty* wireframeProp = m_ActorWireframe->GetProperty();
mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(node,property,renderer);
mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(node,wireframeProp,renderer);
mitk::TransferFunctionProperty::Pointer transferFuncProp;
if (node->GetProperty(transferFuncProp, "TransferFunction", renderer))
{
mitk::TransferFunction::Pointer transferFunction = transferFuncProp->GetValue();
volProp->SetColor(transferFunction->GetColorTransferFunction());
volProp->SetScalarOpacity(transferFunction->GetScalarOpacityFunction());
volProp->SetGradientOpacity(transferFunction->GetGradientOpacityFunction());
m_VtkDataSetMapper->SetLookupTable(transferFunction->GetColorTransferFunction());
m_VtkDataSetMapper2->SetLookupTable(transferFunction->GetColorTransferFunction());
}
bool isVolumeRenderingOn = false;
node->GetBoolProperty("volumerendering", isVolumeRenderingOn, renderer);
if (isVolumeRenderingOn)
{
m_Assembly->RemovePart(m_Actor);
m_Assembly->RemovePart(m_ActorWireframe);
m_Assembly->AddPart(m_Volume);
mitk::GridVolumeMapperProperty::Pointer mapperProp;
if (node->GetProperty(mapperProp, "volumerendering.mapper", renderer))
{
mitk::GridVolumeMapperProperty::IdType type = mapperProp->GetValueAsId();
switch (type) {
case mitk::GridVolumeMapperProperty::RAYCAST:
if (m_VtkVolumeRayCastMapper == 0) {
m_VtkVolumeRayCastMapper = vtkUnstructuredGridVolumeRayCastMapper::New();
m_VtkVolumeRayCastMapper->SetInput(m_VtkTriangleFilter->GetOutput());
}
m_Volume->SetMapper(m_VtkVolumeRayCastMapper);
break;
case mitk::GridVolumeMapperProperty::PT:
if (m_VtkPTMapper == 0) {
m_VtkPTMapper = vtkProjectedTetrahedraMapper::New();
m_VtkPTMapper->SetInputConnection(m_VtkTriangleFilter->GetOutputPort());
}
m_Volume->SetMapper(m_VtkPTMapper);
break;
case mitk::GridVolumeMapperProperty::ZSWEEP:
if (m_VtkVolumeZSweepMapper == 0) {
m_VtkVolumeZSweepMapper = vtkUnstructuredGridVolumeZSweepMapper::New();
m_VtkVolumeZSweepMapper->SetInputConnection(m_VtkTriangleFilter->GetOutputPort());
}
m_Volume->SetMapper(m_VtkVolumeZSweepMapper);
break;
}
}
}
else
{
m_Assembly->RemovePart(m_Volume);
m_Assembly->AddPart(m_Actor);
m_Assembly->RemovePart(m_ActorWireframe);
mitk::GridRepresentationProperty::Pointer gridRepProp;
if (node->GetProperty(gridRepProp, "grid representation", renderer))
{
mitk::GridRepresentationProperty::IdType type = gridRepProp->GetValueAsId();
switch (type) {
case mitk::GridRepresentationProperty::POINTS:
property->SetRepresentationToPoints();
break;
case mitk::GridRepresentationProperty::WIREFRAME:
property->SetRepresentationToWireframe();
break;
case mitk::GridRepresentationProperty::SURFACE:
property->SetRepresentationToSurface();
break;
}
// if (type == mitk::GridRepresentationProperty::WIREFRAME_SURFACE)
// {
// m_Assembly->AddPart(m_ActorWireframe);
// }
}
}
// mitk::LevelWindow levelWindow;
// if(node->GetLevelWindow(levelWindow, renderer, "levelWindow"))
// {
// m_VtkVolumeRayCastMapper->SetScalarRange(levelWindow.GetMin(),levelWindow.GetMax());
// }
// else
// if(node->GetLevelWindow(levelWindow, renderer))
// {
// m_VtkVolumeRayCastMapper->SetScalarRange(levelWindow.GetMin(),levelWindow.GetMax());
// }
//
// mitk::VtkRepresentationProperty* representationProperty;
// node->GetProperty(representationProperty, "material.representation", renderer);
// if ( representationProperty != NULL )
// m_Volume->GetProperty()->SetRepresentation( representationProperty->GetVtkRepresentation() );
//
// mitk::VtkInterpolationProperty* interpolationProperty;
// node->GetProperty(interpolationProperty, "material.interpolation", renderer);
// if ( interpolationProperty != NULL )
// m_Volume->GetProperty()->SetInterpolation( interpolationProperty->GetVtkInterpolation() );
//
mitk::VtkScalarModeProperty* scalarMode = 0;
if(node->GetProperty(scalarMode, "scalar mode", renderer))
{
if (m_VtkVolumeRayCastMapper)
m_VtkVolumeRayCastMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
if (m_VtkPTMapper)
m_VtkPTMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
if (m_VtkVolumeZSweepMapper)
m_VtkVolumeZSweepMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
m_VtkDataSetMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
m_VtkDataSetMapper2->SetScalarMode(scalarMode->GetVtkScalarMode());
}
else
{
if (m_VtkVolumeRayCastMapper)
m_VtkVolumeRayCastMapper->SetScalarModeToDefault();
if (m_VtkPTMapper)
m_VtkPTMapper->SetScalarModeToDefault();
if (m_VtkVolumeZSweepMapper)
m_VtkVolumeZSweepMapper->SetScalarModeToDefault();
m_VtkDataSetMapper->SetScalarModeToDefault();
m_VtkDataSetMapper2->SetScalarModeToDefault();
}
bool scalarVisibility = true;
node->GetBoolProperty("scalar visibility", scalarVisibility, renderer);
m_VtkDataSetMapper->SetScalarVisibility(scalarVisibility ? 1 : 0);
m_VtkDataSetMapper2->SetScalarVisibility(scalarVisibility ? 1 : 0);
// double scalarRangeLower = std::numeric_limits<double>::min();
// double scalarRangeUpper = std::numeric_limits<double>::max();
// mitk::DoubleProperty* lowerRange = 0;
// if (node->GetProperty(lowerRange, "scalar range min", renderer))
// {
// scalarRangeLower = lowerRange->GetValue();
// }
// mitk::DoubleProperty* upperRange = 0;
// if (node->GetProperty(upperRange, "scalar range max", renderer))
// {
// scalarRangeUpper = upperRange->GetValue();
// }
// m_VtkDataSetMapper->SetScalarRange(scalarRangeLower, scalarRangeUpper);
// m_VtkDataSetMapper2->SetScalarRange(scalarRangeLower, scalarRangeUpper);
// bool colorMode = false;
// node->GetBoolProperty("color mode", colorMode);
// m_VtkVolumeRayCastMapper->SetColorMode( (colorMode ? 1 : 0) );
// float scalarsMin = 0;
// if (dynamic_cast<mitk::FloatProperty *>(node->GetProperty("ScalarsRangeMinimum").GetPointer()) != NULL)
// scalarsMin = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("ScalarsRangeMinimum").GetPointer())->GetValue();
// float scalarsMax = 1.0;
// if (dynamic_cast<mitk::FloatProperty *>(node->GetProperty("ScalarsRangeMaximum").GetPointer()) != NULL)
// scalarsMax = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("ScalarsRangeMaximum").GetPointer())->GetValue();
// m_VtkVolumeRayCastMapper->SetScalarRange(scalarsMin,scalarsMax);
}
void mitk::UnstructuredGridVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(node, renderer, overwrite);
node->AddProperty("grid representation", GridRepresentationProperty::New(), renderer, overwrite);
node->AddProperty("volumerendering", BoolProperty::New(false), renderer, overwrite);
node->AddProperty("volumerendering.mapper", GridVolumeMapperProperty::New(), renderer, overwrite);
node->AddProperty("scalar mode", VtkScalarModeProperty::New(0), renderer, overwrite);
node->AddProperty("scalar visibility", BoolProperty::New(true), renderer, overwrite);
//node->AddProperty("scalar range min", DoubleProperty::New(std::numeric_limits<double>::min()), renderer, overwrite);
//node->AddProperty("scalar range max", DoubleProperty::New(std::numeric_limits<double>::max()), renderer, overwrite);
node->AddProperty("outline polygons", BoolProperty::New(false), renderer, overwrite);
node->AddProperty("color", ColorProperty::New(1.0f, 1.0f, 1.0f), renderer, overwrite);
node->AddProperty("line width", IntProperty::New(1), renderer, overwrite);
if(overwrite || node->GetProperty("TransferFunction", renderer) == 0)
{
// add a default transfer function
mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
//tf->GetColorTransferFunction()->RemoveAllPoints();
node->SetProperty ("TransferFunction", mitk::TransferFunctionProperty::New(tf.GetPointer()));
}
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.h b/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.h
index 52f208b015..6925720553 100644
--- a/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.h
+++ b/Modules/MitkExt/Rendering/mitkUnstructuredGridVtkMapper3D.h
@@ -1,90 +1,92 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_UNSTRUCTURED_GRID_VTK_MAPPER_3D_H_
#define _MITK_UNSTRUCTURED_GRID_VTK_MAPPER_3D_H_
#include "mitkCommon.h"
#include "MitkExtExports.h"
#include "mitkVtkMapper.h"
#include "mitkUnstructuredGrid.h"
#include "mitkBaseRenderer.h"
#include <vtkAssembly.h>
#include <vtkActor.h>
#include <vtkVolume.h>
#include <vtkDataSetTriangleFilter.h>
#include "vtkUnstructuredGridMapper.h"
#include <vtkUnstructuredGridVolumeRayCastMapper.h>
#include <vtkProjectedTetrahedraMapper.h>
#include <vtkUnstructuredGridVolumeZSweepMapper.h>
namespace mitk {
//##Documentation
//## @brief Vtk-based mapper for UnstructuredGrid
//##
//## @ingroup Mapper
class MitkExt_EXPORT UnstructuredGridVtkMapper3D : public VtkMapper
{
public:
mitkClassMacro(UnstructuredGridVtkMapper3D, VtkMapper);
itkNewMacro(Self);
virtual const mitk::UnstructuredGrid* GetInput();
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
void ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* renderer);
+ LocalStorageHandler<BaseLocalStorage> m_LSH;
+
protected:
UnstructuredGridVtkMapper3D();
virtual ~UnstructuredGridVtkMapper3D();
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
virtual void ResetMapper( BaseRenderer* /*renderer*/ );
void SetProperties(mitk::BaseRenderer* renderer);
vtkAssembly* m_Assembly;
vtkActor* m_Actor;
vtkActor* m_ActorWireframe;
vtkVolume* m_Volume;
vtkDataSetTriangleFilter* m_VtkTriangleFilter;
vtkUnstructuredGridMapper* m_VtkDataSetMapper;
vtkUnstructuredGridMapper* m_VtkDataSetMapper2;
vtkUnstructuredGridVolumeRayCastMapper* m_VtkVolumeRayCastMapper;
vtkProjectedTetrahedraMapper* m_VtkPTMapper;
vtkUnstructuredGridVolumeZSweepMapper* m_VtkVolumeZSweepMapper;
};
} // namespace mitk
#endif /* _MITK_UNSTRUCTURED_GRID_VTK_MAPPER_3D_H_ */
diff --git a/Modules/MitkExt/Testing/files.cmake b/Modules/MitkExt/Testing/files.cmake
index fb643c22ea..0b9a7eb1c0 100644
--- a/Modules/MitkExt/Testing/files.cmake
+++ b/Modules/MitkExt/Testing/files.cmake
@@ -1,38 +1,40 @@
set(MODULE_TESTS
mitkAutoCropImageFilterTest.cpp
mitkBoundingObjectCutterTest.cpp
mitkCoreExtObjectFactoryTest
mitkDataNodeExtTest.cpp
mitkExternalToolsTest.cpp
mitkMeshTest.cpp
mitkMultiStepperTest.cpp
mitkOrganTypePropertyTest.cpp
- mitkPipelineSmartPointerCorrectnessTest.cpp
+ # mitkPipelineSmartPointerCorrectnessTest.cpp
mitkPlaneFitTest.cpp
mitkPointLocatorTest.cpp
- # mitkSegmentationInterpolationTest.cpp
- # mitkTestTemplate.cpp
mitkUnstructuredGridTest.cpp
mitkSimpleHistogramTest.cpp
mitkToolManagerTest.cpp
)
set(MODULE_IMAGE_TESTS
- mitkUnstructuredGridVtkWriterTest.cpp
- mitkCompressedImageContainerTest.cpp
- mitkCylindricToCartesianFilterTest.cpp
- #mitkExtractImageFilterTest.cpp
- mitkSurfaceToImageFilterTest.cpp
+ mitkUnstructuredGridVtkWriterTest.cpp #crappy test, but it can run with surfaces and images
+ mitkCompressedImageContainerTest.cpp #only runs on images
+ mitkCylindricToCartesianFilterTest.cpp #only runs on images
+)
+set(MODULE_SURFACE_TESTS
+ mitkSurfaceToImageFilterTest.cpp #only runs on surfaces
+ mitkUnstructuredGridVtkWriterTest #crappy test, but it can run with surfaces and images
)
set(MODULE_CUSTOM_TESTS
mitkLabeledImageToSurfaceFilterTest.cpp
mitkImageToSurfaceFilterTest.cpp
)
set(MODULE_TESTIMAGES
US4DCyl.nrrd
Pic3D.nrrd
Pic2DplusT.nrrd
BallBinary30x30x30.nrrd
Png2D-bw.png
+)
+set(MODULE_TESTSURFACES
binary.stl
ball.stl
)
diff --git a/Modules/MitkExt/Testing/mitkBoundingObjectCutterTest.cpp b/Modules/MitkExt/Testing/mitkBoundingObjectCutterTest.cpp
index 0bd6f9bba7..57d5af5f35 100644
--- a/Modules/MitkExt/Testing/mitkBoundingObjectCutterTest.cpp
+++ b/Modules/MitkExt/Testing/mitkBoundingObjectCutterTest.cpp
@@ -1,119 +1,118 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkImage.h>
#include <mitkImageDataItem.h>
#include <mitkImageCast.h>
#include <mitkBoundingObject.h>
#include <mitkCuboid.h>
#include <mitkBoundingObjectCutter.h>
#include <itkImage.h>
#include <fstream>
-#include <itkSmartPointerForwardReference.txx>
#include <mitkDataNodeFactory.h>
#include <vtkImageData.h>
#include <mitkTestingMacros.h>
int mitkBoundingObjectCutterTest(int /*argc*/, char* /*argv*/[])
{
MITK_TEST_BEGIN(mitkBoundingObjectCutterTest);
////Create Image out of nowhere
//mitk::Image::Pointer image;
//mitk::PixelType pt(mitk::MakeScalarPixelType<int>() );
//unsigned int dim[]={100,100,20};
//MITK_TEST_OUTPUT(<< "Creating Image as imput for cutting: ");
//image=mitk::Image::New();
//image->Initialize(mitk::MakeScalarPixelType<int>(), 3, dim);
//int *p = (int*)image->GetData();
//unsigned int i;
//unsigned int size = dim[0]*dim[1]*dim[2];
//for(i=0; i<size; ++i, ++p)
// *p= (signed int)i;
//std::cout<<"[PASSED]"<<std::endl;
//MITK_TEST_OUTPUT(<< "Testing mitk::BoundingObject::FitGeometry(image->GetGeometry()) with an mitk::Cuboid (sub-class of mitk::BoundingObject): ");
//mitk::Cuboid::Pointer cuboid = mitk::Cuboid::New();
//cuboid->FitGeometry(image->GetGeometry());
//std::cout<<"[PASSED]"<<std::endl;
// MITK_TEST_OUTPUT(<< "Testing whether corners of the cuboid are identical to corners of the image: ");
// int c;
// for(c=0; c<6; ++c)
// {
// MITK_TEST_OUTPUT(<< " Testing GetCornerPoint(" << c << "): ");
// MITK_TEST_CONDITION_REQUIRED( mitk::Equal(image->GetGeometry()->GetCornerPoint(c),cuboid->GetGeometry()->GetCornerPoint(c)-1), "");
// }
//MITK_TEST_OUTPUT(<< "Testing whether diagonal^2 of fitted mitk::Cuboid is identical to diagonal^2 of image: ");
//MITK_TEST_CONDITION_REQUIRED( mitk::Equal(image->GetGeometry()->GetDiagonalLength2(),cuboid->GetGeometry()->GetDiagonalLength2()), "");
//MITK_TEST_OUTPUT(<< "Testing mitk::BoundingObjectCutter: ");
//mitk::BoundingObjectCutter::Pointer boCutter = mitk::BoundingObjectCutter::New();
//boCutter->SetInput(image);
//boCutter->SetBoundingObject(cuboid);
//MITK_TEST_OUTPUT(<< " Testing mitk::BoundingObjectCutter::UpdateLargestPossibleRegion():: ");
//boCutter->UpdateLargestPossibleRegion();
//std::cout<<"[PASSED]"<<std::endl;
//mitk::Image::Pointer cuttedImage = boCutter->GetOutput();
//MITK_TEST_OUTPUT(<< " Testing whether origin of cutted image is identical to origin of original image: ");
//MITK_TEST_CONDITION_REQUIRED( mitk::Equal(image->GetGeometry()->GetOrigin(),cuttedImage->GetGeometry()->GetOrigin()), "");
//MITK_TEST_OUTPUT(<< " Testing whether spacing of cutted image is identical to spacing of original image: ");
//MITK_TEST_CONDITION_REQUIRED( mitk::Equal(image->GetGeometry()->GetSpacing(),cuttedImage->GetGeometry()->GetSpacing()), "");
//MITK_TEST_OUTPUT(<< " Testing whether center of cutted image is identical to center of original image: ");
//MITK_TEST_CONDITION_REQUIRED( mitk::Equal(image->GetGeometry()->GetCenter(),cuttedImage->GetGeometry()->GetCenter()), "");
//MITK_TEST_OUTPUT(<< " Testing whether diagonal^2 of cutted image is identical to diagonal^2 of original image: ");
//MITK_TEST_CONDITION_REQUIRED( mitk::Equal(image->GetGeometry()->GetDiagonalLength2(),cuttedImage->GetGeometry()->GetDiagonalLength2()), "");
//MITK_TEST_OUTPUT(<< " Testing whether corners of cutted image are identical to corners of original image: ");
//for(c=0; c<6; ++c)
//{
// MITK_TEST_OUTPUT(<< " Testing GetCornerPoint(" << c << "): ");
// MITK_TEST_CONDITION_REQUIRED( mitk::Equal(image->GetGeometry()->GetCornerPoint(c),cuttedImage->GetGeometry()->GetCornerPoint(c)), "");
//}
//MITK_TEST_OUTPUT(<< " Testing whether pixel data of cutted image are identical to pixel data of original image: ");
//p = (int*)image->GetData();
//int *pCutted = (int*)cuttedImage->GetData();
//for(i=0; i<size; ++i, ++p, ++pCutted)
//{
// if(*p!=*pCutted)
// break;
//}
//MITK_TEST_CONDITION_REQUIRED(i==size, "");
//MITK_TEST_OUTPUT(<< " Testing whether geometry of cutted image has ImageGeometry==true: ");
//MITK_TEST_CONDITION_REQUIRED(cuttedImage->GetGeometry()->GetImageGeometry(), "");
MITK_TEST_END();
return EXIT_SUCCESS;
}
diff --git a/Modules/MitkExt/Testing/mitkCompressedImageContainerTest.cpp b/Modules/MitkExt/Testing/mitkCompressedImageContainerTest.cpp
index 247d3f5c09..0952da7f8e 100644
--- a/Modules/MitkExt/Testing/mitkCompressedImageContainerTest.cpp
+++ b/Modules/MitkExt/Testing/mitkCompressedImageContainerTest.cpp
@@ -1,194 +1,193 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkCompressedImageContainer.h"
#include "mitkCoreObjectFactory.h"
#include "mitkDataNodeFactory.h"
#include "mitkImageDataItem.h"
-#include "itkSmartPointerForwardReference.txx"
class mitkCompressedImageContainerTestClass
{
public:
static void Test( mitk::CompressedImageContainer* container, mitk::Image* image, unsigned int& numberFailed )
{
container->SetImage( image ); // compress
mitk::Image::Pointer uncompressedImage = container->GetImage(); // uncompress
// check dimensions
if (image->GetDimension() != uncompressedImage->GetDimension())
{
++numberFailed;
std::cerr << " (EE) Number of image dimensions wrong after uncompression (was: " << image->GetDimension() << ", now: " << uncompressedImage->GetDimension() << ")" << std::endl;
}
for (unsigned int dim = 0; dim < image->GetDimension(); ++dim)
{
if (image->GetDimension(dim) != uncompressedImage->GetDimension(dim))
{
++numberFailed;
std::cerr << " (EE) Image dimension " << dim << " differs after uncompression (was: " << image->GetDimension(dim) << ", now: " << uncompressedImage->GetDimension(dim) << ")" << std::endl;
}
}
// check pixel type
if (image->GetPixelType() != uncompressedImage->GetPixelType())
{
++numberFailed;
std::cerr << " (EE) Pixel type wrong after uncompression:" << std::endl;
mitk::PixelType m_PixelType = image->GetPixelType();
std::cout << "Original pixel type:" << std::endl;
- std::cout << " PixelType: " << m_PixelType.GetTypeId().name() << std::endl;
+ std::cout << " PixelType: " << m_PixelType.GetTypeAsString() << std::endl;
std::cout << " BitsPerElement: " << m_PixelType.GetBpe() << std::endl;
std::cout << " NumberOfComponents: " << m_PixelType.GetNumberOfComponents() << std::endl;
std::cout << " BitsPerComponent: " << m_PixelType.GetBitsPerComponent() << std::endl;
//m_PixelType = uncompressedImage->GetPixelType();
std::cout << "Uncompressed pixel type:" << std::endl;
- std::cout << " PixelType: " << uncompressedImage->GetPixelType().GetTypeId().name() << std::endl;
+ std::cout << " PixelType: " << uncompressedImage->GetPixelType().GetTypeAsString() << std::endl;
std::cout << " BitsPerElement: " << uncompressedImage->GetPixelType().GetBpe() << std::endl;
std::cout << " NumberOfComponents: " << uncompressedImage->GetPixelType().GetNumberOfComponents() << std::endl;
std::cout << " BitsPerComponent: " << uncompressedImage->GetPixelType().GetBitsPerComponent() << std::endl;
}
// check data
mitk::PixelType m_PixelType = image->GetPixelType();
unsigned long oneTimeStepSizeInBytes = m_PixelType.GetBpe() >> 3; // bits per element divided by 8
for (unsigned int dim = 0; dim < image->GetDimension(); ++dim)
{
if (dim < 3)
{
oneTimeStepSizeInBytes *= image->GetDimension(dim);
}
}
unsigned int numberOfTimeSteps(1);
if (image->GetDimension() > 3)
{
numberOfTimeSteps = image->GetDimension(3);
}
for (unsigned int timeStep = 0; timeStep < numberOfTimeSteps; ++timeStep)
{
unsigned char* originalData( static_cast<unsigned char*>(image->GetVolumeData(timeStep)->GetData()) );
unsigned char* uncompressedData( static_cast<unsigned char*>(uncompressedImage->GetVolumeData(timeStep)->GetData()) );
unsigned long difference(0);
for (unsigned long byte = 0; byte < oneTimeStepSizeInBytes; ++byte)
{
if ( originalData[byte] != uncompressedData[byte] )
{
++difference;
}
}
if ( difference > 0 )
{
++numberFailed;
std::cerr << " (EE) Pixel data in timestep " << timeStep << " not identical after uncompression. " << difference << " pixels different." << std::endl;
break; // break "for timeStep"
}
}
}
};
/// ctest entry point
int mitkCompressedImageContainerTest(int argc, char* argv[])
{
// one big variable to tell if anything went wrong
unsigned int numberFailed(0);
// need one parameter (image filename)
if(argc==0)
{
std::cerr<<"No file specified [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
// load the image
mitk::Image::Pointer image = NULL;
mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
try
{
std::cout << "Testing with parameter '" << argv[1] << "'" << std::endl;
factory->SetFileName( argv[1] );
factory->Update();
if(factory->GetNumberOfOutputs()<1)
{
std::cerr<<"File could not be loaded [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
mitk::DataNode::Pointer node = factory->GetOutput( 0 );
image = dynamic_cast<mitk::Image*>(node->GetData());
if(image.IsNull())
{
std::cout<<"File not an image - test will not be applied [PASSED]"<<std::endl;
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}
}
catch ( itk::ExceptionObject & ex )
{
++numberFailed;
std::cerr << "Exception: " << ex << "[FAILED]" << std::endl;
return EXIT_FAILURE;
}
std::cout << " (II) Could load image." << std::endl;
std::cout << "Testing instantiation" << std::endl;
// instantiation
mitk::CompressedImageContainer::Pointer container = mitk::CompressedImageContainer::New();
if (container.IsNotNull())
{
std::cout << " (II) Instantiation works." << std::endl;
}
else
{
++numberFailed;
std::cout << "Test failed, and it's the ugliest one!" << std::endl;
return EXIT_FAILURE;
}
// some real work
mitkCompressedImageContainerTestClass::Test( container, image, numberFailed );
std::cout << "Testing destruction" << std::endl;
// freeing
container = NULL;
std::cout << " (II) Freeing works." << std::endl;
if (numberFailed > 0)
{
std::cerr << numberFailed << " tests failed." << std::endl;
return EXIT_FAILURE;
}
else
{
std::cout << "PASSED all tests." << std::endl;
return EXIT_SUCCESS;
}
}
diff --git a/Modules/MitkExt/Testing/mitkLabeledImageToSurfaceFilterTest.cpp b/Modules/MitkExt/Testing/mitkLabeledImageToSurfaceFilterTest.cpp
index 36678a3dcb..819ebfd84f 100644
--- a/Modules/MitkExt/Testing/mitkLabeledImageToSurfaceFilterTest.cpp
+++ b/Modules/MitkExt/Testing/mitkLabeledImageToSurfaceFilterTest.cpp
@@ -1,379 +1,379 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLabeledImageToSurfaceFilter.h"
#include <itksys/SystemTools.hxx>
#include "mitkDataNodeFactory.h"
#include "mitkReferenceCountWatcher.h"
#include <cmath>
bool equals(const mitk::ScalarType& val1, const mitk::ScalarType& val2, mitk::ScalarType epsilon = mitk::eps )
{
return ( std::fabs(val1 - val2) <= epsilon );
}
int mitkLabeledImageToSurfaceFilterTest(int argc, char* argv[])
{
if(argc<2)
{
std::cout<<"no path to testing specified [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::string fileIn = argv[1];
std::cout<<"Eingabe Datei: "<<fileIn<<std::endl;
mitk::Image::Pointer image = NULL;
mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
try
{
std::cout << "Loading file: ";
factory->SetFileName( fileIn.c_str() );
factory->Update();
if(factory->GetNumberOfOutputs()<1)
{
std::cout<<"file could not be loaded [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
mitk::DataNode::Pointer node = factory->GetOutput( 0 );
image = dynamic_cast<mitk::Image*>(node->GetData());
if(image.IsNull())
{
std::cout<<"file not an image - test will not be applied [PASSED]"<<std::endl;
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}
else if( image->GetPixelType() != mitk::PixelType( mitk::MakeScalarPixelType<char>() )
|| image->GetPixelType() != mitk::PixelType( mitk::MakeScalarPixelType<unsigned char>() ))
{
std::cout<<"file not a char or unsigned char image - test will not be applied [PASSED]"<<std::endl;
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}
}
catch ( itk::ExceptionObject & ex )
{
std::cout << "Exception: " << ex << "[FAILED]" << std::endl;
return EXIT_FAILURE;
}
std::cout << "Testing instantiation: " ;
mitk::LabeledImageToSurfaceFilter::Pointer filter = mitk::LabeledImageToSurfaceFilter::New();
if (filter.IsNull())
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else {
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Create surface with default settings: ";
filter->SetInput(image);
filter->Update();
if ( filter->GetNumberOfOutputs() != 1 )
{
std::cout<<"Wrong number of outputs, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( filter->GetOutput() == NULL )
{
std::cout<<"Output is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( filter->GetOutput()->GetVtkPolyData() == NULL )
{
std::cout<<"PolyData of surface is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing index to label conversion: ";
if ( filter->GetLabelForNthOutput( 0 ) != 257 )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing volume for label calculation: ";
if ( ! equals ( filter->GetVolumeForLabel( 257 ) , 14.328 ) )
{
std::cout<<filter->GetVolumeForLabel( 257 )<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing volume for index calculation: ";
if ( ! equals ( filter->GetVolumeForNthOutput( 0 ) , 14.328 ) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Create surface using optimised settings: ";
filter->GenerateAllLabelsOn();
filter->SetGaussianStandardDeviation( 1.5 );
filter->SetSmooth(true); // smooth wireframe
filter->SetDecimate( mitk::ImageToSurfaceFilter::DecimatePro );
filter->SetTargetReduction( 0.8 );
if( filter->GetNumberOfOutputs() != 1 )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Create surface for label 257: ";
filter->GenerateAllLabelsOff();
filter->SetLabel(257);
filter->Update();
if ( filter->GetNumberOfOutputs() != 1 )
{
std::cout<<"Wrong number of outputs, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( filter->GetOutput() == NULL )
{
std::cout<<"Output is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( filter->GetOutput()->GetVtkPolyData() == NULL )
{
std::cout<<"PolyData of surface is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing volume for label calculation: ";
if ( ! equals ( filter->GetVolumeForLabel( 257 ) , 14.328 ) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing volume for index calculation: ";
if ( ! equals ( filter->GetVolumeForNthOutput( 0 ) , 14.328 ) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Create surface for multiple labels: ";
filter->GenerateAllLabelsOn();
filter->SetBackgroundLabel(32000);
filter->Update();
if ( filter->GetNumberOfOutputs() != 2 )
{
std::cout<<"Wrong number of outputs, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
- else if ( filter->GetOutput(0) == NULL )
+ else if ( filter->GetOutput() == NULL )
{
std::cout<<"Output 0 is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
- else if ( filter->GetOutput(0)->GetVtkPolyData() == NULL )
+ else if ( filter->GetOutput()->GetVtkPolyData() == NULL )
{
std::cout<<"PolyData of output 0 is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( filter->GetOutput(1) == NULL )
{
std::cout<<"Output 1 is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( filter->GetOutput(1)->GetVtkPolyData() == NULL )
{
std::cout<<"PolyData of output 1 is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing volume for label calculation: ";
if ( ! equals ( filter->GetVolumeForLabel( 257 ) , 14.328 ) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( ! equals ( filter->GetVolumeForLabel( 0 ), 12.672 ) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing volume for index calculation: ";
if ( ! equals( filter->GetVolumeForNthOutput( 1 ), 14.328 ) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( ! equals ( filter->GetVolumeForNthOutput( 0 ), 12.672 ) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
mitk::ReferenceCountWatcher::Pointer outputSurface1Watcher = new mitk::ReferenceCountWatcher(filter->GetOutput(1), "outputSurface1");
mitk::ReferenceCountWatcher::Pointer filterWatcher = new mitk::ReferenceCountWatcher(filter, "filter");
std::cout << "Create surface for background (label 0): " << std::flush;
filter->GenerateAllLabelsOff();
filter->SetLabel(0);
filter->SetBackgroundLabel(257);
//mitk::Surface::Pointer surface = filter->GetOutput(1);
//std::cout<< surface->GetReferenceCount() << std::endl;
filter->Update();
//surface = NULL;
if ( filter->GetNumberOfOutputs() != 1 )
{
std::cout<<"Wrong number of outputs, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( filter->GetOutput() == NULL )
{
std::cout<<"Output is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( filter->GetOutput()->GetVtkPolyData() == NULL )
{
std::cout<<"PolyData of surface is NULL, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing reference count correctness of old output 1: " << std::flush;
if ( outputSurface1Watcher->GetReferenceCount() != 0 )
{
std::cout<<"outputSurface1Watcher->GetReferenceCount()=="
<< outputSurface1Watcher->GetReferenceCount()
<< "!=0, [FAILED]" << std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing reference count correctness of filter: " << std::flush;
if ( filterWatcher->GetReferenceCount() != 2 )
{
std::cout<<"filterWatcher->GetReferenceCount()=="
<< outputSurface1Watcher->GetReferenceCount()
<< "!=2, [FAILED]" << std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing index to label conversion: ";
if ( filter->GetLabelForNthOutput( 0 ) != 0 )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing volume for label calculation: ";
if ( ! equals ( filter->GetVolumeForLabel( filter->GetLabel() ) , 12.672 ) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Testing volume for index calculation: ";
if ( ! equals( filter->GetVolumeForNthOutput( 0 ), 12.672 ) )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout << "Create surface for invalid label: ";
filter->GenerateAllLabelsOff();
filter->SetLabel(1);
filter->Update();
if ( filter->GetNumberOfOutputs() != 1 )
{
std::cout<<"Number of outputs != 1, [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else if ( filter->GetOutput()->GetVtkPolyData()->GetNumberOfPoints() != 0 )
{
std::cout<<"PolyData is not empty ("<<filter->GetOutput()->GetVtkPolyData()->GetNumberOfPoints()<<"), [FAILED]"<<std::endl;
return EXIT_FAILURE;
}
else
{
std::cout<<"[PASSED]"<<std::endl;
}
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}
diff --git a/Modules/MitkExt/Testing/mitkSurfaceToImageFilterTest.cpp b/Modules/MitkExt/Testing/mitkSurfaceToImageFilterTest.cpp
index c923acc72b..069ce545b7 100644
--- a/Modules/MitkExt/Testing/mitkSurfaceToImageFilterTest.cpp
+++ b/Modules/MitkExt/Testing/mitkSurfaceToImageFilterTest.cpp
@@ -1,123 +1,46 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
+#include <mitkTestingMacros.h>
+#include <mitkIOUtil.h>
+
#include "mitkSurfaceToImageFilter.h"
-#include "mitkDataNodeFactory.h"
-#include "mitkPicFileWriter.h"
-#include <mitkSTLFileReader.h>
#include <vtkPolyData.h>
-#include <fstream>
-
int mitkSurfaceToImageFilterTest(int argc, char* argv[])
{
- mitk::SurfaceToImageFilter::Pointer s2iFilter;
- std::cout << "Testing mitk::Surface::New(): " << std::flush;
- s2iFilter = mitk::SurfaceToImageFilter::New();
- if (s2iFilter.IsNull())
- {
- std::cout<<"[FAILED]"<<std::endl;
- return EXIT_FAILURE;
- }
- else
- {
- std::cout<<"[PASSED]"<<std::endl;
- }
-
- std::cout << "Loading file: " << std::flush;
- if(argc==0)
- {
- std::cout<<"no file specified [FAILED]"<<std::endl;
- return EXIT_FAILURE;
- }
-
- if (!mitk::STLFileReader::CanReadFile(argv[1], "", ""))
- {
- std::cout << "Input file not a valid .stl file [PASSED]\n[TEST DONE]" << std::endl;
- return EXIT_SUCCESS;
- }
-
- mitk::STLFileReader::Pointer reader = mitk::STLFileReader::New();
-
- reader->SetFileName(argv[1]);
- reader->Update();
-
- mitk::Surface::Pointer surface = NULL;
-
- surface = reader->GetOutput();
-
- if(surface.IsNull())
- {
- std::cout<<"file not a surface - test will not be applied [PASSED]"<<std::endl;
- std::cout<<"[TEST DONE]"<<std::endl;
- return EXIT_SUCCESS;
- }
-
- std::cout << "Testing number of points of surface: " << std::flush;
- if(surface->GetVtkPolyData()->GetNumberOfPoints() == 0)
- {
- std::cout<<"number of points is 0 - test will not be applied [PASSED]"<<std::endl;
- std::cout<<"[TEST DONE]"<<std::endl;
- return EXIT_SUCCESS;
- }
-
- std::cout << "Testing creation of mitk::Image with same Geometry as Surface: " << std::flush;
- mitk::Image::Pointer image = mitk::Image::New();
- //surface->UpdateOutputInformation(); //is not necessary anymore (bug #1536), should never be neccessary
- image->Initialize( mitk::MakeScalarPixelType<unsigned int>(), *surface->GetGeometry());
-
- std::cout << "Testing mitk::SurfaceToImageFilter::MakeOutputBinaryOn(): " << std::flush;
- s2iFilter->MakeOutputBinaryOn();
- std::cout<<"[PASSED]"<<std::endl;
-
- std::cout << "Testing mitk::SurfaceToImageFilter::SetInput(): " << std::flush;
- s2iFilter->SetInput(surface);
- std::cout<<"[PASSED]"<<std::endl;
-
- std::cout << "Testing mitk::SurfaceToImageFilter::SetImage(): " << std::flush;
- s2iFilter->SetImage(image);
- std::cout<<"[PASSED]"<<std::endl;
-
- std::cout << "Testing mitk::SurfaceToImageFilter::Update(): " << std::flush;
- s2iFilter->Update();
- std::cout<<"[PASSED]"<<std::endl;
+ MITK_TEST_BEGIN( "mitkSurfaceToImageFilterTest");
+ mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
-#ifdef WIN32 // Unix based systems do not seem to resolve pixel type correctly
+ mitk::Surface::Pointer inputSurface = mitk::IOUtil::LoadSurface( std::string(argv[1]) );
- std::cout << "Testing if result image is of type unsigned char: " << std::flush;
- //std::string typeId = s2iFilter->GetOutput()->GetPixelType().GetItkTypeAsString();
- std::string typeId = s2iFilter->GetOutput()->GetPixelType().GetComponentTypeAsString();
- std::cout << std::endl << "XXX: " << typeId << std::endl;
- if( typeId != "unsigned char" )
- {
- if(typeId != "unknown")
- return EXIT_FAILURE;
- else std::cout << "Warning: Pixel type can't be resolved." << std::flush;
- }
- std::cout<<"[PASSED]"<<std::endl;
+ //todo I don't know if this image is always needed. There is no documentation of the filter. Use git blame and ask the author.
+ mitk::Image::Pointer additionalInputImage = mitk::Image::New();
+ additionalInputImage->Initialize( mitk::MakeScalarPixelType<unsigned int>(), *inputSurface->GetGeometry());
-#endif
+ //Arrange the filter
+ //The docu does not really tell if this is always needed. Could we skip SetImage in any case?
+ surfaceToImageFilter->MakeOutputBinaryOn();
+ surfaceToImageFilter->SetInput(inputSurface);
+ surfaceToImageFilter->SetImage(additionalInputImage);
+ surfaceToImageFilter->Update();
- //mitk::PicFileWriter::Pointer picWriter = mitk::PicFileWriter::New();
- //picWriter->SetInput(s2iFilter->GetOutput());
- //picWriter->SetFileName("SurfaceToImageFilterTestOutput.pic");
- //picWriter->Write();
+ MITK_TEST_CONDITION_REQUIRED( surfaceToImageFilter->GetOutput()->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR, "SurfaceToImageFilter_AnyInputImageAndModeSetToBinary_ResultIsImageWithUCHARPixelType");
- std::cout<<"[TEST DONE]"<<std::endl;
- return EXIT_SUCCESS;
+ MITK_TEST_END();
}
diff --git a/Modules/MitkExt/files.cmake b/Modules/MitkExt/files.cmake
index 4061c11ef5..98831db789 100644
--- a/Modules/MitkExt/files.cmake
+++ b/Modules/MitkExt/files.cmake
@@ -1,151 +1,153 @@
set(CPP_FILES
Algorithms/mitkMaskAndCutRoiImageFilter.cpp
Algorithms/mitkBoundingObjectToSegmentationFilter.cpp
Algorithms/vtkPointSetSlicer.cxx
Algorithms/mitkCoreExtObjectFactory.cpp
Algorithms/mitkAngleCorrectByPointFilter.cpp
Algorithms/mitkAutoCropImageFilter.cpp
Algorithms/mitkBoundingObjectCutter.cpp
Algorithms/mitkCylindricToCartesianFilter.cpp
Algorithms/mitkDopplerToStrainRateFilter.cpp
Algorithms/mitkGeometryClipImageFilter.cpp
Algorithms/mitkGeometryDataSource.cpp
Algorithms/mitkHeightFieldSurfaceClipImageFilter.cpp
Algorithms/mitkImageToLookupTableFilter.cpp
Algorithms/mitkImageToSurfaceFilter.cpp
Algorithms/mitkInterpolateLinesFilter.cpp
Algorithms/mitkLabeledImageToSurfaceFilter.cpp
Algorithms/mitkLabeledImageVolumeCalculator.cpp
Algorithms/mitkLookupTableSource.cpp
Algorithms/mitkMaskImageFilter.cpp
Algorithms/mitkMeshSource.cpp
Algorithms/mitkNonBlockingAlgorithm.cpp
Algorithms/mitkPadImageFilter.cpp
Algorithms/mitkPlaneCutFilter.cpp
Algorithms/mitkPlaneFit.cpp
Algorithms/mitkPlanesPerpendicularToLinesFilter.cpp
Algorithms/mitkPointLocator.cpp
Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
Algorithms/mitkPointSetToGeometryDataFilter.cpp
Algorithms/mitkPointSetIndexToWorldTransformFilter.cpp
Algorithms/mitkSurfaceIndexToWorldTransformFilter.cpp
Algorithms/mitkPolygonToRingFilter.cpp
Algorithms/mitkProbeFilter.cpp
Algorithms/mitkSimpleHistogram.cpp
Algorithms/mitkSimpleUnstructuredGridHistogram.cpp
Algorithms/mitkSurfaceToImageFilter.cpp
Algorithms/mitkUnstructuredGridHistogram.cpp
Algorithms/mitkUnstructuredGridSource.cpp
Algorithms/mitkVolumeVisualizationImagePreprocessor.cpp
Controllers/mitkIPythonService.cpp
Controllers/mitkMovieGenerator.cpp
Controllers/mitkMultiStepper.cpp
Controllers/mitkToolManager.cpp
DataManagement/mitkAffineTransformationOperation.cpp
DataManagement/mitkApplyDiffImageOperation.cpp
DataManagement/mitkBoundingObject.cpp
DataManagement/mitkBoundingObjectGroup.cpp
DataManagement/mitkCellOperation.cpp
DataManagement/mitkColorConversions.cpp
DataManagement/mitkColorSequence.cpp
DataManagement/mitkColorSequenceCycleH.cpp
DataManagement/mitkColorSequenceHalfTones.cpp
DataManagement/mitkColorSequenceRainbow.cpp
DataManagement/mitkCompressedImageContainer.cpp
DataManagement/mitkCone.cpp
DataManagement/mitkCuboid.cpp
DataManagement/mitkCylinder.cpp
DataManagement/mitkDataStorageSelection.cpp
DataManagement/mitkDelegateManager.cpp
DataManagement/mitkDrawOperation.cpp
DataManagement/mitkEllipsoid.cpp
DataManagement/mitkExternAbstractTransformGeometry.cpp
DataManagement/mitkFrameOfReferenceUIDManager.cpp
DataManagement/mitkGridRepresentationProperty.cpp
DataManagement/mitkGridVolumeMapperProperty.cpp
DataManagement/mitkItkBaseDataAdapter.cpp
DataManagement/mitkLabeledImageLookupTable.cpp
DataManagement/mitkLineOperation.cpp
DataManagement/mitkMesh.cpp
DataManagement/mitkObjectSet.cpp
DataManagement/mitkOrganTypeProperty.cpp
DataManagement/mitkPlaneLandmarkProjector.cpp
DataManagement/mitkPlane.cpp
DataManagement/mitkPropertyManager.cpp
DataManagement/mitkPropertyObserver.cpp
DataManagement/mitkSeedsImage.cpp
DataManagement/mitkSeedsImageLookupTableSource.cpp
DataManagement/mitkSphereLandmarkProjector.cpp
# DataManagement/mitkUSLookupTableSource.cpp
DataManagement/mitkUnstructuredGrid.cpp
DataManagement/mitkVideoSource.cpp
DataManagement/vtkObjectSet.cpp
IO/mitkObjFileIOFactory.cpp
IO/mitkObjFileReader.cpp
IO/mitkPACSPlugin.cpp
IO/mitkParRecFileIOFactory.cpp
IO/mitkParRecFileReader.cpp
+ IO/mitkPropertyListExportToXmlFile.cpp
+ IO/mitkPropertyListImportFromXmlFile.cpp
IO/mitkStlVolumeTimeSeriesIOFactory.cpp
IO/mitkStlVolumeTimeSeriesReader.cpp
IO/mitkUnstructuredGridVtkWriter.cpp
IO/mitkUnstructuredGridVtkWriterFactory.cpp
IO/mitkVtkUnstructuredGridIOFactory.cpp
IO/mitkVtkUnstructuredGridReader.cpp
IO/mitkVtkVolumeTimeSeriesIOFactory.cpp
IO/mitkVtkVolumeTimeSeriesReader.cpp
Interactions/mitkConferenceEventMapper.cpp
Interactions/mitkConnectPointsInteractor.cpp
#Interactions/mitkCoordinateSupplier.cpp
#Interactions/mitkDisplayCoordinateOperation.cpp
#Interactions/mitkDisplayInteractor.cpp
Interactions/mitkAffineInteractor3D.cpp
Interactions/mitkDisplayPointSetInteractor.cpp
#Interactions/mitkDisplayVectorInteractor.cpp
Interactions/mitkInteractionDebug.cpp
Interactions/mitkInteractionDebugger.cpp
Interactions/mitkPointInteractor.cpp
Interactions/mitkPointSelectorInteractor.cpp
#Interactions/mitkPositionTracker.cpp
Interactions/mitkSeedsInteractor.cpp
Interactions/mitkSocketClient.cpp
Interactions/mitkSurfaceDeformationInteractor3D.cpp
Interactions/mitkSurfaceInteractor.cpp
Interactions/mitkTool.cpp
# Interactions/mitkCreateSurfaceTool.cpp
Interactions/mitkMorphologicTool.cpp
Interactions/mitkErodeTool.cpp
Interactions/mitkDilateTool.cpp
Interactions/mitkOpeningTool.cpp
Interactions/mitkClosingTool.cpp
Interactions/mitkPixelManipulationTool.cpp
Rendering/mitkEnhancedPointSetVtkMapper3D.cpp
Rendering/mitkImageBackground2D.cpp
Rendering/mitkLineMapper2D.cpp
# Rendering/mitkLineVtkMapper3D.cpp
Rendering/mitkMeshMapper2D.cpp
Rendering/mitkMeshVtkMapper3D.cpp
Rendering/mitkNativeRenderWindowInteractor.cpp
Rendering/mitkSplineMapper2D.cpp
Rendering/mitkSplineVtkMapper3D.cpp
Rendering/mitkUnstructuredGridMapper2D.cpp
Rendering/mitkUnstructuredGridVtkMapper3D.cpp
Rendering/mitkVectorImageMapper2D.cpp
Rendering/vtkUnstructuredGridMapper.cpp
Rendering/vtkMaskedGlyph2D.cpp
Rendering/vtkMaskedGlyph3D.cpp
Rendering/vtkMitkVolumeTextureMapper3D.cpp
Rendering/vtkMitkOpenGLVolumeTextureMapper3D.cpp
Rendering/mitkGPUVolumeMapper3D.cpp
Rendering/vtkMitkGPUVolumeRayCastMapper.cpp
)
if(WIN32 AND NOT MINGW)
set(CPP_FILES
Controllers/mitkMovieGeneratorWin32.cpp
${CPP_FILES}
)
endif(WIN32 AND NOT MINGW)
diff --git a/Modules/OpenCVVideoSupport/Testing/mitkImageToOpenCVImageFilterTest.cpp b/Modules/OpenCVVideoSupport/Testing/mitkImageToOpenCVImageFilterTest.cpp
index 3da65bc855..86612b236c 100644
--- a/Modules/OpenCVVideoSupport/Testing/mitkImageToOpenCVImageFilterTest.cpp
+++ b/Modules/OpenCVVideoSupport/Testing/mitkImageToOpenCVImageFilterTest.cpp
@@ -1,177 +1,177 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImageToOpenCVImageFilter.h"
#include "mitkOpenCVToMitkImageFilter.h"
#include <mitkTestingMacros.h>
#include <mitkITKImageImport.h>
#include <iostream>
#include <mitkItkImageFileReader.h>
// #include <itkImageFileWriter.h>
#include <highgui.h>
mitk::Image::Pointer LoadImage( std::string filename )
{
mitk::ItkImageFileReader::Pointer reader = mitk::ItkImageFileReader::New();
reader->SetFileName ( filename.c_str() );
reader->Update();
if ( reader->GetOutput() == NULL )
itkGenericExceptionMacro("File "<<filename <<" could not be read!");
mitk::Image::Pointer image = reader->GetOutput();
return image;
}
static void testGeneratedImage()
{
// create itk rgb image
typedef unsigned char PixelType;
typedef itk::Image< itk::RGBPixel<PixelType>, 2 > ImageType;
ImageType::Pointer itkImage = ImageType::New();
ImageType::IndexType start;
start[0] = 0; // first index on X
start[1] = 0; // first index on Y
ImageType::SizeType size;
size[0] = 50; // size along X
size[1] = 40; // size along Y
ImageType::RegionType region;
region.SetSize( size );
region.SetIndex( start );
itkImage->SetRegions( region );
itkImage->Allocate();
typedef itk::ImageRegionIterator<ImageType> IteratorType;
IteratorType it(itkImage, region);
float twoThirdsTheWidth = size[0] / 4;
unsigned int x=0, y=0;
// create rgb pic
for ( it.GoToBegin(); !it.IsAtEnd(); ++it )
{
ImageType::PixelType newPixel;
newPixel.SetRed(0);
newPixel.SetGreen(0);
// create asymmetric pic
if( x > twoThirdsTheWidth )
newPixel.SetBlue(0);
else
newPixel.SetBlue(255);
it.Set(newPixel);
++x;
// next line found
if( x == size[0] )
x = 0;
}
// debugging
// itk::ImageFileWriter< ImageType >::Pointer writer = itk::ImageFileWriter< ImageType >::New();
// writer->SetFileName( "c:\\image.png" );
// writer->SetInput ( itkImage );
// writer->Update();
// import rgb image as MITK image
- mitk::Image::Pointer mitkImage = mitk::ImportItkImage( itkImage );
+ mitk::Image::Pointer mitkImage = mitk::ImportItkImage(itkImage)->Clone();
mitk::ImageToOpenCVImageFilter::Pointer _ImageToOpenCVImageFilter =
mitk::ImageToOpenCVImageFilter::New();
_ImageToOpenCVImageFilter->SetImage( mitkImage );
IplImage* openCVImage = _ImageToOpenCVImageFilter->GetOpenCVImage();
MITK_TEST_CONDITION_REQUIRED( openCVImage != NULL, "Image returned by filter is not null.");
// check byte size
const unsigned int expectedSize = size[0] * size[1] * 3 * sizeof( unsigned char);// sizeof( PixelType );
const unsigned int realSize = openCVImage->width * openCVImage->height * openCVImage->nChannels * sizeof( unsigned char);//* sizeof ( PixelType );
MITK_TEST_CONDITION_REQUIRED( expectedSize == realSize, "Test expectedSize == realSize");
// check pixel values
PixelType expectedBlueValue;
CvScalar s;
for (y = 0; (int)y < openCVImage->height; ++y)
{
for (x = 0; (int)x < openCVImage->width; ++x)
{
expectedBlueValue = 255;
if(x > twoThirdsTheWidth)
expectedBlueValue = 0;
s = cvGet2D(openCVImage,y,x);
if( s.val[0] != expectedBlueValue || s.val[1] != 0 || s.val[2] != 0 )
{
std::cout << "Wrong RGB values in created OpenCV image" << std::endl;
throw mitk::TestFailedException();
}
}
}
// cvNamedWindow( "test" );
// cvShowImage( "test" , openCVImage );
// cvWaitKey();
}
static void testLoadedImage(std::string mitkImagePath)
{
mitk::Image::Pointer testImage = LoadImage(mitkImagePath);
mitk::ImageToOpenCVImageFilter::Pointer _ImageToOpenCVImageFilter =
mitk::ImageToOpenCVImageFilter::New();
_ImageToOpenCVImageFilter->SetImage( testImage );
IplImage* openCVImage = _ImageToOpenCVImageFilter->GetOpenCVImage();
IplImage* openCVImage_Ref = cvLoadImage(mitkImagePath.c_str());
MITK_TEST_CONDITION_REQUIRED( openCVImage != NULL, "Image returned by filter is not null.");
for(int i = 0 ; i<openCVImage->height ; i++)
{
for(int j = 0 ; j<openCVImage->width ; j++)
{
CvScalar s;
s=cvGet2D(openCVImage,i,j); // get the (i,j) pixel value
CvScalar sRef;
sRef=cvGet2D(openCVImage_Ref,i,j); // get the (i,j) pixel value
for(int c = 0 ; c < openCVImage->nChannels ; c++)
{
MITK_TEST_CONDITION_REQUIRED( s.val[c] == sRef.val[c] , "All pixel values have to be equal");
}
}
}
// cvNamedWindow( "test" );
// cvShowImage( "test" , openCVImage );
// cvWaitKey();
}
/**Documentation
* test for the class "ImageToOpenCVImageFilter".
*/
int mitkImageToOpenCVImageFilterTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("ImageToOpenCVImageFilter")
testGeneratedImage();
testLoadedImage(argv[1]);
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.cpp b/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.cpp
index 4cbbcc62e8..72a65022da 100644
--- a/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.cpp
+++ b/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.cpp
@@ -1,329 +1,329 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkOpenCVVideoControls.h"
#include <QmitkVideoBackground.h>
#include <QmitkStdMultiWidget.h>
#include <mitkOpenCVVideoSource.h>
QmitkOpenCVVideoControls::QmitkOpenCVVideoControls( QmitkVideoBackground* _VideoBackground
, QmitkStdMultiWidget* _MultiWidget
, QWidget * parent, Qt::WindowFlags f)
: QWidget(parent, f)
, m_VideoBackground(0)
, m_MultiWidget(0)
, m_VideoSource(0)
, m_Controls(new Ui::QmitkOpenCVVideoControls)
, m_SliderCurrentlyMoved(false)
{
m_Controls->setupUi(this);
m_Controls->FileChooser->SetFileMustExist(true);
m_Controls->FileChooser->SetSelectDir(false);
this->SetStdMultiWidget(_MultiWidget);
this->SetVideoBackground(_VideoBackground);
}
QmitkOpenCVVideoControls::~QmitkOpenCVVideoControls()
{
if(m_VideoSource != 0 && m_VideoSource->IsCapturingEnabled())
this->Stop(); // emulate stop
}
void QmitkOpenCVVideoControls::on_UseGrabbingDeviceButton_clicked( bool /*checked=false*/ )
{
m_Controls->GrabbingDevicePanel->setEnabled(true);
m_Controls->VideoFilePanel->setEnabled(false);
}
void QmitkOpenCVVideoControls::on_UseVideoFileButton_clicked( bool /*checked=false*/ )
{
m_Controls->GrabbingDevicePanel->setEnabled(false);
m_Controls->VideoFilePanel->setEnabled(true);
m_Controls->FileChooser->setEnabled(true);
}
//void QmitkOpenCVVideoControls::on_VideoProgressSlider_sliderMoved( int value )
//{
// MITK_DEBUG << "progress bar slider clicked";
// double progressRatio = static_cast<double>(value)/static_cast<double>(m_Controls->VideoProgressSlider->maximum());
// MITK_DEBUG << "progressRatio" << progressRatio;
// m_VideoSource->SetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO, progressRatio);
//}
void QmitkOpenCVVideoControls::on_VideoProgressSlider_sliderPressed()
{
m_SliderCurrentlyMoved = true;
// temporary pause the video while sliding
if( !m_VideoSource->GetCapturePaused() )
m_VideoSource->PauseCapturing();
MITK_DEBUG << "freezing video with old pos ratio: "<< m_VideoSource->GetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO);
}
void QmitkOpenCVVideoControls::on_VideoProgressSlider_sliderReleased()
{
double progressRatio = static_cast<double>(m_Controls->VideoProgressSlider->value())
/static_cast<double>(m_Controls->VideoProgressSlider->maximum());
m_VideoSource->SetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO, progressRatio);
MITK_DEBUG << "resuming video with new pos ratio: "<< progressRatio;
// resume the video ( if it was not paused by the user)
if( m_VideoSource->GetCapturePaused() && m_Controls->PlayButton->isChecked() )
m_VideoSource->PauseCapturing();
m_SliderCurrentlyMoved = false;
}
void QmitkOpenCVVideoControls::on_RepeatVideoButton_clicked( bool checked/*=false */ )
{
MITK_INFO << "repeat video clicked";
m_VideoSource->SetRepeatVideo(checked);
}
void QmitkOpenCVVideoControls::on_PlayButton_clicked( bool checked/*=false*/ )
{
MITK_INFO << "play button clicked";
if(checked)
{
if( m_VideoSource->GetCapturePaused() )
{
this->SwitchPlayButton(false);
m_VideoSource->PauseCapturing();
}
else
{
if(m_Controls->UseGrabbingDeviceButton->isChecked())
{
m_VideoSource->SetVideoCameraInput(m_Controls->GrabbingDeviceNumber->text().toInt(),false);
m_Controls->VideoFileControls->setEnabled(false);
}
else
{
m_VideoSource->SetVideoFileInput(m_Controls->FileChooser->GetFile().c_str(), m_Controls->RepeatVideoButton->isChecked(), false);
m_VideoSource->SetRepeatVideo(m_Controls->RepeatVideoButton->isChecked());
m_Controls->VideoProgressSlider->setValue(0);
}
m_VideoSource->StartCapturing();
if(!m_VideoSource->IsCapturingEnabled())
{
MITK_ERROR << "Video could not be initialized!";
m_Controls->PlayButton->setChecked(false);
}
else
{
int hertz = m_Controls->UpdateRate->text().toInt();
- int updateTime = itk::Math::Round( static_cast<double>(1000.0/hertz) );
+ int updateTime = itk::Math::Round<int, double>( 1000.0/hertz );
// resets the whole background
m_VideoBackground->SetTimerDelay( updateTime );
m_VideoBackground->AddRenderWindow( m_MultiWidget->GetRenderWindow4()->GetRenderWindow() );
this->connect( m_VideoBackground, SIGNAL(NewFrameAvailable(mitk::VideoSource*))
, this, SLOT(NewFrameAvailable(mitk::VideoSource*)));
m_MultiWidget->DisableGradientBackground();
m_VideoBackground->Enable();
this->m_Controls->StopButton->setEnabled(true);
// show video file controls
if(m_Controls->UseVideoFileButton->isChecked())
{
m_Controls->VideoFileControls->setEnabled(true);
m_Controls->RepeatVideoButton->setEnabled(true);
m_Controls->VideoProgressSlider->setEnabled(true);
}
// show pause button
this->SwitchPlayButton(false);
// disable other controls
m_Controls->GrabbingDevicePanel->setEnabled(false);
m_Controls->VideoFilePanel->setEnabled(false);
m_Controls->UseGrabbingDeviceButton->setEnabled(false);
m_Controls->UseVideoFileButton->setEnabled(false);
m_Controls->UpdateRatePanel->setEnabled(false);
}
}
}
else
{
// show pause button
this->SwitchPlayButton(true);
m_VideoSource->PauseCapturing();
}
}
void QmitkOpenCVVideoControls::on_StopButton_clicked( bool /*checked=false*/ )
{
this->Stop();
}
void QmitkOpenCVVideoControls::Stop()
{
// disable video file controls, stop button and show play button again
m_Controls->UseGrabbingDeviceButton->setEnabled(true);
m_Controls->UseVideoFileButton->setEnabled(true);
if(m_Controls->UseGrabbingDeviceButton->isChecked())
on_UseGrabbingDeviceButton_clicked(true);
else
on_UseVideoFileButton_clicked(true);
m_Controls->UpdateRatePanel->setEnabled(true);
m_Controls->VideoFileControls->setEnabled(false);
this->m_Controls->StopButton->setEnabled(false);
this->SwitchPlayButton(true);
if(m_MultiWidget)
m_MultiWidget->EnableGradientBackground();
if(m_VideoBackground)
{
m_VideoBackground->Disable();
if(m_MultiWidget)
m_VideoBackground->RemoveRenderWindow( m_MultiWidget->GetRenderWindow4()->GetRenderWindow() );
this->disconnect( m_VideoBackground, SIGNAL(NewFrameAvailable(mitk::VideoSource*))
, this, SLOT(NewFrameAvailable(mitk::VideoSource*)));
}
if(m_VideoSource != 0)
m_VideoSource->StopCapturing();
}
void QmitkOpenCVVideoControls::Reset()
{
this->Stop();
}
void QmitkOpenCVVideoControls::SwitchPlayButton(bool paused)
{
if(paused)
{
m_Controls->PlayButton->setText("Play");
m_Controls->PlayButton->setIcon( QIcon(":/OpenCVVideoSupportUI/media-playback-start.png") );
m_Controls->PlayButton->setChecked(false);
}
else
{
m_Controls->PlayButton->setText("Pause");
m_Controls->PlayButton->setIcon( QIcon(":/OpenCVVideoSupportUI/media-playback-pause.png") );
m_Controls->PlayButton->setChecked(true);
}
}
void QmitkOpenCVVideoControls::NewFrameAvailable( mitk::VideoSource* /*videoSource*/ )
{
emit NewOpenCVFrameAvailable( m_VideoSource->GetCurrentFrame() );
if(!m_SliderCurrentlyMoved)
- m_Controls->VideoProgressSlider->setValue( itk::Math::Round( m_VideoSource->GetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO)
+ m_Controls->VideoProgressSlider->setValue( itk::Math::Round<int,double>( m_VideoSource->GetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO)
*m_Controls->VideoProgressSlider->maximum() ) );
}
void QmitkOpenCVVideoControls::SetStdMultiWidget( QmitkStdMultiWidget* _MultiWidget )
{
if(m_MultiWidget == _MultiWidget)
return;
if(m_MultiWidget != 0)
this->disconnect( m_MultiWidget, SIGNAL(destroyed(QObject*))
, this, SLOT(QObjectDestroyed(QObject*)));
// In Reset() m_MultiWidget is used, set it to 0 now for avoiding errors
if(_MultiWidget == 0)
m_MultiWidget = 0;
this->Reset();
m_MultiWidget = _MultiWidget;
if(m_MultiWidget == 0)
{
MITK_WARN << "m_MultiWidget is 0";
this->setEnabled(false);
}
else
{
this->setEnabled(true);
this->connect( m_MultiWidget, SIGNAL(destroyed(QObject*))
, this, SLOT(QObjectDestroyed(QObject*)));
}
}
QmitkStdMultiWidget* QmitkOpenCVVideoControls::GetStdMultiWidget() const
{
return m_MultiWidget;
}
void QmitkOpenCVVideoControls::SetVideoBackground( QmitkVideoBackground* _VideoBackground )
{
if(m_VideoBackground == _VideoBackground)
return;
if(m_VideoBackground != 0)
this->disconnect( m_VideoBackground, SIGNAL(destroyed(QObject*))
, this, SLOT(QObjectDestroyed(QObject*)));
this->Reset();
m_VideoBackground = _VideoBackground;
if(m_VideoBackground == 0)
{
m_VideoSource = 0;
MITK_WARN << "m_MultiWidget is 0";
this->setEnabled(false);
}
else
{
this->setEnabled(true);
m_VideoSource = dynamic_cast<mitk::OpenCVVideoSource*>(m_VideoBackground->GetVideoSource());
// preset form entries
if(m_VideoSource != 0)
{
if(!m_VideoSource->GetVideoFileName().empty())
{
m_Controls->FileChooser->SetFile( m_VideoSource->GetVideoFileName() );
on_UseGrabbingDeviceButton_clicked( false );
}
else if( m_VideoSource->GetGrabbingDeviceNumber() >= 0)
m_Controls->GrabbingDeviceNumber->setValue( m_VideoSource->GetGrabbingDeviceNumber() );
m_Controls->UpdateRate->setValue( m_VideoBackground->GetTimerDelay() );
this->connect( m_VideoBackground, SIGNAL(destroyed(QObject*))
, this, SLOT(QObjectDestroyed(QObject*)));
}
else
{
MITK_WARN << "m_VideoSource is 0";
this->setEnabled(false);
}
}
}
QmitkVideoBackground* QmitkOpenCVVideoControls::GetVideoBackground() const
{
return m_VideoBackground;
}
void QmitkOpenCVVideoControls::QObjectDestroyed( QObject * obj /*= 0 */ )
{
if(m_MultiWidget == obj)
this->SetStdMultiWidget(0);
else if(m_VideoBackground == obj)
{
m_VideoSource = 0;
this->SetVideoBackground(0);
}
}
diff --git a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp
index 389209a187..8a05a9991a 100644
--- a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp
+++ b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp
@@ -1,178 +1,173 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkOpenCVToMitkImageFilter.h"
#include <itkImportImageFilter.h>
#include <itkRGBPixel.h>
#include <mitkITKImageImport.txx>
mitk::OpenCVToMitkImageFilter::OpenCVToMitkImageFilter()
: m_OpenCVImage(0), m_CopyBuffer(true)
{
}
mitk::OpenCVToMitkImageFilter::~OpenCVToMitkImageFilter()
{
}
void mitk::OpenCVToMitkImageFilter::SetOpenCVImage(const IplImage* image)
{
this->m_OpenCVImage = image;
this->Modified();
}
void mitk::OpenCVToMitkImageFilter::GenerateData()
{
if(m_OpenCVImage == 0)
{
MITK_WARN << "Cannot not start filter. OpenCV Image not set.";
return;
}
// convert to rgb image color space
IplImage* rgbOpenCVImage = cvCreateImage( cvSize( m_OpenCVImage->width, m_OpenCVImage->height )
, m_OpenCVImage->depth, m_OpenCVImage->nChannels );
if( m_OpenCVImage->nChannels == 3)
cvCvtColor( m_OpenCVImage, rgbOpenCVImage, CV_BGR2RGB );
// now convert rgb image
if( (m_OpenCVImage->depth>=0) && ((unsigned int)m_OpenCVImage->depth == IPL_DEPTH_8S) && (m_OpenCVImage->nChannels == 1) )
m_Image = ConvertIplToMitkImage< char, 2>( m_OpenCVImage, m_CopyBuffer );
else if( m_OpenCVImage->depth == IPL_DEPTH_8U && m_OpenCVImage->nChannels == 1 )
m_Image = ConvertIplToMitkImage< unsigned char, 2>( m_OpenCVImage, m_CopyBuffer );
else if( m_OpenCVImage->depth == IPL_DEPTH_8U && m_OpenCVImage->nChannels == 3 )
m_Image = ConvertIplToMitkImage< UCRGBPixelType, 2>( rgbOpenCVImage, m_CopyBuffer );
else if( m_OpenCVImage->depth == IPL_DEPTH_16U && m_OpenCVImage->nChannels == 1 )
m_Image = ConvertIplToMitkImage< unsigned short, 2>( m_OpenCVImage, m_CopyBuffer );
else if( m_OpenCVImage->depth == IPL_DEPTH_16U && m_OpenCVImage->nChannels == 3 )
m_Image = ConvertIplToMitkImage< USRGBPixelType, 2>( rgbOpenCVImage, m_CopyBuffer );
else if( m_OpenCVImage->depth == IPL_DEPTH_32F && m_OpenCVImage->nChannels == 1 )
m_Image = ConvertIplToMitkImage< float, 2>( m_OpenCVImage, m_CopyBuffer );
else if( m_OpenCVImage->depth == IPL_DEPTH_32F && m_OpenCVImage->nChannels == 3 )
m_Image = ConvertIplToMitkImage< FloatRGBPixelType , 2>( rgbOpenCVImage, m_CopyBuffer );
else if( m_OpenCVImage->depth == IPL_DEPTH_64F && m_OpenCVImage->nChannels == 1 )
m_Image = ConvertIplToMitkImage< double, 2>( m_OpenCVImage, m_CopyBuffer );
else if( m_OpenCVImage->depth == IPL_DEPTH_64F && m_OpenCVImage->nChannels == 3 )
m_Image = ConvertIplToMitkImage< DoubleRGBPixelType , 2>( rgbOpenCVImage, m_CopyBuffer );
else
{
MITK_WARN << "Unknown image depth and/or pixel type. Cannot convert OpenCV to MITK image.";
return;
}
cvReleaseImage(&rgbOpenCVImage);
}
-mitk::ImageSource::DataObjectPointer mitk::OpenCVToMitkImageFilter::MakeOutput( unsigned int idx )
-{
- return Superclass::MakeOutput(idx);
-}
-
-mitk::ImageSource::OutputImageType* mitk::OpenCVToMitkImageFilter::GetOutput( unsigned int /*idx*/ )
+mitk::ImageSource::OutputImageType* mitk::OpenCVToMitkImageFilter::GetOutput()
{
return m_Image;
}
/********************************************
* Converting from OpenCV image to ITK Image
*********************************************/
template <typename TPixel, unsigned int VImageDimension>
mitk::Image::Pointer mitk::OpenCVToMitkImageFilter::ConvertIplToMitkImage( const IplImage * input, bool copyBuffer )
{
mitk::Image::Pointer mitkImage(0);
typedef itk::Image< TPixel, VImageDimension > ItkImage;
typedef itk::ImportImageFilter< TPixel, VImageDimension > ImportFilterType;
typename ImportFilterType::Pointer importFilter = ImportFilterType::New();
typename ImportFilterType::SizeType size;
size[0] = input->width;
size[1] = input->height;
typename ImportFilterType::IndexType start;
start.Fill( 0 );
typename ImportFilterType::RegionType region;
region.SetIndex( start );
region.SetSize( size );
importFilter->SetRegion( region );
double origin[ VImageDimension ];
origin[0] = 0.0; // X coordinate
origin[1] = 0.0; // Y coordinate
importFilter->SetOrigin( origin );
double spacing[ VImageDimension ];
spacing[0] = 1.0; // along X direction
spacing[1] = 1.0; // along Y direction
importFilter->SetSpacing( spacing );
const unsigned int numberOfPixels = size[0] * size[1];
const unsigned int numberOfBytes = numberOfPixels * sizeof( TPixel );
if( copyBuffer )
{
const bool importImageFilterWillOwnTheBuffer = false;
TPixel * localBuffer = new TPixel[numberOfPixels];
memcpy(localBuffer, input->imageData, numberOfBytes);
importFilter->SetImportPointer( localBuffer, numberOfPixels,
importImageFilterWillOwnTheBuffer );
}
else
{
const bool importImageFilterWillOwnTheBuffer = false;
TPixel * localBuffer = reinterpret_cast< TPixel * >( input->imageData );
importFilter->SetImportPointer( localBuffer, numberOfPixels,
importImageFilterWillOwnTheBuffer );
}
importFilter->Update();
typename ItkImage::Pointer output = importFilter->GetOutput();
output->DisconnectPipeline();
- mitkImage = mitk::ImportItkImage( output );
+ mitkImage = mitk::ImportItkImage(output)->Clone();
return mitkImage;
}
diff --git a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h
index aa8fcfd5c5..324c7ce381 100644
--- a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h
+++ b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h
@@ -1,77 +1,76 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkOpenCVToMitkImageFilter_h
#define mitkOpenCVToMitkImageFilter_h
#include <mitkCommon.h>
#include <mitkImageSource.h>
#include <itkMacro.h>
#include <itkImage.h>
#include <itkRGBPixel.h>
#include <cv.h>
#include "mitkOpenCVVideoSupportExports.h"
namespace mitk
{
/**
\brief Filter for creating MITK RGB Images from an OpenCV image
Last contributor: $Author: mueller $
*/
class MITK_OPENCVVIDEOSUPPORT_EXPORT OpenCVToMitkImageFilter : public ImageSource
{
public:
typedef itk::RGBPixel< unsigned char > UCRGBPixelType;
typedef itk::RGBPixel< unsigned short > USRGBPixelType;
typedef itk::RGBPixel< float > FloatRGBPixelType;
typedef itk::RGBPixel< double > DoubleRGBPixelType;
template <typename TPixel, unsigned int VImageDimension>
static mitk::Image::Pointer ConvertIplToMitkImage( const IplImage * input, bool copyBuffer = true );
mitkClassMacro(OpenCVToMitkImageFilter, ImageSource);
itkNewMacro(OpenCVToMitkImageFilter);
void SetOpenCVImage(const IplImage* image);
itkGetMacro(OpenCVImage, const IplImage*);
itkSetMacro(CopyBuffer, bool);
itkGetMacro(CopyBuffer, bool);
- virtual DataObjectPointer MakeOutput(unsigned int idx);
- OutputImageType* GetOutput(unsigned int idx);
+ OutputImageType* GetOutput(void);
protected:
OpenCVToMitkImageFilter(); // purposely hidden
virtual ~OpenCVToMitkImageFilter();
virtual void GenerateData();
protected:
mitk::Image::Pointer m_Image;
const IplImage* m_OpenCVImage;
bool m_CopyBuffer;
};
} // namespace
#endif // mitkOpenCVToMitkImageFilter_h
diff --git a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.cpp b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.cpp
index c26a46ce17..d5fb22a7a5 100644
--- a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.cpp
+++ b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.cpp
@@ -1,138 +1,144 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlanarFigureObjectFactory.h"
#include "mitkPlanarFigureWriter.h"
#include "mitkCoreObjectFactory.h"
#include "mitkPlanarFigureIOFactory.h"
#include "mitkPlanarFigureWriterFactory.h"
#include "mitkPlanarFigure.h"
#include "mitkPlanarFigureMapper2D.h"
typedef std::multimap<std::string, std::string> MultimapType;
mitk::PlanarFigureObjectFactory::PlanarFigureObjectFactory()
+: m_PlanarFigureIOFactory(PlanarFigureIOFactory::New().GetPointer())
{
static bool alreadyDone = false;
if ( !alreadyDone )
{
RegisterIOFactories();
- itk::ObjectFactoryBase::RegisterFactory( PlanarFigureIOFactory::New() );
+ itk::ObjectFactoryBase::RegisterFactory( m_PlanarFigureIOFactory );
PlanarFigureWriterFactory::RegisterOneFactory();
m_FileWriters.push_back( PlanarFigureWriter::New().GetPointer() );
- mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(this);
-
CreateFileExtensionsMap();
alreadyDone = true;
}
}
+mitk::PlanarFigureObjectFactory::~PlanarFigureObjectFactory()
+{
+ PlanarFigureWriterFactory::UnRegisterOneFactory();
+ itk::ObjectFactoryBase::UnRegisterFactory(m_PlanarFigureIOFactory);
+}
+
mitk::Mapper::Pointer mitk::PlanarFigureObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
{
mitk::Mapper::Pointer newMapper=NULL;
mitk::BaseData *data = node->GetData();
if ( id == mitk::BaseRenderer::Standard2D )
{
if ( dynamic_cast<PlanarFigure*>(data) != NULL )
{
newMapper = mitk::PlanarFigureMapper2D::New();
newMapper->SetDataNode(node);
}
}
else if ( id == mitk::BaseRenderer::Standard3D )
{
}
return newMapper;
}
void mitk::PlanarFigureObjectFactory::SetDefaultProperties(mitk::DataNode* node)
{
if ( node == NULL )
{
return;
}
mitk::DataNode::Pointer nodePointer = node;
mitk::PlanarFigure::Pointer pf = dynamic_cast<mitk::PlanarFigure*>( node->GetData() );
if ( pf.IsNotNull() )
{
mitk::PlanarFigureMapper2D::SetDefaultProperties(node);
node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), NULL, true );
node->AddProperty( "opacity", mitk::FloatProperty::New(0.8), NULL, true );
}
}
const char* mitk::PlanarFigureObjectFactory::GetFileExtensions()
{
return "";
-};
+}
mitk::CoreObjectFactoryBase::MultimapType mitk::PlanarFigureObjectFactory::GetFileExtensionsMap()
{
return m_FileExtensionsMap;
}
const char* mitk::PlanarFigureObjectFactory::GetSaveFileExtensions()
{
//return ";;Planar Figures (*.pf)"; // for mitk::PlanarFigure and derived classes
std::string fileExtension;
this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
return fileExtension.c_str();
};
mitk::CoreObjectFactoryBase::MultimapType mitk::PlanarFigureObjectFactory::GetSaveFileExtensionsMap()
{
return m_SaveFileExtensionsMap;
}
void mitk::PlanarFigureObjectFactory::CreateFileExtensionsMap()
{
+ m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure Files"));
m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure Files"));
}
void mitk::PlanarFigureObjectFactory::RegisterIOFactories()
{
}
struct RegisterPlanarFigureObjectFactory{
RegisterPlanarFigureObjectFactory()
: m_Factory( mitk::PlanarFigureObjectFactory::New() )
{
mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
}
~RegisterPlanarFigureObjectFactory()
{
mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
}
mitk::PlanarFigureObjectFactory::Pointer m_Factory;
};
static RegisterPlanarFigureObjectFactory registerPlanarFigureObjectFactory;
diff --git a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.h b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.h
index bafdb837e7..8d915c460e 100644
--- a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.h
+++ b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.h
@@ -1,55 +1,61 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef PLANARFIGUREOBJECTFACTORY_H_INCLUDED
#define PLANARFIGUREOBJECTFACTORY_H_INCLUDED
#include "mitkCoreObjectFactoryBase.h"
#include "PlanarFigureExports.h"
namespace mitk {
class PlanarFigure_EXPORT PlanarFigureObjectFactory : public CoreObjectFactoryBase
{
public:
- mitkClassMacro(PlanarFigureObjectFactory,CoreObjectFactoryBase);
- itkNewMacro(PlanarFigureObjectFactory);
+ mitkClassMacro(PlanarFigureObjectFactory,CoreObjectFactoryBase)
+ itkNewMacro(PlanarFigureObjectFactory)
+
+ ~PlanarFigureObjectFactory();
virtual Mapper::Pointer CreateMapper(mitk::DataNode* node, MapperSlotId slotId);
virtual void SetDefaultProperties(mitk::DataNode* node);
virtual const char* GetFileExtensions();
virtual mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap();
virtual const char* GetSaveFileExtensions();
virtual mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap();
void RegisterIOFactories();
protected:
PlanarFigureObjectFactory();
void CreateFileExtensionsMap();
MultimapType m_FileExtensionsMap;
MultimapType m_SaveFileExtensionsMap;
+
+private:
+
+ itk::ObjectFactoryBase::Pointer m_PlanarFigureIOFactory;
};
}
#endif // PLANARFIGUREOBJECTFACTORY_H_INCLUDED
diff --git a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureSource.cpp b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureSource.cpp
index e46d6b0eb7..d6cc731e87 100644
--- a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureSource.cpp
+++ b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureSource.cpp
@@ -1,101 +1,55 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlanarFigureSource.h"
+#include "mitkPlanarCircle.h"
+
mitk::PlanarFigureSource::PlanarFigureSource()
{
- // Create the output. We use static_cast<> here because we know the default
- // output must be of type TOutputImage
- //OutputType::Pointer output = static_cast<OutputType*>( this->MakeOutput( 0 ).GetPointer() );
-
- //if ( output.GetPointer() == NULL )
- //{
- // itkWarningMacro(<<"Output could not be created!");
- //}
- //this->ProcessObject::SetNumberOfRequiredOutputs( 1 );
- //this->ProcessObject::SetNthOutput( 0, output.GetPointer() );
+ // Create the output.
+ itk::DataObject::Pointer output = this->MakeOutput(0);
+ Superclass::SetNumberOfRequiredOutputs(1);
+ Superclass::SetNthOutput(0, output);
}
mitk::PlanarFigureSource::~PlanarFigureSource()
{}
-
-mitk::PlanarFigureSource::DataObjectPointer mitk::PlanarFigureSource::MakeOutput ( unsigned int )
+void mitk::PlanarFigureSource::GenerateInputRequestedRegion()
{
- return NULL;
+ this->ProcessObject::GenerateInputRequestedRegion();
}
-
-void mitk::PlanarFigureSource::SetOutput( OutputType* output )
+itk::DataObject::Pointer mitk::PlanarFigureSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
- this->SetNthOutput( 0, output );
+ return static_cast<itk::DataObject *>(PlanarCircle::New().GetPointer());
}
-mitk::PlanarFigureSource::OutputType* mitk::PlanarFigureSource::GetOutput()
+itk::DataObject::Pointer mitk::PlanarFigureSource::MakeOutput( const DataObjectIdentifierType & name )
{
- if ( this->GetNumberOfOutputs() < 1 )
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
{
- return 0;
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
}
-
- if ( static_cast<OutputType*> ( this->ProcessObject::GetOutput( 0 ) ) == NULL )
- itkWarningMacro(<<"Output is NULL!");
- return static_cast<OutputType*> ( this->ProcessObject::GetOutput( 0 ) );
-}
-
-
-mitk::PlanarFigureSource::OutputType* mitk::PlanarFigureSource::GetOutput ( unsigned int idx )
-{
- return static_cast<OutputType*> ( this->ProcessObject::GetOutput( idx ) );
-}
-
-void mitk::PlanarFigureSource::GenerateInputRequestedRegion()
-{
- this->ProcessObject::GenerateInputRequestedRegion();
+ return static_cast<itk::DataObject *>(PlanarCircle::New().GetPointer());
}
-
-void mitk::PlanarFigureSource::GraftOutput(itk::DataObject *graft)
-{
- this->GraftNthOutput(0, graft);
-}
-
-
-void mitk::PlanarFigureSource::GraftNthOutput(unsigned int idx, itk::DataObject *graft)
-{
- if ( idx >= this->GetNumberOfOutputs() )
- {
- itkExceptionMacro(<<"Requested to graft output " << idx <<
- " but this filter only has " << this->GetNumberOfOutputs() << " Outputs.");
- }
-
- if ( !graft )
- {
- itkExceptionMacro(<<"Requested to graft output with a NULL pointer object" );
- }
-
- itk::DataObject* output = this->GetOutput(idx);
- if ( !output )
- {
- itkExceptionMacro(<<"Requested to graft output that is a NULL pointer" );
- }
- // Call Graft on NavigationData to copy member data
- output->Graft( graft );
-}
+mitkBaseDataSourceGetOutputDefinitions(mitk::PlanarFigureSource)
diff --git a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureSource.h b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureSource.h
index c91dcecac4..5f31868f96 100644
--- a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureSource.h
+++ b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureSource.h
@@ -1,96 +1,77 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKPlanarFigureSOURCE_H_HEADER_INCLUDED
#define MITKPlanarFigureSOURCE_H_HEADER_INCLUDED
#include "mitkPlanarFigure.h"
#include "PlanarFigureExports.h"
#include "mitkCommon.h"
-#include "mitkBaseProcess.h"
+#include "mitkBaseDataSource.h"
namespace mitk
{
/**
* @brief Base class for all filters which have an object of type
* mitk::PlanarFigure as output
*
* Base class for all filters which have an object of type mitk::PlanarFigure
* as output. mitk::PlanarFigureSources do not provide support
* for streaming, that is, that the requested region is always the largest
* possible region.
* @ingroup Process
*/
-class PlanarFigure_EXPORT PlanarFigureSource : public mitk::BaseProcess
+class PlanarFigure_EXPORT PlanarFigureSource : public mitk::BaseDataSource
{
public:
- mitkClassMacro( PlanarFigureSource, BaseProcess );
- itkNewMacro( Self );
+ mitkClassMacro( PlanarFigureSource, BaseDataSource )
+ itkNewMacro( Self )
typedef mitk::PlanarFigure OutputType;
typedef OutputType::Pointer OutputTypePointer;
typedef itk::DataObject::Pointer DataObjectPointer;
+ mitkBaseDataSourceGetOutputDeclarations
+
/**
- * Allocates a new output object and returns it.
+ * Allocates a new output object and returns it. Currently the
+ * index idx is not evaluated.
* @param idx the index of the output for which an object should be created
* @returns the new object
*/
- virtual DataObjectPointer MakeOutput ( unsigned int idx );
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
/**
- * Generates the input requested region simply by calling the equivalent
- * method of the superclass.
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
*/
- void GenerateInputRequestedRegion();
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
/**
- * Allows to set the output of the planar figure source. According to the itk documentation
- * this method is outdated and should not be used. Instead GraftOutput(...)
- * should be used.
- * @param output the intended output of the planar figure source
- */
- void SetOutput( OutputType* output );
-
- /**
- * Graft output 0 to the parameter graft
- */
- virtual void GraftOutput(itk::DataObject *graft);
- /**
- * Graft output idx to the parameter graft
- */
- virtual void GraftNthOutput(unsigned int idx, itk::DataObject *graft);
-
- /**
- * Returns the output with index 0 of the planar figure source
- * @returns the output
- */
- OutputType* GetOutput();
-
- /**
- * Returns the nth output of the planar figure source
- * @param idx the index of the wanted output
- * @returns the output with index idx.
+ * Generates the input requested region simply by calling the equivalent
+ * method of the superclass.
*/
- OutputType* GetOutput ( unsigned int idx );
+ void GenerateInputRequestedRegion();
protected:
PlanarFigureSource();
virtual ~PlanarFigureSource();
};
} // namespace mitk
#endif
diff --git a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureToPlanarFigureFilter.cpp b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureToPlanarFigureFilter.cpp
index 2991c58c89..f43e6f88aa 100644
--- a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureToPlanarFigureFilter.cpp
+++ b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureToPlanarFigureFilter.cpp
@@ -1,75 +1,75 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlanarFigureToPlanarFigureFilter.h"
mitk::PlanarFigureToPlanarFigureFilter::PlanarFigureToPlanarFigureFilter()
: mitk::PlanarFigureSource()
{
this->SetNumberOfRequiredInputs(1);
}
mitk::PlanarFigureToPlanarFigureFilter::~PlanarFigureToPlanarFigureFilter()
{
}
void mitk::PlanarFigureToPlanarFigureFilter::SetInput( const InputType* figure )
{
this->SetInput( 0, figure );
}
void mitk::PlanarFigureToPlanarFigureFilter::SetInput( unsigned int idx, const InputType* figure )
{
if ( this->GetInput(idx) != figure )
{
this->SetNthInput( idx, const_cast<InputType*>( figure ) );
this->CreateOutputsForAllInputs();
this->Modified();
}
}
const mitk::PlanarFigureToPlanarFigureFilter::InputType* mitk::PlanarFigureToPlanarFigureFilter::GetInput()
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const InputType*>(this->ProcessObject::GetInput(0));
}
const mitk::PlanarFigureToPlanarFigureFilter::InputType* mitk::PlanarFigureToPlanarFigureFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < idx)
return NULL;
return static_cast<const InputType*>(this->ProcessObject::GetInput(idx));
}
void mitk::PlanarFigureToPlanarFigureFilter::CreateOutputsForAllInputs()
{
- this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create outputs for all inputs
+ this->SetNumberOfIndexedOutputs(this->GetNumberOfInputs()); // create outputs for all inputs
for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
{
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
}
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
index 0c967a5194..0ffe539b13 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
@@ -1,707 +1,707 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlanarFigure.h"
#include "mitkGeometry2D.h"
#include "mitkProperties.h"
#include "algorithm"
mitk::PlanarFigure::PlanarFigure()
: m_SelectedControlPoint( -1 ),
m_PreviewControlPointVisible( false ),
m_FigurePlaced( false ),
m_Geometry2D( NULL ),
m_PolyLineUpToDate(false),
m_HelperLinesUpToDate(false),
m_FeaturesUpToDate(false),
m_FeaturesMTime( 0 )
{
m_HelperPolyLinesToBePainted = BoolContainerType::New();
m_DisplaySize.first = 0.0;
m_DisplaySize.second = 0;
this->SetProperty( "closed", mitk::BoolProperty::New( false ) );
// Currently only single-time-step geometries are supported
this->InitializeTimeSlicedGeometry( 1 );
}
mitk::PlanarFigure::~PlanarFigure()
{
}
void mitk::PlanarFigure::SetGeometry2D( mitk::Geometry2D *geometry )
{
this->SetGeometry( geometry );
m_Geometry2D = geometry;
}
const mitk::Geometry2D *mitk::PlanarFigure::GetGeometry2D() const
{
return m_Geometry2D;
}
bool mitk::PlanarFigure::IsClosed() const
{
mitk::BoolProperty* closed = dynamic_cast< mitk::BoolProperty* >( this->GetProperty( "closed" ).GetPointer() );
if ( closed != NULL )
{
return closed->GetValue();
}
return false;
}
void mitk::PlanarFigure::PlaceFigure( const mitk::Point2D& point )
{
for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
{
m_ControlPoints.push_back( this->ApplyControlPointConstraints( i, point ) );
}
m_FigurePlaced = true;
m_SelectedControlPoint = 1;
}
bool mitk::PlanarFigure::AddControlPoint( const mitk::Point2D& point, int position )
{
// if we already have the maximum number of control points, do nothing
if ( m_NumberOfControlPoints < this->GetMaximumNumberOfControlPoints() )
{
// if position has not been defined or position would be the last control point, just append the new one
// we also append a new point if we click onto the line between the first two control-points if the second control-point is selected
// -> special case for PlanarCross
if ( position == -1 || position > (int)m_NumberOfControlPoints-1 || (position == 1 && m_SelectedControlPoint == 2) )
{
if ( m_ControlPoints.size() > this->GetMaximumNumberOfControlPoints()-1 )
{
// get rid of deprecated control points in the list. This is necessary
// as ::ResetNumberOfControlPoints() only sets the member, does not resize the list!
m_ControlPoints.resize( this->GetNumberOfControlPoints() );
}
m_ControlPoints.push_back( this->ApplyControlPointConstraints( m_NumberOfControlPoints, point ) );
m_SelectedControlPoint = m_NumberOfControlPoints;
}
else
{
// insert the point at the given position and set it as selected point
ControlPointListType::iterator iter = m_ControlPoints.begin() + position;
m_ControlPoints.insert( iter, this->ApplyControlPointConstraints( position, point ) );
for( unsigned int i = 0; i < m_ControlPoints.size(); ++i )
{
if( point == m_ControlPoints.at(i) )
{
m_SelectedControlPoint = i;
}
}
}
// polylines & helperpolylines need to be repainted
m_PolyLineUpToDate = false;
m_HelperLinesUpToDate = false;
m_FeaturesUpToDate = false;
// one control point more
++m_NumberOfControlPoints;
return true;
}
else
{
return false;
}
}
bool mitk::PlanarFigure::SetControlPoint( unsigned int index, const Point2D& point, bool createIfDoesNotExist )
{
bool controlPointSetCorrectly = false;
if (createIfDoesNotExist)
{
if ( m_NumberOfControlPoints <= index )
{
m_ControlPoints.push_back( this->ApplyControlPointConstraints( index, point ) );
m_NumberOfControlPoints++;
}
else
{
m_ControlPoints.at( index ) = this->ApplyControlPointConstraints( index, point );
}
controlPointSetCorrectly = true;
}
else if ( index < m_NumberOfControlPoints )
{
m_ControlPoints.at( index ) = this->ApplyControlPointConstraints( index, point );
controlPointSetCorrectly = true;
}
else
{
return false;
}
if ( controlPointSetCorrectly )
{
m_PolyLineUpToDate = false;
m_HelperLinesUpToDate = false;
m_FeaturesUpToDate = false;
}
return controlPointSetCorrectly;
}
bool mitk::PlanarFigure::SetCurrentControlPoint( const Point2D& point )
{
if ( (m_SelectedControlPoint < 0) || (m_SelectedControlPoint >= (int)m_NumberOfControlPoints) )
{
return false;
}
return this->SetControlPoint(m_SelectedControlPoint, point, false);
}
unsigned int mitk::PlanarFigure::GetNumberOfControlPoints() const
{
return m_NumberOfControlPoints;
}
bool mitk::PlanarFigure::SelectControlPoint( unsigned int index )
{
if ( index < this->GetNumberOfControlPoints() )
{
m_SelectedControlPoint = index;
return true;
}
else
{
return false;
}
}
bool mitk::PlanarFigure::DeselectControlPoint()
{
bool wasSelected = ( m_SelectedControlPoint != -1);
m_SelectedControlPoint = -1;
return wasSelected;
}
void mitk::PlanarFigure::SetPreviewControlPoint( const Point2D& point )
{
m_PreviewControlPoint = point;
m_PreviewControlPointVisible = true;
}
void mitk::PlanarFigure::ResetPreviewContolPoint()
{
m_PreviewControlPointVisible = false;
}
mitk::Point2D mitk::PlanarFigure::GetPreviewControlPoint()
{
return m_PreviewControlPoint;
}
bool mitk::PlanarFigure::IsPreviewControlPointVisible()
{
return m_PreviewControlPointVisible;
}
mitk::Point2D mitk::PlanarFigure::GetControlPoint( unsigned int index ) const
{
if ( index < m_NumberOfControlPoints )
{
return m_ControlPoints.at( index );
}
itkExceptionMacro( << "GetControlPoint(): Invalid index!" );
}
mitk::Point3D mitk::PlanarFigure::GetWorldControlPoint( unsigned int index ) const
{
Point3D point3D;
if ( (m_Geometry2D != NULL) && (index < m_NumberOfControlPoints) )
{
m_Geometry2D->Map( m_ControlPoints.at( index ), point3D );
return point3D;
}
itkExceptionMacro( << "GetWorldControlPoint(): Invalid index!" );
}
const mitk::PlanarFigure::PolyLineType
mitk::PlanarFigure::GetPolyLine(unsigned int index)
{
mitk::PlanarFigure::PolyLineType polyLine;
if ( index > m_PolyLines.size() || !m_PolyLineUpToDate )
{
this->GeneratePolyLine();
m_PolyLineUpToDate = true;
}
return m_PolyLines.at( index );;
}
const mitk::PlanarFigure::PolyLineType
mitk::PlanarFigure::GetPolyLine(unsigned int index) const
{
return m_PolyLines.at( index );
}
void mitk::PlanarFigure::ClearPolyLines()
{
for ( std::vector<PolyLineType>::size_type i=0; i<m_PolyLines.size(); i++ )
{
m_PolyLines.at( i ).clear();
}
m_PolyLineUpToDate = false;
}
const mitk::PlanarFigure::PolyLineType mitk::PlanarFigure::GetHelperPolyLine( unsigned int index,
double mmPerDisplayUnit,
unsigned int displayHeight )
{
mitk::PlanarFigure::PolyLineType helperPolyLine;
if ( index < m_HelperPolyLines.size() )
{
// m_HelperLinesUpToDate does not cover changes in zoom-level, so we have to check previous values of the
// two parameters as well
if ( !m_HelperLinesUpToDate || m_DisplaySize.first != mmPerDisplayUnit || m_DisplaySize.second != displayHeight )
{
this->GenerateHelperPolyLine(mmPerDisplayUnit, displayHeight);
m_HelperLinesUpToDate = true;
// store these parameters to be able to check next time if somebody zoomed in or out
m_DisplaySize.first = mmPerDisplayUnit;
m_DisplaySize.second = displayHeight;
}
helperPolyLine = m_HelperPolyLines.at(index);
}
return helperPolyLine;
}
void mitk::PlanarFigure::ClearHelperPolyLines()
{
for ( std::vector<PolyLineType>::size_type i=0; i<m_HelperPolyLines.size(); i++ )
{
m_HelperPolyLines.at(i).clear();
}
m_HelperLinesUpToDate = false;
}
/** \brief Returns the number of features available for this PlanarFigure
* (such as, radius, area, ...). */
unsigned int mitk::PlanarFigure::GetNumberOfFeatures() const
{
return m_Features.size();
}
const char *mitk::PlanarFigure::GetFeatureName( unsigned int index ) const
{
if ( index < m_Features.size() )
{
return m_Features[index].Name.c_str();
}
else
{
return NULL;
}
}
const char *mitk::PlanarFigure::GetFeatureUnit( unsigned int index ) const
{
if ( index < m_Features.size() )
{
return m_Features[index].Unit.c_str();
}
else
{
return NULL;
}
}
double mitk::PlanarFigure::GetQuantity( unsigned int index ) const
{
if ( index < m_Features.size() )
{
return m_Features[index].Quantity;
}
else
{
return 0.0;
}
}
bool mitk::PlanarFigure::IsFeatureActive( unsigned int index ) const
{
if ( index < m_Features.size() )
{
return m_Features[index].Active;
}
else
{
return false;
}
}
bool mitk::PlanarFigure::IsFeatureVisible( unsigned int index ) const
{
if ( index < m_Features.size() )
{
return m_Features[index].Visible;
}
else
{
return false;
}
}
void mitk::PlanarFigure::SetFeatureVisible( unsigned int index, bool visible )
{
if ( index < m_Features.size() )
{
m_Features[index].Visible = visible;
}
}
void mitk::PlanarFigure::EvaluateFeatures()
{
if ( !m_FeaturesUpToDate || !m_PolyLineUpToDate )
{
if ( !m_PolyLineUpToDate )
{
this->GeneratePolyLine();
}
this->EvaluateFeaturesInternal();
m_FeaturesUpToDate = true;
}
}
void mitk::PlanarFigure::UpdateOutputInformation()
{
// Bounds are NOT calculated here, since the Geometry2D defines a fixed
// frame (= bounds) for the planar figure.
Superclass::UpdateOutputInformation();
this->GetTimeSlicedGeometry()->UpdateInformation();
}
void mitk::PlanarFigure::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::PlanarFigure::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::PlanarFigure::VerifyRequestedRegion()
{
return true;
}
-void mitk::PlanarFigure::SetRequestedRegion( itk::DataObject * /*data*/ )
+void mitk::PlanarFigure::SetRequestedRegion(const itk::DataObject * /*data*/ )
{
}
void mitk::PlanarFigure::ResetNumberOfControlPoints( int numberOfControlPoints )
{
// DO NOT resize the list here, will cause crash!!
m_NumberOfControlPoints = numberOfControlPoints;
}
mitk::Point2D mitk::PlanarFigure::ApplyControlPointConstraints( unsigned int /*index*/, const Point2D& point )
{
if ( m_Geometry2D == NULL )
{
return point;
}
Point2D indexPoint;
m_Geometry2D->WorldToIndex( point, indexPoint );
BoundingBox::BoundsArrayType bounds = m_Geometry2D->GetBounds();
if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; }
if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; }
if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; }
if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; }
Point2D constrainedPoint;
m_Geometry2D->IndexToWorld( indexPoint, constrainedPoint );
return constrainedPoint;
}
unsigned int mitk::PlanarFigure::AddFeature( const char *featureName, const char *unitName )
{
unsigned int index = m_Features.size();
Feature newFeature( featureName, unitName );
m_Features.push_back( newFeature );
return index;
}
void mitk::PlanarFigure::SetFeatureName( unsigned int index, const char *featureName )
{
if ( index < m_Features.size() )
{
m_Features[index].Name = featureName;
}
}
void mitk::PlanarFigure::SetFeatureUnit( unsigned int index, const char *unitName )
{
if ( index < m_Features.size() )
{
m_Features[index].Unit = unitName;
}
}
void mitk::PlanarFigure::SetQuantity( unsigned int index, double quantity )
{
if ( index < m_Features.size() )
{
m_Features[index].Quantity = quantity;
}
}
void mitk::PlanarFigure::ActivateFeature( unsigned int index )
{
if ( index < m_Features.size() )
{
m_Features[index].Active = true;
}
}
void mitk::PlanarFigure::DeactivateFeature( unsigned int index )
{
if ( index < m_Features.size() )
{
m_Features[index].Active = false;
}
}
void mitk::PlanarFigure::InitializeTimeSlicedGeometry( unsigned int timeSteps )
{
mitk::TimeSlicedGeometry::Pointer timeGeometry = this->GetTimeSlicedGeometry();
mitk::Geometry2D::Pointer geometry2D = mitk::Geometry2D::New();
geometry2D->Initialize();
if ( timeSteps > 1 )
{
mitk::ScalarType timeBounds[] = {0.0, 1.0};
geometry2D->SetTimeBounds( timeBounds );
}
// The geometry is propagated automatically to all time steps,
// if EvenlyTimed is true...
timeGeometry->InitializeEvenlyTimed( geometry2D, timeSteps );
}
void mitk::PlanarFigure::PrintSelf( std::ostream& os, itk::Indent indent) const
{
Superclass::PrintSelf( os, indent );
os << indent << this->GetNameOfClass() << ":\n";
if (this->IsClosed())
os << indent << "This figure is closed\n";
else
os << indent << "This figure is not closed\n";
os << indent << "Minimum number of control points: " << this->GetMinimumNumberOfControlPoints() << std::endl;
os << indent << "Maximum number of control points: " << this->GetMaximumNumberOfControlPoints() << std::endl;
os << indent << "Current number of control points: " << this->GetNumberOfControlPoints() << std::endl;
os << indent << "Control points:" << std::endl;
for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
{
//os << indent.GetNextIndent() << i << ": " << m_ControlPoints->ElementAt( i ) << std::endl;
os << indent.GetNextIndent() << i << ": " << m_ControlPoints.at( i ) << std::endl;
}
os << indent << "Geometry:\n";
this->GetGeometry2D()->Print(os, indent.GetNextIndent());
}
unsigned short mitk::PlanarFigure::GetPolyLinesSize()
{
if ( !m_PolyLineUpToDate )
{
this->GeneratePolyLine();
m_PolyLineUpToDate = true;
}
return m_PolyLines.size();
}
unsigned short mitk::PlanarFigure::GetHelperPolyLinesSize()
{
return m_HelperPolyLines.size();
}
bool mitk::PlanarFigure::IsHelperToBePainted(unsigned int index)
{
return m_HelperPolyLinesToBePainted->GetElement( index );
}
bool mitk::PlanarFigure::ResetOnPointSelect()
{
return false;
}
void mitk::PlanarFigure::RemoveControlPoint( unsigned int index )
{
if ( index > m_ControlPoints.size() )
return;
if ( (m_ControlPoints.size() -1) < this->GetMinimumNumberOfControlPoints() )
return;
ControlPointListType::iterator iter;
iter = m_ControlPoints.begin() + index;
m_ControlPoints.erase( iter );
m_PolyLineUpToDate = false;
m_HelperLinesUpToDate = false;
m_FeaturesUpToDate = false;
--m_NumberOfControlPoints;
}
void mitk::PlanarFigure::RemoveLastControlPoint()
{
RemoveControlPoint( m_ControlPoints.size()-1 );
}
void mitk::PlanarFigure::DeepCopy(Self::Pointer oldFigure)
{
//DeepCopy only same types of planar figures
//Notice to get typeid polymorph you have to use the *operator
if(typeid(*oldFigure) != typeid(*this))
{
itkExceptionMacro( << "DeepCopy(): Inconsistent type of source (" << typeid(*oldFigure).name() << ") and destination figure (" << typeid(*this).name() << ")!" );
return;
}
m_ControlPoints.clear();
this->ClearPolyLines();
this->ClearHelperPolyLines();
// clone base data members
SetPropertyList(oldFigure->GetPropertyList()->Clone());
/// deep copy members
m_FigurePlaced = oldFigure->m_FigurePlaced;
m_SelectedControlPoint = oldFigure->m_SelectedControlPoint;
m_FeaturesMTime = oldFigure->m_FeaturesMTime;
m_Features = oldFigure->m_Features;
m_NumberOfControlPoints = oldFigure->m_NumberOfControlPoints;
//copy geometry 2D of planar figure
SetGeometry2D((mitk::Geometry2D*)oldFigure->m_Geometry2D->Clone().GetPointer());
for(unsigned long index=0; index < oldFigure->GetNumberOfControlPoints(); index++)
{
m_ControlPoints.push_back( oldFigure->GetControlPoint( index ));
}
//After setting the control points we can generate the polylines
this->GeneratePolyLine();
}
void mitk::PlanarFigure::SetNumberOfPolyLines( unsigned int numberOfPolyLines )
{
m_PolyLines.resize(numberOfPolyLines);
}
void mitk::PlanarFigure::SetNumberOfHelperPolyLines( unsigned int numberOfHerlperPolyLines )
{
m_HelperPolyLines.resize(numberOfHerlperPolyLines);
}
void mitk::PlanarFigure::AppendPointToPolyLine( unsigned int index, PolyLineElement element )
{
if ( index < m_PolyLines.size() )
{
m_PolyLines.at( index ).push_back( element );
m_PolyLineUpToDate = false;
}
else
{
MITK_ERROR << "Tried to add point to PolyLine " << index+1 << ", although only " << m_PolyLines.size() << " exists";
}
}
void mitk::PlanarFigure::AppendPointToHelperPolyLine( unsigned int index, PolyLineElement element )
{
if ( index < m_HelperPolyLines.size() )
{
m_HelperPolyLines.at( index ).push_back( element );
m_HelperLinesUpToDate = false;
}
else
{
MITK_ERROR << "Tried to add point to HelperPolyLine " << index+1 << ", although only " << m_HelperPolyLines.size() << " exists";
}
}
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
index d8453e3451..22a892d74b 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
@@ -1,407 +1,410 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_PLANAR_FIGURE_H_
#define _MITK_PLANAR_FIGURE_H_
#include "PlanarFigureExports.h"
#include "mitkBaseData.h"
#include "mitkCommon.h"
#include <deque>
namespace mitk
{
class Geometry2D;
/**
* \brief Base-class for geometric planar (2D) figures, such as
* lines, circles, rectangles, polygons, etc.
*
* \warning Currently does not support time-resolved data handling
*
* Behavior and appearance of PlanarFigures are controlled by various properties; for a detailed
* list of appearance properties see mitk::PlanarFigureMapper2D
*
* The following properties control general PlanarFigure behavior:
*
* <ul>
* <li>"selected": true if the planar figure is selected
* <li>"planarfigure.ishovering": true if the mouse "hovers" over the planar figure
* <li>"planarfigure.iseditable": true if the planar figure can be edited (otherwise,
* it can only be picked/selected, but its control points cannot be edited); default is true
* <li>"planarfigure.isextendable": true if new control points can be inserted into the list of control points;
* default is false
* </ul>
*
*
* TODO: Implement local 2D transform (including center of rotation...)
*
*/
class PlanarFigure_EXPORT PlanarFigure : public BaseData
{
public:
- mitkClassMacro( PlanarFigure, BaseData );
+ mitkClassMacro( PlanarFigure, BaseData )
struct PolyLineElement
{
PolyLineElement( Point2D point, int index )
: Point( point ), Index( index )
{
};
Point2D Point;
int Index;
};
typedef itk::VectorContainer< unsigned long, bool> BoolContainerType;
typedef std::deque< Point2D > ControlPointListType;
typedef std::list< PolyLineElement > PolyLineType;
/** \brief Sets the 2D geometry on which this figure will be placed.
*
* In most cases, this is a Geometry already owned by another object, e.g.
* describing the slice of the image on which measurements will be
* performed.
*/
virtual void SetGeometry2D( mitk::Geometry2D *geometry );
/** \brief Returns (previously set) 2D geometry of this figure. */
virtual const Geometry2D *GetGeometry2D() const;
/** \brief True if the planar figure is closed.
*
* Default is false. The "closed" boolean property must be set in sub-classes. */
virtual bool IsClosed() const;
/** \brief True if the planar figure has been placed (and can be
* displayed/interacted with). */
virtual bool IsPlaced() const { return m_FigurePlaced; };
/** \brief Place figure at the given point (in 2D index coordinates) onto
* the given 2D geometry.
*
* By default, the first two control points of the figure are set to the
* passed point. Further points can be set via AddControlPoint(), if the
* current number of control points is below the maximum number of control
* points.
*
* Can be re-implemented in sub-classes as needed.
*/
virtual void PlaceFigure( const Point2D& point );
/**
* \brief Adds / inserts new control-points
*
* This method adds a new control-point with the coordinates defined by point at the given index.
* If 'index' == -1 or index is greater than the number of control-points the new point is appended
* to the back of the list of control points.
* If a control-point already exists for 'index', an additional point is inserted at that position.
* It is not possible to add more points if the maximum number of control-points (GetMaximumNumberOfControlPoints())
* has been reached.
*/
virtual bool AddControlPoint( const Point2D& point, int index = -1 );
virtual bool SetControlPoint( unsigned int index, const Point2D& point, bool createIfDoesNotExist = false);
virtual bool SetCurrentControlPoint( const Point2D& point );
/** \brief Returns the current number of 2D control points defining this figure. */
unsigned int GetNumberOfControlPoints() const;
/** \brief Returns the minimum number of control points needed to represent
* this figure.
*
* Must be implemented in sub-classes.
*/
virtual unsigned int GetMinimumNumberOfControlPoints() const = 0;
/** \brief Returns the maximum number of control points allowed for
* this figure (e.g. 3 for triangles).
*
* Must be implemented in sub-classes.
*/
virtual unsigned int GetMaximumNumberOfControlPoints() const = 0;
/** \brief Selects currently active control points. */
virtual bool SelectControlPoint( unsigned int index );
/** \brief Deselect control point; no control point active. */
virtual bool DeselectControlPoint();
/** \brief Return currently selected control point. */
virtual int GetSelectedControlPoint() const { return m_SelectedControlPoint; }
/** \brief Returns specified control point in 2D world coordinates. */
Point2D GetControlPoint( unsigned int index ) const;
/** \brief Returns specified control point in world coordinates. */
Point3D GetWorldControlPoint( unsigned int index ) const;
/** \brief Returns the polyline representing the planar figure
* (for rendering, measurements, etc.). */
const PolyLineType GetPolyLine(unsigned int index);
/** \brief Returns the polyline representing the planar figure
* (for rendering, measurments, etc.). */
const PolyLineType GetPolyLine(unsigned int index) const;
/** \brief Returns the polyline that should be drawn the same size at every scale
* (for text, angles, etc.). */
const PolyLineType GetHelperPolyLine( unsigned int index, double mmPerDisplayUnit, unsigned int displayHeight );
/** \brief Sets the position of the PreviewControlPoint. Automatically sets it visible.*/
void SetPreviewControlPoint( const Point2D& point );
/** \brief Marks the PreviewControlPoint as invisible.*/
void ResetPreviewContolPoint();
/** \brief Returns whether or not the PreviewControlPoint is visible.*/
bool IsPreviewControlPointVisible();
/** \brief Returns the coordinates of the PreviewControlPoint. */
Point2D GetPreviewControlPoint();
/** \brief Returns the number of features available for this PlanarFigure
* (such as, radius, area, ...). */
virtual unsigned int GetNumberOfFeatures() const;
/** \brief Returns the name (identifier) of the specified features. */
const char *GetFeatureName( unsigned int index ) const;
/** \brief Returns the physical unit of the specified features. */
const char *GetFeatureUnit( unsigned int index ) const;
/** Returns quantity of the specified feature (e.g., length, radius,
* area, ... ) */
double GetQuantity( unsigned int index ) const;
/** \brief Returns true if the feature with the specified index exists and
* is active (an inactive feature may e.g. be the area of a non-closed
* polygon. */
bool IsFeatureActive( unsigned int index ) const;
/** \brief Returns true if the feature with the specified index exists and is set visible */
bool IsFeatureVisible( unsigned int index ) const;
/** \brief Defines if the feature with the specified index will be shown as an
* overlay in the RenderWindow */
void SetFeatureVisible( unsigned int index, bool visible );
/** \brief Calculates quantities of all features of this planar figure. */
virtual void EvaluateFeatures();
/** \brief Intherited from parent */
virtual void UpdateOutputInformation();
/** \brief Intherited from parent */
virtual void SetRequestedRegionToLargestPossibleRegion();
/** \brief Intherited from parent */
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
/** \brief Intherited from parent */
virtual bool VerifyRequestedRegion();
/** \brief Intherited from parent */
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion( const itk::DataObject *data);
/** \brief Returns the current number of polylines */
virtual unsigned short GetPolyLinesSize();
/** \brief Returns the current number of helperpolylines */
virtual unsigned short GetHelperPolyLinesSize();
/** \brief Returns whether a helper polyline should be painted or not */
virtual bool IsHelperToBePainted(unsigned int index);
/** \brief Returns true if the planar figure is reset to "add points" mode
* when a point is selected.
*
* Default return value is false. Subclasses can overwrite this method and
* execute any reset / initialization statements required. */
virtual bool ResetOnPointSelect();
/** \brief removes the point with the given index from the list of controlpoints. */
virtual void RemoveControlPoint( unsigned int index );
/** \brief Removes last control point */
virtual void RemoveLastControlPoint();
/** \brief Copies contents and state of a figre provided as parameter to the current object.
Requires a matching type of both figures. */
void DeepCopy(Self::Pointer oldFigure);
/** \brief Allow sub-classes to apply constraints on control points.
*
* Sub-classes can define spatial constraints to certain control points by
* overwriting this method and returning a constrained point. By default,
* the points are constrained by the image bounds. */
virtual Point2D ApplyControlPointConstraints( unsigned int /*index*/, const Point2D& point );
protected:
PlanarFigure();
virtual ~PlanarFigure();
/** \brief Set the initial number of control points of the planar figure */
void ResetNumberOfControlPoints( int numberOfControlPoints );
/** Adds feature (e.g., circumference, radius, angle, ...) to feature vector
* of a planar figure object and returns integer ID for the feature element.
* Should be called in sub-class constructors. */
virtual unsigned int AddFeature( const char *featureName, const char *unitName );
/** Sets the name of the specified feature. INTERNAL METHOD. */
void SetFeatureName( unsigned int index, const char *featureName );
/** Sets the physical unit of the specified feature. INTERNAL METHOD. */
void SetFeatureUnit( unsigned int index, const char *unitName );
/** Sets quantity of the specified feature. INTERNAL METHOD. */
void SetQuantity( unsigned int index, double quantity );
/** Sets the specified feature as active. INTERAL METHOD. */
void ActivateFeature( unsigned int index );
/** Sets the specified feature as active. INTERAL METHOD. */
void DeactivateFeature( unsigned int index );
/** \brief Generates the poly-line representation of the planar figure.
* Must be implemented in sub-classes. */
virtual void GeneratePolyLine() = 0;
/** \brief Generates the poly-lines that should be drawn the same size regardless of zoom.
* Must be implemented in sub-classes. */
virtual void GenerateHelperPolyLine(double mmPerDisplayUnit, unsigned int displayHeight) = 0;
/** \brief Calculates quantities of all features of this planar figure.
* Must be implemented in sub-classes. */
virtual void EvaluateFeaturesInternal() = 0;
/** \brief Initializes the TimeSlicedGeometry describing the (time-resolved)
* geometry of this figure. Note that each time step holds one Geometry2D. */
virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 );
/** \brief defines the number of PolyLines that will be available */
void SetNumberOfPolyLines( unsigned int numberOfPolyLines );
/** \brief Append a point to the PolyLine # index */
void AppendPointToPolyLine( unsigned int index, PolyLineElement element );
/** \brief clears the list of PolyLines. Call before re-calculating a new Polyline. */
void ClearPolyLines();
/** \brief defines the number of HelperPolyLines that will be available */
void SetNumberOfHelperPolyLines( unsigned int numberOfHelperPolyLines );
/** \brief Append a point to the HelperPolyLine # index */
void AppendPointToHelperPolyLine( unsigned int index, PolyLineElement element );
/** \brief clears the list of HelperPolyLines. Call before re-calculating a new HelperPolyline. */
void ClearHelperPolyLines();
virtual void PrintSelf( std::ostream& os, itk::Indent indent ) const;
ControlPointListType m_ControlPoints;
unsigned int m_NumberOfControlPoints;
// Currently selected control point; -1 means no point selected
int m_SelectedControlPoint;
std::vector<PolyLineType> m_PolyLines;
std::vector<PolyLineType> m_HelperPolyLines;
BoolContainerType::Pointer m_HelperPolyLinesToBePainted;
// this point is used to store the coordiantes an additional 'ControlPoint' that is rendered
// when the mouse cursor is above the figure (and not a control-point) and when the
// property 'planarfigure.isextendable' is set to true
Point2D m_PreviewControlPoint;
bool m_PreviewControlPointVisible;
bool m_FigurePlaced;
private:
+ // not implemented to prevent PlanarFigure::New() calls which would create an itk::Object.
+ static Pointer New();
+
struct Feature
{
Feature( const char *name, const char *unit )
: Name( name ), Unit( unit ), Quantity( 0.0 ), Active( true ), Visible( true )
{
- };
+ }
std::string Name;
std::string Unit;
double Quantity;
bool Active;
bool Visible;
};
Geometry2D *m_Geometry2D;
bool m_PolyLineUpToDate;
bool m_HelperLinesUpToDate;
bool m_FeaturesUpToDate;
// Vector of features available for this geometric figure
typedef std::vector< Feature > FeatureVectorType;
FeatureVectorType m_Features;
unsigned long m_FeaturesMTime;
// this pair is used to store the mmInDisplayUnits (m_DisplaySize.first) and the displayHeight (m_DisplaySize.second)
// that the helperPolyLines have been calculated for.
// It's used to determine whether or not GetHelperPolyLine() needs to recalculate the HelperPolyLines.
std::pair<double, unsigned int> m_DisplaySize;
};
} // namespace mitk
#endif //_MITK_PLANAR_FIGURE_H_
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarFigureControlPointStyleProperty.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarFigureControlPointStyleProperty.cpp
index e353c99895..1074cbc4ee 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigureControlPointStyleProperty.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigureControlPointStyleProperty.cpp
@@ -1,85 +1,79 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlanarFigureControlPointStyleProperty.h"
mitk::PlanarFigureControlPointStyleProperty::PlanarFigureControlPointStyleProperty( )
{
this->AddEnumTypes();
this->SetValue( static_cast<IdType> ( Square ) );
}
mitk::PlanarFigureControlPointStyleProperty::PlanarFigureControlPointStyleProperty( const IdType &value )
{
this->AddEnumTypes();
if ( this->IsValidEnumerationValue( value ) )
{
this->SetValue( value ) ;
}
else
{
this->SetValue( static_cast<IdType> ( Square ) );
}
}
mitk::PlanarFigureControlPointStyleProperty::PlanarFigureControlPointStyleProperty( const std::string &value )
{
this->AddEnumTypes();
if ( this->IsValidEnumerationValue( value ) )
{
this->SetValue( value );
}
else
{
this->SetValue( static_cast<IdType>( Square ) );
}
}
void mitk::PlanarFigureControlPointStyleProperty::AddEnumTypes()
{
this->AddEnum( "Square", static_cast<IdType>( Square ) );
this->AddEnum( "Circle", static_cast<IdType>( Circle ) );
}
bool mitk::PlanarFigureControlPointStyleProperty::AddEnum( const std::string& name, const IdType& id )
{
return Superclass::AddEnum( name, id );
}
mitk::PlanarFigureControlPointStyleProperty::Shape mitk::PlanarFigureControlPointStyleProperty::GetShape()
{
return static_cast<mitk::PlanarFigureControlPointStyleProperty::Shape>( this->GetValueAsId() );
}
void mitk::PlanarFigureControlPointStyleProperty::SetShape(mitk::PlanarFigureControlPointStyleProperty::Shape shape)
{
this->SetValue( static_cast<IdType>( shape ) );
}
-mitk::PlanarFigureControlPointStyleProperty::Pointer mitk::PlanarFigureControlPointStyleProperty::Clone() const
-{
- Pointer result = static_cast<Self*>(this->InternalClone().GetPointer());
- return result;
-}
-
itk::LightObject::Pointer mitk::PlanarFigureControlPointStyleProperty::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
return result;
}
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarFigureControlPointStyleProperty.h b/Modules/PlanarFigure/DataManagement/mitkPlanarFigureControlPointStyleProperty.h
index 320c57ec07..b4d8309369 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigureControlPointStyleProperty.h
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigureControlPointStyleProperty.h
@@ -1,97 +1,95 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkPlanarFigureControlPointStyleProperty_h
#define mitkPlanarFigureControlPointStyleProperty_h
#include "mitkEnumerationProperty.h"
#include "PlanarFigureExports.h"
namespace mitk
{
/**
* \brief Defines the rendering style of control points for PlanarFigure objects.
* \sa mitk::PlanarFigureMapper2D
* \ingroup DataManagement
*
* Used by PlanarFigureMapper2D to determine which of several control point shapes to use.
* Currently this is basically the choice between squares and circles. If more options
* are implemented, this class should be enhanced.
*
* After construction, the default shape is a square.
*
*/
class PlanarFigure_EXPORT PlanarFigureControlPointStyleProperty : public EnumerationProperty
{
public:
mitkClassMacro( PlanarFigureControlPointStyleProperty, EnumerationProperty );
itkNewMacro(PlanarFigureControlPointStyleProperty);
mitkNewMacro1Param(PlanarFigureControlPointStyleProperty, const IdType&);
mitkNewMacro1Param(PlanarFigureControlPointStyleProperty, const std::string&);
- Pointer Clone() const;
-
typedef enum
{
Square, Circle
} Shape;
virtual Shape GetShape();
virtual void SetShape( Shape );
protected:
PlanarFigureControlPointStyleProperty( );
PlanarFigureControlPointStyleProperty( const IdType &value );
/**
* Constructor. Sets the decoration type to the given value. If it is not
* valid, the representation is set to none
*/
PlanarFigureControlPointStyleProperty( const std::string &value );
/**
* this function is overridden as protected, so that the user may not add
* additional invalid types.
*/
virtual bool AddEnum( const std::string &name, const IdType &id );
/**
* Adds the standard enumeration types with corresponding strings.
*/
virtual void AddEnumTypes();
private:
// purposely not implemented
PlanarFigureControlPointStyleProperty& operator=(const PlanarFigureControlPointStyleProperty&);
virtual itk::LightObject::Pointer InternalClone() const;
};
} // end of namespace mitk
#endif
diff --git a/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
index 92c80e669c..da351f5580 100644
--- a/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
+++ b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
@@ -1,435 +1,429 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlanarFigureReader.h"
#include "mitkPlanarAngle.h"
#include "mitkPlanarCircle.h"
#include "mitkPlanarLine.h"
#include "mitkPlanarArrow.h"
#include "mitkPlanarCross.h"
#include "mitkPlanarFourPointAngle.h"
#include "mitkPlanarPolygon.h"
#include "mitkPlanarSubdivisionPolygon.h"
#include "mitkPlanarRectangle.h"
#include "mitkPlaneGeometry.h"
#include "mitkPlanarEllipse.h"
#include "mitkBasePropertySerializer.h"
#include <tinyxml.h>
#include <itksys/SystemTools.hxx>
mitk::PlanarFigureReader::PlanarFigureReader() : PlanarFigureSource(), FileReader(),
m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
{
this->SetNumberOfRequiredOutputs(1);
- this->SetNumberOfOutputs(1);
+ this->SetNumberOfIndexedOutputs(1);
this->SetNthOutput(0, this->MakeOutput(0));
m_CanReadFromMemory = true;
//this->Modified();
//this->GetOutput()->Modified();
//this->GetOutput()->ReleaseData();
}
mitk::PlanarFigureReader::~PlanarFigureReader()
{}
-mitk::PlanarFigureSource::DataObjectPointer mitk::PlanarFigureReader::MakeOutput ( unsigned int )
-{
- return static_cast<itk::DataObject*>(PlanarCircle::New().GetPointer()); // just as a stand in for the pipeline update mechanism. This will be overwritten in GenerateData()
-}
-
-
void mitk::PlanarFigureReader::GenerateData()
{
m_Success = false;
- this->SetNumberOfOutputs(0); // reset all outputs, we add new ones depending on the file content
+ this->SetNumberOfIndexedOutputs(0); // reset all outputs, we add new ones depending on the file content
TiXmlDocument document;
if(m_ReadFromMemory)
{
if(m_MemoryBuffer == NULL || m_MemorySize == 0)
{
//check
itkWarningMacro( << "Sorry, memory buffer has not been set!" );
return;
}
if(m_MemoryBuffer[ m_MemorySize - 1 ] == '\0')
{
document.Parse(m_MemoryBuffer);
}
else
{
char * tmpArray = new char[(int)m_MemorySize+1];
tmpArray[m_MemorySize] = '\0';
memcpy(tmpArray,m_MemoryBuffer,m_MemorySize);
document.Parse(m_MemoryBuffer);
delete [] tmpArray;
}
}
else
{
if (m_FileName.empty())
{
itkWarningMacro( << "Sorry, filename has not been set!" );
return;
}
if (this->CanReadFile( m_FileName.c_str()) == false)
{
itkWarningMacro( << "Sorry, can't read file " << m_FileName << "!" );
return;
}
if (!document.LoadFile(m_FileName))
{
MITK_ERROR << "Could not open/read/parse " << m_FileName << ". TinyXML reports: '" << document.ErrorDesc() << "'. "
<< "The error occurred in row " << document.ErrorRow() << ", column " << document.ErrorCol() << ".";
return;
}
}
int fileVersion = 1;
TiXmlElement* versionObject = document.FirstChildElement("Version");
if (versionObject != NULL)
{
if ( versionObject->QueryIntAttribute( "FileVersion", &fileVersion ) != TIXML_SUCCESS )
{
MITK_WARN << m_FileName << " does not contain version information! Trying version 1 format." << std::endl;
}
}
else
{
MITK_WARN << m_FileName << " does not contain version information! Trying version 1 format." << std::endl;
}
if (fileVersion != 1) // add file version selection and version specific file parsing here, if newer file versions are created
{
MITK_WARN << "File version > 1 is not supported by this reader.";
return;
}
/* file version 1 reader code */
for( TiXmlElement* pfElement = document.FirstChildElement("PlanarFigure");
pfElement != NULL;
pfElement = pfElement->NextSiblingElement("PlanarFigure") )
{
if (pfElement == NULL)
continue;
std::string type = pfElement->Attribute("type");
mitk::PlanarFigure::Pointer planarFigure = NULL;
if (type == "PlanarAngle")
{
planarFigure = mitk::PlanarAngle::New();
}
else if (type == "PlanarCircle")
{
planarFigure = mitk::PlanarCircle::New();
}
else if (type == "PlanarEllipse")
{
planarFigure = mitk::PlanarEllipse::New();
}
else if (type == "PlanarCross")
{
planarFigure = mitk::PlanarCross::New();
}
else if (type == "PlanarFourPointAngle")
{
planarFigure = mitk::PlanarFourPointAngle::New();
}
else if (type == "PlanarLine")
{
planarFigure = mitk::PlanarLine::New();
}
else if (type == "PlanarPolygon")
{
planarFigure = mitk::PlanarPolygon::New();
}
else if (type == "PlanarSubdivisionPolygon")
{
planarFigure = mitk::PlanarSubdivisionPolygon::New();
}
else if (type == "PlanarRectangle")
{
planarFigure = mitk::PlanarRectangle::New();
}
else if (type == "PlanarArrow")
{
planarFigure = mitk::PlanarArrow::New();
}
else
{
// unknown type
MITK_WARN << "encountered unknown planar figure type '" << type << "'. Skipping this element.";
continue;
}
// Read properties of the planar figure
for( TiXmlElement* propertyElement = pfElement->FirstChildElement("property");
propertyElement != NULL;
propertyElement = propertyElement->NextSiblingElement("property") )
{
const char* keya = propertyElement->Attribute("key");
std::string key( keya ? keya : "");
const char* typea = propertyElement->Attribute("type");
std::string type( typea ? typea : "");
// hand propertyElement to specific reader
std::stringstream propertyDeserializerClassName;
propertyDeserializerClassName << type << "Serializer";
std::list<itk::LightObject::Pointer> readers =
itk::ObjectFactoryBase::CreateAllInstance(propertyDeserializerClassName.str().c_str());
if (readers.size() < 1)
{
MITK_ERROR << "No property reader found for " << type;
}
if (readers.size() > 1)
{
MITK_WARN << "Multiple property readers found for " << type << ". Using arbitrary first one.";
}
for ( std::list<itk::LightObject::Pointer>::iterator iter = readers.begin();
iter != readers.end();
++iter )
{
if (BasePropertySerializer* reader = dynamic_cast<BasePropertySerializer*>( iter->GetPointer() ) )
{
BaseProperty::Pointer property = reader->Deserialize( propertyElement->FirstChildElement() );
if (property.IsNotNull())
{
planarFigure->GetPropertyList()->ReplaceProperty(key, property);
}
else
{
MITK_ERROR << "There were errors while loading property '" << key << "' of type " << type << ". Your data may be corrupted";
}
break;
}
}
}
// Read geometry of containing plane
TiXmlElement* geoElement = pfElement->FirstChildElement("Geometry");
if (geoElement != NULL)
{
try
{
// Create plane geometry
mitk::PlaneGeometry::Pointer planeGeo = mitk::PlaneGeometry::New();
// Extract and set plane transform parameters
DoubleList transformList = this->GetDoubleAttributeListFromXMLNode( geoElement->FirstChildElement( "transformParam" ), "param", 12 );
typedef mitk::AffineGeometryFrame3D::TransformType TransformType;
TransformType::ParametersType parameters;
parameters.SetSize( 12 );
unsigned int i;
DoubleList::iterator it;
for ( it = transformList.begin(), i = 0;
it != transformList.end();
++it, ++i )
{
parameters.SetElement( i, *it );
}
typedef mitk::AffineGeometryFrame3D::TransformType TransformType;
TransformType::Pointer affineGeometry = TransformType::New();
affineGeometry->SetParameters( parameters );
planeGeo->SetIndexToWorldTransform( affineGeometry );
// Extract and set plane bounds
DoubleList boundsList = this->GetDoubleAttributeListFromXMLNode( geoElement->FirstChildElement( "boundsParam" ), "bound", 6 );
typedef mitk::Geometry3D::BoundsArrayType BoundsArrayType;
BoundsArrayType bounds;
for ( it = boundsList.begin(), i = 0;
it != boundsList.end();
++it, ++i )
{
bounds[i] = *it;
}
planeGeo->SetBounds( bounds );
// Extract and set spacing and origin
Vector3D spacing = this->GetVectorFromXMLNode(geoElement->FirstChildElement("Spacing"));
planeGeo->SetSpacing( spacing );
Point3D origin = this->GetPointFromXMLNode(geoElement->FirstChildElement("Origin"));
planeGeo->SetOrigin( origin );
planarFigure->SetGeometry2D(planeGeo);
}
catch (...)
{
}
}
TiXmlElement* cpElement = pfElement->FirstChildElement("ControlPoints");
bool first = true;
if (cpElement != NULL)
for( TiXmlElement* vertElement = cpElement->FirstChildElement("Vertex"); vertElement != NULL; vertElement = vertElement->NextSiblingElement("Vertex"))
{
if (vertElement == NULL)
continue;
int id = 0;
mitk::Point2D::ValueType x = 0.0;
mitk::Point2D::ValueType y = 0.0;
if (vertElement->QueryIntAttribute("id", &id) == TIXML_WRONG_TYPE)
return; // TODO: can we do a better error handling?
if (vertElement->QueryFloatAttribute("x", &x) == TIXML_WRONG_TYPE)
return; // TODO: can we do a better error handling?
if (vertElement->QueryFloatAttribute("y", &y) == TIXML_WRONG_TYPE)
return; // TODO: can we do a better error handling?
Point2D p;
p.SetElement(0, x);
p.SetElement(1, y);
if (first == true) // needed to set m_FigurePlaced to true
{
planarFigure->PlaceFigure(p);
first = false;
}
planarFigure->SetControlPoint(id, p, true);
}
// Calculate feature quantities of this PlanarFigure
planarFigure->EvaluateFeatures();
// Make sure that no control point is currently selected
planarFigure->DeselectControlPoint();
// \TODO: what about m_FigurePlaced and m_SelectedControlPoint ??
this->SetNthOutput( this->GetNumberOfOutputs(), planarFigure ); // add planarFigure as new output of this filter
}
m_Success = true;
}
mitk::Point3D mitk::PlanarFigureReader::GetPointFromXMLNode(TiXmlElement* e)
{
if (e == NULL)
throw std::invalid_argument("node invalid"); // TODO: can we do a better error handling?
mitk::Point3D point;
mitk::ScalarType p(-1.0);
if (e->QueryFloatAttribute("x", &p) == TIXML_WRONG_TYPE)
throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
point.SetElement(0, p);
if (e->QueryFloatAttribute("y", &p) == TIXML_WRONG_TYPE)
throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
point.SetElement(1, p);
if (e->QueryFloatAttribute("z", &p) == TIXML_WRONG_TYPE)
throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
point.SetElement(2, p);
return point;
}
mitk::Vector3D mitk::PlanarFigureReader::GetVectorFromXMLNode(TiXmlElement* e)
{
if (e == NULL)
throw std::invalid_argument("node invalid"); // TODO: can we do a better error handling?
mitk::Vector3D vector;
mitk::ScalarType p(-1.0);
if (e->QueryFloatAttribute("x", &p) == TIXML_WRONG_TYPE)
throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
vector.SetElement(0, p);
if (e->QueryFloatAttribute("y", &p) == TIXML_WRONG_TYPE)
throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
vector.SetElement(1, p);
if (e->QueryFloatAttribute("z", &p) == TIXML_WRONG_TYPE)
throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
vector.SetElement(2, p);
return vector;
}
mitk::PlanarFigureReader::DoubleList
mitk::PlanarFigureReader::GetDoubleAttributeListFromXMLNode(TiXmlElement* e, const char *attributeNameBase, unsigned int count)
{
DoubleList list;
if (e == NULL)
throw std::invalid_argument("node invalid"); // TODO: can we do a better error handling?
for ( unsigned int i = 0; i < count; ++i )
{
mitk::ScalarType p(-1.0);
std::stringstream attributeName;
attributeName << attributeNameBase << i;
if (e->QueryFloatAttribute( attributeName.str().c_str(), &p ) == TIXML_WRONG_TYPE)
throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
list.push_back( p );
}
return list;
}
void mitk::PlanarFigureReader::GenerateOutputInformation()
{
}
int mitk::PlanarFigureReader::CanReadFile ( const char *name )
{
if (std::string(name).empty())
return false;
return (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(name)) == ".pf"); //assume, we can read all .pf files
//TiXmlDocument document(name);
//if (document.LoadFile() == false)
// return false;
//return (document.FirstChildElement("PlanarFigure") != NULL);
}
bool mitk::PlanarFigureReader::CanReadFile(const std::string filename, const std::string, const std::string)
{
if (filename.empty())
return false;
return (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(filename)) == ".pf"); //assume, we can read all .pf files
//TiXmlDocument document(filename);
//if (document.LoadFile() == false)
// return false;
//return (document.FirstChildElement("PlanarFigure") != NULL);
}
void mitk::PlanarFigureReader::ResizeOutputs( const unsigned int& num )
{
unsigned int prevNum = this->GetNumberOfOutputs();
- this->SetNumberOfOutputs( num );
+ this->SetNumberOfIndexedOutputs( num );
for ( unsigned int i = prevNum; i < num; ++i )
{
this->SetNthOutput( i, this->MakeOutput( i ).GetPointer() );
}
}
diff --git a/Modules/PlanarFigure/IO/mitkPlanarFigureReader.h b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.h
index 6efca06271..29c1d73fc0 100644
--- a/Modules/PlanarFigure/IO/mitkPlanarFigureReader.h
+++ b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.h
@@ -1,163 +1,155 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_PlanarFigureReader__H_
#define _MITK_PlanarFigureReader__H_
#include "mitkPlanarFigureSource.h"
#include "PlanarFigureExports.h"
#include "mitkFileReader.h"
#include <list>
class TiXmlElement;
namespace mitk
{
/**
* @brief reads xml representations of mitk::PlanarFigure from a file
*
* Reader for xml files containing one or multiple xml represenations of
* mitk::PlanarFigure. If multiple mitk::PlanarFigure are stored in one file,
* these are assigned to multiple outputs of the filter.
* @ingroup IO
*/
class PlanarFigure_EXPORT PlanarFigureReader: public PlanarFigureSource, public FileReader
{
public:
mitkClassMacro( PlanarFigureReader, FileReader );
itkNewMacro( Self );
/**
* @brief Sets the filename of the file to be read
* @param _arg the filename of the point set xml-file
*/
itkSetStringMacro( FileName );
/**
* @brief Returns the filename of the point set xml-file.
* @returns the filename of the point set xml-file.
*/
itkGetStringMacro( FileName );
/**
* @warning multiple load not (yet) supported
*/
itkSetStringMacro( FilePrefix );
/**
* @warning multiple load not (yet) supported
*/
itkGetStringMacro( FilePrefix );
/**
* @warning multiple load not (yet) supported
*/
itkSetStringMacro( FilePattern );
/**
* @warning multiple load not (yet) supported
*/
itkGetStringMacro( FilePattern );
static bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern);
/**
* @returns whether the last read attempt was successful or not.
*/
itkGetConstMacro(Success, bool);
- /**
- * Allocates a new dummy output object and returns it.
- * GenerateData() will overwrite the outputs with specific types,
- * @param idx the index of the output for which an object should be created
- * @returns the dummy object
- */
- virtual DataObjectPointer MakeOutput ( unsigned int idx );
-
protected:
typedef std::list< double > DoubleList;
/**
* Constructor
*/
PlanarFigureReader();
/**
* Virtual destructor
*/
virtual ~PlanarFigureReader();
/**
* Actually reads the point sets from the given file
*/
virtual void GenerateData();
/**
* Does nothing in the current implementation
*/
virtual void GenerateOutputInformation();
/**
* Resizes the output-objects according to the given number.
* @param num the new number of output objects.
*/
virtual void ResizeOutputs( const unsigned int& num );
/**
* Checks if the given file has appropriate
* read access.
* @returns true if the file exists and may be read
* or false otherwise.
*/
virtual int CanReadFile (const char *name);
/**
* \brief parses the element for the attributes x,y,z and returns a mitk::Vector3D filled with these values
* \param[in] e the TiXmlElement that will be parsed
* \return returns a mitk::Vector3D with the values x,y,z
*/
mitk::Vector3D GetVectorFromXMLNode(TiXmlElement* e);
/**
* \brief parses the element for the attributes x,y,z and returns a mitk::Point3D filled with these values
* \param[in] e the TiXmlElement that will be parsed
* \return returns a mitk::Point3D with the values x,y,z
*/
mitk::Point3D GetPointFromXMLNode(TiXmlElement* e);
/**
* \brief parses the element for the attributes name0 to nameN, where "name" and the number of attributes
* to read are passed as argument. Returns a list of double vales.
* \param[in] e the TiXmlElement that will be parsed
* \param[in] attributeNameBase the basic name of the parameters
* \param[in] count the number of parameters
* \return returns a mitk::Point3D with the values x,y,z
*/
DoubleList GetDoubleAttributeListFromXMLNode(TiXmlElement* e, const char *attributeNameBase, unsigned int count);
std::string m_FileName;
std::string m_FilePrefix;
std::string m_FilePattern;
bool m_Success;
};
}
#endif
diff --git a/Modules/PlanarFigure/IO/mitkPlanarFigureWriter.cpp b/Modules/PlanarFigure/IO/mitkPlanarFigureWriter.cpp
index 6d84fcbccd..e39574a604 100644
--- a/Modules/PlanarFigure/IO/mitkPlanarFigureWriter.cpp
+++ b/Modules/PlanarFigure/IO/mitkPlanarFigureWriter.cpp
@@ -1,303 +1,303 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlanarFigureWriter.h"
#include "mitkBasePropertySerializer.h"
#include <tinyxml.h>
mitk::PlanarFigureWriter::PlanarFigureWriter()
: m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Extension(".pf"),
m_MimeType("application/MITK.PlanarFigure"), m_Success(false)
{
this->SetNumberOfRequiredInputs( 1 );
- this->SetNumberOfOutputs( 0 );
+ this->SetNumberOfIndexedOutputs( 0 );
//this->SetNthOutput( 0, mitk::PlanarFigure::New().GetPointer() );
m_CanWriteToMemory = true;
}
mitk::PlanarFigureWriter::~PlanarFigureWriter()
{}
void mitk::PlanarFigureWriter::GenerateData()
{
m_Success = false;
if (!m_WriteToMemory && m_FileName.empty())
{
MITK_ERROR << "Could not write planar figures. File name is invalid";
throw std::invalid_argument("file name is empty");
}
TiXmlDocument document;
TiXmlDeclaration* decl = new TiXmlDeclaration( "1.0", "", "" ); // TODO what to write here? encoding? etc....
document.LinkEndChild( decl );
TiXmlElement* version = new TiXmlElement("Version");
version->SetAttribute("Writer", __FILE__ );
version->SetAttribute("CVSRevision", "$Revision: 17055 $" );
version->SetAttribute("FileVersion", 1 );
document.LinkEndChild(version);
/* create xml element for each input */
for ( unsigned int i = 0 ; i < this->GetNumberOfInputs(); ++i )
{
// Create root element for this PlanarFigure
InputType::Pointer pf = this->GetInput( i );
if (pf.IsNull())
continue;
TiXmlElement* pfElement = new TiXmlElement("PlanarFigure");
pfElement->SetAttribute("type", pf->GetNameOfClass());
document.LinkEndChild(pfElement);
if ( pf->GetNumberOfControlPoints() == 0 )
continue;
//PlanarFigure::VertexContainerType* vertices = pf->GetControlPoints();
//if (vertices == NULL)
// continue;
// Serialize property list of PlanarFigure
mitk::PropertyList::Pointer propertyList = pf->GetPropertyList();
mitk::PropertyList::PropertyMap::const_iterator it;
for ( it = propertyList->GetMap()->begin(); it != propertyList->GetMap()->end(); ++it )
{
// Create seralizer for this property
const mitk::BaseProperty* prop = it->second;
std::string serializerName = std::string( prop->GetNameOfClass() ) + "Serializer";
std::list< itk::LightObject::Pointer > allSerializers = itk::ObjectFactoryBase::CreateAllInstance(
serializerName.c_str() );
if ( allSerializers.size() != 1 )
{
// No or too many serializer(s) found, skip this property
continue;
}
mitk::BasePropertySerializer* serializer = dynamic_cast< mitk::BasePropertySerializer* >(
allSerializers.begin()->GetPointer() );
if ( serializer == NULL )
{
// Serializer not valid; skip this property
}
TiXmlElement* keyElement = new TiXmlElement( "property" );
keyElement->SetAttribute( "key", it->first );
keyElement->SetAttribute( "type", prop->GetNameOfClass() );
serializer->SetProperty( prop );
TiXmlElement* valueElement = NULL;
try
{
valueElement = serializer->Serialize();
}
catch (...)
{
}
if ( valueElement == NULL )
{
// Serialization failed; skip this property
continue;
}
// Add value to property element
keyElement->LinkEndChild( valueElement );
// Append serialized property to property list
pfElement->LinkEndChild( keyElement );
}
// Serialize control points of PlanarFigure
TiXmlElement* controlPointsElement = new TiXmlElement("ControlPoints");
pfElement->LinkEndChild(controlPointsElement);
for (unsigned int i = 0; i < pf->GetNumberOfControlPoints(); i++)
{
TiXmlElement* vElement = new TiXmlElement("Vertex");
vElement->SetAttribute("id", i);
vElement->SetDoubleAttribute("x", pf->GetControlPoint(i)[0]);
vElement->SetDoubleAttribute("y", pf->GetControlPoint(i)[1]);
controlPointsElement->LinkEndChild(vElement);
}
TiXmlElement* geoElement = new TiXmlElement("Geometry");
const PlaneGeometry* planeGeo = dynamic_cast<const PlaneGeometry*>(pf->GetGeometry2D());
if (planeGeo != NULL)
{
// Write parameters of IndexToWorldTransform of the PlaneGeometry
typedef mitk::AffineGeometryFrame3D::TransformType TransformType;
const TransformType* affineGeometry = planeGeo->GetIndexToWorldTransform();
const TransformType::ParametersType& parameters = affineGeometry->GetParameters();
TiXmlElement* vElement = new TiXmlElement( "transformParam" );
for ( unsigned int i = 0; i < affineGeometry->GetNumberOfParameters(); ++i )
{
std::stringstream paramName;
paramName << "param" << i;
vElement->SetDoubleAttribute( paramName.str().c_str(), parameters.GetElement( i ) );
}
geoElement->LinkEndChild( vElement );
// Write bounds of the PlaneGeometry
typedef mitk::Geometry3D::BoundsArrayType BoundsArrayType;
const BoundsArrayType& bounds = planeGeo->GetBounds();
vElement = new TiXmlElement( "boundsParam" );
for ( unsigned int i = 0; i < 6; ++i )
{
std::stringstream boundName;
boundName << "bound" << i;
vElement->SetDoubleAttribute( boundName.str().c_str(), bounds.GetElement( i ) );
}
geoElement->LinkEndChild( vElement );
// Write spacing and origin of the PlaneGeometry
Vector3D spacing = planeGeo->GetSpacing();
Point3D origin = planeGeo->GetOrigin();
geoElement->LinkEndChild(this->CreateXMLVectorElement("Spacing", spacing));
geoElement->LinkEndChild(this->CreateXMLVectorElement("Origin", origin));
pfElement->LinkEndChild(geoElement);
}
}
if(m_WriteToMemory)
{
// Declare a printer
TiXmlPrinter printer;
// attach it to the document you want to convert in to a std::string
document.Accept(&printer);
// Create memory buffer and print tinyxmldocument there...
m_MemoryBufferSize = printer.Size() + 1;
m_MemoryBuffer = new char[m_MemoryBufferSize];
strcpy(m_MemoryBuffer,printer.CStr());
}
else
{
if (document.SaveFile( m_FileName) == false)
{
MITK_ERROR << "Could not write planar figures to " << m_FileName << "\nTinyXML reports '" << document.ErrorDesc() << "'";
throw std::ios_base::failure("Error during writing of planar figure xml file.");
}
}
m_Success = true;
}
void mitk::PlanarFigureWriter::ReleaseMemory()
{
if(m_MemoryBuffer != NULL)
{
delete [] m_MemoryBuffer;
}
}
TiXmlElement* mitk::PlanarFigureWriter::CreateXMLVectorElement(const char* name, itk::FixedArray<mitk::ScalarType, 3> v)
{
TiXmlElement* vElement = new TiXmlElement(name);
vElement->SetDoubleAttribute("x", v.GetElement(0));
vElement->SetDoubleAttribute("y", v.GetElement(1));
vElement->SetDoubleAttribute("z", v.GetElement(2));
return vElement;
}
void mitk::PlanarFigureWriter::ResizeInputs( const unsigned int& num )
{
//unsigned int prevNum = this->GetNumberOfInputs();
- this->SetNumberOfInputs( num );
+ this->SetNumberOfIndexedInputs( num );
//for ( unsigned int i = prevNum; i < num; ++i )
//{
// this->SetNthInput( i, mitk::PlanarFigure::New().GetPointer() );
//}
}
void mitk::PlanarFigureWriter::SetInput( InputType* PlanarFigure )
{
this->ProcessObject::SetNthInput( 0, PlanarFigure );
}
void mitk::PlanarFigureWriter::SetInput( const unsigned int& id, InputType* PlanarFigure )
{
if ( id >= this->GetNumberOfInputs() )
this->ResizeInputs( id + 1 );
this->ProcessObject::SetNthInput( id, PlanarFigure );
}
mitk::PlanarFigure* mitk::PlanarFigureWriter::GetInput()
{
if ( this->GetNumberOfInputs() < 1 )
return NULL;
else
return dynamic_cast<InputType*> ( this->GetInput( 0 ) );
}
mitk::PlanarFigure* mitk::PlanarFigureWriter::GetInput( const unsigned int& num )
{
return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( num ) );
}
bool mitk::PlanarFigureWriter::CanWriteDataType( DataNode* input )
{
if ( input == NULL )
return false;
mitk::BaseData* data = input->GetData();
if ( data == NULL)
return false;
mitk::PlanarFigure::Pointer PlanarFigure = dynamic_cast<mitk::PlanarFigure*>( data );
if( PlanarFigure.IsNull() )
return false;
// add code for special subclasses here
return true;
}
void mitk::PlanarFigureWriter::SetInput( DataNode* input )
{
if (this->CanWriteDataType(input))
this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::PlanarFigure*>( input->GetData() ) );
}
std::string mitk::PlanarFigureWriter::GetWritenMIMEType()
{
return m_MimeType;
}
std::vector<std::string> mitk::PlanarFigureWriter::GetPossibleFileExtensions()
{
std::vector<std::string> possibleFileExtensions;
possibleFileExtensions.push_back(m_Extension);
return possibleFileExtensions;
}
std::string mitk::PlanarFigureWriter::GetFileExtension()
{
return m_Extension;
}
diff --git a/Modules/PlanarFigure/IO/mitkPlanarFigureWriterFactory.cpp b/Modules/PlanarFigure/IO/mitkPlanarFigureWriterFactory.cpp
index 350cc6f0c9..7970b1b6db 100644
--- a/Modules/PlanarFigure/IO/mitkPlanarFigureWriterFactory.cpp
+++ b/Modules/PlanarFigure/IO/mitkPlanarFigureWriterFactory.cpp
@@ -1,75 +1,96 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlanarFigureWriterFactory.h"
#include "itkCreateObjectFunction.h"
#include "itkVersion.h"
#include <mitkPlanarFigureWriter.h>
namespace mitk
{
template <class T>
class CreatePlanarFigureWriter : public itk::CreateObjectFunctionBase
{
public:
/** Standard class typedefs. */
typedef CreatePlanarFigureWriter Self;
typedef itk::SmartPointer<Self> Pointer;
/** Methods from itk:LightObject. */
- itkFactorylessNewMacro(Self);
- LightObject::Pointer CreateObject() { typename T::Pointer p = T::New();
+ itkFactorylessNewMacro(Self)
+ LightObject::Pointer CreateObject()
+ {
+ typename T::Pointer p = T::New();
p->Register();
return p.GetPointer();
}
protected:
CreatePlanarFigureWriter() {}
~CreatePlanarFigureWriter() {}
private:
CreatePlanarFigureWriter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
PlanarFigureWriterFactory::PlanarFigureWriterFactory()
{
this->RegisterOverride("IOWriter",
"PlanarFigureWriter",
"PlanarFigure xml Writer",
1,
mitk::CreatePlanarFigureWriter< mitk::PlanarFigureWriter >::New());
}
PlanarFigureWriterFactory::~PlanarFigureWriterFactory()
{
}
+itk::ObjectFactoryBase::Pointer PlanarFigureWriterFactory::GetInstance()
+{
+ static itk::ObjectFactoryBase::Pointer factory(mitk::PlanarFigureWriterFactory::New().GetPointer());
+ return factory;
+}
+
+void PlanarFigureWriterFactory::RegisterOneFactory(void)
+{
+ if ( GetInstance()->GetReferenceCount() == 1 )
+ {
+ ObjectFactoryBase::RegisterFactory( GetInstance().GetPointer() );
+ }
+}
+
+void PlanarFigureWriterFactory::UnRegisterOneFactory(void)
+{
+ ObjectFactoryBase::UnRegisterFactory( GetInstance().GetPointer() );
+}
+
const char* PlanarFigureWriterFactory::GetITKSourceVersion() const
{
return ITK_SOURCE_VERSION;
}
const char* PlanarFigureWriterFactory::GetDescription() const
{
return "PlanarFigureWriterFactory";
}
} // end namespace mitk
diff --git a/Modules/PlanarFigure/IO/mitkPlanarFigureWriterFactory.h b/Modules/PlanarFigure/IO/mitkPlanarFigureWriterFactory.h
index 94ac76983b..01c448feb8 100644
--- a/Modules/PlanarFigure/IO/mitkPlanarFigureWriterFactory.h
+++ b/Modules/PlanarFigure/IO/mitkPlanarFigureWriterFactory.h
@@ -1,67 +1,62 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef PLANARFIGURE_WRITERFACTORY_H_HEADER_INCLUDED
#define PLANARFIGURE_WRITERFACTORY_H_HEADER_INCLUDED
#include "itkObjectFactoryBase.h"
#include "PlanarFigureExports.h"
#include "mitkBaseData.h"
namespace mitk
{
class PlanarFigure_EXPORT PlanarFigureWriterFactory : public itk::ObjectFactoryBase
{
public:
mitkClassMacro( mitk::PlanarFigureWriterFactory, itk::ObjectFactoryBase )
/** Class methods used to interface with the registered factories. */
virtual const char* GetITKSourceVersion(void) const;
virtual const char* GetDescription(void) const;
/** Method for class instantiation. */
- itkFactorylessNewMacro(Self);
+ itkFactorylessNewMacro(Self)
/** Register one factory of this type */
- static void RegisterOneFactory(void)
- {
- static bool IsRegistered = false;
- if ( !IsRegistered )
- {
- PlanarFigureWriterFactory::Pointer pfwf = PlanarFigureWriterFactory::New();
- ObjectFactoryBase::RegisterFactory( pfwf );
- IsRegistered = true;
- }
- }
+ static void RegisterOneFactory(void);
+
+ /** UnRegister one factory of this type */
+ static void UnRegisterOneFactory(void);
protected:
PlanarFigureWriterFactory();
~PlanarFigureWriterFactory();
private:
PlanarFigureWriterFactory(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
+ static itk::ObjectFactoryBase::Pointer GetInstance();
};
} // end namespace mitk
#endif // PLANARFIGURE_WRITERFACTORY_H_HEADER_INCLUDED
diff --git a/Modules/Properties/CMakeLists.txt b/Modules/Properties/CMakeLists.txt
new file mode 100644
index 0000000000..234b645486
--- /dev/null
+++ b/Modules/Properties/CMakeLists.txt
@@ -0,0 +1,4 @@
+MITK_CREATE_MODULE(Properties
+ PACKAGE_DEPENDS QT
+ QT_MODULE
+)
diff --git a/Modules/Properties/files.cmake b/Modules/Properties/files.cmake
new file mode 100644
index 0000000000..5206c029e4
--- /dev/null
+++ b/Modules/Properties/files.cmake
@@ -0,0 +1,8 @@
+set(CPP_FILES
+ mitkLoadPropertiesModule.cpp
+ mitkPropertiesActivator.cpp
+ mitkPropertyAliases.cpp
+ mitkPropertyDescriptions.cpp
+ mitkPropertyFilter.cpp
+ mitkPropertyFilters.cpp
+)
diff --git a/Core/Code/Rendering/mitkVtkMapper2D.h b/Modules/Properties/mitkLoadPropertiesModule.cpp
similarity index 58%
copy from Core/Code/Rendering/mitkVtkMapper2D.h
copy to Modules/Properties/mitkLoadPropertiesModule.cpp
index f9db3be352..2fc831cb5d 100644
--- a/Core/Code/Rendering/mitkVtkMapper2D.h
+++ b/Modules/Properties/mitkLoadPropertiesModule.cpp
@@ -1,32 +1,21 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
+#include "mitkLoadPropertiesModule.h"
-#ifndef BASEVTKMAPPER2D_H_HEADER_INCLUDED
-#define BASEVTKMAPPER2D_H_HEADER_INCLUDED
-
-#include "mitkVtkMapper.h"
-
-namespace mitk {
-
- // typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead.
- DEPRECATED(typedef VtkMapper VtkMapper2D);
-
-} // namespace mitk
-
-
-#endif /* BASEVTKMAPPER2D_H_HEADER_INCLUDED */
+void mitk::LoadPropertiesModule()
+{
+}
diff --git a/Core/Code/Rendering/mitkVtkMapper2D.h b/Modules/Properties/mitkLoadPropertiesModule.h
similarity index 58%
copy from Core/Code/Rendering/mitkVtkMapper2D.h
copy to Modules/Properties/mitkLoadPropertiesModule.h
index f9db3be352..0c4d77495d 100644
--- a/Core/Code/Rendering/mitkVtkMapper2D.h
+++ b/Modules/Properties/mitkLoadPropertiesModule.h
@@ -1,32 +1,27 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
+#ifndef mitkLoadPropertiesModule_h
+#define mitkLoadPropertiesModule_h
-#ifndef BASEVTKMAPPER2D_H_HEADER_INCLUDED
-#define BASEVTKMAPPER2D_H_HEADER_INCLUDED
+#include <PropertiesExports.h>
-#include "mitkVtkMapper.h"
+namespace mitk
+{
+ void Properties_EXPORT LoadPropertiesModule();
+}
-namespace mitk {
-
- // typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead.
- DEPRECATED(typedef VtkMapper VtkMapper2D);
-
-} // namespace mitk
-
-
-#endif /* BASEVTKMAPPER2D_H_HEADER_INCLUDED */
+#endif
diff --git a/Modules/Properties/mitkPropertiesActivator.cpp b/Modules/Properties/mitkPropertiesActivator.cpp
new file mode 100644
index 0000000000..d02689236a
--- /dev/null
+++ b/Modules/Properties/mitkPropertiesActivator.cpp
@@ -0,0 +1,303 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkPropertyAliases.h"
+#include "mitkPropertyDescriptions.h"
+#include "mitkPropertyFilters.h"
+#include <itkObjectFactory.h>
+#include <mitkCommon.h>
+#include <usModuleActivator.h>
+#include <usModuleContext.h>
+
+class AliasEquals
+{
+public:
+ AliasEquals(const std::string& alias)
+ : m_Alias(alias)
+ {
+ }
+
+ bool operator()(std::pair<std::string, std::string> element)
+ {
+ return element.second == m_Alias;
+ }
+
+private:
+ std::string m_Alias;
+};
+
+namespace mitk
+{
+ class PropertiesActivator : public ModuleActivator
+ {
+ public:
+ void Load(ModuleContext* context)
+ {
+ m_PropertyAliases = PropertyAliasesImpl::New();
+ context->RegisterService<PropertyAliases>(m_PropertyAliases);
+
+ m_PropertyDescriptions = PropertyDescriptionsImpl::New();
+ context->RegisterService<PropertyDescriptions>(m_PropertyDescriptions);
+
+ m_PropertyFilters = PropertyFiltersImpl::New();
+ context->RegisterService<PropertyFilters>(m_PropertyFilters);
+ }
+
+ void Unload(ModuleContext*)
+ {
+ }
+
+ private:
+ class PropertyAliasesImpl : public itk::LightObject, public PropertyAliases
+ {
+ public:
+ mitkClassMacro(PropertyAliasesImpl, itk::LightObject);
+ itkNewMacro(Self);
+
+ bool AddAlias(const std::string& propertyName, const std::string& alias, bool overwrite);
+ std::string GetAlias(const std::string& propertyName) const;
+ std::string GetPropertyName(const std::string& alias) const;
+ bool HasAlias(const std::string& propertyName) const;
+ void RemoveAllAliases();
+ void RemoveAlias(const std::string& propertyName);
+
+ private:
+ std::map<std::string, std::string> m_Aliases;
+ };
+
+ class PropertyDescriptionsImpl : public itk::LightObject, public PropertyDescriptions
+ {
+ public:
+ mitkClassMacro(PropertyDescriptionsImpl, itk::LightObject);
+ itkNewMacro(Self);
+
+ bool AddDescription(const std::string& propertyName, const std::string& description, bool overwrite);
+ std::string GetDescription(const std::string& propertyName) const;
+ bool HasDescription(const std::string& propertyName) const;
+ void RemoveAllDescriptions();
+ void RemoveDescription(const std::string& propertyName);
+
+ private:
+ std::map<std::string, std::string> m_Descriptions;
+ };
+
+ class PropertyFiltersImpl : public itk::LightObject, public PropertyFilters
+ {
+ public:
+ mitkClassMacro(PropertyFiltersImpl, itk::LightObject);
+ itkNewMacro(Self);
+
+ bool AddFilter(const PropertyFilter& filter, bool overwrite);
+ bool AddFilter(const std::string& className, const PropertyFilter& filter, bool overwrite);
+ std::map<std::string, BaseProperty::Pointer> ApplyFilter(const std::map<std::string, BaseProperty::Pointer>& propertyMap) const;
+ std::map<std::string, BaseProperty::Pointer> ApplyFilter(const std::string& className, const std::map<std::string, BaseProperty::Pointer>& propertyMap) const;
+ PropertyFilter GetFilter(const std::string& className) const;
+ bool HasFilter(const std::string& className) const;
+ void RemoveAllFilters();
+ void RemoveFilter(const std::string& className);
+
+ private:
+ std::map<std::string, PropertyFilter> m_Filters;
+ };
+
+ PropertyAliasesImpl::Pointer m_PropertyAliases;
+ PropertyDescriptionsImpl::Pointer m_PropertyDescriptions;
+ PropertyFiltersImpl::Pointer m_PropertyFilters;
+ };
+
+ bool PropertiesActivator::PropertyAliasesImpl::AddAlias(const std::string& propertyName, const std::string& alias, bool overwrite)
+ {
+ if (alias.empty())
+ return false;
+
+ std::pair<std::map<std::string, std::string>::iterator, bool> ret = m_Aliases.insert(std::make_pair(propertyName, alias));
+
+ if (!ret.second && overwrite)
+ {
+ ret.first->second = alias;
+ ret.second = true;
+ }
+
+ return ret.second;
+ }
+
+ std::string PropertiesActivator::PropertyAliasesImpl::GetAlias(const std::string& propertyName) const
+ {
+ if (!propertyName.empty())
+ {
+ std::map<std::string, std::string>::const_iterator iter = m_Aliases.find(propertyName);
+
+ if (iter != m_Aliases.end())
+ return iter->second;
+ }
+
+ return "";
+ }
+
+ std::string PropertiesActivator::PropertyAliasesImpl::GetPropertyName(const std::string& alias) const
+ {
+ if (!alias.empty())
+ {
+ std::map<std::string, std::string>::const_iterator iter = std::find_if(m_Aliases.begin(), m_Aliases.end(), AliasEquals(alias));
+
+ if (iter != m_Aliases.end())
+ return iter->first;
+ }
+
+ return "";
+ }
+
+ bool PropertiesActivator::PropertyAliasesImpl::HasAlias(const std::string& propertyName) const
+ {
+ return !propertyName.empty()
+ ? m_Aliases.find(propertyName) != m_Aliases.end()
+ : false;
+ }
+
+ void PropertiesActivator::PropertyAliasesImpl::RemoveAlias(const std::string& propertyName)
+ {
+ if (!propertyName.empty())
+ m_Aliases.erase(propertyName);
+ }
+
+ void PropertiesActivator::PropertyAliasesImpl::RemoveAllAliases()
+ {
+ m_Aliases.clear();
+ }
+
+ bool PropertiesActivator::PropertyDescriptionsImpl::AddDescription(const std::string& propertyName, const std::string& description, bool overwrite)
+ {
+ if (!propertyName.empty())
+ {
+ std::pair<std::map<std::string, std::string>::iterator, bool> ret = m_Descriptions.insert(std::make_pair(propertyName, description));
+
+ if (!ret.second && overwrite)
+ {
+ ret.first->second = description;
+ ret.second = true;
+ }
+
+ return ret.second;
+ }
+
+ return false;
+ }
+
+ std::string PropertiesActivator::PropertyDescriptionsImpl::GetDescription(const std::string& propertyName) const
+ {
+ if (!propertyName.empty())
+ {
+ std::map<std::string, std::string>::const_iterator iter = m_Descriptions.find(propertyName);
+
+ if (iter != m_Descriptions.end())
+ return iter->second;
+ }
+
+ return "";
+ }
+
+ bool PropertiesActivator::PropertyDescriptionsImpl::HasDescription(const std::string& propertyName) const
+ {
+ return !propertyName.empty()
+ ? m_Descriptions.find(propertyName) != m_Descriptions.end()
+ : false;
+ }
+
+ void PropertiesActivator::PropertyDescriptionsImpl::RemoveAllDescriptions()
+ {
+ m_Descriptions.clear();
+ }
+
+ void PropertiesActivator::PropertyDescriptionsImpl::RemoveDescription(const std::string& propertyName)
+ {
+ if (!propertyName.empty())
+ m_Descriptions.erase(propertyName);
+ }
+
+ bool PropertiesActivator::PropertyFiltersImpl::AddFilter(const PropertyFilter& filter, bool overwrite)
+ {
+ return this->AddFilter("", filter, overwrite);
+ }
+
+ bool PropertiesActivator::PropertyFiltersImpl::AddFilter(const std::string& className, const PropertyFilter& filter, bool overwrite)
+ {
+ if (!filter.IsEmpty())
+ {
+ std::pair<std::map<std::string, PropertyFilter>::iterator, bool> ret = m_Filters.insert(std::make_pair(className, filter));
+
+ if (!ret.second && overwrite)
+ {
+ ret.first->second = filter;
+ ret.second = true;
+ }
+
+ return ret.second;
+ }
+
+ return false;
+ }
+
+ std::map<std::string, BaseProperty::Pointer> PropertiesActivator::PropertyFiltersImpl::ApplyFilter(const std::map<std::string, BaseProperty::Pointer>& propertyMap) const
+ {
+ return this->ApplyFilter("", propertyMap);
+ }
+
+ std::map<std::string, BaseProperty::Pointer> PropertiesActivator::PropertyFiltersImpl::ApplyFilter(const std::string& className, const std::map<std::string, BaseProperty::Pointer>& propertyMap) const
+ {
+ std::map<std::string, BaseProperty::Pointer> ret = propertyMap;
+ PropertyFilter filter = this->GetFilter("");
+
+ if (!filter.IsEmpty())
+ ret = filter.Apply(ret);
+
+ if (!className.empty())
+ {
+ filter = this->GetFilter(className);
+
+ if (!filter.IsEmpty())
+ ret = filter.Apply(ret);
+ }
+
+ return ret;
+ }
+
+ PropertyFilter PropertiesActivator::PropertyFiltersImpl::GetFilter(const std::string& className) const
+ {
+ std::map<std::string, PropertyFilter>::const_iterator iter = m_Filters.find(className);
+
+ if (iter != m_Filters.end())
+ return iter->second;
+
+ return PropertyFilter();
+ }
+
+ bool PropertiesActivator::PropertyFiltersImpl::HasFilter(const std::string& className) const
+ {
+ return m_Filters.find(className) != m_Filters.end();
+ }
+
+ void PropertiesActivator::PropertyFiltersImpl::RemoveAllFilters()
+ {
+ m_Filters.clear();
+ }
+
+ void PropertiesActivator::PropertyFiltersImpl::RemoveFilter(const std::string& className)
+ {
+ m_Filters.erase(className);
+ }
+}
+
+US_EXPORT_MODULE_ACTIVATOR(Properties, mitk::PropertiesActivator)
diff --git a/Core/Code/Rendering/mitkVtkMapper2D.h b/Modules/Properties/mitkPropertyAliases.cpp
similarity index 58%
copy from Core/Code/Rendering/mitkVtkMapper2D.h
copy to Modules/Properties/mitkPropertyAliases.cpp
index f9db3be352..ddf52e2b67 100644
--- a/Core/Code/Rendering/mitkVtkMapper2D.h
+++ b/Modules/Properties/mitkPropertyAliases.cpp
@@ -1,32 +1,21 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
+#include "mitkPropertyAliases.h"
-#ifndef BASEVTKMAPPER2D_H_HEADER_INCLUDED
-#define BASEVTKMAPPER2D_H_HEADER_INCLUDED
-
-#include "mitkVtkMapper.h"
-
-namespace mitk {
-
- // typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead.
- DEPRECATED(typedef VtkMapper VtkMapper2D);
-
-} // namespace mitk
-
-
-#endif /* BASEVTKMAPPER2D_H_HEADER_INCLUDED */
+mitk::PropertyAliases::~PropertyAliases()
+{
+}
diff --git a/Modules/Properties/mitkPropertyAliases.h b/Modules/Properties/mitkPropertyAliases.h
new file mode 100644
index 0000000000..cded00c7be
--- /dev/null
+++ b/Modules/Properties/mitkPropertyAliases.h
@@ -0,0 +1,42 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkPropertyAliases_h
+#define mitkPropertyAliases_h
+
+#include <itkLightObject.h>
+#include <PropertiesExports.h>
+#include <usServiceInterface.h>
+
+namespace mitk
+{
+ class Properties_EXPORT PropertyAliases
+ {
+ public:
+ virtual ~PropertyAliases();
+
+ virtual bool AddAlias(const std::string& propertyName, const std::string& alias, bool overwrite = false) = 0;
+ virtual std::string GetAlias(const std::string& propertyName) const = 0;
+ virtual std::string GetPropertyName(const std::string& alias) const = 0;
+ virtual bool HasAlias(const std::string& propertyName) const = 0;
+ virtual void RemoveAlias(const std::string& propertyName) = 0;
+ virtual void RemoveAllAliases() = 0;
+ };
+}
+
+US_DECLARE_SERVICE_INTERFACE(mitk::PropertyAliases, "org.mitk.services.PropertyAliases")
+
+#endif
diff --git a/Core/Code/Rendering/mitkVtkMapper2D.h b/Modules/Properties/mitkPropertyDescriptions.cpp
similarity index 58%
copy from Core/Code/Rendering/mitkVtkMapper2D.h
copy to Modules/Properties/mitkPropertyDescriptions.cpp
index f9db3be352..069bdb765a 100644
--- a/Core/Code/Rendering/mitkVtkMapper2D.h
+++ b/Modules/Properties/mitkPropertyDescriptions.cpp
@@ -1,32 +1,21 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
+#include "mitkPropertyDescriptions.h"
-#ifndef BASEVTKMAPPER2D_H_HEADER_INCLUDED
-#define BASEVTKMAPPER2D_H_HEADER_INCLUDED
-
-#include "mitkVtkMapper.h"
-
-namespace mitk {
-
- // typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead.
- DEPRECATED(typedef VtkMapper VtkMapper2D);
-
-} // namespace mitk
-
-
-#endif /* BASEVTKMAPPER2D_H_HEADER_INCLUDED */
+mitk::PropertyDescriptions::~PropertyDescriptions()
+{
+}
diff --git a/Modules/Properties/mitkPropertyDescriptions.h b/Modules/Properties/mitkPropertyDescriptions.h
new file mode 100644
index 0000000000..c22c8da822
--- /dev/null
+++ b/Modules/Properties/mitkPropertyDescriptions.h
@@ -0,0 +1,41 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkPropertyDescriptions_h
+#define mitkPropertyDescriptions_h
+
+#include <itkLightObject.h>
+#include <PropertiesExports.h>
+#include <usServiceInterface.h>
+
+namespace mitk
+{
+ class Properties_EXPORT PropertyDescriptions
+ {
+ public:
+ virtual ~PropertyDescriptions();
+
+ virtual bool AddDescription(const std::string& propertyName, const std::string& description, bool overwrite = false) = 0;
+ virtual std::string GetDescription(const std::string& propertyName) const = 0;
+ virtual bool HasDescription(const std::string& propertyName) const = 0;
+ virtual void RemoveAllDescriptions() = 0;
+ virtual void RemoveDescription(const std::string& propertyName) = 0;
+ };
+}
+
+US_DECLARE_SERVICE_INTERFACE(mitk::PropertyDescriptions, "org.mitk.services.PropertyDescriptions")
+
+#endif
diff --git a/Modules/Properties/mitkPropertyFilter.cpp b/Modules/Properties/mitkPropertyFilter.cpp
new file mode 100644
index 0000000000..3250246329
--- /dev/null
+++ b/Modules/Properties/mitkPropertyFilter.cpp
@@ -0,0 +1,192 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkPropertyFilter.h"
+#include <algorithm>
+
+namespace mitk
+{
+ class PropertyFilter::Impl
+ {
+ public:
+ Impl();
+ ~Impl();
+
+ void AddEntry(const std::string& propertyName, PropertyFilter::List list);
+ std::map<std::string, BaseProperty::Pointer> Apply(const std::map<std::string, BaseProperty::Pointer>& propertyMap) const;
+ bool HasEntry(const std::string& propertyName, PropertyFilter::List list) const;
+ bool IsEmpty() const;
+ void RemoveAllEntries(PropertyFilter::List list);
+ void RemoveEntry(const std::string& propertyName, PropertyFilter::List list);
+
+ private:
+ void AddEntry(const std::string& propertyName, std::vector<std::string>& list);
+ bool HasEntry(const std::string& propertyName, const std::vector<std::string>& list) const;
+ void RemoveAllEntries(std::vector<std::string>& list);
+ void RemoveEntry(const std::string& propertyName, std::vector<std::string>& list);
+
+ std::vector<std::vector<std::string> > m_Lists;
+ };
+
+ PropertyFilter::Impl::Impl()
+ : m_Lists(2)
+ {
+ }
+
+ PropertyFilter::Impl::~Impl()
+ {
+ }
+
+ void mitk::PropertyFilter::Impl::AddEntry(const std::string& propertyName, List list)
+ {
+ this->AddEntry(propertyName, m_Lists.at(list));
+ }
+
+ void PropertyFilter::Impl::AddEntry(const std::string& propertyName, std::vector<std::string>& list)
+ {
+ if (std::find(list.begin(), list.end(), propertyName) == list.end())
+ list.push_back(propertyName);
+ }
+
+ std::map<std::string, BaseProperty::Pointer> PropertyFilter::Impl::Apply(const std::map<std::string, BaseProperty::Pointer>& propertyMap) const
+ {
+ std::map<std::string, BaseProperty::Pointer> ret = !m_Lists[Whitelist].empty()
+ ? std::map<std::string, BaseProperty::Pointer>()
+ : propertyMap;
+
+ if (!m_Lists[Whitelist].empty())
+ {
+ std::map<std::string, BaseProperty::Pointer>::const_iterator end = propertyMap.end();
+
+ for (std::map<std::string, BaseProperty::Pointer>::const_iterator iter = propertyMap.begin(); iter != end; ++iter)
+ {
+ if(std::find(m_Lists[Whitelist].begin(), m_Lists[Whitelist].end(), iter->first) != m_Lists[Whitelist].end())
+ ret.insert(*iter);
+ }
+ }
+
+ if (!m_Lists[Blacklist].empty())
+ {
+ std::vector<std::string>::const_iterator end = m_Lists[Blacklist].end();
+
+ for (std::vector<std::string>::const_iterator iter = m_Lists[Blacklist].begin(); iter != end; ++iter)
+ ret.erase(*iter);
+ }
+
+ return ret;
+ }
+
+ bool mitk::PropertyFilter::Impl::HasEntry(const std::string& propertyName, List list) const
+ {
+ return this->HasEntry(propertyName, m_Lists.at(list));
+ }
+
+ bool PropertyFilter::Impl::HasEntry(const std::string& propertyName, const std::vector<std::string>& list) const
+ {
+ return std::find(list.begin(), list.end(), propertyName) != list.end();
+ }
+
+ bool PropertyFilter::Impl::IsEmpty() const
+ {
+ std::vector<std::vector<std::string> >::const_iterator end = m_Lists.end();
+
+ for (std::vector<std::vector<std::string> >::const_iterator iter = m_Lists.begin(); iter != end; ++iter)
+ {
+ if (!iter->empty())
+ return false;
+ }
+
+ return true;
+ }
+
+ void mitk::PropertyFilter::Impl::RemoveAllEntries(List list)
+ {
+ this->RemoveAllEntries(m_Lists.at(list));
+ }
+
+ void PropertyFilter::Impl::RemoveAllEntries(std::vector<std::string>& list)
+ {
+ list.clear();
+ }
+
+ void mitk::PropertyFilter::Impl::RemoveEntry(const std::string& propertyName, List list)
+ {
+ this->RemoveEntry(propertyName, m_Lists.at(list));
+ }
+
+ void PropertyFilter::Impl::RemoveEntry(const std::string& propertyName, std::vector<std::string>& list)
+ {
+ std::vector<std::string>::iterator iter = std::find(list.begin(), list.end(), propertyName);
+
+ if (iter != list.end())
+ list.erase(iter);
+ }
+}
+
+mitk::PropertyFilter::PropertyFilter()
+ : m_Impl(new Impl)
+{
+}
+
+mitk::PropertyFilter::~PropertyFilter()
+{
+ delete m_Impl;
+}
+
+mitk::PropertyFilter::PropertyFilter(const mitk::PropertyFilter& other)
+ : m_Impl(new Impl(*other.m_Impl))
+{
+}
+
+mitk::PropertyFilter& mitk::PropertyFilter::operator=(mitk::PropertyFilter other)
+{
+ std::swap(this->m_Impl, other.m_Impl);
+ return *this;
+}
+
+void mitk::PropertyFilter::AddEntry(const std::string& propertyName, List list)
+{
+ if (!propertyName.empty())
+ m_Impl->AddEntry(propertyName, list);
+}
+
+std::map<std::string, mitk::BaseProperty::Pointer> mitk::PropertyFilter::Apply(const std::map<std::string, mitk::BaseProperty::Pointer>& propertyMap) const
+{
+ return m_Impl->Apply(propertyMap);
+}
+
+bool mitk::PropertyFilter::HasEntry(const std::string& propertyName, List list) const
+{
+ return !propertyName.empty()
+ ? m_Impl->HasEntry(propertyName, list)
+ : false;
+}
+
+bool mitk::PropertyFilter::IsEmpty() const
+{
+ return m_Impl->IsEmpty();
+}
+
+void mitk::PropertyFilter::RemoveAllEntries(List list)
+{
+ m_Impl->RemoveAllEntries(list);
+}
+
+void mitk::PropertyFilter::RemoveEntry(const std::string& propertyName, List list)
+{
+ if (!propertyName.empty())
+ m_Impl->RemoveEntry(propertyName, list);
+}
diff --git a/Modules/Properties/mitkPropertyFilter.h b/Modules/Properties/mitkPropertyFilter.h
new file mode 100644
index 0000000000..fffd08f3ec
--- /dev/null
+++ b/Modules/Properties/mitkPropertyFilter.h
@@ -0,0 +1,52 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkPropertyFilter_h
+#define mitkPropertyFilter_h
+
+#include <mitkBaseProperty.h>
+#include <PropertiesExports.h>
+
+namespace mitk
+{
+ class Properties_EXPORT PropertyFilter
+ {
+ public:
+ enum List
+ {
+ Blacklist,
+ Whitelist
+ };
+
+ PropertyFilter();
+ ~PropertyFilter();
+ PropertyFilter(const PropertyFilter& other);
+ PropertyFilter& operator=(PropertyFilter other);
+
+ void AddEntry(const std::string& propertyName, List list);
+ std::map<std::string, BaseProperty::Pointer> Apply(const std::map<std::string, BaseProperty::Pointer>& propertyMap) const;
+ bool HasEntry(const std::string& propertyName, List list) const;
+ bool IsEmpty() const;
+ void RemoveAllEntries(List list);
+ void RemoveEntry(const std::string& propertyName, List list);
+
+ private:
+ class Impl;
+ Impl* m_Impl;
+ };
+}
+
+#endif
diff --git a/Core/Code/Rendering/mitkVtkMapper2D.h b/Modules/Properties/mitkPropertyFilters.cpp
similarity index 58%
copy from Core/Code/Rendering/mitkVtkMapper2D.h
copy to Modules/Properties/mitkPropertyFilters.cpp
index f9db3be352..8f1b438f11 100644
--- a/Core/Code/Rendering/mitkVtkMapper2D.h
+++ b/Modules/Properties/mitkPropertyFilters.cpp
@@ -1,32 +1,21 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
+#include "mitkPropertyFilters.h"
-#ifndef BASEVTKMAPPER2D_H_HEADER_INCLUDED
-#define BASEVTKMAPPER2D_H_HEADER_INCLUDED
-
-#include "mitkVtkMapper.h"
-
-namespace mitk {
-
- // typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead.
- DEPRECATED(typedef VtkMapper VtkMapper2D);
-
-} // namespace mitk
-
-
-#endif /* BASEVTKMAPPER2D_H_HEADER_INCLUDED */
+mitk::PropertyFilters::~PropertyFilters()
+{
+}
diff --git a/Modules/Properties/mitkPropertyFilters.h b/Modules/Properties/mitkPropertyFilters.h
new file mode 100644
index 0000000000..a360632615
--- /dev/null
+++ b/Modules/Properties/mitkPropertyFilters.h
@@ -0,0 +1,45 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkPropertyFilters_h
+#define mitkPropertyFilters_h
+
+#include "mitkPropertyFilter.h"
+#include <mitkBaseProperty.h>
+#include <PropertiesExports.h>
+#include <usServiceInterface.h>
+
+namespace mitk
+{
+ class Properties_EXPORT PropertyFilters
+ {
+ public:
+ virtual ~PropertyFilters();
+
+ virtual bool AddFilter(const PropertyFilter& filter, bool overwrite = false) = 0;
+ virtual bool AddFilter(const std::string& className, const PropertyFilter& filter, bool overwrite = false) = 0;
+ virtual std::map<std::string, BaseProperty::Pointer> ApplyFilter(const std::map<std::string, BaseProperty::Pointer>& propertyMap) const = 0;
+ virtual std::map<std::string, BaseProperty::Pointer> ApplyFilter(const std::string& className, const std::map<std::string, BaseProperty::Pointer>& propertyMap) const = 0;
+ virtual PropertyFilter GetFilter(const std::string& className = "") const = 0;
+ virtual bool HasFilter(const std::string& className = "") const = 0;
+ virtual void RemoveAllFilters() = 0;
+ virtual void RemoveFilter(const std::string& className = "") = 0;
+ };
+}
+
+US_DECLARE_SERVICE_INTERFACE(mitk::PropertyFilters, "org.mitk.services.PropertyFilters")
+
+#endif
diff --git a/Modules/Python/PythonPath.h.in b/Modules/Python/PythonPath.h.in
index 384811cc81..6f5daf2961 100644
--- a/Modules/Python/PythonPath.h.in
+++ b/Modules/Python/PythonPath.h.in
@@ -1,19 +1,21 @@
#ifdef _DEBUG
#define PYTHON_PATH_BUILD_TYPE "/Debug"
#else
#define PYTHON_PATH_BUILD_TYPE "/Release"
#endif
#define PYTHONPATH_COMMAND "import sys\n"\
"sys.path.append('@ITK_LIBRARY_DIRS@')\n"\
"sys.path.append('@ITK_DIR@/Wrapping/WrapITK/Python')\n"\
"sys.path.append('@ITK_LIBRARY_DIRS@" PYTHON_PATH_BUILD_TYPE "')\n"\
"sys.path.append('@ITK_DIR@/Wrapping/WrapITK/Python" PYTHON_PATH_BUILD_TYPE "')\n"\
+"sys.path.append('@ITK_DIR@/Wrapping/Generators/Python')\n"\
+"sys.path.append('@ITK_DIR@/lib')\n"\
"sys.path.append('@VTK_LIBRARY_DIRS@')\n"\
"sys.path.append('@VTK_DIR@/Wrapping/Python')\n"\
"sys.path.append('@VTK_DIR@/bin" PYTHON_PATH_BUILD_TYPE "')\n"\
"sys.path.append('@VTK_DIR@/Wrapping/Python')\n"\
"sys.path.append('@OpenCV_DIR@/lib" PYTHON_PATH_BUILD_TYPE "')\n"\
"sys.path.append('@OpenCV_DIR@/lib')\n"\
"sys.path.append('@OpenCV_DIR@/bin')\n"\
"sys.path.append('@OpenCV_DIR@/bin" PYTHON_PATH_BUILD_TYPE "')"
diff --git a/Modules/Python/QmitkPythonVariableStackTableModel.cpp b/Modules/Python/QmitkPythonVariableStackTableModel.cpp
index 2ad27d2fd5..5eb48ff7af 100755
--- a/Modules/Python/QmitkPythonVariableStackTableModel.cpp
+++ b/Modules/Python/QmitkPythonVariableStackTableModel.cpp
@@ -1,223 +1,223 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkPythonVariableStackTableModel.h"
#include <QMimeData>
#include <mitkModuleContext.h>
#include <mitkDataNode.h>
#include <mitkGetModuleContext.h>
#include <QStringList>
#include <QMessageBox>
const QString QmitkPythonVariableStackTableModel::MITK_IMAGE_VAR_NAME = "mitkImage";
const QString QmitkPythonVariableStackTableModel::MITK_SURFACE_VAR_NAME = "mitkSurface";
QmitkPythonVariableStackTableModel::QmitkPythonVariableStackTableModel(QObject *parent)
:QAbstractTableModel(parent)
{
mitk::ModuleContext* context = mitk::GetModuleContext();
m_PythonServiceRef = context->GetServiceReference<mitk::IPythonService>();
m_PythonService = context->GetService<mitk::IPythonService>(m_PythonServiceRef);
m_PythonService->AddPythonCommandObserver( this );
}
QmitkPythonVariableStackTableModel::~QmitkPythonVariableStackTableModel()
{
mitk::ModuleContext* context = mitk::GetModuleContext();
context->UngetService( m_PythonServiceRef );
m_PythonService->RemovePythonCommandObserver( this );
}
bool QmitkPythonVariableStackTableModel::dropMimeData ( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent )
{
// Early exit, returning true, but not actually doing anything (ignoring data).
if (action == Qt::IgnoreAction)
return true;
// Note, we are returning true if we handled it, and false otherwise
bool returnValue = false;
if(data->hasFormat("application/x-mitk-datanodes"))
{
MITK_DEBUG("QmitkPythonVariableStackTableModel") << "dropped MITK DataNode";
returnValue = true;
QString arg = QString(data->data("application/x-mitk-datanodes").data());
QStringList listOfDataNodeAddressPointers = arg.split(",");
QStringList::iterator slIter;
int i = 0;
int j = 0;
for (slIter = listOfDataNodeAddressPointers.begin();
slIter != listOfDataNodeAddressPointers.end();
slIter++)
{
long val = (*slIter).toLong();
mitk::DataNode* node = static_cast<mitk::DataNode *>((void*)val);
mitk::Image* mitkImage = dynamic_cast<mitk::Image*>(node->GetData());
MITK_DEBUG("QmitkPythonVariableStackTableModel") << "mitkImage is not null " << (mitkImage != 0? "true": "false");
if( mitkImage )
{
QString varName = MITK_IMAGE_VAR_NAME;
if( i > 0 )
varName = QString("%1%2").arg(MITK_IMAGE_VAR_NAME).arg(i);
MITK_DEBUG("QmitkPythonVariableStackTableModel") << "varName" << varName.toStdString();
- bool exportAsCvImage = m_PythonService->IsOpenCvPythonWrappingAvailable();
+ bool exportAsCvImage = mitkImage->GetDimension() == 2 && m_PythonService->IsOpenCvPythonWrappingAvailable();
- if( mitkImage->GetDimension() == 2 && exportAsCvImage )
+ if( exportAsCvImage )
{
int ret = QMessageBox::question(NULL, "Export option",
"2D image detected. Export as OpenCV image to Python instead of an ITK image?",
QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
exportAsCvImage = ret == QMessageBox::Yes;
if(exportAsCvImage)
{
m_PythonService->CopyToPythonAsCvImage( mitkImage, MITK_IMAGE_VAR_NAME.toStdString() );
++i;
}
}
if( !exportAsCvImage )
{
if( m_PythonService->IsItkPythonWrappingAvailable() )
{
m_PythonService->CopyToPythonAsItkImage( mitkImage, MITK_IMAGE_VAR_NAME.toStdString() );
++i;
}
else
{
MITK_ERROR << "ITK Python wrapping not available. Skipping export for image " << node->GetName();
}
}
}
else
{
mitk::Surface* surface = dynamic_cast<mitk::Surface*>(node->GetData());
MITK_DEBUG("QmitkPythonVariableStackTableModel") << "found surface";
if( surface )
{
QString varName = MITK_SURFACE_VAR_NAME;
MITK_DEBUG("QmitkPythonVariableStackTableModel") << "varName" << varName.toStdString();
if( j > 0 )
varName = QString("%1%2").arg(MITK_SURFACE_VAR_NAME).arg(j);
MITK_DEBUG("varName") << "varName" << varName.toStdString();
if( m_PythonService->IsVtkPythonWrappingAvailable() )
{
m_PythonService->CopyToPythonAsVtkPolyData( surface, MITK_SURFACE_VAR_NAME.toStdString() );
++j;
}
else
{
MITK_ERROR << "VTK Python wrapping not available. Skipping export for surface " << node->GetName();
}
}
}
}
}
return returnValue;
}
QVariant QmitkPythonVariableStackTableModel::headerData(int section, Qt::Orientation orientation,
int role) const
{
QVariant headerData;
// show only horizontal header
if ( role == Qt::DisplayRole )
{
if( orientation == Qt::Horizontal )
{
// first column: "Attribute"
if(section == 0)
headerData = "Attribute";
else if(section == 1)
headerData = "Type";
else if(section == 2)
headerData = "Value";
}
}
return headerData;
}
Qt::ItemFlags QmitkPythonVariableStackTableModel::flags(const QModelIndex &index) const
{
Qt::ItemFlags flags = QAbstractItemModel::flags(index);
if(index.isValid())
return Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | flags;
else
return Qt::ItemIsDropEnabled | flags;
}
int QmitkPythonVariableStackTableModel::rowCount(const QModelIndex &) const
{
return m_VariableStack.size();
}
int QmitkPythonVariableStackTableModel::columnCount(const QModelIndex &) const
{
return 3;
}
QVariant QmitkPythonVariableStackTableModel::data(const QModelIndex &index, int role) const
{
if (index.isValid() && !m_VariableStack.empty())
{
if(role == Qt::DisplayRole)
{
mitk::PythonVariable item = m_VariableStack.at(index.row());
if(index.column() == 0)
return QString::fromStdString(item.m_Name);
if(index.column() == 1)
return QString::fromStdString(item.m_Type);
if(index.column() == 2)
return QString::fromStdString(item.m_Value);
}
}
return QVariant();
}
QStringList QmitkPythonVariableStackTableModel::mimeTypes() const
{
return QAbstractTableModel::mimeTypes();
QStringList types;
types << "application/x-mitk-datanodes";
types << "application/x-qabstractitemmodeldatalist";
return types;
}
Qt::DropActions QmitkPythonVariableStackTableModel::supportedDropActions() const
{
return Qt::CopyAction | Qt::MoveAction;
}
void QmitkPythonVariableStackTableModel::CommandExecuted(const std::string& pythonCommand)
{
MITK_DEBUG("QmitkPythonVariableStackTableModel") << "command was executed " << pythonCommand;
m_VariableStack = m_PythonService->GetVariableStack();
QAbstractTableModel::reset();
}
std::vector<mitk::PythonVariable> QmitkPythonVariableStackTableModel::GetVariableStack() const
{
return m_VariableStack;
}
diff --git a/Modules/Python/Testing/CMakeLists.txt b/Modules/Python/Testing/CMakeLists.txt
index 2d5e45bb88..c1470c885b 100644
--- a/Modules/Python/Testing/CMakeLists.txt
+++ b/Modules/Python/Testing/CMakeLists.txt
@@ -1,2 +1,4 @@
MITK_CREATE_MODULE_TESTS()
+mitkAddCustomModuleTest(mitkCopyToPythonAsItkImage_CopyPic3DToPythonAndBackToMitk_ImageIsEqual mitkCopyToPythonAsItkImageTest ${MITK_DATA_DIR}/Pic3D.nrrd)
+
diff --git a/Modules/Python/Testing/files.cmake b/Modules/Python/Testing/files.cmake
index d4301946da..c8e9fe00e2 100644
--- a/Modules/Python/Testing/files.cmake
+++ b/Modules/Python/Testing/files.cmake
@@ -1,3 +1,7 @@
set(MODULE_TESTS
mitkPythonTest.cpp
)
+
+set(MODULE_CUSTOM_TESTS
+ mitkCopyToPythonAsItkImageTest.cpp
+)
diff --git a/Modules/Python/Testing/mitkCopyToPythonAsItkImageTest.cpp b/Modules/Python/Testing/mitkCopyToPythonAsItkImageTest.cpp
new file mode 100644
index 0000000000..bdc7f7d08b
--- /dev/null
+++ b/Modules/Python/Testing/mitkCopyToPythonAsItkImageTest.cpp
@@ -0,0 +1,61 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+#include <mitkCommon.h>
+#include <usModuleContext.h>
+#include <usGetModuleContext.h>
+#include <usServiceReference.h>
+#include <mitkTestingMacros.h>
+#include <mitkPythonService.h>
+#include <mitkIPythonService.h>
+#include <mitkIOUtil.h>
+
+#include <mitkModuleRegistry.h>
+#include <mitkModule.h>
+#include <mitkServiceReference.h>
+
+int mitkCopyToPythonAsItkImageTest(int /*argc*/, char* argv[])
+{
+ MITK_TEST_BEGIN("mitkCopyToPythonAsItkImageTest")
+
+ //get the context of the python module
+ mitk::Module* module = mitk::ModuleRegistry::GetModule("mitkPython");
+ mitk::ModuleContext* context = module->GetModuleContext();
+ //get the service which is generated in the PythonModuleActivator
+ mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::IPythonService>();
+ mitk::PythonService* pythonService = dynamic_cast<mitk::PythonService*>( context->GetService<mitk::IPythonService>(serviceRef) );
+ MITK_TEST_CONDITION(pythonService->IsItkPythonWrappingAvailable() == true, "Is Python available?");
+
+ mitk::Image::Pointer testImage = mitk::IOUtil::LoadImage(std::string(argv[1]));
+
+ //give it a name in python
+ std::string nameOfImageInPython("mitkImage");
+
+ MITK_TEST_CONDITION( pythonService->CopyToPythonAsItkImage( testImage, nameOfImageInPython) == true, "Valid image copied to python import should return true.");
+ mitk::Image::Pointer pythonImage = pythonService->CopyItkImageFromPython(nameOfImageInPython);
+
+ //TODO Use the assert comparison methods once we have them implemented and remove GetPixelValueByIndex
+ MITK_TEST_CONDITION( pythonImage->GetDimension(0) == 256, "Is the 1st dimension of Pic3D still 256?");
+ MITK_TEST_CONDITION( pythonImage->GetDimension(1) == 256, "Is the 2nd dimension of Pic3D still 256?");
+ MITK_TEST_CONDITION( pythonImage->GetDimension(2) == 49, "Is the 3rd dimension of Pic3D still 49?");
+
+ mitk::Index3D index;
+ index[0] = 128;
+ index[1] = 128;
+ index[2] = 24;
+ MITK_TEST_CONDITION( pythonImage->GetPixelValueByIndex(index) == 96, "Is the value of Pic3D at (128,128,24) still 96?");
+
+ MITK_TEST_END()
+}
diff --git a/Modules/Python/documentation/mitkPython.dox b/Modules/Python/documentation/mitkPython.dox
index 899290048f..dbfb3994e9 100644
--- a/Modules/Python/documentation/mitkPython.dox
+++ b/Modules/Python/documentation/mitkPython.dox
@@ -1,17 +1,43 @@
/**
\page mitkPython_Overview The MITK Python Module
<h1>Brief description</h1>
The MITK Python Module provides a service class for interactively run python code (passed as C++ strings) and evaluate the results. Furthermore the service class offers means to convert an MITK Image to an ITK/OpenCV image in their wrapped python environment. <strong>Thus, one can process MITK images with Python Code from the OpenCV and ITK wrapping system</strong>. Furthermore one can convert an mitk::Surface to a vtkPolyData in its Python environment.<br />
Under the hood, the MITK build system takes care that the wrapping build process for ITK/VTK/OpenCV is correctly initiated and all paths are correctly set within MITK code.
<h1>Build Instructions</h1>
- Install Python <b>2.x</b>
- Activate MITK_USE_Python in the superbuild process of MITK
- Provide CMake with the correct Python paths (if not found automatically)
- Build MITK: All wrapping will be setup by the MITK superbuild routine
<h1>Known problems and workarounds</h1>
+<p>System: Linux/OSX/gcc<br />
+Problem: An error during the build process occurs:
+<pre>
+Linking CXX shared library libPythonQt.so
+/usr/bin/ld: error: /usr/lib/gcc/x86_64-linux-gnu/4.6.1/../../../../lib/libpython2.7.a(abstract.o): requires dynamic R_X86_64_PC32 reloc against 'PyErr_Occurred' which may overflow at runtime; recompile with -fPIC
+</pre>
+<strong>Workaround</strong>: Try setting the CMake var PYTHON_LIBRARY to the shared object, e.g. /usr/lib/libpython2.7.so
+</p>
+<p>System: Linux/gcc (maybe Mac OS)<br />
+Problem: An error during the build process occurs:
+<pre>
+Scanning dependencies of target install_wrapitk_compatibility
+[ 40%] Built target install_wrapitk_compatibility
+[ 40%] Generating swigrun.xml
+gccxml_cc1plus: error: gccxml_builtins.h: No such file or directory
+make[5]: *** [Wrapping/WrapITK/SwigRuntime/swigrun.xml] Error 1
+make[4]: *** [Wrapping/WrapITK/SwigRuntime/CMakeFiles/SwigRuntimePython.dir/all] Error 2
+make[3]: *** [all] Error 2
+make[2]: *** [ITK-cmake/src/ITK-stamp/ITK-build] Error 2
+make[1]: *** [CMakeFiles/ITK.dir/all] Error 2
+make: *** [all] Error 2
+</pre>
+<strong>Workaround</strong>: Install CableSwig from the software repo and set the CMake var EXTERNAL_CableSwig_DIR to the directory containing CableSwigConfig.cmake, on linux usually /usr/lib/CableSwig
+</p>
+
+
*/
diff --git a/Modules/Python/mitkPythonService.cpp b/Modules/Python/mitkPythonService.cpp
index 4068f2f094..0cb382b5ab 100644
--- a/Modules/Python/mitkPythonService.cpp
+++ b/Modules/Python/mitkPythonService.cpp
@@ -1,532 +1,529 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPythonService.h"
#include <Python.h>
#include <mitkIOUtil.h>
#include <QFile>
#include <QDir>
#include <PythonQt.h>
#include "PythonPath.h"
const QString mitk::PythonService::m_TmpDataFileName("temp_mitk_data_file");
mitk::PythonService::PythonService()
: m_ItkWrappingAvailable( true ), m_OpenCVWrappingAvailable( true ), m_VtkWrappingAvailable( true ), m_ErrorOccured( false )
{
{
MITK_DEBUG << "will init python if necessary";
}
bool pythonInitialized = static_cast<bool>( Py_IsInitialized() ); //m_PythonManager.isPythonInitialized() );
{
MITK_DEBUG << "pythonInitialized " << pythonInitialized;
MITK_DEBUG << "m_PythonManager.isPythonInitialized() " << m_PythonManager.isPythonInitialized();
}
// due to strange static var behaviour on windows Py_IsInitialized() returns correct value while
// m_PythonManager.isPythonInitialized() does not because it has been constructed and destructed again
if( !m_PythonManager.isPythonInitialized() )
{
try
{
if( pythonInitialized )
m_PythonManager.setInitializationFlags(PythonQt::RedirectStdOut|PythonQt::PythonAlreadyInitialized);
else
m_PythonManager.setInitializationFlags(PythonQt::RedirectStdOut);
MITK_DEBUG("PythonService") << "initalizing python";
m_PythonManager.initialize();
MITK_DEBUG("PythonService") << "python initalized";
QString pythonCommand(PYTHONPATH_COMMAND);
MITK_DEBUG("PythonService") << "registering python paths" << PYTHONPATH_COMMAND;
m_PythonManager.executeString( pythonCommand, ctkAbstractPythonManager::FileInput );
/*
//system("export LD_LIBRARY_PATH=/local/muellerm/mitk/bugsquashing/bin-debug/VTK-build/bin:$LD_LIBRARY_PATH");
//m_PythonManager.executeString( "print sys.path", ctkAbstractPythonManager::SingleInput );
//MITK_DEBUG("mitk::PythonService") << "result of 'sys.path': " << result.toString().toStdString();
//m_PythonManager.executeString( "sys.path.append('/usr/share/pyshared/numpy')", ctkAbstractPythonManager::SingleInput );
//m_PythonManager.executeString( "import numpy", ctkAbstractPythonManager::SingleInput );
MITK_DEBUG("mitk::PythonService") << "Trying to import ITK";
m_PythonManager.executeString( "import itk", ctkAbstractPythonManager::SingleInput );
m_ItkWrappingAvailable = !m_PythonManager.pythonErrorOccured();
MITK_DEBUG("mitk::PythonService") << "m_ItkWrappingAvailable: " << (m_ItkWrappingAvailable? "yes": "no");
if( !m_ItkWrappingAvailable )
{
MITK_WARN << "ITK Python wrapping not available. Please check build settings or PYTHONPATH settings.";
}
{
MITK_DEBUG("mitk::PythonService") << "Trying to import OpenCv";
PyRun_SimpleString("import cv2\n");
if (PyErr_Occurred())
{
PyErr_Print();
}
else
m_OpenCVWrappingAvailable = true;
//m_PythonManager.executeString( "import cv2", ctkAbstractPythonManager::SingleInput );
MITK_DEBUG("mitk::PythonService") << "Investigate if an error occured while importing cv2";
//m_OpenCVWrappingAvailable = !m_PythonManager.pythonErrorOccured();
MITK_DEBUG("mitk::PythonService") << "m_OpenCVWrappingAvailable: " << (m_OpenCVWrappingAvailable? "yes": "no");
if( !m_OpenCVWrappingAvailable )
{
MITK_WARN << "OpenCV Python wrapping not available. Please check build settings or PYTHONPATH settings.";
}
}
MITK_DEBUG("mitk::PythonService") << "Trying to import VTK";
m_PythonManager.executeString( "import vtk", ctkAbstractPythonManager::SingleInput );
m_VtkWrappingAvailable = !m_PythonManager.pythonErrorOccured();
MITK_DEBUG("mitk::PythonService") << "m_VtkWrappingAvailable: " << (m_VtkWrappingAvailable? "yes": "no");
if( !m_VtkWrappingAvailable )
{
MITK_WARN << "VTK Python wrapping not available. Please check build settings or PYTHONPATH settings.";
}
*/
}
catch (...)
{
MITK_DEBUG("PythonService") << "exception initalizing python";
}
}
//m_PythonManager.executeString( "for path in sys.path:\n print path\n", ctkAbstractPythonManager::SingleInput );
//m_PythonManager.executeString( "for k, v in os.environ.items():\n print \"%s=%s\" % (k, v)", ctkAbstractPythonManager::SingleInput );
//m_PythonManager.executeFile("/local/muellerm/Dropbox/13-02-11-python-wrapping/interpreterInfo.py");
//std::string result = m_PythonManager.executeString( "5+5", ctkAbstractPythonManager::EvalInput );
//MITK_DEBUG("mitk::PythonService") << "result of '5+5': " << result.toString().toStdString();
}
mitk::PythonService::~PythonService()
{
//QVariant result = m_PythonManager.executeString( "sys.getrefcount(cv2)", ctkAbstractPythonManager::EvalInput );
//MITK_DEBUG("mitk::PythonService") << "sys.getrefcount(cv2): " << result.toString().toStdString();
//m_PythonManager.executeString( "del sys.modules[\"cv2\"]", ctkAbstractPythonManager::SingleInput );
//m_PythonManager.executeString( "del cv2", ctkAbstractPythonManager::SingleInput );
MITK_DEBUG("mitk::PythonService") << "destructing PythonService";
}
std::string mitk::PythonService::Execute(const std::string &stdpythonCommand, int commandType)
{
QString pythonCommand = QString::fromStdString(stdpythonCommand);
{
MITK_DEBUG("mitk::PythonService") << "pythonCommand = " << pythonCommand.toStdString();
MITK_DEBUG("mitk::PythonService") << "commandType = " << commandType;
}
QVariant result;
bool commandIssued = true;
if(commandType == IPythonService::SINGLE_LINE_COMMAND )
result = m_PythonManager.executeString(pythonCommand, ctkAbstractPythonManager::SingleInput );
else if(commandType == IPythonService::MULTI_LINE_COMMAND )
result = m_PythonManager.executeString(pythonCommand, ctkAbstractPythonManager::FileInput );
else if(commandType == IPythonService::EVAL_COMMAND )
result = m_PythonManager.executeString(pythonCommand, ctkAbstractPythonManager::EvalInput );
else
commandIssued = false;
if(commandIssued)
{
this->NotifyObserver(pythonCommand.toStdString());
- m_ErrorOccured = PythonQt::self()->handleError();
+ m_ErrorOccured = PythonQt::self()->errorOccured();
}
return result.toString().toStdString();
}
void mitk::PythonService::ExecuteScript( const std::string& pythonScript )
{
m_PythonManager.executeFile(QString::fromStdString(pythonScript));
}
std::vector<mitk::PythonVariable> mitk::PythonService::GetVariableStack() const
{
std::vector<mitk::PythonVariable> list;
PyObject* dict = PyImport_GetModuleDict();
PyObject* object = PyDict_GetItemString(dict, "__main__");
PyObject* dirMain = PyObject_Dir(object);
PyObject* tempObject = 0;
PyObject* strTempObject = 0;
if(dirMain)
{
std::string name, attrValue, attrType;
for(int i = 0; i<PyList_Size(dirMain); i++)
{
tempObject = PyList_GetItem(dirMain, i);
name = PyString_AsString(tempObject);
tempObject = PyObject_GetAttrString( object, name.c_str() );
attrType = tempObject->ob_type->tp_name;
strTempObject = PyObject_Repr(tempObject);
if(strTempObject && ( PyUnicode_Check(strTempObject) || PyString_Check(strTempObject) ) )
attrValue = PyString_AsString(strTempObject);
else
attrValue = "";
mitk::PythonVariable var;
var.m_Name = name;
var.m_Value = attrValue;
var.m_Type = attrType;
list.push_back(var);
}
}
return list;
}
bool mitk::PythonService::DoesVariableExist(const std::string& name) const
{
bool varExists = false;
std::vector<mitk::PythonVariable> allVars = this->GetVariableStack();
for(int i = 0; i< allVars.size(); i++)
{
if( allVars.at(i).m_Name == name )
{
varExists = true;
break;
}
}
return varExists;
}
void mitk::PythonService::AddPythonCommandObserver(mitk::PythonCommandObserver *observer)
{
if(!m_Observer.contains(observer))
m_Observer.append(observer);
}
void mitk::PythonService::RemovePythonCommandObserver(mitk::PythonCommandObserver *observer)
{
m_Observer.removeOne(observer);
}
void mitk::PythonService::NotifyObserver(const std::string &command)
{
MITK_DEBUG("mitk::PythonService") << "number of observer " << m_Observer.size();
for( size_t i=0; i< m_Observer.size(); ++i )
{
m_Observer.at(i)->CommandExecuted(command);
}
}
QString mitk::PythonService::GetTempDataFileName(const std::string& ext) const
{
QString tmpFolder = QDir::tempPath();
QString fileName = tmpFolder + QDir::separator() + m_TmpDataFileName + QString::fromStdString(ext);
return fileName;
}
bool mitk::PythonService::CopyToPythonAsItkImage(mitk::Image *image, const std::string &stdvarName)
{
QString varName = QString::fromStdString( stdvarName );
- // save image
- QString fileName = this->GetTempDataFileName( mitk::IOUtil::DEFAULTIMAGEEXTENSION );
- fileName = QDir::fromNativeSeparators( fileName );
+ // save image
+ QString fileName = this->GetTempDataFileName( mitk::IOUtil::DEFAULTIMAGEEXTENSION );
+ fileName = QDir::fromNativeSeparators( fileName );
- MITK_DEBUG("PythonService") << "Saving temporary file " << fileName.toStdString();
- if( !mitk::IOUtil::SaveImage(image, fileName.toStdString()) )
+ MITK_DEBUG("PythonService") << "Saving temporary file " << fileName.toStdString();
+ if( !mitk::IOUtil::SaveImage(image, fileName.toStdString()) )
+ {
+ MITK_ERROR << "Temporary file could not be created.";
+ }
+ else
+ {
+ // TODO CORRECT TYPE SETUP, MAKE MITK_DEBUG("PythonService") MITK_DEBUG("PythonService")
+ int dim = image->GetDimension();
+ mitk::PixelType pixelType = image->GetPixelType();
+ itk::ImageIOBase::IOPixelType ioPixelType = image->GetPixelType().GetPixelType();
+
+ // default pixeltype: unsigned short
+ QString type = "US";
+ if( ioPixelType == itk::ImageIOBase::SCALAR )
{
- MITK_ERROR << "Temporary file could not be created.";
+ if( pixelType.GetComponentType() == itk::ImageIOBase::DOUBLE )
+ type = "D";
+ else if( pixelType.GetComponentType() == itk::ImageIOBase::FLOAT )
+ type = "F";
+ else if( pixelType.GetComponentType() == itk::ImageIOBase::SHORT)
+ type = "SS";
+ else if( pixelType.GetComponentType() == itk::ImageIOBase::CHAR )
+ type = "SC";
+ else if( pixelType.GetComponentType() == itk::ImageIOBase::INT )
+ type = "SI";
+ else if( pixelType.GetComponentType() == itk::ImageIOBase::LONG )
+ type = "SL";
+ else if( pixelType.GetComponentType() == itk::ImageIOBase::UCHAR )
+ type = "UC";
+ else if( pixelType.GetComponentType() == itk::ImageIOBase::UINT )
+ type = "UI";
+ else if( pixelType.GetComponentType() == itk::ImageIOBase::ULONG )
+ type = "UL";
+ else if( pixelType.GetComponentType() == itk::ImageIOBase::USHORT )
+ type = "US";
}
- else
- {
- // TODO CORRECT TYPE SETUP, MAKE MITK_DEBUG("PythonService") MITK_DEBUG("PythonService")
- int dim = image->GetDimension();
- mitk::PixelType pixelType = image->GetPixelType();
- itk::ImageIOBase::IOPixelType ioPixelType = image->GetPixelType().GetPixelTypeId();
-
- // default pixeltype: unsigned short
- QString type = "US";
- if( ioPixelType == itk::ImageIOBase::SCALAR )
- {
- if( pixelType.GetTypeId() == typeid(double) )
- type = "D";
- else if( pixelType.GetTypeId() == typeid(float) )
- type = "F";
- if( pixelType.GetTypeId() == typeid(long double) )
- type = "LD";
- else if( pixelType.GetTypeId() == typeid(short) )
- type = "SS";
- else if( pixelType.GetTypeId() == typeid(signed char) )
- type = "SC";
- else if( pixelType.GetTypeId() == typeid(signed int) )
- type = "SI";
- else if( pixelType.GetTypeId() == typeid(signed long) )
- type = "SL";
- else if( pixelType.GetTypeId() == typeid(signed short) )
- type = "SS";
- else if( pixelType.GetTypeId() == typeid(unsigned char) )
- type = "UC";
- else if( pixelType.GetTypeId() == typeid(unsigned int) )
- type = "UI";
- else if( pixelType.GetTypeId() == typeid(unsigned long) )
- type = "UL";
- else if( pixelType.GetTypeId() == typeid(unsigned short) )
- type = "US";
- }
-
- MITK_DEBUG("PythonService") << "Got mitk image with type " << type.toStdString() << " and dim " << dim;
- QString command;
+ MITK_DEBUG("PythonService") << "Got mitk image with type " << type.toStdString() << " and dim " << dim;
- command.append( QString("imageType = itk.Image[itk.%1, %2]\n") .arg( type ).arg( dim ) );
+ QString command;
- command.append( QString("readerType = itk.ImageFileReader[imageType]\n") );
- command.append( QString("reader = readerType.New()\n") );
- command.append( QString("reader.SetFileName( \"%1\" )\n") .arg(fileName) );
- command.append( QString("reader.Update()\n") );
- command.append( QString("%1 = reader.GetOutput()\n").arg( varName ) );
+ command.append( QString("imageType = itk.Image[itk.%1, %2]\n") .arg( type ).arg( dim ) );
- MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
- this->Execute( command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
+ command.append( QString("readerType = itk.ImageFileReader[imageType]\n") );
+ command.append( QString("reader = readerType.New()\n") );
+ command.append( QString("reader.SetFileName( \"%1\" )\n") .arg(fileName) );
+ command.append( QString("reader.Update()\n") );
+ command.append( QString("%1 = reader.GetOutput()\n").arg( varName ) );
- QFile file( fileName );
- MITK_DEBUG("PythonService") << "Removing file " << fileName.toStdString();
- file.remove();
- return true;
- }
+ MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
+ MITK_INFO << this->Execute( command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
- return false;
+ QFile file( fileName );
+ MITK_DEBUG("PythonService") << "Removing file " << fileName.toStdString();
+ file.remove();
+ return true;
+ }
+ return false;
}
mitk::Image::Pointer mitk::PythonService::CopyItkImageFromPython(const std::string &stdvarName)
{
QString varName = QString::fromStdString( stdvarName );
mitk::Image::Pointer mitkImage;
QString command;
QString fileName = GetTempDataFileName( mitk::IOUtil::DEFAULTIMAGEEXTENSION );
fileName = QDir::fromNativeSeparators( fileName );
MITK_DEBUG("PythonService") << "Saving temporary file with python itk code " << fileName.toStdString();
command.append( QString( "writer = itk.ImageFileWriter[ %1 ].New()\n").arg( varName ) );
command.append( QString( "writer.SetFileName( \"%1\" )\n").arg(fileName) );
command.append( QString( "writer.SetInput( %1 )\n").arg(varName) );
command.append( QString( "writer.Update()\n" ) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
try
{
MITK_DEBUG("PythonService") << "Loading temporary file " << fileName.toStdString() << " as MITK image";
mitkImage = mitk::IOUtil::LoadImage( fileName.toStdString() );
}
catch(std::exception& e)
{
MITK_ERROR << e.what();
}
QFile file(fileName);
if( file.exists() )
{
MITK_DEBUG("PythonService") << "Removing temporary file " << fileName.toStdString();
file.remove();
}
return mitkImage;
}
bool mitk::PythonService::CopyToPythonAsCvImage( mitk::Image* image, const std::string& stdvarName )
{
QString varName = QString::fromStdString( stdvarName );
bool convert = false;
if(image->GetDimension() != 2)
{
MITK_ERROR << "Only 2D images allowed for OpenCV images";
return convert;
}
// try to save mitk image
QString fileName = this->GetTempDataFileName( ".bmp" );
fileName = QDir::fromNativeSeparators( fileName );
MITK_DEBUG("PythonService") << "Saving temporary file " << fileName.toStdString();
if( !mitk::IOUtil::SaveImage(image, fileName.toStdString()) )
{
MITK_ERROR << "Temporary file " << fileName.toStdString() << " could not be created.";
return convert;
}
QString command;
command.append( QString("%1 = cv2.imread(\"%2\")\n") .arg( varName ).arg( fileName ) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
MITK_DEBUG("PythonService") << "Removing file " << fileName.toStdString();
QFile file(fileName);
file.remove();
convert = true;
return convert;
}
mitk::Image::Pointer mitk::PythonService::CopyCvImageFromPython( const std::string& stdvarName )
{
QString varName = QString::fromStdString( stdvarName );
mitk::Image::Pointer mitkImage;
QString command;
QString fileName = GetTempDataFileName( ".bmp" );
fileName = QDir::fromNativeSeparators( fileName );
MITK_DEBUG("PythonService") << "run python command to save image with opencv to " << fileName.toStdString();
command.append( QString( "cv2.imwrite(\"%1\", %2)\n").arg( fileName ).arg( varName ) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
try
{
MITK_DEBUG("PythonService") << "Loading temporary file " << fileName.toStdString() << " as MITK image";
mitkImage = mitk::IOUtil::LoadImage( fileName.toStdString() );
}
catch(std::exception& e)
{
MITK_ERROR << e.what();
}
QFile file(fileName);
if( file.exists() )
{
MITK_DEBUG("PythonService") << "Removing temporary file " << fileName.toStdString();
file.remove();
}
return mitkImage;
}
ctkAbstractPythonManager *mitk::PythonService::GetPythonManager()
{
return &m_PythonManager;
}
mitk::Surface::Pointer mitk::PythonService::CopyVtkPolyDataFromPython( const std::string& stdvarName )
{
QString varName = QString::fromStdString( stdvarName );
mitk::Surface::Pointer newSurface;
QString command;
QString fileName = GetTempDataFileName( ".stl" );
fileName = QDir::fromNativeSeparators( fileName );
MITK_DEBUG("PythonService") << "run python command to save polydata with vtk to " << fileName.toStdString();
command = QString (
"vtkStlWriter = vtk.vtkSTLWriter()\n"
"vtkStlWriter.SetInput(%1)\n"
"vtkStlWriter.SetFileName(\"%2\")\n"
"vtkStlWriter.Write()\n").arg(varName).arg(fileName);
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
try
{
MITK_DEBUG("PythonService") << "Loading temporary file " << fileName.toStdString() << " as MITK Surface";
newSurface = mitk::IOUtil::LoadSurface( fileName.toStdString() );
}
catch(std::exception& e)
{
MITK_ERROR << e.what();
}
QFile file(fileName);
if( file.exists() )
{
MITK_DEBUG("PythonService") << "Removing temporary file " << fileName.toStdString();
file.remove();
}
return newSurface;
}
bool mitk::PythonService::CopyToPythonAsVtkPolyData( mitk::Surface* surface, const std::string& stdvarName )
{
QString varName = QString::fromStdString( stdvarName );
bool convert = false;
// try to save mitk image
QString fileName = this->GetTempDataFileName( ".stl" );
fileName = QDir::fromNativeSeparators( fileName );
MITK_DEBUG("PythonService") << "Saving temporary file " << fileName.toStdString();
if( !mitk::IOUtil::SaveSurface( surface, fileName.toStdString() ) )
{
MITK_ERROR << "Temporary file " << fileName.toStdString() << " could not be created.";
return convert;
}
QString command;
command.append( QString("vtkStlReader = vtk.vtkSTLReader()\n") );
command.append( QString("vtkStlReader.SetFileName(\"%1\")\n").arg( fileName ) );
command.append( QString("vtkStlReader.Update()\n") );
command.append( QString("%1 = vtkStlReader.GetOutput()\n").arg( varName ) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
MITK_DEBUG("PythonService") << "Removing file " << fileName.toStdString();
QFile file(fileName);
file.remove();
convert = true;
return convert;
}
bool mitk::PythonService::IsItkPythonWrappingAvailable()
{
this->Execute( "import itk\n", IPythonService::SINGLE_LINE_COMMAND );
+ this->Execute( "print \"Using ITK version \" + itk.Version.GetITKVersion()\n", IPythonService::SINGLE_LINE_COMMAND );
m_ItkWrappingAvailable = !this->PythonErrorOccured();
return m_ItkWrappingAvailable;
}
bool mitk::PythonService::IsOpenCvPythonWrappingAvailable()
{
this->Execute( "import cv2\n", IPythonService::SINGLE_LINE_COMMAND );
m_OpenCVWrappingAvailable = !this->PythonErrorOccured();
return m_OpenCVWrappingAvailable;
}
bool mitk::PythonService::IsVtkPythonWrappingAvailable()
{
this->Execute( "import vtk", IPythonService::SINGLE_LINE_COMMAND );
+ this->Execute( "print \"Using VTK version \" + vtk.vtkVersion.GetVTKVersion()\n", IPythonService::SINGLE_LINE_COMMAND );
m_VtkWrappingAvailable = !this->PythonErrorOccured();
return m_VtkWrappingAvailable;
}
bool mitk::PythonService::PythonErrorOccured() const
{
return m_ErrorOccured;
}
diff --git a/Modules/Qmitk/QmitkDataStorageComboBox.cpp b/Modules/Qmitk/QmitkDataStorageComboBox.cpp
index a3e85a755e..a40c6d7067 100644
--- a/Modules/Qmitk/QmitkDataStorageComboBox.cpp
+++ b/Modules/Qmitk/QmitkDataStorageComboBox.cpp
@@ -1,415 +1,417 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkDataStorageComboBox.h"
#include <itkCommand.h>
//#CTORS/DTOR
QmitkDataStorageComboBox::QmitkDataStorageComboBox( QWidget* parent, bool _AutoSelectNewNodes )
: QComboBox(parent)
, m_DataStorage(0)
, m_Predicate(0)
, m_BlockEvents(false)
, m_AutoSelectNewNodes(_AutoSelectNewNodes)
{
this->Init();
}
QmitkDataStorageComboBox::QmitkDataStorageComboBox( mitk::DataStorage* _DataStorage, const mitk::NodePredicateBase* _Predicate,
QWidget* parent, bool _AutoSelectNewNodes )
: QComboBox(parent)
, m_DataStorage(0)
, m_Predicate(_Predicate)
, m_BlockEvents(false)
, m_AutoSelectNewNodes(_AutoSelectNewNodes)
{
// make connections, fill combobox
this->Init();
this->SetDataStorage(_DataStorage);
}
QmitkDataStorageComboBox::~QmitkDataStorageComboBox()
{
// if there was an old storage, remove listeners
if(m_DataStorage.IsNotNull())
{
this->m_DataStorage->AddNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageComboBox
, const mitk::DataNode*>( this, &QmitkDataStorageComboBox::AddNode ) );
this->m_DataStorage->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageComboBox
, const mitk::DataNode*>( this, &QmitkDataStorageComboBox::RemoveNode ) );
}
//we have lots of observers to nodes and their name properties, this get's ugly if nodes live longer than the box
while(m_Nodes.size() > 0)
RemoveNode(0);
}
//#PUBLIC GETTER
mitk::DataStorage::Pointer QmitkDataStorageComboBox::GetDataStorage() const
{
return m_DataStorage.GetPointer();
}
const mitk::NodePredicateBase::ConstPointer QmitkDataStorageComboBox::GetPredicate() const
{
return m_Predicate.GetPointer();
}
mitk::DataNode::Pointer QmitkDataStorageComboBox::GetNode( int index ) const
{
return (this->HasIndex(index))? m_Nodes.at(index): 0;
}
mitk::DataNode::Pointer QmitkDataStorageComboBox::GetSelectedNode() const
{
+ if (count() == 0)
+ return 0;
int _CurrentIndex = this->currentIndex();
return (_CurrentIndex >= 0)? this->GetNode(_CurrentIndex): 0;
}
mitk::DataStorage::SetOfObjects::ConstPointer QmitkDataStorageComboBox::GetNodes() const
{
mitk::DataStorage::SetOfObjects::Pointer _SetOfObjects = mitk::DataStorage::SetOfObjects::New();
for (std::vector<mitk::DataNode*>::const_iterator it = m_Nodes.begin(); it != m_Nodes.end(); ++it)
{
_SetOfObjects->push_back(*it);
}
return _SetOfObjects.GetPointer();
}
bool QmitkDataStorageComboBox::GetAutoSelectNewItems()
{
return m_AutoSelectNewNodes;
}
//#PUBLIC SETTER
void QmitkDataStorageComboBox::SetDataStorage(mitk::DataStorage* _DataStorage)
{
// reset only if datastorage really changed
if(m_DataStorage.GetPointer() != _DataStorage)
{
// if there was an old storage, remove listeners
if(m_DataStorage.IsNotNull())
{
this->m_DataStorage->AddNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageComboBox
, const mitk::DataNode*>( this, &QmitkDataStorageComboBox::AddNode ) );
this->m_DataStorage->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageComboBox
, const mitk::DataNode*>( this, &QmitkDataStorageComboBox::RemoveNode ) );
}
// set new storage
m_DataStorage = _DataStorage;
// if there is a new storage, add listeners
if(m_DataStorage.IsNotNull())
{
this->m_DataStorage->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageComboBox
, const mitk::DataNode*>( this, &QmitkDataStorageComboBox::AddNode ) );
this->m_DataStorage->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageComboBox
, const mitk::DataNode*>( this, &QmitkDataStorageComboBox::RemoveNode ) );
}
// reset predicate to reset the combobox
this->Reset();
}
}
void QmitkDataStorageComboBox::SetPredicate(const mitk::NodePredicateBase* _Predicate)
{
if(m_Predicate != _Predicate)
{
m_Predicate = _Predicate;
this->Reset();
}
}
void QmitkDataStorageComboBox::AddNode( const mitk::DataNode* _DataNode )
{
// this is an event function, make sure that we didnt call ourself
if(!m_BlockEvents)
{
m_BlockEvents = true;
// pass a -1 to the InsertNode function in order to append the datatreenode to the end
this->InsertNode(-1, _DataNode);
m_BlockEvents = false;
}
}
void QmitkDataStorageComboBox::RemoveNode( int index )
{
if(this->HasIndex(index))
{
//# remove itk::Event observer
mitk::DataNode* _DataNode = m_Nodes.at(index);
// get name property first
mitk::BaseProperty* nameProperty = _DataNode->GetProperty("name");
// if prop exists remove modified listener
if(nameProperty)
{
nameProperty->RemoveObserver(m_NodesModifiedObserverTags[index]);
// remove name property map
m_PropertyToNode.erase(_DataNode);
}
// then remove delete listener on the node itself
_DataNode->RemoveObserver(m_NodesDeleteObserverTags[index]);
// remove observer tags from lists
m_NodesModifiedObserverTags.erase(m_NodesModifiedObserverTags.begin()+index);
m_NodesDeleteObserverTags.erase(m_NodesDeleteObserverTags.begin()+index);
- // remove node name from combobox
- this->removeItem(index);
// remove node from node vector
m_Nodes.erase(m_Nodes.begin()+index);
+ // remove node name from combobox
+ this->removeItem(index);
}
}
void QmitkDataStorageComboBox::RemoveNode( const mitk::DataNode* _DataNode )
{
// this is an event function, make sure that we didnt call ourself
if(!m_BlockEvents)
{
m_BlockEvents = true;
this->RemoveNode( this->Find(_DataNode) );
m_BlockEvents = false;
}
}
void QmitkDataStorageComboBox::SetNode(int index, const mitk::DataNode* _DataNode)
{
if(this->HasIndex(index))
{
this->InsertNode(index, _DataNode);
}
}
void QmitkDataStorageComboBox::SetNode( const mitk::DataNode* _DataNode, const mitk::DataNode* _OtherDataNode)
{
this->SetNode( this->Find(_DataNode), _OtherDataNode);
}
void QmitkDataStorageComboBox::SetAutoSelectNewItems( bool _AutoSelectNewItems )
{
m_AutoSelectNewNodes = _AutoSelectNewItems;
}
void QmitkDataStorageComboBox::OnDataNodeDeleteOrModified(const itk::Object *caller, const itk::EventObject &event)
{
if(!m_BlockEvents)
{
m_BlockEvents = true;
// check if we have a modified event (if not it is a delete event)
const itk::ModifiedEvent* modifiedEvent = dynamic_cast<const itk::ModifiedEvent*>(&event);
// when node was modified reset text
if(modifiedEvent)
{
const mitk::BaseProperty* _NameProperty = dynamic_cast<const mitk::BaseProperty*>(caller);
// node name changed, set it
// but first of all find associated node
for(std::map<mitk::DataNode*, const mitk::BaseProperty*>::iterator it=m_PropertyToNode.begin()
; it!=m_PropertyToNode.end()
; ++it)
{
// property is found take node
if(it->second == _NameProperty)
{
// looks strange but when calling setnode with the same node, that means the node gets updated
this->SetNode(it->first, it->first);
break;
}
}
}
else
{
const mitk::DataNode* _ConstDataNode = dynamic_cast<const mitk::DataNode*>(caller);
if(_ConstDataNode)
// node will be deleted, remove it
this->RemoveNode(_ConstDataNode);
}
m_BlockEvents = false;
}
}
void QmitkDataStorageComboBox::SetSelectedNode(mitk::DataNode::Pointer item)
{
int index = this->Find(item);
if (index == -1)
{
MITK_INFO << "QmitkDataStorageComboBox: item not available";
}
else
{
this->setCurrentIndex(index);
}
}
//#PROTECTED GETTER
bool QmitkDataStorageComboBox::HasIndex(unsigned int index) const
{
return (m_Nodes.size() > 0 && index < m_Nodes.size());
}
int QmitkDataStorageComboBox::Find( const mitk::DataNode* _DataNode ) const
{
int index = -1;
std::vector<mitk::DataNode*>::const_iterator nodeIt =
std::find(m_Nodes.begin(), m_Nodes.end(), _DataNode);
if(nodeIt != m_Nodes.end())
index = std::distance(m_Nodes.begin(), nodeIt);
return index;
}
//#PROTECTED SETTER
void QmitkDataStorageComboBox::OnCurrentIndexChanged(int index)
{
if(index >= 0 && index < this->count())
emit OnSelectionChanged(this->GetSelectedNode());
if(index == -1)
emit OnSelectionChanged(NULL);
}
void QmitkDataStorageComboBox::InsertNode(int index, const mitk::DataNode* _DataNode)
{
// check new or updated node first
if(m_Predicate.IsNotNull() && !m_Predicate->CheckNode(_DataNode))
return;
bool addNewNode = false;
bool insertNewNode = false;
bool changedNode = false;
// if this->HasIndex(index), then a node shall be updated
if(this->HasIndex(index))
{
// if we really have another node at this position then ...
if(_DataNode != m_Nodes.at(index))
{
// ... remove node, then proceed as usual
this->RemoveNode(index);
insertNewNode = true;
}
else
changedNode = true;
}
// otherwise a new node shall be added, let index point to the element after the last element
else
{
index = m_Nodes.size();
addNewNode = true;
}
// const cast because we need non const nodes
mitk::DataNode* _NonConstDataNode = const_cast<mitk::DataNode*>(_DataNode);
mitk::BaseProperty* nameProperty = _NonConstDataNode->GetProperty("name");
if(!changedNode)
{
// break on duplicated nodes (that doesnt make sense to have duplicates in the combobox)
if(this->Find(_DataNode) != -1)
return;
// add modified observer
itk::MemberCommand<QmitkDataStorageComboBox>::Pointer modifiedCommand = itk::MemberCommand<QmitkDataStorageComboBox>::New();
modifiedCommand->SetCallbackFunction(this, &QmitkDataStorageComboBox::OnDataNodeDeleteOrModified);
// !!!! add modified observer for the name
/// property of the node because this is the only thing we are interested in !!!!!
if(nameProperty)
{
m_NodesModifiedObserverTags.push_back( nameProperty->AddObserver(itk::ModifiedEvent(), modifiedCommand) );
m_PropertyToNode[_NonConstDataNode] = nameProperty;
}
// if there is no name node save an invalid value for the observer tag (-1)
else
m_NodesModifiedObserverTags.push_back( -1 );
// add delete observer
itk::MemberCommand<QmitkDataStorageComboBox>::Pointer deleteCommand = itk::MemberCommand<QmitkDataStorageComboBox>::New();
deleteCommand->SetCallbackFunction(this, &QmitkDataStorageComboBox::OnDataNodeDeleteOrModified);
m_NodesDeleteObserverTags.push_back( _NonConstDataNode->AddObserver(itk::DeleteEvent(), modifiedCommand) );
}
// add node to the vector
if(addNewNode)
m_Nodes.push_back( _NonConstDataNode );
else if(insertNewNode)
m_Nodes.insert( m_Nodes.begin()+index, _NonConstDataNode );
// ... and to the combobox
std::string _NonConstDataNodeName = "unnamed node";
// _NonConstDataNodeName is "unnamed node" so far, change it if there is a name property in the node
if(nameProperty)
_NonConstDataNodeName = nameProperty->GetValueAsString();
if(addNewNode)
{
this->addItem(QString::fromStdString(_NonConstDataNodeName));
// select new node if m_AutoSelectNewNodes is true or if we have just added the first node
if(m_AutoSelectNewNodes || m_Nodes.size() == 1)
this->setCurrentIndex(index);
}
else
{
// update text in combobox
this->setItemText( index, QString::fromStdString(_NonConstDataNodeName));
}
}
void QmitkDataStorageComboBox::Init()
{
connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(OnCurrentIndexChanged(int)));
}
void QmitkDataStorageComboBox::Reset()
{
// remove all nodes first
while( !m_Nodes.empty() )
{
// remove last node
this->RemoveNode( m_Nodes.size() - 1 );
}
// clear combobox
this->clear();
if(m_DataStorage.IsNotNull())
{
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects;
// select all if predicate == NULL
if (m_Predicate.IsNotNull())
setOfObjects = m_DataStorage->GetSubset(m_Predicate);
else
setOfObjects = m_DataStorage->GetAll();
// add all found nodes
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each _DataNode
{
// add node to the node vector and to the combobox
this->AddNode( nodeIt.Value().GetPointer() );
}
}
}
diff --git a/Modules/Qmitk/QmitkStdMultiWidget.cpp b/Modules/Qmitk/QmitkStdMultiWidget.cpp
index 0b63b24bf0..01f8e15ea6 100644
--- a/Modules/Qmitk/QmitkStdMultiWidget.cpp
+++ b/Modules/Qmitk/QmitkStdMultiWidget.cpp
@@ -1,2218 +1,2256 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#define SMW_INFO MITK_INFO("widget.stdmulti")
#include "QmitkStdMultiWidget.h"
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QGridLayout>
#include <qsplitter.h>
#include <QMotifStyle>
#include <QList>
#include <QMouseEvent>
#include <QTimer>
#include "mitkProperties.h"
#include "mitkGeometry2DDataMapper2D.h"
#include "mitkGlobalInteraction.h"
#include "mitkDisplayInteractor.h"
#include "mitkPointSet.h"
#include "mitkPositionEvent.h"
#include "mitkStateEvent.h"
#include "mitkLine.h"
#include "mitkInteractionConst.h"
#include "mitkDataStorage.h"
#include "mitkNodePredicateBase.h"
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateNot.h"
#include "mitkNodePredicateProperty.h"
#include "mitkStatusBar.h"
#include "mitkImage.h"
#include "mitkVtkLayerController.h"
#include <iomanip>
QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget* parent, Qt::WindowFlags f, mitk::RenderingManager* renderingManager)
: QWidget(parent, f),
mitkWidget1(NULL),
mitkWidget2(NULL),
mitkWidget3(NULL),
mitkWidget4(NULL),
levelWindowWidget(NULL),
QmitkStdMultiWidgetLayout(NULL),
m_Layout(LAYOUT_DEFAULT),
m_PlaneMode(PLANE_MODE_SLICING),
m_RenderingManager(renderingManager),
m_GradientBackgroundFlag(true),
m_TimeNavigationController(NULL),
m_MainSplit(NULL),
m_LayoutSplit(NULL),
m_SubSplit1(NULL),
m_SubSplit2(NULL),
mitkWidget1Container(NULL),
mitkWidget2Container(NULL),
mitkWidget3Container(NULL),
mitkWidget4Container(NULL),
m_PendingCrosshairPositionEvent(false),
m_CrosshairNavigationEnabled(false)
{
/******************************************************
* Use the global RenderingManager if none was specified
* ****************************************************/
if (m_RenderingManager == NULL)
{
m_RenderingManager = mitk::RenderingManager::GetInstance();
}
m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
/*******************************/
//Create Widget manually
/*******************************/
//create Layouts
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
QmitkStdMultiWidgetLayout->setContentsMargins(0,0,0,0);
//Set Layout to widget
this->setLayout(QmitkStdMultiWidgetLayout);
// QmitkNavigationToolBar* toolBar = new QmitkNavigationToolBar();
// QmitkStdMultiWidgetLayout->addWidget( toolBar );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter( m_LayoutSplit );
m_SubSplit2 = new QSplitter( m_LayoutSplit );
//creae Widget Container
mitkWidget1Container = new QWidget(m_SubSplit1);
mitkWidget2Container = new QWidget(m_SubSplit1);
mitkWidget3Container = new QWidget(m_SubSplit2);
mitkWidget4Container = new QWidget(m_SubSplit2);
mitkWidget1Container->setContentsMargins(0,0,0,0);
mitkWidget2Container->setContentsMargins(0,0,0,0);
mitkWidget3Container->setContentsMargins(0,0,0,0);
mitkWidget4Container->setContentsMargins(0,0,0,0);
//create Widget Layout
QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container);
QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container);
QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container);
QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container);
mitkWidgetLayout1->setMargin(0);
mitkWidgetLayout2->setMargin(0);
mitkWidgetLayout3->setMargin(0);
mitkWidgetLayout4->setMargin(0);
//set Layout to Widget Container
mitkWidget1Container->setLayout(mitkWidgetLayout1);
mitkWidget2Container->setLayout(mitkWidgetLayout2);
mitkWidget3Container->setLayout(mitkWidgetLayout3);
mitkWidget4Container->setLayout(mitkWidgetLayout4);
//set SizePolicy
mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
//insert Widget Container into the splitters
m_SubSplit1->addWidget( mitkWidget1Container );
m_SubSplit1->addWidget( mitkWidget2Container );
m_SubSplit2->addWidget( mitkWidget3Container );
m_SubSplit2->addWidget( mitkWidget4Container );
// m_RenderingManager->SetGlobalInteraction( mitk::GlobalInteraction::GetInstance() );
//Create RenderWindows 1
mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, "stdmulti.widget1", NULL, m_RenderingManager);
mitkWidget1->setMaximumSize(2000,2000);
mitkWidget1->SetLayoutIndex( AXIAL );
mitkWidgetLayout1->addWidget(mitkWidget1);
//Create RenderWindows 2
mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, "stdmulti.widget2", NULL, m_RenderingManager);
mitkWidget2->setMaximumSize(2000,2000);
mitkWidget2->setEnabled( TRUE );
mitkWidget2->SetLayoutIndex( SAGITTAL );
mitkWidgetLayout2->addWidget(mitkWidget2);
//Create RenderWindows 3
mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, "stdmulti.widget3", NULL, m_RenderingManager);
mitkWidget3->setMaximumSize(2000,2000);
mitkWidget3->SetLayoutIndex( CORONAL );
mitkWidgetLayout3->addWidget(mitkWidget3);
//Create RenderWindows 4
mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, "stdmulti.widget4", NULL, m_RenderingManager);
mitkWidget4->setMaximumSize(2000,2000);
mitkWidget4->SetLayoutIndex( THREE_D );
mitkWidgetLayout4->addWidget(mitkWidget4);
//create SignalSlot Connection
connect( mitkWidget1, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
connect( mitkWidget1, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
connect( mitkWidget1, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int)) );
connect( mitkWidget2, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
connect( mitkWidget2, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
connect( mitkWidget2, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int)) );
connect( mitkWidget3, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
connect( mitkWidget3, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
connect( mitkWidget3, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int)) );
connect( mitkWidget4, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
connect( mitkWidget4, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
connect( mitkWidget4, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int)) );
//Create Level Window Widget
levelWindowWidget = new QmitkLevelWindowWidget( m_MainSplit ); //this
levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
sizePolicy.setHorizontalStretch(0);
sizePolicy.setVerticalStretch(0);
sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth());
levelWindowWidget->setSizePolicy(sizePolicy);
levelWindowWidget->setMaximumSize(QSize(50, 2000));
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//show mainSplitt and add to Layout
m_MainSplit->show();
//resize Image.
this->resize( QSize(364, 477).expandedTo(minimumSizeHint()) );
//Initialize the widgets.
this->InitializeWidget();
//Activate Widget Menu
this->ActivateMenuWidget( true );
}
void QmitkStdMultiWidget::InitializeWidget()
{
m_PositionTracker = NULL;
// transfer colors in WorldGeometry-Nodes of the associated Renderer
QColor qcolor;
//float color[3] = {1.0f,1.0f,1.0f};
mitk::DataNode::Pointer planeNode;
mitk::IntProperty::Pointer layer;
// of widget 1
planeNode = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
planeNode->SetColor(1.0,0.0,0.0);
layer = mitk::IntProperty::New(1000);
planeNode->SetProperty("layer",layer);
// ... of widget 2
planeNode = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
planeNode->SetColor(0.0,1.0,0.0);
layer = mitk::IntProperty::New(1000);
planeNode->SetProperty("layer",layer);
// ... of widget 3
planeNode = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
planeNode->SetColor(0.0,0.0,1.0);
layer = mitk::IntProperty::New(1000);
planeNode->SetProperty("layer",layer);
// ... of widget 4
planeNode = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
planeNode->SetColor(1.0,1.0,0.0);
layer = mitk::IntProperty::New(1000);
planeNode->SetProperty("layer",layer);
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
// Set plane mode (slicing/rotation behavior) to slicing (default)
m_PlaneMode = PLANE_MODE_SLICING;
// Set default view directions for SNCs
mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(
mitk::SliceNavigationController::Axial );
mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(
mitk::SliceNavigationController::Sagittal );
mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(
mitk::SliceNavigationController::Frontal );
mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(
mitk::SliceNavigationController::Original );
/*************************************************/
//Write Layout Names into the viewers -- hardCoded
//Info for later:
//int view = this->GetRenderWindow1()->GetSliceNavigationController()->GetDefaultViewDirection();
//QString layoutName;
//if( view == mitk::SliceNavigationController::Axial )
// layoutName = "Axial";
//else if( view == mitk::SliceNavigationController::Sagittal )
// layoutName = "Sagittal";
//else if( view == mitk::SliceNavigationController::Frontal )
// layoutName = "Coronal";
//else if( view == mitk::SliceNavigationController::Original )
// layoutName = "Original";
//if( view >= 0 && view < 4 )
// //write LayoutName --> Viewer 3D shoudn't write the layoutName.
//Render Window 1 == axial
m_CornerAnnotaions[0].cornerText = vtkCornerAnnotation::New();
m_CornerAnnotaions[0].cornerText->SetText(0, "Axial");
m_CornerAnnotaions[0].cornerText->SetMaximumFontSize(12);
m_CornerAnnotaions[0].textProp = vtkTextProperty::New();
m_CornerAnnotaions[0].textProp->SetColor( 1.0, 0.0, 0.0 );
m_CornerAnnotaions[0].cornerText->SetTextProperty( m_CornerAnnotaions[0].textProp );
m_CornerAnnotaions[0].ren = vtkRenderer::New();
m_CornerAnnotaions[0].ren->AddActor(m_CornerAnnotaions[0].cornerText);
m_CornerAnnotaions[0].ren->InteractiveOff();
mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[0].ren,true);
//Render Window 2 == sagittal
m_CornerAnnotaions[1].cornerText = vtkCornerAnnotation::New();
m_CornerAnnotaions[1].cornerText->SetText(0, "Sagittal");
m_CornerAnnotaions[1].cornerText->SetMaximumFontSize(12);
m_CornerAnnotaions[1].textProp = vtkTextProperty::New();
m_CornerAnnotaions[1].textProp->SetColor( 0.0, 1.0, 0.0 );
m_CornerAnnotaions[1].cornerText->SetTextProperty( m_CornerAnnotaions[1].textProp );
m_CornerAnnotaions[1].ren = vtkRenderer::New();
m_CornerAnnotaions[1].ren->AddActor(m_CornerAnnotaions[1].cornerText);
m_CornerAnnotaions[1].ren->InteractiveOff();
mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[1].ren,true);
//Render Window 3 == coronal
m_CornerAnnotaions[2].cornerText = vtkCornerAnnotation::New();
m_CornerAnnotaions[2].cornerText->SetText(0, "Coronal");
m_CornerAnnotaions[2].cornerText->SetMaximumFontSize(12);
m_CornerAnnotaions[2].textProp = vtkTextProperty::New();
m_CornerAnnotaions[2].textProp->SetColor( 0.295, 0.295, 1.0 );
m_CornerAnnotaions[2].cornerText->SetTextProperty( m_CornerAnnotaions[2].textProp );
m_CornerAnnotaions[2].ren = vtkRenderer::New();
m_CornerAnnotaions[2].ren->AddActor(m_CornerAnnotaions[2].cornerText);
m_CornerAnnotaions[2].ren->InteractiveOff();
mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[2].ren,true);
/*************************************************/
// create a slice rotator
// m_SlicesRotator = mitk::SlicesRotator::New();
// @TODO next line causes sure memory leak
// rotator will be created nonetheless (will be switched on and off)
m_SlicesRotator = mitk::SlicesRotator::New("slices-rotator");
m_SlicesRotator->AddSliceController(
mitkWidget1->GetSliceNavigationController() );
m_SlicesRotator->AddSliceController(
mitkWidget2->GetSliceNavigationController() );
m_SlicesRotator->AddSliceController(
mitkWidget3->GetSliceNavigationController() );
// create a slice swiveller (using the same state-machine as SlicesRotator)
m_SlicesSwiveller = mitk::SlicesSwiveller::New("slices-rotator");
m_SlicesSwiveller->AddSliceController(
mitkWidget1->GetSliceNavigationController() );
m_SlicesSwiveller->AddSliceController(
mitkWidget2->GetSliceNavigationController() );
m_SlicesSwiveller->AddSliceController(
mitkWidget3->GetSliceNavigationController() );
//connect to the "time navigation controller": send time via sliceNavigationControllers
m_TimeNavigationController->ConnectGeometryTimeEvent(
mitkWidget1->GetSliceNavigationController() , false);
m_TimeNavigationController->ConnectGeometryTimeEvent(
mitkWidget2->GetSliceNavigationController() , false);
m_TimeNavigationController->ConnectGeometryTimeEvent(
mitkWidget3->GetSliceNavigationController() , false);
m_TimeNavigationController->ConnectGeometryTimeEvent(
mitkWidget4->GetSliceNavigationController() , false);
mitkWidget1->GetSliceNavigationController()
->ConnectGeometrySendEvent(mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
//reverse connection between sliceNavigationControllers and m_TimeNavigationController
mitkWidget1->GetSliceNavigationController()
->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget2->GetSliceNavigationController()
->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget3->GetSliceNavigationController()
->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget4->GetSliceNavigationController()
->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
m_MouseModeSwitcher = mitk::MouseModeSwitcher::New();
m_LastLeftClickPositionSupplier =
mitk::CoordinateSupplier::New("navigation", NULL);
mitk::GlobalInteraction::GetInstance()->AddListener(
m_LastLeftClickPositionSupplier
);
// setup gradient background
m_GradientBackground1 = mitk::GradientBackground::New();
m_GradientBackground1->SetRenderWindow(
mitkWidget1->GetRenderWindow() );
m_GradientBackground1->Disable();
m_GradientBackground2 = mitk::GradientBackground::New();
m_GradientBackground2->SetRenderWindow(
mitkWidget2->GetRenderWindow() );
m_GradientBackground2->Disable();
m_GradientBackground3 = mitk::GradientBackground::New();
m_GradientBackground3->SetRenderWindow(
mitkWidget3->GetRenderWindow() );
m_GradientBackground3->Disable();
m_GradientBackground4 = mitk::GradientBackground::New();
m_GradientBackground4->SetRenderWindow(
mitkWidget4->GetRenderWindow() );
m_GradientBackground4->SetGradientColors(0.1,0.1,0.1,0.5,0.5,0.5);
m_GradientBackground4->Enable();
// setup the department logo rendering
m_LogoRendering1 = mitk::ManufacturerLogo::New();
m_LogoRendering1->SetRenderWindow(
mitkWidget1->GetRenderWindow() );
m_LogoRendering1->Disable();
m_LogoRendering2 = mitk::ManufacturerLogo::New();
m_LogoRendering2->SetRenderWindow(
mitkWidget2->GetRenderWindow() );
m_LogoRendering2->Disable();
m_LogoRendering3 = mitk::ManufacturerLogo::New();
m_LogoRendering3->SetRenderWindow(
mitkWidget3->GetRenderWindow() );
m_LogoRendering3->Disable();
m_LogoRendering4 = mitk::ManufacturerLogo::New();
m_LogoRendering4->SetRenderWindow(
mitkWidget4->GetRenderWindow() );
m_LogoRendering4->Enable();
m_RectangleRendering1 = mitk::RenderWindowFrame::New();
m_RectangleRendering1->SetRenderWindow(
mitkWidget1->GetRenderWindow() );
m_RectangleRendering1->Enable(1.0,0.0,0.0);
m_RectangleRendering2 = mitk::RenderWindowFrame::New();
m_RectangleRendering2->SetRenderWindow(
mitkWidget2->GetRenderWindow() );
m_RectangleRendering2->Enable(0.0,1.0,0.0);
m_RectangleRendering3 = mitk::RenderWindowFrame::New();
m_RectangleRendering3->SetRenderWindow(
mitkWidget3->GetRenderWindow() );
m_RectangleRendering3->Enable(0.0,0.0,1.0);
m_RectangleRendering4 = mitk::RenderWindowFrame::New();
m_RectangleRendering4->SetRenderWindow(
mitkWidget4->GetRenderWindow() );
m_RectangleRendering4->Enable(1.0,1.0,0.0);
}
QmitkStdMultiWidget::~QmitkStdMultiWidget()
{
DisablePositionTracking();
DisableNavigationControllerEventListening();
m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController());
mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[0].ren );
mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[1].ren );
mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[2].ren );
//Delete CornerAnnotation
m_CornerAnnotaions[0].cornerText->Delete();
m_CornerAnnotaions[0].textProp->Delete();
m_CornerAnnotaions[0].ren->Delete();
m_CornerAnnotaions[1].cornerText->Delete();
m_CornerAnnotaions[1].textProp->Delete();
m_CornerAnnotaions[1].ren->Delete();
m_CornerAnnotaions[2].cornerText->Delete();
m_CornerAnnotaions[2].textProp->Delete();
m_CornerAnnotaions[2].ren->Delete();
}
void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
{
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
{
if(m_DataStorage.IsNotNull())
{
m_DataStorage->Remove(m_PlaneNode1);
m_DataStorage->Remove(m_PlaneNode2);
m_DataStorage->Remove(m_PlaneNode3);
m_DataStorage->Remove(m_Node);
}
}
}
void QmitkStdMultiWidget::AddPlanesToDataStorage()
{
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
{
if (m_DataStorage.IsNotNull())
{
m_DataStorage->Add(m_Node);
m_DataStorage->Add(m_PlaneNode1, m_Node);
m_DataStorage->Add(m_PlaneNode2, m_Node);
m_DataStorage->Add(m_PlaneNode3, m_Node);
static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode1->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode2->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode3->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
}
}
}
void QmitkStdMultiWidget::changeLayoutTo2DImagesUp()
{
SMW_INFO << "changing layout to 2D images up... " << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//Set Layout to widget
this->setLayout(QmitkStdMultiWidgetLayout);
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter( m_LayoutSplit );
m_SubSplit2 = new QSplitter( m_LayoutSplit );
//insert Widget Container into splitter top
m_SubSplit1->addWidget( mitkWidget1Container );
m_SubSplit1->addWidget( mitkWidget2Container );
m_SubSplit1->addWidget( mitkWidget3Container );
//set SplitterSize for splitter top
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes( splitterSize );
//insert Widget Container into splitter bottom
m_SubSplit2->addWidget( mitkWidget4Container );
//set SplitterSize for splitter m_LayoutSplit
splitterSize.clear();
splitterSize.push_back(400);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes( splitterSize );
//show mainSplitt
m_MainSplit->show();
//show Widget if hidden
if ( mitkWidget1->isHidden() ) mitkWidget1->show();
if ( mitkWidget2->isHidden() ) mitkWidget2->show();
if ( mitkWidget3->isHidden() ) mitkWidget3->show();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
//Change Layout Name
m_Layout = LAYOUT_2D_IMAGES_UP;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft()
{
SMW_INFO << "changing layout to 2D images left... " << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
m_SubSplit2 = new QSplitter( m_LayoutSplit );
//insert Widget into the splitters
m_SubSplit1->addWidget( mitkWidget1Container );
m_SubSplit1->addWidget( mitkWidget2Container );
m_SubSplit1->addWidget( mitkWidget3Container );
//set splitterSize of SubSplit1
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes( splitterSize );
m_SubSplit2->addWidget( mitkWidget4Container );
//set splitterSize of Layout Split
splitterSize.clear();
splitterSize.push_back(400);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes( splitterSize );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show Widget if hidden
if ( mitkWidget1->isHidden() ) mitkWidget1->show();
if ( mitkWidget2->isHidden() ) mitkWidget2->show();
if ( mitkWidget3->isHidden() ) mitkWidget3->show();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
//update Layout Name
m_Layout = LAYOUT_2D_IMAGES_LEFT;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToDefault()
{
SMW_INFO << "changing layout to default... " << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter( m_LayoutSplit );
m_SubSplit2 = new QSplitter( m_LayoutSplit );
//insert Widget container into the splitters
m_SubSplit1->addWidget( mitkWidget1Container );
m_SubSplit1->addWidget( mitkWidget2Container );
m_SubSplit2->addWidget( mitkWidget3Container );
m_SubSplit2->addWidget( mitkWidget4Container );
//set splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes( splitterSize );
m_SubSplit2->setSizes( splitterSize );
m_LayoutSplit->setSizes( splitterSize );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show Widget if hidden
if ( mitkWidget1->isHidden() ) mitkWidget1->show();
if ( mitkWidget2->isHidden() ) mitkWidget2->show();
if ( mitkWidget3->isHidden() ) mitkWidget3->show();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
m_Layout = LAYOUT_DEFAULT;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_DEFAULT );
mitkWidget2->LayoutDesignListChanged( LAYOUT_DEFAULT );
mitkWidget3->LayoutDesignListChanged( LAYOUT_DEFAULT );
mitkWidget4->LayoutDesignListChanged( LAYOUT_DEFAULT );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToBig3D()
{
SMW_INFO << "changing layout to big 3D ..." << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//add widget Splitter to main Splitter
m_MainSplit->addWidget( mitkWidget4Container );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
mitkWidget3->hide();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
m_Layout = LAYOUT_BIG_3D;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_BIG_3D );
mitkWidget2->LayoutDesignListChanged( LAYOUT_BIG_3D );
mitkWidget3->LayoutDesignListChanged( LAYOUT_BIG_3D );
mitkWidget4->LayoutDesignListChanged( LAYOUT_BIG_3D );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToWidget1()
{
SMW_INFO << "changing layout to big Widget1 ..." << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//add widget Splitter to main Splitter
m_MainSplit->addWidget( mitkWidget1Container );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show/hide Widgets
if ( mitkWidget1->isHidden() ) mitkWidget1->show();
mitkWidget2->hide();
mitkWidget3->hide();
mitkWidget4->hide();
m_Layout = LAYOUT_WIDGET1;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET1 );
mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET1 );
mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET1 );
mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET1 );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToWidget2()
{
SMW_INFO << "changing layout to big Widget2 ..." << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//add widget Splitter to main Splitter
m_MainSplit->addWidget( mitkWidget2Container );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show/hide Widgets
mitkWidget1->hide();
if ( mitkWidget2->isHidden() ) mitkWidget2->show();
mitkWidget3->hide();
mitkWidget4->hide();
m_Layout = LAYOUT_WIDGET2;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET2 );
mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET2 );
mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET2 );
mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET2 );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToWidget3()
{
SMW_INFO << "changing layout to big Widget3 ..." << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//add widget Splitter to main Splitter
m_MainSplit->addWidget( mitkWidget3Container );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
if ( mitkWidget3->isHidden() ) mitkWidget3->show();
mitkWidget4->hide();
m_Layout = LAYOUT_WIDGET3;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET3 );
mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET3 );
mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET3 );
mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET3 );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToRowWidget3And4()
{
SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//add Widgets to splitter
m_LayoutSplit->addWidget( mitkWidget3Container );
m_LayoutSplit->addWidget( mitkWidget4Container );
//set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes( splitterSize );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
if ( mitkWidget3->isHidden() ) mitkWidget3->show();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
m_Layout = LAYOUT_ROW_WIDGET_3_AND_4;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
mitkWidget2->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
mitkWidget3->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
mitkWidget4->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4()
{
SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//add Widgets to splitter
m_LayoutSplit->addWidget( mitkWidget3Container );
m_LayoutSplit->addWidget( mitkWidget4Container );
//set SplitterSize
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes( splitterSize );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
if ( mitkWidget3->isHidden() ) mitkWidget3->show();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
mitkWidget2->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
mitkWidget3->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
mitkWidget4->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4()
{
SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
this->changeLayoutToRowWidget3And4();
m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4;
}
void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4()
{
SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
m_SubSplit2 = new QSplitter( m_LayoutSplit );
//insert Widget into the splitters
m_SubSplit1->addWidget( mitkWidget2Container );
m_SubSplit2->addWidget( mitkWidget3Container );
m_SubSplit2->addWidget( mitkWidget4Container );
//set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit2->setSizes( splitterSize );
splitterSize.clear();
splitterSize.push_back(500);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes( splitterSize );
//show mainSplitt
m_MainSplit->show();
//show Widget if hidden
mitkWidget1->hide();
if ( mitkWidget2->isHidden() ) mitkWidget2->show();
if ( mitkWidget3->isHidden() ) mitkWidget3->show();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
mitkWidget2->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
mitkWidget3->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
mitkWidget4->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget()
{
SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
m_SubSplit2 = new QSplitter( m_LayoutSplit );
//add Widgets to splitter
m_SubSplit1->addWidget( mitkWidget1Container );
m_SubSplit1->addWidget( mitkWidget2Container );
m_SubSplit2->addWidget( mitkWidget4Container );
//set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes( splitterSize );
m_LayoutSplit->setSizes( splitterSize );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show/hide Widgets
if ( mitkWidget1->isHidden() ) mitkWidget1->show();
if ( mitkWidget2->isHidden() ) mitkWidget2->show();
mitkWidget3->hide();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
mitkWidget2->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
mitkWidget3->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
mitkWidget4->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D()
{
SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
m_SubSplit2 = new QSplitter( m_LayoutSplit );
//add Widgets to splitter
m_SubSplit1->addWidget( mitkWidget1Container );
m_SubSplit1->addWidget( mitkWidget4Container );
m_SubSplit2->addWidget( mitkWidget2Container );
//set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes( splitterSize );
m_LayoutSplit->setSizes( splitterSize );
//show mainSplitt and add to Layout
m_MainSplit->show();
//show/hide Widgets
if ( mitkWidget1->isHidden() ) mitkWidget1->show();
if ( mitkWidget2->isHidden() ) mitkWidget2->show();
mitkWidget3->hide();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
//update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown()
{
SMW_INFO << "changing layout to 2D up and 3D down" << std::endl;
//Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout ;
//create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
//Set Layout to widget
this->setLayout(QmitkStdMultiWidgetLayout);
//create main splitter
m_MainSplit = new QSplitter( this );
QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
//create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
m_MainSplit->addWidget( m_LayoutSplit );
//add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget( levelWindowWidget );
//create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter( m_LayoutSplit );
m_SubSplit2 = new QSplitter( m_LayoutSplit );
//insert Widget Container into splitter top
m_SubSplit1->addWidget( mitkWidget1Container );
//set SplitterSize for splitter top
QList<int> splitterSize;
// splitterSize.push_back(1000);
// splitterSize.push_back(1000);
// splitterSize.push_back(1000);
// m_SubSplit1->setSizes( splitterSize );
//insert Widget Container into splitter bottom
m_SubSplit2->addWidget( mitkWidget4Container );
//set SplitterSize for splitter m_LayoutSplit
splitterSize.clear();
splitterSize.push_back(700);
splitterSize.push_back(700);
m_LayoutSplit->setSizes( splitterSize );
//show mainSplitt
m_MainSplit->show();
//show/hide Widgets
if ( mitkWidget1->isHidden() ) mitkWidget1->show();
mitkWidget2->hide();
mitkWidget3->hide();
if ( mitkWidget4->isHidden() ) mitkWidget4->show();
m_Layout = LAYOUT_2D_UP_AND_3D_DOWN;
//update Layout Design List
mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
//update all Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::SetDataStorage( mitk::DataStorage* ds )
{
mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds);
mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds);
mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds);
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds);
m_DataStorage = ds;
}
void QmitkStdMultiWidget::Fit()
{
vtkRenderer * vtkrenderer;
mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDisplayGeometry()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetDisplayGeometry()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetDisplayGeometry()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetDisplayGeometry()->Fit();
int w = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer();
if ( vtkrenderer!= NULL )
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer();
if ( vtkrenderer!= NULL )
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer();
if ( vtkrenderer!= NULL )
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer();
if ( vtkrenderer!= NULL )
vtkrenderer->ResetCamera();
vtkObject::SetGlobalWarningDisplay(w);
}
void QmitkStdMultiWidget::InitPositionTracking()
{
//PoinSetNode for MouseOrientation
m_PositionTrackerNode = mitk::DataNode::New();
m_PositionTrackerNode->SetProperty("name", mitk::StringProperty::New("Mouse Position"));
m_PositionTrackerNode->SetData( mitk::PointSet::New() );
m_PositionTrackerNode->SetColor(1.0,0.33,0.0);
m_PositionTrackerNode->SetProperty("layer", mitk::IntProperty::New(1001));
m_PositionTrackerNode->SetVisibility(true);
m_PositionTrackerNode->SetProperty("inputdevice", mitk::BoolProperty::New(true) );
m_PositionTrackerNode->SetProperty("BaseRendererMapperID", mitk::IntProperty::New(0) );//point position 2D mouse
m_PositionTrackerNode->SetProperty("baserenderer", mitk::StringProperty::New("N/A"));
}
void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
{
// add the displayed planes of the multiwidget to a node to which the subtree
// @a planesSubTree points ...
float white[3] = {1.0f,1.0f,1.0f};
mitk::Geometry2DDataMapper2D::Pointer mapper;
// ... of widget 1
m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("name", mitk::StringProperty::New("widget1Plane"));
m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::Geometry2DDataMapper2D::New();
m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 2
m_PlaneNode2 =( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("name", mitk::StringProperty::New("widget2Plane"));
m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::Geometry2DDataMapper2D::New();
m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 3
m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("name", mitk::StringProperty::New("widget3Plane"));
m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::Geometry2DDataMapper2D::New();
m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
m_Node = mitk::DataNode::New();
m_Node->SetProperty("name", mitk::StringProperty::New("Widgets"));
m_Node->SetProperty("helper object", mitk::BoolProperty::New(true));
}
mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
{
return m_TimeNavigationController;
}
void QmitkStdMultiWidget::EnableStandardLevelWindow()
{
levelWindowWidget->disconnect(this);
levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage());
levelWindowWidget->show();
}
void QmitkStdMultiWidget::DisableStandardLevelWindow()
{
levelWindowWidget->disconnect(this);
levelWindowWidget->hide();
}
// CAUTION: Legacy code for enabling Qt-signal-controlled view initialization.
// Use RenderingManager::InitializeViews() instead.
bool QmitkStdMultiWidget::InitializeStandardViews( const mitk::Geometry3D * geometry )
{
return m_RenderingManager->InitializeViews( geometry );
}
void QmitkStdMultiWidget::RequestUpdate()
{
m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow());
m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow());
m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow());
m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow());
}
void QmitkStdMultiWidget::ForceImmediateUpdate()
{
m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow());
m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow());
m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow());
m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow());
}
void QmitkStdMultiWidget::wheelEvent( QWheelEvent * e )
{
emit WheelMoved( e );
}
void QmitkStdMultiWidget::mousePressEvent(QMouseEvent * e)
{
if (e->button() == Qt::LeftButton) {
mitk::Point3D pointValue = this->GetLastLeftClickPosition();
emit LeftMouseClicked(pointValue);
}
}
void QmitkStdMultiWidget::moveEvent( QMoveEvent* e )
{
QWidget::moveEvent( e );
// it is necessary to readjust the position of the overlays as the StdMultiWidget has moved
// unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
emit Moved();
}
void QmitkStdMultiWidget::leaveEvent ( QEvent * /*e*/ )
{
//set cursor back to initial state
m_SlicesRotator->ResetMouseCursor();
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
{
return mitkWidget1;
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
{
return mitkWidget2;
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
{
return mitkWidget3;
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
{
return mitkWidget4;
}
const mitk::Point3D& QmitkStdMultiWidget::GetLastLeftClickPosition() const
{
return m_LastLeftClickPositionSupplier->GetCurrentPoint();
}
const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const
{
const mitk::PlaneGeometry *plane1 =
mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry *plane2 =
mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry *plane3 =
mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
mitk::Line3D line;
if ( (plane1 != NULL) && (plane2 != NULL)
&& (plane1->IntersectionLine( plane2, line )) )
{
mitk::Point3D point;
if ( (plane3 != NULL)
&& (plane3->IntersectionPoint( line, point )) )
{
return point;
}
}
return m_LastLeftClickPositionSupplier->GetCurrentPoint();
}
void QmitkStdMultiWidget::EnablePositionTracking()
{
if (!m_PositionTracker)
{
m_PositionTracker = mitk::PositionTracker::New("PositionTracker", NULL);
}
mitk::GlobalInteraction* globalInteraction = mitk::GlobalInteraction::GetInstance();
if (globalInteraction)
{
if(m_DataStorage.IsNotNull())
m_DataStorage->Add(m_PositionTrackerNode);
globalInteraction->AddListener(m_PositionTracker);
}
}
void QmitkStdMultiWidget::DisablePositionTracking()
{
mitk::GlobalInteraction* globalInteraction =
mitk::GlobalInteraction::GetInstance();
if(globalInteraction)
{
if (m_DataStorage.IsNotNull())
m_DataStorage->Remove(m_PositionTrackerNode);
globalInteraction->RemoveListener(m_PositionTracker);
}
}
void QmitkStdMultiWidget::EnsureDisplayContainsPoint(
mitk::DisplayGeometry* displayGeometry, const mitk::Point3D& p)
{
mitk::Point2D pointOnPlane;
displayGeometry->Map( p, pointOnPlane );
// point minus origin < width or height ==> outside ?
mitk::Vector2D pointOnRenderWindow_MM;
pointOnRenderWindow_MM = pointOnPlane.GetVectorFromOrigin()
- displayGeometry->GetOriginInMM();
mitk::Vector2D sizeOfDisplay( displayGeometry->GetSizeInMM() );
if ( sizeOfDisplay[0] < pointOnRenderWindow_MM[0]
|| 0 > pointOnRenderWindow_MM[0]
|| sizeOfDisplay[1] < pointOnRenderWindow_MM[1]
|| 0 > pointOnRenderWindow_MM[1] )
{
// point is not visible -> move geometry
mitk::Vector2D offset( (pointOnRenderWindow_MM - sizeOfDisplay / 2.0)
/ displayGeometry->GetScaleFactorMMPerDisplayUnit() );
displayGeometry->MoveBy( offset );
}
}
void QmitkStdMultiWidget::MoveCrossToPosition(const mitk::Point3D& newPosition)
{
// create a PositionEvent with the given position and
// tell the slice navigation controllers to move there
mitk::Point2D p2d;
mitk::PositionEvent event( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()), 0, 0, 0,
mitk::Key_unknown, p2d, newPosition );
mitk::StateEvent stateEvent(mitk::EIDLEFTMOUSEBTN, &event);
mitk::StateEvent stateEvent2(mitk::EIDLEFTMOUSERELEASE, &event);
switch ( m_PlaneMode )
{
default:
case PLANE_MODE_SLICING:
mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent );
mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent );
mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent );
// just in case SNCs will develop something that depends on the mouse
// button being released again
mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
break;
case PLANE_MODE_ROTATION:
m_SlicesRotator->HandleEvent( &stateEvent );
// just in case SNCs will develop something that depends on the mouse
// button being released again
m_SlicesRotator->HandleEvent( &stateEvent2 );
break;
case PLANE_MODE_SWIVEL:
m_SlicesSwiveller->HandleEvent( &stateEvent );
// just in case SNCs will develop something that depends on the mouse
// button being released again
m_SlicesSwiveller->HandleEvent( &stateEvent2 );
break;
}
// determine if cross is now out of display
// if so, move the display window
EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())
->GetDisplayGeometry(), newPosition );
EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())
->GetDisplayGeometry(), newPosition );
EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())
->GetDisplayGeometry(), newPosition );
// update displays
m_RenderingManager->RequestUpdateAll();
}
void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
{
if(!m_PendingCrosshairPositionEvent)
{
m_PendingCrosshairPositionEvent=true;
QTimer::singleShot(0,this,SLOT( HandleCrosshairPositionEventDelayed() ) );
}
}
-void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
+mitk::DataNode::Pointer QmitkStdMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
{
- m_PendingCrosshairPositionEvent = false;
-
- // find image with highest layer
mitk::Point3D crosshairPos = this->GetCrossPosition();
-
- mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
-
- mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
- std::string statusText;
- mitk::Image::Pointer image;
+ mitk::DataNode::Pointer node;
int maxlayer = -32768;
- mitk::BaseRenderer* baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
- // find image with largest layer, that is the image shown on top in the render window
- for (unsigned int x = 0; x < nodes->size(); x++)
+ if(nodes.IsNotNull())
{
+ mitk::BaseRenderer* baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
+ // find node with largest layer, that is the node shown on top in the render window
+ for (unsigned int x = 0; x < nodes->size(); x++)
+ {
if ( (nodes->at(x)->GetData()->GetGeometry() != NULL) &&
nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos) )
{
int layer = 0;
if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
if(layer > maxlayer)
{
if( static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible( baseRenderer ) )
{
- image = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
+ node = nodes->at(x);
maxlayer = layer;
}
}
}
+ }
}
+ return node;
+}
- std::stringstream stream;
+void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
+{
+ m_PendingCrosshairPositionEvent = false;
+
+ // find image with highest layer
+
+ mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
+ mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
+ mitk::DataNode::Pointer node;
+ mitk::DataNode::Pointer topSourceNode;
+ mitk::Image::Pointer image;
+ bool isBinary = false;
+ node = this->GetTopLayerNode(nodes);
+ if(node.IsNotNull())
+ {
+ node->GetBoolProperty("binary",isBinary);
+ if(isBinary)
+ {
+ mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = m_DataStorage->GetSources(node, NULL, true);
+ if(!sourcenodes->empty())
+ {
+ topSourceNode = this->GetTopLayerNode(sourcenodes);
+ }
+ if(topSourceNode.IsNotNull())
+ {
+ image = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
+ }
+ else
+ {
+ image = dynamic_cast<mitk::Image*>(node->GetData());
+ }
+ }
+ else
+ {
+ image = dynamic_cast<mitk::Image*>(node->GetData());
+ }
+ }
+
+ mitk::Point3D crosshairPos = this->GetCrossPosition();
+ std::string statusText;
+ std::stringstream stream;
mitk::Index3D p;
+ mitk::BaseRenderer* baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
int timestep = baseRenderer->GetTimeStep();
if(image.IsNotNull() && (image->GetTimeSteps() > timestep ))
{
image->GetGeometry()->WorldToIndex(crosshairPos, p);
stream.precision(2);
stream<<"Position: <" << std::fixed <<crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", " << std::fixed << crosshairPos[2] << "> mm";
stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
mitk::ScalarType pixelValue = image->GetPixelValueByIndex(p, timestep);
if (fabs(pixelValue)>1000000 || fabs(pixelValue) < 0.01)
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< std::scientific<< pixelValue <<" ";
}
else
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< pixelValue <<" ";
}
}
else
{
stream << "No image information at this position!";
}
statusText = stream.str();
mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
}
void QmitkStdMultiWidget::EnableNavigationControllerEventListening()
{
// Let NavigationControllers listen to GlobalInteraction
mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
// Listen for SliceNavigationController
mitkWidget1->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
mitkWidget2->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
mitkWidget3->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
switch ( m_PlaneMode )
{
default:
case PLANE_MODE_SLICING:
gi->AddListener( mitkWidget1->GetSliceNavigationController() );
gi->AddListener( mitkWidget2->GetSliceNavigationController() );
gi->AddListener( mitkWidget3->GetSliceNavigationController() );
gi->AddListener( mitkWidget4->GetSliceNavigationController() );
break;
case PLANE_MODE_ROTATION:
gi->AddListener( m_SlicesRotator );
break;
case PLANE_MODE_SWIVEL:
gi->AddListener( m_SlicesSwiveller );
break;
}
gi->AddListener( m_TimeNavigationController );
m_CrosshairNavigationEnabled = true;
}
void QmitkStdMultiWidget::DisableNavigationControllerEventListening()
{
// Do not let NavigationControllers listen to GlobalInteraction
mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
switch ( m_PlaneMode )
{
default:
case PLANE_MODE_SLICING:
gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
break;
case PLANE_MODE_ROTATION:
m_SlicesRotator->ResetMouseCursor();
gi->RemoveListener( m_SlicesRotator );
break;
case PLANE_MODE_SWIVEL:
m_SlicesSwiveller->ResetMouseCursor();
gi->RemoveListener( m_SlicesSwiveller );
break;
}
gi->RemoveListener( m_TimeNavigationController );
m_CrosshairNavigationEnabled = false;
}
int QmitkStdMultiWidget::GetLayout() const
{
return m_Layout;
}
bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const
{
return m_GradientBackgroundFlag;
}
void QmitkStdMultiWidget::EnableGradientBackground()
{
// gradient background is by default only in widget 4, otherwise
// interferences between 2D rendering and VTK rendering may occur.
//m_GradientBackground1->Enable();
//m_GradientBackground2->Enable();
//m_GradientBackground3->Enable();
m_GradientBackground4->Enable();
m_GradientBackgroundFlag = true;
}
void QmitkStdMultiWidget::DisableGradientBackground()
{
//m_GradientBackground1->Disable();
//m_GradientBackground2->Disable();
//m_GradientBackground3->Disable();
m_GradientBackground4->Disable();
m_GradientBackgroundFlag = false;
}
void QmitkStdMultiWidget::EnableDepartmentLogo()
{
m_LogoRendering4->Enable();
}
void QmitkStdMultiWidget::DisableDepartmentLogo()
{
m_LogoRendering4->Disable();
}
bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const
{
return m_LogoRendering4->IsEnabled();
}
bool QmitkStdMultiWidget::IsCrosshairNavigationEnabled() const
{
return m_CrosshairNavigationEnabled;
}
mitk::SlicesRotator * QmitkStdMultiWidget::GetSlicesRotator() const
{
return m_SlicesRotator;
}
mitk::SlicesSwiveller * QmitkStdMultiWidget::GetSlicesSwiveller() const
{
return m_SlicesSwiveller;
}
void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char* widgetName, bool visible, mitk::BaseRenderer *renderer)
{
if (m_DataStorage.IsNotNull())
{
mitk::DataNode* n = m_DataStorage->GetNamedNode(widgetName);
if (n != NULL)
n->SetVisibility(visible, renderer);
}
}
void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
{
SetWidgetPlaneVisibility("widget1Plane", visible, renderer);
SetWidgetPlaneVisibility("widget2Plane", visible, renderer);
SetWidgetPlaneVisibility("widget3Plane", visible, renderer);
m_RenderingManager->RequestUpdateAll();
}
void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
{
//do your job and lock or unlock slices.
GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
}
void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
{
//do your job and lock or unlock slices.
GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
}
void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked( bool link )
{
m_SlicesRotator->SetLinkPlanes( link );
m_SlicesSwiveller->SetLinkPlanes( link );
emit WidgetPlanesRotationLinked( link );
}
void QmitkStdMultiWidget::SetWidgetPlaneMode( int userMode )
{
MITK_DEBUG << "Changing crosshair mode to " << userMode;
// first of all reset left mouse button interaction to default if PACS interaction style is active
m_MouseModeSwitcher->SelectMouseMode( mitk::MouseModeSwitcher::MousePointer );
emit WidgetNotifyNewCrossHairMode( userMode );
int mode = m_PlaneMode;
bool link = false;
// Convert user interface mode to actual mode
{
switch(userMode)
{
case 0:
mode = PLANE_MODE_SLICING;
link = false;
break;
case 1:
mode = PLANE_MODE_ROTATION;
link = false;
break;
case 2:
mode = PLANE_MODE_ROTATION;
link = true;
break;
case 3:
mode = PLANE_MODE_SWIVEL;
link = false;
break;
}
}
// Slice rotation linked
m_SlicesRotator->SetLinkPlanes( link );
m_SlicesSwiveller->SetLinkPlanes( link );
// Do nothing if mode didn't change
if ( m_PlaneMode == mode )
{
return;
}
mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
// Remove listeners of previous mode
switch ( m_PlaneMode )
{
default:
case PLANE_MODE_SLICING:
// Notify MainTemplate GUI that this mode has been deselected
emit WidgetPlaneModeSlicing( false );
gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
break;
case PLANE_MODE_ROTATION:
// Notify MainTemplate GUI that this mode has been deselected
emit WidgetPlaneModeRotation( false );
m_SlicesRotator->ResetMouseCursor();
gi->RemoveListener( m_SlicesRotator );
break;
case PLANE_MODE_SWIVEL:
// Notify MainTemplate GUI that this mode has been deselected
emit WidgetPlaneModeSwivel( false );
m_SlicesSwiveller->ResetMouseCursor();
gi->RemoveListener( m_SlicesSwiveller );
break;
}
// Set new mode and add corresponding listener to GlobalInteraction
m_PlaneMode = mode;
switch ( m_PlaneMode )
{
default:
case PLANE_MODE_SLICING:
// Notify MainTemplate GUI that this mode has been selected
emit WidgetPlaneModeSlicing( true );
// Add listeners
gi->AddListener( mitkWidget1->GetSliceNavigationController() );
gi->AddListener( mitkWidget2->GetSliceNavigationController() );
gi->AddListener( mitkWidget3->GetSliceNavigationController() );
gi->AddListener( mitkWidget4->GetSliceNavigationController() );
m_RenderingManager->InitializeViews();
break;
case PLANE_MODE_ROTATION:
// Notify MainTemplate GUI that this mode has been selected
emit WidgetPlaneModeRotation( true );
// Add listener
gi->AddListener( m_SlicesRotator );
break;
case PLANE_MODE_SWIVEL:
// Notify MainTemplate GUI that this mode has been selected
emit WidgetPlaneModeSwivel( true );
// Add listener
gi->AddListener( m_SlicesSwiveller );
break;
}
// Notify MainTemplate GUI that mode has changed
emit WidgetPlaneModeChange(m_PlaneMode);
}
void QmitkStdMultiWidget::SetGradientBackgroundColors( const mitk::Color & upper, const mitk::Color & lower )
{
m_GradientBackground1->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
m_GradientBackground2->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
m_GradientBackground3->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
m_GradientBackground4->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
m_GradientBackgroundFlag = true;
}
void QmitkStdMultiWidget::SetDepartmentLogoPath( const char * path )
{
m_LogoRendering1->SetLogoSource(path);
m_LogoRendering2->SetLogoSource(path);
m_LogoRendering3->SetLogoSource(path);
m_LogoRendering4->SetLogoSource(path);
}
void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing( bool activate )
{
if ( activate )
{
this->SetWidgetPlaneMode( PLANE_MODE_SLICING );
}
}
void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation( bool activate )
{
if ( activate )
{
this->SetWidgetPlaneMode( PLANE_MODE_ROTATION );
}
}
void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel( bool activate )
{
if ( activate )
{
this->SetWidgetPlaneMode( PLANE_MODE_SWIVEL );
}
}
void QmitkStdMultiWidget::OnLayoutDesignChanged( int layoutDesignIndex )
{
switch( layoutDesignIndex )
{
case LAYOUT_DEFAULT:
{
this->changeLayoutToDefault();
break;
}
case LAYOUT_2D_IMAGES_UP:
{
this->changeLayoutTo2DImagesUp();
break;
}
case LAYOUT_2D_IMAGES_LEFT:
{
this->changeLayoutTo2DImagesLeft();
break;
}
case LAYOUT_BIG_3D:
{
this->changeLayoutToBig3D();
break;
}
case LAYOUT_WIDGET1:
{
this->changeLayoutToWidget1();
break;
}
case LAYOUT_WIDGET2:
{
this->changeLayoutToWidget2();
break;
}
case LAYOUT_WIDGET3:
{
this->changeLayoutToWidget3();
break;
}
case LAYOUT_2X_2D_AND_3D_WIDGET:
{
this->changeLayoutTo2x2Dand3DWidget();
break;
}
case LAYOUT_ROW_WIDGET_3_AND_4:
{
this->changeLayoutToRowWidget3And4();
break;
}
case LAYOUT_COLUMN_WIDGET_3_AND_4:
{
this->changeLayoutToColumnWidget3And4();
break;
}
case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4:
{
this->changeLayoutToRowWidgetSmall3andBig4();
break;
}
case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4:
{
this->changeLayoutToSmallUpperWidget2Big3and4();
break;
}
case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET:
{
this->changeLayoutToLeft2Dand3DRight2D();
break;
}
};
}
void QmitkStdMultiWidget::UpdateAllWidgets()
{
mitkWidget1->resize( mitkWidget1Container->frameSize().width()-1, mitkWidget1Container->frameSize().height() );
mitkWidget1->resize( mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height() );
mitkWidget2->resize( mitkWidget2Container->frameSize().width()-1, mitkWidget2Container->frameSize().height() );
mitkWidget2->resize( mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height() );
mitkWidget3->resize( mitkWidget3Container->frameSize().width()-1, mitkWidget3Container->frameSize().height() );
mitkWidget3->resize( mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height() );
mitkWidget4->resize( mitkWidget4Container->frameSize().width()-1, mitkWidget4Container->frameSize().height() );
mitkWidget4->resize( mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height() );
}
void QmitkStdMultiWidget::HideAllWidgetToolbars()
{
mitkWidget1->HideRenderWindowMenu();
mitkWidget2->HideRenderWindowMenu();
mitkWidget3->HideRenderWindowMenu();
mitkWidget4->HideRenderWindowMenu();
}
void QmitkStdMultiWidget::ActivateMenuWidget( bool state )
{
mitkWidget1->ActivateMenuWidget( state, this );
mitkWidget2->ActivateMenuWidget( state, this );
mitkWidget3->ActivateMenuWidget( state, this );
mitkWidget4->ActivateMenuWidget( state, this );
}
bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
{
return mitkWidget1->GetActivateMenuWidgetFlag();
}
void QmitkStdMultiWidget::ResetCrosshair()
{
if (m_DataStorage.IsNotNull())
{
mitk::NodePredicateNot::Pointer pred
= mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
, mitk::BoolProperty::New(false)));
mitk::NodePredicateNot::Pointer pred2
= mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
, mitk::BoolProperty::New(true)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetSubset(pred);
mitk::DataStorage::SetOfObjects::ConstPointer rs2 = m_DataStorage->GetSubset(pred2);
// calculate bounding geometry of these nodes
mitk::TimeSlicedGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible");
m_RenderingManager->InitializeViews(bounds);
//m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
// reset interactor to normal slicing
this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
}
}
void QmitkStdMultiWidget::EnableColoredRectangles()
{
m_RectangleRendering1->Enable(1.0, 0.0, 0.0);
m_RectangleRendering2->Enable(0.0, 1.0, 0.0);
m_RectangleRendering3->Enable(0.0, 0.0, 1.0);
m_RectangleRendering4->Enable(1.0, 1.0, 0.0);
}
void QmitkStdMultiWidget::DisableColoredRectangles()
{
m_RectangleRendering1->Disable();
m_RectangleRendering2->Disable();
m_RectangleRendering3->Disable();
m_RectangleRendering4->Disable();
}
bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const
{
return m_RectangleRendering1->IsEnabled();
}
mitk::MouseModeSwitcher* QmitkStdMultiWidget::GetMouseModeSwitcher()
{
return m_MouseModeSwitcher;
}
void QmitkStdMultiWidget::MouseModeSelected( mitk::MouseModeSwitcher::MouseMode mouseMode )
{
if ( mouseMode == 0 )
{
this->EnableNavigationControllerEventListening();
}
else
{
this->DisableNavigationControllerEventListening();
}
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1()
{
return this->m_PlaneNode1;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2()
{
return this->m_PlaneNode2;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3()
{
return this->m_PlaneNode3;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id)
{
switch(id)
{
case 1: return this->m_PlaneNode1;
break;
case 2: return this->m_PlaneNode2;
break;
case 3: return this->m_PlaneNode3;
break;
default: return NULL;
}
}
diff --git a/Modules/Qmitk/QmitkStdMultiWidget.h b/Modules/Qmitk/QmitkStdMultiWidget.h
index e68e3ec9d4..5acdcf65c1 100644
--- a/Modules/Qmitk/QmitkStdMultiWidget.h
+++ b/Modules/Qmitk/QmitkStdMultiWidget.h
@@ -1,360 +1,362 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QMITKSTDMULTIWIDGET_H_
#define QMITKSTDMULTIWIDGET_H_
#include <QmitkExports.h>
#include "mitkPositionTracker.h"
#include "mitkSlicesRotator.h"
#include "mitkSlicesSwiveller.h"
#include "mitkRenderWindowFrame.h"
#include "mitkManufacturerLogo.h"
#include "mitkGradientBackground.h"
#include "mitkCoordinateSupplier.h"
#include "mitkDataStorage.h"
#include "mitkMouseModeSwitcher.h"
#include <qwidget.h>
#include <qsplitter.h>
#include <QFrame>
#include <QmitkRenderWindow.h>
#include <QmitkLevelWindowWidget.h>
#include "vtkTextProperty.h"
#include "vtkCornerAnnotation.h"
class QHBoxLayout;
class QVBoxLayout;
class QGridLayout;
class QSpacerItem;
class QmitkLevelWindowWidget;
class QmitkRenderWindow;
namespace mitk {
class RenderingManager;
}
/// \ingroup QmitkModule
class QMITK_EXPORT QmitkStdMultiWidget : public QWidget
{
Q_OBJECT
public:
QmitkStdMultiWidget(QWidget* parent = 0, Qt::WindowFlags f = 0, mitk::RenderingManager* renderingManager = 0);
virtual ~QmitkStdMultiWidget();
mitk::SliceNavigationController*
GetTimeNavigationController();
void RequestUpdate();
void ForceImmediateUpdate();
mitk::MouseModeSwitcher* GetMouseModeSwitcher();
QmitkRenderWindow* GetRenderWindow1() const;
QmitkRenderWindow* GetRenderWindow2() const;
QmitkRenderWindow* GetRenderWindow3() const;
QmitkRenderWindow* GetRenderWindow4() const;
const mitk::Point3D &
GetLastLeftClickPosition() const;
const mitk::Point3D
GetCrossPosition() const;
void EnablePositionTracking();
void DisablePositionTracking();
int GetLayout() const;
mitk::SlicesRotator * GetSlicesRotator() const;
mitk::SlicesSwiveller * GetSlicesSwiveller() const;
bool GetGradientBackgroundFlag() const;
/*!
\brief Access node of widget plane 1
\return DataNode holding widget plane 1
*/
mitk::DataNode::Pointer GetWidgetPlane1();
/*!
\brief Access node of widget plane 2
\return DataNode holding widget plane 2
*/
mitk::DataNode::Pointer GetWidgetPlane2();
/*!
\brief Access node of widget plane 3
\return DataNode holding widget plane 3
*/
mitk::DataNode::Pointer GetWidgetPlane3();
/*!
\brief Convenience method to access node of widget planes
\param id number of widget plane to be returned
\return DataNode holding widget plane 3
*/
mitk::DataNode::Pointer GetWidgetPlane(int id);
bool IsColoredRectanglesEnabled() const;
bool IsDepartmentLogoEnabled() const;
bool IsCrosshairNavigationEnabled() const;
void InitializeWidget();
/// called when the StdMultiWidget is closed to remove the 3 widget planes and the helper node from the DataStorage
void RemovePlanesFromDataStorage();
void AddPlanesToDataStorage();
void SetDataStorage( mitk::DataStorage* ds );
/** \brief Listener to the CrosshairPositionEvent
Ensures the CrosshairPositionEvent is handled only once and at the end of the Qt-Event loop
*/
void HandleCrosshairPositionEvent();
/// activate Menu Widget. true: activated, false: deactivated
void ActivateMenuWidget( bool state );
bool IsMenuWidgetEnabled() const;
protected:
void UpdateAllWidgets();
void HideAllWidgetToolbars();
+ mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
+
public slots:
/// Receives the signal from HandleCrosshairPositionEvent, executes the StatusBar update
void HandleCrosshairPositionEventDelayed();
void changeLayoutTo2DImagesUp();
void changeLayoutTo2DImagesLeft();
void changeLayoutToDefault();
void changeLayoutToBig3D();
void changeLayoutToWidget1();
void changeLayoutToWidget2();
void changeLayoutToWidget3();
void changeLayoutToRowWidget3And4();
void changeLayoutToColumnWidget3And4();
void changeLayoutToRowWidgetSmall3andBig4();
void changeLayoutToSmallUpperWidget2Big3and4();
void changeLayoutTo2x2Dand3DWidget();
void changeLayoutToLeft2Dand3DRight2D();
void changeLayoutTo2DUpAnd3DDown();
void Fit();
void InitPositionTracking();
void AddDisplayPlaneSubTree();
void EnableStandardLevelWindow();
void DisableStandardLevelWindow();
bool InitializeStandardViews( const mitk::Geometry3D * geometry );
void wheelEvent( QWheelEvent * e );
void mousePressEvent(QMouseEvent * e);
void moveEvent( QMoveEvent* e );
void leaveEvent ( QEvent * e );
void EnsureDisplayContainsPoint(
mitk::DisplayGeometry* displayGeometry, const mitk::Point3D& p);
void MoveCrossToPosition(const mitk::Point3D& newPosition);
void EnableNavigationControllerEventListening();
void DisableNavigationControllerEventListening();
void EnableGradientBackground();
void DisableGradientBackground();
void EnableDepartmentLogo();
void DisableDepartmentLogo();
void EnableColoredRectangles();
void DisableColoredRectangles();
void SetWidgetPlaneVisibility(const char* widgetName, bool visible, mitk::BaseRenderer *renderer=NULL);
void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer=NULL);
void SetWidgetPlanesLocked(bool locked);
void SetWidgetPlanesRotationLocked(bool locked);
void SetWidgetPlanesRotationLinked( bool link );
void SetWidgetPlaneMode( int mode );
void SetGradientBackgroundColors( const mitk::Color & upper, const mitk::Color & lower );
void SetDepartmentLogoPath( const char * path );
void SetWidgetPlaneModeToSlicing( bool activate );
void SetWidgetPlaneModeToRotation( bool activate );
void SetWidgetPlaneModeToSwivel( bool activate );
void OnLayoutDesignChanged( int layoutDesignIndex );
void ResetCrosshair();
void MouseModeSelected( mitk::MouseModeSwitcher::MouseMode mouseMode );
signals:
void LeftMouseClicked(mitk::Point3D pointValue);
void WheelMoved(QWheelEvent*);
void WidgetPlanesRotationLinked(bool);
void WidgetPlanesRotationEnabled(bool);
void ViewsInitialized();
void WidgetPlaneModeSlicing(bool);
void WidgetPlaneModeRotation(bool);
void WidgetPlaneModeSwivel(bool);
void WidgetPlaneModeChange(int);
void WidgetNotifyNewCrossHairMode(int);
void Moved();
public:
/** Define RenderWindow (public)*/
QmitkRenderWindow* mitkWidget1;
QmitkRenderWindow* mitkWidget2;
QmitkRenderWindow* mitkWidget3;
QmitkRenderWindow* mitkWidget4;
QmitkLevelWindowWidget* levelWindowWidget;
/********************************/
enum { PLANE_MODE_SLICING = 0, PLANE_MODE_ROTATION, PLANE_MODE_SWIVEL };
enum { LAYOUT_DEFAULT = 0, LAYOUT_2D_IMAGES_UP, LAYOUT_2D_IMAGES_LEFT,
LAYOUT_BIG_3D, LAYOUT_WIDGET1, LAYOUT_WIDGET2, LAYOUT_WIDGET3,
LAYOUT_2X_2D_AND_3D_WIDGET, LAYOUT_ROW_WIDGET_3_AND_4,
LAYOUT_COLUMN_WIDGET_3_AND_4, LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4 ,
LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4,LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET,
LAYOUT_2D_UP_AND_3D_DOWN};
enum {
TRANSVERSAL,
AXIAL = TRANSVERSAL,
SAGITTAL,
CORONAL,
THREE_D
};
protected:
QHBoxLayout* QmitkStdMultiWidgetLayout;
int m_Layout;
int m_PlaneMode;
mitk::RenderingManager* m_RenderingManager;
mitk::RenderWindowFrame::Pointer m_RectangleRendering3;
mitk::RenderWindowFrame::Pointer m_RectangleRendering2;
mitk::RenderWindowFrame::Pointer m_RectangleRendering1;
mitk::RenderWindowFrame::Pointer m_RectangleRendering4;
mitk::ManufacturerLogo::Pointer m_LogoRendering1;
mitk::ManufacturerLogo::Pointer m_LogoRendering2;
mitk::ManufacturerLogo::Pointer m_LogoRendering3;
mitk::ManufacturerLogo::Pointer m_LogoRendering4;
mitk::GradientBackground::Pointer m_GradientBackground1;
mitk::GradientBackground::Pointer m_GradientBackground2;
mitk::GradientBackground::Pointer m_GradientBackground4;
mitk::GradientBackground::Pointer m_GradientBackground3;
bool m_GradientBackgroundFlag;
mitk::MouseModeSwitcher::Pointer m_MouseModeSwitcher;
mitk::CoordinateSupplier::Pointer m_LastLeftClickPositionSupplier;
mitk::PositionTracker::Pointer m_PositionTracker;
mitk::SliceNavigationController* m_TimeNavigationController;
mitk::SlicesRotator::Pointer m_SlicesRotator;
mitk::SlicesSwiveller::Pointer m_SlicesSwiveller;
mitk::DataNode::Pointer m_PositionTrackerNode;
mitk::DataStorage::Pointer m_DataStorage;
mitk::DataNode::Pointer m_PlaneNode1;
mitk::DataNode::Pointer m_PlaneNode2;
mitk::DataNode::Pointer m_PlaneNode3;
mitk::DataNode::Pointer m_Node;
QSplitter *m_MainSplit;
QSplitter *m_LayoutSplit;
QSplitter *m_SubSplit1;
QSplitter *m_SubSplit2;
QWidget *mitkWidget1Container;
QWidget *mitkWidget2Container;
QWidget *mitkWidget3Container;
QWidget *mitkWidget4Container;
struct
{
vtkCornerAnnotation *cornerText;
vtkTextProperty *textProp;
vtkRenderer *ren;
} m_CornerAnnotaions[3];
bool m_PendingCrosshairPositionEvent;
bool m_CrosshairNavigationEnabled;
};
#endif /*QMITKSTDMULTIWIDGET_H_*/
diff --git a/Modules/QmitkExt/QmitkAdaptiveRegionGrowingWidget.cpp b/Modules/QmitkExt/QmitkAdaptiveRegionGrowingWidget.cpp
index f85ff649ab..6fe13d1834 100644
--- a/Modules/QmitkExt/QmitkAdaptiveRegionGrowingWidget.cpp
+++ b/Modules/QmitkExt/QmitkAdaptiveRegionGrowingWidget.cpp
@@ -1,911 +1,911 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkAdaptiveRegionGrowingWidget.h"
#include "QmitkStdMultiWidget.h"
#include <qmessagebox.h>
#include "mitkNodePredicateDataType.h"
#include "mitkGlobalInteraction.h"
#include "mitkPointSetInteractor.h"
#include "mitkProperties.h"
#include "mitkITKImageImport.h"
#include "mitkImageAccessByItk.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkImageTimeSelector.h"
#include "mitkImageStatisticsHolder.h"
#include <itkConnectedAdaptiveThresholdImageFilter.h>
#include <itkMinimumMaximumImageCalculator.h>
#include <itkBinaryThresholdImageFilter.h>
#include <itkImageIterator.h>
QmitkAdaptiveRegionGrowingWidget::QmitkAdaptiveRegionGrowingWidget(QWidget * parent) :
QWidget(parent), m_MultiWidget(NULL), m_UseVolumeRendering(false), m_UpdateSuggestedThreshold(true), m_SuggestedThValue(0.0)
{
m_Controls.setupUi(this);
// muellerm, 8.8.12.: assure no limits for thresholding (there can be images with pixel values above 4000!!!)
m_Controls.m_LowerThresholdSpinBox->setMinimum( std::numeric_limits<int>::min() );
m_Controls.m_UpperThresholdSpinBox->setMinimum( std::numeric_limits<int>::min() );
m_Controls.m_LowerThresholdSpinBox->setMaximum( std::numeric_limits<int>::max() );
m_Controls.m_UpperThresholdSpinBox->setMaximum( std::numeric_limits<int>::max() );
m_NAMEFORSEEDPOINT = "Seed Point";
this->CreateConnections();
this->SetDataNodeNames("labeledRGSegmentation","RGResult","RGFeedbackSurface","RGSeedpoint");
}
QmitkAdaptiveRegionGrowingWidget::~QmitkAdaptiveRegionGrowingWidget()
{
//Removing the observer of the PointSet node
mitk::DataNode* node = m_DataStorage->GetNamedNode(m_NAMEFORSEEDPOINT);
if (node != NULL)
{
this->DeactivateSeedPointMode();
dynamic_cast<mitk::PointSet*>(node->GetData())->RemoveObserver(m_PointSetAddObserverTag);
}
this->RemoveHelperNodes();
}
void QmitkAdaptiveRegionGrowingWidget::RemoveHelperNodes()
{
mitk::DataNode::Pointer seedNode = m_DataStorage->GetNamedNode(m_NAMEFORSEEDPOINT);
if( seedNode.IsNotNull() )
{
m_DataStorage->Remove(seedNode);
}
mitk::DataNode::Pointer imageNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if( imageNode.IsNotNull() )
{
m_DataStorage->Remove(imageNode);
}
}
void QmitkAdaptiveRegionGrowingWidget::CreateConnections()
{
//Connecting GUI components
connect( (QObject*) (m_Controls.m_pbDefineSeedPoint), SIGNAL( toggled(bool) ), this, SLOT( SetSeedPointToggled(bool)) );
connect( (QObject*) (m_Controls.m_pbRunSegmentation), SIGNAL(clicked()), this, SLOT(RunSegmentation()));
connect( (QObject*) (m_Controls.m_Slider), SIGNAL(valueChanged(int)), this, SLOT(ChangeLevelWindow(int)) );
connect( (QObject*) (m_Controls.m_DecreaseTH), SIGNAL(clicked()), this, SLOT(DecreaseSlider()));
connect( (QObject*) (m_Controls.m_IncreaseTH), SIGNAL(clicked()), this,SLOT(IncreaseSlider()));
connect( (QObject*) (m_Controls.m_pbConfirmSegementation), SIGNAL(clicked()), this, SLOT(ConfirmSegmentation()));
connect( (QObject*) (m_Controls.m_cbVolumeRendering), SIGNAL(toggled(bool)), this, SLOT(UseVolumeRendering(bool) ));
connect( m_Controls.m_LowerThresholdSpinBox, SIGNAL(valueChanged(double)), this, SLOT(SetLowerThresholdValue(double)));
connect( m_Controls.m_UpperThresholdSpinBox, SIGNAL(valueChanged(double)), this, SLOT(SetUpperThresholdValue(double)));
}
void QmitkAdaptiveRegionGrowingWidget::SetDataNodeNames(std::string labledSegmentation, std::string binaryImage, std::string surface, std::string seedPoint)
{
m_NAMEFORLABLEDSEGMENTATIONIMAGE = labledSegmentation;
m_NAMEFORBINARYIMAGE = binaryImage;
m_NAMEFORSURFACE = surface;
m_NAMEFORSEEDPOINT = seedPoint;
}
void QmitkAdaptiveRegionGrowingWidget::SetDataStorage(mitk::DataStorage* dataStorage)
{
m_DataStorage = dataStorage;
}
void QmitkAdaptiveRegionGrowingWidget::SetMultiWidget(QmitkStdMultiWidget* multiWidget)
{
m_MultiWidget = multiWidget;
}
void QmitkAdaptiveRegionGrowingWidget::SetInputImageNode(mitk::DataNode* node)
{
m_InputImageNode = node;
}
void QmitkAdaptiveRegionGrowingWidget::SetSeedPointToggled(bool toggled)
{
if (m_InputImageNode.IsNull())
{
if (m_Controls.m_pbDefineSeedPoint->isChecked())
{
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Please specify the image in Datamanager!");
m_Controls.m_pbDefineSeedPoint->toggle();
}
return;
}
//check that a pointset node with the given name exists in data storage
mitk::DataNode* node = m_DataStorage->GetNamedNode(m_NAMEFORSEEDPOINT);
if (node == NULL) //no pointSet present
{
// new node and data item
mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
pointSetNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New(m_NAMEFORSEEDPOINT));
pointSetNode->GetPropertyList()->SetProperty("helper object", mitk::BoolProperty::New(true));
pointSetNode->GetPropertyList()->SetProperty("layer", mitk::IntProperty::New(2));
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
pointSetNode->SetData(pointSet);
//Watch for point added or modified
itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingWidget>::Pointer pointAddedCommand = itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingWidget>::New();
pointAddedCommand->SetCallbackFunction(this, &QmitkAdaptiveRegionGrowingWidget::OnPointAdded);
m_PointSetAddObserverTag = pointSet->AddObserver( mitk::PointSetAddEvent(), pointAddedCommand);
//add to DataStorage
m_DataStorage->Add(pointSetNode, m_InputImageNode);
}
mitk::NodePredicateDataType::Pointer imagePred = mitk::NodePredicateDataType::New("Image");
mitk::DataStorage::SetOfObjects::ConstPointer setOfImages = m_DataStorage->GetSubset(imagePred);
//no image node found
if (setOfImages->Size() < 1)
{
QMessageBox::information(NULL, "Segmentation functionality", "Please load an image before setting a seed point.");
return;
}
else
{
//get PointSet node from DataStorage
mitk::DataNode* node = m_DataStorage->GetNamedNode(m_NAMEFORSEEDPOINT);
if (node == NULL)
{
QMessageBox::critical(NULL, "QmitkAdaptiveRegionGrowingWidget", "No seed point node found!");
return;
}
if (toggled == true) // button is down
{
this->ActivateSeedPointMode(); //add pointSet Interactor if there is none
}
else
{
this->DeactivateSeedPointMode(); //disable pointSet Interactor
}
//enable the Run Segmentation button once the set seed point button is pressed
m_Controls.m_pbRunSegmentation->setEnabled(true);
}
}
void QmitkAdaptiveRegionGrowingWidget::OnPointAdded()
{
mitk::DataNode* node = m_DataStorage->GetNamedNode(m_NAMEFORSEEDPOINT);
if (node != NULL) //no pointSet present
{
mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
if (pointSet.IsNull())
{
QMessageBox::critical(NULL, "QmitkAdaptiveRegionGrowingWidget", "PointSetNode does not contain a pointset");
return;
}
mitk::Image* image = dynamic_cast<mitk::Image*>(m_InputImageNode->GetData());
mitk::Point3D seedPoint = pointSet->GetPointSet(m_MultiWidget->GetTimeNavigationController()->GetTime()->GetPos())->GetPoints()->ElementAt(0);
m_SeedpointValue = image->GetPixelValueByWorldCoordinate(seedPoint);
/* In this case the seedpoint is placed e.g. in the lung or bronchialtree
* The lowerFactor sets the windowsize depending on the regiongrowing direction
*/
m_CurrentRGDirectionIsUpwards = true;
if (m_SeedpointValue < -500)
{
m_CurrentRGDirectionIsUpwards = false;
}
m_SeedPointValueMean = 0;
mitk::Index3D currentIndex, runningIndex;
mitk::ScalarType pixelValues[125];
unsigned int pos (0);
image->GetGeometry(0)->WorldToIndex(seedPoint, currentIndex);
runningIndex = currentIndex;
for(int i = runningIndex[0]-2; i <= runningIndex[0]+2; i++)
{
for(int j = runningIndex[1]-2; j <= runningIndex[1]+2; j++)
{
for(int k = runningIndex[2]-2; k <= runningIndex[2]+2; k++)
{
currentIndex[0] = i;
currentIndex[1] = j;
currentIndex[2] = k;
if(image->GetGeometry()->IsIndexInside(currentIndex))
{
pixelValues[pos] = image->GetPixelValueByIndex(currentIndex);
pos++;
}
else
{
pixelValues[pos] = -10000000;
pos++;
}
}
}
}
//Now calculation mean of the pixelValues
unsigned int numberOfValues(0);
for (unsigned int i = 0; i < 125; i++)
{
if(pixelValues[i] > -10000000)
{
m_SeedPointValueMean += pixelValues[i];
numberOfValues++;
}
}
m_SeedPointValueMean = m_SeedPointValueMean/numberOfValues;
/*
* Here the upper- and lower threshold is calculated:
* The windowSize is 20% of the maximum range of the intensity values existing in the current image
* If the RG direction is upwards the lower TH is meanSeedValue-0.15*windowSize and upper TH is meanSeedValue+0.85*windowsSize
* if the RG direction is downwards the lower TH is meanSeedValue-0.85*windowSize and upper TH is meanSeedValue+0.15*windowsSize
*/
mitk::ScalarType min = image->GetStatistics()->GetScalarValueMin();
mitk::ScalarType max = image->GetStatistics()->GetScalarValueMax();
mitk::ScalarType windowSize = max - min;
windowSize = 0.15*windowSize;
if (m_CurrentRGDirectionIsUpwards)
{
m_LOWERTHRESHOLD = m_SeedPointValueMean;
if (m_SeedpointValue < m_SeedPointValueMean)
m_LOWERTHRESHOLD = m_SeedpointValue;
m_UPPERTHRESHOLD = m_SeedpointValue + windowSize;
}
else
{
m_UPPERTHRESHOLD = m_SeedPointValueMean;
if (m_SeedpointValue > m_SeedPointValueMean)
m_UPPERTHRESHOLD = m_SeedpointValue;
m_LOWERTHRESHOLD = m_SeedpointValue - windowSize;
}
this->m_Controls.m_LowerThresholdSpinBox->setValue(m_LOWERTHRESHOLD);
this->m_Controls.m_UpperThresholdSpinBox->setValue(m_UPPERTHRESHOLD);
}
}
void QmitkAdaptiveRegionGrowingWidget::RunSegmentation()
{
if (m_InputImageNode.IsNull())
{
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Please specify the image in Datamanager!");
return;
}
//release the "define seed point"-button if it is still pressed
if (m_Controls.m_pbDefineSeedPoint->isChecked())
m_Controls.m_pbDefineSeedPoint->toggle();
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode(m_NAMEFORSEEDPOINT);
if (node.IsNull())
{
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Please insert a seed point inside the image.\n\nFirst press the \"Define Seed Point\" button,\nthen click left mouse button inside the image.");
return;
}
//safety if no pointSet or pointSet empty
mitk::PointSet::Pointer seedPointSet = dynamic_cast<mitk::PointSet*> (node->GetData());
if (seedPointSet.IsNull())
{
m_Controls.m_pbRunSegmentation->setEnabled(true);
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
return;
}
if (!(seedPointSet->GetSize(m_MultiWidget->GetTimeNavigationController()->GetTime()->GetPos()) > 0))
{
m_Controls.m_pbRunSegmentation->setEnabled(true);
m_Controls.m_pbDefineSeedPoint->setHidden(false);
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
return;
}
int timeStep = m_MultiWidget->GetTimeNavigationController()->GetTime()->GetPos();
mitk::PointSet::PointType seedPoint = seedPointSet->GetPointSet(timeStep)->GetPoints()->Begin().Value();
mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image*> (m_InputImageNode->GetData());
if (orgImage.IsNotNull())
{
if (orgImage->GetDimension() == 4)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(orgImage);
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
mitk::Image* timedImage = timeSelector->GetOutput();
AccessByItk_2( timedImage , StartRegionGrowing, timedImage->GetGeometry(), seedPoint);
}
else if (orgImage->GetDimension() == 3)
{
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor)); //set the cursor to waiting
AccessByItk_2(orgImage, StartRegionGrowing, orgImage->GetGeometry(), seedPoint);
QApplication::restoreOverrideCursor();//reset cursor
}
else
{
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Only images of dimension 3 or 4 can be processed!");
return;
}
}
EnableControls(true); // Segmentation ran successfully, so enable all controls.
node->SetVisibility(true);
}
template<typename TPixel, unsigned int VImageDimension>
void QmitkAdaptiveRegionGrowingWidget::StartRegionGrowing(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Geometry3D* imageGeometry, mitk::PointSet::PointType seedPoint)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
typedef itk::ConnectedAdaptiveThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
typedef itk::MinimumMaximumImageCalculator<InputImageType> MinMaxValueFilterType;
if ( !imageGeometry->IsInside(seedPoint) )
{
QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside of the image! Please choose a position inside the image!");
return;
}
IndexType seedIndex;
imageGeometry->WorldToIndex( seedPoint, seedIndex);// convert world coordinates to image indices
if (m_SeedpointValue>m_UPPERTHRESHOLD || m_SeedpointValue<m_LOWERTHRESHOLD)
{
QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside the defined thresholds! Please set a new seed point or adjust the thresholds.");
MITK_INFO << "Mean: " <<m_SeedPointValueMean;
return;
}
//Setting the direction of the regiongrowing. For dark structures e.g. the lung the regiongrowing
//is performed starting at the upper value going to the lower one
regionGrower->SetGrowingDirectionIsUpwards( m_CurrentRGDirectionIsUpwards );
regionGrower->SetInput( itkImage );
regionGrower->AddSeed( seedIndex );
//In some cases we have to subtract 1 for the lower threshold and add 1 to the upper.
//Otherwise no region growing is done. Maybe a bug in the ConnectiveAdaptiveThresholdFilter
regionGrower->SetLower( m_LOWERTHRESHOLD-1 );
regionGrower->SetUpper( m_UPPERTHRESHOLD+1);
try
{
regionGrower->Update();
}
catch(itk::ExceptionObject &exc)
{
QMessageBox errorInfo;
errorInfo.setWindowTitle("Adaptive RG Segmentation Functionality");
errorInfo.setIcon(QMessageBox::Critical);
errorInfo.setText("An error occurred during region growing!");
errorInfo.setDetailedText(exc.what());
errorInfo.exec();
return; // can't work
}
catch( ... )
{
QMessageBox::critical( NULL, "Adaptive RG Segmentation Functionality", "An error occurred during region growing!");
return;
}
this->m_SeedpointValue = regionGrower->GetSeedpointValue();
//initialize slider
if(m_CurrentRGDirectionIsUpwards)
{
this->m_Controls.m_Slider->setMinimum(m_LOWERTHRESHOLD);
this->m_Controls.m_Slider->setMaximum(m_UPPERTHRESHOLD);
}
else
{
m_Controls.m_Slider->setMinimum(m_LOWERTHRESHOLD);
m_Controls.m_Slider->setMaximum(m_UPPERTHRESHOLD);
}
this->m_SliderInitialized = true;
this->m_DetectedLeakagePoint = regionGrower->GetLeakagePoint();
- mitk::Image::Pointer resultImage = mitk::ImportItkImage( regionGrower->GetOutput() );
+ mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput())->Clone();
//create new node and then delete the old one if there is one
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetData( resultImage );
// set some properties
newNode->SetProperty("name", mitk::StringProperty::New(m_NAMEFORLABLEDSEGMENTATIONIMAGE));
newNode->SetProperty("helper object", mitk::BoolProperty::New(true));
newNode->SetProperty("color", mitk::ColorProperty::New(1.0,0.0,0.0));
newNode->SetProperty("layer", mitk::IntProperty::New(1));
newNode->SetProperty("opacity", mitk::FloatProperty::New(0.7));
//delete the old image, if there was one:
mitk::DataNode::Pointer binaryNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
m_DataStorage->Remove(binaryNode);
// now add result to data tree
m_DataStorage->Add( newNode, m_InputImageNode );
this->InitializeLevelWindow();
if(m_UseVolumeRendering)
this->EnableVolumeRendering(true);
m_UpdateSuggestedThreshold = true;// reset first stored threshold value
//Setting progress to finished
mitk::ProgressBar::GetInstance()->Progress(357);
}
void QmitkAdaptiveRegionGrowingWidget::InitializeLevelWindow()
{
//get the preview from the datatree
mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
mitk::LevelWindow tempLevelWindow;
newNode->GetLevelWindow(tempLevelWindow, NULL, "levelwindow");
mitk::ScalarType* level = new mitk::ScalarType(0.0);
mitk::ScalarType* window = new mitk::ScalarType(1.0);
int upper;
if (m_CurrentRGDirectionIsUpwards)
{
upper = m_UPPERTHRESHOLD - m_SeedpointValue;
}
else
{
upper = m_SeedpointValue - m_LOWERTHRESHOLD;
}
tempLevelWindow.SetRangeMinMax(mitk::ScalarType(0), mitk::ScalarType(upper));
//get the suggested threshold from the detected leakage-point and adjust the slider
if (m_CurrentRGDirectionIsUpwards)
{
this->m_Controls.m_Slider->setValue(this->m_SeedpointValue + this->m_DetectedLeakagePoint -1);
*level = m_UPPERTHRESHOLD - (this->m_SeedpointValue + this->m_DetectedLeakagePoint -1) + 0.5;
}
else
{
this->m_Controls.m_Slider->setValue(this->m_SeedpointValue - this->m_DetectedLeakagePoint +1);
*level = (this->m_SeedpointValue + this->m_DetectedLeakagePoint +1) - m_LOWERTHRESHOLD + 0.5;
}
tempLevelWindow.SetLevelWindow(*level, *window);
newNode->SetLevelWindow(tempLevelWindow, NULL, "levelwindow");
//update the widgets
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_SliderInitialized = true;
//inquiry need to fix bug#1828
static int lastSliderPosition = 0;
if ((this->m_SeedpointValue + this->m_DetectedLeakagePoint - 1) == lastSliderPosition)
{
this->ChangeLevelWindow(lastSliderPosition);
}
lastSliderPosition = this->m_SeedpointValue + this->m_DetectedLeakagePoint-1;
this->m_MultiWidget->levelWindowWidget->GetManager()->SetAutoTopMostImage(false);
this->m_MultiWidget->levelWindowWidget->GetManager()->SetLevelWindowProperty(static_cast<mitk::LevelWindowProperty*>(newNode->GetProperty("levelwindow")));
if (m_UseVolumeRendering)
this->UpdateVolumeRenderingThreshold((int) (*level + 0.5));//lower threshold for labeled image
}
void QmitkAdaptiveRegionGrowingWidget::ChangeLevelWindow(int newValue)
{
if (m_SliderInitialized)
{
//do nothing, if no preview exists
mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if (newNode.IsNull())
return;
mitk::LevelWindow tempLevelWindow;
newNode->GetLevelWindow(tempLevelWindow, NULL, "levelwindow"); //get the levelWindow associated with the preview
mitk::ScalarType level;// = this->m_UPPERTHRESHOLD - newValue + 0.5;
mitk::ScalarType* window = new mitk::ScalarType(1);
//adjust the levelwindow according to the position of the slider (newvalue)
if (m_CurrentRGDirectionIsUpwards)
{
level = m_UPPERTHRESHOLD - newValue + 0.5;
tempLevelWindow.SetLevelWindow(level, *window);
}
else
{
level = newValue - m_LOWERTHRESHOLD +0.5;
tempLevelWindow.SetLevelWindow(level, *window);
}
newNode->SetLevelWindow(tempLevelWindow, NULL, "levelwindow");
if (m_UseVolumeRendering)
this->UpdateVolumeRenderingThreshold((int) (level - 0.5));//lower threshold for labeled image
this->m_Controls.m_SliderValueLabel->setNum(newValue);
newNode->SetVisibility(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkAdaptiveRegionGrowingWidget::DecreaseSlider()
{
//moves the slider one step to the left, when the "-"-button is pressed
if (this->m_Controls.m_Slider->value() != this->m_Controls.m_Slider->minimum())
{
int newValue = this->m_Controls.m_Slider->value() - 1;
this->ChangeLevelWindow(newValue);
this->m_Controls.m_Slider->setValue(newValue);
}
}
void QmitkAdaptiveRegionGrowingWidget::IncreaseSlider()
{
//moves the slider one step to the right, when the "+"-button is pressed
if (this->m_Controls.m_Slider->value() != this->m_Controls.m_Slider->maximum())
{
int newValue = this->m_Controls.m_Slider->value() + 1;
this->ChangeLevelWindow(newValue);
this->m_Controls.m_Slider->setValue(newValue);
}
}
void QmitkAdaptiveRegionGrowingWidget::ConfirmSegmentation()
{
//get image node
if(m_InputImageNode.IsNull())
{
QMessageBox::critical( NULL, "Adaptive region growing functionality", "Please specify the image in Datamanager!");
return;
}
//get image data
mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image*> (m_InputImageNode->GetData());
if(orgImage.IsNull())
{
QMessageBox::critical( NULL, "Adaptive region growing functionality", "No Image found!");
return;
}
//get labeled segmentation
mitk::Image::Pointer labeledSeg = (mitk::Image*)m_DataStorage->GetNamedObject<mitk::Image>(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if(labeledSeg.IsNull())
{
QMessageBox::critical( NULL, "Adaptive region growing functionality", "No Segmentation Preview found!");
return;
}
mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if (newNode.IsNull())
return;
mitk::Image* img = dynamic_cast<mitk::Image*>(newNode->GetData());
AccessByItk(img, ITKThresholding);
// disable volume rendering preview after the segmentation node was created
this->EnableVolumeRendering(false);
newNode->SetVisibility(false);
m_Controls.m_cbVolumeRendering->setChecked(false);
}
template<typename TPixel, unsigned int VImageDimension>
void QmitkAdaptiveRegionGrowingWidget::ITKThresholding(itk::Image<TPixel, VImageDimension>* itkImage)
{
/*
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef itk::Image<unsigned char, VImageDimension> SegmentationType;
typedef itk::BinaryThresholdImageFilter<InputImageType, SegmentationType> ThresholdFilterType;
typename ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
filter->SetInput(itkImage);
filter->SetInsideValue(1);
filter->SetOutsideValue(0);
mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if (newNode.IsNull())
return;
mitk::LevelWindow tempLevelWindow;
newNode->GetLevelWindow(tempLevelWindow, NULL, "levelwindow"); //get the levelWindow associated with the preview
filter->SetUpperThreshold(tempLevelWindow.GetRangeMax());
if (m_CurrentRGDirectionIsUpwards)
{
filter->SetLowerThreshold(tempLevelWindow.GetLevel()+0.5);
}
else
{
filter->SetLowerThreshold(tempLevelWindow.GetLevel()+0.5);
}
filter->Update();
*/
// muellerm, 6.8. change:
// instead of using the not working threshold filter, implemented a manual creation
// of the binary image in an easy way: every pixel unequal zero in the preview (input)
// image is a one in the resulting segmentation. at the same time overwrite the preview
// with zeros to invalidate it
// Allocate empty image
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef itk::Image<unsigned char, VImageDimension> SegmentationType;
typename SegmentationType::Pointer segmentationImage = SegmentationType::New();
segmentationImage->SetRegions( itkImage->GetLargestPossibleRegion() );
segmentationImage->SetOrigin( itkImage->GetOrigin() );
segmentationImage->SetDirection( itkImage->GetDirection() );
segmentationImage->SetSpacing( itkImage->GetSpacing() );
segmentationImage->Allocate();
itk::ImageRegionIterator<SegmentationType> itOutput( segmentationImage, segmentationImage->GetLargestPossibleRegion() );
itk::ImageRegionIterator<InputImageType> itInput( itkImage, itkImage->GetLargestPossibleRegion() );
itOutput.GoToBegin();
itInput.GoToBegin();
while( !itOutput.IsAtEnd() && !itInput.IsAtEnd() )
{
if( itInput.Value() != 0 )
itOutput.Set( 1 );
else
itOutput.Set( 0 );
// overwrite preview, so it wont disturb as when we see our resulting segmentation
//itInput.Set( 0 );
++itOutput;
++itInput;
}
mitk::Image::Pointer new_image = mitk::Image::New();
mitk::CastToMitkImage( segmentationImage, new_image );
mitk::DataNode::Pointer segNode = mitk::DataNode::New();
segNode->SetData(new_image);
segNode->SetName("RegionGrowing_Result");
segNode->SetBoolProperty("binary", mitk::BoolProperty::New(true));
//delete the old image, if there was one:
mitk::DataNode::Pointer prevSegNode = m_DataStorage->GetNamedNode("RegionGrowing_Result");
m_DataStorage->Remove(prevSegNode);
m_DataStorage->Add(segNode, m_InputImageNode);
}
void QmitkAdaptiveRegionGrowingWidget::EnableControls(bool enable)
{
//set the labels below the slider
this->m_Controls.m_RSliderLabelLower->setText("Shrink");
this->m_Controls.m_RGSliderLaberUpper->setText("Expand");
this->m_Controls.m_RSliderLabelLower->setEnabled(enable);
this->m_Controls.m_RGSliderLaberUpper->setEnabled(enable);
this->m_Controls.m_pbDefineSeedPoint->setEnabled(enable);
// Check if seed point is already set, if not leave RunSegmentation disabled
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode(m_NAMEFORSEEDPOINT);
if (node.IsNull()) {
this->m_Controls.m_pbRunSegmentation->setEnabled(false);
}
else
{
this->m_Controls.m_pbRunSegmentation->setEnabled(enable);
}
// Check if a segmentation exists, if not leave segmentation dependent disabled.
node = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if (node.IsNull()) {
this->m_Controls.m_DecreaseTH->setEnabled(false);
this->m_Controls.m_IncreaseTH->setEnabled(false);
this->m_Controls.m_Slider->setEnabled(false);
this->m_Controls.m_SliderValueLabel->setEnabled(false);
this->m_Controls.m_pbConfirmSegementation->setEnabled(false);
}
else
{
this->m_Controls.m_DecreaseTH->setEnabled(enable);
this->m_Controls.m_IncreaseTH->setEnabled(enable);
this->m_Controls.m_Slider->setEnabled(enable);
this->m_Controls.m_SliderValueLabel->setEnabled(enable);
this->m_Controls.m_pbConfirmSegementation->setEnabled(enable);
}
this->m_Controls.m_cbVolumeRendering->setEnabled(enable);
}
void QmitkAdaptiveRegionGrowingWidget::EnableVolumeRendering(bool enable)
{
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if(node.IsNull())
return;
if(m_MultiWidget)
m_MultiWidget->SetWidgetPlanesVisibility(!enable);
if (enable)
{
node->SetBoolProperty("volumerendering", enable);
node->SetBoolProperty("volumerendering.uselod", true);
}
else
{
node->SetBoolProperty("volumerendering", enable);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkAdaptiveRegionGrowingWidget::UpdateVolumeRenderingThreshold(int thValue)
{
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
if (m_UpdateSuggestedThreshold)
{
m_SuggestedThValue = thValue;
m_UpdateSuggestedThreshold = false;
}
// grayvalue->opacity
{
vtkPiecewiseFunction *f = tf->GetScalarOpacityFunction();
f->RemoveAllPoints();
f->AddPoint(0, 0);
f->AddPoint(thValue+0.5, 0);
f->AddPoint(thValue+1.5, 1);
f->AddPoint(1000, 1);
f->ClampingOn();
f->Modified();
}
// grayvalue->color
{
float a = 255.0;
vtkColorTransferFunction *ctf = tf->GetColorTransferFunction();
ctf->RemoveAllPoints();
//ctf->AddRGBPoint(-1000, 0.0, 0.0, 0.0);
ctf->AddRGBPoint(m_SuggestedThValue+1, 203/a, 104/a, 102/a);
ctf->AddRGBPoint(m_SuggestedThValue, 255/a, 0/a, 0/a);
ctf->ClampingOn();
ctf->Modified();
}
// GradientOpacityFunction
{
vtkPiecewiseFunction *gof = tf->GetGradientOpacityFunction();
gof->RemoveAllPoints();
gof->AddPoint(-10000, 1);
gof->AddPoint(10000, 1);
gof->ClampingOn();
gof->Modified();
}
mitk::TransferFunctionProperty::Pointer tfp = mitk::TransferFunctionProperty::New();
tfp->SetValue(tf);
node->SetProperty("TransferFunction", tfp);
}
void QmitkAdaptiveRegionGrowingWidget::UseVolumeRendering(bool on)
{
m_UseVolumeRendering = on;
this->EnableVolumeRendering(on);
}
void QmitkAdaptiveRegionGrowingWidget::OnDefineThresholdBoundaries(bool status)
{
m_Controls.m_LowerThresholdSpinBox->setEnabled(status);
m_Controls.m_UpperThresholdSpinBox->setEnabled(status);
m_Controls.lb_LowerTh->setEnabled(status);
m_Controls.lb_UpperTh->setEnabled(status);
}
void QmitkAdaptiveRegionGrowingWidget::SetLowerThresholdValue( double lowerThreshold )
{
m_LOWERTHRESHOLD = lowerThreshold;
}
void QmitkAdaptiveRegionGrowingWidget::SetUpperThresholdValue( double upperThreshold)
{
m_UPPERTHRESHOLD = upperThreshold;
}
void QmitkAdaptiveRegionGrowingWidget::Deactivated()
{
this->DeactivateSeedPointMode();
// make the segmentation preview node invisible
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if( node.IsNotNull() )
{
node->SetVisibility(false);
}
// disable volume rendering preview after the segmentation node was created
this->EnableVolumeRendering(false);
m_Controls.m_cbVolumeRendering->setChecked(false);
}
void QmitkAdaptiveRegionGrowingWidget::Activated()
{
}
void QmitkAdaptiveRegionGrowingWidget::ActivateSeedPointMode()
{
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode(m_NAMEFORSEEDPOINT);
if(node.IsNotNull())
{
//set the cursor to cross
QApplication::setOverrideCursor(QCursor(Qt::CrossCursor));
mitk::PointSetInteractor::Pointer interactor = dynamic_cast<mitk::PointSetInteractor*> (node->GetInteractor());
if (interactor.IsNull())
{
//create a new interactor and add it to node
interactor = mitk::PointSetInteractor::New("singlepointinteractorwithoutshiftclick", node, 1);
}
mitk::GlobalInteraction::GetInstance()->AddInteractor(interactor);
}
}
void QmitkAdaptiveRegionGrowingWidget::DeactivateSeedPointMode()
{
//set the cursor to default again
QApplication::restoreOverrideCursor();
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode(m_NAMEFORSEEDPOINT);
if(node.IsNotNull())
{
mitk::PointSetInteractor::Pointer
interactor = dynamic_cast<mitk::PointSetInteractor*> (node->GetInteractor());
if (interactor.IsNotNull())
{
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(interactor);
}
}
}
diff --git a/Modules/QmitkExt/QmitkFunctionalityComponents/QmitkThresholdComponent.cpp b/Modules/QmitkExt/QmitkFunctionalityComponents/QmitkThresholdComponent.cpp
index 0280c1d0f5..8202cb8308 100644
--- a/Modules/QmitkExt/QmitkFunctionalityComponents/QmitkThresholdComponent.cpp
+++ b/Modules/QmitkExt/QmitkFunctionalityComponents/QmitkThresholdComponent.cpp
@@ -1,637 +1,636 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkThresholdComponent.h"
#include "ui_QmitkThresholdComponentControls.h"
#include <QmitkDataStorageComboBox.h>
#include <mitkDataStorage.h>
#include "mitkRenderingManager.h"
#include "mitkProperties.h"
#include "mitkDataNodeFactory.h"
#include "mitkImageTimeSelector.h"
#include "mitkLevelWindowProperty.h"
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateProperty.h>
#include <qlineedit.h>
#include <qslider.h>
#include <qgroupbox.h>
#include <qcheckbox.h>
#include <QIntValidator>
#include <mitkImageCast.h>
#include <mitkImageAccessByItk.h>
//#include <mitkIpPicTypeMultiplex.h>
#include <itkImageConstIteratorWithIndex.h>
/*************** CONSTRUCTOR ***************/
QmitkThresholdComponent::QmitkThresholdComponent(QObject * parent, const char * parentName, bool updateSelector, bool showSelector, QmitkStdMultiWidget * /*mitkStdMultiWidget*/)
: QmitkFunctionalityComponentContainer(parent, parentName, updateSelector, showSelector),
m_ThresholdImageNode(NULL),
m_ThresholdComponentGUI(NULL),
m_ThresholdNodeExisting(false)
{
SetAvailability(true);
SetComponentName("ThresholdFinder");
}
/*************** DESTRUCTOR ***************/
QmitkThresholdComponent::~QmitkThresholdComponent()
{
}
/************** SET SELECTOR VISIBILITY ***************/
void QmitkThresholdComponent::SetSelectorVisibility(bool /*visibility*/)
{
if(m_ThresholdComponentGUI)
{
//m_ImageContent->setShown(visibility);
m_ImageContent->setShown(true);
}
}
/*************** GET IMAGE CONTENT ***************/
QGroupBox* QmitkThresholdComponent::GetImageContent()
{
return (QGroupBox*) m_ImageContent;
}
/*************** GET TREE NODE SELECTOR ***************/
QmitkDataStorageComboBox* QmitkThresholdComponent::GetTreeNodeSelector()
{
return m_TreeNodeSelector;
}
/*************** CONNECTIONS ***************/
void QmitkThresholdComponent::CreateConnections()
{
if ( m_ThresholdComponentGUI )
{
connect( (QObject*)(m_TreeNodeSelector), SIGNAL(OnSelectionChanged (const mitk::DataNode *)), (QObject*) this, SLOT(ImageSelected(const mitk::DataNode *)));
connect( (QObject*)(m_ThresholdFinder), SIGNAL(toggled(bool)), (QObject*) this, SLOT(ShowThresholdFinderContent(bool)));
connect( (QObject*)(m_ThresholdSelectDataGroupBox), SIGNAL(toggled(bool)), (QObject*) this, SLOT(ShowImageContent(bool)));
connect( (QObject*)(m_ThresholdInputSlider), SIGNAL(sliderMoved(int)), (QObject*) this, SLOT(ThresholdSliderChanged(int)));
connect( (QObject*)(m_ThresholdInputNumber), SIGNAL(returnPressed()), (QObject*) this, SLOT(ThresholdValueChanged()));
//connect( (QObject*)( m_ShowThresholdGroupBox), SIGNAL(toggled(bool)), (QObject*) this, SLOT(ShowThreshold(bool)));
//to connect the toplevel checkable GroupBox with the method SetContentContainerVisibility to inform all containing komponent to shrink or to expand
connect( (QObject*)(m_ThresholdFinder), SIGNAL(toggled(bool)), (QObject*) this, SLOT(SetContentContainerVisibility(bool)));
connect( (QObject*)(m_CreateSegmentationButton), SIGNAL(released()), (QObject*) this, SLOT(CreateThresholdSegmentation()));
}
}
/*************** DATA STORAGE CHANGED ***************/
void QmitkThresholdComponent::DataStorageChanged(mitk::DataStorage::Pointer ds)
{
if(!ds)
return;
m_DataStorage = ds;
m_TreeNodeSelector->SetDataStorage(ds);
if(m_ThresholdComponentGUI != NULL)
{
for(unsigned int i = 0; i < m_AddedChildList.size(); i++)
{
QmitkBaseFunctionalityComponent* functionalityComponent = dynamic_cast<QmitkBaseFunctionalityComponent*>(m_AddedChildList[i]);
if (functionalityComponent != NULL)
functionalityComponent->DataStorageChanged(ds);
}
}
if(!ds)
return;
DataObjectSelected();
SetSliderRange();
ShowThreshold();
}
/*************** IMAGE SELECTED ***************/
void QmitkThresholdComponent::ImageSelected(const mitk::DataNode* item)
{
if(m_ThresholdComponentGUI != NULL)
{
mitk::DataNode::Pointer selectedItem = const_cast< mitk::DataNode*>(item);
m_TreeNodeSelector->SetSelectedNode(selectedItem);
for(unsigned int i = 0; i < m_AddedChildList.size(); i++)
{
QmitkBaseFunctionalityComponent* functionalityComponent = dynamic_cast<QmitkBaseFunctionalityComponent*>(m_AddedChildList[i]);
if (functionalityComponent != NULL)
functionalityComponent->ImageSelected(item);
}
}
DataObjectSelected();
SetSliderRange();
ShowThreshold();
}
/*************** DATA OBJECT SELECTED **************/
void QmitkThresholdComponent::DataObjectSelected()
{
if(m_Active)
{
if(m_ThresholdNodeExisting)
{
m_ThresholdImageNode->SetData(m_TreeNodeSelector->GetSelectedNode()->GetData());
}
else
{
CreateThresholdImageNode();
m_ThresholdImageNode->SetData(m_TreeNodeSelector->GetSelectedNode()->GetData());
}
ShowThreshold();
}
}
/** \brief Method to set the DataStorage*/
void QmitkThresholdComponent::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
{
m_DataStorage = dataStorage;
}
/** \brief Method to get the DataStorage*/
mitk::DataStorage::Pointer QmitkThresholdComponent::GetDataStorage()
{
return m_DataStorage;
}
/*************** CREATE CONTAINER WIDGET **************/
void QmitkThresholdComponent::CreateQtPartControl(QWidget * /*parent*/, mitk::DataStorage::Pointer dataStorage)
{
m_GUI = new QWidget;
m_ThresholdComponentGUI = new Ui::QmitkThresholdComponentControls;
m_ThresholdComponentGUI->setupUi(m_GUI);
/*CREATE GUI ELEMENTS*/
m_ThresholdFinder = new QGroupBox("2. Find Threshold", m_GUI);
m_ThresholdSelectDataGroupBox = new QGroupBox("Show Image Selector", m_ThresholdFinder);
m_TreeNodeSelector = new QmitkDataStorageComboBox(m_ThresholdSelectDataGroupBox);
m_ImageContent = new QGroupBox("m_ImageContent", m_ThresholdSelectDataGroupBox);
m_ContainerContent = new QGroupBox(m_ImageContent);
m_ShowThresholdGroupBox = new QGroupBox("m_ShowThresholdGroupBox", m_ContainerContent);
m_ThresholdInputNumber = new QLineEdit(m_ShowThresholdGroupBox);
m_ThresholdInputSlider = new QSlider(m_ShowThresholdGroupBox);
m_ThresholdInputSlider->setOrientation(Qt::Horizontal);
m_ThresholdValueContent = new QGroupBox("m_ThresholdValueContent", m_ShowThresholdGroupBox);
m_CreateSegmentationButton = new QPushButton("Create Segmentation", m_ThresholdValueContent);
m_DeleateImageIfDeactivatedCheckBox = new QCheckBox("Deleate Threshold Image if \nComponent is deactivated", m_ThresholdValueContent);
m_ThresholdFinder->setCheckable(true);
m_ThresholdFinder->setChecked(true);
m_ThresholdSelectDataGroupBox->setCheckable(true);
m_ThresholdSelectDataGroupBox->setChecked(true);
m_ThresholdInputNumber->setFixedSize(40, 20);
QIntValidator* intValid = new QIntValidator(-32000, 5000, m_ThresholdInputNumber);
m_ThresholdInputNumber->setValidator(intValid);
m_ThresholdInputNumber->setText("0");
m_ThresholdValueContent->setMaximumHeight(90);
// m_ThresholdSelectDataGroupBox->setContentsMargins(0,9,9,9);
// m_ImageContent->setContentsMargins(0,9,9,9);
// m_ContainerContent->setContentsMargins(0,9,9,9);
// m_ShowThresholdGroupBox->setContentsMargins(0,9,9,9);
//m_ThresholdValueContent->setContentsMargins(0,9,9,9);
//m_ThresholdFinder->setFlat(true);
//m_ThresholdSelectDataGroupBox->setFlat(true);
//m_ImageContent->setFlat(true);
//m_ContainerContent->setFlat(true);
//m_ShowThresholdGroupBox->setFlat(true);
//m_ThresholdValueContent->setFlat(true);
QVBoxLayout* guiLayout = new QVBoxLayout(m_GUI);
m_GUI->setLayout(guiLayout);
guiLayout->addWidget(m_ThresholdFinder);
QVBoxLayout* thresholdFinderLayout = new QVBoxLayout(m_ThresholdFinder);
thresholdFinderLayout->setContentsMargins(0,9,0,9);
m_ThresholdFinder->setLayout(thresholdFinderLayout);
thresholdFinderLayout->addWidget(m_ThresholdSelectDataGroupBox);
thresholdFinderLayout->addWidget(m_ImageContent);
QVBoxLayout* thresholdSelectDataGroupBoxLayout = new QVBoxLayout(m_ThresholdSelectDataGroupBox);
thresholdSelectDataGroupBoxLayout->setContentsMargins(0,9,0,9);
m_ThresholdSelectDataGroupBox->setLayout(thresholdSelectDataGroupBoxLayout);
thresholdSelectDataGroupBoxLayout->addWidget(m_TreeNodeSelector);
QVBoxLayout* imageContentLayout = new QVBoxLayout(m_ImageContent);
imageContentLayout->setContentsMargins(0,9,0,9);
m_ImageContent->setLayout(imageContentLayout);
imageContentLayout->addWidget(m_ContainerContent);
QVBoxLayout* containerContentLayout = new QVBoxLayout(m_ContainerContent);
containerContentLayout->setContentsMargins(0,9,0,9);
m_ContainerContent->setLayout(containerContentLayout);
containerContentLayout->addWidget(m_ShowThresholdGroupBox);
QVBoxLayout* showThresholdGroupBoxLayout = new QVBoxLayout(m_ShowThresholdGroupBox);
showThresholdGroupBoxLayout->setContentsMargins(0,9,0,9);
m_ShowThresholdGroupBox->setLayout(showThresholdGroupBoxLayout);
QHBoxLayout* thresholdInputLayout = new QHBoxLayout(m_ShowThresholdGroupBox);
thresholdInputLayout->addWidget(m_ThresholdInputNumber);
thresholdInputLayout->addWidget(m_ThresholdInputSlider);
showThresholdGroupBoxLayout->addLayout(thresholdInputLayout);
showThresholdGroupBoxLayout->addWidget(m_ThresholdValueContent);
QVBoxLayout* thresholdValueContentLayout = new QVBoxLayout(m_ThresholdValueContent);
thresholdValueContentLayout->setContentsMargins(0,9,0,9);
m_ThresholdValueContent->setLayout(thresholdValueContentLayout);
thresholdValueContentLayout->addWidget(m_DeleateImageIfDeactivatedCheckBox);
thresholdValueContentLayout->addWidget(m_CreateSegmentationButton);
this->CreateConnections();
SetDataStorage(dataStorage);
m_TreeNodeSelector->SetDataStorage(dataStorage);
m_TreeNodeSelector->SetPredicate(mitk::NodePredicateDataType::New("Image"));
if(m_ShowSelector)
{
m_ImageContent->setShown( m_ThresholdSelectDataGroupBox->isChecked());
//m_ImageContent->setShown(true);
}
else
{
m_ThresholdSelectDataGroupBox->setShown(m_ShowSelector);
//m_ThresholdSelectDataGroupBox->setShown(true);
}
}
/*************** GET CONTENT CONTAINER ***************/
QGroupBox * QmitkThresholdComponent::GetContentContainer()
{
return m_ContainerContent;
}
/************ GET MAIN CHECK BOX CONTAINER ************/
QGroupBox * QmitkThresholdComponent::GetMainCheckBoxContainer()
{
return m_ThresholdFinder;
}
///*********** SET CONTENT CONTAINER VISIBLE ************/
//void QmitkThresholdComponent::SetContentContainerVisibility()
//{
// for(unsigned int i = 0; i < m_AddedChildList.size(); i++)
// {
// if(m_AddedChildList[i]->GetContentContainer() != NULL)
// {
// m_AddedChildList[i]->GetContentContainer()->setShown(GetMainCheckBoxContainer()->isChecked());
// }
// }
//}
/*************** ACTIVATED ***************/
void QmitkThresholdComponent::Activated()
{
QmitkBaseFunctionalityComponent::Activated();
m_Active = true;
for(unsigned int i = 0; i < m_AddedChildList.size(); i++)
{
m_AddedChildList[i]->Activated();
}
CreateThresholdImageNode();
ShowThreshold();
SetSliderRange();
}
/*************** DEACTIVATED ***************/
void QmitkThresholdComponent::Deactivated()
{
QmitkBaseFunctionalityComponent::Deactivated();
m_Active = false;
for(unsigned int i = 0; i < m_AddedChildList.size(); i++)
{
m_AddedChildList[i]->Deactivated();
}
ShowThreshold();
if( m_DeleateImageIfDeactivatedCheckBox->isChecked())
{
DeleteThresholdNode();
}
}
///************ SHOW THRESHOLD FINDER CONTENT ***********/
void QmitkThresholdComponent::ShowThresholdFinderContent(bool)
{
// m_ShowThresholdGroupBox->setShown( m_ThresholdFinder->isChecked());
// m_ContainerContent->setShown( m_ThresholdSelectDataGroupBox->isChecked());
m_ContainerContent->setShown( m_ThresholdFinder->isChecked());
if(m_ShowSelector)
{
//m_ThresholdSelectDataGroupBox->setShown( m_ThresholdSelectDataGroupBox->isChecked());
//m_ThresholdSelectDataGroupBox->setShown( true);
m_ThresholdSelectDataGroupBox->setShown(m_ThresholdFinder->isChecked());
}
//ShowThreshold();
}
///*************** SHOW IMAGE CONTENT **************/
void QmitkThresholdComponent::ShowImageContent(bool)
{
//m_ImageContent->setShown( m_ThresholdSelectDataGroupBox->isChecked());
m_ImageContent->setShown( true);
if(m_ShowSelector)
{
//m_ImageContent->setShown( m_ThresholdSelectDataGroupBox->isChecked());
m_ImageContent->setShown( true);
}
else
{
//m_ThresholdSelectDataGroupBox->setShown(m_ShowSelector);
m_ThresholdSelectDataGroupBox->setShown(true);
}
}
///*************** SHOW THRESHOLD **************/
void QmitkThresholdComponent::ShowThreshold(bool)
{
if(m_ThresholdImageNode)
{
if(m_Active == true)
{
m_ThresholdImageNode->SetProperty("visible", mitk::BoolProperty::New(( m_ThresholdFinder->isChecked())) );
}
else
{
if( m_DeleateImageIfDeactivatedCheckBox->isChecked())
{
m_ThresholdImageNode->SetProperty("visible", mitk::BoolProperty::New((false)) );
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
///*************** THRESHOLD VALUE CHANGED **************/
//By Slider
void QmitkThresholdComponent::ThresholdSliderChanged(int)
{
int value = m_ThresholdInputSlider->value();
if (m_ThresholdImageNode)
{
m_ThresholdImageNode->SetLevelWindow(mitk::LevelWindow(value,1));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
m_ThresholdInputNumber->setText(QString::number(value));
}
///*************** THRESHOLD VALUE CHANGED **************/
//By LineEdit
void QmitkThresholdComponent::ThresholdValueChanged( )
{
int value = atoi( m_ThresholdInputNumber->text().toLocal8Bit().constData() );
if (m_ThresholdImageNode)
{
m_ThresholdImageNode->SetLevelWindow(mitk::LevelWindow(value,1));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
m_ThresholdInputSlider->setValue(value);
}
///*************** SET SLIDER RANGE **************/
void QmitkThresholdComponent::SetSliderRange()
{
if(m_Active)
{
if( m_ThresholdFinder->isChecked()==true)
{
if(!m_TreeNodeSelector->GetSelectedNode())
return;
if(!m_TreeNodeSelector->GetSelectedNode()->GetData())
return;
mitk::Image* currentImage = dynamic_cast<mitk::Image*>(m_TreeNodeSelector->GetSelectedNode()->GetData());
if(currentImage)
{
int min = (int) currentImage->GetScalarValueMin();
int max = (int) currentImage->GetScalarValueMaxNoRecompute();
//int realMax = currentImage->GetScalarValueMax();
if(min < -32000)
{
min = (int) currentImage->GetScalarValue2ndMin();
max = (int) currentImage->GetScalarValue2ndMaxNoRecompute();
}
QIntValidator* intValid = new QIntValidator(min-150, max+150, m_ThresholdInputNumber);
m_ThresholdInputNumber->setValidator(intValid);
m_ThresholdInputNumber->setText("1");
m_ThresholdInputSlider->setMinimum(min-150);
m_ThresholdInputSlider->setMaximum(max+150);
m_ThresholdInputSlider->setRange(min-150, max+150);
m_ThresholdInputSlider->setPageStep(1);
m_ThresholdInputSlider->setValue(1);
m_GUI->repaint();
//m_ThresholdInputSlider->resize();
/* m_ThresholdInputSlider->setMinValue((int)currentImage->GetScalarValueMin());
m_ThresholdInputSlider->setMaxValue((int)currentImage->GetScalarValueMaxNoRecompute());*/
}
}
}
}
///*************** DELETE THRESHOLD NODE **************/
void QmitkThresholdComponent::DeleteThresholdNode()
{
if(m_ThresholdImageNode)
{
mitk::DataNode::Pointer foundNode = m_DataStorage->GetNamedNode("Thresholdview image");
foundNode->Delete();
m_ThresholdNodeExisting = false;
return;
}
}
///*************CREATE THRESHOLD IMAGE NODE************/
void QmitkThresholdComponent::CreateThresholdImageNode()
{
if(m_Active)
{
if( m_ThresholdNodeExisting)
return;
if(!m_TreeNodeSelector)
return;
if(!m_TreeNodeSelector->GetSelectedNode())
return;
m_ThresholdImageNode = mitk::DataNode::New();
mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New("Thresholdview image" );
m_ThresholdImageNode->SetProperty( "name", nameProp );
mitk::BoolProperty::Pointer componentThresholdImageProp = mitk::BoolProperty::New(true);
m_ThresholdImageNode->SetProperty( "isComponentThresholdImage", componentThresholdImageProp );
m_ThresholdImageNode->SetData(m_TreeNodeSelector->GetSelectedNode()->GetData());
m_ThresholdImageNode->SetColor(0.0,1.0,0.0);
m_ThresholdImageNode->SetOpacity(.25);
int layer = 0;
m_ThresholdImageNode->GetIntProperty("layer", layer);
m_ThresholdImageNode->SetIntProperty("layer", layer+1);
m_ThresholdImageNode->SetLevelWindow(mitk::LevelWindow(atoi( m_ThresholdInputNumber->text().toLocal8Bit().constData()),1));
m_ThresholdNodeExisting = true;
m_DataStorage->Add(m_ThresholdImageNode);
}
}
/*************CREAET THRESHOLD SEGMENTATION************/
void QmitkThresholdComponent::CreateThresholdSegmentation()
{
mitk::Image::Pointer original = dynamic_cast<mitk::Image*>(m_TreeNodeSelector->GetSelectedNode()->GetData());
// we NEED a reference image for size etc.
if (!original) return;
// actually create a new empty segmentation
mitk::PixelType pixelType( mitk::MakeScalarPixelType<DefaultSegmentationDataType>() );
mitk::Image::Pointer segmentation = mitk::Image::New();
//segmentation->SetProperty( "organ type", OrganTypeProperty::New( organType ) );
segmentation->Initialize( pixelType, original->GetDimension(), original->GetDimensions() );
unsigned int byteSize = sizeof(DefaultSegmentationDataType);
for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
memset( segmentation->GetData(), 0, byteSize );
if (original->GetTimeSlicedGeometry() )
{
- mitk::AffineGeometryFrame3D::Pointer originalGeometryAGF = original->GetTimeSlicedGeometry()->Clone();
- mitk::TimeSlicedGeometry::Pointer originalGeometry = dynamic_cast<mitk::TimeSlicedGeometry*>( originalGeometryAGF.GetPointer() );
+ mitk::TimeSlicedGeometry::Pointer originalGeometry = original->GetTimeSlicedGeometry()->Clone();
segmentation->SetGeometry( originalGeometry );
}
else
{
MITK_INFO<<"Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.";
return ;
}
mitk::DataNode::Pointer emptySegmentationNode = CreateSegmentationNode( segmentation);
if (emptySegmentationNode)
{
// actually perform a thresholding and ask for an organ type
for (unsigned int timeStep = 0; timeStep < original->GetTimeSteps(); ++timeStep)
{
try
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput( original );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
mitk::Image::Pointer image3D = timeSelector->GetOutput();
AccessFixedDimensionByItk_2( image3D, ITKThresholding, 3, dynamic_cast<mitk::Image*>(emptySegmentationNode->GetData()), timeStep );
}
catch(...)
{
MITK_INFO<<"Error accessing single time steps of the original image. Cannot create segmentation.";
}
}
mitk::DataNode::Pointer originalNode = m_TreeNodeSelector->GetSelectedNode();
m_DataStorage->Add( emptySegmentationNode, originalNode ); // add as a child, because the segmentation "derives" from the original
}
}
mitk::DataNode::Pointer QmitkThresholdComponent::CreateSegmentationNode( mitk::Image* image)
{
if (!image) return NULL;
// decorate the datatreenode with some properties
mitk::DataNode::Pointer segmentationNode = mitk::DataNode::New();
segmentationNode->SetData( image );
// name
segmentationNode->SetProperty( "name", mitk::StringProperty::New( "TH segmentation from ThresholdFinder" ) );
// visualization properties
segmentationNode->SetProperty( "binary", mitk::BoolProperty::New(true) );
segmentationNode->SetProperty( "color", mitk::ColorProperty::New(0.0, 1.0, 0.0) );
segmentationNode->SetProperty( "texture interpolation", mitk::BoolProperty::New(false) );
segmentationNode->SetProperty( "layer", mitk::IntProperty::New(10) );
segmentationNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( mitk::LevelWindow(0.5, 1) ) );
segmentationNode->SetProperty( "opacity", mitk::FloatProperty::New(0.3) );
segmentationNode->SetProperty( "segmentation", mitk::BoolProperty::New(true) );
segmentationNode->SetProperty( "showVolume", mitk::BoolProperty::New( false ) );
return segmentationNode;
}
template <typename TPixel, unsigned int VImageDimension>
void QmitkThresholdComponent::ITKThresholding( itk::Image<TPixel, VImageDimension>* originalImage, mitk::Image* segmentation, unsigned int timeStep )
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput( segmentation );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
mitk::Image::Pointer segmentation3D = timeSelector->GetOutput();
typedef itk::Image< DefaultSegmentationDataType, 3> SegmentationType; // this is sure for new segmentations
SegmentationType::Pointer itkSegmentation;
CastToItkImage( segmentation3D, itkSegmentation );
// iterate over original and segmentation
typedef itk::ImageRegionConstIterator< itk::Image<TPixel, VImageDimension> > InputIteratorType;
typedef itk::ImageRegionIterator< SegmentationType > SegmentationIteratorType;
InputIteratorType inputIterator( originalImage, originalImage->GetLargestPossibleRegion() );
SegmentationIteratorType outputIterator( itkSegmentation, itkSegmentation->GetLargestPossibleRegion() );
inputIterator.GoToBegin();
outputIterator.GoToBegin();
while (!outputIterator.IsAtEnd())
{
if ( (signed)inputIterator.Get() >= atoi( m_ThresholdInputNumber->text().toLocal8Bit().constData()) )
{
outputIterator.Set( 1 );
}
else
{
outputIterator.Set( 0 );
}
++inputIterator;
++outputIterator;
}
}
diff --git a/Modules/QmitkExt/QmitkHistogramJSWidget.cpp b/Modules/QmitkExt/QmitkHistogramJSWidget.cpp
index c0a2e33188..0cfc54184a 100644
--- a/Modules/QmitkExt/QmitkHistogramJSWidget.cpp
+++ b/Modules/QmitkExt/QmitkHistogramJSWidget.cpp
@@ -1,293 +1,293 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkHistogramJSWidget.h"
#include "mitkPixelTypeMultiplex.h"
#include <mitkImagePixelReadAccessor.h>
#include "mitkRenderingManager.h"
#include "mitkBaseRenderer.h"
#include "mitkImageTimeSelector.h"
#include "mitkExtractSliceFilter.h"
QmitkHistogramJSWidget::QmitkHistogramJSWidget(QWidget *parent) :
QWebView(parent)
{
// set histogram type to barchart in first instance
m_UseLineGraph = false;
// set html from source
connect(page()->mainFrame(), SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(AddJSObject()));
QUrl myUrl = QUrl("qrc:/qmitk/Histogram.html");
setUrl(myUrl);
// set Scrollbars to be always disabled
page()->mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
page()->mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
m_ParametricPath = ParametricPathType::New();
}
QmitkHistogramJSWidget::~QmitkHistogramJSWidget()
{
}
// adds an Object of Type QmitkHistogramJSWidget to the JavaScript, using QtWebkitBridge
void QmitkHistogramJSWidget::AddJSObject()
{
page()->mainFrame()->addToJavaScriptWindowObject(QString("histogramData"), this);
}
// reloads WebView, everytime its size has been changed, so the size of the Histogram fits to the size of the widget
void QmitkHistogramJSWidget::resizeEvent(QResizeEvent* resizeEvent)
{
QWebView::resizeEvent(resizeEvent);
this->reload();
}
// method to expose data to JavaScript by using properties
void QmitkHistogramJSWidget::ComputeHistogram(HistogramType* histogram)
{
m_Histogram = histogram;
HistogramConstIteratorType startIt = m_Histogram->End();
HistogramConstIteratorType endIt = m_Histogram->End();
- HistogramConstIteratorType it;
+ HistogramConstIteratorType it = m_Histogram->Begin();
ClearData();
unsigned int i = 0;
bool firstValue = false;
// removes frequencies of 0, which are outside the first and last bin
- for (it = m_Histogram->Begin() ; it != m_Histogram->End(); ++it)
+ for (; it != m_Histogram->End(); ++it)
{
if (it.GetFrequency() > 0.0)
{
endIt = it;
if (!firstValue)
{
firstValue = true;
startIt = it;
}
}
}
++endIt;
// generating Lists of measurement and frequencies
for (it = startIt ; it != endIt; ++it, ++i)
{
- QVariant frequency = it.GetFrequency();
+ QVariant frequency = QVariant::fromValue(it.GetFrequency());
QVariant measurement = it.GetMeasurementVector()[0];
m_Frequency.insert(i, frequency);
m_Measurement.insert(i, measurement);
}
m_IntensityProfile = false;
this->SignalDataChanged();
}
void QmitkHistogramJSWidget::ClearData()
{
m_Frequency.clear();
m_Measurement.clear();
}
void QmitkHistogramJSWidget::ClearHistogram()
{
this->ClearData();
this->SignalDataChanged();
}
QList<QVariant> QmitkHistogramJSWidget::GetFrequency()
{
return m_Frequency;
}
QList<QVariant> QmitkHistogramJSWidget::GetMeasurement()
{
return m_Measurement;
}
bool QmitkHistogramJSWidget::GetUseLineGraph()
{
return m_UseLineGraph;
}
void QmitkHistogramJSWidget::OnBarRadioButtonSelected()
{
m_UseLineGraph = false;
this->SignalGraphChanged();
}
void QmitkHistogramJSWidget::OnLineRadioButtonSelected()
{
m_UseLineGraph = true;
this->SignalGraphChanged();
}
void QmitkHistogramJSWidget::SetImage(mitk::Image* image)
{
m_Image = image;
}
void QmitkHistogramJSWidget::SetPlanarFigure(const mitk::PlanarFigure* planarFigure)
{
m_PlanarFigure = planarFigure;
}
template <class PixelType>
void ReadPixel(mitk::PixelType ptype, mitk::Image::Pointer image, mitk::Index3D indexPoint, double& value)
{
if (image->GetDimension() == 2)
{
mitk::ImagePixelReadAccessor<PixelType,2> readAccess(image, image->GetSliceData(0));
itk::Index<2> idx;
idx[0] = indexPoint[0];
idx[1] = indexPoint[1];
value = readAccess.GetPixelByIndex(idx);
}
else if (image->GetDimension() == 3)
{
mitk::ImagePixelReadAccessor<PixelType,3> readAccess(image, image->GetVolumeData(0));
itk::Index<3> idx;
idx[0] = indexPoint[0];
idx[1] = indexPoint[1];
idx[2] = indexPoint[2];
value = readAccess.GetPixelByIndex(idx);
}
else
{
//unhandled
}
}
void QmitkHistogramJSWidget::ComputeIntensityProfile(unsigned int timeStep)
{
this->ClearData();
m_ParametricPath->Initialize();
if (m_PlanarFigure.IsNull())
{
mitkThrow() << "PlanarFigure not set!";
}
if (m_Image.IsNull())
{
mitkThrow() << "Image not set!";
}
// Get 2D geometry frame of PlanarFigure
mitk::Geometry2D* planarFigureGeometry2D = dynamic_cast<mitk::Geometry2D*>(m_PlanarFigure->GetGeometry(0));
if (planarFigureGeometry2D == NULL)
{
mitkThrow() << "PlanarFigure has no valid geometry!";
}
// Get 3D geometry from Image (needed for conversion of point to index)
mitk::Geometry3D* imageGeometry = m_Image->GetGeometry(0);
if (imageGeometry == NULL)
{
mitkThrow() << "Image has no valid geometry!";
}
// Get first poly-line of PlanarFigure (other possible poly-lines in PlanarFigure
// are not supported)
const VertexContainerType vertexContainer = m_PlanarFigure->GetPolyLine(0);
VertexContainerType::const_iterator it;
for (it = vertexContainer.begin(); it != vertexContainer.end(); ++it)
{
// Map PlanarFigure 2D point to 3D point
mitk::Point3D point3D;
planarFigureGeometry2D->Map(it->Point, point3D);
// Convert world to index coordinates
mitk::Point3D indexPoint3D;
imageGeometry->WorldToIndex(point3D, indexPoint3D);
ParametricPathType::OutputType index;
index[0] = indexPoint3D[0];
index[1] = indexPoint3D[1];
index[2] = indexPoint3D[2];
// Add index to parametric path
m_ParametricPath->AddVertex(index);
}
m_DerivedPath = m_ParametricPath;
if (m_DerivedPath.IsNull())
{
mitkThrow() << "No path set!";
}
// Fill item model with line profile data
double distance = 0.0;
mitk::Point3D currentWorldPoint;
double t;
unsigned int i = 0;
for (i = 0, t = m_DerivedPath->StartOfInput(); ;++i)
{
const PathType::OutputType &continousIndex = m_DerivedPath->Evaluate(t);
mitk::Point3D worldPoint;
imageGeometry->IndexToWorld(continousIndex, worldPoint);
if (i == 0)
{
currentWorldPoint = worldPoint;
}
distance += currentWorldPoint.EuclideanDistanceTo(worldPoint);
mitk::Index3D indexPoint;
imageGeometry->WorldToIndex(worldPoint, indexPoint);
const mitk::PixelType ptype = m_Image->GetPixelType();
double intensity = 0.0;
if (m_Image->GetDimension() == 4)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(m_Image);
timeSelector->SetTimeNr(timeStep);
timeSelector->Update();
mitk::Image::Pointer image = timeSelector->GetOutput();
mitkPixelTypeMultiplex3( ReadPixel, ptype, image, indexPoint, intensity);
}
else
{
mitkPixelTypeMultiplex3( ReadPixel, ptype, m_Image, indexPoint, intensity);
}
m_Measurement.insert(i, distance);
m_Frequency.insert(i, intensity);
// Go to next index; when iteration offset reaches zero, iteration is finished
PathType::OffsetType offset = m_DerivedPath->IncrementInput(t);
if (!(offset[0] || offset[1] || offset[2]))
{
break;
}
currentWorldPoint = worldPoint;
}
m_IntensityProfile = true;
m_UseLineGraph = true;
this->SignalDataChanged();
}
bool QmitkHistogramJSWidget::GetIntensityProfile()
{
return m_IntensityProfile;
}
diff --git a/Modules/QmitkExt/QmitkHistogramWidget.cpp b/Modules/QmitkExt/QmitkHistogramWidget.cpp
index 5f2d780b26..fee42eb4b5 100644
--- a/Modules/QmitkExt/QmitkHistogramWidget.cpp
+++ b/Modules/QmitkExt/QmitkHistogramWidget.cpp
@@ -1,187 +1,183 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkHistogramWidget.h"
#include "mitkImageStatisticsHolder.h"
#include <qlabel.h>
#include <qpen.h>
#include <qgroupbox.h>
#include <qwt_plot_grid.h>
#include <qwt_interval_data.h>
#include <qwt_array.h>
#include <qwt_text_label.h>
#include <qwt_text.h>
#include <qwt_symbol.h>
//#include <iostream>
QmitkHistogramWidget::QmitkHistogramWidget(QWidget * parent, bool showreport)
: QDialog(parent)
{
QBoxLayout *layout = new QVBoxLayout(this);
//***histogram***
QGroupBox *hgroupbox = new QGroupBox("", this);
hgroupbox->setMinimumSize(900, 400);
m_Plot = new QwtPlot(hgroupbox);
m_Plot->setCanvasBackground(QColor(Qt::white));
m_Plot->setTitle("Histogram");
QwtText text = m_Plot->titleLabel()->text();
text.setFont(QFont("Helvetica", 12, QFont::Normal));
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->enableYMin(true);
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(m_Plot);
layout->addWidget(hgroupbox);
layout->setSpacing(20);
if (showreport == true)
{
//***report***
QGroupBox *rgroupbox = new QGroupBox("", this);
rgroupbox->setMinimumSize(900, 400);
QLabel *label = new QLabel("Gray Value Analysis", rgroupbox);
label->setAlignment(Qt::AlignHCenter);
label->setFont(QFont("Helvetica", 14, QFont::Bold));
m_Textedit = new QTextEdit(rgroupbox);
m_Textedit->setFont(QFont("Helvetica", 12, QFont::Normal));
m_Textedit->setReadOnly(true);
layout->addWidget(rgroupbox);
}
m_Picker = new QwtPlotPicker(QwtPlot::xBottom, QwtPlot::yLeft,
QwtPicker::PointSelection,
QwtPlotPicker::NoRubberBand, QwtPicker::AlwaysOn,
m_Plot->canvas());
connect(m_Picker, SIGNAL(selected(const QwtDoublePoint &)),
SLOT(OnSelect(const QwtDoublePoint &)));
}
QmitkHistogramWidget::~QmitkHistogramWidget()
{
}
void QmitkHistogramWidget::SetHistogram(HistogramType::ConstPointer itkHistogram)
{
HistogramType::SizeType size = itkHistogram->GetSize();
HistogramType::IndexType index;
HistogramType::MeasurementVectorType currentMeasurementVector;
QwtArray<QwtDoubleInterval> xValues(size[0]);
QwtArray<double> yValues(size[0]);
for (unsigned int i = 0; i < size[0]; ++i)
{
-#if !defined(ITK_USE_REVIEW_STATISTICS)
- index[0] = static_cast<HistogramType::IndexType::IndexValueType> (i);
-#else
index[0] = static_cast<HistogramType::IndexValueType> (i);
-#endif
currentMeasurementVector = itkHistogram->GetMeasurementVector(index);
if (currentMeasurementVector[0] != 0.0)
{
xValues[i] = QwtDoubleInterval(Round(currentMeasurementVector[0]-1), Round(currentMeasurementVector[0]));
yValues[i] = static_cast<double> (itkHistogram->GetFrequency(index));
}
}
// rebuild the plot
m_Plot->clear();
m_Histogram = new QmitkHistogram();
m_Histogram->setColor(Qt::darkCyan);
m_Histogram->setData(QwtIntervalData(xValues, yValues));
m_Histogram->attach(m_Plot);
this->InitializeMarker();
this->InitializeZoomer();
m_Plot->replot();
}
void QmitkHistogramWidget::SetHistogram( mitk::Image* mitkImage )
{
this->SetHistogram(mitkImage->GetStatistics()->GetScalarHistogram());
}
void QmitkHistogramWidget::SetReport(std::string report)
{
m_Textedit->setText(report.c_str());
}
void QmitkHistogramWidget::InitializeMarker()
{
m_Marker = new QwtPlotMarker();
m_Marker->setXValue(0.);
m_Marker->setLineStyle(QwtPlotMarker::VLine);
m_Marker->setLabelAlignment(Qt::AlignHCenter | Qt::AlignRight);
m_Marker->setLinePen(QPen(QColor(200,150,0), 3, Qt::SolidLine));
m_Marker->setSymbol( QwtSymbol(QwtSymbol::Diamond,
QColor(Qt::red), QColor(Qt::red), QSize(10,10)));
m_Marker->attach(m_Plot);
}
void QmitkHistogramWidget::InitializeZoomer()
{
m_Zoomer = new QwtPlotZoomer(m_Plot->xBottom, m_Plot->yLeft, m_Plot->canvas());
m_Zoomer->setRubberBandPen(QPen(Qt::red, 2, Qt::DotLine));
m_Zoomer->setTrackerPen(QPen(Qt::red));
m_Zoomer->setSelectionFlags(QwtPlotZoomer::RectSelection);
}
void QmitkHistogramWidget::OnSelect( const QwtDoublePoint& pos )
{
m_Marker->setXValue( this->Round(pos.x()) );
//unsigned int count = (unsigned int)(m_Histogram->data().value(pos.x()));
QString str = QString( "%1" )
.arg( (int)(this->Round(pos.x())), 0, 10 );
QwtText text(str);
text.setBackgroundBrush(QColor(200,150,0));
text.setFont(QFont("Helvetica", 14, QFont::Bold));
m_Marker->setLabel(text);
m_Plot->replot();
}
double QmitkHistogramWidget::GetMarkerPosition()
{
return m_Marker->xValue();
}
double QmitkHistogramWidget::Round(double val)
{
double ival = (double)(int)val;
if( (val - ival) > 0.5)
return ival+1;
else
return ival;
}
diff --git a/Modules/QmitkExt/QmitkLineEdit.cpp b/Modules/QmitkExt/QmitkLineEdit.cpp
new file mode 100644
index 0000000000..c3a667d038
--- /dev/null
+++ b/Modules/QmitkExt/QmitkLineEdit.cpp
@@ -0,0 +1,105 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "QmitkLineEdit.h"
+#include <QApplication>
+
+QmitkLineEdit::QmitkLineEdit(QWidget* parent)
+ : QLineEdit(parent)
+{
+ this->Initialize();
+}
+
+QmitkLineEdit::QmitkLineEdit(const QString& defaultText, QWidget* parent)
+ : QLineEdit(parent),
+ m_DefaultText(defaultText)
+{
+ this->Initialize();
+}
+
+QmitkLineEdit::~QmitkLineEdit()
+{
+}
+
+void QmitkLineEdit::focusInEvent(QFocusEvent* event)
+{
+ QLineEdit::focusInEvent(event);
+ emit this->FocusChanged(true);
+}
+
+void QmitkLineEdit::focusOutEvent(QFocusEvent* event)
+{
+ QLineEdit::focusOutEvent(event);
+ emit this->FocusChanged(false);
+}
+
+QString QmitkLineEdit::GetDefaultText() const
+{
+ return m_DefaultText;
+}
+
+void QmitkLineEdit::Initialize()
+{
+ m_DefaultPalette.setColor(QPalette::Text, QApplication::palette().color(QPalette::Disabled, QPalette::Text));
+
+ this->ShowDefaultText(true);
+
+ connect(this, SIGNAL(FocusChanged(bool)), this, SLOT(OnFocusChanged(bool)));
+ connect(this, SIGNAL(textChanged(const QString&)), this, SLOT(OnTextChanged(const QString&)));
+}
+
+void QmitkLineEdit::OnFocusChanged(bool hasFocus)
+{
+ if (hasFocus)
+ {
+ if (this->text() == m_DefaultText && this->palette() == m_DefaultPalette)
+ this->ShowDefaultText(false);
+ }
+ else
+ {
+ if (this->text().isEmpty())
+ this->ShowDefaultText(true);
+ }
+}
+
+void QmitkLineEdit::OnTextChanged(const QString& text)
+{
+ if (this->palette() == m_DefaultPalette)
+ this->setPalette(QPalette());
+}
+
+void QmitkLineEdit::SetDefaultText(const QString& defaultText)
+{
+ m_DefaultText = defaultText;
+}
+
+void QmitkLineEdit::ShowDefaultText(bool show)
+{
+ this->blockSignals(true);
+
+ if (show)
+ {
+ this->setPalette(m_DefaultPalette);
+ this->setText(m_DefaultText);
+ }
+ else
+ {
+ this->setPalette(QPalette());
+ this->clear();
+ }
+
+ this->blockSignals(false);
+}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkLineEdit.h b/Modules/QmitkExt/QmitkLineEdit.h
similarity index 50%
rename from Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkLineEdit.h
rename to Modules/QmitkExt/QmitkLineEdit.h
index 599db72b2e..b0e1f3756a 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkLineEdit.h
+++ b/Modules/QmitkExt/QmitkLineEdit.h
@@ -1,56 +1,56 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#ifndef QMITKLINEEDIT_H
-#define QMITKLINEEDIT_H
+#ifndef QmitkLineEdit_h
+#define QmitkLineEdit_h
+#include <QmitkExtExports.h>
#include <QLineEdit>
-class QmitkLineEdit : public QLineEdit
+class QmitkExt_EXPORT QmitkLineEdit : public QLineEdit
{
Q_OBJECT
-
- Q_PROPERTY(QString defaultText READ defaultText WRITE setDefaultText)
+ Q_PROPERTY(QString DefaultText READ GetDefaultText WRITE SetDefaultText FINAL)
public:
- explicit QmitkLineEdit(QWidget *parent = NULL);
- explicit QmitkLineEdit(const QString &defaultText, QWidget *parent = NULL);
+ explicit QmitkLineEdit(QWidget* parent = NULL);
+ explicit QmitkLineEdit(const QString& defaultText, QWidget* parent = NULL);
~QmitkLineEdit();
- QString defaultText() const;
- void setDefaultText(const QString &defaultText);
-
-signals:
- void focusChanged(bool hasFocus);
+ QString GetDefaultText() const;
+ void SetDefaultText(const QString& defaultText);
protected:
- void focusInEvent(QFocusEvent *event);
- void focusOutEvent(QFocusEvent *event);
+ void focusInEvent(QFocusEvent* event);
+ void focusOutEvent(QFocusEvent* event);
+
+private:
+ void Initialize();
+ void ShowDefaultText(bool show);
+
+signals:
+ void FocusChanged(bool hasFocus);
private slots:
- void onFocusChanged(bool hasFocus);
- void onTextChanged(const QString &text);
+ void OnFocusChanged(bool hasFocus);
+ void OnTextChanged(const QString& text);
private:
- void initialize();
- void showDefaultText(bool show);
-
QString m_DefaultText;
- QPalette m_Palette;
QPalette m_DefaultPalette;
};
#endif
diff --git a/Modules/QmitkExt/QmitkSlicesInterpolator.cpp b/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
index 8e89b7ba79..5b8693c764 100644
--- a/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
+++ b/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
@@ -1,1079 +1,1074 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkSlicesInterpolator.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkSelectableGLWidget.h"
#include "mitkToolManager.h"
#include "mitkDataNodeFactory.h"
#include "mitkLevelWindowProperty.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkRenderingManager.h"
#include "mitkOverwriteSliceImageFilter.h"
#include "mitkProgressBar.h"
#include "mitkGlobalInteraction.h"
#include "mitkOperationEvent.h"
#include "mitkUndoController.h"
#include "mitkInteractionConst.h"
#include "mitkApplyDiffImageOperation.h"
#include "mitkDiffImageApplier.h"
#include "mitkSegTool2D.h"
#include "mitkCoreObjectFactory.h"
#include "mitkSurfaceToImageFilter.h"
#include <itkCommand.h>
#include <QCheckBox>
#include <QPushButton>
#include <QMenu>
#include <QCursor>
#include <QHBoxLayout>
#include <QMessageBox>
#define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
const std::map<QAction*, unsigned int> QmitkSlicesInterpolator::createActionToSliceDimension()
{
std::map<QAction*, unsigned int> actionToSliceDimension;
actionToSliceDimension[new QAction("Axial (red window)", 0)] = 2;
actionToSliceDimension[new QAction("Sagittal (green window)", 0)] = 0;
actionToSliceDimension[new QAction("Coronal (blue window)", 0)] = 1;
return actionToSliceDimension;
}
QmitkSlicesInterpolator::QmitkSlicesInterpolator(QWidget* parent, const char* /*name*/)
:QWidget(parent),
ACTION_TO_SLICEDIMENSION( createActionToSliceDimension() ),
m_Interpolator( mitk::SegmentationInterpolationController::New() ),
m_MultiWidget(NULL),
m_ToolManager(NULL),
m_Initialized(false),
m_LastSliceDimension(2),
m_LastSliceIndex(0),
m_2DInterpolationEnabled(false),
m_3DInterpolationEnabled(false)
{
m_SurfaceInterpolator = mitk::SurfaceInterpolationController::GetInstance();
QHBoxLayout* layout = new QHBoxLayout(this);
m_GroupBoxEnableExclusiveInterpolationMode = new QGroupBox("Interpolation", this);
QGridLayout* grid = new QGridLayout(m_GroupBoxEnableExclusiveInterpolationMode);
m_RBtnEnable3DInterpolation = new QRadioButton("3D",this);
connect(m_RBtnEnable3DInterpolation, SIGNAL(toggled(bool)), this, SLOT(On3DInterpolationEnabled(bool)));
m_RBtnEnable3DInterpolation->setChecked(true);
m_RBtnEnable3DInterpolation->setToolTip("Interpolate a binary volume from a set of arbitrarily arranged contours.");
grid->addWidget(m_RBtnEnable3DInterpolation,0,0);
m_BtnAccept3DInterpolation = new QPushButton("Accept", this);
m_BtnAccept3DInterpolation->setEnabled(false);
connect(m_BtnAccept3DInterpolation, SIGNAL(clicked()), this, SLOT(OnAccept3DInterpolationClicked()));
grid->addWidget(m_BtnAccept3DInterpolation, 0,1);
m_CbShowMarkers = new QCheckBox("Show Position Nodes", this);
m_CbShowMarkers->setChecked(false);
connect(m_CbShowMarkers, SIGNAL(toggled(bool)), this, SLOT(OnShowMarkers(bool)));
connect(m_CbShowMarkers, SIGNAL(toggled(bool)), this, SIGNAL(SignalShowMarkerNodes(bool)));
grid->addWidget(m_CbShowMarkers,0,2);
m_RBtnEnable2DInterpolation = new QRadioButton("2D",this);
connect(m_RBtnEnable2DInterpolation, SIGNAL(toggled(bool)), this, SLOT(On2DInterpolationEnabled(bool)));
m_RBtnEnable2DInterpolation ->setToolTip("Interpolate contours in left-out slices from a set of slice-by-slice arranged contours.");
grid->addWidget(m_RBtnEnable2DInterpolation,1,0);
m_BtnAcceptInterpolation = new QPushButton("Accept", this);
m_BtnAcceptInterpolation->setEnabled( false );
connect( m_BtnAcceptInterpolation, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()) );
grid->addWidget(m_BtnAcceptInterpolation,1,1);
m_BtnAcceptAllInterpolations = new QPushButton("... for all slices", this);
m_BtnAcceptAllInterpolations->setEnabled( false );
connect( m_BtnAcceptAllInterpolations, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()) );
grid->addWidget(m_BtnAcceptAllInterpolations,1,2);
m_RBtnDisableInterpolation = new QRadioButton("Disable", this);
connect(m_RBtnDisableInterpolation, SIGNAL(toggled(bool)), this, SLOT(OnInterpolationDisabled(bool)));
m_RBtnDisableInterpolation->setToolTip("Disable interpolation.");
grid->addWidget(m_RBtnDisableInterpolation, 2,0);
layout->addWidget(m_GroupBoxEnableExclusiveInterpolationMode);
this->setLayout(layout);
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnInterpolationInfoChanged );
InterpolationInfoChangedObserverTag = m_Interpolator->AddObserver( itk::ModifiedEvent(), command );
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command2->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged );
SurfaceInterpolationInfoChangedObserverTag = m_SurfaceInterpolator->AddObserver( itk::ModifiedEvent(), command2 );
// feedback node and its visualization properties
m_FeedbackNode = mitk::DataNode::New();
mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties( m_FeedbackNode );
m_FeedbackNode->SetProperty( "binary", mitk::BoolProperty::New(true) );
m_FeedbackNode->SetProperty( "outline binary", mitk::BoolProperty::New(true) );
m_FeedbackNode->SetProperty( "color", mitk::ColorProperty::New(255.0, 255.0, 0.0) );
m_FeedbackNode->SetProperty( "texture interpolation", mitk::BoolProperty::New(false) );
m_FeedbackNode->SetProperty( "layer", mitk::IntProperty::New( 20 ) );
m_FeedbackNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( mitk::LevelWindow(0, 1) ) );
m_FeedbackNode->SetProperty( "name", mitk::StringProperty::New("Interpolation feedback") );
m_FeedbackNode->SetProperty( "opacity", mitk::FloatProperty::New(0.8) );
m_FeedbackNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
m_InterpolatedSurfaceNode = mitk::DataNode::New();
m_InterpolatedSurfaceNode->SetProperty( "color", mitk::ColorProperty::New(255.0,255.0,0.0) );
m_InterpolatedSurfaceNode->SetProperty( "name", mitk::StringProperty::New("Surface Interpolation feedback") );
m_InterpolatedSurfaceNode->SetProperty( "opacity", mitk::FloatProperty::New(0.5) );
m_InterpolatedSurfaceNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false));
m_InterpolatedSurfaceNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
m_InterpolatedSurfaceNode->SetVisibility(false);
m_3DContourNode = mitk::DataNode::New();
m_3DContourNode->SetProperty( "color", mitk::ColorProperty::New(0.0, 0.0, 0.0) );
m_3DContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_3DContourNode->SetProperty( "name", mitk::StringProperty::New("Drawn Contours") );
m_3DContourNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New(VTK_WIREFRAME));
m_3DContourNode->SetProperty("material.wireframeLineWidth", mitk::FloatProperty::New(2.0f));
m_3DContourNode->SetProperty("3DContourContainer", mitk::BoolProperty::New(true));
m_3DContourNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false));
m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")));
m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
QWidget::setContentsMargins(0, 0, 0, 0);
if ( QWidget::layout() != NULL )
{
QWidget::layout()->setContentsMargins(0, 0, 0, 0);
}
//For running 3D Interpolation in background
// create a QFuture and a QFutureWatcher
connect(&m_Watcher, SIGNAL(started()), this, SLOT(StartUpdateInterpolationTimer()));
connect(&m_Watcher, SIGNAL(finished()), this, SLOT(OnSurfaceInterpolationFinished()));
connect(&m_Watcher, SIGNAL(finished()), this, SLOT(StopUpdateInterpolationTimer()));
m_Timer = new QTimer(this);
connect(m_Timer, SIGNAL(timeout()), this, SLOT(ChangeSurfaceColor()));
}
void QmitkSlicesInterpolator::SetDataStorage( mitk::DataStorage& storage )
{
m_DataStorage = &storage;
m_SurfaceInterpolator->SetDataStorage(storage);
}
mitk::DataStorage* QmitkSlicesInterpolator::GetDataStorage()
{
if ( m_DataStorage.IsNotNull() )
{
return m_DataStorage;
}
else
{
return NULL;
}
}
void QmitkSlicesInterpolator::Initialize(mitk::ToolManager* toolManager, QmitkStdMultiWidget* multiWidget)
{
if (m_Initialized)
{
// remove old observers
if (m_ToolManager)
{
m_ToolManager->WorkingDataChanged
-= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
m_ToolManager->ReferenceDataChanged
-= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
}
if (m_MultiWidget)
{
disconnect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
slicer->RemoveObserver( TSliceObserverTag );
slicer->RemoveObserver( TTimeObserverTag );
slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
slicer->RemoveObserver( SSliceObserverTag );
slicer->RemoveObserver( STimeObserverTag );
slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
slicer->RemoveObserver( FSliceObserverTag );
slicer->RemoveObserver( FTimeObserverTag );
}
//return;
}
m_MultiWidget = multiWidget;
connect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
m_ToolManager = toolManager;
if (m_ToolManager)
{
// set enabled only if a segmentation is selected
mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
QWidget::setEnabled( node != NULL );
// react whenever the set of selected segmentation changes
m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
// connect to the steppers of the three multi widget widgets. after each change, call the interpolator
if (m_MultiWidget)
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
m_TimeStep.resize(3);
m_TimeStep[2] = slicer->GetTime()->GetPos();
{
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnAxialTimeChanged );
TTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
}
{
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnAxialSliceChanged );
TSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
// connect to the steppers of the three multi widget widgets. after each change, call the interpolator
slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
m_TimeStep[0] = slicer->GetTime()->GetPos();
{
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalTimeChanged );
STimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
}
{
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalSliceChanged );
SSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
// connect to the steppers of the three multi widget widgets. after each change, call the interpolator
slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
m_TimeStep[1] = slicer->GetTime()->GetPos();
{
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalTimeChanged );
FTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
}
{
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalSliceChanged );
FSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
}
}
m_Initialized = true;
}
QmitkSlicesInterpolator::~QmitkSlicesInterpolator()
{
if (m_MultiWidget)
{
mitk::SliceNavigationController* slicer;
if(m_MultiWidget->mitkWidget1 != NULL)
{
slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
slicer->RemoveObserver( TSliceObserverTag );
slicer->RemoveObserver( TTimeObserverTag );
}
if(m_MultiWidget->mitkWidget2 != NULL)
{
slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
slicer->RemoveObserver( SSliceObserverTag );
slicer->RemoveObserver( STimeObserverTag );
}
if(m_MultiWidget->mitkWidget3 != NULL)
{
slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
slicer->RemoveObserver( FSliceObserverTag );
slicer->RemoveObserver( FTimeObserverTag );
}
}
if(m_DataStorage->Exists(m_3DContourNode))
m_DataStorage->Remove(m_3DContourNode);
if(m_DataStorage->Exists(m_InterpolatedSurfaceNode))
m_DataStorage->Remove(m_InterpolatedSurfaceNode);
// remove observer
m_Interpolator->RemoveObserver( InterpolationInfoChangedObserverTag );
m_SurfaceInterpolator->RemoveObserver( SurfaceInterpolationInfoChangedObserverTag );
delete m_Timer;
}
void QmitkSlicesInterpolator::On2DInterpolationEnabled(bool status)
{
OnInterpolationActivated(status);
m_Interpolator->Activate2DInterpolation(status);
}
void QmitkSlicesInterpolator::On3DInterpolationEnabled(bool status)
{
On3DInterpolationActivated(status);
}
void QmitkSlicesInterpolator::OnInterpolationDisabled(bool status)
{
if (status)
{
OnInterpolationActivated(!status);
On3DInterpolationActivated(!status);
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::OnShowMarkers(bool state)
{
mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = m_DataStorage->GetSubset(mitk::NodePredicateProperty::New("isContourMarker"
, mitk::BoolProperty::New(true)));
for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
{
it->Value()->SetProperty("helper object", mitk::BoolProperty::New(!state));
}
}
void QmitkSlicesInterpolator::OnToolManagerWorkingDataModified()
{
- //Check if the new working data has already a contourlist for 3D interpolation
- this->SetCurrentContourListID();
+ //For the 3D interpolation
+ SetCurrentContourListID();
if (m_2DInterpolationEnabled)
{
OnInterpolationActivated( true ); // re-initialize if needed
}
- if (m_3DInterpolationEnabled)
- {
- //On3DInterpolationActivated( true);
- SetCurrentContourListID();
- }
}
void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
{
if (m_2DInterpolationEnabled)
{
OnInterpolationActivated( true ); // re-initialize if needed
}
if (m_3DInterpolationEnabled)
{
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::OnAxialTimeChanged(itk::Object* sender, const itk::EventObject& e)
{
const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
m_TimeStep[2] = event.GetPos();
if (m_LastSliceDimension == 2)
{
mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
if (snc) snc->SendSlice(); // will trigger a new interpolation
}
}
void QmitkSlicesInterpolator::OnTransversalTimeChanged(itk::Object* sender, const itk::EventObject& e)
{
this->OnAxialTimeChanged(sender, e);
}
void QmitkSlicesInterpolator::OnSagittalTimeChanged(itk::Object* sender, const itk::EventObject& e)
{
const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
m_TimeStep[0] = event.GetPos();
if (m_LastSliceDimension == 0)
{
mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
if (snc) snc->SendSlice(); // will trigger a new interpolation
}
}
void QmitkSlicesInterpolator::OnFrontalTimeChanged(itk::Object* sender, const itk::EventObject& e)
{
const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
m_TimeStep[1] = event.GetPos();
if (m_LastSliceDimension == 1)
{
mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
if (snc) snc->SendSlice(); // will trigger a new interpolation
}
}
void QmitkSlicesInterpolator::OnAxialSliceChanged(const itk::EventObject& e)
{
if ( TranslateAndInterpolateChangedSlice( e, 2 ) )
{
if (m_MultiWidget)
{
mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget1->GetRenderWindow())->RequestUpdate();
}
}
}
void QmitkSlicesInterpolator::OnTransversalSliceChanged(const itk::EventObject& e)
{
this->OnAxialSliceChanged(e);
}
void QmitkSlicesInterpolator::OnSagittalSliceChanged(const itk::EventObject& e)
{
if ( TranslateAndInterpolateChangedSlice( e, 0 ) )
{
if (m_MultiWidget)
{
mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget2->GetRenderWindow())->RequestUpdate();
}
}
}
void QmitkSlicesInterpolator::OnFrontalSliceChanged(const itk::EventObject& e)
{
if ( TranslateAndInterpolateChangedSlice( e, 1 ) )
{
if (m_MultiWidget)
{
mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget3->GetRenderWindow())->RequestUpdate();
}
}
}
bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const itk::EventObject& e, unsigned int windowID)
{
if (!m_2DInterpolationEnabled) return false;
try
{
const mitk::SliceNavigationController::GeometrySliceEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent&>(e);
mitk::TimeSlicedGeometry* tsg = event.GetTimeSlicedGeometry();
if (tsg && m_TimeStep.size() > windowID)
{
mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(tsg->GetGeometry3D(m_TimeStep[windowID]));
if (slicedGeometry)
{
mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( event.GetPos() ));
if (plane)
Interpolate( plane, m_TimeStep[windowID] );
return true;
}
}
}
catch(std::bad_cast)
{
return false; // so what
}
return false;
}
void QmitkSlicesInterpolator::Interpolate( mitk::PlaneGeometry* plane, unsigned int timeStep )
{
if (m_ToolManager)
{
mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
if (node)
{
m_Segmentation = dynamic_cast<mitk::Image*>(node->GetData());
if (m_Segmentation)
{
int clickedSliceDimension(-1);
int clickedSliceIndex(-1);
// calculate real slice position, i.e. slice of the image and not slice of the TimeSlicedGeometry
mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, clickedSliceDimension, clickedSliceIndex );
mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( clickedSliceDimension, clickedSliceIndex, timeStep );
m_FeedbackNode->SetData( interpolation );
// Workaround for Bug 11318
if ((interpolation.IsNotNull()) && (interpolation->GetGeometry() != NULL))
{
if(clickedSliceDimension == 1)
{
mitk::Point3D orig = interpolation->GetGeometry()->GetOrigin();
orig[0] = orig[0];
orig[1] = orig[1] + 0.5;
orig[2] = orig[2];
interpolation->GetGeometry()->SetOrigin(orig);
}
}
// Workaround for Bug 11318 END
m_LastSliceDimension = clickedSliceDimension;
m_LastSliceIndex = clickedSliceIndex;
}
}
}
}
void QmitkSlicesInterpolator::OnSurfaceInterpolationFinished()
{
mitk::Surface::Pointer interpolatedSurface = m_SurfaceInterpolator->GetInterpolationResult();
if(interpolatedSurface.IsNotNull())
{
m_BtnAccept3DInterpolation->setEnabled(true);
m_InterpolatedSurfaceNode->SetData(interpolatedSurface);
m_3DContourNode->SetData(m_SurfaceInterpolator->GetContoursAsSurface());
this->Show3DInterpolationResult(true);
if( !m_DataStorage->Exists(m_InterpolatedSurfaceNode) && !m_DataStorage->Exists(m_3DContourNode))
{
m_DataStorage->Add(m_3DContourNode);
m_DataStorage->Add(m_InterpolatedSurfaceNode);
}
}
else if (interpolatedSurface.IsNull())
{
m_BtnAccept3DInterpolation->setEnabled(false);
if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
{
this->Show3DInterpolationResult(false);
}
}
if (m_MultiWidget)
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSlicesInterpolator::OnAcceptInterpolationClicked()
{
if (m_Segmentation && m_FeedbackNode->GetData())
{
//making interpolation separately undoable
mitk::UndoStackItem::IncCurrObjectEventId();
mitk::UndoStackItem::IncCurrGroupEventId();
mitk::UndoStackItem::ExecuteIncrement();
mitk::OverwriteSliceImageFilter::Pointer slicewriter = mitk::OverwriteSliceImageFilter::New();
slicewriter->SetInput( m_Segmentation );
slicewriter->SetCreateUndoInformation( true );
slicewriter->SetSliceImage( dynamic_cast<mitk::Image*>(m_FeedbackNode->GetData()) );
slicewriter->SetSliceDimension( m_LastSliceDimension );
slicewriter->SetSliceIndex( m_LastSliceIndex );
slicewriter->SetTimeStep( m_TimeStep[m_LastSliceDimension] );
slicewriter->Update();
m_FeedbackNode->SetData(NULL);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSlicesInterpolator::AcceptAllInterpolations(unsigned int windowID)
{
// first creates a 3D diff image, then applies this diff to the segmentation
if (m_Segmentation)
{
int sliceDimension(-1);
int dummySliceIndex(-1);
if (!GetSliceForWindowsID(windowID, sliceDimension, dummySliceIndex))
{
return; // cannot determine slice orientation
}
//making interpolation separately undoable
mitk::UndoStackItem::IncCurrObjectEventId();
mitk::UndoStackItem::IncCurrGroupEventId();
mitk::UndoStackItem::ExecuteIncrement();
// create a diff image for the undo operation
mitk::Image::Pointer diffImage = mitk::Image::New();
diffImage->Initialize( m_Segmentation );
mitk::PixelType pixelType( mitk::MakeScalarPixelType<short signed int>() );
diffImage->Initialize( pixelType, 3, m_Segmentation->GetDimensions() );
memset( diffImage->GetData(), 0, (pixelType.GetBpe() >> 3) * diffImage->GetDimension(0) * diffImage->GetDimension(1) * diffImage->GetDimension(2) );
// now the diff image is all 0
unsigned int timeStep( m_TimeStep[windowID] );
// a slicewriter to create the diff image
mitk::OverwriteSliceImageFilter::Pointer diffslicewriter = mitk::OverwriteSliceImageFilter::New();
diffslicewriter->SetCreateUndoInformation( false );
diffslicewriter->SetInput( diffImage );
diffslicewriter->SetSliceDimension( sliceDimension );
diffslicewriter->SetTimeStep( timeStep );
unsigned int totalChangedSlices(0);
unsigned int zslices = m_Segmentation->GetDimension( sliceDimension );
mitk::ProgressBar::GetInstance()->AddStepsToDo(zslices);
for (unsigned int sliceIndex = 0; sliceIndex < zslices; ++sliceIndex)
{
mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( sliceDimension, sliceIndex, timeStep );
if (interpolation.IsNotNull()) // we don't check if interpolation is necessary/sensible - but m_Interpolator does
{
diffslicewriter->SetSliceImage( interpolation );
diffslicewriter->SetSliceIndex( sliceIndex );
diffslicewriter->Update();
++totalChangedSlices;
}
mitk::ProgressBar::GetInstance()->Progress();
}
if (totalChangedSlices > 0)
{
// store undo stack items
if ( true )
{
// create do/undo operations (we don't execute the doOp here, because it has already been executed during calculation of the diff image
mitk::ApplyDiffImageOperation* doOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
mitk::ApplyDiffImageOperation* undoOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
undoOp->SetFactor( -1.0 );
std::stringstream comment;
comment << "Accept all interpolations (" << totalChangedSlices << ")";
mitk::OperationEvent* undoStackItem = new mitk::OperationEvent( mitk::DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, comment.str() );
mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
// acutally apply the changes here
mitk::DiffImageApplier::GetInstanceForUndo()->ExecuteOperation( doOp );
}
}
m_FeedbackNode->SetData(NULL);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSlicesInterpolator::FinishInterpolation(int windowID)
{
//this redirect is for calling from outside
if (windowID < 0)
OnAcceptAllInterpolationsClicked();
else
AcceptAllInterpolations( (unsigned int)windowID );
}
void QmitkSlicesInterpolator::OnAcceptAllInterpolationsClicked()
{
QMenu orientationPopup(this);
std::map<QAction*, unsigned int>::const_iterator it;
for(it = ACTION_TO_SLICEDIMENSION.begin(); it != ACTION_TO_SLICEDIMENSION.end(); it++)
orientationPopup.addAction(it->first);
connect( &orientationPopup, SIGNAL(triggered(QAction*)), this, SLOT(OnAcceptAllPopupActivated(QAction*)) );
orientationPopup.exec( QCursor::pos() );
}
void QmitkSlicesInterpolator::OnAccept3DInterpolationClicked()
{
if (m_InterpolatedSurfaceNode.IsNotNull() && m_InterpolatedSurfaceNode->GetData())
{
mitk::SurfaceToImageFilter::Pointer s2iFilter = mitk::SurfaceToImageFilter::New();
s2iFilter->MakeOutputBinaryOn();
s2iFilter->SetInput(dynamic_cast<mitk::Surface*>(m_InterpolatedSurfaceNode->GetData()));
// check if ToolManager holds valid ReferenceData
if (m_ToolManager->GetReferenceData(0) == NULL)
{
return;
}
s2iFilter->SetImage(dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData()));
s2iFilter->Update();
mitk::DataNode* segmentationNode = m_ToolManager->GetWorkingData(0);
segmentationNode->SetData(s2iFilter->GetOutput());
m_RBtnDisableInterpolation->setChecked(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::OnAcceptAllPopupActivated(QAction* action)
{
try
{
std::map<QAction*, unsigned int>::const_iterator iter = ACTION_TO_SLICEDIMENSION.find( action );
if (iter != ACTION_TO_SLICEDIMENSION.end())
{
int windowID = iter->second;
AcceptAllInterpolations( windowID );
}
}
catch(...)
{
/* Showing message box with possible memory error */
QMessageBox errorInfo;
errorInfo.setWindowTitle("Interpolation Process");
errorInfo.setIcon(QMessageBox::Critical);
errorInfo.setText("An error occurred during interpolation. Possible cause: Not enough memory!");
errorInfo.exec();
//additional error message on std::cerr
std::cerr << "Ill construction in " __FILE__ " l. " << __LINE__ << std::endl;
}
}
void QmitkSlicesInterpolator::OnInterpolationActivated(bool on)
{
m_2DInterpolationEnabled = on;
try
{
if ( m_DataStorage.IsNotNull() )
{
if (on && !m_DataStorage->Exists(m_FeedbackNode))
{
m_DataStorage->Add( m_FeedbackNode );
}
//else
//{
// m_DataStorage->Remove( m_FeedbackNode );
//}
}
}
catch(...)
{
// don't care (double add/remove)
}
if (m_ToolManager)
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
QWidget::setEnabled( workingNode != NULL );
m_BtnAcceptAllInterpolations->setEnabled( on );
m_BtnAcceptInterpolation->setEnabled( on );
m_FeedbackNode->SetVisibility( on );
if (!on)
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
if (workingNode)
{
mitk::Image* segmentation = dynamic_cast<mitk::Image*>(workingNode->GetData());
if (segmentation)
{
m_Interpolator->SetSegmentationVolume( segmentation );
if (referenceNode)
{
mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
m_Interpolator->SetReferenceVolume( referenceImage ); // may be NULL
}
}
}
}
UpdateVisibleSuggestion();
}
void QmitkSlicesInterpolator::Run3DInterpolation()
{
m_SurfaceInterpolator->Interpolate();
}
void QmitkSlicesInterpolator::StartUpdateInterpolationTimer()
{
m_Timer->start(500);
}
void QmitkSlicesInterpolator::StopUpdateInterpolationTimer()
{
m_Timer->stop();
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0,255.0,0.0));
mitk::RenderingManager::GetInstance()->RequestUpdate(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetRenderWindow());
}
void QmitkSlicesInterpolator::ChangeSurfaceColor()
{
float currentColor[3];
m_InterpolatedSurfaceNode->GetColor(currentColor);
float yellow[3] = {255.0,255.0,0.0};
if( currentColor[2] == yellow[2])
{
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0,255.0,255.0));
}
else
{
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(yellow));
}
m_InterpolatedSurfaceNode->Update();
mitk::RenderingManager::GetInstance()->RequestUpdate(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetRenderWindow());
}
void QmitkSlicesInterpolator::On3DInterpolationActivated(bool on)
{
m_3DInterpolationEnabled = on;
try
{
if ( m_DataStorage.IsNotNull() && m_ToolManager && m_3DInterpolationEnabled)
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode)
{
bool isInterpolationResult(false);
workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
if ((workingNode->IsSelected() &&
workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")))) &&
!isInterpolationResult && m_3DInterpolationEnabled)
{
int ret = QMessageBox::Yes;
if (m_SurfaceInterpolator->EstimatePortionOfNeededMemory() > 0.5)
{
QMessageBox msgBox;
msgBox.setText("Due to short handed system memory the 3D interpolation may be very slow!");
msgBox.setInformativeText("Are you sure you want to activate the 3D interpolation?");
msgBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
ret = msgBox.exec();
}
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
if (ret == QMessageBox::Yes)
{
m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
m_Watcher.setFuture(m_Future);
}
else
{
m_RBtnDisableInterpolation->toggle();
}
}
else if (!m_3DInterpolationEnabled)
{
this->Show3DInterpolationResult(false);
m_BtnAccept3DInterpolation->setEnabled(m_3DInterpolationEnabled);
}
}
else
{
QWidget::setEnabled( false );
m_CbShowMarkers->setEnabled(m_3DInterpolationEnabled);
}
}
if (!m_3DInterpolationEnabled)
{
this->Show3DInterpolationResult(false);
m_BtnAccept3DInterpolation->setEnabled(m_3DInterpolationEnabled);
}
}
catch(...)
{
MITK_ERROR<<"Error with 3D surface interpolation!";
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::EnableInterpolation(bool on)
{
// only to be called from the outside world
// just a redirection to OnInterpolationActivated
OnInterpolationActivated(on);
}
void QmitkSlicesInterpolator::Enable3DInterpolation(bool on)
{
// only to be called from the outside world
// just a redirection to OnInterpolationActivated
On3DInterpolationActivated(on);
}
void QmitkSlicesInterpolator::UpdateVisibleSuggestion()
{
if (m_2DInterpolationEnabled)
{
// determine which one is the current view, try to do an initial interpolation
mitk::BaseRenderer* renderer = mitk::GlobalInteraction::GetInstance()->GetFocus();
if (renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
{
const mitk::TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>( renderer->GetWorldGeometry() );
if (timeSlicedGeometry)
{
mitk::SliceNavigationController::GeometrySliceEvent event( const_cast<mitk::TimeSlicedGeometry*>(timeSlicedGeometry), renderer->GetSlice() );
if ( renderer->GetCurrentWorldGeometry2DNode() )
{
if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane1() )
{
TranslateAndInterpolateChangedSlice( event, 2 );
}
else if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane2() )
{
TranslateAndInterpolateChangedSlice( event, 0 );
}
else if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane3() )
{
TranslateAndInterpolateChangedSlice( event, 1 );
}
}
}
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::OnInterpolationInfoChanged(const itk::EventObject& /*e*/)
{
// something (e.g. undo) changed the interpolation info, we should refresh our display
UpdateVisibleSuggestion();
}
void QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged(const itk::EventObject& /*e*/)
{
if(m_3DInterpolationEnabled)
{
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
m_Watcher.setFuture(m_Future);
}
}
bool QmitkSlicesInterpolator::GetSliceForWindowsID(unsigned windowID, int& sliceDimension, int& sliceIndex)
{
mitk::BaseRenderer* renderer(NULL);
// find sliceDimension for windowID:
// windowID 2: axial window = renderWindow1
// windowID 1: frontal window = renderWindow3
// windowID 0: sagittal window = renderWindow2
if ( m_MultiWidget )
{
switch (windowID)
{
case 2:
default:
renderer = m_MultiWidget->mitkWidget1->GetRenderer();
break;
case 1:
renderer = m_MultiWidget->mitkWidget3->GetRenderer();
break;
case 0:
renderer = m_MultiWidget->mitkWidget2->GetRenderer();
break;
}
}
if ( m_Segmentation && renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
{
const mitk::TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>( renderer->GetWorldGeometry() );
if (timeSlicedGeometry)
{
mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(timeSlicedGeometry->GetGeometry3D(m_TimeStep[windowID]));
if (slicedGeometry)
{
mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( renderer->GetSlice() ));
Interpolate( plane, m_TimeStep[windowID] );
return mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, sliceDimension, sliceIndex );
}
}
}
return false;
}
void QmitkSlicesInterpolator::OnMultiWidgetDeleted(QObject*)
{
if (m_MultiWidget)
{
m_MultiWidget = NULL;
}
}
void QmitkSlicesInterpolator:: SetCurrentContourListID()
{
if ( m_DataStorage.IsNotNull() && m_ToolManager )
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode)
{
//int listID;
bool isInterpolationResult(false);
workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
if ((m_MultiWidget != NULL && workingNode->IsSelected() &&
workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")))) &&
!isInterpolationResult)
{
QWidget::setEnabled( true );
mitk::Vector3D spacing = workingNode->GetData()->GetGeometry( m_MultiWidget->GetRenderWindow3()->GetRenderer()->GetTimeStep() )->GetSpacing();
double minSpacing (100);
double maxSpacing (0);
for (int i =0; i < 3; i++)
{
if (spacing[i] < minSpacing)
{
minSpacing = spacing[i];
}
else if (spacing[i] > maxSpacing)
{
maxSpacing = spacing[i];
}
}
m_SurfaceInterpolator->SetSegmentationImage(dynamic_cast<mitk::Image*>(workingNode->GetData()));
m_SurfaceInterpolator->SetMaxSpacing(maxSpacing);
m_SurfaceInterpolator->SetMinSpacing(minSpacing);
m_SurfaceInterpolator->SetDistanceImageVolume(50000);
m_SurfaceInterpolator->SetCurrentSegmentationInterpolationList(dynamic_cast<mitk::Image*>(workingNode->GetData()));
}
}
}
}
void QmitkSlicesInterpolator::Show3DInterpolationResult(bool status)
{
if (m_InterpolatedSurfaceNode.IsNotNull())
m_InterpolatedSurfaceNode->SetVisibility(status);
if (m_3DContourNode.IsNotNull())
m_3DContourNode->SetVisibility(status, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
diff --git a/Modules/QmitkExt/QmitkToolSelectionBox.cpp b/Modules/QmitkExt/QmitkToolSelectionBox.cpp
index 355938a432..9cc6bec5c1 100755
--- a/Modules/QmitkExt/QmitkToolSelectionBox.cpp
+++ b/Modules/QmitkExt/QmitkToolSelectionBox.cpp
@@ -1,632 +1,636 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//#define MBILOG_ENABLE_DEBUG 1
#include "QmitkToolSelectionBox.h"
#include "QmitkToolGUI.h"
+#include "mitkBaseRenderer.h"
#include <qtoolbutton.h>
#include <QList>
#include <qtooltip.h>
#include <qmessagebox.h>
#include <qlayout.h>
#include <qapplication.h>
#include <queue>
QmitkToolSelectionBox::QmitkToolSelectionBox(QWidget* parent, mitk::DataStorage* storage)
:QWidget(parent),
m_SelfCall(false),
m_DisplayedGroups("default"),
m_LayoutColumns(2),
m_ShowNames(true),
m_GenerateAccelerators(false),
m_ToolGUIWidget(NULL),
m_LastToolGUI(NULL),
m_ToolButtonGroup(NULL),
m_ButtonLayout(NULL),
- m_EnabledMode(EnabledWithReferenceAndWorkingData)
+ m_EnabledMode(EnabledWithReferenceAndWorkingDataVisible)
{
QFont currentFont = QWidget::font();
currentFont.setBold(true);
QWidget::setFont( currentFont );
m_ToolManager = mitk::ToolManager::New( storage );
// muellerm
// QButtonGroup
m_ToolButtonGroup = new QButtonGroup(this);
// some features of QButtonGroup
m_ToolButtonGroup->setExclusive( false ); // mutually exclusive toggle buttons
RecreateButtons();
QWidget::setContentsMargins(0, 0, 0, 0);
if ( layout() != NULL )
{
layout()->setContentsMargins(0, 0, 0, 0);
}
// reactions to signals
connect( m_ToolButtonGroup, SIGNAL(buttonClicked(int)), this, SLOT(toolButtonClicked(int)) );
// reactions to ToolManager events
m_ToolManager->ActiveToolChanged += mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerToolModified );
m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified );
m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified );
// show active tool
SetOrUnsetButtonForActiveTool();
QWidget::setEnabled( false );
}
QmitkToolSelectionBox::~QmitkToolSelectionBox()
{
m_ToolManager->ActiveToolChanged -= mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerToolModified );
m_ToolManager->ReferenceDataChanged -= mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified );
m_ToolManager->WorkingDataChanged -= mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified );
}
void QmitkToolSelectionBox::SetEnabledMode(EnabledMode mode)
{
m_EnabledMode = mode;
SetGUIEnabledAccordingToToolManagerState();
}
mitk::ToolManager* QmitkToolSelectionBox::GetToolManager()
{
return m_ToolManager;
}
void QmitkToolSelectionBox::SetToolManager(mitk::ToolManager& newManager) // no NULL pointer allowed here, a manager is required
{
// say bye to the old manager
m_ToolManager->ActiveToolChanged -= mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerToolModified );
m_ToolManager->ReferenceDataChanged -= mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified );
m_ToolManager->WorkingDataChanged -= mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified );
if ( QWidget::isEnabled() )
{
m_ToolManager->UnregisterClient();
}
m_ToolManager = &newManager;
RecreateButtons();
// greet the new one
m_ToolManager->ActiveToolChanged += mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerToolModified );
m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified );
m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified );
if ( QWidget::isEnabled() )
{
m_ToolManager->RegisterClient();
}
// ask the new one what the situation is like
SetOrUnsetButtonForActiveTool();
}
void QmitkToolSelectionBox::toolButtonClicked(int id)
{
if ( !QWidget::isEnabled() ) return; // this method could be triggered from the constructor, when we are still disabled
MITK_DEBUG << "toolButtonClicked(" << id << "): id translates to tool ID " << m_ToolIDForButtonID[id];
//QToolButton* toolButton = dynamic_cast<QToolButton*>( Q3ButtonGroup::find(id) );
QToolButton* toolButton = dynamic_cast<QToolButton*>( m_ToolButtonGroup->buttons().at(id) );
if (toolButton)
{
if ( (m_ButtonIDForToolID.find( m_ToolManager->GetActiveToolID() ) != m_ButtonIDForToolID.end()) // if we have this tool in our box
&& (m_ButtonIDForToolID[ m_ToolManager->GetActiveToolID() ] == id) ) // the tool corresponding to this button is already active
{
// disable this button, disable all tools
// mmueller
toolButton->setChecked(false);
m_ToolManager->ActivateTool(-1); // disable everything
}
else
{
// enable the corresponding tool
m_SelfCall = true;
m_ToolManager->ActivateTool( m_ToolIDForButtonID[id] );
m_SelfCall = false;
}
}
}
void QmitkToolSelectionBox::OnToolManagerToolModified()
{
SetOrUnsetButtonForActiveTool();
}
void QmitkToolSelectionBox::SetOrUnsetButtonForActiveTool()
{
// we want to emit a signal in any case, whether we selected ourselves or somebody else changes "our" tool manager. --> emit before check on m_SelfCall
int id = m_ToolManager->GetActiveToolID();
// don't emit signal for shape model tools
bool emitSignal = true;
mitk::Tool* tool = m_ToolManager->GetActiveTool();
if(tool && std::string(tool->GetGroup()) == "organ_segmentation")
emitSignal = false;
if(emitSignal)
emit ToolSelected(id);
// delete old GUI (if any)
if ( m_LastToolGUI && m_ToolGUIWidget )
{
if (m_ToolGUIWidget->layout())
{
m_ToolGUIWidget->layout()->removeWidget(m_LastToolGUI);
}
//m_LastToolGUI->reparent(NULL, QPoint(0,0));
// TODO: reparent <-> setParent, Daniel fragen
m_LastToolGUI->setParent(0);
delete m_LastToolGUI; // will hopefully notify parent and layouts
m_LastToolGUI = NULL;
QLayout* layout = m_ToolGUIWidget->layout();
if (layout)
{
layout->activate();
}
}
QToolButton* toolButton(NULL);
//mitk::Tool* tool = m_ToolManager->GetActiveTool();
if (m_ButtonIDForToolID.find(id) != m_ButtonIDForToolID.end()) // if this tool is in our box
{
//toolButton = dynamic_cast<QToolButton*>( Q3ButtonGroup::find( m_ButtonIDForToolID[id] ) );
toolButton = dynamic_cast<QToolButton*>( m_ToolButtonGroup->buttons().at( m_ButtonIDForToolID[id] ) );
}
if ( toolButton )
{
// mmueller
// uncheck all other buttons
QAbstractButton* tmpBtn = 0;
QList<QAbstractButton*>::iterator it;
for(int i=0; i < m_ToolButtonGroup->buttons().size(); ++i)
{
tmpBtn = m_ToolButtonGroup->buttons().at(i);
if(tmpBtn != toolButton)
dynamic_cast<QToolButton*>( tmpBtn )->setChecked(false);
}
toolButton->setChecked(true);
if (m_ToolGUIWidget && tool)
{
// create and reparent new GUI (if any)
itk::Object::Pointer possibleGUI = tool->GetGUI("Qmitk", "GUI").GetPointer(); // prefix and postfix
QmitkToolGUI* gui = dynamic_cast<QmitkToolGUI*>( possibleGUI.GetPointer() );
//!
m_LastToolGUI = gui;
if (gui)
{
gui->SetTool( tool );
// mmueller
//gui->reparent(m_ToolGUIWidget, gui->geometry().topLeft(), true );
gui->setParent(m_ToolGUIWidget);
gui->move(gui->geometry().topLeft());
gui->show();
QLayout* layout = m_ToolGUIWidget->layout();
if (!layout)
{
layout = new QVBoxLayout( m_ToolGUIWidget );
}
if (layout)
{
// mmueller
layout->addWidget( gui );
//layout->add( gui );
layout->activate();
}
}
}
}
else
{
// disable all buttons
QToolButton* selectedToolButton = dynamic_cast<QToolButton*>( m_ToolButtonGroup->checkedButton() );
//QToolButton* selectedToolButton = dynamic_cast<QToolButton*>( Q3ButtonGroup::find( Q3ButtonGroup::selectedId() ) );
if (selectedToolButton)
{
// mmueller
selectedToolButton->setChecked(false);
//selectedToolButton->setOn(false);
}
}
}
void QmitkToolSelectionBox::OnToolManagerReferenceDataModified()
{
if (m_SelfCall) return;
MITK_DEBUG << "OnToolManagerReferenceDataModified()";
SetGUIEnabledAccordingToToolManagerState();
}
void QmitkToolSelectionBox::OnToolManagerWorkingDataModified()
{
if (m_SelfCall) return;
MITK_DEBUG << "OnToolManagerWorkingDataModified()";
SetGUIEnabledAccordingToToolManagerState();
}
/**
Implementes the logic, which decides, when tools are activated/deactivated.
*/
void QmitkToolSelectionBox::SetGUIEnabledAccordingToToolManagerState()
{
mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
//MITK_DEBUG << this->name() << ": SetGUIEnabledAccordingToToolManagerState: referenceNode " << (void*)referenceNode << " workingNode " << (void*)workingNode << " isVisible() " << isVisible();
bool enabled = true;
switch ( m_EnabledMode )
{
default:
- case EnabledWithReferenceAndWorkingData:
- enabled = referenceNode && workingNode && isVisible();
+ case EnabledWithReferenceAndWorkingDataVisible:
+ enabled = referenceNode && workingNode
+ && referenceNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")))
+ && workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")))
+ && isVisible();
break;
case EnabledWithReferenceData:
enabled = referenceNode && isVisible();
break;
case EnabledWithWorkingData:
enabled = workingNode && isVisible();
break;
case AlwaysEnabled:
enabled = isVisible();
break;
}
if ( QWidget::isEnabled() == enabled ) return; // nothing to change
QWidget::setEnabled( enabled );
if (enabled)
{
m_ToolManager->RegisterClient();
int id = m_ToolManager->GetActiveToolID();
emit ToolSelected(id);
}
else
{
m_ToolManager->ActivateTool(-1);
m_ToolManager->UnregisterClient();
emit ToolSelected(-1);
}
}
/**
External enableization...
*/
void QmitkToolSelectionBox::setEnabled( bool enable )
{
QWidget::setEnabled(enable);
SetGUIEnabledAccordingToToolManagerState();
}
void QmitkToolSelectionBox::RecreateButtons()
{
if (m_ToolManager.IsNull()) return;
/*
// remove all buttons that are there
QObjectList *l = Q3ButtonGroup::queryList( "QButton" );
QObjectListIt it( *l ); // iterate over all buttons
QObject *obj;
while ( (obj = it.current()) != 0 )
{
++it;
QButton* button = dynamic_cast<QButton*>(obj);
if (button)
{
Q3ButtonGroup::remove(button);
delete button;
}
}
delete l; // delete the list, not the objects
*/
// mmueller Qt4 impl
QList<QAbstractButton *> l = m_ToolButtonGroup->buttons();
// remove all buttons that are there
QList<QAbstractButton *>::iterator it;
QAbstractButton * btn;
for(it=l.begin(); it!=l.end();++it)
{
btn = *it;
m_ToolButtonGroup->removeButton(btn);
//this->removeChild(btn);
delete btn;
}
// end mmueller Qt4 impl
mitk::ToolManager::ToolVectorTypeConst allPossibleTools = m_ToolManager->GetTools();
mitk::ToolManager::ToolVectorTypeConst allTools;
typedef std::pair< std::string::size_type, const mitk::Tool* > SortPairType;
typedef std::priority_queue< SortPairType > SortedToolQueueType;
SortedToolQueueType toolPositions;
// clear and sort all tools
// step one: find name/group of all tools in m_DisplayedGroups string. remember these positions for all tools.
for ( mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allPossibleTools.begin();
iter != allPossibleTools.end();
++iter)
{
const mitk::Tool* tool = *iter;
std::string::size_type namePos = m_DisplayedGroups.find( std::string("'") + tool->GetName() + "'" );
std::string::size_type groupPos = m_DisplayedGroups.find( std::string("'") + tool->GetGroup() + "'" );
if ( !m_DisplayedGroups.empty() && namePos == std::string::npos && groupPos == std::string::npos ) continue; // skip
if ( m_DisplayedGroups.empty() && std::string(tool->GetName()).length() > 0 )
{
namePos = static_cast<std::string::size_type> (tool->GetName()[0]);
}
SortPairType thisPair = std::make_pair( namePos < groupPos ? namePos : groupPos, *iter );
toolPositions.push( thisPair );
}
// step two: sort tools according to previously found positions in m_DisplayedGroups
MITK_DEBUG << "Sorting order of tools (lower number --> earlier in button group)";
while ( !toolPositions.empty() )
{
SortPairType thisPair = toolPositions.top();
MITK_DEBUG << "Position " << thisPair.first << " : " << thisPair.second->GetName();
allTools.push_back( thisPair.second );
toolPositions.pop();
}
std::reverse( allTools.begin(), allTools.end() );
MITK_DEBUG << "Sorted tools:";
for ( mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allTools.begin();
iter != allTools.end();
++iter)
{
MITK_DEBUG << (*iter)->GetName();
}
// try to change layout... bad?
//Q3GroupBox::setColumnLayout ( m_LayoutColumns, Qt::Horizontal );
// mmueller using gridlayout instead of Q3GroupBox
//this->setLayout(0);
if(m_ButtonLayout == NULL)
m_ButtonLayout = new QGridLayout;
/*else
delete m_ButtonLayout;*/
int row(0);
int column(-1);
int currentButtonID(0);
m_ButtonIDForToolID.clear();
m_ToolIDForButtonID.clear();
QToolButton* button = 0;
MITK_DEBUG << "Creating buttons for tools";
// fill group box with buttons
for ( mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allTools.begin();
iter != allTools.end();
++iter)
{
const mitk::Tool* tool = *iter;
int currentToolID( m_ToolManager->GetToolID( tool ) );
++column;
// new line if we are at the maximum columns
if(column == m_LayoutColumns)
{
++row;
column = 0;
}
button = new QToolButton;
button->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));
// add new button to the group
MITK_DEBUG << "Adding button with ID " << currentToolID;
m_ToolButtonGroup->addButton(button, currentButtonID);
// ... and to the layout
MITK_DEBUG << "Adding button in row/column " << row << "/" << column;
m_ButtonLayout->addWidget(button, row, column);
if (m_LayoutColumns == 1)
{
//button->setTextPosition( QToolButton::BesideIcon );
// mmueller
button->setToolButtonStyle( Qt::ToolButtonTextBesideIcon );
}
else
{
//button->setTextPosition( QToolButton::BelowIcon );
// mmueller
button->setToolButtonStyle( Qt::ToolButtonTextUnderIcon );
}
//button->setToggleButton( true );
// mmueller
button->setCheckable ( true );
QString label;
if (m_GenerateAccelerators)
{
label += "&";
}
label += tool->GetName();
QString tooltip = tool->GetName();
MITK_DEBUG << tool->GetName() << ", " << label.toLocal8Bit().constData() << ", '" << tooltip.toLocal8Bit().constData();
if ( m_ShowNames )
{
/*
button->setUsesTextLabel(true);
button->setTextLabel( label ); // a label
QToolTip::add( button, tooltip );
*/
// mmueller Qt4
button->setText( label ); // a label
button->setToolTip( tooltip );
// mmueller
QFont currentFont = button->font();
currentFont.setBold(false);
button->setFont( currentFont );
}
//button->setPixmap( QPixmap( tool->GetXPM() ) ); // an icon
// mmueller
button->setIcon( QIcon( QPixmap( tool->GetXPM() ) ) ); // an icon
if (m_GenerateAccelerators)
{
QString firstLetter = QString( tool->GetName() );
firstLetter.truncate( 1 );
button->setShortcut( firstLetter ); // a keyboard shortcut (just the first letter of the given name w/o any CTRL or something)
}
m_ButtonIDForToolID[currentToolID] = currentButtonID;
m_ToolIDForButtonID[currentButtonID] = currentToolID;
MITK_DEBUG << "m_ButtonIDForToolID[" << currentToolID << "] == " << currentButtonID;
MITK_DEBUG << "m_ToolIDForButtonID[" << currentButtonID << "] == " << currentToolID;
tool->GUIProcessEventsMessage += mitk::MessageDelegate<QmitkToolSelectionBox>( this, &QmitkToolSelectionBox::OnToolGUIProcessEventsMessage ); // will never add a listener twice, so we don't have to check here
tool->ErrorMessage += mitk::MessageDelegate1<QmitkToolSelectionBox, std::string>( this, &QmitkToolSelectionBox::OnToolErrorMessage ); // will never add a listener twice, so we don't have to check here
tool->GeneralMessage += mitk::MessageDelegate1<QmitkToolSelectionBox, std::string>( this, &QmitkToolSelectionBox::OnGeneralToolMessage );
++currentButtonID;
}
// setting grid layout for this groupbox
this->setLayout(m_ButtonLayout);
//this->update();
}
void QmitkToolSelectionBox::OnToolGUIProcessEventsMessage()
{
qApp->processEvents();
}
void QmitkToolSelectionBox::OnToolErrorMessage(std::string s)
{
QMessageBox::critical(NULL, "MITK", QString( s.c_str() ), QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
}
void QmitkToolSelectionBox::OnGeneralToolMessage(std::string s)
{
QMessageBox::information(NULL, "MITK", QString( s.c_str() ), QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
}
void QmitkToolSelectionBox::SetDisplayedToolGroups(const std::string& toolGroups)
{
if (m_DisplayedGroups != toolGroups)
{
QString q_DisplayedGroups = toolGroups.c_str();
// quote all unquoted single words
q_DisplayedGroups = q_DisplayedGroups.replace( QRegExp("\\b(\\w+)\\b|'([^']+)'"), "'\\1\\2'" );
MITK_DEBUG << "m_DisplayedGroups was \"" << toolGroups << "\"";
m_DisplayedGroups = q_DisplayedGroups.toLocal8Bit().constData();
MITK_DEBUG << "m_DisplayedGroups is \"" << m_DisplayedGroups << "\"";
RecreateButtons();
SetOrUnsetButtonForActiveTool();
}
}
void QmitkToolSelectionBox::SetLayoutColumns(int columns)
{
if (columns > 0 && columns != m_LayoutColumns)
{
m_LayoutColumns = columns;
RecreateButtons();
}
}
void QmitkToolSelectionBox::SetShowNames(bool show)
{
if (show != m_ShowNames)
{
m_ShowNames = show;
RecreateButtons();
}
}
void QmitkToolSelectionBox::SetGenerateAccelerators(bool accel)
{
if (accel != m_GenerateAccelerators)
{
m_GenerateAccelerators = accel;
RecreateButtons();
}
}
void QmitkToolSelectionBox::SetToolGUIArea( QWidget* parentWidget )
{
m_ToolGUIWidget = parentWidget;
}
void QmitkToolSelectionBox::setTitle( const QString& /*title*/ )
{
}
void QmitkToolSelectionBox::showEvent( QShowEvent* e )
{
QWidget::showEvent(e);
SetGUIEnabledAccordingToToolManagerState();
}
void QmitkToolSelectionBox::hideEvent( QHideEvent* e )
{
QWidget::hideEvent(e);
SetGUIEnabledAccordingToToolManagerState();
}
diff --git a/Modules/QmitkExt/QmitkToolSelectionBox.h b/Modules/QmitkExt/QmitkToolSelectionBox.h
index 61c4163fc1..c3d4ebff13 100755
--- a/Modules/QmitkExt/QmitkToolSelectionBox.h
+++ b/Modules/QmitkExt/QmitkToolSelectionBox.h
@@ -1,145 +1,145 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkToolSelectionBox_h_Included
#define QmitkToolSelectionBox_h_Included
#include "QmitkToolGUIArea.h"
#include "QmitkExtExports.h"
#include "mitkToolManager.h"
#include <QWidget>
#include <QButtonGroup>
#include <QGridLayout>
#include <map>
class QmitkToolGUI;
/**
\brief Display the tool selection state of a mitk::ToolManager
\sa mitk::ToolManager
\ingroup org_mitk_gui_qt_interactivesegmentation
\ingroup ToolManagerEtAl
There is a separate page describing the general design of QmitkInteractiveSegmentation: \ref QmitkInteractiveSegmentationTechnicalPage
This widget graphically displays the active tool of a mitk::ToolManager as a set
of toggle buttons. Each button show the identification of a Tool (icon and name).
When a button's toggle state is "down", the tool is activated. When a different button
is clicked, the active tool is switched. When you click an already active button, the
associated tool is deactivated with no replacement, which means that no tool is active
then.
When this widget is enabled/disabled it (normally) also enables/disables the tools. There
could be cases where two QmitkToolSelectionBox widgets are associated to the same ToolManager,
but if this happens, please look deeply into the code.
Last contributor: $Author: maleike $
*/
class QmitkExt_EXPORT QmitkToolSelectionBox : public QWidget
//!
{
Q_OBJECT
public:
- enum EnabledMode { EnabledWithReferenceAndWorkingData, EnabledWithReferenceData, EnabledWithWorkingData, AlwaysEnabled };
+ enum EnabledMode { EnabledWithReferenceAndWorkingDataVisible, EnabledWithReferenceData, EnabledWithWorkingData, AlwaysEnabled };
QmitkToolSelectionBox(QWidget* parent = 0, mitk::DataStorage* storage = 0);
virtual ~QmitkToolSelectionBox();
mitk::ToolManager* GetToolManager();
void SetToolManager(mitk::ToolManager&); // no NULL pointer allowed here, a manager is required
void setTitle( const QString& title );
/**
You may specify a list of tool "groups" that should be displayed in this widget. Every Tool can report its group
as a string. This method will try to find the tool's group inside the supplied string \param toolGroups. If there is a match,
the tool is displayed. Effectively, you can provide a human readable list like "default, lymphnodevolumetry, oldERISstuff".
*/
void SetDisplayedToolGroups(const std::string& toolGroups = 0);
void OnToolManagerToolModified();
void OnToolManagerReferenceDataModified();
void OnToolManagerWorkingDataModified();
void OnToolGUIProcessEventsMessage();
void OnToolErrorMessage(std::string s);
void OnGeneralToolMessage(std::string s);
signals:
/// Whenever a tool is activated. id is the index of the active tool. Counting starts at 0, -1 indicates "no tool selected"
/// This signal is also emitted, when the whole QmitkToolSelectionBox get disabled. Then it will claim ToolSelected(-1)
/// When it is enabled again, there will be another ToolSelected event with the tool that is currently selected
void ToolSelected(int id);
public slots:
virtual void setEnabled( bool );
virtual void SetEnabledMode(EnabledMode mode);
virtual void SetLayoutColumns(int);
virtual void SetShowNames(bool);
virtual void SetGenerateAccelerators(bool);
virtual void SetToolGUIArea( QWidget* parentWidget );
protected slots:
void toolButtonClicked(int id);
void SetGUIEnabledAccordingToToolManagerState();
protected:
void showEvent( QShowEvent* );
void hideEvent( QHideEvent* );
void RecreateButtons();
void SetOrUnsetButtonForActiveTool();
mitk::ToolManager::Pointer m_ToolManager;
bool m_SelfCall;
std::string m_DisplayedGroups;
/// stores relationship between button IDs of the Qt widget and tool IDs of ToolManager
std::map<int,int> m_ButtonIDForToolID;
/// stores relationship between button IDs of the Qt widget and tool IDs of ToolManager
std::map<int,int> m_ToolIDForButtonID;
int m_LayoutColumns;
bool m_ShowNames;
bool m_GenerateAccelerators;
QWidget* m_ToolGUIWidget;
QmitkToolGUI* m_LastToolGUI;
// store buttons in this group
QButtonGroup* m_ToolButtonGroup;
QGridLayout* m_ButtonLayout;
EnabledMode m_EnabledMode;
};
#endif
diff --git a/Modules/QmitkExt/QmitkVtkHistogramWidget.cpp b/Modules/QmitkExt/QmitkVtkHistogramWidget.cpp
index 3d3b1fdf59..717d7aefe1 100644
--- a/Modules/QmitkExt/QmitkVtkHistogramWidget.cpp
+++ b/Modules/QmitkExt/QmitkVtkHistogramWidget.cpp
@@ -1,277 +1,279 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkVtkHistogramWidget.h"
#include "mitkHistogramGenerator.h"
#include <qlabel.h>
#include <qpen.h>
#include <qgroupbox.h>
#include <vtkQtChartArea.h>
#include <vtkQtChartTableSeriesModel.h>
#include <vtkQtChartStyleManager.h>
#include <vtkQtChartColorStyleGenerator.h>
#include <vtkQtChartMouseSelection.h>
#include <vtkQtChartInteractorSetup.h>
#include <vtkQtChartSeriesSelectionHandler.h>
#include <vtkQtChartAxisLayer.h>
#include <vtkQtChartAxis.h>
#include <vtkQtChartAxisOptions.h>
#include <vtkQtChartLegend.h>
#include <vtkQtChartLegendManager.h>
//#include <iostream>
QmitkVtkHistogramWidget::QmitkVtkHistogramWidget( QWidget * parent )
: QDialog(parent), m_HistogramMode( HISTOGRAM_MODE_ENTIREIMAGE )
{
//QGroupBox *hgroupbox = new QGroupBox( "", this );
//hgroupbox->setMinimumSize( 150, 150 );
m_ChartWidget = new vtkQtChartWidget( this );
QBoxLayout *layout = new QVBoxLayout( this );
layout->addWidget( m_ChartWidget );
layout->setSpacing( 10 );
vtkQtChartArea *area = m_ChartWidget->getChartArea();
// Set up the bar chart.
m_BarChart = new vtkQtBarChart();
area->insertLayer( area->getAxisLayerIndex(), m_BarChart );
// Set up the default interactor.
vtkQtChartMouseSelection *selector =
vtkQtChartInteractorSetup::createDefault( area );
vtkQtChartSeriesSelectionHandler *handler =
new vtkQtChartSeriesSelectionHandler( selector );
handler->setModeNames( "Bar Chart - Series", "Bar Chart - Bars" );
handler->setMousePressModifiers( Qt::ControlModifier, Qt::ControlModifier );
handler->setLayer( m_BarChart );
selector->addHandler( handler );
selector->setSelectionMode("Bar Chart - Bars");
// Hide the x-axis grid.
vtkQtChartAxisLayer *axisLayer = area->getAxisLayer();
vtkQtChartAxis *xAxis = axisLayer->getAxis(vtkQtChartAxis::Bottom);
xAxis->getOptions()->setGridVisible(false);
xAxis->getOptions()->setPrecision( 0 );
xAxis->getOptions()->setNotation( vtkQtChartAxisOptions::Standard );
vtkQtChartAxis *yAxis = axisLayer->getAxis(vtkQtChartAxis::Left);
yAxis->getOptions()->setPrecision( 0 );
yAxis->getOptions()->setNotation( vtkQtChartAxisOptions::Standard );
// Set up the model for the bar chart.
m_ItemModel = new QStandardItemModel( m_BarChart );
m_ItemModel->setItemPrototype( new QStandardItem() );
}
QmitkVtkHistogramWidget::~QmitkVtkHistogramWidget()
{
}
void QmitkVtkHistogramWidget::SetHistogramModeToDirectHistogram()
{
if ( m_HistogramMode != HISTOGRAM_MODE_DIRECT )
{
m_HistogramMode = HISTOGRAM_MODE_DIRECT;
}
}
void QmitkVtkHistogramWidget::SetHistogramModeToEntireImage()
{
if ( m_HistogramMode != HISTOGRAM_MODE_ENTIREIMAGE )
{
m_HistogramMode = HISTOGRAM_MODE_ENTIREIMAGE;
}
}
void QmitkVtkHistogramWidget::SetHistogramModeToMaskedImage()
{
if ( m_HistogramMode != HISTOGRAM_MODE_MASKEDIMAGE )
{
m_HistogramMode = HISTOGRAM_MODE_MASKEDIMAGE;
}
}
void QmitkVtkHistogramWidget::SetHistogramModeToImageRegion()
{
if ( m_HistogramMode != HISTOGRAM_MODE_IMAGEREGION )
{
m_HistogramMode = HISTOGRAM_MODE_IMAGEREGION;
}
}
void QmitkVtkHistogramWidget::SetHistogramModeToPlanarFigureRegion()
{
if ( m_HistogramMode != HISTOGRAM_MODE_PLANARFIGUREREGION )
{
m_HistogramMode = HISTOGRAM_MODE_PLANARFIGUREREGION;
}
}
void QmitkVtkHistogramWidget::UpdateItemModelFromHistogram()
{
this->ComputeHistogram();
if ( m_DerivedHistogram.IsNull() )
{
return;
}
// Determine non-zero range of histogram
unsigned int startIndex = 0, endIndex = 0, i = 0;
HistogramConstIteratorType startIt = m_DerivedHistogram->End();
HistogramConstIteratorType endIt = m_DerivedHistogram->End();
- HistogramConstIteratorType it;
bool firstNonEmptyBinFound = false;
- for ( it = m_DerivedHistogram->Begin(); it != m_DerivedHistogram->End(); ++it, ++i )
+ for (HistogramConstIteratorType it = m_DerivedHistogram->Begin(); it != m_DerivedHistogram->End(); ++it, ++i )
{
if ( it.GetFrequency() > 0.0 )
{
endIt = it;
endIndex = i;
if ( !firstNonEmptyBinFound )
{
firstNonEmptyBinFound = true;
startIt = it;
startIndex = i;
}
}
}
++endIt;
// For empty image / mask: clear histogram
if ( startIt == m_DerivedHistogram->End() )
{
this->ClearItemModel();
return;
}
// Allocate data in item model
m_ItemModel->setRowCount( endIndex + 1 - startIndex );
m_ItemModel->setColumnCount( 1 );
// Fill item model with histogram data
- for ( it = startIt, i = 0; it != endIt; ++it, ++i )
+ i = 0;
+ for (HistogramConstIteratorType it = startIt; it != endIt; ++it)
{
const double &frequency = it.GetFrequency();
const double &measurement = it.GetMeasurementVector()[0];
m_ItemModel->setVerticalHeaderItem( i, new QStandardItem() );
m_ItemModel->verticalHeaderItem( i )->setData(
QVariant( measurement ), Qt::DisplayRole );
m_ItemModel->setItem( i, 0, new QStandardItem() );
m_ItemModel->item( i, 0 )->setData( QVariant( frequency ), Qt::DisplayRole );
+
+ ++i;
}
vtkQtChartTableSeriesModel *table =
new vtkQtChartTableSeriesModel( m_ItemModel, m_BarChart );
m_BarChart->setModel( table );
m_ChartWidget->show();
}
void QmitkVtkHistogramWidget::ClearItemModel()
{
m_ItemModel->clear();
}
void QmitkVtkHistogramWidget::ComputeHistogram()
{
switch ( m_HistogramMode )
{
case HISTOGRAM_MODE_DIRECT:
{
m_DerivedHistogram = m_Histogram;
break;
}
case HISTOGRAM_MODE_ENTIREIMAGE:
{
mitk::HistogramGenerator::Pointer histogramGenerator = mitk::HistogramGenerator::New();
histogramGenerator->SetImage( m_Image );
histogramGenerator->ComputeHistogram();
m_DerivedHistogram = histogramGenerator->GetHistogram();
break;
}
case HISTOGRAM_MODE_MASKEDIMAGE:
{
break;
}
case HISTOGRAM_MODE_IMAGEREGION:
{
break;
}
case HISTOGRAM_MODE_PLANARFIGUREREGION:
{
break;
}
}
}
void QmitkVtkHistogramWidget::SetHistogram(const HistogramType* histogram )
{
m_Histogram = histogram;
}
void QmitkVtkHistogramWidget::SetImage(const mitk::Image* image )
{
m_Image = image;
}
void QmitkVtkHistogramWidget::SetImageMask(const mitk::Image* imageMask )
{
m_ImageMask = imageMask;
}
void QmitkVtkHistogramWidget::SetImageRegion( const RegionType imageRegion )
{
m_ImageRegion = imageRegion;
}
void QmitkVtkHistogramWidget::SetPlanarFigure(const mitk::PlanarFigure* planarFigure )
{
m_PlanarFigure = planarFigure;
}
void QmitkVtkHistogramWidget::SetHistogramMode( unsigned int histogramMode )
{
m_HistogramMode = histogramMode;
}
unsigned int QmitkVtkHistogramWidget::GetHistogramMode()
{
return m_HistogramMode;
}
diff --git a/Modules/QmitkExt/files.cmake b/Modules/QmitkExt/files.cmake
index 48eefa8b88..87f13f6fda 100644
--- a/Modules/QmitkExt/files.cmake
+++ b/Modules/QmitkExt/files.cmake
@@ -1,267 +1,271 @@
set(CPP_FILES
QmitkApplicationBase/QmitkCommonFunctionality.cpp
QmitkApplicationBase/QmitkIOUtil.cpp
#QmitkModels/QmitkDataStorageListModel.cpp
#QmitkModels/QmitkPropertiesTableModel.cpp
#QmitkModels/QmitkDataStorageTreeModel.cpp
#QmitkModels/QmitkDataStorageTableModel.cpp
#QmitkModels/QmitkPropertyDelegate.cpp
#QmitkModels/QmitkPointListModel.cpp
#QmitkAlgorithmFunctionalityComponent.cpp
#QmitkBaseAlgorithmComponent.cpp
QmitkAboutDialog/QmitkAboutDialog.cpp
#QmitkFunctionalityComponents/QmitkSurfaceCreatorComponent.cpp
#QmitkFunctionalityComponents/QmitkPixelGreyValueManipulatorComponent.cpp
#QmitkFunctionalityComponents/QmitkConnectivityFilterComponent.cpp
#QmitkFunctionalityComponents/QmitkImageCropperComponent.cpp
#QmitkFunctionalityComponents/QmitkSeedPointSetComponent.cpp
#QmitkFunctionalityComponents/QmitkSurfaceTransformerComponent.cpp
QmitkPropertyObservers/QmitkBasePropertyView.cpp
QmitkPropertyObservers/QmitkBoolPropertyWidget.cpp
QmitkPropertyObservers/QmitkColorPropertyEditor.cpp
QmitkPropertyObservers/QmitkColorPropertyView.cpp
QmitkPropertyObservers/QmitkEnumerationPropertyWidget.cpp
QmitkPropertyObservers/QmitkNumberPropertyEditor.cpp
QmitkPropertyObservers/QmitkNumberPropertyView.cpp
QmitkPropertyObservers/QmitkPropertyViewFactory.cpp
QmitkPropertyObservers/QmitkStringPropertyEditor.cpp
QmitkPropertyObservers/QmitkStringPropertyOnDemandEdit.cpp
QmitkPropertyObservers/QmitkStringPropertyView.cpp
QmitkPropertyObservers/QmitkNumberPropertySlider.cpp
QmitkPropertyObservers/QmitkUGCombinedRepresentationPropertyWidget.cpp
qclickablelabel.cpp
#QmitkAbortEventFilter.cpp
# QmitkApplicationCursor.cpp
QmitkCallbackFromGUIThread.cpp
QmitkEditPointDialog.cpp
QmitkExtRegisterClasses.cpp
QmitkFileChooser.cpp
# QmitkRenderingManager.cpp
# QmitkRenderingManagerFactory.cpp
# QmitkRenderWindow.cpp
# QmitkEventAdapter.cpp
QmitkFloatingPointSpanSlider.cpp
QmitkColorTransferFunctionCanvas.cpp
QmitkSlicesInterpolator.cpp
QmitkStandardViews.cpp
QmitkStepperAdapter.cpp
# QmitkLineEditLevelWindowWidget.cpp
# mitkSliderLevelWindowWidget.cpp
# QmitkLevelWindowWidget.cpp
# QmitkPointListWidget.cpp
# QmitkPointListView.cpp
QmitkPiecewiseFunctionCanvas.cpp
QmitkSliderNavigatorWidget.cpp
QmitkTransferFunctionCanvas.cpp
QmitkCrossWidget.cpp
#QmitkLevelWindowRangeChangeDialog.cpp
#QmitkLevelWindowPresetDefinitionDialog.cpp
# QmitkLevelWindowWidgetContextMenu.cpp
QmitkSliceWidget.cpp
# QmitkStdMultiWidget.cpp
QmitkTransferFunctionWidget.cpp
QmitkTransferFunctionGeneratorWidget.cpp
QmitkSelectableGLWidget.cpp
QmitkToolReferenceDataSelectionBox.cpp
QmitkToolWorkingDataSelectionBox.cpp
QmitkToolGUIArea.cpp
QmitkToolSelectionBox.cpp
# QmitkPropertyListPopup.cpp
QmitkToolGUI.cpp
QmitkNewSegmentationDialog.cpp
QmitkPaintbrushToolGUI.cpp
QmitkDrawPaintbrushToolGUI.cpp
QmitkErasePaintbrushToolGUI.cpp
QmitkBinaryThresholdToolGUI.cpp
QmitkCalculateGrayValueStatisticsToolGUI.cpp
QmitkCopyToClipBoardDialog.cpp
# QmitkMaterialEditor.cpp
# QmitkMaterialShowcase.cpp
# QmitkPropertiesTableEditor.cpp
QmitkPrimitiveMovieNavigatorWidget.cpp
# QmitkDataStorageComboBox.cpp
QmitkHistogram.cpp
QmitkHistogramWidget.cpp
QmitkPlotWidget.cpp
QmitkPlotDialog.cpp
QmitkPointListModel.cpp
QmitkPointListView.cpp
QmitkPointListWidget.cpp
QmitkPointListViewWidget.cpp
QmitkCorrespondingPointSetsView.cpp
QmitkCorrespondingPointSetsModel.cpp
QmitkCorrespondingPointSetsWidget.cpp
QmitkVideoBackground.cpp
QmitkHotkeyLineEdit.cpp
QmitkErodeToolGUI.cpp
QmitkDilateToolGUI.cpp
QmitkMorphologicToolGUI.cpp
QmitkOpeningToolGUI.cpp
QmitkClosingToolGUI.cpp
QmitkBinaryThresholdULToolGUI.cpp
QmitkPixelManipulationToolGUI.cpp
QmitkRegionGrow3DToolGUI.cpp
QmitkToolRoiDataSelectionBox.cpp
QmitkBoundingObjectWidget.cpp
QmitkAdaptiveRegionGrowingWidget.cpp
QmitkModuleTableModel.cpp
QmitkModulesDialog.cpp
QmitkHistogramJSWidget.cpp
+
+ QmitkLineEdit.cpp
)
if( NOT ${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}.${VTK_BUILD_VERSION} VERSION_LESS 5.4.0 )
set(CPP_FILES
${CPP_FILES}
QmitkVtkHistogramWidget.cpp
QmitkVtkLineProfileWidget.cpp
)
endif()
if(NOT APPLE)
set(CPP_FILES
${CPP_FILES}
QmitkBaseComponent.cpp
QmitkBaseFunctionalityComponent.cpp
QmitkFunctionalityComponentContainer.cpp
QmitkFunctionalityComponents/QmitkThresholdComponent.cpp
)
endif()
QT4_ADD_RESOURCES(CPP_FILES resources/QmitkResources.qrc)
set(MOC_H_FILES
QmitkPropertyObservers/QmitkBasePropertyView.h
QmitkPropertyObservers/QmitkBoolPropertyWidget.h
QmitkPropertyObservers/QmitkColorPropertyEditor.h
QmitkPropertyObservers/QmitkColorPropertyView.h
QmitkPropertyObservers/QmitkEnumerationPropertyWidget.h
QmitkPropertyObservers/QmitkNumberPropertyEditor.h
QmitkPropertyObservers/QmitkNumberPropertyView.h
QmitkPropertyObservers/QmitkStringPropertyEditor.h
QmitkPropertyObservers/QmitkStringPropertyOnDemandEdit.h
QmitkPropertyObservers/QmitkStringPropertyView.h
QmitkPropertyObservers/QmitkNumberPropertySlider.h
QmitkPropertyObservers/QmitkUGCombinedRepresentationPropertyWidget.h
# QmitkFunctionalityComponents/QmitkSurfaceCreatorComponent.h
#QmitkFunctionalityComponents/QmitkPixelGreyValueManipulatorComponent.h
# QmitkFunctionalityComponents/QmitkConnectivityFilterComponent.h
# QmitkFunctionalityComponents/QmitkImageCropperComponent.h
# QmitkFunctionalityComponents/QmitkSeedPointSetComponent.h
# QmitkFunctionalityComponents/QmitkSurfaceTransformerComponent.h
qclickablelabel.h
QmitkCallbackFromGUIThread.h
QmitkEditPointDialog.h
#QmitkAlgorithmFunctionalityComponent.h
#QmitkBaseAlgorithmComponent.h
QmitkStandardViews.h
QmitkStepperAdapter.h
QmitkSliderNavigatorWidget.h
QmitkSliceWidget.h
QmitkSlicesInterpolator.h
QmitkColorTransferFunctionCanvas.h
QmitkPiecewiseFunctionCanvas.h
QmitkTransferFunctionCanvas.h
QmitkFloatingPointSpanSlider.h
QmitkCrossWidget.h
QmitkTransferFunctionWidget.h
QmitkTransferFunctionGeneratorWidget.h
QmitkToolGUIArea.h
QmitkToolGUI.h
QmitkToolReferenceDataSelectionBox.h
QmitkToolWorkingDataSelectionBox.h
QmitkToolSelectionBox.h
# QmitkPropertyListPopup.h
#QmitkSelectableGLWidget.h
QmitkNewSegmentationDialog.h
QmitkPaintbrushToolGUI.h
QmitkDrawPaintbrushToolGUI.h
QmitkErasePaintbrushToolGUI.h
QmitkBinaryThresholdToolGUI.h
QmitkCalculateGrayValueStatisticsToolGUI.h
QmitkCopyToClipBoardDialog.h
QmitkPrimitiveMovieNavigatorWidget.h
QmitkPlotWidget.h
QmitkPointListModel.h
QmitkPointListView.h
QmitkPointListWidget.h
QmitkPointListViewWidget.h
QmitkCorrespondingPointSetsView.h
QmitkCorrespondingPointSetsModel.h
QmitkCorrespondingPointSetsWidget.h
QmitkHistogramWidget.h
QmitkVideoBackground.h
QmitkFileChooser.h
QmitkHotkeyLineEdit.h
QmitkAboutDialog/QmitkAboutDialog.h
QmitkErodeToolGUI.h
QmitkDilateToolGUI.h
QmitkMorphologicToolGUI.h
QmitkOpeningToolGUI.h
QmitkClosingToolGUI.h
QmitkBinaryThresholdULToolGUI.h
QmitkPixelManipulationToolGUI.h
QmitkRegionGrow3DToolGUI.h
QmitkToolRoiDataSelectionBox.h
QmitkBoundingObjectWidget.h
QmitkPlotWidget.h
QmitkAdaptiveRegionGrowingWidget.h
QmitkHistogramJSWidget.h
+
+ QmitkLineEdit.h
)
if( NOT ${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}.${VTK_BUILD_VERSION} VERSION_LESS 5.4.0 )
set(MOC_H_FILES
${MOC_H_FILES}
QmitkVtkHistogramWidget.h
QmitkVtkLineProfileWidget.h
)
endif()
if(NOT APPLE)
set(MOC_H_FILES
${MOC_H_FILES}
QmitkBaseComponent.h
QmitkBaseFunctionalityComponent.h
QmitkFunctionalityComponentContainer.h
QmitkFunctionalityComponents/QmitkThresholdComponent.h
)
endif()
set(UI_FILES
QmitkSliderNavigator.ui
# QmitkLevelWindowRangeChange.ui
# QmitkLevelWindowPresetDefinition.ui
# QmitkLevelWindowWidget.ui
QmitkSliceWidget.ui
QmitkTransferFunctionWidget.ui
QmitkTransferFunctionGeneratorWidget.ui
QmitkSelectableGLWidget.ui
QmitkPrimitiveMovieNavigatorWidget.ui
QmitkFunctionalityComponentContainerControls.ui
QmitkFunctionalityComponents/QmitkThresholdComponentControls.ui
QmitkAboutDialog/QmitkAboutDialogGUI.ui
QmitkAdaptiveRegionGrowingWidgetControls.ui
)
set(QRC_FILES
QmitkExt.qrc
)
diff --git a/Modules/RigidRegistration/mitkPyramidalRegistrationMethodAccessFunctor.txx b/Modules/RigidRegistration/mitkPyramidalRegistrationMethodAccessFunctor.txx
index d97acce25c..5cad7bc4b5 100644
--- a/Modules/RigidRegistration/mitkPyramidalRegistrationMethodAccessFunctor.txx
+++ b/Modules/RigidRegistration/mitkPyramidalRegistrationMethodAccessFunctor.txx
@@ -1,247 +1,247 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPyramidalRegistrationMethodAccessFunctor.h"
#include "mitkPyramidalRegistrationMethod.h"
#include <mitkImageCast.h>
#include <itkLinearInterpolateImageFunction.h>
#include <itkMultiResolutionImageRegistrationMethod.h>
#include <itkRescaleIntensityImageFilter.h>
#include <itkHistogramMatchingImageFilter.h>
#include "mitkMetricFactory.h"
#include "mitkTransformFactory.h"
#include "mitkOptimizerFactory.h"
#include "mitkRegistrationInterfaceCommand.h"
namespace mitk {
template<typename TPixel, unsigned int VImageDimension>
void PyramidalRegistrationMethodAccessFunctor::AccessItkImage(itk::Image<TPixel, VImageDimension>* itkImage1,
PyramidalRegistrationMethod* method)
{
// TYPEDEFS
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef float InternalPixelType;
typedef itk::Image<InternalPixelType, VImageDimension> InternalImageType;
typedef typename itk::Transform<double, VImageDimension, VImageDimension> TransformType;
typedef mitk::TransformFactory<InternalPixelType, VImageDimension> TransformFactoryType;
typedef itk::LinearInterpolateImageFunction<InternalImageType, double> InterpolatorType;
typedef mitk::MetricFactory<InternalPixelType, VImageDimension> MetricFactoryType;
typedef itk::RecursiveMultiResolutionPyramidImageFilter<InternalImageType, InternalImageType > ImagePyramidType;
typedef itk::DiscreteGaussianImageFilter<ImageType, InternalImageType> GaussianFilterType;
typedef itk::MultiResolutionImageRegistrationMethod<InternalImageType, InternalImageType > RegistrationType;
typedef RegistrationInterfaceCommand<RegistrationType, TPixel> CommandType;
typedef itk::CastImageFilter<ImageType, InternalImageType> CastImageFilterType;
itk::Array<double> initialParameters;
if(method->m_TransformParameters->GetInitialParameters().size())
{
initialParameters = method->m_TransformParameters->GetInitialParameters();
}
// LOAD PARAMETERS
itk::Array<double> transformValues = method->m_Preset->getTransformValues(method->m_Presets[0]);
itk::Array<double> metricValues = method->m_Preset->getMetricValues(method->m_Presets[0]);
itk::Array<double> optimizerValues = method->m_Preset->getOptimizerValues(method->m_Presets[0]);
method->m_TransformParameters = method->ParseTransformParameters(transformValues);
method->m_MetricParameters = method->ParseMetricParameters(metricValues);
method->m_OptimizerParameters = method->ParseOptimizerParameters(optimizerValues);
// The fixed and the moving image
typename InternalImageType::Pointer fixedImage = InternalImageType::New();
typename InternalImageType::Pointer movingImage = InternalImageType::New();
mitk::CastToItkImage(method->m_ReferenceImage, fixedImage);
// Blur the moving image
if(method->m_BlurMovingImage)
{
typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
gaussianFilter->SetInput(itkImage1);
gaussianFilter->SetVariance(6.0);
gaussianFilter->SetMaximumError( 0.1 );
//gaussianFilter->SetMaximumKernelWidth ( 3 );
gaussianFilter->Update();
movingImage = gaussianFilter->GetOutput();
}
else
{
typename CastImageFilterType::Pointer castImageFilter = CastImageFilterType::New();
castImageFilter->SetInput(itkImage1);
castImageFilter->Update();
movingImage = castImageFilter->GetOutput();
}
if(method->m_MatchHistograms)
{
typedef itk::RescaleIntensityImageFilter<InternalImageType,InternalImageType> FilterType;
typedef itk::HistogramMatchingImageFilter<InternalImageType,InternalImageType> HEFilterType;
typename FilterType::Pointer inputRescaleFilter = FilterType::New();
typename FilterType::Pointer referenceRescaleFilter = FilterType::New();
referenceRescaleFilter->SetInput(fixedImage);
inputRescaleFilter->SetInput(movingImage);
const float desiredMinimum = 0.0;
const float desiredMaximum = 255.0;
referenceRescaleFilter->SetOutputMinimum( desiredMinimum );
referenceRescaleFilter->SetOutputMaximum( desiredMaximum );
referenceRescaleFilter->UpdateLargestPossibleRegion();
inputRescaleFilter->SetOutputMinimum( desiredMinimum );
inputRescaleFilter->SetOutputMaximum( desiredMaximum );
inputRescaleFilter->UpdateLargestPossibleRegion();
// Histogram match the images
typename HEFilterType::Pointer intensityEqualizeFilter = HEFilterType::New();
intensityEqualizeFilter->SetReferenceImage( inputRescaleFilter->GetOutput() );
intensityEqualizeFilter->SetInput( referenceRescaleFilter->GetOutput() );
intensityEqualizeFilter->SetNumberOfHistogramLevels( 64 );
intensityEqualizeFilter->SetNumberOfMatchPoints( 12 );
intensityEqualizeFilter->ThresholdAtMeanIntensityOn();
intensityEqualizeFilter->Update();
//fixedImage = referenceRescaleFilter->GetOutput();
//movingImage = IntensityEqualizeFilter->GetOutput();
fixedImage = intensityEqualizeFilter->GetOutput();
movingImage = inputRescaleFilter->GetOutput();
}
typename TransformFactoryType::Pointer transFac = TransformFactoryType::New();
transFac->SetTransformParameters(method->m_TransformParameters);
transFac->SetFixedImage(fixedImage);
transFac->SetMovingImage(movingImage);
typename TransformType::Pointer transform = transFac->GetTransform();
typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
typename MetricFactoryType::Pointer metFac = MetricFactoryType::New();
metFac->SetMetricParameters(method->m_MetricParameters);
typename OptimizerFactory::Pointer optFac = OptimizerFactory::New();
optFac->SetOptimizerParameters(method->m_OptimizerParameters);
optFac->SetNumberOfTransformParameters(transform->GetNumberOfParameters());
typename PyramidalRegistrationMethod::OptimizerType::Pointer optimizer = optFac->GetOptimizer();
// optimizer scales
if (method->m_TransformParameters->GetUseOptimizerScales())
{
itk::Array<double> optimizerScales = method->m_TransformParameters->GetScales();
typename PyramidalRegistrationMethod::OptimizerType::ScalesType scales( transform->GetNumberOfParameters() );
for (unsigned int i = 0; i < scales.Size(); i++)
{
scales[i] = optimizerScales[i];
}
optimizer->SetScales( scales );
}
typename ImagePyramidType::Pointer fixedImagePyramid = ImagePyramidType::New();
typename ImagePyramidType::Pointer movingImagePyramid = ImagePyramidType::New();
if(method->m_FixedSchedule.size() > 0 && method->m_MovingSchedule.size() > 0)
{
fixedImagePyramid->SetSchedule(method->m_FixedSchedule);
movingImagePyramid->SetSchedule(method->m_MovingSchedule);
// Otherwise just use the default schedule
}
typename RegistrationType::Pointer registration = RegistrationType::New();
registration->SetOptimizer( optimizer );
registration->SetTransform( transform );
registration->SetInterpolator( interpolator );
registration->SetMetric( metFac->GetMetric() );
registration->SetFixedImagePyramid( fixedImagePyramid );
registration->SetMovingImagePyramid( movingImagePyramid );
registration->SetFixedImage( fixedImage );
registration->SetMovingImage( movingImage );
registration->SetFixedImageRegion( fixedImage->GetBufferedRegion() );
if(transFac->GetTransformParameters()->GetInitialParameters().size())
{
registration->SetInitialTransformParameters( transFac->GetTransformParameters()->GetInitialParameters() );
}
else
{
itk::Array<double> zeroInitial;
zeroInitial.set_size(transform->GetNumberOfParameters());
zeroInitial.fill(0.0);
zeroInitial[0] = 1.0;
zeroInitial[4] = 1.0;
zeroInitial[8] = 1.0;
registration->SetInitialTransformParameters( zeroInitial );
}
if(method->m_UseMask)
{
itk::ImageMaskSpatialObject< VImageDimension>* mask =
dynamic_cast< itk::ImageMaskSpatialObject< VImageDimension>* > ( method->m_BrainMask.GetPointer() );
registration->GetMetric()->SetFixedImageMask(mask);
}
// registering command observer with the optimizer
if (method->m_Observer.IsNotNull())
{
method->m_Observer->AddStepsToDo(20);
optimizer->AddObserver(itk::AnyEvent(), method->m_Observer);
registration->AddObserver(itk::AnyEvent(), method->m_Observer);
transform->AddObserver(itk::AnyEvent(), method->m_Observer);
}
typename CommandType::Pointer command = CommandType::New();
command->observer = method->m_Observer;
command->m_Presets = method->m_Presets;
command->m_UseMask = method->m_UseMask;
command->m_BrainMask = method->m_BrainMask;
registration->AddObserver( itk::IterationEvent(), command );
registration->SetSchedules(method->m_FixedSchedule, method->m_MovingSchedule);
// Start the registration process
try
{
- registration->StartRegistration();
+ registration->Update();
}
catch( itk::ExceptionObject & err )
{
std::cout << "ExceptionObject caught !" << std::endl;
std::cout << err << std::endl;
}
if (method->m_Observer.IsNotNull())
{
optimizer->RemoveAllObservers();
registration->RemoveAllObservers();
transform->RemoveAllObservers();
method->m_Observer->SetRemainingProgress(15);
}
if (method->m_Observer.IsNotNull())
{
method->m_Observer->SetRemainingProgress(5);
}
}
} // end namespace
diff --git a/Modules/RigidRegistration/mitkRigidRegistrationPreset.cpp b/Modules/RigidRegistration/mitkRigidRegistrationPreset.cpp
index d816c92de2..a20acad531 100644
--- a/Modules/RigidRegistration/mitkRigidRegistrationPreset.cpp
+++ b/Modules/RigidRegistration/mitkRigidRegistrationPreset.cpp
@@ -1,1158 +1,1159 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkRigidRegistrationPreset.h"
#include "mitkMetricParameters.h"
#include "mitkOptimizerParameters.h"
#include "mitkTransformParameters.h"
#include "mitkGetModuleContext.h"
#include "mitkModuleContext.h"
#include "mitkModule.h"
#include "mitkModuleResource.h"
#include "mitkModuleResourceStream.h"
namespace mitk {
RigidRegistrationPreset::RigidRegistrationPreset()
{
m_Name = "";
m_XmlFileName = "mitkRigidRegistrationPresets.xml";
}
RigidRegistrationPreset::~RigidRegistrationPreset()
{
}
bool RigidRegistrationPreset::LoadPreset()
{
return LoadPreset("mitkRigidRegistrationPresets.xml");
}
bool RigidRegistrationPreset::LoadPreset(std::string fileName)
{
if ( fileName.empty() )
return false;
ModuleResource presetResource = GetModuleContext()->GetModule()->GetResource(fileName);
if (!presetResource) return false;
ModuleResourceStream presetStream(presetResource);
vtkXMLParser::SetStream(&presetStream);
if ( !vtkXMLParser::Parse() )
{
#ifdef INTERDEBUG
MITK_INFO<<"RigidRegistrationPreset::LoadPreset xml file cannot parse!"<<std::endl;
#endif
}
return true;
}
void RigidRegistrationPreset::StartElement (const char *elementName, const char **atts)
{
std::string elementNameString = elementName;
if ( elementNameString == "preset" )
{
m_Name = ReadXMLStringAttribut( "NAME", atts );
}
else if (elementNameString == "transform")
{
itk::Array<double> transformValues;
transformValues.SetSize(25);
transformValues.fill(0);
std::string transform = ReadXMLStringAttribut( "TRANSFORM", atts );
double trans = atof(transform.c_str());
transformValues[0] = trans;
transformValues = this->loadTransformValues(transformValues, trans, atts);
m_TransformValues[m_Name] = transformValues;
}
else if (elementNameString == "metric")
{
itk::Array<double> metricValues;
metricValues.SetSize(25);
metricValues.fill(0);
std::string metric = ReadXMLStringAttribut( "METRIC", atts );
double met = atof(metric.c_str());
metricValues[0] = met;
metricValues = this->loadMetricValues(metricValues, met, atts);
m_MetricValues[m_Name] = metricValues;
}
else if (elementNameString == "optimizer")
{
itk::Array<double> optimizerValues;
optimizerValues.SetSize(25);
optimizerValues.fill(0);
std::string optimizer = ReadXMLStringAttribut( "OPTIMIZER", atts );
double opt = atof(optimizer.c_str());
optimizerValues[0] = opt;
optimizerValues = this->loadOptimizerValues(optimizerValues, opt, atts);
m_OptimizerValues[m_Name] = optimizerValues;
}
else if (elementNameString == "interpolator")
{
itk::Array<double> interpolatorValues;
interpolatorValues.SetSize(25);
interpolatorValues.fill(0);
std::string interpolator = ReadXMLStringAttribut( "INTERPOLATOR", atts );
double inter = atof(interpolator.c_str());
interpolatorValues[0] = inter;
interpolatorValues = this->loadInterpolatorValues(interpolatorValues/*, inter, atts*/);
m_InterpolatorValues[m_Name] = interpolatorValues;
}
}
std::string RigidRegistrationPreset::ReadXMLStringAttribut( std::string name, const char** atts )
{
if(atts)
{
const char** attsIter = atts;
while(*attsIter)
{
if ( name == *attsIter )
{
attsIter++;
return *attsIter;
}
attsIter++;
attsIter++;
}
}
return std::string();
}
itk::Array<double> RigidRegistrationPreset::getTransformValues(std::string name)
{
return m_TransformValues[name];
}
itk::Array<double> RigidRegistrationPreset::getMetricValues(std::string name)
{
return m_MetricValues[name];
}
itk::Array<double> RigidRegistrationPreset::getOptimizerValues(std::string name)
{
return m_OptimizerValues[name];
}
itk::Array<double> RigidRegistrationPreset::getInterpolatorValues(std::string name)
{
return m_InterpolatorValues[name];
}
std::map<std::string, itk::Array<double> >& RigidRegistrationPreset::getTransformValuesPresets()
{
return m_TransformValues;
}
std::map<std::string, itk::Array<double> >& RigidRegistrationPreset::getMetricValuesPresets()
{
return m_MetricValues;
}
std::map<std::string, itk::Array<double> >& RigidRegistrationPreset::getOptimizerValuesPresets()
{
return m_OptimizerValues;
}
std::map<std::string, itk::Array<double> >& RigidRegistrationPreset::getInterpolatorValuesPresets()
{
return m_InterpolatorValues;
}
bool RigidRegistrationPreset::save()
{
//XMLWriter writer(m_XmlFileName.c_str());
//return saveXML(writer);
return false;
}
//bool RigidRegistrationPreset::saveXML(mitk::XMLWriter& xmlWriter)
//{
// xmlWriter.BeginNode("mitkRigidRegistrationPresets");
// for( std::map<std::string, itk::Array<double> >::iterator iter = m_TransformValues.begin(); iter != m_TransformValues.end(); iter++ ) {
// std::string item = ((*iter).first.c_str());
// xmlWriter.BeginNode("preset");
// xmlWriter.WriteProperty("NAME", item);
// xmlWriter.BeginNode("transform");
// this->saveTransformValues(xmlWriter, item);
// xmlWriter.EndNode();
// xmlWriter.BeginNode("metric");
// this->saveMetricValues(xmlWriter, item);
// xmlWriter.EndNode();
// xmlWriter.BeginNode("optimizer");
// this->saveOptimizerValues(xmlWriter, item);
// xmlWriter.EndNode();
// xmlWriter.BeginNode("interpolator");
// this->saveInterpolatorValues(xmlWriter, item);
// xmlWriter.EndNode();
// xmlWriter.EndNode();
// }
// xmlWriter.EndNode();
// return true;
//}
bool RigidRegistrationPreset::newPresets(std::map<std::string, itk::Array<double> > newTransformValues, std::map<std::string, itk::Array<double> > newMetricValues,
std::map<std::string, itk::Array<double> > newOptimizerValues, std::map<std::string, itk::Array<double> > newInterpolatorValues, std::string fileName)
{
if ( !fileName.empty() )
{
m_XmlFileName = fileName;
}
m_TransformValues = newTransformValues;
m_MetricValues = newMetricValues;
m_OptimizerValues = newOptimizerValues;
m_InterpolatorValues = newInterpolatorValues;
return save();
}
//void RigidRegistrationPreset::saveTransformValues(mitk::XMLWriter& xmlWriter, std::string item)
//{
// itk::Array<double> transformValues = m_TransformValues[item];
// double transform = transformValues[0];
// xmlWriter.WriteProperty("TRANSFORM", transformValues[0]);
// if (transform == mitk::TransformParameters::TRANSLATIONTRANSFORM || transform == mitk::TransformParameters::SCALETRANSFORM ||
// transform == mitk::TransformParameters::SCALELOGARITHMICTRANSFORM || transform == mitk::TransformParameters::VERSORTRANSFORM ||
// transform == mitk::TransformParameters::RIGID2DTRANSFORM || transform == mitk::TransformParameters::EULER2DTRANSFORM)
// {
// xmlWriter.WriteProperty("USESCALES", transformValues[1]);
// xmlWriter.WriteProperty("SCALE1", transformValues[2]);
// xmlWriter.WriteProperty("SCALE2", transformValues[3]);
// xmlWriter.WriteProperty("SCALE3", transformValues[4]);
// }
// else if (transform == mitk::TransformParameters::AFFINETRANSFORM || transform == mitk::TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM)
// {
// xmlWriter.WriteProperty("USESCALES", transformValues[1]);
// xmlWriter.WriteProperty("SCALE1", transformValues[2]);
// xmlWriter.WriteProperty("SCALE2", transformValues[3]);
// xmlWriter.WriteProperty("SCALE3", transformValues[4]);
// xmlWriter.WriteProperty("SCALE4", transformValues[5]);
// xmlWriter.WriteProperty("SCALE5", transformValues[6]);
// xmlWriter.WriteProperty("SCALE6", transformValues[7]);
// xmlWriter.WriteProperty("SCALE7", transformValues[8]);
// xmlWriter.WriteProperty("SCALE8", transformValues[9]);
// xmlWriter.WriteProperty("SCALE9", transformValues[10]);
// xmlWriter.WriteProperty("SCALE10", transformValues[11]);
// xmlWriter.WriteProperty("SCALE11", transformValues[12]);
// xmlWriter.WriteProperty("SCALE12", transformValues[13]);
// /* xmlWriter.WriteProperty("SCALE13", transformValues[14]);
// xmlWriter.WriteProperty("SCALE14", transformValues[15]);
// xmlWriter.WriteProperty("SCALE15", transformValues[16]);
// xmlWriter.WriteProperty("SCALE16", transformValues[17]);*/
// xmlWriter.WriteProperty("USEINITIALIZER", transformValues[14]);
// xmlWriter.WriteProperty("USEMOMENTS", transformValues[15]);
// }
// else if (transform == mitk::TransformParameters::RIGID3DTRANSFORM)
// {
// xmlWriter.WriteProperty("USESCALES", transformValues[1]);
// xmlWriter.WriteProperty("SCALE1", transformValues[2]);
// xmlWriter.WriteProperty("SCALE2", transformValues[3]);
// xmlWriter.WriteProperty("SCALE3", transformValues[4]);
// xmlWriter.WriteProperty("SCALE4", transformValues[5]);
// xmlWriter.WriteProperty("SCALE5", transformValues[6]);
// xmlWriter.WriteProperty("SCALE6", transformValues[7]);
// xmlWriter.WriteProperty("SCALE7", transformValues[8]);
// xmlWriter.WriteProperty("SCALE8", transformValues[9]);
// xmlWriter.WriteProperty("SCALE9", transformValues[10]);
// xmlWriter.WriteProperty("SCALE10", transformValues[11]);
// xmlWriter.WriteProperty("SCALE11", transformValues[12]);
// xmlWriter.WriteProperty("SCALE12", transformValues[13]);
// xmlWriter.WriteProperty("USEINITIALIZER", transformValues[14]);
// xmlWriter.WriteProperty("USEMOMENTS", transformValues[15]);
// }
// else if (transform == mitk::TransformParameters::EULER3DTRANSFORM || transform == mitk::TransformParameters::CENTEREDEULER3DTRANSFORM
// || transform == mitk::TransformParameters::VERSORRIGID3DTRANSFORM)
// {
// xmlWriter.WriteProperty("USESCALES", transformValues[1]);
// xmlWriter.WriteProperty("SCALE1", transformValues[2]);
// xmlWriter.WriteProperty("SCALE2", transformValues[3]);
// xmlWriter.WriteProperty("SCALE3", transformValues[4]);
// xmlWriter.WriteProperty("SCALE4", transformValues[5]);
// xmlWriter.WriteProperty("SCALE5", transformValues[6]);
// xmlWriter.WriteProperty("SCALE6", transformValues[7]);
// xmlWriter.WriteProperty("USEINITIALIZER", transformValues[8]);
// xmlWriter.WriteProperty("USEMOMENTS", transformValues[9]);
// }
// else if (transform == mitk::TransformParameters::QUATERNIONRIGIDTRANSFORM || transform == mitk::TransformParameters::SIMILARITY3DTRANSFORM)
// {
// xmlWriter.WriteProperty("USESCALES", transformValues[1]);
// xmlWriter.WriteProperty("SCALE1", transformValues[2]);
// xmlWriter.WriteProperty("SCALE2", transformValues[3]);
// xmlWriter.WriteProperty("SCALE3", transformValues[4]);
// xmlWriter.WriteProperty("SCALE4", transformValues[5]);
// xmlWriter.WriteProperty("SCALE5", transformValues[6]);
// xmlWriter.WriteProperty("SCALE6", transformValues[7]);
// xmlWriter.WriteProperty("SCALE7", transformValues[8]);
// xmlWriter.WriteProperty("USEINITIALIZER", transformValues[9]);
// xmlWriter.WriteProperty("USEMOMENTS", transformValues[10]);
// }
// else if (transform == mitk::TransformParameters::SCALESKEWVERSOR3DTRANSFORM)
// {
// xmlWriter.WriteProperty("USESCALES", transformValues[1]);
// xmlWriter.WriteProperty("SCALE1", transformValues[2]);
// xmlWriter.WriteProperty("SCALE2", transformValues[3]);
// xmlWriter.WriteProperty("SCALE3", transformValues[4]);
// xmlWriter.WriteProperty("SCALE4", transformValues[5]);
// xmlWriter.WriteProperty("SCALE5", transformValues[6]);
// xmlWriter.WriteProperty("SCALE6", transformValues[7]);
// xmlWriter.WriteProperty("SCALE7", transformValues[8]);
// xmlWriter.WriteProperty("SCALE8", transformValues[9]);
// xmlWriter.WriteProperty("SCALE9", transformValues[10]);
// xmlWriter.WriteProperty("SCALE10", transformValues[11]);
// xmlWriter.WriteProperty("SCALE11", transformValues[12]);
// xmlWriter.WriteProperty("SCALE12", transformValues[13]);
// xmlWriter.WriteProperty("SCALE13", transformValues[14]);
// xmlWriter.WriteProperty("SCALE14", transformValues[15]);
// xmlWriter.WriteProperty("SCALE15", transformValues[16]);
// xmlWriter.WriteProperty("USEINITIALIZER", transformValues[17]);
// xmlWriter.WriteProperty("USEMOMENTS", transformValues[18]);
// }
// else if (transform == mitk::TransformParameters::CENTEREDRIGID2DTRANSFORM)
// {
// xmlWriter.WriteProperty("USESCALES", transformValues[1]);
// xmlWriter.WriteProperty("SCALE1", transformValues[2]);
// xmlWriter.WriteProperty("SCALE2", transformValues[3]);
// xmlWriter.WriteProperty("SCALE3", transformValues[4]);
// xmlWriter.WriteProperty("SCALE4", transformValues[5]);
// xmlWriter.WriteProperty("SCALE5", transformValues[6]);
// xmlWriter.WriteProperty("ANGLE", transformValues[7]);
// xmlWriter.WriteProperty("USEINITIALIZER", transformValues[8]);
// xmlWriter.WriteProperty("USEMOMENTS", transformValues[9]);
// }
// else if (transform == mitk::TransformParameters::SIMILARITY2DTRANSFORM)
// {
// xmlWriter.WriteProperty("USESCALES", transformValues[1]);
// xmlWriter.WriteProperty("SCALE1", transformValues[2]);
// xmlWriter.WriteProperty("SCALE2", transformValues[3]);
// xmlWriter.WriteProperty("SCALE3", transformValues[4]);
// xmlWriter.WriteProperty("SCALE4", transformValues[5]);
// xmlWriter.WriteProperty("SCALE", transformValues[6]);
// xmlWriter.WriteProperty("ANGLE", transformValues[7]);
// xmlWriter.WriteProperty("USEINITIALIZER", transformValues[8]);
// xmlWriter.WriteProperty("USEMOMENTS", transformValues[9]);
// }
// else if (transform == mitk::TransformParameters::CENTEREDSIMILARITY2DTRANSFORM)
// {
// xmlWriter.WriteProperty("USESCALES", transformValues[1]);
// xmlWriter.WriteProperty("SCALE1", transformValues[2]);
// xmlWriter.WriteProperty("SCALE2", transformValues[3]);
// xmlWriter.WriteProperty("SCALE3", transformValues[4]);
// xmlWriter.WriteProperty("SCALE4", transformValues[5]);
// xmlWriter.WriteProperty("SCALE5", transformValues[6]);
// xmlWriter.WriteProperty("SCALE6", transformValues[7]);
// xmlWriter.WriteProperty("SCALE", transformValues[8]);
// xmlWriter.WriteProperty("ANGLE", transformValues[9]);
// xmlWriter.WriteProperty("USEINITIALIZER", transformValues[10]);
// xmlWriter.WriteProperty("USEMOMENTS", transformValues[11]);
// }
//}
//void RigidRegistrationPreset::saveMetricValues(mitk::XMLWriter& xmlWriter, std::string item)
//{
// itk::Array<double> metricValues = m_MetricValues[item];
// double metric = metricValues[0];
// xmlWriter.WriteProperty("METRIC", metricValues[0]);
// xmlWriter.WriteProperty("COMPUTEGRADIENT", metricValues[1]);
// if (metric == mitk::MetricParameters::MEANSQUARESIMAGETOIMAGEMETRIC || metric == mitk::MetricParameters::NORMALIZEDCORRELATIONIMAGETOIMAGEMETRIC
// || metric == mitk::MetricParameters::GRADIENTDIFFERENCEIMAGETOIMAGEMETRIC || metric == mitk::MetricParameters::MATCHCARDINALITYIMAGETOIMAGEMETRIC
// || metric == mitk::MetricParameters::KAPPASTATISTICIMAGETOIMAGEMETRIC)
// {
// }
// else if (metric == mitk::MetricParameters::KULLBACKLEIBLERCOMPAREHISTOGRAMIMAGETOIMAGEMETRIC
// || metric == mitk::MetricParameters::CORRELATIONCOEFFICIENTHISTOGRAMIMAGETOIMAGEMETRIC
// || metric == mitk::MetricParameters::MEANSQUARESHISTOGRAMIMAGETOIMAGEMETRIC
// || metric == mitk::MetricParameters::MUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC
// || metric == mitk::MetricParameters::NORMALIZEDMUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC)
// {
// xmlWriter.WriteProperty("HISTOGRAMBINS", metricValues[2]);
// }
// else if (metric == mitk::MetricParameters::MATTESMUTUALINFORMATIONIMAGETOIMAGEMETRIC)
// {
// xmlWriter.WriteProperty("USESAMPLING", metricValues[2]);
// xmlWriter.WriteProperty("SPATIALSAMPLES", metricValues[3]);
// xmlWriter.WriteProperty("HISTOGRAMBINS", metricValues[4]);
// }
// else if (metric == mitk::MetricParameters::MEANRECIPROCALSQUAREDIFFERENCEIMAGETOIMAGEMETRIC)
// {
// xmlWriter.WriteProperty("LAMBDA", metricValues[2]);
// }
// else if (metric == mitk::MetricParameters::MUTUALINFORMATIONIMAGETOIMAGEMETRIC)
// {
// xmlWriter.WriteProperty("SPATIALSAMPLES", metricValues[2]);
// xmlWriter.WriteProperty("FIXEDSTANDARDDEVIATION", metricValues[3]);
// xmlWriter.WriteProperty("MOVINGSTANDARDDEVIATION", metricValues[4]);
// xmlWriter.WriteProperty("USENORMALIZERANDSMOOTHER", metricValues[5]);
// xmlWriter.WriteProperty("FIXEDSMOOTHERVARIANCE", metricValues[6]);
// xmlWriter.WriteProperty("MOVINGSMOOTHERVARIANCE", metricValues[7]);
// }
//}
//void RigidRegistrationPreset::saveOptimizerValues(mitk::XMLWriter& xmlWriter, std::string item)
//{
// itk::Array<double> optimizerValues = m_OptimizerValues[item];
// double optimizer = optimizerValues[0];
// xmlWriter.WriteProperty("OPTIMIZER", optimizerValues[0]);
// xmlWriter.WriteProperty("MAXIMIZE", optimizerValues[1]);
// if (optimizer == mitk::OptimizerParameters::EXHAUSTIVEOPTIMIZER)
// {
// xmlWriter.WriteProperty("STEPLENGTH", optimizerValues[2]);
// xmlWriter.WriteProperty("NUMBEROFSTEPS", optimizerValues[3]);
// }
// else if (optimizer == mitk::OptimizerParameters::GRADIENTDESCENTOPTIMIZER
// || optimizer == mitk::OptimizerParameters::QUATERNIONRIGIDTRANSFORMGRADIENTDESCENTOPTIMIZER)
// {
// xmlWriter.WriteProperty("LEARNINGRATE", optimizerValues[2]);
// xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[3]);
// }
// else if (optimizer == mitk::OptimizerParameters::LBFGSBOPTIMIZER)
// {
// }
// else if (optimizer == mitk::OptimizerParameters::ONEPLUSONEEVOLUTIONARYOPTIMIZER)
// {
// xmlWriter.WriteProperty("SHRINKFACTOR", optimizerValues[2]);
// xmlWriter.WriteProperty("GROWTHFACTOR", optimizerValues[3]);
// xmlWriter.WriteProperty("EPSILON", optimizerValues[4]);
// xmlWriter.WriteProperty("INITIALRADIUS", optimizerValues[5]);
// xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[6]);
// }
// else if (optimizer == mitk::OptimizerParameters::POWELLOPTIMIZER)
// {
// xmlWriter.WriteProperty("STEPLENGTH", optimizerValues[2]);
// xmlWriter.WriteProperty("STEPTOLERANCE", optimizerValues[3]);
// xmlWriter.WriteProperty("VALUETOLERANCE", optimizerValues[4]);
// xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[5]);
// }
// else if (optimizer == mitk::OptimizerParameters::FRPROPTIMIZER)
// {
// xmlWriter.WriteProperty("USEFLETCHREEVES", optimizerValues[2]);
// xmlWriter.WriteProperty("STEPLENGTH", optimizerValues[3]);
// xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[4]);
// }
// else if (optimizer == mitk::OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER)
// {
// xmlWriter.WriteProperty("GRADIENTMAGNITUDETOLERANCE", optimizerValues[2]);
// xmlWriter.WriteProperty("MINSTEPLENGTH", optimizerValues[3]);
// xmlWriter.WriteProperty("MAXSTEPLENGTH", optimizerValues[4]);
// xmlWriter.WriteProperty("RELAXATIONFACTOR", optimizerValues[5]);
// xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[6]);
// }
// else if (optimizer == mitk::OptimizerParameters::VERSORTRANSFORMOPTIMIZER || optimizer == mitk::OptimizerParameters::VERSORRIGID3DTRANSFORMOPTIMIZER)
// {
// xmlWriter.WriteProperty("GRADIENTMAGNITUDETOLERANCE", optimizerValues[2]);
// xmlWriter.WriteProperty("MINSTEPLENGTH", optimizerValues[3]);
// xmlWriter.WriteProperty("MAXSTEPLENGTH", optimizerValues[4]);
// xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[5]);
// }
// else if (optimizer == mitk::OptimizerParameters::AMOEBAOPTIMIZER)
// {
// xmlWriter.WriteProperty("SIMPLEXDELTA1", optimizerValues[2]);
// xmlWriter.WriteProperty("SIMPLEXDELTA2", optimizerValues[3]);
// xmlWriter.WriteProperty("SIMPLEXDELTA3", optimizerValues[4]);
// xmlWriter.WriteProperty("SIMPLEXDELTA4", optimizerValues[5]);
// xmlWriter.WriteProperty("SIMPLEXDELTA5", optimizerValues[6]);
// xmlWriter.WriteProperty("SIMPLEXDELTA6", optimizerValues[7]);
// xmlWriter.WriteProperty("SIMPLEXDELTA7", optimizerValues[8]);
// xmlWriter.WriteProperty("SIMPLEXDELTA8", optimizerValues[9]);
// xmlWriter.WriteProperty("SIMPLEXDELTA9", optimizerValues[10]);
// xmlWriter.WriteProperty("SIMPLEXDELTA10", optimizerValues[11]);
// xmlWriter.WriteProperty("SIMPLEXDELTA11", optimizerValues[12]);
// xmlWriter.WriteProperty("SIMPLEXDELTA12", optimizerValues[13]);
// xmlWriter.WriteProperty("SIMPLEXDELTA13", optimizerValues[14]);
// xmlWriter.WriteProperty("SIMPLEXDELTA14", optimizerValues[15]);
// xmlWriter.WriteProperty("SIMPLEXDELTA15", optimizerValues[16]);
// xmlWriter.WriteProperty("SIMPLEXDELTA16", optimizerValues[17]);
// xmlWriter.WriteProperty("PARAMETERSCONVERGENCETOLERANCE", optimizerValues[18]);
// xmlWriter.WriteProperty("FUNCTIONCONVERGENCETOLERANCE", optimizerValues[19]);
// xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[20]);
// }
// else if (optimizer == mitk::OptimizerParameters::CONJUGATEGRADIENTOPTIMIZER)
// {
// }
// else if (optimizer == mitk::OptimizerParameters::LBFGSOPTIMIZER)
// {
// xmlWriter.WriteProperty("GRADIENTCONVERGENCETOLERANCE", optimizerValues[2]);
// xmlWriter.WriteProperty("LINESEARCHACCURACY", optimizerValues[3]);
// xmlWriter.WriteProperty("DEFAULTSTEPLENGTH", optimizerValues[4]);
// xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[5]);
// xmlWriter.WriteProperty("USETRACE", optimizerValues[6]);
// }
// else if (optimizer == mitk::OptimizerParameters::SPSAOPTIMIZER)
// {
// xmlWriter.WriteProperty("a", optimizerValues[2]);
// xmlWriter.WriteProperty("A", optimizerValues[3]);
// xmlWriter.WriteProperty("ALPHA", optimizerValues[4]);
// xmlWriter.WriteProperty("c", optimizerValues[5]);
// xmlWriter.WriteProperty("GAMMA", optimizerValues[6]);
// xmlWriter.WriteProperty("TOLERANCE", optimizerValues[7]);
// xmlWriter.WriteProperty("STATEOFCONVERGENCEDECAYRATE", optimizerValues[8]);
// xmlWriter.WriteProperty("MINNUMBERITERATIONS", optimizerValues[9]);
// xmlWriter.WriteProperty("NUMBERPERTURBATIONS", optimizerValues[10]);
// xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[11]);
// }
//}
//void RigidRegistrationPreset::saveInterpolatorValues(mitk::XMLWriter& xmlWriter, std::string item)
//{
// itk::Array<double> interpolatorValues = m_InterpolatorValues[item];
// xmlWriter.WriteProperty("INTERPOLATOR", interpolatorValues[0]);
//}
itk::Array<double> RigidRegistrationPreset::loadTransformValues(itk::Array<double> transformValues, double transform, const char **atts)
{
if (transform == mitk::TransformParameters::TRANSLATIONTRANSFORM || transform == mitk::TransformParameters::SCALETRANSFORM ||
transform == mitk::TransformParameters::SCALELOGARITHMICTRANSFORM || transform == mitk::TransformParameters::VERSORTRANSFORM ||
transform == mitk::TransformParameters::RIGID2DTRANSFORM || transform == mitk::TransformParameters::EULER2DTRANSFORM)
{
std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
double useSca = atof(useScales.c_str());
transformValues[1] = useSca;
std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
double sca1 = atof(scale1.c_str());
transformValues[2] = sca1;
std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
double sca2 = atof(scale2.c_str());
transformValues[3] = sca2;
std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
double sca3 = atof(scale3.c_str());
transformValues[4] = sca3;
}
else if (transform == mitk::TransformParameters::AFFINETRANSFORM || transform == mitk::TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM)
{
std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
double useSca = atof(useScales.c_str());
transformValues[1] = useSca;
std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
double sca1 = atof(scale1.c_str());
transformValues[2] = sca1;
std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
double sca2 = atof(scale2.c_str());
transformValues[3] = sca2;
std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
double sca3 = atof(scale3.c_str());
transformValues[4] = sca3;
std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
double sca4 = atof(scale4.c_str());
transformValues[5] = sca4;
std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
double sca5 = atof(scale5.c_str());
transformValues[6] = sca5;
std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
double sca6 = atof(scale6.c_str());
transformValues[7] = sca6;
std::string scale7 = ReadXMLStringAttribut( "SCALE7", atts );
double sca7 = atof(scale7.c_str());
transformValues[8] = sca7;
std::string scale8 = ReadXMLStringAttribut( "SCALE8", atts );
double sca8 = atof(scale8.c_str());
transformValues[9] = sca8;
std::string scale9 = ReadXMLStringAttribut( "SCALE9", atts );
double sca9 = atof(scale9.c_str());
transformValues[10] = sca9;
std::string scale10 = ReadXMLStringAttribut( "SCALE10", atts );
double sca10 = atof(scale10.c_str());
transformValues[11] = sca10;
std::string scale11 = ReadXMLStringAttribut( "SCALE11", atts );
double sca11 = atof(scale11.c_str());
transformValues[12] = sca11;
std::string scale12 = ReadXMLStringAttribut( "SCALE12", atts );
double sca12 = atof(scale12.c_str());
transformValues[13] = sca12;
/*
std::string scale13 = ReadXMLStringAttribut( "SCALE13", atts );
double sca13 = atof(scale13.c_str());
transformValues[14] = sca13;
std::string scale14 = ReadXMLStringAttribut( "SCALE14", atts );
double sca14 = atof(scale14.c_str());
transformValues[15] = sca14;
std::string scale15 = ReadXMLStringAttribut( "SCALE15", atts );
double sca15 = atof(scale15.c_str());
transformValues[16] = sca15;
std::string scale16 = ReadXMLStringAttribut( "SCALE16", atts );
double sca16 = atof(scale16.c_str());
transformValues[17] = sca16;
*/
std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
double useIni = atof(useInitializer.c_str());
transformValues[14] = useIni;
std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
double useMo = atof(useMoments.c_str());
transformValues[15] = useMo;
}
- else if (transform == mitk::TransformParameters::RIGID3DTRANSFORM)
- {
- std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
- double useSca = atof(useScales.c_str());
- transformValues[1] = useSca;
- std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
- double sca1 = atof(scale1.c_str());
- transformValues[2] = sca1;
- std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
- double sca2 = atof(scale2.c_str());
- transformValues[3] = sca2;
- std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
- double sca3 = atof(scale3.c_str());
- transformValues[4] = sca3;
- std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
- double sca4 = atof(scale4.c_str());
- transformValues[5] = sca4;
- std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
- double sca5 = atof(scale5.c_str());
- transformValues[6] = sca5;
- std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
- double sca6 = atof(scale6.c_str());
- transformValues[7] = sca6;
- std::string scale7 = ReadXMLStringAttribut( "SCALE7", atts );
- double sca7 = atof(scale7.c_str());
- transformValues[8] = sca7;
- std::string scale8 = ReadXMLStringAttribut( "SCALE8", atts );
- double sca8 = atof(scale8.c_str());
- transformValues[9] = sca8;
- std::string scale9 = ReadXMLStringAttribut( "SCALE9", atts );
- double sca9 = atof(scale9.c_str());
- transformValues[10] = sca9;
- std::string scale10 = ReadXMLStringAttribut( "SCALE10", atts );
- double sca10 = atof(scale10.c_str());
- transformValues[11] = sca10;
- std::string scale11 = ReadXMLStringAttribut( "SCALE11", atts );
- double sca11 = atof(scale11.c_str());
- transformValues[12] = sca11;
- std::string scale12 = ReadXMLStringAttribut( "SCALE12", atts );
- double sca12 = atof(scale12.c_str());
- transformValues[13] = sca12;
- std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
- double useIni = atof(useInitializer.c_str());
- transformValues[14] = useIni;
- std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
- double useMo = atof(useMoments.c_str());
- transformValues[15] = useMo;
- }
+ //TODO remove rigid3dTransform
+// else if (transform == mitk::TransformParameters::RIGID3DTRANSFORM)
+// {
+// std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
+// double useSca = atof(useScales.c_str());
+// transformValues[1] = useSca;
+// std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
+// double sca1 = atof(scale1.c_str());
+// transformValues[2] = sca1;
+// std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
+// double sca2 = atof(scale2.c_str());
+// transformValues[3] = sca2;
+// std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
+// double sca3 = atof(scale3.c_str());
+// transformValues[4] = sca3;
+// std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
+// double sca4 = atof(scale4.c_str());
+// transformValues[5] = sca4;
+// std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
+// double sca5 = atof(scale5.c_str());
+// transformValues[6] = sca5;
+// std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
+// double sca6 = atof(scale6.c_str());
+// transformValues[7] = sca6;
+// std::string scale7 = ReadXMLStringAttribut( "SCALE7", atts );
+// double sca7 = atof(scale7.c_str());
+// transformValues[8] = sca7;
+// std::string scale8 = ReadXMLStringAttribut( "SCALE8", atts );
+// double sca8 = atof(scale8.c_str());
+// transformValues[9] = sca8;
+// std::string scale9 = ReadXMLStringAttribut( "SCALE9", atts );
+// double sca9 = atof(scale9.c_str());
+// transformValues[10] = sca9;
+// std::string scale10 = ReadXMLStringAttribut( "SCALE10", atts );
+// double sca10 = atof(scale10.c_str());
+// transformValues[11] = sca10;
+// std::string scale11 = ReadXMLStringAttribut( "SCALE11", atts );
+// double sca11 = atof(scale11.c_str());
+// transformValues[12] = sca11;
+// std::string scale12 = ReadXMLStringAttribut( "SCALE12", atts );
+// double sca12 = atof(scale12.c_str());
+// transformValues[13] = sca12;
+// std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
+// double useIni = atof(useInitializer.c_str());
+// transformValues[14] = useIni;
+// std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
+// double useMo = atof(useMoments.c_str());
+// transformValues[15] = useMo;
+// }
else if (transform == mitk::TransformParameters::EULER3DTRANSFORM || transform == mitk::TransformParameters::CENTEREDEULER3DTRANSFORM
|| transform == mitk::TransformParameters::VERSORRIGID3DTRANSFORM)
{
std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
double useSca = atof(useScales.c_str());
transformValues[1] = useSca;
std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
double sca1 = atof(scale1.c_str());
transformValues[2] = sca1;
std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
double sca2 = atof(scale2.c_str());
transformValues[3] = sca2;
std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
double sca3 = atof(scale3.c_str());
transformValues[4] = sca3;
std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
double sca4 = atof(scale4.c_str());
transformValues[5] = sca4;
std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
double sca5 = atof(scale5.c_str());
transformValues[6] = sca5;
std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
double sca6 = atof(scale6.c_str());
transformValues[7] = sca6;
std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
double useIni = atof(useInitializer.c_str());
transformValues[8] = useIni;
std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
double useMo = atof(useMoments.c_str());
transformValues[9] = useMo;
}
else if (transform == mitk::TransformParameters::QUATERNIONRIGIDTRANSFORM || transform == mitk::TransformParameters::SIMILARITY3DTRANSFORM)
{
std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
double useSca = atof(useScales.c_str());
transformValues[1] = useSca;
std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
double sca1 = atof(scale1.c_str());
transformValues[2] = sca1;
std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
double sca2 = atof(scale2.c_str());
transformValues[3] = sca2;
std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
double sca3 = atof(scale3.c_str());
transformValues[4] = sca3;
std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
double sca4 = atof(scale4.c_str());
transformValues[5] = sca4;
std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
double sca5 = atof(scale5.c_str());
transformValues[6] = sca5;
std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
double sca6 = atof(scale6.c_str());
transformValues[7] = sca6;
std::string scale7 = ReadXMLStringAttribut( "SCALE7", atts );
double sca7 = atof(scale7.c_str());
transformValues[8] = sca7;
std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
double useIni = atof(useInitializer.c_str());
transformValues[9] = useIni;
std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
double useMo = atof(useMoments.c_str());
transformValues[10] = useMo;
}
else if (transform == mitk::TransformParameters::SCALESKEWVERSOR3DTRANSFORM)
{
std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
double useSca = atof(useScales.c_str());
transformValues[1] = useSca;
std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
double sca1 = atof(scale1.c_str());
transformValues[2] = sca1;
std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
double sca2 = atof(scale2.c_str());
transformValues[3] = sca2;
std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
double sca3 = atof(scale3.c_str());
transformValues[4] = sca3;
std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
double sca4 = atof(scale4.c_str());
transformValues[5] = sca4;
std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
double sca5 = atof(scale5.c_str());
transformValues[6] = sca5;
std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
double sca6 = atof(scale6.c_str());
transformValues[7] = sca6;
std::string scale7 = ReadXMLStringAttribut( "SCALE7", atts );
double sca7 = atof(scale7.c_str());
transformValues[8] = sca7;
std::string scale8 = ReadXMLStringAttribut( "SCALE8", atts );
double sca8 = atof(scale8.c_str());
transformValues[9] = sca8;
std::string scale9 = ReadXMLStringAttribut( "SCALE9", atts );
double sca9 = atof(scale9.c_str());
transformValues[10] = sca9;
std::string scale10 = ReadXMLStringAttribut( "SCALE10", atts );
double sca10 = atof(scale10.c_str());
transformValues[11] = sca10;
std::string scale11 = ReadXMLStringAttribut( "SCALE11", atts );
double sca11 = atof(scale11.c_str());
transformValues[12] = sca11;
std::string scale12 = ReadXMLStringAttribut( "SCALE12", atts );
double sca12 = atof(scale12.c_str());
transformValues[13] = sca12;
std::string scale13 = ReadXMLStringAttribut( "SCALE13", atts );
double sca13 = atof(scale13.c_str());
transformValues[14] = sca13;
std::string scale14 = ReadXMLStringAttribut( "SCALE14", atts );
double sca14 = atof(scale14.c_str());
transformValues[15] = sca14;
std::string scale15 = ReadXMLStringAttribut( "SCALE15", atts );
double sca15 = atof(scale15.c_str());
transformValues[16] = sca15;
std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
double useIni = atof(useInitializer.c_str());
transformValues[17] = useIni;
std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
double useMo = atof(useMoments.c_str());
transformValues[18] = useMo;
}
else if (transform == mitk::TransformParameters::CENTEREDRIGID2DTRANSFORM)
{
std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
double useSca = atof(useScales.c_str());
transformValues[1] = useSca;
std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
double sca1 = atof(scale1.c_str());
transformValues[2] = sca1;
std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
double sca2 = atof(scale2.c_str());
transformValues[3] = sca2;
std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
double sca3 = atof(scale3.c_str());
transformValues[4] = sca3;
std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
double sca4 = atof(scale4.c_str());
transformValues[5] = sca4;
std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
double sca5 = atof(scale5.c_str());
transformValues[6] = sca5;
std::string angle = ReadXMLStringAttribut( "ANGLE", atts );
double ang = atof(angle.c_str());
transformValues[7] = ang;
std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
double useIni = atof(useInitializer.c_str());
transformValues[8] = useIni;
std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
double useMo = atof(useMoments.c_str());
transformValues[9] = useMo;
}
else if (transform == mitk::TransformParameters::SIMILARITY2DTRANSFORM)
{
std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
double useSca = atof(useScales.c_str());
transformValues[1] = useSca;
std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
double sca1 = atof(scale1.c_str());
transformValues[2] = sca1;
std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
double sca2 = atof(scale2.c_str());
transformValues[3] = sca2;
std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
double sca3 = atof(scale3.c_str());
transformValues[4] = sca3;
std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
double sca4 = atof(scale4.c_str());
transformValues[5] = sca4;
std::string scale = ReadXMLStringAttribut( "SCALE", atts );
double sca = atof(scale.c_str());
transformValues[6] = sca;
std::string angle = ReadXMLStringAttribut( "ANGLE", atts );
double ang = atof(angle.c_str());
transformValues[7] = ang;
std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
double useIni = atof(useInitializer.c_str());
transformValues[8] = useIni;
std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
double useMo = atof(useMoments.c_str());
transformValues[9] = useMo;
}
else if (transform == mitk::TransformParameters::CENTEREDSIMILARITY2DTRANSFORM)
{
std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
double useSca = atof(useScales.c_str());
transformValues[1] = useSca;
std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
double sca1 = atof(scale1.c_str());
transformValues[2] = sca1;
std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
double sca2 = atof(scale2.c_str());
transformValues[3] = sca2;
std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
double sca3 = atof(scale3.c_str());
transformValues[4] = sca3;
std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
double sca4 = atof(scale4.c_str());
transformValues[5] = sca4;
std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
double sca5 = atof(scale5.c_str());
transformValues[6] = sca5;
std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
double sca6 = atof(scale6.c_str());
transformValues[7] = sca6;
std::string scale = ReadXMLStringAttribut( "SCALE", atts );
double sca = atof(scale.c_str());
transformValues[8] = sca;
std::string angle = ReadXMLStringAttribut( "ANGLE", atts );
double ang = atof(angle.c_str());
transformValues[9] = ang;
std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
double useIni = atof(useInitializer.c_str());
transformValues[10] = useIni;
std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
double useMo = atof(useMoments.c_str());
transformValues[11] = useMo;
}
return transformValues;
}
itk::Array<double> RigidRegistrationPreset::loadMetricValues(itk::Array<double> metricValues, double metric, const char **atts)
{
std::string computeGradient = ReadXMLStringAttribut( "COMPUTEGRADIENT", atts );
double compGra = atof(computeGradient.c_str());
metricValues[1] = compGra;
if (metric == mitk::MetricParameters::MEANSQUARESIMAGETOIMAGEMETRIC || metric == mitk::MetricParameters::NORMALIZEDCORRELATIONIMAGETOIMAGEMETRIC
|| metric == mitk::MetricParameters::GRADIENTDIFFERENCEIMAGETOIMAGEMETRIC || metric == mitk::MetricParameters::MATCHCARDINALITYIMAGETOIMAGEMETRIC
|| metric == mitk::MetricParameters::KAPPASTATISTICIMAGETOIMAGEMETRIC)
{
}
else if (metric == mitk::MetricParameters::KULLBACKLEIBLERCOMPAREHISTOGRAMIMAGETOIMAGEMETRIC
|| metric == mitk::MetricParameters::CORRELATIONCOEFFICIENTHISTOGRAMIMAGETOIMAGEMETRIC
|| metric == mitk::MetricParameters::MEANSQUARESHISTOGRAMIMAGETOIMAGEMETRIC
|| metric == mitk::MetricParameters::MUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC
|| metric == mitk::MetricParameters::NORMALIZEDMUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC)
{
std::string histogramBins = ReadXMLStringAttribut( "HISTOGRAMBINS", atts );
double histBins = atof(histogramBins.c_str());
metricValues[2] = histBins;
}
else if (metric == mitk::MetricParameters::MATTESMUTUALINFORMATIONIMAGETOIMAGEMETRIC)
{
std::string useSampling = ReadXMLStringAttribut( "USESAMPLING", atts );
double useSamp = atof(useSampling.c_str());
metricValues[2] = useSamp;
std::string spatialSamples = ReadXMLStringAttribut( "SPATIALSAMPLES", atts );
double spatSamp = atof(spatialSamples.c_str());
metricValues[3] = spatSamp;
std::string histogramBins = ReadXMLStringAttribut( "HISTOGRAMBINS", atts );
double histBins = atof(histogramBins.c_str());
metricValues[4] = histBins;
}
else if (metric == mitk::MetricParameters::MEANRECIPROCALSQUAREDIFFERENCEIMAGETOIMAGEMETRIC)
{
std::string lambda = ReadXMLStringAttribut( "LAMBDA", atts );
double lamb = atof(lambda.c_str());
metricValues[2] = lamb;
}
else if (metric == mitk::MetricParameters::MUTUALINFORMATIONIMAGETOIMAGEMETRIC)
{
std::string spatialSamples = ReadXMLStringAttribut( "SPATIALSAMPLES", atts );
double spatSamp = atof(spatialSamples.c_str());
metricValues[2] = spatSamp;
std::string fixedStandardDeviation = ReadXMLStringAttribut( "FIXEDSTANDARDDEVIATION", atts );
double fiStaDev = atof(fixedStandardDeviation.c_str());
metricValues[3] = fiStaDev;
std::string movingStandardDeviation = ReadXMLStringAttribut( "MOVINGSTANDARDDEVIATION", atts );
double moStaDev = atof(movingStandardDeviation.c_str());
metricValues[4] = moStaDev;
std::string useNormalizer = ReadXMLStringAttribut( "USENORMALIZERANDSMOOTHER", atts );
double useNormal = atof(useNormalizer.c_str());
metricValues[5] = useNormal;
std::string fixedSmootherVariance = ReadXMLStringAttribut( "FIXEDSMOOTHERVARIANCE", atts );
double fiSmoVa = atof(fixedSmootherVariance.c_str());
metricValues[6] = fiSmoVa;
std::string movingSmootherVariance = ReadXMLStringAttribut( "MOVINGSMOOTHERVARIANCE", atts );
double moSmoVa = atof(movingSmootherVariance.c_str());
metricValues[7] = moSmoVa;
}
return metricValues;
}
itk::Array<double> RigidRegistrationPreset::loadOptimizerValues(itk::Array<double> optimizerValues, double optimizer, const char **atts)
{
std::string maximize = ReadXMLStringAttribut( "MAXIMIZE", atts );
double max = atof(maximize.c_str());
optimizerValues[1] = max;
if (optimizer == mitk::OptimizerParameters::EXHAUSTIVEOPTIMIZER)
{
std::string stepLength = ReadXMLStringAttribut( "STEPLENGTH", atts );
double stepLe = atof(stepLength.c_str());
optimizerValues[2] = stepLe;
std::string numberOfSteps = ReadXMLStringAttribut( "NUMBEROFSTEPS", atts );
double numSteps = atof(numberOfSteps.c_str());
optimizerValues[3] = numSteps;
}
else if (optimizer == mitk::OptimizerParameters::GRADIENTDESCENTOPTIMIZER
|| optimizer == mitk::OptimizerParameters::QUATERNIONRIGIDTRANSFORMGRADIENTDESCENTOPTIMIZER)
{
std::string learningRate = ReadXMLStringAttribut( "LEARNINGRATE", atts );
double learn = atof(learningRate.c_str());
optimizerValues[2] = learn;
std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
double numIt = atof(numberIterations.c_str());
optimizerValues[3] = numIt;
}
else if (optimizer == mitk::OptimizerParameters::LBFGSBOPTIMIZER)
{
}
else if (optimizer == mitk::OptimizerParameters::ONEPLUSONEEVOLUTIONARYOPTIMIZER)
{
std::string shrinkFactor = ReadXMLStringAttribut( "SHRINKFACTOR", atts );
double shrink = atof(shrinkFactor.c_str());
optimizerValues[2] = shrink;
std::string growthFactor = ReadXMLStringAttribut( "GROWTHFACTOR", atts );
double growth = atof(growthFactor.c_str());
optimizerValues[3] = growth;
std::string epsilon = ReadXMLStringAttribut( "EPSILON", atts );
double eps = atof(epsilon.c_str());
optimizerValues[4] = eps;
std::string initialRadius = ReadXMLStringAttribut( "INITIALRADIUS", atts );
double initRad = atof(initialRadius.c_str());
optimizerValues[5] = initRad;
std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
double numIt = atof(numberIterations.c_str());
optimizerValues[6] = numIt;
}
else if (optimizer == mitk::OptimizerParameters::POWELLOPTIMIZER)
{
std::string stepLength = ReadXMLStringAttribut( "STEPLENGTH", atts );
double stepLe = atof(stepLength.c_str());
optimizerValues[2] = stepLe;
std::string stepTolerance = ReadXMLStringAttribut( "STEPTOLERANCE", atts );
double stepTo = atof(stepTolerance.c_str());
optimizerValues[3] = stepTo;
std::string valueTolerance = ReadXMLStringAttribut( "VALUETOLERANCE", atts );
double valTo = atof(valueTolerance.c_str());
optimizerValues[4] = valTo;
std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
double numIt = atof(numberIterations.c_str());
optimizerValues[5] = numIt;
}
else if (optimizer == mitk::OptimizerParameters::FRPROPTIMIZER)
{
std::string useFletchReeves = ReadXMLStringAttribut( "USEFLETCHREEVES", atts );
double useFleRe = atof(useFletchReeves.c_str());
optimizerValues[2] = useFleRe;
std::string stepLength = ReadXMLStringAttribut( "STEPLENGTH", atts );
double stepLe = atof(stepLength.c_str());
optimizerValues[3] = stepLe;
std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
double numIt = atof(numberIterations.c_str());
optimizerValues[4] = numIt;
}
else if (optimizer == mitk::OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER)
{
std::string gradientMagnitudeTolerance = ReadXMLStringAttribut( "GRADIENTMAGNITUDETOLERANCE", atts );
double graMagTo = atof(gradientMagnitudeTolerance.c_str());
optimizerValues[2] = graMagTo;
std::string minStepLength = ReadXMLStringAttribut( "MINSTEPLENGTH", atts );
double minStep = atof(minStepLength.c_str());
optimizerValues[3] = minStep;
std::string maxStepLength = ReadXMLStringAttribut( "MAXSTEPLENGTH", atts );
double maxStep = atof(maxStepLength.c_str());
optimizerValues[4] = maxStep;
std::string relaxationFactor = ReadXMLStringAttribut( "RELAXATIONFACTOR", atts );
double relFac = atof(relaxationFactor.c_str());
optimizerValues[5] = relFac;
std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
double numIt = atof(numberIterations.c_str());
optimizerValues[6] = numIt;
}
else if (optimizer == mitk::OptimizerParameters::VERSORTRANSFORMOPTIMIZER || optimizer == mitk::OptimizerParameters::VERSORRIGID3DTRANSFORMOPTIMIZER)
{
std::string gradientMagnitudeTolerance = ReadXMLStringAttribut( "GRADIENTMAGNITUDETOLERANCE", atts );
double graMagTo = atof(gradientMagnitudeTolerance.c_str());
optimizerValues[2] = graMagTo;
std::string minStepLength = ReadXMLStringAttribut( "MINSTEPLENGTH", atts );
double minStep = atof(minStepLength.c_str());
optimizerValues[3] = minStep;
std::string maxStepLength = ReadXMLStringAttribut( "MAXSTEPLENGTH", atts );
double maxStep = atof(maxStepLength.c_str());
optimizerValues[4] = maxStep;
std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
double numIt = atof(numberIterations.c_str());
optimizerValues[5] = numIt;
}
else if (optimizer == mitk::OptimizerParameters::AMOEBAOPTIMIZER)
{
std::string simplexDelta1 = ReadXMLStringAttribut( "SIMPLEXDELTA1", atts );
double simpDel1 = atof(simplexDelta1.c_str());
optimizerValues[2] = simpDel1;
std::string simplexDelta2 = ReadXMLStringAttribut( "SIMPLEXDELTA2", atts );
double simpDel2 = atof(simplexDelta2.c_str());
optimizerValues[3] = simpDel2;
std::string simplexDelta3 = ReadXMLStringAttribut( "SIMPLEXDELTA3", atts );
double simpDel3 = atof(simplexDelta3.c_str());
optimizerValues[4] = simpDel3;
std::string simplexDelta4 = ReadXMLStringAttribut( "SIMPLEXDELTA4", atts );
double simpDel4 = atof(simplexDelta4.c_str());
optimizerValues[5] = simpDel4;
std::string simplexDelta5 = ReadXMLStringAttribut( "SIMPLEXDELTA5", atts );
double simpDel5 = atof(simplexDelta5.c_str());
optimizerValues[6] = simpDel5;
std::string simplexDelta6 = ReadXMLStringAttribut( "SIMPLEXDELTA6", atts );
double simpDel6 = atof(simplexDelta6.c_str());
optimizerValues[7] = simpDel6;
std::string simplexDelta7 = ReadXMLStringAttribut( "SIMPLEXDELTA7", atts );
double simpDel7 = atof(simplexDelta7.c_str());
optimizerValues[8] = simpDel7;
std::string simplexDelta8 = ReadXMLStringAttribut( "SIMPLEXDELTA8", atts );
double simpDel8 = atof(simplexDelta8.c_str());
optimizerValues[9] = simpDel8;
std::string simplexDelta9 = ReadXMLStringAttribut( "SIMPLEXDELTA9", atts );
double simpDel9 = atof(simplexDelta9.c_str());
optimizerValues[10] = simpDel9;
std::string simplexDelta10 = ReadXMLStringAttribut( "SIMPLEXDELTA10", atts );
double simpDel10 = atof(simplexDelta10.c_str());
optimizerValues[11] = simpDel10;
std::string simplexDelta11 = ReadXMLStringAttribut( "SIMPLEXDELTA11", atts );
double simpDel11 = atof(simplexDelta11.c_str());
optimizerValues[12] = simpDel11;
std::string simplexDelta12 = ReadXMLStringAttribut( "SIMPLEXDELTA12", atts );
double simpDel12 = atof(simplexDelta12.c_str());
optimizerValues[13] = simpDel12;
std::string simplexDelta13 = ReadXMLStringAttribut( "SIMPLEXDELTA13", atts );
double simpDel13 = atof(simplexDelta13.c_str());
optimizerValues[14] = simpDel13;
std::string simplexDelta14 = ReadXMLStringAttribut( "SIMPLEXDELTA14", atts );
double simpDel14 = atof(simplexDelta14.c_str());
optimizerValues[15] = simpDel14;
std::string simplexDelta15 = ReadXMLStringAttribut( "SIMPLEXDELTA15", atts );
double simpDel15 = atof(simplexDelta15.c_str());
optimizerValues[16] = simpDel15;
std::string simplexDelta16 = ReadXMLStringAttribut( "SIMPLEXDELTA16", atts );
double simpDel16 = atof(simplexDelta16.c_str());
optimizerValues[17] = simpDel16;
std::string parametersConvergenceTolerance = ReadXMLStringAttribut( "PARAMETERSCONVERGENCETOLERANCE", atts );
double paramConv = atof(parametersConvergenceTolerance.c_str());
optimizerValues[18] = paramConv;
std::string functionConvergenceTolerance = ReadXMLStringAttribut( "FUNCTIONCONVERGENCETOLERANCE", atts );
double funcConv = atof(functionConvergenceTolerance.c_str());
optimizerValues[19] = funcConv;
std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
double numIt = atof(numberIterations.c_str());
optimizerValues[20] = numIt;
}
else if (optimizer == mitk::OptimizerParameters::CONJUGATEGRADIENTOPTIMIZER)
{
}
else if (optimizer == mitk::OptimizerParameters::LBFGSOPTIMIZER)
{
std::string GradientConvergenceTolerance = ReadXMLStringAttribut( "GRADIENTCONVERGENCETOLERANCE", atts );
double graConTo = atof(GradientConvergenceTolerance.c_str());
optimizerValues[2] = graConTo;
std::string lineSearchAccuracy = ReadXMLStringAttribut( "LINESEARCHACCURACY", atts );
double lineSearch = atof(lineSearchAccuracy.c_str());
optimizerValues[3] = lineSearch;
std::string defaultStepLength = ReadXMLStringAttribut( "DEFAULTSTEPLENGTH", atts );
double defStep = atof(defaultStepLength.c_str());
optimizerValues[4] = defStep;
std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
double numIt = atof(numberIterations.c_str());
optimizerValues[5] = numIt;
std::string useTrace = ReadXMLStringAttribut( "USETRACE", atts );
double useTr = atof(useTrace.c_str());
optimizerValues[6] = useTr;
}
else if (optimizer == mitk::OptimizerParameters::SPSAOPTIMIZER)
{
std::string a = ReadXMLStringAttribut( "a", atts );
double a1 = atof(a.c_str());
optimizerValues[2] = a1;
std::string a2 = ReadXMLStringAttribut( "A", atts );
double a3 = atof(a2.c_str());
optimizerValues[3] = a3;
std::string alpha = ReadXMLStringAttribut( "ALPHA", atts );
double alp = atof(alpha.c_str());
optimizerValues[4] = alp;
std::string c = ReadXMLStringAttribut( "c", atts );
double c1 = atof(c.c_str());
optimizerValues[5] = c1;
std::string gamma = ReadXMLStringAttribut( "GAMMA", atts );
double gam = atof(gamma.c_str());
optimizerValues[6] = gam;
std::string tolerance = ReadXMLStringAttribut( "TOLERANCE", atts );
double tol = atof(tolerance.c_str());
optimizerValues[7] = tol;
std::string stateOfConvergenceDecayRate = ReadXMLStringAttribut( "STATEOFCONVERGENCEDECAYRATE", atts );
double stateOfConvergence = atof(stateOfConvergenceDecayRate.c_str());
optimizerValues[8] = stateOfConvergence;
std::string minNumberIterations = ReadXMLStringAttribut( "MINNUMBERITERATIONS", atts );
double minNumIt = atof(minNumberIterations.c_str());
optimizerValues[9] = minNumIt;
std::string numberPerturbations = ReadXMLStringAttribut( "NUMBERPERTURBATIONS", atts );
double numPer = atof(numberPerturbations.c_str());
optimizerValues[10] = numPer;
std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
double numIt = atof(numberIterations.c_str());
optimizerValues[11] = numIt;
}
return optimizerValues;
}
itk::Array<double> RigidRegistrationPreset::loadInterpolatorValues(itk::Array<double> interpolatorValues/*, double interpolator, const char **atts*/)
{
return interpolatorValues;
}
}
diff --git a/Modules/RigidRegistration/mitkTransformFactory.txx b/Modules/RigidRegistration/mitkTransformFactory.txx
index fc38ad9fa1..0c60661d90 100644
--- a/Modules/RigidRegistration/mitkTransformFactory.txx
+++ b/Modules/RigidRegistration/mitkTransformFactory.txx
@@ -1,470 +1,471 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTransformFactory.h"
#include "mitkTransformParameters.h"
#include "itkTranslationTransform.h"
#include "itkScaleTransform.h"
#include "itkScaleLogarithmicTransform.h"
#include "itkAffineTransform.h"
#include "itkCenteredAffineTransform.h"
#include "itkFixedCenterOfRotationAffineTransform.h"
#include "itkAzimuthElevationToCartesianTransform.h"
#include "itkCenteredTransformInitializer.h"
#include <itkRigid3DTransform.h>
#include <itkEuler3DTransform.h>
#include <itkCenteredEuler3DTransform.h>
#include <itkQuaternionRigidTransform.h>
#include <itkVersorTransform.h>
#include <itkVersorRigid3DTransform.h>
#include <itkScaleSkewVersor3DTransform.h>
#include <itkSimilarity3DTransform.h>
#include <itkRigid2DTransform.h>
#include <itkCenteredRigid2DTransform.h>
#include <itkEuler2DTransform.h>
#include <itkSimilarity2DTransform.h>
#include <itkCenteredSimilarity2DTransform.h>
namespace mitk {
template < class TPixelType, unsigned int VImageDimension >
TransformFactory< TPixelType, VImageDimension >::TransformFactory() :
m_TransformParameters(NULL),
m_FixedImage(NULL),
m_MovingImage(NULL),
m_FixedImage2D(NULL),
m_MovingImage2D(NULL),
m_FixedImage3D(NULL),
m_MovingImage3D(NULL)
{
}
template < class TPixelType, unsigned int VImageDimension >
void TransformFactory< TPixelType, VImageDimension >::SetFixedImage(FixedImageType* fixed)
{
if (VImageDimension == 2)
{
m_FixedImage2D = reinterpret_cast<FixedImage2DType*>(fixed);
m_FixedImage = fixed;
}
else
{
m_FixedImage3D = reinterpret_cast<FixedImage3DType*>(fixed);;
m_FixedImage = fixed;
}
}
template < class TPixelType, unsigned int VImageDimension >
void TransformFactory< TPixelType, VImageDimension >::SetMovingImage(MovingImageType* moving)
{
if (VImageDimension == 2)
{
m_MovingImage2D = reinterpret_cast<MovingImage2DType*>(moving);
m_MovingImage = moving;
}
else
{
m_MovingImage3D = reinterpret_cast<MovingImage3DType*>(moving);
m_MovingImage = moving;
}
}
/*template < class TPixelType, unsigned int VImageDimension >
typename ::itk::Transform< double, VImageDimension, VImageDimension >::Pointer
MakeRigidTransform();
template <class TPixelType>
typename ::itk::Transform< double, 3, 3 >::Pointer
MakeRigidTransform<TPixelType, 3>()
{
itk::Rigid3DTransform< double >::Pointer transform = itk::Rigid3DTransform< double >::New();
transform->SetIdentity();
return transform.GetPointer();
}
template <class TPixelType>
typename ::itk::Transform< double, 2, 2 >::Pointer
MakeRigidTransform<TPixelType, 2>()
{
return NULL;
}*/
/*template < unsigned int VImageDimension >
typename ::itk::Transform< double, VImageDimension, VImageDimension >::Pointer
MakeRigidTransform();
template <>
typename ::itk::Transform< double, 3, 3 >::Pointer
MakeRigidTransform<3>()
{
itk::Rigid3DTransform< double >::Pointer transform = itk::Rigid3DTransform< double >::New();
transform->SetIdentity();
return transform.GetPointer();
}
template <>
typename ::itk::Transform< double, 2, 2 >::Pointer
MakeRigidTransform<2>()
{
return NULL;
}*/
//
//template<class T, class U, int I> class X
// { void f() { cout << "Primary template" << endl; } };
//template<class T> class X<int, T*, 10>
// { void f() { cout << "Partial specialization 3" << endl;
// } };
//
//
//template < class TPixelType > class TransformFactory<TPixelType, 3>
//{
// typedef typename itk::Transform< double, 3, 3 > TransformType;
// typedef typename TransformType::Pointer TransformPointer;
//
// typename TransformPointer MakeRigidTransform()
// {
// }
//};
//template <>
// typename TransformFactory< double, 3 >::TransformPointer
// TransformFactory< double, 3 >::MakeRigidTransform()
//{
// itk::Rigid3DTransform< double >::Pointer transform = itk::Rigid3DTransform< double >::New();
// transform->SetIdentity();
// return transform.GetPointer();
//}
//template <>
// typename TransformFactory< double, 2 >::TransformPointer
// TransformFactory< double, 2 >::MakeRigidTransform()
//{
// return NULL;
//}
template < class TPixelType, unsigned int VImageDimension >
typename TransformFactory< TPixelType, VImageDimension >::TransformPointer
TransformFactory< TPixelType, VImageDimension >::GetTransform()
{
int transform = m_TransformParameters->GetTransform();
if (transform == TransformParameters::TRANSLATIONTRANSFORM)
{
typename itk::TranslationTransform< double, VImageDimension>::Pointer transformPointer = itk::TranslationTransform< double, VImageDimension>::New();
transformPointer->SetIdentity();
return transformPointer.GetPointer();
}
else if (transform == TransformParameters::SCALETRANSFORM)
{
typename itk::ScaleTransform< double, VImageDimension>::Pointer transformPointer = itk::ScaleTransform< double, VImageDimension>::New();
transformPointer->SetIdentity();
return transformPointer.GetPointer();
}
else if (transform == TransformParameters::SCALELOGARITHMICTRANSFORM)
{
typename itk::ScaleLogarithmicTransform< double, VImageDimension>::Pointer transformPointer = itk::ScaleLogarithmicTransform< double, VImageDimension>::New();
transformPointer->SetIdentity();
return transformPointer.GetPointer();
}
else if (transform == TransformParameters::AFFINETRANSFORM)
{
typename itk::AffineTransform< double, VImageDimension>::Pointer transformPointer = itk::AffineTransform< double, VImageDimension>::New();
transformPointer->SetIdentity();
if (m_TransformParameters->GetTransformInitializerOn())
{
typedef typename itk::AffineTransform< double, VImageDimension > AffineTransformType;
typedef typename itk::CenteredTransformInitializer<AffineTransformType, FixedImageType, MovingImageType> TransformInitializerType;
typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
transformInitializer->SetFixedImage( m_FixedImage );
transformInitializer->SetMovingImage( m_MovingImage );
transformInitializer->SetTransform( transformPointer );
if (m_TransformParameters->GetMomentsOn())
{
transformInitializer->MomentsOn();
}
else
{
transformInitializer->GeometryOn();
}
transformInitializer->InitializeTransform();
}
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
return transformPointer.GetPointer();
}
else if (transform == TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM)
{
typedef typename itk::FixedCenterOfRotationAffineTransform< double, VImageDimension > CenteredAffineTransformType;
typename itk::FixedCenterOfRotationAffineTransform< double, VImageDimension>::Pointer transformPointer = itk::FixedCenterOfRotationAffineTransform< double, VImageDimension>::New();
transformPointer->SetIdentity();
if (m_TransformParameters->GetTransformInitializerOn())
{
typedef typename itk::FixedCenterOfRotationAffineTransform< double, VImageDimension > FixedCenterOfRotationAffineTransformType;
typedef typename itk::CenteredTransformInitializer<FixedCenterOfRotationAffineTransformType, FixedImageType, MovingImageType> TransformInitializerType;
typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
transformInitializer->SetFixedImage( m_FixedImage );
transformInitializer->SetMovingImage( m_MovingImage );
transformInitializer->SetTransform( transformPointer );
if (m_TransformParameters->GetMomentsOn())
{
transformInitializer->MomentsOn();
}
else
{
transformInitializer->GeometryOn();
}
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
transformInitializer->InitializeTransform();
}
return transformPointer.GetPointer();
}
- else if (transform == TransformParameters::RIGID3DTRANSFORM)
- {
- //return MakeRigidTransform<VImageDimension>();
- if (VImageDimension == 3)
- {
- typename itk::Rigid3DTransform< double >::Pointer transformPointer = itk::Rigid3DTransform< double >::New();
- transformPointer->SetIdentity();
- m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
- m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
- m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
- return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
- }
- }
+ //TODO remove rigid3dTransform
+// else if (transform == TransformParameters::RIGID3DTRANSFORM)
+// {
+// //return MakeRigidTransform<VImageDimension>();
+// if (VImageDimension == 3)
+// {
+// typename itk::Rigid3DTransform< double >::Pointer transformPointer = itk::Rigid3DTransform< double >::New();
+// transformPointer->SetIdentity();
+// m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
+// m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
+// m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
+// return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
+// }
+// }
else if (transform == TransformParameters::EULER3DTRANSFORM)
{
if (VImageDimension == 3)
{
typename itk::Euler3DTransform< double >::Pointer transformPointer = itk::Euler3DTransform< double >::New();
transformPointer->SetIdentity();
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::CENTEREDEULER3DTRANSFORM)
{
if (VImageDimension == 3)
{
typename itk::CenteredEuler3DTransform< double >::Pointer transformPointer = itk::CenteredEuler3DTransform< double >::New();
transformPointer->SetIdentity();
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::QUATERNIONRIGIDTRANSFORM)
{
if (VImageDimension == 3)
{
typename itk::QuaternionRigidTransform< double >::Pointer transformPointer = itk::QuaternionRigidTransform< double >::New();
transformPointer->SetIdentity();
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::VERSORTRANSFORM)
{
if (VImageDimension == 3)
{
typename itk::VersorTransform< double >::Pointer transformPointer = itk::VersorTransform< double >::New();
transformPointer->SetIdentity();
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::VERSORRIGID3DTRANSFORM)
{
if (VImageDimension == 3)
{
typename itk::VersorRigid3DTransform< double >::Pointer transformPointer = itk::VersorRigid3DTransform< double >::New();
transformPointer->SetIdentity();
typedef typename itk::VersorRigid3DTransform< double > VersorRigid3DTransformType;
if (m_TransformParameters->GetTransformInitializerOn())
{
typedef typename itk::CenteredTransformInitializer<VersorRigid3DTransformType, FixedImage3DType, MovingImage3DType> TransformInitializerType;
typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
transformInitializer->SetFixedImage( m_FixedImage3D );
transformInitializer->SetMovingImage( m_MovingImage3D );
transformInitializer->SetTransform( transformPointer );
if (m_TransformParameters->GetMomentsOn())
{
transformInitializer->MomentsOn();
}
else
{
transformInitializer->GeometryOn();
}
transformInitializer->InitializeTransform();
}
typedef VersorRigid3DTransformType::VersorType VersorType;
typedef VersorType::VectorType VectorType;
VersorType rotation;
VectorType axis;
axis[0] = 0.0;
axis[1] = 0.0;
axis[2] = 1.0;
const double angle = 0;
rotation.Set( axis, angle );
transformPointer->SetRotation( rotation );
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::SCALESKEWVERSOR3DTRANSFORM)
{
if (VImageDimension == 3)
{
typename itk::ScaleSkewVersor3DTransform< double >::Pointer transformPointer = itk::ScaleSkewVersor3DTransform< double >::New();
transformPointer->SetIdentity();
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::SIMILARITY3DTRANSFORM)
{
if (VImageDimension == 3)
{
typename itk::Similarity3DTransform< double >::Pointer transformPointer = itk::Similarity3DTransform< double >::New();
transformPointer->SetIdentity();
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::RIGID2DTRANSFORM)
{
if (VImageDimension == 2)
{
typename itk::Rigid2DTransform< double >::Pointer transformPointer = itk::Rigid2DTransform< double >::New();
transformPointer->SetIdentity();
transformPointer->SetAngle( m_TransformParameters->GetAngle() );
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::CENTEREDRIGID2DTRANSFORM)
{
if (VImageDimension == 2)
{
typename itk::CenteredRigid2DTransform< double >::Pointer transformPointer = itk::CenteredRigid2DTransform< double >::New();
transformPointer->SetIdentity();
if (m_TransformParameters->GetTransformInitializerOn())
{
typedef typename itk::CenteredRigid2DTransform< double > CenteredRigid2DTransformType;
typedef typename itk::CenteredTransformInitializer<CenteredRigid2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
transformInitializer->SetFixedImage( m_FixedImage2D );
transformInitializer->SetMovingImage( m_MovingImage2D );
transformInitializer->SetTransform( transformPointer );
if (m_TransformParameters->GetMomentsOn())
{
transformInitializer->MomentsOn();
}
else
{
transformInitializer->GeometryOn();
}
transformInitializer->InitializeTransform();
}
transformPointer->SetAngle( m_TransformParameters->GetAngle() );
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::EULER2DTRANSFORM)
{
if (VImageDimension == 2)
{
typename itk::Euler2DTransform< double >::Pointer transformPointer = itk::Euler2DTransform< double >::New();
transformPointer->SetIdentity();
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::SIMILARITY2DTRANSFORM)
{
if (VImageDimension == 2)
{
typename itk::Similarity2DTransform< double >::Pointer transformPointer = itk::Similarity2DTransform< double >::New();
transformPointer->SetIdentity();
transformPointer->SetScale( m_TransformParameters->GetScale() );
transformPointer->SetAngle( m_TransformParameters->GetAngle() );
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
else if (transform == TransformParameters::CENTEREDSIMILARITY2DTRANSFORM)
{
if (VImageDimension == 2)
{
typename itk::CenteredSimilarity2DTransform< double >::Pointer transformPointer = itk::CenteredSimilarity2DTransform< double >::New();
transformPointer->SetIdentity();
if (m_TransformParameters->GetTransformInitializerOn())
{
typedef typename itk::CenteredSimilarity2DTransform< double > CenteredSimilarity2DTransformType;
typedef typename itk::CenteredTransformInitializer<CenteredSimilarity2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
transformInitializer->SetFixedImage( m_FixedImage2D );
transformInitializer->SetMovingImage( m_MovingImage2D );
transformInitializer->SetTransform( transformPointer );
if (m_TransformParameters->GetMomentsOn())
{
transformInitializer->MomentsOn();
}
else
{
transformInitializer->GeometryOn();
}
transformInitializer->InitializeTransform();
}
transformPointer->SetScale( m_TransformParameters->GetScale() );
transformPointer->SetAngle( m_TransformParameters->GetAngle() );
m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
}
}
return NULL;
}
} // end namespace
diff --git a/Modules/RigidRegistration/mitkTransformParameters.h b/Modules/RigidRegistration/mitkTransformParameters.h
index 11dd5cc7d3..dfad5f282a 100644
--- a/Modules/RigidRegistration/mitkTransformParameters.h
+++ b/Modules/RigidRegistration/mitkTransformParameters.h
@@ -1,211 +1,211 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKTRANSFORMPARAMETERS_H
#define MITKTRANSFORMPARAMETERS_H
#include <itkObjectFactory.h>
#include "MitkRigidRegistrationExports.h"
#include <itkArray.h>
#include "mitkCommon.h"
namespace mitk {
/*!
\brief This class is used to hold all transform parameters needed for a rigid registration process.
To use the rigid registration framework you have to create an instance of this class and fill it with the parameters
belonging to the selected transformation. To let the rigid registration work properly, this instance has to be given
to mitkImageRegistrationMethod before calling the update() method in mitkImageRegistrationMethod.
Also instances of the classes mitkMetricParameters and mitkOptimizerParameters have to be set in mitkImageRegistrationMethod
before calling the update() method.
\ingroup RigidRegistration
\author Daniel Stein
*/
class MITK_RIGIDREGISTRATION_EXPORT TransformParameters : public itk::Object
{
public:
mitkClassMacro(TransformParameters, ::itk::Object);
itkNewMacro(Self);
/**
\brief Unique integer value for every transform.
*/
enum TransformType {
TRANSLATIONTRANSFORM = 0,
SCALETRANSFORM = 1,
SCALELOGARITHMICTRANSFORM = 2,
AFFINETRANSFORM = 3,
FIXEDCENTEROFROTATIONAFFINETRANSFORM = 4,
- RIGID3DTRANSFORM = 5,
+ RIGID3DTRANSFORM = 5, //TODO remove rigid3dTrassform
EULER3DTRANSFORM = 6,
CENTEREDEULER3DTRANSFORM = 7,
QUATERNIONRIGIDTRANSFORM = 8,
VERSORTRANSFORM = 9,
VERSORRIGID3DTRANSFORM = 10,
SCALESKEWVERSOR3DTRANSFORM = 11,
SIMILARITY3DTRANSFORM = 12,
RIGID2DTRANSFORM = 13,
CENTEREDRIGID2DTRANSFORM = 14,
EULER2DTRANSFORM = 15,
SIMILARITY2DTRANSFORM = 16,
CENTEREDSIMILARITY2DTRANSFORM = 17
};
/**
\brief Sets the transform used for registration by its unique integer value.
*/
itkSetMacro( Transform, int );
/**
\brief Returns the transform used for registration by its unique integer value.
*/
itkGetMacro( Transform, int );
/**
\brief Sets an array that holds the magnitudes of changes for the transforms degrees of freedom.
The optimizer changes the transforms values corresponding to this array values.
*/
void SetScales(itk::Array<double> scales);
/**
\brief Returns an array that holds the magnitudes of changes for the transforms degrees of freedom.
The optimizer changes the transforms values corresponding to this array values.
*/
itk::Array<double> GetScales();
/**
\brief Sets an array that holds the initial transform parameters.
*/
void SetInitialParameters(itk::Array<double> initialParameters);
/**
\brief Returns an array that holds the initial transform parameters.
*/
itk::Array<double> GetInitialParameters();
/**
\brief Sets whether a transform initializer will be used.
True = initializer is used, initializer is not used.
*/
itkSetMacro( TransformInitializerOn, bool );
/**
\brief Returns whether a transform initializer will be used.
True = initializer is used, false = initializer is not used.
*/
itkGetMacro( TransformInitializerOn, bool );
/**
\brief Sets whether the transform initializer will be used to align the images moments or their centers.
True = image moments will be aligned, false = image centers will be aligned.
*/
itkSetMacro( MomentsOn, bool );
/**
\brief Returns whether the transform initializer will be used to align the images moments or their centers.
True = image moments will be aligned, false = image centers will be aligned.
*/
itkGetMacro( MomentsOn, bool );
/**
\brief Sets whether the optimizer scales will be used to let the optimizer know about different magnitudes for
the transforms degrees of freedom.
True = optimizer scales will be used, false = optimizer scales will not be used.
*/
itkSetMacro( UseOptimizerScales, bool );
/**
\brief Returns whether the optimizer scales will be used to let the optimizer know about different magnitudes for
the transforms degrees of freedom.
True = optimizer scales will be used, false = optimizer scales will not be used.
*/
itkGetMacro( UseOptimizerScales, bool );
/**
\brief Sets the initial angle for transforms.
*/
itkSetMacro( Angle, float );
/**
\brief Returns the initial angle for transforms.
*/
itkGetMacro( Angle, float );
/**
\brief Sets the transforms initial scale.
*/
itkSetMacro( Scale, float );
/**
\brief Returns the transforms initial scale.
*/
itkGetMacro( Scale, float );
/**
\brief This setter is used by the mitkTransformFactory to set the transforms initial center in X direction.
*/
itkSetMacro( TransformCenterX, double );
/**
\brief Returns the transforms initial center in X direction.
*/
itkGetMacro( TransformCenterX, double );
/**
\brief This setter is used by the mitkTransformFactory to set the transforms initial center in Y direction.
*/
itkSetMacro( TransformCenterY, double );
/**
\brief Returns the transforms initial center in Y direction.
*/
itkGetMacro( TransformCenterY, double );
/**
\brief This setter is used by the mitkTransformFactory to set the transforms initial center in Z direction.
*/
itkSetMacro( TransformCenterZ, double );
/**
\brief Returns the transforms initial center in Z direction.
*/
itkGetMacro( TransformCenterZ, double );
protected:
TransformParameters();
~TransformParameters() {};
int m_Transform;
float m_Angle;
float m_Scale;
bool m_TransformInitializerOn;
bool m_MomentsOn;
bool m_UseOptimizerScales;
double m_TransformCenterX;
double m_TransformCenterY;
double m_TransformCenterZ;
itk::Array<double> m_Scales;
itk::Array<double> m_InitialParameters;
};
} // namespace mitk
#endif // MITKTRANSFORMPARAMETERS_H
diff --git a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkRigid3DTransformView.cpp b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkRigid3DTransformView.cpp
index 82ce5195f8..ca5a64b3e6 100644
--- a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkRigid3DTransformView.cpp
+++ b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkRigid3DTransformView.cpp
@@ -1,193 +1,193 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkRigid3DTransformView.h"
#include "mitkImageAccessByItk.h"
-#include <itkRigid3DTransform.h>
+#include <itkVersorRigid3DTransform.h>
#include <itkCenteredTransformInitializer.h>
#include <QValidator>
QmitkRigid3DTransformView::QmitkRigid3DTransformView(QWidget* parent, Qt::WindowFlags f ) : QmitkRigidRegistrationTransformsGUIBase(parent, f),
m_CenterX(0), m_CenterY(0), m_CenterZ(0)
{
}
QmitkRigid3DTransformView::~QmitkRigid3DTransformView()
{
}
mitk::TransformParameters::TransformType QmitkRigid3DTransformView::GetTransformType()
{
return mitk::TransformParameters::RIGID3DTRANSFORM;
}
itk::Object::Pointer QmitkRigid3DTransformView::GetTransform()
{
if (m_FixedImage.IsNotNull())
{
AccessByItk(m_FixedImage, GetTransform2);
return m_TransformObject;
}
return NULL;
}
template < class TPixelType, unsigned int VImageDimension >
itk::Object::Pointer QmitkRigid3DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* /*itkImage1*/)
{
typedef typename itk::Image< TPixelType, VImageDimension > FixedImageType;
typedef typename itk::Image< TPixelType, VImageDimension > MovingImageType;
if (VImageDimension == 3)
{
- typename itk::Rigid3DTransform< double >::Pointer transformPointer = itk::Rigid3DTransform< double >::New();
+ typename itk::VersorRigid3DTransform< double >::Pointer transformPointer = itk::VersorRigid3DTransform< double >::New();
transformPointer->SetIdentity();
m_CenterX = transformPointer->GetCenter()[0];
m_CenterY = transformPointer->GetCenter()[1];
m_CenterZ = transformPointer->GetCenter()[2];
m_TransformObject = transformPointer.GetPointer();
return transformPointer.GetPointer();
}
return NULL;
}
itk::Array<double> QmitkRigid3DTransformView::GetTransformParameters()
{
itk::Array<double> transformValues;
transformValues.SetSize(15);
transformValues.fill(0);
transformValues[0] = m_Controls.m_UseOptimizerScalesRigid3D->isChecked();
transformValues[1] = m_Controls.m_ScalesRigid3DTransformScale1->text().toDouble();
transformValues[2] = m_Controls.m_ScalesRigid3DTransformScale2->text().toDouble();
transformValues[3] = m_Controls.m_ScalesRigid3DTransformScale3->text().toDouble();
transformValues[4] = m_Controls.m_ScalesRigid3DTransformScale4->text().toDouble();
transformValues[5] = m_Controls.m_ScalesRigid3DTransformScale5->text().toDouble();
transformValues[6] = m_Controls.m_ScalesRigid3DTransformScale6->text().toDouble();
transformValues[7] = m_Controls.m_ScalesRigid3DTransformScale7->text().toDouble();
transformValues[8] = m_Controls.m_ScalesRigid3DTransformScale8->text().toDouble();
transformValues[9] = m_Controls.m_ScalesRigid3DTransformScale9->text().toDouble();
transformValues[10] = m_Controls.m_ScalesRigid3DTransformScaleTranslationX->text().toDouble();
transformValues[11] = m_Controls.m_ScalesRigid3DTransformScaleTranslationY->text().toDouble();
transformValues[12] = m_Controls.m_ScalesRigid3DTransformScaleTranslationZ->text().toDouble();
transformValues[13] = m_Controls.m_CenterForInitializerRigid3D->isChecked();
transformValues[14] = m_Controls.m_MomentsRigid3D->isChecked();
return transformValues;
}
void QmitkRigid3DTransformView::SetTransformParameters(itk::Array<double> transformValues)
{
m_Controls.m_UseOptimizerScalesRigid3D->setChecked(transformValues[0]);
m_Controls.m_ScalesRigid3DTransformScale1->setText(QString::number(transformValues[1]));
m_Controls.m_ScalesRigid3DTransformScale2->setText(QString::number(transformValues[2]));
m_Controls.m_ScalesRigid3DTransformScale3->setText(QString::number(transformValues[3]));
m_Controls.m_ScalesRigid3DTransformScale4->setText(QString::number(transformValues[4]));
m_Controls.m_ScalesRigid3DTransformScale5->setText(QString::number(transformValues[5]));
m_Controls.m_ScalesRigid3DTransformScale6->setText(QString::number(transformValues[6]));
m_Controls.m_ScalesRigid3DTransformScale7->setText(QString::number(transformValues[7]));
m_Controls.m_ScalesRigid3DTransformScale8->setText(QString::number(transformValues[8]));
m_Controls.m_ScalesRigid3DTransformScale9->setText(QString::number(transformValues[9]));
m_Controls.m_ScalesRigid3DTransformScaleTranslationX->setText(QString::number(transformValues[10]));
m_Controls.m_ScalesRigid3DTransformScaleTranslationY->setText(QString::number(transformValues[11]));
m_Controls.m_ScalesRigid3DTransformScaleTranslationZ->setText(QString::number(transformValues[12]));
m_Controls.m_CenterForInitializerRigid3D->setChecked(transformValues[13]);
m_Controls.m_MomentsRigid3D->setChecked(transformValues[14]);
m_Controls.m_GeometryRigid3D->setChecked(!transformValues[14]);
}
QString QmitkRigid3DTransformView::GetName()
{
return "Rigid3D";
}
void QmitkRigid3DTransformView::SetupUI(QWidget* parent)
{
m_Controls.setupUi(parent);
QValidator* validatorLineEditInputFloat = new QDoubleValidator(0, 20000000, 8, this);
m_Controls.m_ScalesRigid3DTransformScale1->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScale2->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScale3->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScale4->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScale5->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScale6->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScale7->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScale8->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScale9->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScaleTranslationX->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScaleTranslationY->setValidator(validatorLineEditInputFloat);
m_Controls.m_ScalesRigid3DTransformScaleTranslationZ->setValidator(validatorLineEditInputFloat);
}
itk::Array<double> QmitkRigid3DTransformView::GetScales()
{
itk::Array<double> scales;
scales.SetSize(12);
scales.Fill(1.0);
if (m_Controls.m_UseOptimizerScalesRigid3D->isChecked())
{
scales[0] = m_Controls.m_ScalesRigid3DTransformScale1->text().toDouble();
scales[1] = m_Controls.m_ScalesRigid3DTransformScale2->text().toDouble();
scales[2] = m_Controls.m_ScalesRigid3DTransformScale3->text().toDouble();
scales[3] = m_Controls.m_ScalesRigid3DTransformScale4->text().toDouble();
scales[4] = m_Controls.m_ScalesRigid3DTransformScale5->text().toDouble();
scales[5] = m_Controls.m_ScalesRigid3DTransformScale6->text().toDouble();
scales[6] = m_Controls.m_ScalesRigid3DTransformScale7->text().toDouble();
scales[7] = m_Controls.m_ScalesRigid3DTransformScale8->text().toDouble();
scales[8] = m_Controls.m_ScalesRigid3DTransformScale9->text().toDouble();
scales[9] = m_Controls.m_ScalesRigid3DTransformScaleTranslationX->text().toDouble();
scales[10] = m_Controls.m_ScalesRigid3DTransformScaleTranslationY->text().toDouble();
scales[11] = m_Controls.m_ScalesRigid3DTransformScaleTranslationZ->text().toDouble();
}
return scales;
}
vtkTransform* QmitkRigid3DTransformView::Transform(vtkMatrix4x4* vtkmatrix, vtkTransform* vtktransform, itk::Array<double> transformParams)
{
if (m_MovingImage.IsNotNull())
{
int m = 0;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
vtkmatrix->SetElement(i, j, transformParams[m]);
m++;
}
}
float center[4];
float translation[4];
center[0] = m_CenterX;
center[1] = m_CenterY;
center[2] = m_CenterZ;
center[3] = 1;
vtkmatrix->MultiplyPoint(center, translation);
vtkmatrix->SetElement(0, 3, -translation[0] + center[0] + transformParams[9]);
vtkmatrix->SetElement(1, 3, -translation[1] + center[1] + transformParams[10]);
vtkmatrix->SetElement(2, 3, -translation[2] + center[2] + transformParams[11]);
vtktransform->SetMatrix(vtkmatrix);
}
return vtktransform;
}
int QmitkRigid3DTransformView::GetNumberOfTransformParameters()
{
if (m_FixedImage.IsNotNull())
{
if (m_FixedImage->GetDimension() == 2)
return 6;
else
return 12;
}
else
return 0;
}
diff --git a/Modules/RigidRegistrationUI/files.cmake b/Modules/RigidRegistrationUI/files.cmake
index 135f7ba523..25f183a8f6 100644
--- a/Modules/RigidRegistrationUI/files.cmake
+++ b/Modules/RigidRegistrationUI/files.cmake
@@ -1,98 +1,98 @@
set(CPP_FILES
RigidRegistrationMetrics/QmitkRigidRegistrationMetricsGUIBase.cpp
RigidRegistrationMetrics/QmitkMeanSquaresMetricView.cpp
RigidRegistrationMetrics/QmitkNormalizedCorrelationMetricView.cpp
RigidRegistrationMetrics/QmitkGradientDifferenceMetricView.cpp
RigidRegistrationMetrics/QmitkKullbackLeiblerCompareHistogramMetricView.cpp
RigidRegistrationMetrics/QmitkCorrelationCoefficientHistogramMetricView.cpp
RigidRegistrationMetrics/QmitkMeanSquaresHistogramMetricView.cpp
RigidRegistrationMetrics/QmitkMutualInformationHistogramMetricView.cpp
RigidRegistrationMetrics/QmitkNormalizedMutualInformationHistogramMetricView.cpp
RigidRegistrationMetrics/QmitkMattesMutualInformationMetricView.cpp
RigidRegistrationMetrics/QmitkMeanReciprocalSquareDifferenceMetricView.cpp
RigidRegistrationMetrics/QmitkMutualInformationMetricView.cpp
RigidRegistrationMetrics/QmitkMatchCardinalityMetricView.cpp
RigidRegistrationMetrics/QmitkKappaStatisticMetricView.cpp
RigidRegistrationOptimizer/QmitkRigidRegistrationOptimizerGUIBase.cpp
RigidRegistrationOptimizer/QmitkExhaustiveOptimizerView.cpp
RigidRegistrationOptimizer/QmitkGradientDescentOptimizerView.cpp
RigidRegistrationOptimizer/QmitkQuaternionRigidTransformGradientDescentOptimizerView.cpp
RigidRegistrationOptimizer/QmitkLBFGSBOptimizerView.cpp
RigidRegistrationOptimizer/QmitkOnePlusOneEvolutionaryOptimizerView.cpp
RigidRegistrationOptimizer/QmitkPowellOptimizerView.cpp
RigidRegistrationOptimizer/QmitkFRPROptimizerView.cpp
RigidRegistrationOptimizer/QmitkRegularStepGradientDescentOptimizerView.cpp
RigidRegistrationOptimizer/QmitkVersorTransformOptimizerView.cpp
RigidRegistrationOptimizer/QmitkAmoebaOptimizerView.cpp
RigidRegistrationOptimizer/QmitkConjugateGradientOptimizerView.cpp
RigidRegistrationOptimizer/QmitkLBFGSOptimizerView.cpp
RigidRegistrationOptimizer/QmitkSPSAOptimizerView.cpp
RigidRegistrationOptimizer/QmitkVersorRigid3DTransformOptimizerView.cpp
RigidRegistrationTransforms/QmitkRigidRegistrationTransformsGUIBase.cpp
RigidRegistrationTransforms/QmitkTranslationTransformView.cpp
RigidRegistrationTransforms/QmitkScaleTransformView.cpp
RigidRegistrationTransforms/QmitkScaleLogarithmicTransformView.cpp
RigidRegistrationTransforms/QmitkAffineTransformView.cpp
RigidRegistrationTransforms/QmitkFixedCenterOfRotationAffineTransformView.cpp
- RigidRegistrationTransforms/QmitkRigid3DTransformView.cpp
+ #RigidRegistrationTransforms/QmitkRigid3DTransformView.cpp
RigidRegistrationTransforms/QmitkEuler3DTransformView.cpp
RigidRegistrationTransforms/QmitkCenteredEuler3DTransformView.cpp
RigidRegistrationTransforms/QmitkQuaternionRigidTransformView.cpp
RigidRegistrationTransforms/QmitkVersorTransformView.cpp
RigidRegistrationTransforms/QmitkVersorRigid3DTransformView.cpp
RigidRegistrationTransforms/QmitkScaleSkewVersor3DTransformView.cpp
RigidRegistrationTransforms/QmitkSimilarity3DTransformView.cpp
RigidRegistrationTransforms/QmitkRigid2DTransformView.cpp
RigidRegistrationTransforms/QmitkCenteredRigid2DTransformView.cpp
RigidRegistrationTransforms/QmitkEuler2DTransformView.cpp
RigidRegistrationTransforms/QmitkSimilarity2DTransformView.cpp
RigidRegistrationTransforms/QmitkCenteredSimilarity2DTransformView.cpp
)
set(UI_FILES
RigidRegistrationMetrics/QmitkMeanSquaresMetricControls.ui
RigidRegistrationMetrics/QmitkNormalizedCorrelationMetricControls.ui
RigidRegistrationMetrics/QmitkGradientDifferenceMetricControls.ui
RigidRegistrationMetrics/QmitkKullbackLeiblerCompareHistogramMetricControls.ui
RigidRegistrationMetrics/QmitkCorrelationCoefficientHistogramMetricControls.ui
RigidRegistrationMetrics/QmitkMeanSquaresHistogramMetricControls.ui
RigidRegistrationMetrics/QmitkMutualInformationHistogramMetricControls.ui
RigidRegistrationMetrics/QmitkNormalizedMutualInformationHistogramMetricControls.ui
RigidRegistrationMetrics/QmitkMattesMutualInformationMetricControls.ui
RigidRegistrationMetrics/QmitkMeanReciprocalSquareDifferenceMetricControls.ui
RigidRegistrationMetrics/QmitkMutualInformationMetricControls.ui
RigidRegistrationMetrics/QmitkMatchCardinalityMetricControls.ui
RigidRegistrationMetrics/QmitkKappaStatisticMetricControls.ui
RigidRegistrationOptimizer/QmitkExhaustiveOptimizerControls.ui
RigidRegistrationOptimizer/QmitkGradientDescentOptimizerControls.ui
RigidRegistrationOptimizer/QmitkQuaternionRigidTransformGradientDescentOptimizerControls.ui
RigidRegistrationOptimizer/QmitkLBFGSBOptimizerControls.ui
RigidRegistrationOptimizer/QmitkOnePlusOneEvolutionaryOptimizerControls.ui
RigidRegistrationOptimizer/QmitkPowellOptimizerControls.ui
RigidRegistrationOptimizer/QmitkFRPROptimizerControls.ui
RigidRegistrationOptimizer/QmitkRegularStepGradientDescentOptimizerControls.ui
RigidRegistrationOptimizer/QmitkVersorTransformOptimizerControls.ui
RigidRegistrationOptimizer/QmitkAmoebaOptimizerControls.ui
RigidRegistrationOptimizer/QmitkConjugateGradientOptimizerControls.ui
RigidRegistrationOptimizer/QmitkLBFGSOptimizerControls.ui
RigidRegistrationOptimizer/QmitkSPSAOptimizerControls.ui
RigidRegistrationOptimizer/QmitkVersorRigid3DTransformOptimizerControls.ui
RigidRegistrationTransforms/QmitkTranslationTransformControls.ui
RigidRegistrationTransforms/QmitkScaleTransformControls.ui
RigidRegistrationTransforms/QmitkScaleLogarithmicTransformControls.ui
RigidRegistrationTransforms/QmitkAffineTransformControls.ui
RigidRegistrationTransforms/QmitkFixedCenterOfRotationAffineTransformControls.ui
- RigidRegistrationTransforms/QmitkRigid3DTransformControls.ui
+ #RigidRegistrationTransforms/QmitkRigid3DTransformControls.ui
RigidRegistrationTransforms/QmitkEuler3DTransformControls.ui
RigidRegistrationTransforms/QmitkCenteredEuler3DTransformControls.ui
RigidRegistrationTransforms/QmitkQuaternionRigidTransformControls.ui
RigidRegistrationTransforms/QmitkVersorTransformControls.ui
RigidRegistrationTransforms/QmitkVersorRigid3DTransformControls.ui
RigidRegistrationTransforms/QmitkScaleSkewVersor3DTransformControls.ui
RigidRegistrationTransforms/QmitkSimilarity3DTransformControls.ui
RigidRegistrationTransforms/QmitkRigid2DTransformControls.ui
RigidRegistrationTransforms/QmitkCenteredRigid2DTransformControls.ui
RigidRegistrationTransforms/QmitkEuler2DTransformControls.ui
RigidRegistrationTransforms/QmitkSimilarity2DTransformControls.ui
RigidRegistrationTransforms/QmitkCenteredSimilarity2DTransformControls.ui
)
\ No newline at end of file
diff --git a/Modules/SceneSerializationBase/BasePropertySerializer/mitkEnumerationSubclassesSerializer.cpp b/Modules/SceneSerializationBase/BasePropertySerializer/mitkEnumerationSubclassesSerializer.cpp
index e36daf2d06..f13a191638 100644
--- a/Modules/SceneSerializationBase/BasePropertySerializer/mitkEnumerationSubclassesSerializer.cpp
+++ b/Modules/SceneSerializationBase/BasePropertySerializer/mitkEnumerationSubclassesSerializer.cpp
@@ -1,78 +1,80 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkEnumerationSubclassesSerializer_h_included
#define mitkEnumerationSubclassesSerializer_h_included
#include "mitkEnumerationPropertySerializer.h"
#include "mitkPlaneOrientationProperty.h"
#include "mitkShaderProperty.h"
#include "mitkVtkInterpolationProperty.h"
#include "mitkVtkRepresentationProperty.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include "mitkVtkScalarModeProperty.h"
#include "mitkVtkVolumeRenderingProperty.h"
#include "mitkModalityProperty.h"
#include "mitkRenderingModeProperty.h"
+#include "mitkPointSetShapeProperty.h"
#define MITK_REGISTER_ENUM_SUB_SERIALIZER(classname) \
\
namespace mitk \
{ \
\
class SceneSerializationBase_EXPORT classname ## Serializer : public EnumerationPropertySerializer \
{ \
public: \
\
mitkClassMacro( classname ## Serializer, EnumerationPropertySerializer ); \
itkNewMacro(Self); \
\
virtual BaseProperty::Pointer Deserialize(TiXmlElement* element) \
{ \
if (!element) return NULL; \
const char* sa( element->Attribute("value") ); \
\
std::string s(sa?sa:""); \
classname::Pointer property = classname::New(); \
property->SetValue( s ); \
\
return property.GetPointer(); \
} \
\
protected: \
\
classname ## Serializer () {} \
virtual ~classname ## Serializer () {} \
}; \
\
} \
\
MITK_REGISTER_SERIALIZER( classname ## Serializer );
MITK_REGISTER_ENUM_SUB_SERIALIZER(PlaneOrientationProperty);
MITK_REGISTER_ENUM_SUB_SERIALIZER(ShaderProperty);
MITK_REGISTER_ENUM_SUB_SERIALIZER(VtkInterpolationProperty);
MITK_REGISTER_ENUM_SUB_SERIALIZER(VtkRepresentationProperty);
MITK_REGISTER_ENUM_SUB_SERIALIZER(VtkResliceInterpolationProperty);
MITK_REGISTER_ENUM_SUB_SERIALIZER(VtkScalarModeProperty);
MITK_REGISTER_ENUM_SUB_SERIALIZER(VtkVolumeRenderingProperty);
MITK_REGISTER_ENUM_SUB_SERIALIZER(ModalityProperty);
MITK_REGISTER_ENUM_SUB_SERIALIZER(RenderingModeProperty);
+MITK_REGISTER_ENUM_SUB_SERIALIZER(PointSetShapeProperty);
#endif
diff --git a/Modules/Segmentation/Algorithms/itkAdaptiveThresholdIterator.h b/Modules/Segmentation/Algorithms/itkAdaptiveThresholdIterator.h
index 90eca32555..524e4e703e 100644
--- a/Modules/Segmentation/Algorithms/itkAdaptiveThresholdIterator.h
+++ b/Modules/Segmentation/Algorithms/itkAdaptiveThresholdIterator.h
@@ -1,267 +1,267 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __itkAdaptiveThresholdIterator_h
#define __itkAdaptiveThresholdIterator_h
#include "itkIndex.h"
#include "itkSize.h"
#include "itkConditionalConstIterator.h"
#include "itkImage.h"
#include <vector>
#include <map>
#include <queue>
#include <utility>
namespace itk
{
/**
* \class AdaptiveThresholdIterator
* \brief Iterates over an image using a variable image function,
* which threshold can be varied during the iteration process.
*
* \ingroup ImageIterators
*
*/
template<class TImage, class TFunction>
class ITK_EXPORT AdaptiveThresholdIterator: public ConditionalConstIterator<TImage>
{
public:
/** Standard class typedefs. */
typedef AdaptiveThresholdIterator Self;
typedef ConditionalConstIterator<TImage> Superclass;
typedef TImage ImageType;
// A temporary image used for storing info about all indices
typedef TImage TTempImage;
typename TTempImage::Pointer tempPtr;
//[!] isn't really used?!
/** Type of function */
typedef TFunction FunctionType;
/** Type of vector used to store location info in the spatial function */
typedef typename TFunction::InputType FunctionInputType;
/** Size typedef support. */
typedef typename TImage::SizeType SizeType;
/** Region typedef support */
typedef typename TImage::RegionType RegionType;
typedef typename TImage::IndexType IndexType;
/** Internal Pixel Type */
typedef typename TImage::InternalPixelType InternalPixelType;
/** External Pixel Type */
typedef typename TImage::PixelType PixelType;
/** Queue containing indices representing a voxel position */
typedef std::queue<IndexType> IndexQueueType;
/** Map used to generate the output result */
typedef std::map<unsigned int, IndexQueueType> QueueMapType;
/** Dimension of the image the iterator walks. This constant is needed so
* that functions that are templated over image iterator type (as opposed to
* being templated over pixel type and dimension) can have compile time
* access to the dimension of the image that the iterator walks. */
itkStaticConstMacro(NDimensions, unsigned int, TImage::ImageDimension);
/** Constructor establishes an iterator to walk a particular image and a
* particular region of that image. This version of the constructor uses
* an explicit seed pixel for the flood fill, the "startIndex" */
AdaptiveThresholdIterator(ImageType *imagePtr,
FunctionType *fnPtr,
IndexType startIndex);
/** Constructor establishes an iterator to walk a particular image and a
* particular region of that image. This version of the constructor uses
* an explicit list of seed pixels for the flood fill, the "startIndex" */
AdaptiveThresholdIterator(ImageType *imagePtr,
FunctionType *fnPtr,
std::vector<IndexType> & startIndex);
/** Constructor establishes an iterator to walk a particular image and a
* particular region of that image. This version of the constructor
* should be used when the seed pixel is unknown */
AdaptiveThresholdIterator(ImageType *imagePtr,
FunctionType *fnPtr);
/** Default Destructor. */
virtual ~AdaptiveThresholdIterator() {};
/** Initializes the iterator, called from constructor */
void InitializeIterator();
//makes the iterator go one step further
void DoExtendedFloodStep();
//set-method for member-variable
void SetExpansionDirection(bool upwards);
//Init-method
void InitRegionGrowingState();
void SetMinTH(int min);
void SetMaxTH(int max);
int GetSeedPointValue(void);
/** switch between fine and raw leakage detection */
void SetFineDetectionMode(bool fine = false)
{m_FineDetectionMode = fine; m_DetectionStop = false;}
/** Get the index. This provides a read only reference to the index.
* This causes the index to be calculated from pointer arithmetic and is
* therefore an expensive operation.
* \sa SetIndex */
const IndexType GetIndex()
{ return (* m_QueueMap.find(m_RegionGrowingState)).second.front();}// [!] is never called?!
- const PixelType & Get(void) const
+ const PixelType Get(void) const
{ return const_cast<ImageType *>(this->m_Image.GetPointer())->GetPixel((* m_QueueMap.find(m_RegionGrowingState)).second.front() ); }
//[!] is never called?!
void Set( const PixelType & value)
{ const_cast<ImageType *>(this->m_Image.GetPointer())->GetPixel((* m_QueueMap.find(m_RegionGrowingState)).second.front() ) = value; }
void GoToBegin();
/** Is the iterator at the end of the region? */
bool IsAtEnd()
{ return this->m_IsAtEnd; };
/** Walk forward one index */
void operator++()
{ this->DoExtendedFloodStep(); }
virtual SmartPointer<FunctionType> GetFunction() const
{
return m_Function;
}
/** operator= is provided to make sure the handle to the image is properly
* reference counted. */
Self &operator=(const Self& it)
{
this->m_Image = it.m_Image; // copy the smart pointer
this->m_Region = it.m_Region;
return *this;
}
/** Compute whether the index of interest should be included in the flood */
bool IsPixelIncluded(const IndexType & index) const;
//Calculate the value the outputImage is initialized to
static int CalculateInitializeValue(int lower, int upper)
{
return ((upper - lower)+1)*(-1);
};
int GetLeakagePoint(void)
{return m_DetectedLeakagePoint;}
protected:
/*
* @brief Pointer on the output image to which the result shall be written
*/
SmartPointer<ImageType> m_OutputImage;
SmartPointer<FunctionType> m_Function;
/** A list of locations to start the recursive fill */
std::vector<IndexType> m_StartIndices;
/** The origin of the source image */
typename ImageType::PointType m_ImageOrigin;
/** The spacing of the source image */
typename ImageType::SpacingType m_ImageSpacing;
/** Region of the source image */
RegionType m_ImageRegion;
bool m_UpwardsExpansion;
int m_InitializeValue;
void ExpandThresholdUpwards();
void ExpandThresholdDownwards();
void IncrementRegionGrowingState();
//calculates how many steps the voxel is from the current step
int EstimateDistance(IndexType);
//calculates how many expansion steps will be taken
unsigned int CalculateMaxRGS();
private:
void InsertIndexTypeIntoQueueMap (unsigned int key, IndexType index);
int m_RegionGrowingState;
QueueMapType m_QueueMap;
int m_MinTH;
int m_MaxTH;
int m_SeedPointValue;
unsigned int m_VoxelCounter;
unsigned int m_LastVoxelNumber;
int m_DetectedLeakagePoint;
float m_CurrentLeakageRatio;
void CheckSeedPointValue();
/* flag for switching between raw leakage detection (bigger bronchial vessels)
* and fine leakage detection (smaller bronchial vessels [starting from leaves])
*/
bool m_FineDetectionMode;
bool m_DetectionStop;
};
}//end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkAdaptiveThresholdIterator.txx"
#endif
#endif
diff --git a/Modules/Segmentation/Algorithms/itkConnectedAdaptiveThresholdImageFilter.txx b/Modules/Segmentation/Algorithms/itkConnectedAdaptiveThresholdImageFilter.txx
index aa39364406..93880dadaf 100644
--- a/Modules/Segmentation/Algorithms/itkConnectedAdaptiveThresholdImageFilter.txx
+++ b/Modules/Segmentation/Algorithms/itkConnectedAdaptiveThresholdImageFilter.txx
@@ -1,303 +1,303 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _itkConnectedAdaptiveThresholdImageFilter_txx
#define _itkConnectedAdaptiveThresholdImageFilter_txx
#include "itkConnectedAdaptiveThresholdImageFilter.h"
#include "itkThresholdImageFilter.h"
#include "itkBinaryThresholdImageFunction.h"
#include "itkAdaptiveThresholdIterator.h"
#include "itkMinimumMaximumImageFilter.h"
namespace itk
{
/**
* Constructor
*/
template <class TInputImage, class TOutputImage>
ConnectedAdaptiveThresholdImageFilter<TInputImage, TOutputImage>
::ConnectedAdaptiveThresholdImageFilter()
: m_FineDetectionMode(false)
{
}
template <class TInputImage, class TOutputImage>
void ConnectedAdaptiveThresholdImageFilter<TInputImage,TOutputImage>::GenerateData()
{
typename ConnectedAdaptiveThresholdImageFilter::InputImageConstPointer inputImage = this->GetInput();
typename ConnectedAdaptiveThresholdImageFilter::OutputImagePointer outputImage = this->GetOutput();
typename Superclass::InputPixelObjectType::Pointer lowerThreshold=this->GetLowerInput();
typename Superclass::InputPixelObjectType::Pointer upperThreshold=this->GetUpperInput();
//kommt drauf, wie wir hier die Pipeline aufbauen
Superclass::m_Lower = lowerThreshold->Get();
Superclass::m_Upper = upperThreshold->Get();
typedef BinaryThresholdImageFunction<InputImageType> FunctionType;
typedef AdaptiveThresholdIterator<OutputImageType, FunctionType> IteratorType;
int initValue = IteratorType::CalculateInitializeValue((int)Superclass::m_Lower, (int)Superclass::m_Upper);
// Initialize the output according to the segmentation (fine or raw)
if(m_FineDetectionMode)
{
outputImage = this->m_OutoutImageMaskFineSegmentation;
}
typename ConnectedAdaptiveThresholdImageFilter::OutputImageRegionType region = outputImage->GetRequestedRegion();
outputImage->SetBufferedRegion( region );
outputImage->Allocate();
if(!m_FineDetectionMode)
{ // only initalize the output image if we are using the raw segmentation mode
outputImage->FillBuffer ((typename ConnectedAdaptiveThresholdImageFilter::OutputImagePixelType) initValue );
}
typename FunctionType::Pointer function = FunctionType::New();
function->SetInputImage ( inputImage );
//pass parameters needed for region growing to iterator
- IteratorType it ( outputImage, function, this->m_SeedList );
+ IteratorType it ( outputImage, function, this->m_Seeds );
it.SetFineDetectionMode(m_FineDetectionMode);
it.SetExpansionDirection(m_GrowingDirectionIsUpwards);
it.SetMinTH((int) Superclass::m_Lower);
it.SetMaxTH((int) Superclass::m_Upper);
it.GoToBegin();
this->m_SeedpointValue = it.GetSeedPointValue();
if (Superclass::m_Lower > this->m_SeedpointValue || this->m_SeedpointValue > Superclass::m_Upper)
{
//set m_SegmentationCancelled to true, so if it doesn't reach the point where it is set back to false
//we can asssume that there was an error
this->m_SegmentationCancelled = true;
return;
}
//iterate through image until
while( !it.IsAtEnd())
{
//make iterator go one step further (calls method DoFloodStep())
++it;
}
this->m_DetectedLeakagePoint = it.GetLeakagePoint();
this->m_SegmentationCancelled = false;
}
template <class TInputImage, class TOutputImage>
TOutputImage* itk::ConnectedAdaptiveThresholdImageFilter<TInputImage, TOutputImage>::GetResultImage()
{
return m_OutoutImageMaskFineSegmentation;
}
template <class TInputImage, class TOutputImage>
typename ConnectedAdaptiveThresholdImageFilter<TInputImage, TOutputImage>::IndexType
itk::ConnectedAdaptiveThresholdImageFilter<TInputImage, TOutputImage>::CorrectSeedPointPosition(unsigned int sizeOfVolume, int lowerTh, int upperTh)
{
typename ConnectedAdaptiveThresholdImageFilter::InputImageConstPointer inputImage = this->GetInput();
typedef typename TInputImage::IndexType IndexType;
IndexType itkIntelligentSeedIndex;
int seedPixelValue = inputImage->GetPixel(m_SeedPointIndex);
//set new seed index to the voxel with the darkest value and shortest distance to original seed
if ( seedPixelValue > upperTh || seedPixelValue < lowerTh)
{
//MITK_INFO << "seed pixel value [BEFORE] = " << seedPixelValue;
//ToDo crop region
itk::Index<3> workindex;
for(int i = 0; i < 3; i++)
{
workindex[i] = m_SeedPointIndex[i] - sizeOfVolume/2;
if(workindex[i]<0)
workindex[i]=0;
}
itk::Size<3> worksize;
for(int i = 0; i < 3; i++)
{
worksize[i] = sizeOfVolume;
}
itk::ImageRegion<3> workregion(workindex, worksize);
itk::ImageRegionIterator<TInputImage> regionIt(const_cast<TInputImage*>(inputImage.GetPointer()), workregion);
//int darkestGrayValue=seedPixelValue;
int currentGrayValue;
float distance = (float) (sizeOfVolume/2);
float relativeDistance = 1; // between 0 and 1
mitk::Vector3D seedVector,currentVector;
mitk::FillVector3D(seedVector,m_SeedPointIndex[0],m_SeedPointIndex[1],m_SeedPointIndex[2]);
currentVector = seedVector;
float costValue=0; //beware, Depending on seeking upper or lower value...
for(regionIt.GoToBegin(); !regionIt.IsAtEnd(); ++regionIt)
{
//get current gray value
currentGrayValue = regionIt.Value();
//get current seed index
m_SeedPointIndex = regionIt.GetIndex();
//fill current vector
mitk::FillVector3D(currentVector,m_SeedPointIndex[0],m_SeedPointIndex[1],m_SeedPointIndex[2]);
//calculate distance from original seed to new seed
mitk::Vector3D distVector = currentVector - seedVector;
distance = fabs(distVector.GetSquaredNorm());
relativeDistance = distance/(sizeOfVolume/2);
//calculate "cost function"
float currentCostValue = (1-relativeDistance)* currentGrayValue;
if (currentCostValue < costValue && currentGrayValue < upperTh)
{
itkIntelligentSeedIndex = regionIt.GetIndex();
costValue = currentCostValue;
//MITK_INFO <<"cost value="<< costValue;
//MITK_INFO <<"darkest and closest Voxel ="<< currentGrayValue;
//MITK_INFO <<"m_UPPER="<< upperTh;
}
}
//MITK_INFO<< "seed pixel value [AFTER] =" << inputImage->GetPixel(itkIntelligentSeedIndex) <<"\n";
}
else
{ // no correction of the seed point is needed, just pass the original seed
itkIntelligentSeedIndex = m_SeedPointIndex;
}
return itkIntelligentSeedIndex;
}
template <class TInputImage, class TOutputImage>
void itk::ConnectedAdaptiveThresholdImageFilter<TInputImage, TOutputImage>::CropMask(unsigned int croppingSize)
{
//initialize center point of the working region
itk::Index<3> workindex;
for(int i = 0; i < 3; i++)
{
workindex[i] = m_SeedPointIndex[i] - croppingSize/2;
if(workindex[i]<0)
workindex[i]=0;
}
// initialize working volume
itk::Size<3> worksize;
for(int i = 0; i < 3; i++)
{
worksize[i] = croppingSize;
}
// set working region
itk::ImageRegion<3> workregion(workindex, worksize);
//check if the entire region is inside the image
if(!(m_OutoutImageMaskFineSegmentation->GetLargestPossibleRegion().IsInside(workregion)))
{
// if not then crop to the intersection of the image (gemeinsame Schnittmenge Bild und workingRegion)
if(!(workregion.Crop(m_OutoutImageMaskFineSegmentation->GetLargestPossibleRegion())))
{
MITK_ERROR<< "Cropping working region failed!";
return;
}
}
// initialize region iterator
itk::ImageRegionIterator<TOutputImage> regionIt(m_OutoutImageMaskFineSegmentation, workregion);
for(regionIt.GoToBegin(); !regionIt.IsAtEnd(); ++regionIt)
{
//and set all voxel inside the working region to zero
regionIt.Set(0);
}
}
template <class TInputImage, class TOutputImage>
unsigned int itk::ConnectedAdaptiveThresholdImageFilter<TInputImage, TOutputImage>::AdjustIteratorMask()
{
typedef itk::ThresholdImageFilter<TOutputImage> ThresholdFilterType;
typedef itk::MinimumMaximumImageFilter<TOutputImage> MaxFilterType;
typename ThresholdFilterType::Pointer thresholdFilter = ThresholdFilterType::New();
typename MaxFilterType::Pointer maxFilter = MaxFilterType::New();
unsigned int maxValue;
if(!m_DiscardLastPreview)
{
//get the biggest value of the image
maxFilter->SetInput(m_OutoutImageMaskFineSegmentation);
maxFilter->UpdateLargestPossibleRegion();
maxValue = maxFilter->GetMaximum();
}
else
{ // use the last biggest value in the preview. This was set in SetParameterForFineSegmentation(...adjLowerTh...) []
maxValue = m_AdjLowerTh;
}
//set all values <lower && >upper to zero (thresouldOutside uses < and > NOT <= and >=)
thresholdFilter->SetInput(m_OutoutImageMaskFineSegmentation);
thresholdFilter->SetOutsideValue(0);
thresholdFilter->ThresholdOutside(m_AdjLowerTh, maxValue );
thresholdFilter->UpdateLargestPossibleRegion();
//set all values in between lower and upper (>=lower && <=upper) to the highest value in the image
thresholdFilter->SetInput(thresholdFilter->GetOutput());
thresholdFilter->SetOutsideValue(maxValue);
thresholdFilter->ThresholdOutside(0, m_AdjLowerTh-1);
thresholdFilter->UpdateLargestPossibleRegion();
m_OutoutImageMaskFineSegmentation = thresholdFilter->GetOutput();
return maxValue;
}
template <class TInputImage, class TOutputImage>
void itk::ConnectedAdaptiveThresholdImageFilter<TInputImage, TOutputImage>::SetParameterForFineSegmentation( TOutputImage * iteratorMaskForFineSegmentation ,unsigned int adjLowerTh, unsigned int adjUpperTh, itk::Index<3> seedPoint, bool discardLeafSegmentation)
{
//just to make sure we´re in the right mode and the mask exsits
if(m_FineDetectionMode && iteratorMaskForFineSegmentation)
{
m_OutoutImageMaskFineSegmentation = iteratorMaskForFineSegmentation;
m_AdjLowerTh = adjLowerTh;
m_AdjUpperTh = adjUpperTh; //still needed?
m_SeedPointIndex = seedPoint;
m_DiscardLastPreview = discardLeafSegmentation;
}
else
{
if(!m_FineDetectionMode)
{
MITK_ERROR<< "Fine-detection-segmentation mode not set!";
}
else
{
MITK_ERROR<< "Iterator-mask-image not set!";
}
}
}
}//end namespace itk
#endif
diff --git a/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.h b/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.h
index 1c14b4232a..8a80a44316 100644
--- a/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.h
+++ b/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.h
@@ -1,295 +1,295 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkContourExtractor2DImageFilter_h
#define __itkContourExtractor2DImageFilter_h
#include "itkImageToPathFilter.h"
#include "itkNumericTraits.h"
#include "itkPolyLineParametricPath.h"
#include "itkConceptChecking.h"
-#include "itk_hash_map.h"
+#include <itksys/hash_map.hxx>
#include "vcl_deque.h"
#include "vcl_list.h"
namespace itk
{
/** \class ContourExtractor2DImageFilter
* \brief Computes a list of PolyLineParametricPath objects from the contours in
* a 2D image.
*
* Uses the "marching squares" method to compute a the iso-valued contours of
* the input 2D image for a given intensity value. Multiple outputs may be
* produced because an image can have multiple contours at a given level, so it
* is advised to call GetNumberOfOutputs() and GetOutput(n) to retrieve all of
* the contours. The contour value to be extracted can be set with
* SetContourValue(). Image intensities will be linearly interpolated to provide
* sub-pixel resolution for the output contours.
*
* The marching squares algorithm is a special case of the marching cubes
* algorithm (Lorensen, William and Harvey E. Cline. Marching Cubes: A High
* Resolution 3D Surface Construction Algorithm. Computer Graphics (SIGGRAPH 87
* Proceedings) 21(4) July 1987, p. 163-170). A simple explanation is available
* here: http://www.essi.fr/~lingrand/MarchingCubes/algo.html
*
* There is a single ambiguous case in the marching squares algorithm: if a
* given 2x2-pixel square has two high-valued and two low-valued pixels, each
* pair diagonally adjacent. (Where high- and low-valued is with respect to the
* contour value sought.) In this case, either the high-valued pixels can be
* connected into the same "object" (where groups of pixels encircled by a given
* contour are considered an object), or the low-valued pixels can be connected.
* This is the "face connected" versus "face + vertex connected" (or 4- versus
* 4-connected) distinction: high-valued pixels most be treated as one, and
* low-valued as the other. By default, high-valued pixels are treated as
* "face-connected" and low-valued pixels are treated as "face + vertex"
* connected. To reverse this, call VertexConnectHighPixelsOn();
*
* Outputs are not guaranteed to be closed paths: contours which intersect the
* image edge will be left open. All other paths will be closed. (The
* closed-ness of a path can be tested by checking whether the beginning point
* is the same as the end point.)
*
* Produced paths are oriented. Following the path from beginning to end, image
* intensity values lower than the contour value are to the left of the path and
* intensity values grater than the contour value are to the right. In other
* words, the image gradient at a path segment is (approximately) in the direct
* of that segment rotated right by 90 degrees, because the image intensity
* values increase from left-to-right across the segment. This means that the
* generated contours will circle clockwise around "hills" of
* above-contour-value intensity, and counter-clockwise around "depressions" of
* below-contour-value intensity. This convention can be reversed by calling
* ReverseContourOrientationOn().
*
* By default the input image's largest possible region will be processed; call
* SetRequestedRegion() to process a different region, or ClearRequestedRegion()
* to revert to the default value. Note that the requested regions are usually
* set on the output; however since paths have no notion of a "region", this
* must be set at the filter level.
*
* This class was contributed to the Insight Journal by Zachary Pincus.
* http://insight-journal.org/midas/handle.php?handle=1926/165
*
* \sa Image
* \sa Path
* \sa PolyLineParametricPath
*
*/
template <class TInputImage>
class ITK_EXPORT ContourExtractor2DImageFilter :
public ImageToPathFilter< TInputImage, PolyLineParametricPath<2> >
{
public:
/** Extract dimension from input and output image. */
itkStaticConstMacro(InputImageDimension, unsigned int,
TInputImage::ImageDimension);
/** Convenient typedefs for simplifying declarations. */
typedef TInputImage InputImageType;
typedef PolyLineParametricPath<2> OutputPathType;
/** Standard class typedefs. */
typedef ContourExtractor2DImageFilter Self;
typedef ImageToPathFilter<InputImageType, OutputPathType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(ContourExtractor2DImageFilter, ImageToPathFilter);
/** Image and path typedef support. */
typedef typename InputImageType::Pointer InputImagePointer;
typedef typename InputImageType::PixelType InputPixelType;
typedef typename InputImageType::IndexType InputIndexType;
typedef typename InputImageType::OffsetType InputOffsetType;
typedef typename InputImageType::RegionType InputRegionType;
typedef typename OutputPathType::Pointer OutputPathPointer;
typedef typename OutputPathType::VertexType VertexType;
typedef typename OutputPathType::VertexListType VertexListType;
/** Real type associated to the input pixel type. */
typedef typename NumericTraits<InputPixelType>::RealType InputRealType;
typedef typename VertexListType::ConstPointer
VertexListConstPointer;
/** Control the orientation of the contours with reference to the image
* gradient. (See class documentation.) */
itkSetMacro(ReverseContourOrientation, bool);
itkGetConstReferenceMacro(ReverseContourOrientation, bool);
itkBooleanMacro(ReverseContourOrientation);
/** Control whether high- or low-valued pixels are vertex-connected.
* Default is for low-valued pixels to be vertex-connected.
* (See class documentation.) */
itkSetMacro(VertexConnectHighPixels, bool);
itkGetConstReferenceMacro(VertexConnectHighPixels, bool);
itkBooleanMacro(VertexConnectHighPixels);
/** Control whether the largest possible input region is used, or if a
* custom requested region is to be used. */
void SetRequestedRegion(const InputRegionType region);
itkGetConstReferenceMacro(RequestedRegion, InputRegionType);
void ClearRequestedRegion();
/** Set/Get the image intensity value that the contours should follow.
* This is the equivalent of an iso-value in Marching Squares. */
itkSetMacro(ContourValue,InputRealType);
itkGetConstReferenceMacro(ContourValue, InputRealType);
#ifdef ITK_USE_CONCEPT_CHECKING
/** Begin concept checking */
itkConceptMacro(DimensionShouldBe2,
(Concept::SameDimension<itkGetStaticConstMacro(InputImageDimension),2>));
itkConceptMacro(InputPixelTypeComparable,
(Concept::Comparable<InputPixelType>));
itkConceptMacro(InputHasPixelTraitsCheck,
(Concept::HasPixelTraits<InputPixelType>));
itkConceptMacro(InputHasNumericTraitsCheck,
(Concept::HasNumericTraits<InputPixelType>));
/** End concept checking */
#endif
protected:
ContourExtractor2DImageFilter();
virtual ~ContourExtractor2DImageFilter();
void PrintSelf(std::ostream& os, Indent indent) const;
void GenerateData();
/** ContourExtractor2DImageFilter manually controls the input requested
* region via SetRequestedRegion and ClearRequestedRegion, so it must
* override the superclass method. */
virtual void GenerateInputRequestedRegion()
throw(InvalidRequestedRegionError);
private:
VertexType InterpolateContourPosition(InputPixelType fromValue,
InputPixelType toValue,
InputIndexType fromIndex,
InputOffsetType toOffset);
void AddSegment(const VertexType from, const VertexType to);
void FillOutputs();
ContourExtractor2DImageFilter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
InputRealType m_ContourValue;
bool m_ReverseContourOrientation;
bool m_VertexConnectHighPixels;
bool m_UseCustomRegion;
InputRegionType m_RequestedRegion;
unsigned int m_NumberOfContoursCreated;
// Represent each contour as deque of vertices to facilitate addition of
// nodes at beginning or end. At the end of the processing, we will copy
// the contour into a PolyLineParametricPath.
// We subclass the deque to store an additional bit of information: an
// identification number for each growing contour. We use this number so
// that when it becomes necessary to merge two growing contours, we can
// merge the newer one into the older one. This helps because then we can
// guarantee that the output contour list is ordered from left to right,
// top to bottom (in terms of the first pixel of the contour encountered
// by the marching squares). Currently we make no guarantees that this
// pixel is the first pixel in the contour list, just that the contours
// are so ordered in the output. Ensuring this latter condition (first
// pixel traversed = first pixel in contour) would be possible by either
// changing the merging rules, which would make the contouring operation
//slower, or by storing additional data as to which pixel was first.
class ContourType : public vcl_deque<VertexType>
{
public:
unsigned int m_ContourNumber;
};
// Store all the growing contours in a list. We may need to delete contours
// from anywhere in the sequence (when we merge them together), so we need to
// use a list instead of a vector or similar.
typedef vcl_list<ContourType> ContourContainer;
typedef typename ContourContainer::iterator ContourRef;
// declare the hash function we are using for the hash_map.
struct VertexHash
{
typedef typename VertexType::CoordRepType CoordinateType;
inline size_t operator()(const VertexType& k) const
{
// Xor the hashes of the vertices together, after multiplying the
// first by some number, so that identical (x,y) vertex indices
// don't all hash to the same bucket. This is a decent if not
// optimal hash.
const size_t hashVertex1 = this->float_hash(k[0] * 0xbeef);
const size_t hashVertex2 = this->float_hash(k[1]);
const size_t hashValue = hashVertex1 ^ hashVertex2;
return hashValue;
}
// Define hash function for floats. Based on method from
// http://www.brpreiss.com/books/opus4/html/page217.html
inline size_t float_hash(const CoordinateType &k) const
{
if (k == 0)
{
return 0;
}
int exponent;
CoordinateType mantissa = vcl_frexp(k, &exponent);
size_t value = static_cast<size_t>(vcl_fabs(mantissa));
value = ( 2 * value - 1 ) * ~0U;
return value;
}
};
// We use a hash to associate the endpoints of each contour with the
// contour itself. This makes it easy to look up which contour we should add
// a new arc to.
// We can't store the contours themselves in the hashtable because we
// need to have two tables (one to hash from beginpoint -> contour and one
// for endpoint -> contour), and sometimes will remove a contour from the
// tables (if it has been closed or merged with another contour). So in the
// hash table we store a reference to the contour. Because sometimes we will
// need to merge contours, we need to be able to quickly remove contours
// from our list when they have been merged into another. Thus, we store
// an iterator pointing to the contour in the list.
- typedef hash_map<VertexType, ContourRef, VertexHash> VertexToContourMap;
+ typedef itksys::hash_map<VertexType, ContourRef, VertexHash> VertexToContourMap;
typedef typename VertexToContourMap::iterator VertexMapIterator;
typedef typename VertexToContourMap::value_type VertexContourRefPair;
// The contours we find in the image are stored here
ContourContainer m_Contours;
// And indexed by their beginning and ending points here
VertexToContourMap m_ContourStarts;
VertexToContourMap m_ContourEnds;
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkContourExtractor2DImageFilter.txx"
#endif
#endif
diff --git a/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.txx b/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.txx
index 48b1116021..2ba6926287 100644
--- a/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.txx
+++ b/Modules/Segmentation/Algorithms/itkContourExtractor2DImageFilter.txx
@@ -1,563 +1,563 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkContourExtractor2DImageFilter_txx
#define __itkContourExtractor2DImageFilter_txx
#include "itkConstShapedNeighborhoodIterator.h"
#include "itkProgressReporter.h"
#include "itkConstShapedNeighborhoodIterator.h"
#include "vcl_cmath.h"
#include "itkContourExtractor2DImageFilter.h"
namespace itk
{
// Constructor
template< class TInputImage>
ContourExtractor2DImageFilter< TInputImage>
::ContourExtractor2DImageFilter()
{
this->m_ContourValue = NumericTraits<InputRealType>::Zero;
this->m_ReverseContourOrientation = false;
this->m_VertexConnectHighPixels = false;
this->m_UseCustomRegion = false;
this->m_NumberOfContoursCreated = 0;
}
// Destructor
template< class TInputImage>
ContourExtractor2DImageFilter< TInputImage>
::~ContourExtractor2DImageFilter()
{
}
template< class TInputImage>
void
ContourExtractor2DImageFilter< TInputImage>
::GenerateData()
{
// Make sure the structures for containing, looking up, and numbering the
// growing contours are empty and ready.
m_Contours.clear();
m_ContourStarts.clear();
m_ContourEnds.clear();
m_NumberOfContoursCreated = 0;
// Set up an iterator to "march the squares" across the image.
// We associate each 2px-by-2px square with the pixel in the upper left of
// that square. We then iterate across the image, examining these 2x2 squares
// and building the contour. By iterating the upper-left pixel of our
// "current square" across every pixel in the image except those on the
// bottom row and rightmost column, we have visited every valid square in the
// image.
InputRegionType region = this->GetInput()->GetRequestedRegion();
typename InputRegionType::SizeType shrunkSize = region.GetSize();
shrunkSize[0] -= 1;
shrunkSize[1] -= 1;
InputRegionType shrunkRegion(region.GetIndex(), shrunkSize);
// Set up a progress reporter
ProgressReporter progress(this, 0, shrunkRegion.GetNumberOfPixels());
// A 1-pixel radius sets up a neighborhood with the following indices:
// 0 1 2
// 3 4 5
// 6 7 8
// We are interested only in the square of 4,5,7,8 which is the 2x2 square
// with the center pixel at the top-left. So we only activate the
// coresponding offsets, and only query pixels 4, 5, 7, and 8 with the
// iterator's GetPixel method.
typedef ConstShapedNeighborhoodIterator<InputImageType> SquareIterator;
typename SquareIterator::RadiusType radius = {{1,1}};
SquareIterator it(radius, this->GetInput(), shrunkRegion);
InputOffsetType none = {{0,0}};
InputOffsetType right = {{1,0}};
InputOffsetType down = {{0,1}};
InputOffsetType diag = {{1,1}};
it.ActivateOffset(none);
it.ActivateOffset(right);
it.ActivateOffset(down);
it.ActivateOffset(diag);
for(it.GoToBegin(); !it.IsAtEnd(); ++it)
{
// There are sixteen different possible square types, diagramed below.
// A + indicates that the vertex is above the contour value, and a -
// indicates that the vertex is below or equal to the contour value.
// The vertices of each square are here numbered:
// 01
// 23
// and treated as a binary value with the bits in that order. Thus each
// square can be so numbered:
// 0-- 1+- 2-+ 3++ 4-- 5+- 6-+ 7++
// -- -- -- -- +- +- +- +-
//
// 8-- 9+- 10-+ 11++ 12-- 13+- 14-+ 15++
// -+ -+ -+ -+ ++ ++ ++ ++
//
// The position of the line segment that cuts through (or doesn't, in case
// 0 and 15) each square is clear, except in cases 6 and 9. In this case,
// where the segments are placed is determined by
// m_VertexConnectHighPixels. If m_VertexConnectHighPixels is false, then
// lines like are drawn through square 6, and lines like are drawn through
// square 9. Otherwise, the situation is reversed.
// Finally, recall that we draw the lines so that (moving from tail to
// head) the lower-valued pixels are on the left of the line. So, for
// example, case 1 entails a line slanting from the middle of the top of
// the square to the middle of the left side of the square.
// (1) Determine what number square we are currently inspecting. Remember
// that as far as the neighborhood iterator is concerned, our square
// 01 is numbered as 45
// 23 78
InputPixelType v0, v1, v2, v3;
v0 = it.GetPixel(4);
v1 = it.GetPixel(5);
v2 = it.GetPixel(7);
v3 = it.GetPixel(8);
InputIndexType index = it.GetIndex();
unsigned char squareCase = 0;
if (v0 > m_ContourValue) squareCase += 1;
if (v1 > m_ContourValue) squareCase += 2;
if (v2 > m_ContourValue) squareCase += 4;
if (v3 > m_ContourValue) squareCase += 8;
// Set up macros to find the ContinuousIndex where the contour intersects
// one of the sides of the square. Normally macros should, of course, be
// eschewed, but since this is an inner loop not calling the function four
// times when two would do is probably worth while. Plus, copy-pasting
// these into the switch below is even worse. InterpolateContourPosition
// takes the values at two vertices, the index of the first vertex, and the
// offset between the two vertices.
#define TOP_ this->InterpolateContourPosition(v0,v1,index,right)
#define BOTTOM_ this->InterpolateContourPosition(v2,v3,index + down,right)
#define LEFT_ this->InterpolateContourPosition(v0,v2,index, down)
#define RIGHT_ this->InterpolateContourPosition(v1,v3,index + right,down)
// (2) Add line segments to the growing contours as defined by the cases.
// AddSegment takes a "from" vertex and a "to" vertex, and adds it to the
// a growing contour, creates a new contour, or merges two together.
switch(squareCase)
{
case 0: // no line
break;
case 1: // top to left
this->AddSegment(TOP_, LEFT_);
break;
case 2: // right to top
this->AddSegment(RIGHT_, TOP_);
break;
case 3: // right to left
this->AddSegment(RIGHT_, LEFT_);
break;
case 4: // left to bottom
this->AddSegment(LEFT_, BOTTOM_);
break;
case 5: // top to bottom
this->AddSegment(TOP_, BOTTOM_);
break;
case 6:
if (m_VertexConnectHighPixels)
{
// left to top
this->AddSegment(LEFT_, TOP_);
// right to bottom
this->AddSegment(RIGHT_, BOTTOM_);
}
else
{
// right to top
this->AddSegment(RIGHT_, TOP_);
// left to bottom
this->AddSegment(LEFT_, BOTTOM_);
}
break;
case 7: // right to bottom
this->AddSegment(RIGHT_, BOTTOM_);
break;
case 8: // bottom to right
this->AddSegment(BOTTOM_, RIGHT_);
break;
case 9:
if (m_VertexConnectHighPixels)
{
// top to right
this->AddSegment(TOP_, RIGHT_);
// bottom to left
this->AddSegment(BOTTOM_, LEFT_);
}
else
{
// top to left
this->AddSegment(TOP_, LEFT_);
// bottom to right
this->AddSegment(BOTTOM_, RIGHT_);
}
break;
case 10: // bottom to top
this->AddSegment(BOTTOM_, TOP_);
break;
case 11: // bottom to left
this->AddSegment(BOTTOM_, LEFT_);
break;
case 12: // left to right
this->AddSegment(LEFT_, RIGHT_);
break;
case 13: // top to right
this->AddSegment(TOP_, RIGHT_);
break;
case 14: // left to top
this->AddSegment(LEFT_, TOP_);
break;
case 15: // no line
break;
} // switch squareCase
progress.CompletedPixel();
} // iteration
// Now create the outputs paths from the deques we've been using.
this->FillOutputs();
m_Contours.clear();
m_ContourStarts.clear();
m_ContourEnds.clear();
m_NumberOfContoursCreated = 0;
}
template <class TInputImage>
inline
typename ContourExtractor2DImageFilter<TInputImage>::VertexType
ContourExtractor2DImageFilter<TInputImage>
::InterpolateContourPosition(InputPixelType fromValue, InputPixelType toValue,
InputIndexType fromIndex, InputOffsetType toOffset)
{
VertexType output;
// Now calculate the fraction of the way from 'from' to 'to' that the contour
// crosses. Interpolate linearly: y = v0 + (v1 - v0) * x, and solve for the
// x that gives y = m_ContourValue: x = (m_ContourValue - v0) / (v1 - v0).
// This assumes that v0 and v1 are separated by exactly ONE unit. So the to
// Offset. value must have exactly one component 1 and the other component 0.
// Also this assumes that fromValue and toValue are different. Otherwise we
// can't interpolate anything!
itkAssertOrThrowMacro( (fromValue != toValue), "source and destination are the same" );
itkAssertOrThrowMacro(
( (toOffset[0] == 0 && toOffset[1] == 1) || (toOffset[0] == 1 && toOffset[1] == 0) ),
"toOffset has unexpected values");
double x = (m_ContourValue - static_cast<InputRealType>(fromValue)) /
(toValue - static_cast<InputRealType>(fromValue));
output[0] = fromIndex[0] + x * toOffset[0];
output[1] = fromIndex[1] + x * toOffset[1];
return output;
}
template <class TInputImage>
void
ContourExtractor2DImageFilter<TInputImage>
::AddSegment(VertexType from, VertexType to)
{
if (from == to)
{
// Arc is degenerate: ignore, and the from/two point will be connected
// later by other squares. Degeneracy happens when (and only when) a square
// has exactly one vertex that is the contour value, and the rest are above
// that value.
return;
}
// Try to find an existing contour that starts where the new segment ends.
VertexMapIterator newTail = m_ContourStarts.find(to);
// Try to find an existing contour that ends where the new segment starts.
VertexMapIterator newHead = m_ContourEnds.find(from);
if (newTail != m_ContourStarts.end() && newHead != m_ContourEnds.end())
{
// We need to connect these two contours. The act of connecting them will
// add the needed arc.
ContourRef tail = newTail->second;
itkAssertOrThrowMacro( (tail->front() == to), "End doesn't match Beginning" );
ContourRef head = newHead->second;
itkAssertOrThrowMacro( (head->back() == from), "Beginning doesn't match End");
if (head == tail)
{
// We've closed a contour. Add the end point, and remove from the maps
head->push_back(to);
m_ContourStarts.erase(newTail);
// erase the front of tail. Because head and tail are the same contour,
// don't worry about erasing the front of head!
m_ContourEnds.erase(newHead); // erase the end of head/tail.
}
else
{
// We have found two distinct contours that need to be joined. Careful
// here: we want to keep the first segment in the list when merging so
// that contours are always returned in top-to-bottom, right-to-left
// order (with regard to the image pixel found to be inside the contour).
if (tail->m_ContourNumber > head->m_ContourNumber)
{
// if tail was created later than head...
// Copy tail to the end of head and remove
// tail from everything.
head->insert(head->end(), tail->begin(), tail->end());
// Now remove 'tail' from the list and the maps because it has been
// subsumed.
m_ContourStarts.erase(newTail);
int erased = m_ContourEnds.erase(tail->back());
// There should be exactly one entry in the hash for that endpoint
if (erased != 1)
{
itkWarningMacro (<< "There should be exactly one entry in the hash for that endpoint, but there are " << erased);
}
m_Contours.erase(tail); // remove from the master list
// Now remove the old end of 'head' from the ends map and add
// the new end.
m_ContourEnds.erase(newHead);
m_ContourEnds.insert(VertexContourRefPair(head->back(), head));
}
else
{
// Copy head to the beginning of tail and remove
// head from everything.
tail->insert(tail->begin(), head->begin(), head->end());
// Now remove 'head' from the list and the maps because
// it has been subsumed.
m_ContourEnds.erase(newHead);
int erased = m_ContourStarts.erase(head->front());
if (erased != 1)
{
itkWarningMacro (<< "There should be exactly one entry in the hash for that endpoint, but there are " << erased);
}
m_Contours.erase(head); // remove from the master list
// Now remove the old start of 'tail' from the starts map and
// add the new start.
m_ContourStarts.erase(newTail);
m_ContourStarts.insert(VertexContourRefPair(tail->front(), tail));
}
}
}
else if (newTail == m_ContourStarts.end() && newHead == m_ContourEnds.end())
{
// No contours found: add a new one.
// Make it on the heap. It will be copied into m_Contours.
ContourType contour;
// Add the endpoints
contour.push_front(from);
contour.push_back(to);
contour.m_ContourNumber = m_NumberOfContoursCreated++;
// Add the contour to the end of the list and get a reference to it.
m_Contours.push_back(contour);
// recall that end() is an iterator to one past the back!
ContourRef newContour = --m_Contours.end();
// add the endpoints and an iterator pointing to the contour
// in the list to the maps.
m_ContourStarts.insert(VertexContourRefPair(from, newContour));
m_ContourEnds.insert(VertexContourRefPair(to, newContour));
}
else if (newTail != m_ContourStarts.end() && newHead == m_ContourEnds.end())
{
// Found a single contour to which the new arc should be prepended.
ContourRef tail = newTail->second;
itkAssertOrThrowMacro( (tail->front() == to), "End doesn't match Beginning" );
tail->push_front(from);
// erase the old start of this contour
m_ContourStarts.erase(newTail);
// Now add the new start of this contour.
m_ContourStarts.insert(VertexContourRefPair(from, tail));
}
else if (newTail == m_ContourStarts.end() && newHead != m_ContourEnds.end())
{
// Found a single contour to which the new arc should be appended.
ContourRef head = newHead->second;
itkAssertOrThrowMacro( (head->back() == from), "Beginning doesn't match End");
head->push_back(to);
// erase the old end of this contour
m_ContourEnds.erase(newHead);
// Now add the new start of this contour.
m_ContourEnds.insert(VertexContourRefPair(to, head));
}
}
template <class TInputImage>
void
ContourExtractor2DImageFilter<TInputImage>
::FillOutputs()
{
- this->SetNumberOfOutputs(m_Contours.size());
+ this->SetNumberOfIndexedOutputs(m_Contours.size());
int i = 0;
for(ContourRef it = m_Contours.begin(); it != m_Contours.end(); it++, i++)
{
OutputPathPointer output = this->GetOutput(i);
if (output.IsNull())
{
// Static cast is OK because we know PathSource will make its templated
// class type
output = static_cast<OutputPathType*>(this->MakeOutput(i).GetPointer());
this->SetNthOutput( i, output.GetPointer() );
}
typename VertexListType::Pointer path =
const_cast<VertexListType*>(output->GetVertexList());
path->Initialize();
path->reserve(it->size()); // use std::vector version of 'reserve()'
//instead of VectorContainer::Reserve() to work around
// the fact that the latter is essentially std::vector::resize(),
// which is not what we want.
// Now put all the points from the contour deque into the path and
// mark output as modified
typedef typename ContourType::const_iterator ConstIteratorType;
if (m_ReverseContourOrientation)
{
ConstIteratorType itC = (*it).end();
do
{
itC--;
path->push_back(*itC);
}
while(itC != (*it).begin());
}
else
{
ConstIteratorType itC = (*it).begin();
while(itC != (*it).end())
{
path->push_back(*itC);
itC++;
}
}
output->Modified();
}
}
template <class TInputImage>
void
ContourExtractor2DImageFilter<TInputImage>
::SetRequestedRegion(const InputRegionType region)
{
itkDebugMacro("setting RequestedRegion to " << region);
m_UseCustomRegion = true;
if (this->m_RequestedRegion != region)
{
this->m_RequestedRegion = region;
this->Modified();
}
}
template <class TInputImage>
void
ContourExtractor2DImageFilter<TInputImage>
::ClearRequestedRegion()
{
itkDebugMacro("Clearing RequestedRegion.");
if (this->m_UseCustomRegion == true)
{
this->m_UseCustomRegion = false;
this->Modified();
}
}
template <class TInputImage>
void
ContourExtractor2DImageFilter<TInputImage>
::GenerateInputRequestedRegion() throw (InvalidRequestedRegionError)
{
InputImageType *input = const_cast<InputImageType*>(this->GetInput());
if (!input) return;
if ( m_UseCustomRegion )
{
InputRegionType requestedRegion = m_RequestedRegion;
if ( requestedRegion.Crop(input->GetLargestPossibleRegion()) )
{
input->SetRequestedRegion( requestedRegion );
return;
}
else
{
// Couldn't crop the region (requested region is outside the largest
// possible region). Throw an exception.
// store what we tried to request (prior to trying to crop)
input->SetRequestedRegion( requestedRegion );
// build an exception
InvalidRequestedRegionError e(__FILE__, __LINE__);
e.SetLocation(ITK_LOCATION);
e.SetDescription(
"Requested region is outside the largest possible region.");
e.SetDataObject(input);
throw e;
}
}
else
{
input->SetRequestedRegion(input->GetLargestPossibleRegion());
}
}
/**
* Standard "PrintSelf" method
*/
template <class TInputImage>
void
ContourExtractor2DImageFilter<TInputImage>
::PrintSelf(std::ostream& os, Indent indent) const
{
Superclass::PrintSelf( os, indent );
os << indent << "ReverseContourOrientation: " << m_ReverseContourOrientation
<< std::endl;
os << indent << "VertexConnectHighPixels: " << m_VertexConnectHighPixels
<< std::endl;
os << indent << "UseCustomRegion: " << m_UseCustomRegion << std::endl;
os << indent << "NumericTraits: " << m_UseCustomRegion << std::endl;
os << indent << "NumberOfContoursCreated: " << m_NumberOfContoursCreated
<< std::endl;
if (m_UseCustomRegion)
{
os << indent << "Custom region: " << m_RequestedRegion << std::endl;
}
typedef typename NumericTraits<InputRealType>::PrintType InputRealPrintType;
os << indent << "Contour value: "
<< static_cast<InputRealPrintType> (m_ContourValue)
<< std::endl;
}
} // end namespace itk
#endif
diff --git a/Modules/Segmentation/Algorithms/mitkComputeContourSetNormalsFilter.cpp b/Modules/Segmentation/Algorithms/mitkComputeContourSetNormalsFilter.cpp
index 979741685d..9fdcd9f9af 100644
--- a/Modules/Segmentation/Algorithms/mitkComputeContourSetNormalsFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkComputeContourSetNormalsFilter.cpp
@@ -1,305 +1,311 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkComputeContourSetNormalsFilter.h"
mitk::ComputeContourSetNormalsFilter::ComputeContourSetNormalsFilter()
{
- m_MaxSpacing = 5;
- this->m_UseProgressBar = false;
- this->m_ProgressStepSize = 1;
+ m_MaxSpacing = 5;
+ this->m_UseProgressBar = false;
+ this->m_ProgressStepSize = 1;
+
+ mitk::Surface::Pointer output = mitk::Surface::New();
+ this->SetNthOutput(0, output.GetPointer());
}
mitk::ComputeContourSetNormalsFilter::~ComputeContourSetNormalsFilter()
{
}
void mitk::ComputeContourSetNormalsFilter::GenerateData()
{
- unsigned int numberOfInputs = this->GetNumberOfInputs();
+ unsigned int numberOfInputs = this->GetNumberOfIndexedInputs();
this->CreateOutputsForAllInputs(numberOfInputs);
//Iterating over each input
for(unsigned int i = 0; i < numberOfInputs; i++)
{
//Getting the inputs polydata and polygons
Surface* currentSurface = const_cast<Surface*>( this->GetInput(i) );
vtkPolyData* polyData = currentSurface->GetVtkPolyData();
vtkSmartPointer<vtkCellArray> existingPolys = polyData->GetPolys();
vtkSmartPointer<vtkPoints> existingPoints = polyData->GetPoints();
existingPolys->InitTraversal();
vtkIdType* cell (NULL);
vtkIdType cellSize (0);
//The array that contains all the vertex normals of the current polygon
vtkSmartPointer<vtkDoubleArray> normals = vtkSmartPointer<vtkDoubleArray>::New();
normals->SetNumberOfComponents(3);
normals->SetNumberOfTuples(polyData->GetNumberOfPoints());
//If the current contour is an inner contour then the direction is -1
//A contour lies inside another one if the pixel values in the direction of the normal is 1
m_NegativeNormalCounter = 0;
m_PositiveNormalCounter = 0;
//Iterating over each polygon
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
{
if(cellSize < 3)continue;
//First we calculate the current polygon's normal
double polygonNormal[3] = {0.0};
double p1[3];
double p2[3];
double v1[3];
double v2[3];
existingPoints->GetPoint(cell[0], p1);
unsigned int index = cellSize*0.5;
existingPoints->GetPoint(cell[index], p2);
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
for (unsigned int k = 2; k < cellSize; k++)
{
index = cellSize*0.25;
existingPoints->GetPoint(cell[index], p1);
index = cellSize*0.75;
existingPoints->GetPoint(cell[index], p2);
v2[0] = p2[0]-p1[0];
v2[1] = p2[1]-p1[1];
v2[2] = p2[2]-p1[2];
vtkMath::Cross(v1,v2,polygonNormal);
if (vtkMath::Norm(polygonNormal) != 0)
break;
}
vtkMath::Normalize(polygonNormal);
//Now we start computing the normal for each vertex
double vertexNormalTemp[3];
existingPoints->GetPoint(cell[0], p1);
existingPoints->GetPoint(cell[1], p2);
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
vtkMath::Cross(v1,polygonNormal,vertexNormalTemp);
vtkMath::Normalize(vertexNormalTemp);
double vertexNormal[3];
for (unsigned j = 0; j < cellSize-2; j++)
{
existingPoints->GetPoint(cell[j+1], p1);
existingPoints->GetPoint(cell[j+2], p2);
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
vtkMath::Cross(v1,polygonNormal,vertexNormal);
vtkMath::Normalize(vertexNormal);
double finalNormal[3];
finalNormal[0] = (vertexNormal[0] + vertexNormalTemp[0])*0.5;
finalNormal[1] = (vertexNormal[1] + vertexNormalTemp[1])*0.5;
finalNormal[2] = (vertexNormal[2] + vertexNormalTemp[2])*0.5;
//Here we determine the direction of the normal
if (j == 0 && m_SegmentationBinaryImage)
{
Point3D worldCoord;
worldCoord[0] = p1[0]+finalNormal[0]*m_MaxSpacing;
worldCoord[1] = p1[1]+finalNormal[1]*m_MaxSpacing;
worldCoord[2] = p1[2]+finalNormal[2]*m_MaxSpacing;
double val = m_SegmentationBinaryImage->GetPixelValueByWorldCoordinate(worldCoord);
if (val == 1.0)
{
++m_PositiveNormalCounter;
}
else
{
++m_NegativeNormalCounter;
}
}
vertexNormalTemp[0] = vertexNormal[0];
vertexNormalTemp[1] = vertexNormal[1];
vertexNormalTemp[2] = vertexNormal[2];
vtkIdType id = cell[j+1];
normals->SetTuple(id,finalNormal);
}
existingPoints->GetPoint(cell[0], p1);
existingPoints->GetPoint(cell[1], p2);
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
vtkMath::Cross(v1,polygonNormal,vertexNormal);
vtkMath::Normalize(vertexNormal);
vertexNormal[0] = (vertexNormal[0] + vertexNormalTemp[0])*0.5;
vertexNormal[1] = (vertexNormal[1] + vertexNormalTemp[1])*0.5;
vertexNormal[2] = (vertexNormal[2] + vertexNormalTemp[2])*0.5;
vtkIdType id = cell[0];
normals->SetTuple(id,vertexNormal);
id = cell[cellSize-1];
normals->SetTuple(id,vertexNormal);
int normalDirection(-1);
if(m_NegativeNormalCounter < m_PositiveNormalCounter)
{
normalDirection = 1;
}
for(unsigned int n = 0; n < normals->GetNumberOfTuples(); n++)
{
double normal[3];
normals->GetTuple(n,normal);
normal[0] = normalDirection*normal[0];
normal[1] = normalDirection*normal[1];
normal[2] = normalDirection*normal[2];
}
}//end for all cells
Surface::Pointer surface = this->GetOutput(i);
surface->GetVtkPolyData()->GetCellData()->SetNormals(normals);
}//end for all inputs
//Setting progressbar
if (this->m_UseProgressBar)
mitk::ProgressBar::GetInstance()->Progress(this->m_ProgressStepSize);
}
mitk::Surface::Pointer mitk::ComputeContourSetNormalsFilter::GetNormalsAsSurface()
{
//Just for debugging:
vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> newLines = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
unsigned int idCounter (0);
//Debug end
- for (unsigned int i = 0; i < this->GetNumberOfOutputs(); i++)
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs(); i++)
{
Surface* currentSurface = const_cast<Surface*>( this->GetOutput(i) );
vtkPolyData* polyData = currentSurface->GetVtkPolyData();
vtkSmartPointer<vtkDoubleArray> currentCellNormals = vtkDoubleArray::SafeDownCast(polyData->GetCellData()->GetNormals());
vtkSmartPointer<vtkCellArray> existingPolys = polyData->GetPolys();
vtkSmartPointer<vtkPoints> existingPoints = polyData->GetPoints();
existingPolys->InitTraversal();
vtkIdType* cell (NULL);
vtkIdType cellSize (0);
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
{
for ( unsigned int j = 0; j < cellSize; j++ )
{
double currentNormal[3];
currentCellNormals->GetTuple(cell[j], currentNormal);
vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
line->GetPointIds()->SetNumberOfIds(2);
double newPoint[3];
double p0[3];
existingPoints->GetPoint(cell[j], p0);
newPoint[0] = p0[0] + currentNormal[0];
newPoint[1] = p0[1] + currentNormal[1];
newPoint[2] = p0[2] + currentNormal[2];
line->GetPointIds()->SetId(0, idCounter);
newPoints->InsertPoint(idCounter, p0);
idCounter++;
line->GetPointIds()->SetId(1, idCounter);
newPoints->InsertPoint(idCounter, newPoint);
idCounter++;
newLines->InsertNextCell(line);
}//end for all points
}//end for all cells
}//end for all outputs
newPolyData->SetPoints(newPoints);
newPolyData->SetLines(newLines);
newPolyData->BuildCells();
mitk::Surface::Pointer surface = mitk::Surface::New();
surface->SetVtkPolyData(newPolyData);
return surface;
}
void mitk::ComputeContourSetNormalsFilter::SetMaxSpacing(double maxSpacing)
{
m_MaxSpacing = maxSpacing;
}
void mitk::ComputeContourSetNormalsFilter::GenerateOutputInformation()
{
Superclass::GenerateOutputInformation();
}
void mitk::ComputeContourSetNormalsFilter::Reset()
{
- for (unsigned int i = 0; i < this->GetNumberOfInputs(); i++)
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); i++)
{
this->PopBackInput();
}
- this->SetNumberOfInputs(0);
- this->SetNumberOfOutputs(0);
+ this->SetNumberOfIndexedInputs(0);
+ this->SetNumberOfIndexedOutputs(0);
+
+ mitk::Surface::Pointer output = mitk::Surface::New();
+ this->SetNthOutput(0, output.GetPointer());
}
void mitk::ComputeContourSetNormalsFilter::SetUseProgressBar(bool status)
{
this->m_UseProgressBar = status;
}
void mitk::ComputeContourSetNormalsFilter::SetProgressStepSize(unsigned int stepSize)
{
this->m_ProgressStepSize = stepSize;
}
diff --git a/Modules/Segmentation/Algorithms/mitkContourModelSource.cpp b/Modules/Segmentation/Algorithms/mitkContourModelSource.cpp
index 59b85b88e4..57b23e3fa7 100644
--- a/Modules/Segmentation/Algorithms/mitkContourModelSource.cpp
+++ b/Modules/Segmentation/Algorithms/mitkContourModelSource.cpp
@@ -1,83 +1,48 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContourModelSource.h"
mitk::ContourModelSource::ContourModelSource()
{
// Create the output.
- OutputType::Pointer output = dynamic_cast<OutputType*>(this->MakeOutput(0).GetPointer());
+ itk::DataObject::Pointer output = this->MakeOutput(0);
Superclass::SetNumberOfRequiredInputs(0);
Superclass::SetNumberOfRequiredOutputs(1);
- Superclass::SetNthOutput(0, output.GetPointer());
+ Superclass::SetNthOutput(0, output);
}
-
-
mitk::ContourModelSource::~ContourModelSource()
{
}
-
-
-itk::DataObject::Pointer mitk::ContourModelSource::MakeOutput ( unsigned int /*idx */)
-{
- return OutputType::New().GetPointer();
-}
-
-
-
-void mitk::ContourModelSource::SetOutput( OutputType* output )
+itk::DataObject::Pointer mitk::ContourModelSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
{
- //itkWarningMacro(<< "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead." );
- this->ProcessObject::SetNthOutput( 0, output );
+ return OutputType::New().GetPointer();
}
-
-
-void mitk::ContourModelSource::GraftOutput(OutputType *graft)
+itk::DataObject::Pointer mitk::ContourModelSource::MakeOutput( const DataObjectIdentifierType & name )
{
- this->GraftNthOutput(0, graft);
+ itkDebugMacro("MakeOutput(" << name << ")");
+ if( this->IsIndexedOutputName(name) )
+ {
+ return this->MakeOutput( this->MakeIndexFromOutputName(name) );
+ }
+ return OutputType::New().GetPointer();
}
-void mitk::ContourModelSource::GraftNthOutput(unsigned int /*idx*/, OutputType* /*graft*/)
-{
- itkWarningMacro(<< "GraftNthOutput(): This method is not yet implemented for mitk. Implement it before using!!" );
- assert(false);
-}
-
-
-
-mitk::ContourModelSource::OutputType* mitk::ContourModelSource::GetOutput()
-{
- if ( this->GetNumberOfOutputs() < 1 )
- {
- return 0;
- }
- else
- {
- return dynamic_cast<OutputType*>
- (this->BaseProcess::GetOutput(0));
- }
-}
-
-
-
-mitk::ContourModelSource::OutputType* mitk::ContourModelSource::GetOutput ( unsigned int idx )
-{
- return dynamic_cast<OutputType*> ( this->ProcessObject::GetOutput( idx ) );
-}
+mitkBaseDataSourceGetOutputDefinitions(mitk::ContourModelSource)
diff --git a/Modules/Segmentation/Algorithms/mitkContourModelSource.h b/Modules/Segmentation/Algorithms/mitkContourModelSource.h
index 25be0bd256..1b7a846950 100644
--- a/Modules/Segmentation/Algorithms/mitkContourModelSource.h
+++ b/Modules/Segmentation/Algorithms/mitkContourModelSource.h
@@ -1,80 +1,68 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_CONTOURMODEL_SOURCE_H
#define _MITK_CONTOURMODEL_SOURCE_H
#include "SegmentationExports.h"
-#include "mitkBaseProcess.h"
+#include "mitkBaseDataSource.h"
#include "mitkContourModel.h"
namespace mitk
{
/**
* @brief Superclass of all classes generating ContourModels.
* @ingroup Process
*/
- class Segmentation_EXPORT ContourModelSource : public BaseProcess
+ class Segmentation_EXPORT ContourModelSource : public BaseDataSource
{
public:
- mitkClassMacro( ContourModelSource, BaseProcess );
- itkNewMacro( Self );
+ mitkClassMacro( ContourModelSource, BaseDataSource )
+ itkNewMacro( Self )
typedef ContourModel OutputType;
typedef OutputType::Pointer OutputTypePointer;
- /**
- * Allocates a new output object and returns it. Currently the
- * index idx is not evaluated.
- * @param idx the index of the output for which an object should be created
- * @returns the new object
- */
- virtual itk::DataObject::Pointer MakeOutput ( unsigned int idx );
-
- /**
- * Allows to set the output of the point set source.
- * @param output the intended output of the point set source
- */
- virtual void SetOutput( OutputType* output );
-
- virtual void GraftOutput(OutputType *output);
- virtual void GraftNthOutput(unsigned int idx, OutputType *output);
+ mitkBaseDataSourceGetOutputDeclarations
/**
- * Returns the output with index 0 of the point set source
- * @returns the output
- */
- virtual OutputType* GetOutput();
+ * Allocates a new output object and returns it. Currently the
+ * index idx is not evaluated.
+ * @param idx the index of the output for which an object should be created
+ * @returns the new object
+ */
+ virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
/**
- * Returns the n'th output of the point set source
- * @param idx the index of the wanted output
- * @returns the output with index idx.
- */
- virtual OutputType* GetOutput ( unsigned int idx );
+ * This is a default implementation to make sure we have something.
+ * Once all the subclasses of ProcessObject provide an appopriate
+ * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
+ * virtual.
+ */
+ virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
protected:
ContourModelSource();
virtual ~ContourModelSource();
};
}
#endif // #_MITK_CONTOURMODEL_SOURCE_H
diff --git a/Modules/Segmentation/Algorithms/mitkContourModelSubDivisionFilter.cpp b/Modules/Segmentation/Algorithms/mitkContourModelSubDivisionFilter.cpp
index 2cade37ec3..2efb3fc92c 100644
--- a/Modules/Segmentation/Algorithms/mitkContourModelSubDivisionFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkContourModelSubDivisionFilter.cpp
@@ -1,217 +1,217 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContourModelSubDivisionFilter.h"
#include <mitkInteractionConst.h>
#include <mitkPointOperation.h>
mitk::ContourModelSubDivisionFilter::ContourModelSubDivisionFilter()
{
OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
this->SetNumberOfRequiredInputs(1);
this->SetNumberOfOutputs( 1 );
this->SetNthOutput(0, output.GetPointer());
this->m_InterpolationIterations = 4;
}
mitk::ContourModelSubDivisionFilter::~ContourModelSubDivisionFilter()
{
}
void mitk::ContourModelSubDivisionFilter::SetInput ( const mitk::ContourModelSubDivisionFilter::InputType* input )
{
this->SetInput( 0, input );
}
void mitk::ContourModelSubDivisionFilter::SetInput ( unsigned int idx, const mitk::ContourModelSubDivisionFilter::InputType* input )
{
if ( idx + 1 > this->GetNumberOfInputs() )
{
this->SetNumberOfRequiredInputs(idx + 1);
}
if ( input != static_cast<InputType*> ( this->ProcessObject::GetInput ( idx ) ) )
{
this->ProcessObject::SetNthInput ( idx, const_cast<InputType*> ( input ) );
this->Modified();
}
}
const mitk::ContourModelSubDivisionFilter::InputType* mitk::ContourModelSubDivisionFilter::GetInput( void )
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const mitk::ContourModelSubDivisionFilter::InputType*>(this->ProcessObject::GetInput(0));
}
const mitk::ContourModelSubDivisionFilter::InputType* mitk::ContourModelSubDivisionFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const mitk::ContourModelSubDivisionFilter::InputType*>(this->ProcessObject::GetInput(idx));
}
void mitk::ContourModelSubDivisionFilter::GenerateData()
{
mitk::ContourModel::Pointer input = const_cast<mitk::ContourModel*>(this->GetInput(0));
mitk::ContourModelSubDivisionFilter::OutputType::Pointer outputContour = this->GetOutput();
mitk::ContourModel::Pointer contour(input);
unsigned int timestep = input->GetTimeSteps();
for ( int currentTimestep = 0; currentTimestep < timestep; currentTimestep++)
{
if( input->GetNumberOfVertices(currentTimestep) >= 4)
{
for( int iterations = 0; iterations < this->m_InterpolationIterations; iterations++)
{
InputType::VertexIterator it = contour->IteratorBegin();
InputType::VertexIterator end = contour->IteratorEnd();
InputType::VertexIterator first = contour->IteratorBegin();
InputType::VertexIterator last = contour->IteratorEnd()-1;
//tempory contour to store result of a subdivision iteration
mitk::ContourModel::Pointer tempContour = mitk::ContourModel::New();
//insert subpoints
while ( it != end )
{
//add the current point to the temp contour
tempContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, currentTimestep);
//control points for interpolation
InputType::VertexIterator Ci = it;
InputType::VertexIterator CiPlus1;
InputType::VertexIterator CiPlus2;
InputType::VertexIterator CiMinus1;
//consider all possible cases
if( it == first)
{
if( input->IsClosed(currentTimestep) )
{
CiPlus1 = it + 1;
CiPlus2 = it + 2;
CiMinus1 = last;
}
else
{
CiPlus1 = it + 1;
CiPlus2 = it + 2;
CiMinus1 = it;
}
}
else if( it == last )
{
if( input->IsClosed(currentTimestep) )
{
CiPlus1 = first;
CiPlus2 = first + 1;
CiMinus1 = it -1;
}
else
{
//don't add point after last
break;
}
}
else if( it == (last - 1) )
{
if( input->IsClosed(currentTimestep) )
{
CiPlus1 = it + 1;
CiPlus2 = first;
CiMinus1 = it -1;
}
else
{
CiPlus1 = it + 1;
CiPlus2 = it + 1;
CiMinus1 = it -1;
}
}
else
{
CiPlus1 = it + 1;
CiPlus2 = it + 2;
CiMinus1 = it -1;
}
/* F2i = Ci
* F2i+1 = -1/16Ci-1 + 9/16Ci + 9/16Ci+1 - 1/16Ci+2
*/
mitk::Point3D subpoint;
mitk::Point3D a;
a[0]=(-1.0/16.0) * (*CiMinus1)->Coordinates[0];
a[1]=(-1.0/16.0) * (*CiMinus1)->Coordinates[1];
a[2]= (-1.0/16.0) * (*CiMinus1)->Coordinates[2];
mitk::Point3D b;
b[0]=(9.0/16.0) * (*Ci)->Coordinates[0];
b[1]=(9.0/16.0) * (*Ci)->Coordinates[1];
b[2]= (9.0/16.0) * (*Ci)->Coordinates[2];
mitk::Point3D c;
c[0]=(9.0/16.0) * (*CiPlus1)->Coordinates[0];
c[1]=(9.0/16.0) * (*CiPlus1)->Coordinates[1];
c[2]= (9.0/16.0) * (*CiPlus1)->Coordinates[2];
mitk::Point3D d;
d[0]=(-1.0/16.0) * (*CiPlus2)->Coordinates[0];
d[1]=(-1.0/16.0) * (*CiPlus2)->Coordinates[1];
d[2]= (-1.0/16.0) * (*CiPlus2)->Coordinates[2];
subpoint[0] = a[0] + b[0] + c[0] + d[0];
subpoint[1] = a[1] + b[1] + c[1] + d[1];
subpoint[2] = a[2] + b[2] + c[2] + d[2];
InputType::VertexType subdivisionPoint(subpoint,false);
//add the new subdivision point to our tempContour
tempContour->AddVertex(subdivisionPoint.Coordinates, currentTimestep);
it++;
}
//set the interpolated contour as the contour for the next iteration
contour = tempContour;
}
}
else
{
//filter not executeable - set input to output
contour = input;
}
}
//somehow the isClosed property is not set via copy constructor
contour->SetIsClosed(input->IsClosed());
- this->SetOutput(contour);
+ this->SetOutput(0, contour);
}
diff --git a/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.cpp b/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.cpp
index 914a97c87e..81b5522b39 100644
--- a/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.cpp
@@ -1,151 +1,65 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContourModelToPointSetFilter.h"
#include <mitkInteractionConst.h>
#include <mitkPointOperation.h>
mitk::ContourModelToPointSetFilter::ContourModelToPointSetFilter()
{
- OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
+ itk::DataObject::Pointer output = this->MakeOutput(0);
this->SetNumberOfRequiredInputs(1);
- this->SetNumberOfOutputs( 1 );
+ this->SetNumberOfRequiredOutputs( 1 );
this->SetNthOutput(0, output.GetPointer());
}
mitk::ContourModelToPointSetFilter::~ContourModelToPointSetFilter()
{
}
-void mitk::ContourModelToPointSetFilter::SetInput ( const mitk::ContourModelToPointSetFilter::InputType* input )
-{
- this->SetInput( 0, input );
-}
-
-void mitk::ContourModelToPointSetFilter::SetInput ( unsigned int idx, const mitk::ContourModelToPointSetFilter::InputType* input )
-{
- if ( idx + 1 > this->GetNumberOfInputs() )
- {
- this->SetNumberOfRequiredInputs(idx + 1);
- }
- if ( input != static_cast<InputType*> ( this->ProcessObject::GetInput ( idx ) ) )
- {
- this->ProcessObject::SetNthInput ( idx, const_cast<InputType*> ( input ) );
- this->Modified();
- }
-}
-
-
-
-mitk::ContourModelToPointSetFilter::OutputType* mitk::ContourModelToPointSetFilter::GetOutput()
-{
- if (this->GetNumberOfOutputs() < 1)
- {
- return 0;
- }
-
- return static_cast<mitk::ContourModelToPointSetFilter::OutputType*>
- (this->BaseProcess::GetOutput(0));
-}
-
-mitk::ContourModelToPointSetFilter::OutputType* mitk::ContourModelToPointSetFilter::GetOutput(unsigned int idx)
-{
- return static_cast<mitk::ContourModelToPointSetFilter::OutputType*>
- (this->itk::ProcessObject::GetOutput(idx));
-}
-
-void mitk::ContourModelToPointSetFilter::SetOutput(mitk::ContourModelToPointSetFilter::OutputType* output)
-{
- itkWarningMacro(<< "SetOutput(): This method is slated to be removed from ITK. Please use GraftOutput() in possible combination with DisconnectPipeline() instead." );
- BaseProcess::SetNthOutput(0, output);
-}
-
-void mitk::ContourModelToPointSetFilter::GraftOutput(mitk::ContourModelToPointSetFilter::OutputType* graft)
-{
- this->GraftNthOutput(0, graft);
-}
-
-void mitk::ContourModelToPointSetFilter::GraftNthOutput(unsigned int idx, mitk::ContourModelToPointSetFilter::OutputType *graft)
-{
- if (idx < this->GetNumberOfOutputs())
- {
- mitk::ContourModelToPointSetFilter::OutputType* output = this->GetOutput(idx);
-
- if (output && graft)
- {
- //// grab a handle to the bulk data of the specified data object
- //// output->SetPixelContainer( graft->GetPixelContainer() ); @FIXME!!!!
-
- //// copy the region ivars of the specified data object
- //output->SetRequestedRegion( graft );//graft->GetRequestedRegion() );
- //// output->SetLargestPossibleRegion( graft->GetLargestPossibleRegion() ); @FIXME!!!!
- //// output->SetBufferedRegion( graft->GetBufferedRegion() ); @FIXME!!!!
-
- //// copy the meta-information
- //output->CopyInformation( graft );
- }
- }
-}
-
-const mitk::ContourModelToPointSetFilter::InputType* mitk::ContourModelToPointSetFilter::GetInput( void )
-{
- if (this->GetNumberOfInputs() < 1)
- return NULL;
- return static_cast<const mitk::ContourModelToPointSetFilter::InputType*>(this->ProcessObject::GetInput(0));
-}
-
-
-const mitk::ContourModelToPointSetFilter::InputType* mitk::ContourModelToPointSetFilter::GetInput( unsigned int idx )
-{
- if (this->GetNumberOfInputs() < 1)
- return NULL;
- return static_cast<const mitk::ContourModelToPointSetFilter::InputType*>(this->ProcessObject::GetInput(idx));
-}
-
-
void mitk::ContourModelToPointSetFilter::GenerateData()
{
- mitk::ContourModel::Pointer inputContour = const_cast<mitk::ContourModel*>(this->GetInput(0));
+ mitk::ContourModel::Pointer inputContour = static_cast<mitk::ContourModel*>(this->GetInput(0));
mitk::ContourModelToPointSetFilter::OutputType* outputPointSet = this->GetOutput();
InputType::VertexIterator it = inputContour->IteratorBegin();
InputType::VertexIterator end = inputContour->IteratorEnd();
unsigned int pointId = 0;
unsigned int timestep = inputContour->GetTimeSteps();
for ( int i = 0; i < timestep; i++)
{
while ( it <= end )
{
mitk::Point3D p = (*it)->Coordinates;
mitk::PointOperation popInsert( mitk::OpINSERT,
inputContour->GetTimeSlicedGeometry()->TimeStepToMS(timestep),
p,
pointId++,
false );
outputPointSet->ExecuteOperation( &popInsert );
it++;
}
}
}
diff --git a/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.h b/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.h
index 3ed42d080b..ac83851cd0 100644
--- a/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.h
+++ b/Modules/Segmentation/Algorithms/mitkContourModelToPointSetFilter.h
@@ -1,90 +1,62 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _mitkContourModelToPointSetFilter_h__
#define _mitkContourModelToPointSetFilter_h__
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkPointSet.h"
#include "mitkPointSetSource.h"
#include "mitkContourModel.h"
namespace mitk {
/**
*
* @brief Converts a contour set to a point set.
*
* The resulting pointset consists of sample points of all the contours
*
* @ingroup SurfaceFilters
* @ingroup Process
*/
class Segmentation_EXPORT ContourModelToPointSetFilter : public PointSetSource
{
public:
- mitkClassMacro(ContourModelToPointSetFilter, PointSetSource);
- itkNewMacro(Self);
-
+ mitkClassMacro(ContourModelToPointSetFilter, PointSetSource)
+ itkNewMacro(Self)
typedef PointSet OutputType;
typedef OutputType::Pointer OutputTypePointer;
typedef mitk::ContourModel InputType;
-
- /**
- * Allows to set the output of the point set source.
- * @param output the intended output of the point set source
- */
- virtual void SetOutput( OutputType* output );
-
- virtual void GraftOutput(OutputType *output);
- virtual void GraftNthOutput(unsigned int idx, OutputType *output);
-
- /**
- * Returns the output with index 0 of the point set source
- * @returns the output
- */
- virtual OutputType* GetOutput();
-
- /**
- * Returns the n'th output of the point set source
- * @param idx the index of the wanted output
- * @returns the output with index idx.
- */
- virtual OutputType* GetOutput ( unsigned int idx );
-
- virtual void SetInput( const InputType *input);
- virtual void SetInput( unsigned int idx, const InputType * input);
- const InputType * GetInput(void);
- const InputType * GetInput(unsigned int idx);
-
protected:
+
ContourModelToPointSetFilter();
virtual ~ContourModelToPointSetFilter();
- void GenerateOutputInformation() {};
+ void GenerateOutputInformation() {}
void GenerateData();
};
}
#endif
diff --git a/Modules/Segmentation/Algorithms/mitkContourSetToPointSetFilter.cpp b/Modules/Segmentation/Algorithms/mitkContourSetToPointSetFilter.cpp
index d7b62f75e5..8e247ef471 100644
--- a/Modules/Segmentation/Algorithms/mitkContourSetToPointSetFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkContourSetToPointSetFilter.cpp
@@ -1,91 +1,91 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContourSetToPointSetFilter.h"
#include <mitkPointOperation.h>
#include <mitkInteractionConst.h>
mitk::ContourSetToPointSetFilter::ContourSetToPointSetFilter()
{
OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
this->SetNumberOfRequiredInputs(1);
- this->SetNumberOfOutputs( 1 );
+ this->SetNumberOfIndexedOutputs( 1 );
this->SetNthOutput(0, output.GetPointer());
m_Frequency = 5;
}
mitk::ContourSetToPointSetFilter::~ContourSetToPointSetFilter()
{
}
void mitk::ContourSetToPointSetFilter::GenerateOutputInformation()
{
}
void mitk::ContourSetToPointSetFilter::GenerateData()
{
mitk::ContourSet* input = (mitk::ContourSet*) (this->GetInput());
mitk::PointSet::Pointer output = this->GetOutput();
mitk::ContourSet::ContourVectorType contourVec = input->GetContours();
mitk::ContourSet::ContourIterator contourIt = contourVec.begin();
unsigned int pointId = 0;
while ( contourIt != contourVec.end() )
{
mitk::Contour* nextContour = (mitk::Contour*) (*contourIt).second;
mitk::Contour::InputType idx = nextContour->GetContourPath()->StartOfInput();
mitk::Contour::OutputType point;
mitk::Contour::InputType end = nextContour->GetContourPath()->EndOfInput();
if (end > 50000) end = 0;
while ( idx <= end )
{
point = nextContour->GetContourPath()->Evaluate(idx);
Contour::BoundingBoxType::PointType p;
p.CastFrom(point);
mitk::PointOperation popInsert( mitk::OpINSERT, p, pointId++ );
mitk::PointOperation popDeactivate( mitk::OpDESELECTPOINT, p , pointId++ );
output->ExecuteOperation( &popInsert );
output->ExecuteOperation( &popDeactivate );
idx+=m_Frequency;
}
contourIt++;
}
}
const mitk::ContourSet* mitk::ContourSetToPointSetFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return static_cast<const mitk::ContourSet * >
( this->BaseProcess::GetInput(0) );
}
void mitk::ContourSetToPointSetFilter::SetInput(const mitk::ContourSet *input)
{
// Process object is not const-correct so the const_cast is required here
this->BaseProcess::SetNthInput(0,
const_cast< mitk::ContourSet * >( input ) );
}
diff --git a/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp b/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
index 02d7183d74..057a847b1e 100644
--- a/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
+++ b/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
@@ -1,517 +1,516 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkCorrectorAlgorithm.h"
#include "mitkImageCast.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageDataItem.h"
#include "mitkContourUtils.h"
mitk::CorrectorAlgorithm::CorrectorAlgorithm()
:ImageToImageFilter()
{
}
mitk::CorrectorAlgorithm::~CorrectorAlgorithm()
{
}
void mitk::CorrectorAlgorithm::GenerateData()
{
Image::Pointer inputImage = const_cast<Image*>(ImageToImageFilter::GetInput(0));
if (inputImage.IsNull() || inputImage->GetDimension() != 2)
{
itkExceptionMacro("CorrectorAlgorithm needs a 2D image as input.");
}
if (m_Contour.IsNull())
{
itkExceptionMacro("CorrectorAlgorithm needs a Contour object as input.");
}
// copy the input (since m_WorkingImage will be changed later)
m_WorkingImage = Image::New();
m_WorkingImage->Initialize( inputImage );
m_WorkingImage->SetVolume( inputImage.GetPointer()->GetData() );
TimeSlicedGeometry::Pointer originalGeometry;
if (inputImage->GetTimeSlicedGeometry() )
{
- AffineGeometryFrame3D::Pointer originalGeometryAGF = inputImage->GetTimeSlicedGeometry()->Clone();
- originalGeometry = dynamic_cast<TimeSlicedGeometry*>( originalGeometryAGF.GetPointer() );
+ originalGeometry = inputImage->GetTimeSlicedGeometry()->Clone();
m_WorkingImage->SetGeometry( originalGeometry );
}
else
{
itkExceptionMacro("Original image does not have a 'Time sliced geometry'! Cannot copy.");
}
Image::Pointer temporarySlice;
// Convert to ipMITKSegmentationTYPE (because TobiasHeimannCorrectionAlgorithm relys on that data type)
{
itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
CastToItkImage( m_WorkingImage, correctPixelTypeImage );
assert (correctPixelTypeImage.IsNotNull() );
// possible bug in CastToItkImage ?
// direction maxtrix is wrong/broken/not working after CastToItkImage, leading to a failed assertion in
// mitk/Core/DataStructures/mitkSlicedGeometry3D.cpp, 479:
// virtual void mitk::SlicedGeometry3D::SetSpacing(const mitk::Vector3D&): Assertion `aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0' failed
// solution here: we overwrite it with an unity matrix
itk::Image< ipMITKSegmentationTYPE, 2 >::DirectionType imageDirection;
imageDirection.SetIdentity();
//correctPixelTypeImage->SetDirection(imageDirection);
temporarySlice = this->GetOutput();
// temporarySlice = ImportItkImage( correctPixelTypeImage );
CastToMitkImage( correctPixelTypeImage, temporarySlice );
}
mitkIpPicDescriptor* temporarySlicePic = mitkIpPicNew();
CastToIpPicDescriptor( temporarySlice, temporarySlicePic );
TobiasHeimannCorrectionAlgorithm( temporarySlicePic );
temporarySlice->SetGeometry(originalGeometry);
// temporarySlice is our return value (user can get it by calling GetOutput() )
// CalculateDifferenceImage( temporarySlice, inputImage );
// if ( m_DifferenceImage.IsNotNull() && inputImage->GetTimeSlicedGeometry() )
// {
// AffineGeometryFrame3D::Pointer originalGeometryAGF = inputImage->GetTimeSlicedGeometry()->Clone();
// TimeSlicedGeometry::Pointer originalGeometry = dynamic_cast<TimeSlicedGeometry*>( originalGeometryAGF.GetPointer() );
// m_DifferenceImage->SetGeometry( originalGeometry );
// }
// else
// {
// itkExceptionMacro("Original image does not have a 'Time sliced geometry'! Cannot copy.");
// }
}
void mitk::CorrectorAlgorithm::TobiasHeimannCorrectionAlgorithm(mitkIpPicDescriptor* pic)
{
/*!
Some documentation (not by the original author)
TobiasHeimannCorrectionAlgorithm will be called, when the user has finished drawing a freehand line.
There should be different results, depending on the line's properties:
1. Without any prior segmentation, the start point and the end point of the drawn line will be
connected to a contour and the area enclosed by the contour will be marked as segmentation.
2. When the whole line is inside a segmentation, start and end point will be connected to
a contour and the area of this contour will be subtracted from the segmentation.
3. When the line starts inside a segmentation and ends outside with only a single
transition from segmentation to no-segmentation, nothing will happen.
4. When there are multiple transitions between inside-segmentation and
outside-segmentation, the line will be divided in so called segments. Each segment is
either fully inside or fully outside a segmentation. When it is inside a segmentation, its
enclosed area will be subtracted from the segmentation. When the segment is outside a
segmentation, its enclosed area it will be added to the segmentation.
The algorithm is described in full length in Tobias Heimann's diploma thesis
(MBI Technical Report 145, p. 37 - 40).
*/
int oaSize = 1000000; // if we need a fixed number, then let it be big
int* _ofsArray = new int[ oaSize ];
for (int i=0; i<oaSize; i++) _ofsArray[i] = 0;
std::vector<TSegData> segData;
segData.reserve( 16 );
Contour* contour3D = const_cast<Contour*>(m_Contour.GetPointer());
ContourUtils::Pointer contourUtils = ContourUtils::New();
Contour::Pointer projectedContour = contourUtils->ProjectContourTo2DSlice( m_WorkingImage, contour3D, true, false );
if (projectedContour.IsNull())
{
delete[] _ofsArray;
return;
}
if (projectedContour->GetNumberOfPoints() < 2)
{
delete[] _ofsArray;
return;
}
// convert the projected contour into a ipSegmentation format
mitkIpInt4_t* _points = new mitkIpInt4_t[2 * projectedContour->GetNumberOfPoints()];
const Contour::PathType::VertexListType* pointsIn2D = projectedContour->GetContourPath()->GetVertexList();
unsigned int index(0);
for ( Contour::PathType::VertexListType::const_iterator iter = pointsIn2D->begin();
iter != pointsIn2D->end();
++iter, ++index )
{
_points[ 2 * index + 0 ] = static_cast<mitkIpInt4_t>( (*iter)[0] + 0.5 );
_points[ 2 * index + 1 ] = static_cast<mitkIpInt4_t>( (*iter)[1] + 0.5 );
}
// store ofsets of the drawn line in array
int _ofsNum = 0;
unsigned int num = projectedContour->GetNumberOfPoints();
int lastOfs = -1;
for (unsigned int i=0; i<num-1; i++)
{
float x = _points [2*i] + 0.5;
float y = _points [2*i+1] + 0.5;
float difX = _points [2*i+2] - x + 0.5;
float difY = _points [2*i+3] - y + 0.5;
float length = sqrt( difX*difX + difY*difY );
float dx = difX / length;
float dy = difY / length;
for (int p=0; ((float)p)<length; p++)
{
// if ofs is out of bounds, very nasty things will happen, so better check coordinates:
if (x<0) x=0.5;
else if (x>=pic->n[0]) x = pic->n[0]-0.5;
if (y<0) y=0.5;
else if (y>=pic->n[1]) y = pic->n[1]-0.5;
// ok, now store safe ofs
int ofs = (int)(x) + pic->n[0]*((int)(y));
x += dx;
y += dy;
if (ofs != lastOfs)
{
_ofsArray[_ofsNum++] = ofs;
lastOfs = ofs;
}
}
}
if (_ofsNum == 0)
{
// contour was completely outside the binary image
delete[] _ofsArray;
delete[] _points;
return;
}
ipMITKSegmentationTYPE* picdata = static_cast<ipMITKSegmentationTYPE*>(pic->data);
// divide line in logical segments:
int numSegments = 0;
ipMITKSegmentationTYPE state = *(picdata + _ofsArray[0]);
int ofsP = 1;
int modifyStart, modifyEnd; // start of first and end of last segment
bool nextSegment;
segData.clear();
do
{
nextSegment = false;
while (ofsP<_ofsNum && *(picdata + _ofsArray[ofsP])==state) ofsP++;
if (ofsP<_ofsNum)
{
int lineStart = ofsP-1;
if (numSegments==0) modifyStart = ofsP;
state = *(picdata + _ofsArray[ofsP]);
while (ofsP<_ofsNum && *(picdata + _ofsArray[ofsP])==state) ofsP++;
if (ofsP<_ofsNum)
{
int lineEnd = ofsP;
modifyEnd = lineEnd;
nextSegment = true;
// now we've got a valid segment from lineStart to lineEnd
TSegData thisSegData;
thisSegData.lineStart = lineStart;
thisSegData.lineEnd = lineEnd;
thisSegData.modified = modifySegment( lineStart, lineEnd, state, pic, _ofsArray );
segData.push_back( thisSegData );
numSegments++;
}
}
} while (nextSegment);
for (int segNr=0; segNr < numSegments; segNr++)
{
// draw line if modified:
if ( segData[segNr].modified )
{
for (int i=segData[segNr].lineStart+1; i<segData[segNr].lineEnd; i++)
{
*(picdata + _ofsArray[i]) = 1;
}
}
}
if (numSegments == 0)
{
if (num <= 1)
{ // only a single pixel. _ofsArray[_ofsNum-1] in else statement would crash, so don't do anything
// no movement: delete operation
// This behaviour would probably confuse users when they use the correction
// tool to change a segmentation and it deletes much more than selected
// if (state == 1) ipMITKSegmentationReplaceRegion4N( pic, _ofsArray[0], 0 );
}
else if ( *(picdata + _ofsArray[_ofsNum-1]) == *(picdata + _ofsArray[0]))
{
// start point and end point both inside or both outside any segmentation
// normal paint operation
mitkIpInt4_t* p = new mitkIpInt4_t[2 * num];
for (unsigned int i = 0; i < num; i++)
{
p[2 * i] = (mitkIpInt4_t) _points [2 * i];
p[2 * i + 1] = (mitkIpInt4_t) _points [2 * i + 1];
}
if (state == 0) ipMITKSegmentationCombineRegion (pic, p, num, 0, IPSEGMENTATION_OR, 1);
else ipMITKSegmentationCombineRegion (pic, p, num, 0, IPSEGMENTATION_AND, 0);
delete[] p;
}
}
int numberOfContourPoints( 0 );
int oneContourOffset( 0 );
int newBufferSize( 0 );
int imageSize = pic->n[0]*pic->n[1];
for (oneContourOffset = 0; oneContourOffset < imageSize; oneContourOffset++)
if ( ((ipMITKSegmentationTYPE*) pic->data)[oneContourOffset]> 0) break;
float* contourPoints = ipMITKSegmentationGetContour8N( pic, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
if (contourPoints)
{
// copy point from float* to mitk::Contour
Contour::Pointer contourInImageIndexCoordinates = Contour::New();
contourInImageIndexCoordinates->Initialize();
Point3D newPoint;
for (int index = 0; index < numberOfContourPoints; ++index)
{
newPoint[0] = contourPoints[ 2 * index + 0 ];
newPoint[1] = contourPoints[ 2 * index + 1];
newPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex( newPoint );
}
free(contourPoints);
ContourUtils::Pointer contourUtils = ContourUtils::New();
contourUtils->FillContourInSlice( contourInImageIndexCoordinates, m_WorkingImage );
}
delete[] _ofsArray;
delete[] _points;
}
bool mitk::CorrectorAlgorithm::modifySegment( int lineStart, int lineEnd, ipMITKSegmentationTYPE state, mitkIpPicDescriptor *pic, int* _ofsArray )
{
// offsets for pixels right, top, left, bottom
int nbDelta4[4];
nbDelta4[0]=1; nbDelta4[1]=pic->n[0]; nbDelta4[1]*=-1; // necessary because of unsigned declaration of pic->n
nbDelta4[2]=-1; nbDelta4[3]=pic->n[0];
// offsets for pixels right, top-right, top, top-left left, bottom-left, bottom, bottom-right
int nbDelta8[8];
nbDelta8[0] = 1; nbDelta8[1] = nbDelta4[1]+1; nbDelta8[2] = nbDelta4[1]; nbDelta8[3] = nbDelta4[1]-1;
nbDelta8[4] = -1; nbDelta8[5] = nbDelta4[3]-1; nbDelta8[6] = nbDelta4[3]; nbDelta8[7] = nbDelta4[3]+1;
ipMITKSegmentationTYPE* picdata = static_cast<ipMITKSegmentationTYPE*>(pic->data);
ipMITKSegmentationTYPE saveStart = *(picdata + _ofsArray[lineStart]);
ipMITKSegmentationTYPE saveEnd = *(picdata + _ofsArray[lineEnd]);
ipMITKSegmentationTYPE newState = ((!state)&1) + 2; // probably equal to: ipMITKSegmentationTYPE newState = 3 - state;
// make two copies of pic:
mitkIpPicDescriptor *seg1 = mitkIpPicClone( pic );
mitkIpPicDescriptor *seg2 = mitkIpPicClone( pic );
int i;
// mark line in original
for (i=lineStart; i<=lineEnd; i++) {
*(picdata + _ofsArray[i]) = 3;
}
// mark the first side in copy 1:
bool firstPix = true;
bool modified;
int line = pic->n[0]; // #pixels in line
int maxOfs = (int)(line * pic->n[1]); // #pixels in slice
for (i=lineStart+1; i<lineEnd; i++) {
do {
modified = false;
for (int nb=0; nb<8; nb++) {
int nbOfs = _ofsArray[i] + nbDelta8[nb];
if ( nbOfs < 0 // above first line
|| nbOfs >= maxOfs // below last line
) continue;
ipMITKSegmentationTYPE nbVal = *(picdata + nbOfs);
ipMITKSegmentationTYPE destVal = *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs);
if (nbVal!=3 && destVal!=newState) { // get only neigbhours that are not part of the line itself
if (firstPix) {
*(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs) = newState; // this one is used to mark the side!
firstPix = false;
modified = true;
}
else {
int tnb = 0;
while ( tnb < 4
&& ((nbOfs + nbDelta4[tnb]) >= 0) && ((nbOfs + nbDelta4[tnb]) < maxOfs)
&& *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs + nbDelta4[tnb]) != newState
)
tnb++;
if (tnb < 4 && ((nbOfs + nbDelta4[tnb]) >= 0) && ((nbOfs + nbDelta4[tnb]) < maxOfs) ) {
*(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs) = newState; // we've got a buddy close
modified = true;
}
}
}
}
} while (modified);
}
// mark the other side in copy 2:
for (i=lineStart+1; i<lineEnd; i++) {
for (int nb=0; nb<4; nb++) {
int nbOfs = _ofsArray[i] + nbDelta4[nb];
if ( nbOfs < 0 // above first line
|| nbOfs >= maxOfs // below last line
) continue;
ipMITKSegmentationTYPE lineVal = *(picdata + nbOfs);
ipMITKSegmentationTYPE side1Val = *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs);
if (lineVal != 3 && side1Val != newState) {
*(((ipMITKSegmentationTYPE*)seg2->data) + nbOfs) = newState;
}
}
}
// take care of line ends for multiple segments:
*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[lineStart]) = newState;
*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[lineEnd]) = newState;
*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[lineStart]) = newState;
*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[lineEnd]) = newState;
// replace regions:
newState = (!state)&1;
int sizeRegion1 = 0, sizeRegion2 = 0;
for (i=lineStart+1; i<lineEnd; i++) {
if (*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[i]) != newState) {
sizeRegion1 += ipMITKSegmentationReplaceRegion4N( seg1, _ofsArray[i], newState );
}
if (*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[i]) != newState) {
sizeRegion2 += ipMITKSegmentationReplaceRegion4N( seg2, _ofsArray[i], newState );
}
}
// combine image:
//printf( "Size Region1 = %8i Size Region2 = %8i\n", sizeRegion1, sizeRegion2 );
int sizeDif;
ipMITKSegmentationTYPE *current, *segSrc;
if (sizeRegion1 < sizeRegion2) {
segSrc = (ipMITKSegmentationTYPE*)seg1->data;
sizeDif = sizeRegion2 - sizeRegion1;
}
else {
segSrc = (ipMITKSegmentationTYPE*)seg2->data;
sizeDif = sizeRegion1 - sizeRegion2;
}
modified = false;
if (sizeDif > 2*(lineEnd-lineStart)) {
// decision is safe enough:
ipMITKSegmentationTYPE *end = picdata + (pic->n[0]*pic->n[1]);
for (current = picdata; current<end; current++) {
if (*segSrc == newState) *current = newState;
segSrc++;
}
modified = true;
}
// restore line:
for (int i=lineStart+1; i<lineEnd; i++) {
*(picdata + _ofsArray[i]) = state;
}
// restore end points:
*(picdata + _ofsArray[lineStart]) = saveStart;
*(picdata + _ofsArray[lineEnd]) = saveEnd;
mitkIpPicFree( seg1 );
mitkIpPicFree( seg2 );
return modified;
}
void mitk::CorrectorAlgorithm::CalculateDifferenceImage( Image* modifiedImage, Image* originalImage )
{
/*
* modifiedImage has ipMITKSegmentationTYPE
* originalImage may be any type
*
* --> we calculate a diff image using ITK, switching for the correct type of originalImage
*/
m_DifferenceImage = NULL;
Image::Pointer tmpPtr = originalImage;
AccessFixedDimensionByItk_1( tmpPtr, ItkCalculateDifferenceImage, 2, modifiedImage );
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::CorrectorAlgorithm::ItkCalculateDifferenceImage( itk::Image<TPixel, VImageDimension>* originalImage, Image* modifiedMITKImage )
{
typedef itk::Image<ipMITKSegmentationTYPE, VImageDimension> ModifiedImageType;
typedef itk::Image<short signed int, VImageDimension> DiffImageType;
typedef itk::ImageRegionConstIterator< itk::Image<TPixel,VImageDimension> > OriginalSliceIteratorType;
typedef itk::ImageRegionConstIterator< ModifiedImageType > ModifiedSliceIteratorType;
typedef itk::ImageRegionIterator< DiffImageType > DiffSliceIteratorType;
typename ModifiedImageType::Pointer modifiedImage;
CastToItkImage( modifiedMITKImage, modifiedImage );
// create new image as a copy of the input
// this new image is the output of this filter class
typename DiffImageType::Pointer diffImage;
m_DifferenceImage = Image::New();
PixelType pixelType( mitk::MakeScalarPixelType<short>() );
m_DifferenceImage->Initialize( pixelType, 2, modifiedMITKImage->GetDimensions() );
CastToItkImage( m_DifferenceImage, diffImage );
// iterators over both input images (original and modified) and the output image (diff)
ModifiedSliceIteratorType modifiedIterator( modifiedImage, diffImage->GetLargestPossibleRegion() );
OriginalSliceIteratorType originalIterator( originalImage, diffImage->GetLargestPossibleRegion() );
DiffSliceIteratorType diffIterator( diffImage, diffImage->GetLargestPossibleRegion() );
modifiedIterator.GoToBegin();
originalIterator.GoToBegin();
diffIterator.GoToBegin();
while ( !diffIterator.IsAtEnd() )
{
short signed int difference = static_cast<short signed int>( static_cast<signed int>(modifiedIterator.Get()) -
static_cast<signed int>(originalIterator.Get())); // not good for bigger values ?!
diffIterator.Set( difference );
++modifiedIterator;
++originalIterator;
++diffIterator;
}
}
diff --git a/Modules/Segmentation/Algorithms/mitkCreateDistanceImageFromSurfaceFilter.cpp b/Modules/Segmentation/Algorithms/mitkCreateDistanceImageFromSurfaceFilter.cpp
index 0a282d6b74..b30422728d 100644
--- a/Modules/Segmentation/Algorithms/mitkCreateDistanceImageFromSurfaceFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkCreateDistanceImageFromSurfaceFilter.cpp
@@ -1,600 +1,679 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkCreateDistanceImageFromSurfaceFilter.h"
mitk::CreateDistanceImageFromSurfaceFilter::CreateDistanceImageFromSurfaceFilter()
{
m_DistanceImageVolume = 50000;
this->m_UseProgressBar = false;
this->m_ProgressStepSize = 5;
+
+ mitk::Image::Pointer output = mitk::Image::New();
+ this->SetNthOutput(0, output.GetPointer());
}
mitk::CreateDistanceImageFromSurfaceFilter::~CreateDistanceImageFromSurfaceFilter()
{
}
void mitk::CreateDistanceImageFromSurfaceFilter::GenerateData()
{
//First of all we have to build the equation-system from the existing contour-edge-points
this->CreateSolutionMatrixAndFunctionValues();
//Then we solve the equation-system via QR - decomposition. The interpolation weights are obtained in that way
vnl_qr<double> solver (m_SolutionMatrix);
m_Weights = solver.solve(m_FunctionValues);
//Setting progressbar
if (this->m_UseProgressBar)
mitk::ProgressBar::GetInstance()->Progress(2);
//The last step is to create the distance map with the interpolated distance function
this->CreateDistanceImage();
m_Centers.clear();
m_FunctionValues.clear();
m_Normals.clear();
m_Weights.clear();
m_SolutionMatrix.clear();
//Setting progressbar
if (this->m_UseProgressBar)
mitk::ProgressBar::GetInstance()->Progress(3);
}
void mitk::CreateDistanceImageFromSurfaceFilter::CreateSolutionMatrixAndFunctionValues()
{
- unsigned int numberOfInputs = this->GetNumberOfInputs();
+ unsigned int numberOfInputs = this->GetNumberOfIndexedInputs();
if (numberOfInputs == 0)
{
MITK_ERROR << "mitk::CreateDistanceImageFromSurfaceFilter: No input available. Please set an input!" << std::endl;
itkExceptionMacro("mitk::CreateDistanceImageFromSurfaceFilter: No input available. Please set an input!");
return;
}
//First of all we have to extract the nomals and the surface points.
//Duplicated points can be eliminated
Surface* currentSurface;
vtkSmartPointer<vtkPolyData> polyData;
vtkSmartPointer<vtkDoubleArray> currentCellNormals;
vtkSmartPointer<vtkCellArray> existingPolys;
vtkSmartPointer<vtkPoints> existingPoints;
double p[3];
PointType currentPoint;
PointType normal;
for (unsigned int i = 0; i < numberOfInputs; i++)
{
currentSurface = const_cast<Surface*>( this->GetInput(i) );
polyData = currentSurface->GetVtkPolyData();
if (polyData->GetNumberOfPolys() == 0)
{
MITK_INFO << "mitk::CreateDistanceImageFromSurfaceFilter: No input-polygons available. Please be sure the input surface consists of polygons!" << std::endl;
}
currentCellNormals = vtkDoubleArray::SafeDownCast(polyData->GetCellData()->GetNormals());
existingPolys = polyData->GetPolys();
existingPoints = polyData->GetPoints();
existingPolys->InitTraversal();
vtkIdType* cell (NULL);
vtkIdType cellSize (0);
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
{
for ( unsigned int j = 0; j < cellSize; j++ )
{
existingPoints->GetPoint(cell[j], p);
currentPoint.copy_in(p);
int count = std::count(m_Centers.begin() ,m_Centers.end(),currentPoint);
if (count == 0)
{
double currentNormal[3];
currentCellNormals->GetTuple(cell[j], currentNormal);
normal.copy_in(currentNormal);
m_Normals.push_back(normal);
m_Centers.push_back(currentPoint);
}
}//end for all points
}//end for all cells
}//end for all outputs
//For we can now calculate the exact size of the centers we initialize the data structures
unsigned int numberOfCenters = m_Centers.size();
m_Centers.reserve(numberOfCenters*3);
m_FunctionValues.set_size(numberOfCenters*3);
m_FunctionValues.fill(0);
//Create inner points
for (unsigned int i = 0; i < numberOfCenters; i++)
{
currentPoint = m_Centers.at(i);
normal = m_Normals.at(i);
currentPoint[0] = currentPoint[0] - normal[0];
currentPoint[1] = currentPoint[1] - normal[1];
currentPoint[2] = currentPoint[2] - normal[2];
m_Centers.push_back(currentPoint);
m_FunctionValues.put(numberOfCenters+i, -1);
}
//Create outer points
for (unsigned int i = 0; i < numberOfCenters; i++)
{
currentPoint = m_Centers.at(i);
normal = m_Normals.at(i);
currentPoint[0] = currentPoint[0] + normal[0];
currentPoint[1] = currentPoint[1] + normal[1];
currentPoint[2] = currentPoint[2] + normal[2];
m_Centers.push_back(currentPoint);
m_FunctionValues.put(numberOfCenters*2+i, 1);
}
//Now we have created all centers and all function values. Next step is to create the solution matrix
numberOfCenters = m_Centers.size();
m_SolutionMatrix.set_size(numberOfCenters, numberOfCenters);
m_Weights.set_size(numberOfCenters);
PointType p1;
PointType p2;
double norm;
for (unsigned int i = 0; i < numberOfCenters; i++)
{
for (unsigned int j = 0; j < numberOfCenters; j++)
{
//Calculate the RBF value. Currently using Phi(r) = r with r is the euclidian distance between two points
p1 = m_Centers.at(i);
p2 = m_Centers.at(j);
p1 = p1 - p2;
norm = p1.two_norm();
m_SolutionMatrix(i,j) = norm;
}
}
}
void mitk::CreateDistanceImageFromSurfaceFilter::CreateDistanceImage()
{
- typedef itk::Image<double, 3> DistanceImageType;
- typedef itk::ImageRegionIteratorWithIndex<DistanceImageType> ImageIterator;
- typedef itk::NeighborhoodIterator<DistanceImageType> NeighborhoodImageIterator;
-
DistanceImageType::Pointer distanceImg = DistanceImageType::New();
// Determine the bounds of the input points in index- and world-coordinates
DistanceImageType::PointType minPointInWorldCoordinates, maxPointInWorldCoordinates;
DistanceImageType::IndexType minPointInIndexCoordinates, maxPointInIndexCoordinates;
DetermineBounds( minPointInWorldCoordinates, maxPointInWorldCoordinates,
minPointInIndexCoordinates, maxPointInIndexCoordinates );
// Calculate the extent of the region that contains all given points in MM.
// To do this, we take the difference between the maximal and minimal
// index-coordinates (must not be less than 1) and multiply it with the
// spacing of the reference-image.
Vector3D extentMM;
for (unsigned int dim = 0; dim < 3; ++dim)
{
extentMM[dim] = (int)
(
(std::max( std::abs(maxPointInIndexCoordinates[dim] - minPointInIndexCoordinates[dim]),
(DistanceImageType::IndexType::IndexValueType) 1
) + 1.0) // (max-index - min-index)+1 because the pixels between index 3 and 5 cover 2+1=3 pixels (pixel 3,4, and 5)
* m_ReferenceImage->GetSpacing()[dim]
) + 1; // (int) ((...) + 1) -> we round up to the next BIGGER int value
}
/*
* Now create an empty distance image. The create image will always have the same sizeOfRegion, independent from
* the original image (e.g. always consists of 500000 pixels) and will have an isotropic spacing.
* The spacing is calculated like the following:
* The image's volume = 500000 Pixels = extentX*spacing*extentY*spacing*extentZ*spacing
* So the spacing is: spacing = ( 500000 / extentX*extentY*extentZ )^(1/3)
*/
double basis = (extentMM[0]*extentMM[1]*extentMM[2]) / m_DistanceImageVolume;
double exponent = 1.0/3.0;
double distImgSpacing = pow(basis, exponent);
int tempSpacing = (distImgSpacing+0.05)*10;
m_DistanceImageSpacing = (double)tempSpacing/10.0;
// calculate the number of pixels of the distance image for each direction
unsigned int numberOfXPixel = extentMM[0] / m_DistanceImageSpacing;
unsigned int numberOfYPixel = extentMM[1] / m_DistanceImageSpacing;
unsigned int numberOfZPixel = extentMM[2] / m_DistanceImageSpacing;
// We increase the sizeOfRegion by 4 as we decrease the origin by 2 later.
// This expansion of the region is necessary to achieve a complete
// interpolation.
DistanceImageType::SizeType sizeOfRegion;
sizeOfRegion[0] = numberOfXPixel + 4;
sizeOfRegion[1] = numberOfYPixel + 4;
sizeOfRegion[2] = numberOfZPixel + 4;
// The region starts at index 0,0,0
DistanceImageType::IndexType initialOriginAsIndex;
initialOriginAsIndex.Fill(0);
DistanceImageType::PointType originAsWorld = minPointInWorldCoordinates;
DistanceImageType::RegionType lpRegion;
lpRegion.SetSize(sizeOfRegion);
lpRegion.SetIndex(initialOriginAsIndex);
// We initialize the itk::Image with
// * origin and direction to have it correctly placed and rotated in the world
// * the largest possible region to set the extent to be calculated
// * the isotropic spacing that we have calculated above
distanceImg->SetOrigin( originAsWorld );
distanceImg->SetDirection( m_ReferenceImage->GetDirection() );
distanceImg->SetRegions( lpRegion );
distanceImg->SetSpacing( m_DistanceImageSpacing );
distanceImg->Allocate();
//First of all the image is initialized with the value 10 for each pixel
distanceImg->FillBuffer(10);
// Now we move the origin of the distanceImage 2 index-Coordinates
// in all directions
DistanceImageType::IndexType originAsIndex;
distanceImg->TransformPhysicalPointToIndex( originAsWorld, originAsIndex );
originAsIndex[0] -= 2;
originAsIndex[1] -= 2;
originAsIndex[2] -= 2;
distanceImg->TransformIndexToPhysicalPoint( originAsIndex, originAsWorld );
distanceImg->SetOrigin( originAsWorld );
/*
* Now we must calculate the distance for each pixel. But instead of calculating the distance value
* for all of the image's pixels we proceed similar to the region growing algorithm:
*
* 1. Take the first pixel from the narrowband_point_list and calculate the distance for each neighbor (6er)
* 2. If the current index's distance value is below a certain threshold push it into the list
* 3. Next iteration take the next index from the list and originAsIndex with 1. again
*
* This is done until the narrowband_point_list is empty.
*/
std::queue<DistanceImageType::IndexType> narrowbandPoints;
PointType currentPoint = m_Centers.at(0);
double distance = this->CalculateDistanceValue(currentPoint);
// create itk::Point from vnl_vector
DistanceImageType::PointType currentPointAsPoint;
currentPointAsPoint[0] = currentPoint[0];
currentPointAsPoint[1] = currentPoint[1];
currentPointAsPoint[2] = currentPoint[2];
// Transform the input point in world-coordinates to index-coordinates
DistanceImageType::IndexType currentIndex;
distanceImg->TransformPhysicalPointToIndex( currentPointAsPoint, currentIndex );
assert( lpRegion.IsInside(currentIndex) ); // we are quite certain this should hold
narrowbandPoints.push(currentIndex);
distanceImg->SetPixel(currentIndex, distance);
NeighborhoodImageIterator::RadiusType radius;
radius.Fill(1);
NeighborhoodImageIterator nIt(radius, distanceImg, distanceImg->GetLargestPossibleRegion());
unsigned int relativeNbIdx[] = {4, 10, 12, 14, 16, 22};
bool isInBounds = false;
while ( !narrowbandPoints.empty() )
{
nIt.SetLocation(narrowbandPoints.front());
narrowbandPoints.pop();
unsigned int* relativeNb = &relativeNbIdx[0];
for (int i = 0; i < 6; i++)
{
nIt.GetPixel(*relativeNb, isInBounds);
if( isInBounds && nIt.GetPixel(*relativeNb) == 10)
{
currentIndex = nIt.GetIndex(*relativeNb);
// Transform the currently checked point from index-coordinates to
// world-coordinates
distanceImg->TransformIndexToPhysicalPoint( currentIndex, currentPointAsPoint );
// create a vnl_vector
currentPoint[0] = currentPointAsPoint[0];
currentPoint[1] = currentPointAsPoint[1];
currentPoint[2] = currentPointAsPoint[2];
// and check the distance
distance = this->CalculateDistanceValue(currentPoint);
- if ( abs(distance) <= m_DistanceImageSpacing*2 )
+ if ( abs(distance) <= m_DistanceImageSpacing )
{
nIt.SetPixel(*relativeNb, distance);
narrowbandPoints.push(currentIndex);
}
}
relativeNb++;
}
}
ImageIterator imgRegionIterator (distanceImg, distanceImg->GetLargestPossibleRegion());
imgRegionIterator.GoToBegin();
- double prevPixelVal = 1;
+ // Fist we set the border slices of the image to value 1000 so that we can perform a
+ // region growing afterwards starting from the middle of the image
- unsigned int _size[3] = { (unsigned int)(sizeOfRegion[0] - 1), (unsigned int)(sizeOfRegion[1] - 1), (unsigned int)(sizeOfRegion[2] - 1) };
+ DistanceImageType::SizeType reqSize;
- //Set every pixel inside the surface to -10 except the edge point (so that the received surface is closed)
- while (!imgRegionIterator.IsAtEnd()) {
+ reqSize[0] = distanceImg->GetLargestPossibleRegion().GetSize()[0];
+ reqSize[1] = distanceImg->GetLargestPossibleRegion().GetSize()[1];
+ reqSize[2] = 1;
- if ( imgRegionIterator.Get() == 10 && prevPixelVal < 0 )
- {
+ DistanceImageType::IndexType reqStart;
+ reqStart[0] = 0;
+ reqStart[1] = 0;
+ reqStart[2] = 0;
- while (imgRegionIterator.Get() == 10)
- {
- if (imgRegionIterator.GetIndex()[0] == _size[0] || imgRegionIterator.GetIndex()[1] == _size[1] || imgRegionIterator.GetIndex()[2] == _size[2]
- || imgRegionIterator.GetIndex()[0] == 0U || imgRegionIterator.GetIndex()[1] == 0U || imgRegionIterator.GetIndex()[2] == 0U )
- {
- imgRegionIterator.Set(10);
- prevPixelVal = 10;
- ++imgRegionIterator;
- break;
- }
- else
- {
- imgRegionIterator.Set(-10);
- ++imgRegionIterator;
- prevPixelVal = -10;
- }
+ DistanceImageType::RegionType reqRegion;
- }
+ reqRegion.SetSize(reqSize);
+ reqRegion.SetIndex(reqStart);
- }
- else if (imgRegionIterator.GetIndex()[0] == _size[0] || imgRegionIterator.GetIndex()[1] == _size[1] || imgRegionIterator.GetIndex()[2] == _size[2]
- || imgRegionIterator.GetIndex()[0] == 0U || imgRegionIterator.GetIndex()[1] == 0U || imgRegionIterator.GetIndex()[2] == 0U)
+ this->FillImageRegion(reqRegion, 1000, distanceImg);
+
+ reqStart[0] = 0;
+ reqStart[1] = 0;
+ reqStart[2] = distanceImg->GetLargestPossibleRegion().GetSize()[2]-1;
+
+ reqRegion.SetIndex(reqStart);
+
+ this->FillImageRegion(reqRegion, 1000, distanceImg);
+
+ reqSize[0] = 1;
+ reqSize[1] = distanceImg->GetLargestPossibleRegion().GetSize()[1];
+ reqSize[2] = distanceImg->GetLargestPossibleRegion().GetSize()[2];;
+
+ reqStart[0] = 0;
+ reqStart[1] = 0;
+ reqStart[2] = 0;
+
+ reqRegion.SetSize(reqSize);
+ reqRegion.SetIndex(reqStart);
+
+ this->FillImageRegion(reqRegion, 1000, distanceImg);
+
+ reqStart[0] = distanceImg->GetLargestPossibleRegion().GetSize()[0]-1;
+ reqStart[1] = 0;
+ reqStart[2] = 0;
+
+ reqRegion.SetIndex(reqStart);
+
+ this->FillImageRegion(reqRegion, 1000, distanceImg);
+
+ reqSize[0] = distanceImg->GetLargestPossibleRegion().GetSize()[0];
+ reqSize[1] = 1;
+ reqSize[2] = distanceImg->GetLargestPossibleRegion().GetSize()[2];;
+
+ reqStart[0] = 0;
+ reqStart[1] = 0;
+ reqStart[2] = 0;
+
+ reqRegion.SetSize(reqSize);
+ reqRegion.SetIndex(reqStart);
+
+ this->FillImageRegion(reqRegion, 1000, distanceImg);
+
+ reqStart[0] = 0;
+ reqStart[1] = distanceImg->GetLargestPossibleRegion().GetSize()[1]-1;
+ reqStart[2] = 0;
+
+ reqRegion.SetIndex(reqStart);
+
+ this->FillImageRegion(reqRegion, 1000, distanceImg);
+
+ // Now we make some kind of region growing from the middle of the image to set all
+ // inner pixels to -10. In this way we assure to extract a valid surface
+ NeighborhoodImageIterator nIt2(radius, distanceImg, distanceImg->GetLargestPossibleRegion());
+
+ currentIndex[0] = distanceImg->GetLargestPossibleRegion().GetSize()[0]*0.5;
+ currentIndex[1] = distanceImg->GetLargestPossibleRegion().GetSize()[1]*0.5;
+ currentIndex[2] = distanceImg->GetLargestPossibleRegion().GetSize()[2]*0.5;
+
+ narrowbandPoints.push(currentIndex);
+ distanceImg->SetPixel(currentIndex, -10);
+
+ while ( !narrowbandPoints.empty() )
+ {
+
+ nIt2.SetLocation(narrowbandPoints.front());
+ narrowbandPoints.pop();
+
+ for (int i = 0; i < 6; i++)
{
- imgRegionIterator.Set(10);
- prevPixelVal = 10;
- ++imgRegionIterator;
- }
- else {
- prevPixelVal = imgRegionIterator.Get();
- ++imgRegionIterator;
+ if( nIt2.GetPixel(relativeNbIdx[i]) == 10)
+ {
+ currentIndex = nIt2.GetIndex(relativeNbIdx[i]);
+ nIt2.SetPixel(relativeNbIdx[i], -10);
+ narrowbandPoints.push(currentIndex);
+ }
}
-
}
Image::Pointer resultImage = this->GetOutput();
// Cast the created distance-Image from itk::Image to the mitk::Image
// that is our output.
CastToMitkImage(distanceImg, resultImage);
}
+void mitk::CreateDistanceImageFromSurfaceFilter::FillImageRegion(DistanceImageType::RegionType reqRegion,
+ DistanceImageType::PixelType pixelValue, DistanceImageType::Pointer image)
+{
+ image->SetRequestedRegion(reqRegion);
+ ImageIterator it (image, image->GetRequestedRegion());
+ while (!it.IsAtEnd())
+ {
+ it.Set(pixelValue);
+ ++it;
+ }
+
+}
+
double mitk::CreateDistanceImageFromSurfaceFilter::CalculateDistanceValue(PointType p)
{
double distanceValue (0);
PointType p1;
PointType p2;
double norm;
CenterList::iterator centerIter;
InterpolationWeights::iterator weightsIter;
for ( centerIter=m_Centers.begin(), weightsIter=m_Weights.begin();
centerIter!=m_Centers.end(), weightsIter!=m_Weights.end();
centerIter++, weightsIter++ )
{
p1 = *centerIter;
p2 = p-p1;
norm = p2.two_norm();
distanceValue = distanceValue + norm* (*weightsIter);
}
return distanceValue;
}
void mitk::CreateDistanceImageFromSurfaceFilter::GenerateOutputInformation()
{
}
void mitk::CreateDistanceImageFromSurfaceFilter::PrintEquationSystem()
{
std::ofstream esfile;
esfile.open("C:/Users/fetzer/Desktop/equationSystem/es.txt");
esfile<<"Nummber of rows: "<<m_SolutionMatrix.rows()<<" ****** Number of columns: "<<m_SolutionMatrix.columns()<<endl;
esfile<<"[ ";
for (unsigned int i = 0; i < m_SolutionMatrix.rows(); i++)
{
for (unsigned int j = 0; j < m_SolutionMatrix.columns(); j++)
{
esfile<<m_SolutionMatrix(i,j)<<" ";
}
esfile<<";"<<endl;
}
esfile<<" ]";
esfile.close();
std::ofstream centersFile;
centersFile.open("C:/Users/fetzer/Desktop/equationSystem/centers.txt");
for (unsigned int i = 0; i < m_Centers.size(); i++)
{
centersFile<<m_Centers.at(i)<<";"<<endl;
}
centersFile.close();
}
void mitk::CreateDistanceImageFromSurfaceFilter::SetInput( const mitk::Surface* surface )
{
this->SetInput( 0, const_cast<mitk::Surface*>( surface ) );
}
void mitk::CreateDistanceImageFromSurfaceFilter::SetInput( unsigned int idx, const mitk::Surface* surface )
{
if ( this->GetInput(idx) != surface )
{
this->SetNthInput( idx, const_cast<mitk::Surface*>( surface ) );
this->Modified();
}
}
const mitk::Surface* mitk::CreateDistanceImageFromSurfaceFilter::GetInput()
{
- if (this->GetNumberOfInputs() < 1)
+ if (this->GetNumberOfIndexedInputs() < 1)
return NULL;
return static_cast<const mitk::Surface*>(this->ProcessObject::GetInput(0));
}
const mitk::Surface* mitk::CreateDistanceImageFromSurfaceFilter::GetInput( unsigned int idx)
{
- if (this->GetNumberOfInputs() < 1)
+ if (this->GetNumberOfIndexedInputs() < 1)
return NULL;
return static_cast<const mitk::Surface*>(this->ProcessObject::GetInput(idx));
}
void mitk::CreateDistanceImageFromSurfaceFilter::RemoveInputs(mitk::Surface* input)
{
- this->RemoveInput(input);
+ DataObjectPointerArraySizeType nb = this->GetNumberOfIndexedInputs();
+
+ for(DataObjectPointerArraySizeType i = 0; i < nb; i++)
+ {
+ if( this->GetInput(i) == input )
+ {
+ this->RemoveInput(i);
+ return;
+ }
+ }
}
void mitk::CreateDistanceImageFromSurfaceFilter::Reset()
{
- for (unsigned int i = 0; i < this->GetNumberOfInputs(); i++)
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); i++)
{
this->PopBackInput();
}
- this->SetNumberOfInputs(0);
- this->SetNumberOfOutputs(1);
+ this->SetNumberOfIndexedInputs(0);
+ this->SetNumberOfIndexedOutputs(1);
+
+ mitk::Image::Pointer output = mitk::Image::New();
+ this->SetNthOutput(0, output.GetPointer());
}
void mitk::CreateDistanceImageFromSurfaceFilter::SetUseProgressBar(bool status)
{
this->m_UseProgressBar = status;
}
void mitk::CreateDistanceImageFromSurfaceFilter::SetProgressStepSize(unsigned int stepSize)
{
this->m_ProgressStepSize = stepSize;
}
void mitk::CreateDistanceImageFromSurfaceFilter::SetReferenceImage( itk::ImageBase<3>::Pointer referenceImage )
{
m_ReferenceImage = referenceImage;
}
void mitk::CreateDistanceImageFromSurfaceFilter::DetermineBounds( DistanceImageType::PointType &minPointInWorldCoordinates,
DistanceImageType::PointType &maxPointInWorldCoordinates,
DistanceImageType::IndexType &minPointInIndexCoordinates,
DistanceImageType::IndexType &maxPointInIndexCoordinates )
{
PointType firstCenter = m_Centers.at(0);
DistanceImageType::PointType tmpPoint;
tmpPoint[0] = firstCenter[0];
tmpPoint[1] = firstCenter[1];
tmpPoint[2] = firstCenter[2];
// transform the first point from world-coordinates to index-coordinates
DistanceImageType::IndexType tmpIndex;
m_ReferenceImage->TransformPhysicalPointToIndex( tmpPoint, tmpIndex );
// initialize the variables with this first point
int xmin = tmpIndex[0];
int ymin = tmpIndex[1];
int zmin = tmpIndex[2];
int xmax = tmpIndex[0];
int ymax = tmpIndex[1];
int zmax = tmpIndex[2];
// iterate over the rest of the points
CenterList::iterator centerIter = m_Centers.begin();
for ( ++centerIter; centerIter!=m_Centers.end(); centerIter++)
{
tmpPoint[0] = (*centerIter)[0];
tmpPoint[1] = (*centerIter)[1];
tmpPoint[2] = (*centerIter)[2];
// transform each point from world-coordinates to index-coordinates
m_ReferenceImage->TransformPhysicalPointToIndex( tmpPoint, tmpIndex );
// and set the variables accordingly to find the minimum
// and maximum in all directions in index-coordinates
if (xmin > tmpIndex[0])
{
xmin = tmpIndex[0];
}
if (ymin > tmpIndex[1])
{
ymin = tmpIndex[1];
}
if (zmin > tmpIndex[2])
{
zmin = tmpIndex[2];
}
if (xmax < tmpIndex[0])
{
xmax = tmpIndex[0];
}
if (ymax < tmpIndex[1])
{
ymax = tmpIndex[1];
}
if (zmax < tmpIndex[2])
{
zmax = tmpIndex[2];
}
}
// put the found coordinates into Index-Points
minPointInIndexCoordinates[0] = xmin;
minPointInIndexCoordinates[1] = ymin;
minPointInIndexCoordinates[2] = zmin;
maxPointInIndexCoordinates[0] = xmax;
maxPointInIndexCoordinates[1] = ymax;
maxPointInIndexCoordinates[2] = zmax;
// and transform them into world-coordinates
m_ReferenceImage->TransformIndexToPhysicalPoint( minPointInIndexCoordinates, minPointInWorldCoordinates );
m_ReferenceImage->TransformIndexToPhysicalPoint( maxPointInIndexCoordinates, maxPointInWorldCoordinates );
}
diff --git a/Modules/Segmentation/Algorithms/mitkCreateDistanceImageFromSurfaceFilter.h b/Modules/Segmentation/Algorithms/mitkCreateDistanceImageFromSurfaceFilter.h
index e7c429aea1..755d42b9b8 100644
--- a/Modules/Segmentation/Algorithms/mitkCreateDistanceImageFromSurfaceFilter.h
+++ b/Modules/Segmentation/Algorithms/mitkCreateDistanceImageFromSurfaceFilter.h
@@ -1,189 +1,196 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkCreateDistanceImageFromSurfaceFilter_h_Included
#define mitkCreateDistanceImageFromSurfaceFilter_h_Included
#include "SegmentationExports.h"
#include "mitkImageSource.h"
#include "mitkSurface.h"
#include "mitkProgressBar.h"
#include "vtkSmartPointer.h"
#include "vtkDoubleArray.h"
#include "vtkCellArray.h"
#include "vtkCellData.h"
#include "vtkPolyData.h"
#include "vnl/vnl_matrix.h"
#include "vnl/vnl_vector.h"
#include "vnl/vnl_vector_fixed.h"
#include "vnl/algo/vnl_qr.h"
#include "itkImageBase.h"
#include "itkImageRegionIteratorWithIndex.h"
#include "itkNeighborhoodIterator.h"
#include <queue>
namespace mitk {
/**
\brief This filter interpolates the 3D surface for a segmented area. The basis for the interpolation
are the edge-points of contours that are drawn into an image.
The interpolation itself is performed via Radial Basis Function Interpolation.
ATTENTION:
This filter needs beside the edge points of the delineated contours additionally the normals for each
edge point.
\sa mitkSurfaceInterpolationController
Based on the contour edge points and their normal this filter calculates a distance function with the following
properties:
- Putting a point into the distance function that lies inside the considered surface gives a negativ scalar value
- Putting a point into the distance function that lies outside the considered surface gives a positive scalar value
- Putting a point into the distance function that lies exactly on the considered surface gives the value zero
With this interpolated distance function a distance image will be created. The desired surface can then be extract e.g.
with the marching cubes algorithm. (Within the distance image the surface goes exactly where the pixelvalues are zero)
Note that the obtained distance image has always an isotropig spacing. The size (in this case volume) of the image can be
adjusted by calling SetDistanceImageVolume(unsigned int volume) which specifies the number ob pixels enclosed by the image.
\ingroup Process
$Author: fetzer$
*/
class Segmentation_EXPORT CreateDistanceImageFromSurfaceFilter : public ImageSource
{
public:
typedef vnl_vector_fixed<double,3> PointType;
typedef itk::Image<double, 3> DistanceImageType;
//typedef DistanceImageType::PointType PointType;
typedef DistanceImageType::IndexType IndexType;
typedef std::vector< PointType > NormalList;
typedef std::vector< PointType > CenterList;
typedef vnl_matrix<double> SolutionMatrix;
typedef vnl_vector<double> FunctionValues;
typedef vnl_vector<double> InterpolationWeights;
typedef std::vector<Surface::Pointer> SurfaceList;
+ typedef itk::Image<double, 3> DistanceImageType;
+ typedef itk::ImageRegionIteratorWithIndex<DistanceImageType> ImageIterator;
+ typedef itk::NeighborhoodIterator<DistanceImageType> NeighborhoodImageIterator;
+
mitkClassMacro(CreateDistanceImageFromSurfaceFilter,ImageSource);
itkNewMacro(Self);
//Methods copied from mitkSurfaceToSurfaceFilter
virtual void SetInput( const mitk::Surface* surface );
virtual void SetInput( unsigned int idx, const mitk::Surface* surface );
virtual const mitk::Surface* GetInput();
virtual const mitk::Surface* GetInput( unsigned int idx );
virtual void RemoveInputs(mitk::Surface* input);
/**
\brief Set the size of the output distance image. The size is specified by the image's volume
(i.e. in this case how many pixels are enclosed by the image)
If non is set, the volume will be 500000 pixels.
*/
itkSetMacro(DistanceImageVolume, unsigned int);
void PrintEquationSystem();
//Resets the filter, i.e. removes all inputs and outputs
void Reset();
/**
\brief Set whether the mitkProgressBar should be used
\a Parameter true for using the progress bar, false otherwise
*/
void SetUseProgressBar(bool);
/**
\brief Set the stepsize which the progress bar should proceed
\a Parameter The stepsize for progressing
*/
void SetProgressStepSize(unsigned int stepSize);
void SetReferenceImage( itk::ImageBase<3>::Pointer referenceImage );
protected:
CreateDistanceImageFromSurfaceFilter();
virtual ~CreateDistanceImageFromSurfaceFilter();
virtual void GenerateData();
virtual void GenerateOutputInformation();
private:
void CreateSolutionMatrixAndFunctionValues();
double CalculateDistanceValue(PointType p);
void CreateDistanceImage ();
/**
* \brief This method fills the given variables with the minimum and
* maximum coordinates that contain all input-points in index- and
* world-coordinates.
*
* This method iterates over all input-points and transforms them from
* world-coordinates to index-coordinates using the transform of the
* reference-Image.
* Next, the minimal and maximal index-coordinates are determined that
* span an area that contains all given input-points.
* These index-coordinates are then transformed back to world-coordinates.
*
* These minimal and maximal points are then set to the given variables.
*/
void DetermineBounds( DistanceImageType::PointType &minPointInWorldCoordinates,
DistanceImageType::PointType &maxPointInWorldCoordinates,
DistanceImageType::IndexType &minPointInIndexCoordinates,
DistanceImageType::IndexType &maxPointInIndexCoordinates );
+
+ void FillImageRegion(DistanceImageType::RegionType reqRegion, DistanceImageType::PixelType pixelValue, DistanceImageType::Pointer image);
+
//Datastructures for the interpolation
CenterList m_Centers;
NormalList m_Normals;
FunctionValues m_FunctionValues;
InterpolationWeights m_Weights;
SolutionMatrix m_SolutionMatrix;
double m_DistanceImageSpacing;
itk::ImageBase<3>::Pointer m_ReferenceImage;
unsigned int m_DistanceImageVolume;
bool m_UseProgressBar;
unsigned int m_ProgressStepSize;
};
}//namespace
#endif
diff --git a/Modules/Segmentation/Algorithms/mitkDiffImageApplier.cpp b/Modules/Segmentation/Algorithms/mitkDiffImageApplier.cpp
index bbf640f070..360e21c1b8 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffImageApplier.cpp
+++ b/Modules/Segmentation/Algorithms/mitkDiffImageApplier.cpp
@@ -1,331 +1,331 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkDiffImageApplier.h"
#include "mitkImageCast.h"
#include "mitkImageAccessByItk.h"
#include "mitkApplyDiffImageOperation.h"
#include "mitkRenderingManager.h"
#include "mitkSegmentationInterpolationController.h"
#include "mitkImageTimeSelector.h"
#include <itkImageSliceIteratorWithIndex.h>
#include <itkImageRegionConstIterator.h>
mitk::DiffImageApplier::DiffImageApplier()
{
}
mitk::DiffImageApplier::~DiffImageApplier()
{
}
void mitk::DiffImageApplier::ExecuteOperation( Operation* operation )
{
ApplyDiffImageOperation* imageOperation = dynamic_cast<ApplyDiffImageOperation*>( operation );
if ( imageOperation // we actually have the kind of operation that we can handle
&& imageOperation->IsImageStillValid() ) // AND the image is not yet deleted
{
m_Image = imageOperation->GetImage();
Image::Pointer image3D = m_Image; // will be changed later in case of 3D+t
m_SliceDifferenceImage = imageOperation->GetDiffImage();
m_TimeStep = imageOperation->GetTimeStep();
m_Factor = imageOperation->GetFactor();
if ( m_SliceDifferenceImage->GetDimension() == 2 )
{
m_SliceIndex = imageOperation->GetSliceIndex();
m_SliceDimension = imageOperation->GetSliceDimension();
switch (m_SliceDimension)
{
default:
case 2:
m_Dimension0 = 0;
m_Dimension1 = 1;
break;
case 1:
m_Dimension0 = 0;
m_Dimension1 = 2;
break;
case 0:
m_Dimension0 = 1;
m_Dimension1 = 2;
break;
}
if ( m_SliceDifferenceImage->GetDimension() != 2 || (m_Image->GetDimension() < 3 || m_Image->GetDimension() > 4) ||
m_SliceDifferenceImage->GetDimension(0) != m_Image->GetDimension(m_Dimension0) ||
m_SliceDifferenceImage->GetDimension(1) != m_Image->GetDimension(m_Dimension1) ||
m_SliceIndex >= m_Image->GetDimension(m_SliceDimension)
)
{
itkExceptionMacro("Slice and image dimensions differ or slice index is too large. Sorry, cannot work like this.");
return;
}
if ( m_Image->GetDimension() == 4 )
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( m_Image );
timeSelector->SetTimeNr( m_TimeStep );
timeSelector->UpdateLargestPossibleRegion();
image3D = timeSelector->GetOutput();
}
// this will do a long long if/else to find out both pixel types
AccessFixedDimensionByItk( image3D, ItkImageSwitch2DDiff, 3 );
if ( m_Factor == 1 || m_Factor == -1 )
{
if ( m_Factor == -1 )
{
// multiply diff pixels by factor and then send this diff slice
AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 2 );
}
// just send the diff to SegmentationInterpolationController
SegmentationInterpolationController* interpolator = SegmentationInterpolationController::InterpolatorForImage( m_Image );
if (interpolator)
{
interpolator->BlockModified(true);
interpolator->SetChangedSlice( m_SliceDifferenceImage, m_SliceDimension, m_SliceIndex, m_TimeStep );
}
m_Image->Modified();
if (interpolator)
{
interpolator->BlockModified(false);
}
if ( m_Factor == -1 ) // return to normal values
{
AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 2 );
}
}
else // no trivial case, too lazy to do something else
{
m_Image->Modified(); // check if interpolation is called. prefer to send diff directly
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
else if ( m_SliceDifferenceImage->GetDimension() == 3 )
{
// ...
if ( m_SliceDifferenceImage->GetDimension(0) != m_Image->GetDimension(0) ||
m_SliceDifferenceImage->GetDimension(1) != m_Image->GetDimension(1) ||
m_SliceDifferenceImage->GetDimension(2) != m_Image->GetDimension(2) ||
m_TimeStep >= m_Image->GetDimension(3)
)
{
itkExceptionMacro("Diff image size differs from original image size. Sorry, cannot work like this.");
return;
}
if ( m_Image->GetDimension() == 4 )
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( m_Image );
timeSelector->SetTimeNr( m_TimeStep );
timeSelector->UpdateLargestPossibleRegion();
image3D = timeSelector->GetOutput();
}
// this will do a long long if/else to find out both pixel types
AccessFixedDimensionByItk( image3D, ItkImageSwitch3DDiff, 3 );
if ( m_Factor == 1 || m_Factor == -1 )
{
if ( m_Factor == -1 )
{
// multiply diff pixels by factor and then send this diff slice
AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 3 );
}
// just send the diff to SegmentationInterpolationController
SegmentationInterpolationController* interpolator = SegmentationInterpolationController::InterpolatorForImage( m_Image );
if (interpolator)
{
interpolator->BlockModified(true);
interpolator->SetChangedVolume( m_SliceDifferenceImage, m_TimeStep );
}
m_Image->Modified();
if (interpolator)
{
interpolator->BlockModified(false);
}
if ( m_Factor == -1 ) // return to normal values
{
AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 3 );
}
}
else // no trivial case, too lazy to do something else
{
m_Image->Modified(); // check if interpolation is called. prefer to send diff directly
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
else
{
itkExceptionMacro("Diff image must be 2D or 3D. Sorry, cannot work like this.");
return;
}
}
m_Image = NULL;
m_SliceDifferenceImage = NULL;
}
mitk::DiffImageApplier* mitk::DiffImageApplier::GetInstanceForUndo()
{
static DiffImageApplier::Pointer s_Instance = DiffImageApplier::New();
return s_Instance;
}
// basically copied from mitk/Core/Algorithms/mitkImageAccessByItk.h
#define myMITKDiffImageApplierFilterAccessByItk(mitkImage, itkImageTypeFunction, pixeltype, dimension, itkimage2) \
- if ( typeId == typeid(pixeltype) ) \
+ if ( typeId == MapPixelComponentType<pixeltype>::value ) \
{ \
typedef itk::Image<pixeltype, dimension> ImageType; \
typedef mitk::ImageToItk<ImageType> ImageToItkType; \
itk::SmartPointer<ImageToItkType> imagetoitk = ImageToItkType::New(); \
const mitk::Image* constImage = mitkImage; \
mitk::Image* nonConstImage = const_cast<mitk::Image*>(constImage); \
nonConstImage->Update(); \
imagetoitk->SetInput(nonConstImage); \
imagetoitk->Update(); \
itkImageTypeFunction(imagetoitk->GetOutput(), itkimage2); \
}
#define myMITKDiffImageApplierFilterAccessAllTypesByItk(mitkImage, itkImageTypeFunction, dimension, itkimage2) \
{ \
myMITKDiffImageApplierFilterAccessByItk(mitkImage, itkImageTypeFunction, double, dimension, itkimage2) else \
myMITKDiffImageApplierFilterAccessByItk(mitkImage, itkImageTypeFunction, float, dimension, itkimage2) else \
myMITKDiffImageApplierFilterAccessByItk(mitkImage, itkImageTypeFunction, int, dimension, itkimage2) else \
myMITKDiffImageApplierFilterAccessByItk(mitkImage, itkImageTypeFunction, unsigned int, dimension, itkimage2) else \
myMITKDiffImageApplierFilterAccessByItk(mitkImage, itkImageTypeFunction, short, dimension, itkimage2) else \
myMITKDiffImageApplierFilterAccessByItk(mitkImage, itkImageTypeFunction, unsigned short, dimension, itkimage2) else \
myMITKDiffImageApplierFilterAccessByItk(mitkImage, itkImageTypeFunction, char, dimension, itkimage2) else \
myMITKDiffImageApplierFilterAccessByItk(mitkImage, itkImageTypeFunction, unsigned char, dimension, itkimage2) \
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::DiffImageApplier::ItkImageSwitch2DDiff( itk::Image<TPixel,VImageDimension>* itkImage )
{
- const std::type_info& typeId=m_SliceDifferenceImage->GetPixelType().GetTypeId();
+ const int typeId=m_SliceDifferenceImage->GetPixelType().GetComponentType();
myMITKDiffImageApplierFilterAccessAllTypesByItk( m_SliceDifferenceImage, ItkImageProcessing2DDiff, 2, itkImage );
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::DiffImageApplier::ItkImageSwitch3DDiff( itk::Image<TPixel,VImageDimension>* itkImage )
{
- const std::type_info& typeId=m_SliceDifferenceImage->GetPixelType().GetTypeId();
+ const int typeId=m_SliceDifferenceImage->GetPixelType().GetComponentType();
myMITKDiffImageApplierFilterAccessAllTypesByItk( m_SliceDifferenceImage, ItkImageProcessing3DDiff, 3, itkImage );
}
template<typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
void mitk::DiffImageApplier::ItkImageProcessing2DDiff( itk::Image<TPixel1,VImageDimension1>* diffImage, itk::Image<TPixel2,VImageDimension2>* outputImage )
{
typedef itk::Image<TPixel1, VImageDimension1> DiffImageType;
typedef itk::Image<TPixel2, VImageDimension2> VolumeImageType;
typedef itk::ImageSliceIteratorWithIndex< VolumeImageType > OutputSliceIteratorType;
typedef itk::ImageRegionConstIterator< DiffImageType > DiffSliceIteratorType;
typename VolumeImageType::RegionType sliceInVolumeRegion;
sliceInVolumeRegion = outputImage->GetLargestPossibleRegion();
sliceInVolumeRegion.SetSize( m_SliceDimension, 1 ); // just one slice
sliceInVolumeRegion.SetIndex( m_SliceDimension, m_SliceIndex ); // exactly this slice, please
OutputSliceIteratorType outputIterator( outputImage, sliceInVolumeRegion );
outputIterator.SetFirstDirection(m_Dimension0);
outputIterator.SetSecondDirection(m_Dimension1);
DiffSliceIteratorType diffIterator( diffImage, diffImage->GetLargestPossibleRegion() );
// iterate over output slice (and over input slice simultaneously)
outputIterator.GoToBegin();
diffIterator.GoToBegin();
while ( !outputIterator.IsAtEnd() )
{
while ( !outputIterator.IsAtEndOfSlice() )
{
while ( !outputIterator.IsAtEndOfLine() )
{
TPixel2 newValue = outputIterator.Get() + (TPixel2) ((double)diffIterator.Get() * m_Factor);
outputIterator.Set( newValue );
++outputIterator;
++diffIterator;
}
outputIterator.NextLine();
}
outputIterator.NextSlice();
}
}
template<typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
void mitk::DiffImageApplier::ItkImageProcessing3DDiff( itk::Image<TPixel1,VImageDimension1>* diffImage, itk::Image<TPixel2,VImageDimension2>* outputImage )
{
typedef itk::Image<TPixel1, VImageDimension1> DiffImageType;
typedef itk::Image<TPixel2, VImageDimension2> VolumeImageType;
typedef itk::ImageRegionIterator< VolumeImageType > OutputSliceIteratorType;
typedef itk::ImageRegionConstIterator< DiffImageType > DiffSliceIteratorType;
OutputSliceIteratorType outputIterator( outputImage, outputImage->GetLargestPossibleRegion() );
DiffSliceIteratorType diffIterator( diffImage, diffImage->GetLargestPossibleRegion() );
// iterate over output slice (and over input slice simultaneously)
outputIterator.GoToBegin();
diffIterator.GoToBegin();
while ( !outputIterator.IsAtEnd() )
{
TPixel2 newValue = outputIterator.Get() + (TPixel2) ((double)diffIterator.Get() * m_Factor);
outputIterator.Set( newValue );
++outputIterator;
++diffIterator;
}
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::DiffImageApplier::ItkInvertPixelValues( itk::Image<TPixel,VImageDimension>* itkImage )
{
typedef itk::ImageRegionIterator< itk::Image<TPixel,VImageDimension> > IteratorType;
IteratorType iter( itkImage, itkImage->GetLargestPossibleRegion() );
iter.GoToBegin();
while ( !iter.IsAtEnd() )
{
iter.Set( -( iter.Get() ) );
++iter;
}
}
diff --git a/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.cpp b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.cpp
new file mode 100644
index 0000000000..69094bfa56
--- /dev/null
+++ b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.cpp
@@ -0,0 +1,416 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkImageLiveWireContourModelFilter.h"
+
+
+#include <itkImageRegionIterator.h>
+#include <itkCastImageFilter.h>
+#include <itkGradientMagnitudeImageFilter.h>
+
+
+mitk::ImageLiveWireContourModelFilter::ImageLiveWireContourModelFilter()
+{
+ OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
+ this->SetNumberOfRequiredInputs(1);
+ this->SetNumberOfOutputs( 1 );
+ this->SetNthOutput(0, output.GetPointer());
+ m_CostFunction = ImageLiveWireContourModelFilter::CostFunctionType::New();
+ m_ShortestPathFilter = ShortestPathImageFilterType::New();
+ m_ShortestPathFilter->SetCostFunction(m_CostFunction);
+ m_UseDynamicCostMap = false;
+ m_ImageModified = false;
+ m_Timestep = 0;
+}
+
+mitk::ImageLiveWireContourModelFilter::~ImageLiveWireContourModelFilter()
+{
+
+}
+
+
+mitk::ImageLiveWireContourModelFilter::OutputType* mitk::ImageLiveWireContourModelFilter::GetOutput()
+{
+ return Superclass::GetOutput();
+}
+
+void mitk::ImageLiveWireContourModelFilter::SetInput ( const mitk::ImageLiveWireContourModelFilter::InputType* input )
+{
+ this->SetInput( 0, input );
+}
+
+void mitk::ImageLiveWireContourModelFilter::SetInput ( unsigned int idx, const mitk::ImageLiveWireContourModelFilter::InputType* input )
+{
+ if ( idx + 1 > this->GetNumberOfInputs() )
+ {
+ this->SetNumberOfRequiredInputs(idx + 1);
+ }
+ if ( input != static_cast<InputType*> ( this->ProcessObject::GetInput ( idx ) ) )
+ {
+ this->ProcessObject::SetNthInput ( idx, const_cast<InputType*> ( input ) );
+ this->Modified();
+ this->m_ImageModified = true;
+ m_ShortestPathFilter = ShortestPathImageFilterType::New();
+ m_ShortestPathFilter->SetCostFunction(m_CostFunction);
+ }
+}
+
+
+
+const mitk::ImageLiveWireContourModelFilter::InputType* mitk::ImageLiveWireContourModelFilter::GetInput( void )
+{
+ if (this->GetNumberOfInputs() < 1)
+ return NULL;
+ return static_cast<const mitk::ImageLiveWireContourModelFilter::InputType*>(this->ProcessObject::GetInput(0));
+}
+
+
+const mitk::ImageLiveWireContourModelFilter::InputType* mitk::ImageLiveWireContourModelFilter::GetInput( unsigned int idx )
+{
+ if (this->GetNumberOfInputs() < 1)
+ return NULL;
+ return static_cast<const mitk::ImageLiveWireContourModelFilter::InputType*>(this->ProcessObject::GetInput(idx));
+}
+
+
+void mitk::ImageLiveWireContourModelFilter::GenerateData()
+{
+ mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
+
+ if(!input)
+ {
+ MITK_ERROR << "No input available.";
+ itkExceptionMacro("mitk::ImageToLiveWireContourFilter: No input available. Please set the input!");
+ return;
+ }
+
+ if( input->GetDimension() != 2 )
+ {
+ MITK_ERROR << "Filter is only working on 2D images.";
+ itkExceptionMacro("mitk::ImageToLiveWireContourFilter: Filter is only working on 2D images.. Please make sure that the input is 2D!");
+ return;
+ }
+
+
+ input->GetGeometry()->WorldToIndex(m_StartPoint, m_StartPointInIndex);
+ input->GetGeometry()->WorldToIndex(m_EndPoint, m_EndPointInIndex);
+
+ //only start calculating if both indices are inside image geometry
+ if( input->GetGeometry()->IsIndexInside(this->m_StartPointInIndex) && input->GetGeometry()->IsIndexInside(this->m_EndPointInIndex) )
+ {
+ AccessFixedDimensionByItk(input, ItkProcessImage, 2);
+ m_ImageModified = false;
+ }
+}
+
+
+
+template<typename TPixel, unsigned int VImageDimension>
+void mitk::ImageLiveWireContourModelFilter::ItkProcessImage (itk::Image<TPixel, VImageDimension>* inputImage)
+{
+ typedef itk::Image< TPixel, VImageDimension > InputImageType;
+ typedef typename InputImageType::IndexType IndexType;
+
+
+ /* compute the requested region for itk filters */
+
+ IndexType startPoint, endPoint;
+
+ startPoint[0] = m_StartPointInIndex[0];
+ startPoint[1] = m_StartPointInIndex[1];
+
+ endPoint[0] = m_EndPointInIndex[0];
+ endPoint[1] = m_EndPointInIndex[1];
+
+ //minimum value in each direction for startRegion
+ IndexType startRegion;
+ startRegion[0] = startPoint[0] < endPoint[0] ? startPoint[0] : endPoint[0];
+ startRegion[1] = startPoint[1] < endPoint[1] ? startPoint[1] : endPoint[1];
+
+ //maximum value in each direction for size
+ typename InputImageType::SizeType size;
+ size[0] = abs( startPoint[0] - endPoint[0] );
+ size[1] = abs( startPoint[1] - endPoint[1] );
+
+
+ typename CostFunctionType::RegionType region;
+ region.SetSize( size );
+ region.SetIndex( startRegion );
+ /*---------------------------------------------*/
+
+ //inputImage->SetRequestedRegion(region);
+
+ typedef itk::CastImageFilter< InputImageType, FloatImageType > CastFilterType;
+ typename CastFilterType::Pointer castFilter = CastFilterType::New();
+ castFilter->SetInput(inputImage);
+ castFilter->Update();
+ /* extracts features from image and calculates costs */
+ if( m_ImageModified )
+ m_CostFunction->SetImage(castFilter->GetOutput());
+ m_CostFunction->SetStartIndex(startPoint);
+ m_CostFunction->SetEndIndex(endPoint);
+ m_CostFunction->SetRequestedRegion(region);
+ m_CostFunction->SetUseCostMap(m_UseDynamicCostMap);
+ /*---------------------------------------------*/
+
+
+ /* calculate shortest path between start and end point */
+ m_ShortestPathFilter->SetFullNeighborsMode(true);
+ m_ShortestPathFilter->SetInput(castFilter->GetOutput());
+ m_ShortestPathFilter->SetMakeOutputImage(false);
+
+ //m_ShortestPathFilter->SetCalcAllDistances(true);
+ m_ShortestPathFilter->SetStartIndex(startPoint);
+ m_ShortestPathFilter->SetEndIndex(endPoint);
+
+
+ m_ShortestPathFilter->Update();
+
+ /*---------------------------------------------*/
+
+
+ /* construct contour from path image */
+ //get the shortest path as vector
+ typename std::vector< ShortestPathImageFilterType::IndexType> shortestPath = m_ShortestPathFilter->GetVectorPath();
+
+ //fill the output contour with controll points from the path
+ OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
+ this->SetNthOutput(0, output.GetPointer());
+
+ output->Expand(m_Timestep+1);
+
+ mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
+
+ typename std::vector< ShortestPathImageFilterType::IndexType>::iterator pathIterator = shortestPath.begin();
+
+ while(pathIterator != shortestPath.end())
+ {
+ mitk::Point3D currentPoint;
+ currentPoint[0] = (*pathIterator)[0];
+ currentPoint[1] = (*pathIterator)[1];
+ currentPoint[2] = 0;
+
+
+ input->GetGeometry()->IndexToWorld(currentPoint, currentPoint);
+ output->AddVertex(currentPoint, false, m_Timestep);
+
+ pathIterator++;
+ }
+ /*---------------------------------------------*/
+}
+
+bool mitk::ImageLiveWireContourModelFilter::CreateDynamicCostMap(mitk::ContourModel* path)
+{
+ mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
+ if(input)
+ {
+ AccessFixedDimensionByItk_1(input,CreateDynamicCostMapByITK, 2, path);
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+
+
+template<typename TPixel, unsigned int VImageDimension>
+void mitk::ImageLiveWireContourModelFilter::CreateDynamicCostMapByITK( itk::Image<TPixel, VImageDimension>* inputImage, mitk::ContourModel* path )
+{
+ /*++++++++++ create dynamic cost transfer map ++++++++++*/
+
+ /* Compute the costs of the gradient magnitude dynamically.
+ * using a map of the histogram of gradient magnitude image.
+ * Use the histogram gradient map to interpolate the costs
+ * with gaussing function including next two bins right and left
+ * to current position x. With the histogram gradient costs are interpolated
+ * with a gaussing function summation of next two bins right and left
+ * to current position x.
+ */
+ std::vector< itk::Index<VImageDimension> > shortestPath;
+
+ mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
+ if(path == NULL)
+ {
+ OutputType::Pointer output = this->GetOutput();
+ mitk::ContourModel::VertexIterator it = output->IteratorBegin();
+ while( it != output->IteratorEnd() )
+ {
+ itk::Index<VImageDimension> cur;
+ mitk::Point3D c = (*it)->Coordinates;
+ input->GetGeometry()->WorldToIndex(c, c);
+ cur[0] = c[0];
+ cur[1] = c[1];
+
+ shortestPath.push_back( cur);
+ it++;
+ }
+ }
+ else
+ {
+
+ mitk::ContourModel::VertexIterator it = path->IteratorBegin();
+ while( it != path->IteratorEnd() )
+ {
+ itk::Index<VImageDimension> cur;
+ mitk::Point3D c = (*it)->Coordinates;
+ input->GetGeometry()->WorldToIndex(c, c);
+ cur[0] = c[0];
+ cur[1] = c[1];
+
+ shortestPath.push_back( cur);
+ it++;
+ }
+
+ }
+
+
+ /*+++ filter image gradient magnitude +++*/
+ typedef itk::GradientMagnitudeImageFilter< itk::Image<TPixel, VImageDimension>, itk::Image<TPixel, VImageDimension> > GradientMagnitudeFilterType;
+ typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
+ gradientFilter->SetInput(inputImage);
+ gradientFilter->Update();
+ typename itk::Image<TPixel, VImageDimension>::Pointer gradientMagnImage = gradientFilter->GetOutput();
+
+ //get the path
+
+
+ //iterator of path
+ typename std::vector< itk::Index<VImageDimension> >::iterator pathIterator = shortestPath.begin();
+
+ std::map< int, int > histogram;
+
+ //create histogram within path
+ while(pathIterator != shortestPath.end())
+ {
+ //count pixel values
+ //use scale factor to avoid mapping gradients between 0.0 and 1.0 to same bin
+ histogram[ static_cast<int>( gradientMagnImage->GetPixel((*pathIterator)) * ImageLiveWireContourModelFilter::CostFunctionType::MAPSCALEFACTOR ) ] += 1;
+
+ pathIterator++;
+ }
+
+ double max = 1.0;
+
+ if( !histogram.empty() )
+ {
+
+ std::map< int, int >::iterator itMAX;
+
+ //get max of histogramm
+ int currentMaxValue = 0;
+ std::map< int, int >::iterator it = histogram.begin();
+ while( it != histogram.end())
+ {
+ if((*it).second > currentMaxValue)
+ {
+ itMAX = it;
+ currentMaxValue = (*it).second;
+ }
+ it++;
+ }
+
+
+ std::map< int, int >::key_type keyOfMax = itMAX->first;
+
+
+ /*+++++++++++++++++++++++++ compute the to max of gaussian summation ++++++++++++++++++++++++*/
+ std::map< int, int >::iterator end = histogram.end();
+ std::map< int, int >::iterator last = --(histogram.end());
+
+ std::map< int, int >::iterator left2;
+ std::map< int, int >::iterator left1;
+ std::map< int, int >::iterator right1;
+ std::map< int, int >::iterator right2;
+
+ right1 = itMAX;
+
+
+ if(right1 == end || right1 == last )
+ {
+ right2 = end;
+ }
+ else//( right1 <= last )
+ {
+ std::map< int, int >::iterator temp = right1;
+ right2 = ++right1;//rght1 + 1
+ right1 = temp;
+ }
+
+
+ if( right1 == histogram.begin() )
+ {
+ left1 = end;
+ left2 = end;
+ }
+ else if( right1 == (++(histogram.begin())) )
+ {
+ std::map< int, int >::iterator temp = right1;
+ left1 = --right1;//rght1 - 1
+ right1 = temp;
+ left2 = end;
+ }
+ else
+ {
+ std::map< int, int >::iterator temp = right1;
+ left1 = --right1;//rght1 - 1
+ left2 = --right1;//rght1 - 2
+ right1 = temp;
+ }
+
+ double partRight1, partRight2, partLeft1, partLeft2;
+ partRight1 = partRight2 = partLeft1 = partLeft2 = 0.0;
+
+
+ /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ f(x) = v(bin) * e^ ( -1/2 * (|x-k(bin)| / sigma)^2 )
+
+ gaussian approximation
+
+ where
+ v(bin) is the value in the map
+ k(bin) is the key
+ */
+ if( left2 != end )
+ {
+ partLeft2 = ImageLiveWireContourModelFilter::CostFunctionType::Gaussian(keyOfMax, left2->first, left2->second);
+ }
+
+ if( left1 != end )
+ {
+ partLeft1 = ImageLiveWireContourModelFilter::CostFunctionType::Gaussian(keyOfMax, left1->first, left1->second);
+ }
+
+ if( right1 != end )
+ {
+ partRight1 = ImageLiveWireContourModelFilter::CostFunctionType::Gaussian(keyOfMax, right1->first, right1->second);
+ }
+
+ if( right2 != end )
+ {
+ partRight2 = ImageLiveWireContourModelFilter::CostFunctionType::Gaussian(keyOfMax, right2->first, right2->second);
+ }
+ /*----------------------------------------------------------------------------*/
+
+ max = (partRight1 + partRight2 + partLeft1 + partLeft2);
+
+ }
+
+ this->m_CostFunction->SetDynamicCostMap(histogram);
+ this->m_CostFunction->SetCostMapMaximum(max);
+
+}
diff --git a/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h
new file mode 100644
index 0000000000..74ff4fa4e8
--- /dev/null
+++ b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h
@@ -0,0 +1,153 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef _mitkImageLiveWireContourModelFilter_h__
+#define _mitkImageLiveWireContourModelFilter_h__
+
+#include "mitkCommon.h"
+#include "SegmentationExports.h"
+#include "mitkContourModel.h"
+#include "mitkContourModelSource.h"
+
+#include <mitkImage.h>
+#include <mitkImageAccessByItk.h>
+#include <mitkImageCast.h>
+
+#include <itkShortestPathCostFunctionLiveWire.h>
+#include <itkShortestPathImageFilter.h>
+
+
+namespace mitk {
+
+ /**
+
+ \brief Calculates a LiveWire contour between two points in an image.
+
+ For defining costs between two pixels specific features are extraced from the image and tranformed into a single cost value.
+ \sa ShortestPathCostFunctionLiveWire
+
+ The filter is able to create dynamic cost tranfer map and thus use on the fly training.
+ \Note On the fly training will only be used for next update.
+ The computation uses the last calculated segment to map cost according to features in the area of the segment.
+
+ For time resolved purposes use ImageLiveWireContourModelFilter::SetTimestep( unsigned int ) to create the LiveWire contour
+ at a specific timestep.
+
+ \ingroup ContourModelFilters
+ \ingroup Process
+ */
+ class Segmentation_EXPORT ImageLiveWireContourModelFilter : public ContourModelSource
+ {
+
+ public:
+
+ mitkClassMacro(ImageLiveWireContourModelFilter, ContourModelSource);
+ itkNewMacro(Self);
+
+
+ typedef ContourModel OutputType;
+ typedef OutputType::Pointer OutputTypePointer;
+ typedef mitk::Image InputType;
+
+ typedef itk::Image< float, 2 > FloatImageType;
+ typedef itk::ShortestPathImageFilter< FloatImageType, FloatImageType > ShortestPathImageFilterType;
+ typedef itk::ShortestPathCostFunctionLiveWire< FloatImageType > CostFunctionType;
+
+
+ /** \brief start point in worldcoordinates*/
+ itkSetMacro(StartPoint, mitk::Point3D);
+ itkGetMacro(StartPoint, mitk::Point3D);
+
+ /** \brief end point in woorldcoordinates*/
+ itkSetMacro(EndPoint, mitk::Point3D);
+ itkGetMacro(EndPoint, mitk::Point3D);
+
+ /** \brief Create dynamic cost tranfer map - use on the fly training.
+ \Note On the fly training will be used for next update only.
+ The computation uses the last calculated segment to map cost according to features in the area of the segment.
+ */
+ itkSetMacro(UseDynamicCostMap, bool);
+ itkGetMacro(UseDynamicCostMap, bool);
+
+
+ virtual void SetInput( const InputType *input);
+
+ virtual void SetInput( unsigned int idx, const InputType * input);
+
+ const InputType* GetInput(void);
+
+ const InputType* GetInput(unsigned int idx);
+
+ virtual OutputType* GetOutput();
+
+
+ /** \brief Create dynamic cost tranfer map - on the fly training*/
+ bool CreateDynamicCostMap(mitk::ContourModel* path=NULL);
+
+ void SetTimestep( unsigned int timestep )
+ {
+ m_Timestep = timestep;
+ }
+
+ unsigned int GetTimestep()
+ {
+ return m_Timestep;
+ }
+
+ protected:
+ ImageLiveWireContourModelFilter();
+
+ virtual ~ImageLiveWireContourModelFilter();
+
+ void GenerateOutputInformation() {};
+
+ void GenerateData();
+
+ /** \brief start point in worldcoordinates*/
+ mitk::Point3D m_StartPoint;
+
+ /** \brief end point in woorldcoordinates*/
+ mitk::Point3D m_EndPoint;
+
+ /** \brief Start point in index*/
+ mitk::Point3D m_StartPointInIndex;
+
+ /** \brief End point in index*/
+ mitk::Point3D m_EndPointInIndex;
+
+ /** \brief The cost function to compute costs between two pixels*/
+ CostFunctionType::Pointer m_CostFunction;
+
+ /** \brief Shortest path filter according to cost function m_CostFunction*/
+ ShortestPathImageFilterType::Pointer m_ShortestPathFilter;
+
+ /** \brief Flag to use a dynmic cost map or not*/
+ bool m_UseDynamicCostMap;
+
+ bool m_ImageModified;
+
+ unsigned int m_Timestep;
+
+ template<typename TPixel, unsigned int VImageDimension>
+ void ItkProcessImage (itk::Image<TPixel, VImageDimension>* inputImage);
+
+ template<typename TPixel, unsigned int VImageDimension>
+ void CreateDynamicCostMapByITK(itk::Image<TPixel, VImageDimension>* inputImage, mitk::ContourModel* path=NULL);
+ };
+
+}
+
+#endif
diff --git a/Modules/Segmentation/Algorithms/mitkImageToContourModelFilter.cpp b/Modules/Segmentation/Algorithms/mitkImageToContourModelFilter.cpp
new file mode 100644
index 0000000000..5468ca98c7
--- /dev/null
+++ b/Modules/Segmentation/Algorithms/mitkImageToContourModelFilter.cpp
@@ -0,0 +1,76 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkImageToContourModelFilter.h"
+
+
+
+mitk::ImageToContourModelFilter::ImageToContourModelFilter()
+{
+}
+
+
+
+mitk::ImageToContourModelFilter::~ImageToContourModelFilter()
+{
+
+}
+
+
+
+void mitk::ImageToContourModelFilter::SetInput ( const mitk::ImageToContourModelFilter::InputType* input )
+{
+ this->SetInput( 0, input );
+}
+
+
+
+void mitk::ImageToContourModelFilter::SetInput ( unsigned int idx, const mitk::ImageToContourModelFilter::InputType* input )
+{
+ if ( idx + 1 > this->GetNumberOfInputs() )
+ {
+ this->SetNumberOfRequiredInputs(idx + 1);
+ }
+ if ( input != static_cast<InputType*> ( this->ProcessObject::GetInput ( idx ) ) )
+ {
+ this->ProcessObject::SetNthInput ( idx, const_cast<InputType*> ( input ) );
+ this->Modified();
+ }
+}
+
+
+
+const mitk::ImageToContourModelFilter::InputType* mitk::ImageToContourModelFilter::GetInput( void )
+{
+ if (this->GetNumberOfInputs() < 1)
+ return NULL;
+ return static_cast<const mitk::ImageToContourModelFilter::InputType*>(this->ProcessObject::GetInput(0));
+}
+
+
+
+const mitk::ImageToContourModelFilter::InputType* mitk::ImageToContourModelFilter::GetInput( unsigned int idx )
+{
+ if (this->GetNumberOfInputs() < 1)
+ return NULL;
+ return static_cast<const mitk::ImageToContourModelFilter::InputType*>(this->ProcessObject::GetInput(idx));
+}
+
+
+void mitk::ImageToContourModelFilter::GenerateData()
+{
+
+}
diff --git a/Modules/Segmentation/Algorithms/mitkImageToContourModelFilter.h b/Modules/Segmentation/Algorithms/mitkImageToContourModelFilter.h
new file mode 100644
index 0000000000..40fc5d9a4f
--- /dev/null
+++ b/Modules/Segmentation/Algorithms/mitkImageToContourModelFilter.h
@@ -0,0 +1,66 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef _mitkImageToContourModelFilter_h__
+#define _mitkImageToContourModelFilter_h__
+
+#include "mitkCommon.h"
+#include "SegmentationExports.h"
+#include "mitkContourModel.h"
+#include "mitkContourModelSource.h"
+#include <mitkImage.h>
+
+
+namespace mitk {
+
+ /**
+ *
+ * \brief Base class for all filters with mitk::Image as input and mitk::ContourModel
+ *
+ * \ingroup ContourModelFilters
+ * \ingroup Process
+ */
+ class Segmentation_EXPORT ImageToContourModelFilter : public ContourModelSource
+ {
+
+ public:
+
+ mitkClassMacro(ImageToContourModelFilter, ContourModelSource);
+ itkNewMacro(Self);
+
+ typedef mitk::Image InputType;
+
+
+ virtual void SetInput( const InputType *input);
+
+ virtual void SetInput( unsigned int idx, const InputType * input);
+
+ const InputType* GetInput(void);
+
+ const InputType* GetInput(unsigned int idx);
+
+ protected:
+ ImageToContourModelFilter();
+
+ virtual ~ImageToContourModelFilter();
+
+ void GenerateData();
+
+ };
+
+}
+
+#endif
diff --git a/Modules/Segmentation/Algorithms/mitkImageToLiveWireContourFilter.cpp b/Modules/Segmentation/Algorithms/mitkImageToLiveWireContourFilter.cpp
new file mode 100644
index 0000000000..a9b7a18f0d
--- /dev/null
+++ b/Modules/Segmentation/Algorithms/mitkImageToLiveWireContourFilter.cpp
@@ -0,0 +1,194 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkImageToLiveWireContourFilter.h"
+
+
+#include <itkShortestPathCostFunctionLiveWire.h>
+#include <itkImageRegionIterator.h>
+#include <itkShortestPathImageFilter.h>
+
+
+
+mitk::ImageToLiveWireContourFilter::ImageToLiveWireContourFilter()
+{
+ OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
+ this->SetNumberOfRequiredInputs(1);
+ this->SetNumberOfOutputs( 1 );
+ this->SetNthOutput(0, output.GetPointer());
+}
+
+
+
+mitk::ImageToLiveWireContourFilter::~ImageToLiveWireContourFilter()
+{
+
+}
+
+
+
+void mitk::ImageToLiveWireContourFilter::SetInput ( const mitk::ImageToLiveWireContourFilter::InputType* input )
+{
+ this->SetInput( 0, input );
+}
+
+void mitk::ImageToLiveWireContourFilter::SetInput ( unsigned int idx, const mitk::ImageToLiveWireContourFilter::InputType* input )
+{
+ if ( idx + 1 > this->GetNumberOfInputs() )
+ {
+ this->SetNumberOfRequiredInputs(idx + 1);
+ }
+ if ( input != static_cast<InputType*> ( this->ProcessObject::GetInput ( idx ) ) )
+ {
+ this->ProcessObject::SetNthInput ( idx, const_cast<InputType*> ( input ) );
+ this->Modified();
+ }
+}
+
+
+
+const mitk::ImageToLiveWireContourFilter::InputType* mitk::ImageToLiveWireContourFilter::GetInput( void )
+{
+ if (this->GetNumberOfInputs() < 1)
+ return NULL;
+ return static_cast<const mitk::ImageToLiveWireContourFilter::InputType*>(this->ProcessObject::GetInput(0));
+}
+
+
+const mitk::ImageToLiveWireContourFilter::InputType* mitk::ImageToLiveWireContourFilter::GetInput( unsigned int idx )
+{
+ if (this->GetNumberOfInputs() < 1)
+ return NULL;
+ return static_cast<const mitk::ImageToLiveWireContourFilter::InputType*>(this->ProcessObject::GetInput(idx));
+}
+
+
+
+void mitk::ImageToLiveWireContourFilter::GenerateData()
+{
+ mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
+
+ if(!input)
+ {
+ MITK_ERROR << "No input available.";
+ itkExceptionMacro("mitk::ImageToLiveWireContourFilter: No input available. Please set the input!");
+ return;
+ }
+
+ if( input->GetDimension() != 2 )
+ {
+ MITK_ERROR << "Filter is only working on 2D images.";
+ itkExceptionMacro("mitk::ImageToLiveWireContourFilter: Filter is only working on 2D images.. Please make sure that the input is 2D!");
+ return;
+ }
+
+
+ input->GetGeometry()->WorldToIndex(m_StartPoint, m_StartPointInIndex);
+ input->GetGeometry()->WorldToIndex(m_EndPoint, m_EndPointInIndex);
+
+
+ AccessFixedDimensionByItk(input, ItkProcessImage, 2);
+}
+
+
+
+template<typename TPixel, unsigned int VImageDimension>
+void mitk::ImageToLiveWireContourFilter::ItkProcessImage (itk::Image<TPixel, VImageDimension>* inputImage)
+{
+ //typedef itk::Image< TPixel, VImageDimension > InputImageType;
+ //typedef itk::Image< float, 2 > FloatImageType;
+
+ //typedef typename itk::ShortestPathImageFilter< InputImageType, InputImageType > ShortestPathImageFilterType;
+ //typedef typename itk::ShortestPathCostFunctionLiveWire< InputImageType > CostFunctionType;
+
+ //typedef InputImageType::IndexType IndexType;
+
+
+ ///* compute the requested region for itk filters */
+
+ //typename IndexType startPoint, endPoint;
+ //
+ //startPoint[0] = m_StartPointInIndex[0];
+ //startPoint[1] = m_StartPointInIndex[1];
+
+ //endPoint[0] = m_EndPointInIndex[0];
+ //endPoint[1] = m_EndPointInIndex[1];
+
+ ////minimum value in each direction for startRegion
+ //typename IndexType startRegion;
+ //startRegion[0] = startPoint[0] < endPoint[0] ? startPoint[0] : endPoint[0];
+ //startRegion[1] = startPoint[1] < endPoint[1] ? startPoint[1] : endPoint[1];
+
+ ////maximum value in each direction for size
+ //typename InputImageType::SizeType size;
+ //size[0] = startPoint[0] > endPoint[0] ? startPoint[0] : endPoint[0];
+ //size[1] = startPoint[1] > endPoint[1] ? startPoint[1] : endPoint[1];
+
+
+ //typename InputImageType::RegionType region;
+ //region.SetSize( size );
+ //region.SetIndex( startRegion );
+ ///*---------------------------------------------*/
+
+
+ ///* extracts features from image and calculates costs */
+ //typename CostFunctionType::Pointer costFunction = CostFunctionType::New();
+ //costFunction->SetImage(inputImage);
+ //costFunction->SetStartIndex(startPoint);
+ //costFunction->SetEndIndex(endPoint);
+ //costFunction->SetRequestedRegion(region);
+ ///*---------------------------------------------*/
+
+
+ ///* calculate shortest path between start and end point */
+ //ShortestPathImageFilterType::Pointer shortestPathFilter = ShortestPathImageFilterType::New();
+ //shortestPathFilter->SetFullNeighborsMode(true);
+ //shortestPathFilter->SetInput(inputImage);
+ //shortestPathFilter->SetMakeOutputImage(true);
+ //shortestPathFilter->SetStoreVectorOrder(false);
+ ////shortestPathFilter->SetActivateTimeOut(true);
+ //shortestPathFilter->SetStartIndex(startPoint);
+ //shortestPathFilter->SetEndIndex(endPoint);
+
+ //shortestPathFilter->Update();
+
+ ///*---------------------------------------------*/
+
+
+ ///* construct contour from path image */
+ ////get the shortest path as vector
+ //std::vector< itk::Index<3> > shortestPath = shortestPathFilter->GetVectorPath();
+
+ ////fill the output contour with controll points from the path
+ //OutputType::Pointer outputContour = this->GetOutput();
+ //mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
+
+ //std::vector< itk::Index<3> >::iterator pathIterator = shortestPath.begin();
+
+ //while(pathIterator != shortestPath.end())
+ //{
+ // mitk::Point3D currentPoint;
+ // currentPoint[0] = (*pathIterator)[0];
+ // currentPoint[1] = (*pathIterator)[1];
+
+ // input->GetGeometry(0)->IndexToWorld(currentPoint, currentPoint);
+ // outputContour->AddVertex(currentPoint);
+ //
+ // pathIterator++;
+ //}
+ /*---------------------------------------------*/
+
+}
diff --git a/Modules/Segmentation/Algorithms/mitkImageToLiveWireContourFilter.h b/Modules/Segmentation/Algorithms/mitkImageToLiveWireContourFilter.h
new file mode 100644
index 0000000000..eebf622d6b
--- /dev/null
+++ b/Modules/Segmentation/Algorithms/mitkImageToLiveWireContourFilter.h
@@ -0,0 +1,92 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef _mitkImageToLiveWireContourFilter_h__
+#define _mitkImageToLiveWireContourFilter_h__
+
+#include "mitkCommon.h"
+#include "SegmentationExports.h"
+#include "mitkContourModel.h"
+#include "mitkContourModelSource.h"
+
+#include <mitkImage.h>
+#include <mitkImageAccessByItk.h>
+#include <mitkImageCast.h>
+
+
+
+
+namespace mitk {
+
+ /**
+ *
+ * \brief
+ *
+ * \ingroup ContourModelFilters
+ * \ingroup Process
+ */
+ class Segmentation_EXPORT ImageToLiveWireContourFilter : public ContourModelSource
+ {
+
+ public:
+
+ mitkClassMacro(ImageToLiveWireContourFilter, ContourModelSource);
+ itkNewMacro(Self);
+
+ typedef ContourModel OutputType;
+ typedef OutputType::Pointer OutputTypePointer;
+ typedef mitk::Image InputType;
+
+ itkSetMacro(StartPoint, mitk::Point3D);
+ itkGetMacro(StartPoint, mitk::Point3D);
+
+ itkSetMacro(EndPoint, mitk::Point3D);
+ itkGetMacro(EndPoint, mitk::Point3D);
+
+
+ virtual void SetInput( const InputType *input);
+
+ virtual void SetInput( unsigned int idx, const InputType * input);
+
+ const InputType* GetInput(void);
+
+ const InputType* GetInput(unsigned int idx);
+
+ protected:
+ ImageToLiveWireContourFilter();
+
+ virtual ~ImageToLiveWireContourFilter();
+
+ void GenerateData();
+
+ void GenerateOutputInformation() {};
+
+ mitk::Point3D m_StartPoint;
+ mitk::Point3D m_EndPoint;
+
+ mitk::Point3D m_StartPointInIndex;
+ mitk::Point3D m_EndPointInIndex;
+
+ private:
+
+ template<typename TPixel, unsigned int VImageDimension>
+ void ItkProcessImage (itk::Image<TPixel, VImageDimension>* inputImage);
+
+
+ };
+
+}
+#endif
diff --git a/Modules/Segmentation/Algorithms/mitkOverwriteSliceImageFilter.cpp b/Modules/Segmentation/Algorithms/mitkOverwriteSliceImageFilter.cpp
index 62c241d84b..4c6db9d883 100644
--- a/Modules/Segmentation/Algorithms/mitkOverwriteSliceImageFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkOverwriteSliceImageFilter.cpp
@@ -1,250 +1,250 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkOverwriteSliceImageFilter.h"
#include "mitkImageCast.h"
#include "mitkImageAccessByItk.h"
#include "mitkSegmentationInterpolationController.h"
#include "mitkApplyDiffImageOperation.h"
#include "mitkOperationEvent.h"
#include "mitkInteractionConst.h"
#include "mitkUndoController.h"
#include "mitkDiffImageApplier.h"
#include "mitkImageTimeSelector.h"
#include <itkImageSliceIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
mitk::OverwriteSliceImageFilter::OverwriteSliceImageFilter()
:m_SliceIndex(0),
m_SliceDimension(0),
m_TimeStep(0),
m_Dimension0(0),
m_Dimension1(1),
m_CreateUndoInformation(false)
{
MITK_WARN << "Class is deprecated! Use mitkVtkImageOverwrite instead.";
}
mitk::OverwriteSliceImageFilter::~OverwriteSliceImageFilter()
{
}
void mitk::OverwriteSliceImageFilter::GenerateData()
{
//
// this is the place to implement the major part of undo functionality (bug #491)
// here we have to create undo/do operations
//
// WHO is the operation actor? This object may not be destroyed ever (design of undo stack)!
// -> some singleton method of this filter?
//
// neccessary additional objects:
// - something that executes the operations
// - the operation class (must hold a binary diff or something)
// - observer commands to know when the image is deleted (no further action then, perhaps even remove the operations from the undo stack)
//
Image::ConstPointer input = ImageToImageFilter::GetInput(0);
Image::ConstPointer input3D = input;
Image::ConstPointer slice = m_SliceImage;
if ( input.IsNull() || slice.IsNull() ) return;
switch (m_SliceDimension)
{
default:
case 2:
m_Dimension0 = 0;
m_Dimension1 = 1;
break;
case 1:
m_Dimension0 = 0;
m_Dimension1 = 2;
break;
case 0:
m_Dimension0 = 1;
m_Dimension1 = 2;
break;
}
if ( slice->GetDimension() < 2 || input->GetDimension() > 4 ||
slice->GetDimension(0) != input->GetDimension(m_Dimension0) ||
slice->GetDimension(1) != input->GetDimension(m_Dimension1) ||
m_SliceIndex >= input->GetDimension(m_SliceDimension)
)
{
itkExceptionMacro("Slice and image dimensions differ or slice index is too large. Sorry, cannot work like this.");
return;
}
if ( input->GetDimension() == 4 )
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( input );
timeSelector->SetTimeNr( m_TimeStep );
timeSelector->UpdateLargestPossibleRegion();
input3D = timeSelector->GetOutput();
}
if ( m_SliceDifferenceImage.IsNull() ||
m_SliceDifferenceImage->GetDimension(0) != m_SliceImage->GetDimension(0) ||
m_SliceDifferenceImage->GetDimension(1) != m_SliceImage->GetDimension(1) )
{
m_SliceDifferenceImage = mitk::Image::New();
mitk::PixelType pixelType( mitk::MakeScalarPixelType<short signed int>() );
m_SliceDifferenceImage->Initialize( pixelType, 2, m_SliceImage->GetDimensions() );
}
//MITK_INFO << "Overwriting slice " << m_SliceIndex << " in dimension " << m_SliceDimension << " at time step " << m_TimeStep << std::endl;
// this will do a long long if/else to find out both pixel types
AccessFixedDimensionByItk( input3D, ItkImageSwitch, 3 );
SegmentationInterpolationController* interpolator = SegmentationInterpolationController::InterpolatorForImage( input );
if (interpolator)
{
interpolator->BlockModified(true);
interpolator->SetChangedSlice( m_SliceDifferenceImage, m_SliceDimension, m_SliceIndex, m_TimeStep );
}
if ( m_CreateUndoInformation )
{
// create do/undo operations (we don't execute the doOp here, because it has already been executed during calculation of the diff image
ApplyDiffImageOperation* doOp = new ApplyDiffImageOperation( OpTEST, const_cast<Image*>(input.GetPointer()), m_SliceDifferenceImage, m_TimeStep, m_SliceDimension, m_SliceIndex );
ApplyDiffImageOperation* undoOp = new ApplyDiffImageOperation( OpTEST, const_cast<Image*>(input.GetPointer()), m_SliceDifferenceImage, m_TimeStep, m_SliceDimension, m_SliceIndex );
undoOp->SetFactor( -1.0 );
OperationEvent* undoStackItem = new OperationEvent( DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, this->EventDescription(m_SliceDimension, m_SliceIndex, m_TimeStep) );
UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
}
// this image is modified (good to know for the renderer)
input->Modified();
if (interpolator)
{
interpolator->BlockModified(false);
}
}
// basically copied from mitk/Core/Algorithms/mitkImageAccessByItk.h
#define myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, pixeltype, dimension, itkimage2) \
- if ( typeId == typeid(pixeltype) ) \
+ if ( typeId == MapPixelComponentType<pixeltype>::value ) \
{ \
typedef itk::Image<pixeltype, dimension> ImageType; \
typedef mitk::ImageToItk<ImageType> ImageToItkType; \
itk::SmartPointer<ImageToItkType> imagetoitk = ImageToItkType::New(); \
const mitk::Image* constImage = mitkImage; \
mitk::Image* nonConstImage = const_cast<mitk::Image*>(constImage); \
nonConstImage->Update(); \
imagetoitk->SetInput(nonConstImage); \
imagetoitk->Update(); \
itkImageTypeFunction(imagetoitk->GetOutput(), itkimage2); \
}
#define myMITKOverwriteSliceImageFilterAccessAllTypesByItk(mitkImage, itkImageTypeFunction, dimension, itkimage2) \
{ \
myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, double, dimension, itkimage2) else \
myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, float, dimension, itkimage2) else \
myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, int, dimension, itkimage2) else \
myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, unsigned int, dimension, itkimage2) else \
myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, short, dimension, itkimage2) else \
myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, unsigned short, dimension, itkimage2) else \
myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, char, dimension, itkimage2) else \
myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, unsigned char, dimension, itkimage2) \
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::OverwriteSliceImageFilter::ItkImageSwitch( itk::Image<TPixel,VImageDimension>* itkImage )
{
- const std::type_info& typeId=m_SliceImage->GetPixelType().GetTypeId();
+ const int typeId=m_SliceImage->GetPixelType().GetComponentType();
myMITKOverwriteSliceImageFilterAccessAllTypesByItk( m_SliceImage, ItkImageProcessing, 2, itkImage );
}
template<typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
void mitk::OverwriteSliceImageFilter::ItkImageProcessing( itk::Image<TPixel1,VImageDimension1>* inputImage, itk::Image<TPixel2,VImageDimension2>* outputImage )
{
typedef itk::Image<TPixel1, VImageDimension1> SliceImageType;
typedef itk::Image<short signed int, VImageDimension1> DiffImageType;
typedef itk::Image<TPixel2, VImageDimension2> VolumeImageType;
typedef itk::ImageSliceIteratorWithIndex< VolumeImageType > OutputSliceIteratorType;
typedef itk::ImageRegionConstIterator< SliceImageType > InputSliceIteratorType;
typedef itk::ImageRegionIterator< DiffImageType > DiffSliceIteratorType;
typename VolumeImageType::RegionType sliceInVolumeRegion;
sliceInVolumeRegion = outputImage->GetLargestPossibleRegion();
sliceInVolumeRegion.SetSize( m_SliceDimension, 1 ); // just one slice
sliceInVolumeRegion.SetIndex( m_SliceDimension, m_SliceIndex ); // exactly this slice, please
OutputSliceIteratorType outputIterator( outputImage, sliceInVolumeRegion );
outputIterator.SetFirstDirection(m_Dimension0);
outputIterator.SetSecondDirection(m_Dimension1);
InputSliceIteratorType inputIterator( inputImage, inputImage->GetLargestPossibleRegion() );
typename DiffImageType::Pointer diffImage;
CastToItkImage( m_SliceDifferenceImage, diffImage );
DiffSliceIteratorType diffIterator( diffImage, diffImage->GetLargestPossibleRegion() );
// iterate over output slice (and over input slice simultaneously)
outputIterator.GoToBegin();
inputIterator.GoToBegin();
diffIterator.GoToBegin();
while ( !outputIterator.IsAtEnd() )
{
while ( !outputIterator.IsAtEndOfSlice() )
{
while ( !outputIterator.IsAtEndOfLine() )
{
diffIterator.Set( static_cast<short signed int>(inputIterator.Get() - outputIterator.Get()) ); // oh oh, not good for bigger values
outputIterator.Set( (TPixel2) inputIterator.Get() );
++outputIterator;
++inputIterator;
++diffIterator;
}
outputIterator.NextLine();
}
outputIterator.NextSlice();
}
}
std::string mitk::OverwriteSliceImageFilter::EventDescription( unsigned int sliceDimension, unsigned int sliceIndex, unsigned int timeStep )
{
std::stringstream s;
s << "Changed slice (";
switch (sliceDimension)
{
default:
case 2:
s << "T";
break;
case 1:
s << "C";
break;
case 0:
s << "S";
break;
}
s << " " << sliceIndex << " " << timeStep << ")";
return s.str();
}
diff --git a/Modules/Segmentation/Algorithms/mitkReduceContourSetFilter.cpp b/Modules/Segmentation/Algorithms/mitkReduceContourSetFilter.cpp
index 83320349df..8b5c1ec98a 100644
--- a/Modules/Segmentation/Algorithms/mitkReduceContourSetFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkReduceContourSetFilter.cpp
@@ -1,492 +1,502 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkReduceContourSetFilter.h"
mitk::ReduceContourSetFilter::ReduceContourSetFilter()
{
m_MaxSegmentLenght = 0;
m_StepSize = 10;
m_Tolerance = -1;
m_ReductionType = DOUGLAS_PEUCKER;
m_MaxSpacing = -1;
m_MinSpacing = -1;
this->m_UseProgressBar = false;
this->m_ProgressStepSize = 1;
m_NumberOfPointsAfterReduction = 0;
+
+ mitk::Surface::Pointer output = mitk::Surface::New();
+ this->SetNthOutput(0, output.GetPointer());
}
mitk::ReduceContourSetFilter::~ReduceContourSetFilter()
{
}
void mitk::ReduceContourSetFilter::GenerateData()
{
- unsigned int numberOfInputs = this->GetNumberOfInputs();
+ unsigned int numberOfInputs = this->GetNumberOfIndexedInputs();
unsigned int numberOfOutputs (0);
vtkSmartPointer<vtkPolyData> newPolyData;
vtkSmartPointer<vtkCellArray> newPolygons;
vtkSmartPointer<vtkPoints> newPoints;
//For the purpose of evaluation
// unsigned int numberOfPointsBefore (0);
m_NumberOfPointsAfterReduction=0;
for(unsigned int i = 0; i < numberOfInputs; i++)
{
mitk::Surface* currentSurface = const_cast<mitk::Surface*>( this->GetInput(i) );
vtkSmartPointer<vtkPolyData> polyData = currentSurface->GetVtkPolyData();
newPolyData = vtkPolyData::New();
newPolygons = vtkCellArray::New();
newPoints = vtkPoints::New();
vtkSmartPointer<vtkCellArray> existingPolys = polyData->GetPolys();
vtkSmartPointer<vtkPoints> existingPoints = polyData->GetPoints();
existingPolys->InitTraversal();
vtkIdType* cell (NULL);
vtkIdType cellSize (0);
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
{
bool incorporatePolygon = this->CheckForIntersection(cell,cellSize,existingPoints, /*numberOfIntersections, intersectionPoints, */i);
if ( !incorporatePolygon ) continue;
vtkSmartPointer<vtkPolygon> newPolygon = vtkSmartPointer<vtkPolygon>::New();
if(m_ReductionType == NTH_POINT)
{
this->ReduceNumberOfPointsByNthPoint(cellSize, cell, existingPoints, newPolygon, newPoints);
if (newPolygon->GetPointIds()->GetNumberOfIds() != 0)
{
newPolygons->InsertNextCell(newPolygon);
}
}
else if (m_ReductionType == DOUGLAS_PEUCKER)
{
this->ReduceNumberOfPointsByDouglasPeucker(cellSize, cell, existingPoints, newPolygon, newPoints);
if (newPolygon->GetPointIds()->GetNumberOfIds() > 3)
{
newPolygons->InsertNextCell(newPolygon);
}
}
//Again for evaluation
// numberOfPointsBefore += cellSize;
m_NumberOfPointsAfterReduction += newPolygon->GetPointIds()->GetNumberOfIds();
}
if (newPolygons->GetNumberOfCells() != 0)
{
newPolyData->SetPolys(newPolygons);
newPolyData->SetPoints(newPoints);
newPolyData->BuildLinks();
- Surface::Pointer surface = this->GetOutput(numberOfOutputs);
+ this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedOutputs() + 1);
+ mitk::Surface::Pointer surface = mitk::Surface::New();
+ this->SetNthOutput(numberOfOutputs, surface.GetPointer());
+
surface->SetVtkPolyData(newPolyData);
numberOfOutputs++;
}
}
// MITK_INFO<<"Points before: "<<numberOfPointsBefore<<" ##### Points after: "<<numberOfPointsAfter;
- this->SetNumberOfOutputs(numberOfOutputs);
+ this->SetNumberOfIndexedOutputs(numberOfOutputs);
//Setting progressbar
if (this->m_UseProgressBar)
mitk::ProgressBar::GetInstance()->Progress(this->m_ProgressStepSize);
}
void mitk::ReduceContourSetFilter::ReduceNumberOfPointsByNthPoint (vtkIdType cellSize, vtkIdType* cell, vtkPoints* points, vtkPolygon* reducedPolygon, vtkPoints* reducedPoints)
{
unsigned int newNumberOfPoints (0);
unsigned int mod = cellSize%m_StepSize;
if(mod == 0)
{
newNumberOfPoints = cellSize/m_StepSize;
}
else
{
newNumberOfPoints = ( (cellSize-mod)/m_StepSize )+1;
}
if (newNumberOfPoints <= 3)
{
return;
}
reducedPolygon->GetPointIds()->SetNumberOfIds(newNumberOfPoints);
reducedPolygon->GetPoints()->SetNumberOfPoints(newNumberOfPoints);
for (unsigned int i = 0; i < cellSize; i++)
{
if (i%m_StepSize == 0)
{
double point[3];
points->GetPoint(cell[i], point);
vtkIdType id = reducedPoints->InsertNextPoint(point);
reducedPolygon->GetPointIds()->SetId(i/m_StepSize, id);
}
}
vtkIdType id = cell[0];
double point[3];
points->GetPoint(id, point);
id = reducedPoints->InsertNextPoint(point);
reducedPolygon->GetPointIds()->SetId(newNumberOfPoints-1, id);
}
void mitk::ReduceContourSetFilter::ReduceNumberOfPointsByDouglasPeucker(vtkIdType cellSize, vtkIdType* cell, vtkPoints* points,
vtkPolygon* reducedPolygon, vtkPoints* reducedPoints)
{
//If the cell is too small to obtain a reduced polygon with the given stepsize return
if (cellSize <= m_StepSize*3)return;
/*
What we do now is (see the Douglas Peucker Algorithm):
1. Divide the current contour in two line segments (start - middle; middle - end), put them into the stack
2. Fetch first line segment and create the following vectors:
- v1 = (start;end)
- v2 = (start;currentPoint) -> for each point of the current line segment!
3. Calculate the distance from the currentPoint to v1:
a. Determine the length of the orthogonal projection of v2 to v1 by:
l = v2 * (normalized v1)
b. There a three possibilities for the distance then:
d = sqrt(lenght(v2)^2 - l^2) if l > 0 and l < length(v1)
d = lenght(v2-v1) if l > 0 and l > lenght(v1)
d = length(v2) if l < 0 because v2 is then pointing in a different direction than v1
4. Memorize the point with the biggest distance and create two new line segments with it at the end of the iteration
and put it into the stack
5. If the distance value D <= m_Tolerance, then add the start and end index and the corresponding points to the reduced ones
*/
//First of all set tolerance if none is specified
if(m_Tolerance < 0)
{
if(m_MaxSpacing > 0)
{
m_Tolerance = m_MinSpacing;
}
else
{
m_Tolerance = 1.5;
}
}
std::stack<LineSegment> lineSegments;
//1. Divide in line segments
LineSegment ls2;
ls2.StartIndex = cell[cellSize/2];
ls2.EndIndex = cell[cellSize-1];
lineSegments.push(ls2);
LineSegment ls1;
ls1.StartIndex = cell[0];
ls1.EndIndex = cell[cellSize/2];
lineSegments.push(ls1);
LineSegment currentSegment;
double v1[3];
double v2[3];
double tempV[3];
double lenghtV1;
double currentMaxDistance (0);
vtkIdType currentMaxDistanceIndex (0);
double l;
double d;
vtkIdType pointId (0);
//Add the start index to the reduced points. From now on just the end indices will be added
pointId = reducedPoints->InsertNextPoint(points->GetPoint(cell[0]));
reducedPolygon->GetPointIds()->InsertNextId(pointId);
while (!lineSegments.empty())
{
currentSegment = lineSegments.top();
lineSegments.pop();
//2. Create vectors
points->GetPoint(currentSegment.EndIndex, tempV);
points->GetPoint(currentSegment.StartIndex, v1);
v1[0] = tempV[0]-v1[0];
v1[1] = tempV[1]-v1[1];
v1[2] = tempV[2]-v1[2];
lenghtV1 = vtkMath::Norm(v1);
vtkMath::Normalize(v1);
int range = currentSegment.EndIndex - currentSegment.StartIndex;
for (int i = 1; i < abs(range); ++i)
{
points->GetPoint(currentSegment.StartIndex+i, tempV);
points->GetPoint(currentSegment.StartIndex, v2);
v2[0] = tempV[0]-v2[0];
v2[1] = tempV[1]-v2[1];
v2[2] = tempV[2]-v2[2];
//3. Calculate the distance
l = vtkMath::Dot(v2, v1);
d = vtkMath::Norm(v2);
if (l > 0 && l < lenghtV1)
{
d = sqrt((d*d-l*l));
}
else if (l > 0 && l > lenghtV1)
{
tempV[0] = lenghtV1*v1[0] - v2[0];
tempV[1] = lenghtV1*v1[1] - v2[1];
tempV[2] = lenghtV1*v1[2] - v2[2];
d = vtkMath::Norm(tempV);
}
//4. Memorize maximum distance
if (d > currentMaxDistance)
{
currentMaxDistance = d;
currentMaxDistanceIndex = currentSegment.StartIndex+i;
}
}
//4. & 5.
if (currentMaxDistance <= m_Tolerance)
{
//double temp[3];
int segmentLenght = currentSegment.EndIndex - currentSegment.StartIndex;
if (segmentLenght > (int)m_MaxSegmentLenght)
{
m_MaxSegmentLenght = (unsigned int)segmentLenght;
}
// MITK_INFO<<"Lenght: "<<abs(segmentLenght);
if (abs(segmentLenght) > 25)
{
unsigned int newLenght(segmentLenght);
while (newLenght > 25)
{
newLenght = newLenght*0.5;
}
unsigned int divisions = abs(segmentLenght)/newLenght;
// MITK_INFO<<"Divisions: "<<divisions;
for (unsigned int i = 1; i<=divisions; ++i)
{
// MITK_INFO<<"Inserting MIDDLE: "<<(currentSegment.StartIndex + newLenght*i);
pointId = reducedPoints->InsertNextPoint(points->GetPoint(currentSegment.StartIndex + newLenght*i));
reducedPolygon->GetPointIds()->InsertNextId(pointId);
}
}
// MITK_INFO<<"Inserting END: "<<currentSegment.EndIndex;
pointId = reducedPoints->InsertNextPoint(points->GetPoint(currentSegment.EndIndex));
reducedPolygon->GetPointIds()->InsertNextId(pointId);
}
else
{
ls2.StartIndex = currentMaxDistanceIndex;
ls2.EndIndex = currentSegment.EndIndex;
lineSegments.push(ls2);
ls1.StartIndex = currentSegment.StartIndex;
ls1.EndIndex = currentMaxDistanceIndex;
lineSegments.push(ls1);
}
currentMaxDistance = 0;
}
}
bool mitk::ReduceContourSetFilter::CheckForIntersection (vtkIdType* currentCell, vtkIdType currentCellSize, vtkPoints* currentPoints,/* vtkIdType numberOfIntersections, vtkIdType* intersectionPoints,*/ unsigned int currentInputIndex)
{
/*
If we check the current cell for intersections then we have to consider three possibilies:
1. There is another cell among all the other input surfaces which intersects the current polygon:
- That means we have to save the intersection points because these points should not be eliminated
2. There current polygon exists just because of an intersection of another polygon with the current plane defined by the current polygon
- That means the current polygon should not be incorporated and all of its points should be eliminated
3. There is no intersection
- That mean we can just reduce the current polygons points without considering any intersections
*/
- for (unsigned int i = 0; i < this->GetNumberOfInputs(); i++)
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); i++)
{
//Don't check for intersection with the polygon itself
if (i == currentInputIndex) continue;
//Get the next polydata to check for intersection
vtkSmartPointer<vtkPolyData> poly = const_cast<Surface*>( this->GetInput(i) )->GetVtkPolyData();
vtkSmartPointer<vtkCellArray> polygonArray = poly->GetPolys();
polygonArray->InitTraversal();
vtkIdType anotherInputPolygonSize (0);
vtkIdType* anotherInputPolygonIDs(NULL);
/*
The procedure is:
- Create the equation of the plane, defined by the points of next input
- Calculate the distance of each point of the current polygon to the plane
- If the maximum distance is not bigger than 1.5 of the maximum spacing AND the minimal distance is not bigger
than 0.5 of the minimum spacing then the current contour is an intersection contour
*/
for( polygonArray->InitTraversal(); polygonArray->GetNextCell(anotherInputPolygonSize, anotherInputPolygonIDs);)
{
//Choosing three plane points to calculate the plane vectors
double p1[3];
double p2[3];
double p3[3];
//The plane vectors
double v1[3];
double v2[3] = { 0 };
//The plane normal
double normal[3];
//Create first Vector
poly->GetPoint(anotherInputPolygonIDs[0], p1);
poly->GetPoint(anotherInputPolygonIDs[1], p2);
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
//Find 3rd point for 2nd vector (The angle between the two plane vectors should be bigger than 30 degrees)
double maxDistance (0);
double minDistance (10000);
for (unsigned int j = 2; j < anotherInputPolygonSize; j++)
{
poly->GetPoint(anotherInputPolygonIDs[j], p3);
v2[0] = p3[0]-p1[0];
v2[1] = p3[1]-p1[1];
v2[2] = p3[2]-p1[2];
//Calculate the angle between the two vector for the current point
double dotV1V2 = vtkMath::Dot(v1,v2);
double absV1 = sqrt(vtkMath::Dot(v1,v1));
double absV2 = sqrt(vtkMath::Dot(v2,v2));
double cosV1V2 = dotV1V2/(absV1*absV2);
double arccos = acos(cosV1V2);
double degree = vtkMath::DegreesFromRadians(arccos);
//If angle is bigger than 30 degrees break
if (degree > 30) break;
}//for (to find 3rd point)
//Calculate normal of the plane by taking the cross product of the two vectors
vtkMath::Cross(v1,v2,normal);
vtkMath::Normalize(normal);
//Determine position of the plane
double lambda = vtkMath::Dot(normal, p1);
/*
Calculate the distance to the plane for each point of the current polygon
If the distance is zero then save the currentPoint as intersection point
*/
for (unsigned int k = 0; k < currentCellSize; k++)
{
double currentPoint[3];
currentPoints->GetPoint(currentCell[k], currentPoint);
double tempPoint[3];
tempPoint[0] = normal[0]*currentPoint[0];
tempPoint[1] = normal[1]*currentPoint[1];
tempPoint[2] = normal[2]*currentPoint[2];
double temp = tempPoint[0]+tempPoint[1]+tempPoint[2]-lambda;
double distance = fabs(temp);
if (distance > maxDistance)
{
maxDistance = distance;
}
if (distance < minDistance)
{
minDistance = distance;
}
}//for (to calculate distance and intersections with currentPolygon)
if (maxDistance < 1.5*m_MaxSpacing && minDistance < 0.5*m_MinSpacing)
{
return false;
}
//Because we are considering the plane defined by the acual input polygon only one iteration is sufficient
//We do not need to consider each cell of the plane
break;
}//for (to traverse through all cells of actualInputPolyData)
}//for (to iterate through all inputs)
return true;
}
void mitk::ReduceContourSetFilter::GenerateOutputInformation()
{
Superclass::GenerateOutputInformation();
}
void mitk::ReduceContourSetFilter::Reset()
{
- for (unsigned int i = 0; i < this->GetNumberOfInputs(); i++)
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); i++)
{
this->PopBackInput();
}
- this->SetNumberOfInputs(0);
- this->SetNumberOfOutputs(0);
+ this->SetNumberOfIndexedInputs(0);
+ this->SetNumberOfIndexedOutputs(0);
+
+ mitk::Surface::Pointer output = mitk::Surface::New();
+ this->SetNthOutput(0, output.GetPointer());
+
m_NumberOfPointsAfterReduction = 0;
}
void mitk::ReduceContourSetFilter::SetUseProgressBar(bool status)
{
this->m_UseProgressBar = status;
}
void mitk::ReduceContourSetFilter::SetProgressStepSize(unsigned int stepSize)
{
this->m_ProgressStepSize = stepSize;
}
diff --git a/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp b/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
index 73f2b769a1..542f914b4e 100644
--- a/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
+++ b/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
@@ -1,532 +1,532 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkShowSegmentationAsSmoothedSurface.h"
#include "mitkImageToItk.h"
#include "itkIntelligentBinaryClosingFilter.h"
#include <mitkUIDGenerator.h>
#include <mitkGeometry3D.h>
#include <mitkProgressBar.h>
#include <mitkStatusBar.h>
#include <mitkImageTimeSelector.h>
#include <mitkImageToSurfaceFilter.h>
#include <mitkVtkRepresentationProperty.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkRegionOfInterestImageFilter.h>
#include <itkConstantPadImageFilter.h>
#include <itkBinaryMedianImageFilter.h>
#include <itkBinaryThresholdImageFilter.h>
#include <itkDiscreteGaussianImageFilter.h>
#include <itkMultiplyImageFilter.h>
#include <itkConnectedThresholdImageFilter.h>
#include <itkAddImageFilter.h>
#include <vtkQuadricDecimation.h>
#include <vtkCleanPolyData.h>
#include <vtkPolyDataNormals.h>
using namespace mitk;
using namespace std;
ShowSegmentationAsSmoothedSurface::ShowSegmentationAsSmoothedSurface()
{
}
ShowSegmentationAsSmoothedSurface::~ShowSegmentationAsSmoothedSurface()
{
}
void ShowSegmentationAsSmoothedSurface::Initialize(const NonBlockingAlgorithm *other)
{
Superclass::Initialize(other);
bool syncVisibility = false;
if (other != NULL)
other->GetParameter("Sync visibility", syncVisibility);
SetParameter("Sync visibility", syncVisibility);
SetParameter("Wireframe", false);
// The Smoothing value is used as variance for a Gauß filter.
// A reasonable default value equals the image spacing in mm.
SetParameter("Smoothing", 1.0f);
// Valid range for decimation value is [0, 1). High values
// increase decimation, especially when very close to 1.
// A value of 0 disables decimation.
SetParameter("Decimation", 0.5f);
// Valid range for closing value is [0, 1]. Higher values
// increase closing. A value of 0 disables closing.
SetParameter("Closing", 0.0f);
}
bool ShowSegmentationAsSmoothedSurface::ReadyToRun()
{
try
{
mitk::Image::Pointer image;
GetPointerParameter("Input", image);
return image.IsNotNull() && GetGroupNode();
}
catch (const invalid_argument &)
{
return false;
}
}
bool ShowSegmentationAsSmoothedSurface::ThreadedUpdateFunction()
{
Image::Pointer image;
GetPointerParameter("Input", image);
float smoothing;
GetParameter("Smoothing", smoothing);
float decimation;
GetParameter("Decimation", decimation);
float closing;
GetParameter("Closing", closing);
int timeNr = 0;
GetParameter("TimeNr", timeNr);
if (image->GetDimension() == 4)
MITK_INFO << "CREATING SMOOTHED POLYGON MODEL (t = " << timeNr << ')';
else
MITK_INFO << "CREATING SMOOTHED POLYGON MODEL";
MITK_INFO << " Smoothing = " << smoothing;
MITK_INFO << " Decimation = " << decimation;
MITK_INFO << " Closing = " << closing;
Geometry3D::Pointer geometry = dynamic_cast<Geometry3D *>(image->GetGeometry()->Clone().GetPointer());
// Make ITK image out of MITK image
typedef itk::Image<unsigned char, 3> CharImageType;
typedef itk::Image<unsigned short, 3> ShortImageType;
typedef itk::Image<float, 3> FloatImageType;
if (image->GetDimension() == 4)
{
ImageTimeSelector::Pointer imageTimeSelector = ImageTimeSelector::New();
imageTimeSelector->SetInput(image);
imageTimeSelector->SetTimeNr(timeNr);
imageTimeSelector->UpdateLargestPossibleRegion();
- image = imageTimeSelector->GetOutput();
+ image = imageTimeSelector->GetOutput(0);
}
ImageToItk<CharImageType>::Pointer imageToItkFilter = ImageToItk<CharImageType>::New();
try
{
imageToItkFilter->SetInput(image);
}
catch (const itk::ExceptionObject &e)
{
// Most probably the input image type is wrong. Binary images are expected to be
// >unsigned< char images.
MITK_ERROR << e.GetDescription() << endl;
return false;
}
imageToItkFilter->Update();
CharImageType::Pointer itkImage = imageToItkFilter->GetOutput();
// Get bounding box and relabel
MITK_INFO << "Extracting VOI...";
int imageLabel = 1;
bool roiFound = false;
CharImageType::IndexType minIndex;
minIndex.Fill(numeric_limits<CharImageType::IndexValueType>::max());
CharImageType::IndexType maxIndex;
maxIndex.Fill(numeric_limits<CharImageType::IndexValueType>::min());
itk::ImageRegionIteratorWithIndex<CharImageType> iter(itkImage, itkImage->GetLargestPossibleRegion());
for (iter.GoToBegin(); !iter.IsAtEnd(); ++iter)
{
if (iter.Get() == imageLabel)
{
roiFound = true;
iter.Set(1);
CharImageType::IndexType currentIndex = iter.GetIndex();
for (unsigned int dim = 0; dim < 3; ++dim)
{
minIndex[dim] = min(currentIndex[dim], minIndex[dim]);
maxIndex[dim] = max(currentIndex[dim], maxIndex[dim]);
}
}
else
{
iter.Set(0);
}
}
if (!roiFound)
{
ProgressBar::GetInstance()->Progress(8);
MITK_ERROR << "Didn't found segmentation labeled with " << imageLabel << "!" << endl;
return false;
}
ProgressBar::GetInstance()->Progress(1);
// Extract and pad bounding box
typedef itk::RegionOfInterestImageFilter<CharImageType, CharImageType> ROIFilterType;
ROIFilterType::Pointer roiFilter = ROIFilterType::New();
CharImageType::RegionType region;
CharImageType::SizeType size;
for (unsigned int dim = 0; dim < 3; ++dim)
{
size[dim] = maxIndex[dim] - minIndex[dim] + 1;
}
region.SetIndex(minIndex);
region.SetSize(size);
roiFilter->SetInput(itkImage);
roiFilter->SetRegionOfInterest(region);
roiFilter->ReleaseDataFlagOn();
roiFilter->ReleaseDataBeforeUpdateFlagOn();
typedef itk::ConstantPadImageFilter<CharImageType, CharImageType> PadFilterType;
PadFilterType::Pointer padFilter = PadFilterType::New();
const PadFilterType::SizeValueType pad[3] = { 10, 10, 10 };
padFilter->SetInput(roiFilter->GetOutput());
padFilter->SetConstant(0);
padFilter->SetPadLowerBound(pad);
padFilter->SetPadUpperBound(pad);
padFilter->ReleaseDataFlagOn();
padFilter->ReleaseDataBeforeUpdateFlagOn();
padFilter->Update();
CharImageType::Pointer roiImage = padFilter->GetOutput();
roiImage->DisconnectPipeline();
roiFilter = 0;
padFilter = 0;
// Correct origin of real geometry (changed by cropping and padding)
typedef AffineGeometryFrame3D::TransformType TransformType;
TransformType::Pointer transform = TransformType::New();
TransformType::OutputVectorType translation;
for (unsigned int dim = 0; dim < 3; ++dim)
translation[dim] = (int)minIndex[dim] - (int)pad[dim];
transform->SetIdentity();
transform->Translate(translation);
geometry->Compose(transform, true);
ProgressBar::GetInstance()->Progress(1);
// Median
MITK_INFO << "Median...";
typedef itk::BinaryMedianImageFilter<CharImageType, CharImageType> MedianFilterType;
MedianFilterType::Pointer medianFilter = MedianFilterType::New();
CharImageType::SizeType radius = { 0 };
medianFilter->SetRadius(radius);
medianFilter->SetBackgroundValue(0);
medianFilter->SetForegroundValue(1);
medianFilter->SetInput(roiImage);
medianFilter->ReleaseDataFlagOn();
medianFilter->ReleaseDataBeforeUpdateFlagOn();
medianFilter->Update();
ProgressBar::GetInstance()->Progress(1);
// Intelligent closing
MITK_INFO << "Intelligent closing...";
unsigned int surfaceRatio = (unsigned int)((1.0f - closing) * 100.0f);
typedef itk::IntelligentBinaryClosingFilter<CharImageType, ShortImageType> ClosingFilterType;
ClosingFilterType::Pointer closingFilter = ClosingFilterType::New();
closingFilter->SetInput(medianFilter->GetOutput());
closingFilter->ReleaseDataFlagOn();
closingFilter->ReleaseDataBeforeUpdateFlagOn();
closingFilter->SetSurfaceRatio(surfaceRatio);
closingFilter->Update();
ShortImageType::Pointer closedImage = closingFilter->GetOutput();
closedImage->DisconnectPipeline();
roiImage = 0;
medianFilter = 0;
closingFilter = 0;
ProgressBar::GetInstance()->Progress(1);
// Gaussian blur
MITK_INFO << "Gauss...";
typedef itk::BinaryThresholdImageFilter<ShortImageType, FloatImageType> BinaryThresholdToFloatFilterType;
BinaryThresholdToFloatFilterType::Pointer binThresToFloatFilter = BinaryThresholdToFloatFilterType::New();
binThresToFloatFilter->SetInput(closedImage);
binThresToFloatFilter->SetLowerThreshold(1);
binThresToFloatFilter->SetUpperThreshold(1);
binThresToFloatFilter->SetInsideValue(100);
binThresToFloatFilter->SetOutsideValue(0);
binThresToFloatFilter->ReleaseDataFlagOn();
binThresToFloatFilter->ReleaseDataBeforeUpdateFlagOn();
typedef itk::DiscreteGaussianImageFilter<FloatImageType, FloatImageType> GaussianFilterType;
// From the following line on, IntelliSense (VS 2008) is broken. Any idea how to fix it?
GaussianFilterType::Pointer gaussFilter = GaussianFilterType::New();
gaussFilter->SetInput(binThresToFloatFilter->GetOutput());
gaussFilter->SetUseImageSpacing(true);
gaussFilter->SetVariance(smoothing);
gaussFilter->ReleaseDataFlagOn();
gaussFilter->ReleaseDataBeforeUpdateFlagOn();
typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> BinaryThresholdFromFloatFilterType;
BinaryThresholdFromFloatFilterType::Pointer binThresFromFloatFilter = BinaryThresholdFromFloatFilterType::New();
binThresFromFloatFilter->SetInput(gaussFilter->GetOutput());
binThresFromFloatFilter->SetLowerThreshold(50);
binThresFromFloatFilter->SetUpperThreshold(255);
binThresFromFloatFilter->SetInsideValue(1);
binThresFromFloatFilter->SetOutsideValue(0);
binThresFromFloatFilter->ReleaseDataFlagOn();
binThresFromFloatFilter->ReleaseDataBeforeUpdateFlagOn();
binThresFromFloatFilter->Update();
CharImageType::Pointer blurredImage = binThresFromFloatFilter->GetOutput();
blurredImage->DisconnectPipeline();
closedImage = 0;
binThresToFloatFilter = 0;
gaussFilter = 0;
ProgressBar::GetInstance()->Progress(1);
// Fill holes
MITK_INFO << "Filling cavities...";
typedef itk::ConnectedThresholdImageFilter<CharImageType, CharImageType> ConnectedThresholdFilterType;
ConnectedThresholdFilterType::Pointer connectedThresFilter = ConnectedThresholdFilterType::New();
CharImageType::IndexType corner;
corner[0] = 0;
corner[1] = 0;
corner[2] = 0;
connectedThresFilter->SetInput(blurredImage);
connectedThresFilter->SetSeed(corner);
connectedThresFilter->SetLower(0);
connectedThresFilter->SetUpper(0);
connectedThresFilter->SetReplaceValue(2);
connectedThresFilter->ReleaseDataFlagOn();
connectedThresFilter->ReleaseDataBeforeUpdateFlagOn();
typedef itk::BinaryThresholdImageFilter<CharImageType, CharImageType> BinaryThresholdFilterType;
BinaryThresholdFilterType::Pointer binThresFilter = BinaryThresholdFilterType::New();
binThresFilter->SetInput(connectedThresFilter->GetOutput());
binThresFilter->SetLowerThreshold(0);
binThresFilter->SetUpperThreshold(0);
binThresFilter->SetInsideValue(50);
binThresFilter->SetOutsideValue(0);
binThresFilter->ReleaseDataFlagOn();
binThresFilter->ReleaseDataBeforeUpdateFlagOn();
typedef itk::AddImageFilter<CharImageType, CharImageType, CharImageType> AddFilterType;
AddFilterType::Pointer addFilter = AddFilterType::New();
addFilter->SetInput1(blurredImage);
addFilter->SetInput2(binThresFilter->GetOutput());
addFilter->ReleaseDataFlagOn();
addFilter->ReleaseDataBeforeUpdateFlagOn();
addFilter->Update();
ProgressBar::GetInstance()->Progress(1);
// Surface extraction
MITK_INFO << "Surface extraction...";
Image::Pointer filteredImage = Image::New();
CastToMitkImage(addFilter->GetOutput(), filteredImage);
filteredImage->SetGeometry(geometry);
ImageToSurfaceFilter::Pointer imageToSurfaceFilter = ImageToSurfaceFilter::New();
imageToSurfaceFilter->SetInput(filteredImage);
imageToSurfaceFilter->SetThreshold(50);
imageToSurfaceFilter->SmoothOn();
imageToSurfaceFilter->SetDecimate(ImageToSurfaceFilter::NoDecimation);
- m_Surface = imageToSurfaceFilter->GetOutput();
+ m_Surface = imageToSurfaceFilter->GetOutput(0);
ProgressBar::GetInstance()->Progress(1);
// Mesh decimation
if (decimation > 0.0f && decimation < 1.0f)
{
MITK_INFO << "Quadric mesh decimation...";
vtkQuadricDecimation *quadricDecimation = vtkQuadricDecimation::New();
quadricDecimation->SetInput(m_Surface->GetVtkPolyData());
quadricDecimation->SetTargetReduction(decimation);
quadricDecimation->AttributeErrorMetricOn();
quadricDecimation->GlobalWarningDisplayOff();
quadricDecimation->Update();
vtkCleanPolyData* cleaner = vtkCleanPolyData::New();
cleaner->SetInput(quadricDecimation->GetOutput());
cleaner->PieceInvariantOn();
cleaner->ConvertLinesToPointsOn();
cleaner->ConvertStripsToPolysOn();
cleaner->PointMergingOn();
cleaner->Update();
m_Surface->SetVtkPolyData(cleaner->GetOutput());
}
ProgressBar::GetInstance()->Progress(1);
// Compute Normals
vtkPolyDataNormals* computeNormals = vtkPolyDataNormals::New();
computeNormals->SetInput(m_Surface->GetVtkPolyData());
computeNormals->SetFeatureAngle(360.0f);
computeNormals->FlipNormalsOff();
computeNormals->Update();
m_Surface->SetVtkPolyData(computeNormals->GetOutput());
return true;
}
void ShowSegmentationAsSmoothedSurface::ThreadedUpdateSuccessful()
{
DataNode::Pointer node = LookForPointerTargetBelowGroupNode("Surface representation");
bool addToTree = node.IsNull();
if (addToTree)
{
node = DataNode::New();
bool wireframe = false;
GetParameter("Wireframe", wireframe);
if (wireframe)
{
VtkRepresentationProperty *representation = dynamic_cast<VtkRepresentationProperty *>(
node->GetProperty("material.representation"));
if (representation != NULL)
representation->SetRepresentationToWireframe();
}
node->SetProperty("opacity", FloatProperty::New(1.0));
node->SetProperty("line width", IntProperty::New(1));
node->SetProperty("scalar visibility", BoolProperty::New(false));
UIDGenerator uidGenerator("Surface_");
node->SetProperty("FILENAME", StringProperty::New(uidGenerator.GetUID() + ".vtk"));
std::string groupNodeName = "surface";
DataNode *groupNode = GetGroupNode();
if (groupNode != NULL)
groupNode->GetName(groupNodeName);
node->SetProperty("name", StringProperty::New(groupNodeName));
}
node->SetData(m_Surface);
if (addToTree)
{
DataNode* groupNode = GetGroupNode();
if (groupNode != NULL)
{
groupNode->SetProperty("Surface representation", SmartPointerProperty::New(node));
BaseProperty *colorProperty = groupNode->GetProperty("color");
if (colorProperty != NULL)
node->ReplaceProperty("color", colorProperty);
else
node->SetProperty("color", ColorProperty::New(1.0f, 0.0f, 0.0f));
bool showResult = true;
GetParameter("Show result", showResult);
bool syncVisibility = false;
GetParameter("Sync visibility", syncVisibility);
Image::Pointer image;
GetPointerParameter("Input", image);
BaseProperty *organTypeProperty = image->GetProperty("organ type");
if (organTypeProperty != NULL)
m_Surface->SetProperty("organ type", organTypeProperty);
BaseProperty *visibleProperty = groupNode->GetProperty("visible");
if (visibleProperty != NULL && syncVisibility)
node->ReplaceProperty("visible", visibleProperty);
else
node->SetProperty("visible", BoolProperty::New(showResult));
}
InsertBelowGroupNode(node);
}
Superclass::ThreadedUpdateSuccessful();
}
diff --git a/Modules/Segmentation/Algorithms/mitkVtkImageOverwrite.cpp b/Modules/Segmentation/Algorithms/mitkVtkImageOverwrite.cpp
index 49944169ac..b8e89feefa 100644
--- a/Modules/Segmentation/Algorithms/mitkVtkImageOverwrite.cpp
+++ b/Modules/Segmentation/Algorithms/mitkVtkImageOverwrite.cpp
@@ -1,901 +1,917 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
/*=========================================================================
Program: Visualization Toolkit
Module: mitkVtkImageOverwrite.cpp
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm 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 notice for more information.
=========================================================================*/
#include "mitkVtkImageOverwrite.h"
#include "vtkImageData.h"
#include "vtkImageStencilData.h"
#include "vtkInformation.h"
#include "vtkInformationVector.h"
#include "vtkMath.h"
#include "vtkObjectFactory.h"
#include "vtkStreamingDemandDrivenPipeline.h"
#include "vtkTransform.h"
#include "vtkDataSetAttributes.h"
#include "vtkGarbageCollector.h"
#include "vtkTemplateAliasMacro.h"
// turn off 64-bit ints when templating over all types
# undef VTK_USE_INT64
# define VTK_USE_INT64 0
# undef VTK_USE_UINT64
# define VTK_USE_UINT64 0
#include <limits.h>
#include <float.h>
#include <math.h>
vtkStandardNewMacro(mitkVtkImageOverwrite);
//--------------------------------------------------------------------------
// The 'floor' function on x86 and mips is many times slower than these
// and is used a lot in this code, optimize for different CPU architectures
template<class F>
inline int vtkResliceFloor(double x, F &f)
{
#if defined mips || defined sparc || defined __ppc__
x += 2147483648.0;
unsigned int i = static_cast<unsigned int>(x);
f = x - i;
return static_cast<int>(i - 2147483648U);
#elif defined i386 || defined _M_IX86
union { double d; unsigned short s[4]; unsigned int i[2]; } dual;
dual.d = x + 103079215104.0; // (2**(52-16))*1.5
f = dual.s[0]*0.0000152587890625; // 2**(-16)
return static_cast<int>((dual.i[1]<<16)|((dual.i[0])>>16));
#elif defined ia64 || defined __ia64__ || defined IA64
x += 103079215104.0;
long long i = static_cast<long long>(x);
f = x - i;
return static_cast<int>(i - 103079215104LL);
#else
double y = floor(x);
f = x - y;
return static_cast<int>(y);
#endif
}
inline int vtkResliceRound(double x)
{
#if defined mips || defined sparc || defined __ppc__
return static_cast<int>(static_cast<unsigned int>(x + 2147483648.5) - 2147483648U);
#elif defined i386 || defined _M_IX86
union { double d; unsigned int i[2]; } dual;
dual.d = x + 103079215104.5; // (2**(52-16))*1.5
return static_cast<int>((dual.i[1]<<16)|((dual.i[0])>>16));
#elif defined ia64 || defined __ia64__ || defined IA64
x += 103079215104.5;
long long i = static_cast<long long>(x);
return static_cast<int>(i - 103079215104LL);
#else
return static_cast<int>(floor(x+0.5));
#endif
}
//----------------------------------------------------------------------------
mitkVtkImageOverwrite::mitkVtkImageOverwrite()
{
m_Overwrite_Mode = false;
this->GetOutput()->SetScalarTypeToUnsignedInt();
}
//----------------------------------------------------------------------------
mitkVtkImageOverwrite::~mitkVtkImageOverwrite()
{
}
//----------------------------------------------------------------------------
// constants for different boundary-handling modes
#define VTK_RESLICE_BACKGROUND 0 // use background if out-of-bounds
#define VTK_RESLICE_WRAP 1 // wrap to opposite side of image
#define VTK_RESLICE_MIRROR 2 // mirror off of the boundary
#define VTK_RESLICE_BORDER 3 // use a half-voxel border
#define VTK_RESLICE_NULL 4 // do nothing to *outPtr if out-of-bounds
//----------------------------------------------------------------------------
// rounding functions for each type, where 'F' is a floating-point type
#if (VTK_USE_INT8 != 0)
template <class F>
inline void vtkResliceRound(F val, vtkTypeInt8& rnd)
{
rnd = vtkResliceRound(val);
}
#endif
#if (VTK_USE_UINT8 != 0)
template <class F>
inline void vtkResliceRound(F val, vtkTypeUInt8& rnd)
{
rnd = vtkResliceRound(val);
}
#endif
#if (VTK_USE_INT16 != 0)
template <class F>
inline void vtkResliceRound(F val, vtkTypeInt16& rnd)
{
rnd = vtkResliceRound(val);
}
#endif
#if (VTK_USE_UINT16 != 0)
template <class F>
inline void vtkResliceRound(F val, vtkTypeUInt16& rnd)
{
rnd = vtkResliceRound(val);
}
#endif
#if (VTK_USE_INT32 != 0)
template <class F>
inline void vtkResliceRound(F val, vtkTypeInt32& rnd)
{
rnd = vtkResliceRound(val);
}
#endif
#if (VTK_USE_UINT32 != 0)
template <class F>
inline void vtkResliceRound(F val, vtkTypeUInt32& rnd)
{
rnd = vtkResliceRound(val);
}
#endif
#if (VTK_USE_FLOAT32 != 0)
template <class F>
inline void vtkResliceRound(F val, vtkTypeFloat32& rnd)
{
rnd = val;
}
#endif
#if (VTK_USE_FLOAT64 != 0)
template <class F>
inline void vtkResliceRound(F val, vtkTypeFloat64& rnd)
{
rnd = val;
}
#endif
//----------------------------------------------------------------------------
// clamping functions for each type
#if (VTK_USE_INT8 != 0)
template <class F>
inline void vtkResliceClamp(F val, vtkTypeInt8& clamp)
{
if (val < -128.0)
{
val = -128.0;
}
if (val > 127.0)
{
val = 127.0;
}
vtkResliceRound(val,clamp);
}
#endif
#if (VTK_USE_UINT8 != 0)
template <class F>
inline void vtkResliceClamp(F val, vtkTypeUInt8& clamp)
{
if (val < 0)
{
val = 0;
}
if (val > 255.0)
{
val = 255.0;
}
vtkResliceRound(val,clamp);
}
#endif
#if (VTK_USE_INT16 != 0)
template <class F>
inline void vtkResliceClamp(F val, vtkTypeInt16& clamp)
{
if (val < -32768.0)
{
val = -32768.0;
}
if (val > 32767.0)
{
val = 32767.0;
}
vtkResliceRound(val,clamp);
}
#endif
#if (VTK_USE_UINT16 != 0)
template <class F>
inline void vtkResliceClamp(F val, vtkTypeUInt16& clamp)
{
if (val < 0)
{
val = 0;
}
if (val > 65535.0)
{
val = 65535.0;
}
vtkResliceRound(val,clamp);
}
#endif
#if (VTK_USE_INT32 != 0)
template <class F>
inline void vtkResliceClamp(F val, vtkTypeInt32& clamp)
{
if (val < -2147483648.0)
{
val = -2147483648.0;
}
if (val > 2147483647.0)
{
val = 2147483647.0;
}
vtkResliceRound(val,clamp);
}
#endif
#if (VTK_USE_UINT32 != 0)
template <class F>
inline void vtkResliceClamp(F val, vtkTypeUInt32& clamp)
{
if (val < 0)
{
val = 0;
}
if (val > 4294967295.0)
{
val = 4294967295.0;
}
vtkResliceRound(val,clamp);
}
#endif
#if (VTK_USE_FLOAT32 != 0)
template <class F>
inline void vtkResliceClamp(F val, vtkTypeFloat32& clamp)
{
clamp = val;
}
#endif
#if (VTK_USE_FLOAT64 != 0)
template <class F>
inline void vtkResliceClamp(F val, vtkTypeFloat64& clamp)
{
clamp = val;
}
#endif
//----------------------------------------------------------------------------
// Perform a wrap to limit an index to [0,range).
// Ensures correct behaviour when the index is negative.
inline int vtkInterpolateWrap(int num, int range)
{
if ((num %= range) < 0)
{
num += range; // required for some % implementations
}
return num;
}
//----------------------------------------------------------------------------
// Perform a mirror to limit an index to [0,range).
inline int vtkInterpolateMirror(int num, int range)
{
if (num < 0)
{
num = -num - 1;
}
int count = num/range;
num %= range;
if (count & 0x1)
{
num = range - num - 1;
}
return num;
}
//----------------------------------------------------------------------------
// If the value is within one half voxel of the range [0,inExtX), then
// set it to "0" or "inExtX-1" as appropriate.
inline int vtkInterpolateBorder(int &inIdX0, int &inIdX1, int inExtX,
double fx)
{
if (inIdX0 >= 0 && inIdX1 < inExtX)
{
return 0;
}
if (inIdX0 == -1 && fx >= 0.5)
{
inIdX1 = inIdX0 = 0;
return 0;
}
if (inIdX0 == inExtX - 1 && fx < 0.5)
{
inIdX1 = inIdX0;
return 0;
}
return 1;
}
inline int vtkInterpolateBorderCheck(int inIdX0, int inIdX1, int inExtX,
double fx)
{
if ((inIdX0 >= 0 && inIdX1 < inExtX) ||
(inIdX0 == -1 && fx >= 0.5) ||
(inIdX0 == inExtX - 1 && fx < 0.5))
{
return 0;
}
return 1;
}
//----------------------------------------------------------------------------
// Do nearest-neighbor interpolation of the input data 'inPtr' of extent
// 'inExt' at the 'point'. The result is placed at 'outPtr'.
// If the lookup data is beyond the extent 'inExt', set 'outPtr' to
// the background color 'background'.
// The number of scalar components in the data is 'numscalars'
template <class F, class T>
static int vtkNearestNeighborInterpolation(T *&outPtr, const T *inPtr,
const int inExt[6],
const vtkIdType inInc[3],
int numscalars, const F point[3],
int mode, const T *background,
mitkVtkImageOverwrite *self)
{
int inIdX0 = vtkResliceRound(point[0]) - inExt[0];
int inIdY0 = vtkResliceRound(point[1]) - inExt[2];
int inIdZ0 = vtkResliceRound(point[2]) - inExt[4];
int inExtX = inExt[1] - inExt[0] + 1;
int inExtY = inExt[3] - inExt[2] + 1;
int inExtZ = inExt[5] - inExt[4] + 1;
if (inIdX0 < 0 || inIdX0 >= inExtX ||
inIdY0 < 0 || inIdY0 >= inExtY ||
inIdZ0 < 0 || inIdZ0 >= inExtZ)
{
if (mode == VTK_RESLICE_WRAP)
{
inIdX0 = vtkInterpolateWrap(inIdX0, inExtX);
inIdY0 = vtkInterpolateWrap(inIdY0, inExtY);
inIdZ0 = vtkInterpolateWrap(inIdZ0, inExtZ);
}
else if (mode == VTK_RESLICE_MIRROR)
{
inIdX0 = vtkInterpolateMirror(inIdX0, inExtX);
inIdY0 = vtkInterpolateMirror(inIdY0, inExtY);
inIdZ0 = vtkInterpolateMirror(inIdZ0, inExtZ);
}
else if (mode == VTK_RESLICE_BACKGROUND ||
mode == VTK_RESLICE_BORDER)
{
do
{
*outPtr++ = *background++;
}
while (--numscalars);
return 0;
}
else
{
return 0;
}
}
inPtr += inIdX0*inInc[0]+inIdY0*inInc[1]+inIdZ0*inInc[2];
do
{
if(!self->IsOverwriteMode())
{
//just copy from input to output
*outPtr++ = *inPtr++;
}
else
{
//copy from output to input in overwrite mode
*(const_cast<T*>(inPtr)) = *outPtr++;
inPtr++;
}
}
while (--numscalars);
return 1;
}
//--------------------------------------------------------------------------
// get appropriate interpolation function according to scalar type
template<class F>
static void vtkGetResliceInterpFunc(mitkVtkImageOverwrite *self,
int (**interpolate)(void *&outPtr,
const void *inPtr,
const int inExt[6],
const vtkIdType inInc[3],
int numscalars,
const F point[3],
int mode,
const void *background,
mitkVtkImageOverwrite *self))
{
int dataType = self->GetOutput()->GetScalarType();
switch (dataType)
{
vtkTemplateAliasMacro(*((int (**)(VTK_TT *&outPtr, const VTK_TT *inPtr,
const int inExt[6],
const vtkIdType inInc[3],
int numscalars, const F point[3],
int mode,
const VTK_TT *background,
mitkVtkImageOverwrite *self))interpolate) = \
&vtkNearestNeighborInterpolation);
default:
interpolate = 0;
}
}
//----------------------------------------------------------------------------
// Some helper functions for 'RequestData'
//----------------------------------------------------------------------------
//--------------------------------------------------------------------------
// pixel copy function, templated for different scalar types
template <class T>
struct vtkImageResliceSetPixels
{
static void Set(void *&outPtrV, const void *inPtrV, int numscalars, int n)
{
const T* inPtr = static_cast<const T*>(inPtrV);
T* outPtr = static_cast<T*>(outPtrV);
for (int i = 0; i < n; i++)
{
const T *tmpPtr = inPtr;
int m = numscalars;
do
{
*outPtr++ = *tmpPtr++;
}
while (--m);
}
outPtrV = outPtr;
}
// optimized for 1 scalar components
static void Set1(void *&outPtrV, const void *inPtrV,
int vtkNotUsed(numscalars), int n)
{
const T* inPtr = static_cast<const T*>(inPtrV);
T* outPtr = static_cast<T*>(outPtrV);
T val = *inPtr;
for (int i = 0; i < n; i++)
{
*outPtr++ = val;
}
outPtrV = outPtr;
}
};
// get a pixel copy function that is appropriate for the data type
static void vtkGetSetPixelsFunc(mitkVtkImageOverwrite *self,
void (**setpixels)(void *&out, const void *in,
int numscalars, int n))
{
int dataType = self->GetOutput()->GetScalarType();
int numscalars = self->GetOutput()->GetNumberOfScalarComponents();
switch (numscalars)
{
case 1:
switch (dataType)
{
vtkTemplateAliasMacro(
*setpixels = &vtkImageResliceSetPixels<VTK_TT>::Set1
);
default:
setpixels = 0;
}
default:
switch (dataType)
{
vtkTemplateAliasMacro(
*setpixels = &vtkImageResliceSetPixels<VTK_TT>::Set
);
default:
setpixels = 0;
}
}
}
//----------------------------------------------------------------------------
// Convert background color from float to appropriate type
template <class T>
static void vtkAllocBackgroundPixelT(mitkVtkImageOverwrite *self,
T **background_ptr, int numComponents)
{
*background_ptr = new T[numComponents];
T *background = *background_ptr;
for (int i = 0; i < numComponents; i++)
{
if (i < 4)
{
vtkResliceClamp(self->GetBackgroundColor()[i], background[i]);
}
else
{
background[i] = 0;
}
}
}
static void vtkAllocBackgroundPixel(mitkVtkImageOverwrite *self, void **rval,
int numComponents)
{
switch (self->GetOutput()->GetScalarType())
{
vtkTemplateAliasMacro(vtkAllocBackgroundPixelT(self, (VTK_TT **)rval,
numComponents));
}
}
static void vtkFreeBackgroundPixel(mitkVtkImageOverwrite *self, void **rval)
{
switch (self->GetOutput()->GetScalarType())
{
vtkTemplateAliasMacro(delete [] *((VTK_TT **)rval));
}
*rval = 0;
}
//----------------------------------------------------------------------------
// helper function for clipping of the output with a stencil
static int vtkResliceGetNextExtent(vtkImageStencilData *stencil,
int &r1, int &r2, int rmin, int rmax,
int yIdx, int zIdx,
void *&outPtr, void *background,
int numscalars,
void (*setpixels)(void *&out,
const void *in,
int numscalars,
int n),
int &iter)
{
// trivial case if stencil is not set
if (!stencil)
{
if (iter++ == 0)
{
r1 = rmin;
r2 = rmax;
return 1;
}
return 0;
}
// for clearing, start at last r2 plus 1
int clear1 = r2 + 1;
if (iter == 0)
{ // if no 'last time', start at rmin
clear1 = rmin;
}
int rval = stencil->GetNextExtent(r1, r2, rmin, rmax, yIdx, zIdx, iter);
int clear2 = r1 - 1;
if (rval == 0)
{
clear2 = rmax;
}
setpixels(outPtr, background, numscalars, clear2 - clear1 + 1);
return rval;
}
//----------------------------------------------------------------------------
// This function simply clears the entire output to the background color,
// for cases where the transformation places the output extent completely
// outside of the input extent.
static void vtkImageResliceClearExecute(mitkVtkImageOverwrite *self,
vtkImageData *, void *,
vtkImageData *outData, void *outPtr,
int outExt[6], int id)
{
int numscalars;
int idY, idZ;
vtkIdType outIncX, outIncY, outIncZ;
int scalarSize;
unsigned long count = 0;
unsigned long target;
void *background;
void (*setpixels)(void *&out, const void *in, int numscalars, int n);
// for the progress meter
target = static_cast<unsigned long>
((outExt[5]-outExt[4]+1)*(outExt[3]-outExt[2]+1)/50.0);
target++;
// Get Increments to march through data
outData->GetContinuousIncrements(outExt, outIncX, outIncY, outIncZ);
scalarSize = outData->GetScalarSize();
numscalars = outData->GetNumberOfScalarComponents();
// allocate a voxel to copy into the background (out-of-bounds) regions
vtkAllocBackgroundPixel(self, &background, numscalars);
// get the appropriate function for pixel copying
vtkGetSetPixelsFunc(self, &setpixels);
// Loop through output voxels
for (idZ = outExt[4]; idZ <= outExt[5]; idZ++)
{
for (idY = outExt[2]; idY <= outExt[3]; idY++)
{
if (id == 0)
{ // update the progress if this is the main thread
if (!(count%target))
{
self->UpdateProgress(count/(50.0*target));
}
count++;
}
// clear the pixels to background color and go to next row
setpixels(outPtr, background, numscalars, outExt[1]-outExt[0]+1);
outPtr = static_cast<void *>(
static_cast<char *>(outPtr) + outIncY*scalarSize);
}
outPtr = static_cast<void *>(
static_cast<char *>(outPtr) + outIncZ*scalarSize);
}
vtkFreeBackgroundPixel(self, &background);
}
//----------------------------------------------------------------------------
// This function executes the filter for any type of data. It is much simpler
// in structure than vtkImageResliceOptimizedExecute.
static void vtkImageResliceExecute(mitkVtkImageOverwrite *self,
vtkImageData *inData, void *inPtr,
vtkImageData *outData, void *outPtr,
int outExt[6], int id)
{
int numscalars;
int idX, idY, idZ;
int idXmin, idXmax, iter;
vtkIdType outIncX, outIncY, outIncZ;
int scalarSize;
int inExt[6];
vtkIdType inInc[3];
unsigned long count = 0;
unsigned long target;
double point[4];
double f;
double *inSpacing, *inOrigin, *outSpacing, *outOrigin, inInvSpacing[3];
void *background;
int (*interpolate)(void *&outPtr, const void *inPtr,
const int inExt[6], const vtkIdType inInc[3],
int numscalars, const double point[3],
int mode, const void *background, mitkVtkImageOverwrite *self);
void (*setpixels)(void *&out, const void *in, int numscalars, int n);
// the 'mode' species what to do with the 'pad' (out-of-bounds) area
int mode = VTK_RESLICE_BACKGROUND;
if (self->GetMirror())
{
mode = VTK_RESLICE_MIRROR;
}
else if (self->GetWrap())
{
mode = VTK_RESLICE_WRAP;
}
else if (self->GetBorder())
{
mode = VTK_RESLICE_BORDER;
}
// the transformation to apply to the data
vtkAbstractTransform *transform = self->GetResliceTransform();
vtkMatrix4x4 *matrix = self->GetResliceAxes();
// for conversion to data coordinates
inOrigin = inData->GetOrigin();
inSpacing = inData->GetSpacing();
outOrigin = outData->GetOrigin();
outSpacing = outData->GetSpacing();
// save effor later: invert inSpacing
inInvSpacing[0] = 1.0/inSpacing[0];
inInvSpacing[1] = 1.0/inSpacing[1];
inInvSpacing[2] = 1.0/inSpacing[2];
// find maximum input range
inData->GetExtent(inExt);
// for the progress meter
target = static_cast<unsigned long>
((outExt[5]-outExt[4]+1)*(outExt[3]-outExt[2]+1)/50.0);
target++;
// Get Increments to march through data
inData->GetIncrements(inInc);
outData->GetContinuousIncrements(outExt, outIncX, outIncY, outIncZ);
scalarSize = outData->GetScalarSize();
numscalars = inData->GetNumberOfScalarComponents();
// allocate a voxel to copy into the background (out-of-bounds) regions
vtkAllocBackgroundPixel(self, &background, numscalars);
// get the appropriate functions for interpolation and pixel copying
vtkGetResliceInterpFunc(self, &interpolate);
vtkGetSetPixelsFunc(self, &setpixels);
// get the stencil
vtkImageStencilData *stencil = self->GetStencil();
// Loop through output voxels
for (idZ = outExt[4]; idZ <= outExt[5]; idZ++)
{
for (idY = outExt[2]; idY <= outExt[3]; idY++)
{
if (id == 0)
{ // update the progress if this is the main thread
if (!(count%target))
{
self->UpdateProgress(count/(50.0*target));
}
count++;
}
iter = 0; // if there is a stencil, it is applied here
while (vtkResliceGetNextExtent(stencil, idXmin, idXmax,
outExt[0], outExt[1], idY, idZ,
outPtr, background, numscalars,
setpixels, iter))
{
for (idX = idXmin; idX <= idXmax; idX++)
{
// convert to data coordinates
point[0] = idX*outSpacing[0] + outOrigin[0];
point[1] = idY*outSpacing[1] + outOrigin[1];
point[2] = idZ*outSpacing[2] + outOrigin[2];
// apply ResliceAxes matrix
if (matrix)
{
point[3] = 1.0;
matrix->MultiplyPoint(point, point);
f = 1.0/point[3];
point[0] *= f;
point[1] *= f;
point[2] *= f;
}
// apply ResliceTransform
if (transform)
{
transform->InternalTransformPoint(point, point);
}
// convert back to voxel indices
point[0] = (point[0] - inOrigin[0])*inInvSpacing[0];
point[1] = (point[1] - inOrigin[1])*inInvSpacing[1];
point[2] = (point[2] - inOrigin[2])*inInvSpacing[2];
// interpolate output voxel from input data set
interpolate(outPtr, inPtr, inExt, inInc, numscalars,
point, mode, background, self);
}
}
outPtr = static_cast<void *>(
static_cast<char *>(outPtr) + outIncY*scalarSize);
}
outPtr = static_cast<void *>(
static_cast<char *>(outPtr) + outIncZ*scalarSize);
}
vtkFreeBackgroundPixel(self, &background);
}
void mitkVtkImageOverwrite::SetOverwriteMode(bool b){
m_Overwrite_Mode = b;
}
void mitkVtkImageOverwrite::SetInputSlice(vtkImageData* slice){
//set the output as input
this->SetOutput(slice);
}
//----------------------------------------------------------------------------
// This method is passed a input and output region, and executes the filter
// algorithm to fill the output from the input or vice versa.
void mitkVtkImageOverwrite::ThreadedRequestData(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **vtkNotUsed(inputVector),
vtkInformationVector *vtkNotUsed(outputVector),
vtkImageData ***inData,
vtkImageData **outData,
int outExt[6], int id)
{
vtkDebugMacro(<< "Execute: inData = " << inData[0][0]
<< ", outData = " << outData[0]);
// this filter expects that input is the same type as output.
if (inData[0][0]->GetScalarType() != outData[0]->GetScalarType())
{
vtkErrorMacro(<< "Execute: input ScalarType, "
<< inData[0][0]->GetScalarType()
<< ", must match out ScalarType "
<< outData[0]->GetScalarType());
return;
}
int inExt[6];
inData[0][0]->GetExtent(inExt);
// check for empty input extent
if (inExt[1] < inExt[0] ||
inExt[3] < inExt[2] ||
inExt[5] < inExt[4])
{
return;
}
// Get the output pointer
void *outPtr = outData[0]->GetScalarPointerForExtent(outExt);
if (this->HitInputExtent == 0)
{
vtkImageResliceClearExecute(this, inData[0][0], 0, outData[0], outPtr,
outExt, id);
return;
}
// Now that we know that we need the input, get the input pointer
void *inPtr = inData[0][0]->GetScalarPointerForExtent(inExt);
vtkImageResliceExecute(this, inData[0][0], inPtr, outData[0], outPtr,
outExt, id);
}
diff --git a/Modules/Segmentation/CMakeLists.txt b/Modules/Segmentation/CMakeLists.txt
index 133b39a60c..f156909325 100644
--- a/Modules/Segmentation/CMakeLists.txt
+++ b/Modules/Segmentation/CMakeLists.txt
@@ -1,10 +1,10 @@
#configure_file(${PROJECT_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in $#{PROJECT_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY)
#configure_file(${PROJECT_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in $#{PROJECT_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY)
#configure_file(${PROJECT_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in $#{PROJECT_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY)
MITK_CREATE_MODULE( Segmentation
INCLUDE_DIRS Algorithms Controllers DataManagement Interactions IO Rendering
- DEPENDS Mitk ipSegmentation mitkIpFunc MitkExt
+ DEPENDS Mitk ipSegmentation mitkIpFunc MitkExt MitkGraphAlgorithms
)
add_subdirectory(Testing)
\ No newline at end of file
diff --git a/Modules/Segmentation/Controllers/mitkSegmentationInterpolationController.cpp b/Modules/Segmentation/Controllers/mitkSegmentationInterpolationController.cpp
index d22dc0b2b5..d0980f0ff2 100644
--- a/Modules/Segmentation/Controllers/mitkSegmentationInterpolationController.cpp
+++ b/Modules/Segmentation/Controllers/mitkSegmentationInterpolationController.cpp
@@ -1,491 +1,489 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSegmentationInterpolationController.h"
#include "mitkImageCast.h"
#include "mitkImageAccessByItk.h"
-#include "mitkExtractImageFilter.h"
#include "mitkImageTimeSelector.h"
+#include <mitkExtractSliceFilter.h>
#include "mitkShapeBasedInterpolationAlgorithm.h"
#include <itkCommand.h>
#include <itkImage.h>
#include <itkImageSliceConstIteratorWithIndex.h>
mitk::SegmentationInterpolationController::InterpolatorMapType mitk::SegmentationInterpolationController::s_InterpolatorForImage; // static member initialization
mitk::SegmentationInterpolationController* mitk::SegmentationInterpolationController::InterpolatorForImage(const Image* image)
{
InterpolatorMapType::iterator iter = s_InterpolatorForImage.find( image );
if ( iter != s_InterpolatorForImage.end() )
{
return iter->second;
}
else
{
return NULL;
}
}
mitk::SegmentationInterpolationController::SegmentationInterpolationController()
:m_BlockModified(false)
{
}
void mitk::SegmentationInterpolationController::Activate2DInterpolation(bool status)
{
m_2DInterpolationActivated = status;
}
mitk::SegmentationInterpolationController::~SegmentationInterpolationController()
{
// remove this from the list of interpolators
for ( InterpolatorMapType::iterator iter = s_InterpolatorForImage.begin();
iter != s_InterpolatorForImage.end();
++iter )
{
if (iter->second == this)
{
s_InterpolatorForImage.erase( iter );
break;
}
}
}
void mitk::SegmentationInterpolationController::OnImageModified(const itk::EventObject&)
{
if (!m_BlockModified && m_Segmentation.IsNotNull() && m_2DInterpolationActivated )
{
SetSegmentationVolume( m_Segmentation );
}
}
void mitk::SegmentationInterpolationController::BlockModified(bool block)
{
m_BlockModified = block;
}
void mitk::SegmentationInterpolationController::SetSegmentationVolume( const Image* segmentation )
{
// clear old information (remove all time steps
m_SegmentationCountInSlice.clear();
// delete this from the list of interpolators
InterpolatorMapType::iterator iter = s_InterpolatorForImage.find( segmentation );
if ( iter != s_InterpolatorForImage.end() )
{
s_InterpolatorForImage.erase( iter );
}
if (!segmentation) return;
if (segmentation->GetDimension() > 4 || segmentation->GetDimension() < 3)
{
itkExceptionMacro("SegmentationInterpolationController needs a 3D-segmentation or 3D+t, not 2D.");
}
if (m_Segmentation != segmentation)
{
// observe Modified() event of image
itk::ReceptorMemberCommand<SegmentationInterpolationController>::Pointer command = itk::ReceptorMemberCommand<SegmentationInterpolationController>::New();
command->SetCallbackFunction( this, &SegmentationInterpolationController::OnImageModified );
segmentation->AddObserver( itk::ModifiedEvent(), command );
}
m_Segmentation = segmentation;
m_SegmentationCountInSlice.resize( m_Segmentation->GetTimeSteps() );
for (unsigned int timeStep = 0; timeStep < m_Segmentation->GetTimeSteps(); ++timeStep)
{
m_SegmentationCountInSlice[timeStep].resize(3);
for (unsigned int dim = 0; dim < 3; ++dim)
{
m_SegmentationCountInSlice[timeStep][dim].clear();
m_SegmentationCountInSlice[timeStep][dim].resize( m_Segmentation->GetDimension(dim) );
m_SegmentationCountInSlice[timeStep][dim].assign( m_Segmentation->GetDimension(dim), 0 );
}
}
s_InterpolatorForImage.insert( std::make_pair( m_Segmentation, this ) );
// for all timesteps
// scan whole image
for (unsigned int timeStep = 0; timeStep < m_Segmentation->GetTimeSteps(); ++timeStep)
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( m_Segmentation );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer segmentation3D = timeSelector->GetOutput();
AccessFixedDimensionByItk_2( segmentation3D, ScanWholeVolume, 3, m_Segmentation, timeStep );
}
//PrintStatus();
SetReferenceVolume( m_ReferenceImage );
Modified();
}
void mitk::SegmentationInterpolationController::SetReferenceVolume( const Image* referenceImage )
{
m_ReferenceImage = referenceImage;
if ( m_ReferenceImage.IsNull() ) return; // no image set - ignore it then
assert ( m_Segmentation.IsNotNull() ); // should never happen
// ensure the reference image has the same dimensionality and extents as the segmentation image
if ( m_ReferenceImage.IsNull()
|| m_Segmentation.IsNull()
|| m_ReferenceImage->GetDimension() != m_Segmentation->GetDimension()
|| m_ReferenceImage->GetPixelType().GetNumberOfComponents() != 1
|| m_Segmentation->GetPixelType().GetNumberOfComponents() != 1
)
{
MITK_WARN << "Segmentation image has different image characteristics than reference image." << std::endl;
m_ReferenceImage = NULL;
return;
}
for (unsigned int dim = 0; dim < m_Segmentation->GetDimension(); ++dim)
if ( m_ReferenceImage->GetDimension(dim) != m_Segmentation->GetDimension(dim) )
{
MITK_WARN << "original patient image does not match segmentation (different extent in dimension " << dim
<< "), ignoring patient image" << std::endl;
m_ReferenceImage = NULL;
return;
}
}
void mitk::SegmentationInterpolationController::SetChangedVolume( const Image* sliceDiff, unsigned int timeStep )
{
if ( !sliceDiff ) return;
if ( sliceDiff->GetDimension() != 3 ) return;
AccessFixedDimensionByItk_1( sliceDiff, ScanChangedVolume, 3, timeStep );
//PrintStatus();
Modified();
}
void mitk::SegmentationInterpolationController::SetChangedSlice( const Image* sliceDiff, unsigned int sliceDimension, unsigned int sliceIndex, unsigned int timeStep )
{
if ( !sliceDiff ) return;
if ( sliceDimension > 2 ) return;
if ( timeStep >= m_SegmentationCountInSlice.size() ) return;
if ( sliceIndex >= m_SegmentationCountInSlice[timeStep][sliceDimension].size() ) return;
unsigned int dim0(0);
unsigned int dim1(1);
// determine the other two dimensions
switch (sliceDimension)
{
default:
case 2:
dim0 = 0; dim1 = 1; break;
case 1:
dim0 = 0; dim1 = 2; break;
case 0:
dim0 = 1; dim1 = 2; break;
}
//mitkIpPicDescriptor* rawSlice = const_cast<Image*>(sliceDiff)->GetSliceData()->GetPicDescriptor(); // we promise not to change anything!
unsigned char* rawSlice = (unsigned char*) const_cast<Image*>(sliceDiff)->GetData();
if (!rawSlice) return;
AccessFixedDimensionByItk_1( sliceDiff, ScanChangedSlice, 2, SetChangedSliceOptions(sliceDimension, sliceIndex, dim0, dim1, timeStep, rawSlice) );
//PrintStatus();
Modified();
}
template < typename DATATYPE >
void mitk::SegmentationInterpolationController::ScanChangedSlice( itk::Image<DATATYPE, 2>*, const SetChangedSliceOptions& options )
{
DATATYPE* pixelData( (DATATYPE*)options.pixelData );
unsigned int timeStep( options.timeStep );
unsigned int sliceDimension( options.sliceDimension );
unsigned int sliceIndex( options.sliceIndex );
if ( sliceDimension > 2 ) return;
if ( sliceIndex >= m_SegmentationCountInSlice[timeStep][sliceDimension].size() ) return;
unsigned int dim0( options.dim0 );
unsigned int dim1( options.dim1 );
int numberOfPixels(0); // number of pixels in this slice that are not 0
unsigned int dim0max = m_SegmentationCountInSlice[timeStep][dim0].size();
unsigned int dim1max = m_SegmentationCountInSlice[timeStep][dim1].size();
// scan the slice from two directions
// and set the flags for the two dimensions of the slice
for (unsigned int v = 0; v < dim1max; ++v)
{
for (unsigned int u = 0; u < dim0max; ++u)
{
DATATYPE value = *(pixelData + u + v * dim0max);
assert ( (signed) m_SegmentationCountInSlice[timeStep][dim0][u] + (signed)value >= 0 ); // just for debugging. This must always be true, otherwise some counting is going wrong
assert ( (signed) m_SegmentationCountInSlice[timeStep][dim1][v] + (signed)value >= 0 );
m_SegmentationCountInSlice[timeStep][dim0][u] = static_cast<unsigned int>( m_SegmentationCountInSlice[timeStep][dim0][u] + value );
m_SegmentationCountInSlice[timeStep][dim1][v] = static_cast<unsigned int>( m_SegmentationCountInSlice[timeStep][dim1][v] + value );
numberOfPixels += static_cast<int>( value );
}
}
// flag for the dimension of the slice itself
assert ( (signed) m_SegmentationCountInSlice[timeStep][sliceDimension][sliceIndex] + numberOfPixels >= 0 );
m_SegmentationCountInSlice[timeStep][sliceDimension][sliceIndex] += numberOfPixels;
//MITK_INFO << "scan t=" << timeStep << " from (0,0) to (" << dim0max << "," << dim1max << ") (" << pixelData << "-" << pixelData+dim0max*dim1max-1 << ") in slice " << sliceIndex << " found " << numberOfPixels << " pixels" << std::endl;
}
template < typename TPixel, unsigned int VImageDimension >
void mitk::SegmentationInterpolationController::ScanChangedVolume( itk::Image<TPixel, VImageDimension>* diffImage, unsigned int timeStep )
{
typedef itk::ImageSliceConstIteratorWithIndex< itk::Image<TPixel, VImageDimension> > IteratorType;
IteratorType iter( diffImage, diffImage->GetLargestPossibleRegion() );
iter.SetFirstDirection(0);
iter.SetSecondDirection(1);
int numberOfPixels(0); // number of pixels in this slice that are not 0
typename IteratorType::IndexType index;
unsigned int x = 0;
unsigned int y = 0;
unsigned int z = 0;
iter.GoToBegin();
while ( !iter.IsAtEnd() )
{
while ( !iter.IsAtEndOfSlice() )
{
while ( !iter.IsAtEndOfLine() )
{
index = iter.GetIndex();
x = index[0];
y = index[1];
z = index[2];
TPixel value = iter.Get();
assert ( (signed) m_SegmentationCountInSlice[timeStep][0][x] + (signed)value >= 0 ); // just for debugging. This must always be true, otherwise some counting is going wrong
assert ( (signed) m_SegmentationCountInSlice[timeStep][1][y] + (signed)value >= 0 );
m_SegmentationCountInSlice[timeStep][0][x] = static_cast<unsigned int>( m_SegmentationCountInSlice[timeStep][0][x] + value );
m_SegmentationCountInSlice[timeStep][1][y] = static_cast<unsigned int>( m_SegmentationCountInSlice[timeStep][1][y] + value );
numberOfPixels += static_cast<int>( value );
++iter;
}
iter.NextLine();
}
assert ( (signed) m_SegmentationCountInSlice[timeStep][2][z] + numberOfPixels >= 0 );
m_SegmentationCountInSlice[timeStep][2][z] += numberOfPixels;
numberOfPixels = 0;
iter.NextSlice();
}
}
template < typename DATATYPE >
void mitk::SegmentationInterpolationController::ScanWholeVolume( itk::Image<DATATYPE, 3>*, const Image* volume, unsigned int timeStep )
{
if (!volume) return;
if ( timeStep >= m_SegmentationCountInSlice.size() ) return;
for (unsigned int slice = 0; slice < volume->GetDimension(2); ++slice)
{
DATATYPE* rawVolume = static_cast<DATATYPE*>( const_cast<Image*>(volume)->GetVolumeData(timeStep)->GetData() ); // we again promise not to change anything, we'll just count
//DATATYPE* rawSlice = static_cast<DATATYPE*>( volume->GetSliceData(slice)->GetData() ); // TODO THIS wouldn't work. Did I mess up with some internal mitk::Image data structure?
DATATYPE* rawSlice = rawVolume + ( volume->GetDimension(0) * volume->GetDimension(1) * slice );
ScanChangedSlice<DATATYPE>( NULL, SetChangedSliceOptions(2, slice, 0, 1, timeStep, rawSlice) );
}
}
void mitk::SegmentationInterpolationController::PrintStatus()
{
unsigned int timeStep(0); // if needed, put a loop over time steps around everyting, but beware, output will be long
MITK_INFO << "Interpolator status (timestep 0): dimensions "
<< m_SegmentationCountInSlice[timeStep][0].size() << " "
<< m_SegmentationCountInSlice[timeStep][1].size() << " "
<< m_SegmentationCountInSlice[timeStep][2].size() << std::endl;
MITK_INFO << "Slice 0: " << m_SegmentationCountInSlice[timeStep][2][0] << std::endl;
// row "x"
for (unsigned int index = 0; index < m_SegmentationCountInSlice[timeStep][0].size(); ++index)
{
if ( m_SegmentationCountInSlice[timeStep][0][index] > 0 )
MITK_INFO << "O";
else
MITK_INFO << ".";
}
MITK_INFO << std::endl;
// rows "y" and "z" (diagonal)
for (unsigned int index = 1; index < m_SegmentationCountInSlice[timeStep][1].size(); ++index)
{
if ( m_SegmentationCountInSlice[timeStep][1][index] > 0 )
MITK_INFO << "O";
else
MITK_INFO << ".";
if ( m_SegmentationCountInSlice[timeStep][2].size() > index ) // if we also have a z value here, then print it, too
{
for (unsigned int indent = 1; indent < index; ++indent)
MITK_INFO << " ";
if ( m_SegmentationCountInSlice[timeStep][2][index] > 0 )
MITK_INFO << m_SegmentationCountInSlice[timeStep][2][index];//"O";
else
MITK_INFO << ".";
}
MITK_INFO << std::endl;
}
// z indices that are larger than the biggest y index
for (unsigned int index = m_SegmentationCountInSlice[timeStep][1].size(); index < m_SegmentationCountInSlice[timeStep][2].size(); ++index)
{
for (unsigned int indent = 0; indent < index; ++indent)
MITK_INFO << " ";
if ( m_SegmentationCountInSlice[timeStep][2][index] > 0 )
MITK_INFO << m_SegmentationCountInSlice[timeStep][2][index];//"O";
else
MITK_INFO << ".";
MITK_INFO << std::endl;
}
}
mitk::Image::Pointer mitk::SegmentationInterpolationController::Interpolate( unsigned int sliceDimension, unsigned int sliceIndex, unsigned int timeStep )
{
if (m_Segmentation.IsNull()) return NULL;
if ( timeStep >= m_SegmentationCountInSlice.size() ) return NULL;
if ( sliceDimension > 2 ) return NULL;
unsigned int upperLimit = m_SegmentationCountInSlice[timeStep][sliceDimension].size();
if ( sliceIndex >= upperLimit - 1 ) return NULL; // can't interpolate first and last slice
if ( sliceIndex < 1 ) return NULL;
if ( m_SegmentationCountInSlice[timeStep][sliceDimension][sliceIndex] > 0 ) return NULL; // slice contains a segmentation, won't interpolate anything then
unsigned int lowerBound(0);
unsigned int upperBound(0);
bool bounds( false );
for (lowerBound = sliceIndex - 1; /*lowerBound >= 0*/; --lowerBound)
{
if ( m_SegmentationCountInSlice[timeStep][sliceDimension][lowerBound] > 0 )
{
bounds = true;
break;
}
if (lowerBound == 0) break; // otherwise overflow and start at something like 4294967295
}
if (!bounds) return NULL;
bounds = false;
for (upperBound = sliceIndex + 1 ; upperBound < upperLimit; ++upperBound)
{
if ( m_SegmentationCountInSlice[timeStep][sliceDimension][upperBound] > 0 )
{
bounds = true;
break;
}
}
if (!bounds) return NULL;
// ok, we have found two neighboring slices with segmentations (and we made sure that the current slice does NOT contain anything
//MITK_INFO << "Interpolate in timestep " << timeStep << ", dimension " << sliceDimension << ": estimate slice " << sliceIndex << " from slices " << lowerBound << " and " << upperBound << std::endl;
mitk::Image::Pointer lowerMITKSlice;
mitk::Image::Pointer upperMITKSlice;
mitk::Image::Pointer resultImage;
try
{
// extract the two neighoring slices from the segmentation volume
- ExtractImageFilter::Pointer extractor= ExtractImageFilter::New();
- extractor->SetInput( m_Segmentation );
- extractor->SetSliceDimension( sliceDimension );
- extractor->SetSliceIndex( lowerBound );
- extractor->SetTimeStep( timeStep );
+ mitk::ExtractSliceFilter::Pointer extractor = ExtractSliceFilter::New();
+ extractor->SetInput(m_Segmentation);
+ extractor->SetTimeStep(timeStep);
+ extractor->SetWorldGeometry(m_Segmentation->GetSlicedGeometry(timeStep)->GetGeometry2D(lowerBound));
+ extractor->SetVtkOutputRequest(false);
+ extractor->Modified();
extractor->Update();
lowerMITKSlice = extractor->GetOutput();
- lowerMITKSlice->DisconnectPipeline(); // otherwise the next output of the filter will overwrite this pointer, too
+ lowerMITKSlice->DisconnectPipeline();
- extractor->SetInput( m_Segmentation );
- extractor->SetSliceDimension( sliceDimension );
- extractor->SetSliceIndex( sliceIndex );
- extractor->SetTimeStep( timeStep );
+ extractor->SetWorldGeometry(m_Segmentation->GetSlicedGeometry(timeStep)->GetGeometry2D(sliceIndex));
+ extractor->Modified();
extractor->Update();
resultImage = extractor->GetOutput();
resultImage->DisconnectPipeline();
- extractor->SetInput( m_Segmentation );
- extractor->SetSliceDimension( sliceDimension );
- extractor->SetSliceIndex( upperBound );
- extractor->SetTimeStep( timeStep );
+ extractor->SetWorldGeometry(m_Segmentation->GetSlicedGeometry(timeStep)->GetGeometry2D(upperBound));
+ extractor->Modified();
extractor->Update();
upperMITKSlice = extractor->GetOutput();
+ upperMITKSlice->DisconnectPipeline();
if ( lowerMITKSlice.IsNull() || upperMITKSlice.IsNull() ) return NULL;
}
catch(...)
{
return NULL;
}
// interpolation algorithm gets some inputs
// two segmentations (guaranteed to be of the same data type, but no special data type guaranteed)
// orientation (sliceDimension) of the segmentations
// position of the two slices (sliceIndices)
// one volume image (original patient image)
//
// interpolation algorithm can use e.g. itk::ImageSliceConstIteratorWithIndex to
// inspect the original patient image at appropriate positions
mitk::SegmentationInterpolationAlgorithm::Pointer algorithm = mitk::ShapeBasedInterpolationAlgorithm::New().GetPointer();
return algorithm->Interpolate( lowerMITKSlice.GetPointer(), lowerBound,
upperMITKSlice.GetPointer(), upperBound,
sliceIndex,
sliceDimension,
resultImage,
timeStep,
m_ReferenceImage );
}
diff --git a/Modules/Segmentation/DataManagement/mitkContour.cpp b/Modules/Segmentation/DataManagement/mitkContour.cpp
index ebf3a2486a..25de442b69 100644
--- a/Modules/Segmentation/DataManagement/mitkContour.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContour.cpp
@@ -1,162 +1,162 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContour.h"
mitk::Contour::Contour() :
m_ContourPath (PathType::New()),
m_CurrentWindow ( NULL ),
m_BoundingBox (BoundingBoxType::New()),
m_Vertices ( BoundingBoxType::PointsContainer::New() ),
m_Closed ( true ),
m_Selected ( false ),
m_Width (3.0)
{
Superclass::InitializeTimeSlicedGeometry();
}
mitk::Contour::Contour( const Contour & other ): BaseData(other),
m_ContourPath(other.m_ContourPath),
m_CurrentWindow(other.m_CurrentWindow),
m_BoundingBox(other.m_BoundingBox),
m_Vertices(other.m_Vertices),
m_Closed(other.m_Closed),
m_Selected(other.m_Selected),
m_Width(other.m_Width)
{
}
mitk::Contour::~Contour()
{
}
void mitk::Contour::AddVertex(mitk::Point3D newPoint)
{
BoundingBoxType::PointType p;
p.CastFrom(newPoint);
m_Vertices->InsertElement(m_Vertices->Size(), p);
ContinuousIndexType idx;
idx.CastFrom(newPoint);
m_ContourPath->AddVertex(idx);
m_BoundingBox->SetPoints(m_Vertices);
Modified();
}
void mitk::Contour::UpdateOutputInformation()
{
// \todo probably we should do this additionally for each time-step
float mitkBounds[6];
if (m_Vertices->Size() == 0) {
mitkBounds[0] = 0.0;
mitkBounds[1] = 0.0;
mitkBounds[2] = 0.0;
mitkBounds[3] = 0.0;
mitkBounds[4] = 0.0;
mitkBounds[5] = 0.0;
}
else
{
m_BoundingBox->ComputeBoundingBox();
BoundingBoxType::BoundsArrayType tmp = m_BoundingBox->GetBounds();
mitkBounds[0] = tmp[0];
mitkBounds[1] = tmp[1];
mitkBounds[2] = tmp[2];
mitkBounds[3] = tmp[3];
mitkBounds[4] = tmp[4];
mitkBounds[5] = tmp[5];
}
Geometry3D* geometry3d = GetGeometry(0);
geometry3d->SetBounds(mitkBounds);
GetTimeSlicedGeometry()->UpdateInformation();
}
void mitk::Contour::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::Contour::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::Contour::VerifyRequestedRegion()
{
return true;
}
-void mitk::Contour::SetRequestedRegion(itk::DataObject*)
+void mitk::Contour::SetRequestedRegion( const itk::DataObject*)
{
}
mitk::Contour::PathType::Pointer mitk::Contour::GetContourPath() const
{
return m_ContourPath;
}
void mitk::Contour::SetCurrentWindow(vtkRenderWindow* rw)
{
m_CurrentWindow = rw;
}
vtkRenderWindow* mitk::Contour::GetCurrentWindow() const
{
return m_CurrentWindow;
}
void mitk::Contour::Initialize()
{
m_ContourPath = PathType::New();
m_ContourPath->Initialize();
m_BoundingBox = BoundingBoxType::New();
m_Vertices = BoundingBoxType::PointsContainer::New();
GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
}
unsigned int mitk::Contour::GetNumberOfPoints() const
{
return m_Vertices->Size();
}
mitk::Contour::PointsContainerPointer
mitk::Contour::GetPoints() const
{
return m_Vertices;
}
void mitk::Contour::SetPoints(mitk::Contour::PointsContainerPointer points)
{
m_Vertices = points;
Modified();
}
void mitk::Contour::PrintSelf( std::ostream& os, itk::Indent indent) const
{
Superclass::PrintSelf( os, indent );
os << indent << "Number of verticies: " << GetNumberOfPoints() << std::endl;
mitk::Contour::PointsContainerIterator pointsIt = m_Vertices->Begin(), end = m_Vertices->End();
os << indent << "Verticies: " << std::endl;
int i = 0;
while ( pointsIt != end )
{
os << indent << indent << i << ": " << pointsIt.Value() << std::endl;
++pointsIt; ++i;
}
}
diff --git a/Modules/Segmentation/DataManagement/mitkContour.h b/Modules/Segmentation/DataManagement/mitkContour.h
index 583ce0ff49..e1ecb164e7 100644
--- a/Modules/Segmentation/DataManagement/mitkContour.h
+++ b/Modules/Segmentation/DataManagement/mitkContour.h
@@ -1,182 +1,182 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_CONTOUR_H_
#define _MITK_CONTOUR_H_
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkBaseData.h"
#include <vtkRenderWindow.h>
#include <itkPolyLineParametricPath.h>
namespace mitk
{
/**
* This class holds stores vertices for drawing a contour
*
*/
class Segmentation_EXPORT Contour : public BaseData
{
public:
mitkClassMacro(Contour, BaseData);
itkNewMacro(Self);
mitkCloneMacro(Contour);
typedef itk::PolyLineParametricPath<3> PathType;
typedef PathType::Pointer PathPointer;
typedef PathType::ContinuousIndexType ContinuousIndexType;
typedef PathType::InputType InputType;
typedef PathType::OutputType OutputType;
typedef PathType::OffsetType OffsetType;
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
typedef BoundingBoxType::PointsContainer PointsContainer;
typedef BoundingBoxType::PointsContainer::Pointer PointsContainerPointer;
typedef BoundingBoxType::PointsContainerIterator PointsContainerIterator;
/**
* sets whether the contour should be closed or open.
* by default the contour is closed
*/
itkSetMacro(Closed, bool);
/**
* returns if the contour is closed or opened
*/
itkGetMacro(Closed, bool);
itkSetMacro(Selected, bool);
itkGetMacro(Selected, bool);
itkSetMacro(Width, float);
itkGetMacro(Width, float);
/**
* clean up the contour data
*/
void Initialize();
/**
* add a new vertex to the contour
*/
void AddVertex(mitk::Point3D newPoint);
/**
* return an itk parametric path of the contour
*/
PathPointer GetContourPath() const;
/**
* set the current render window. This is helpful if one
* wants to draw the contour in one special window only.
*/
void SetCurrentWindow(vtkRenderWindow* rw);
/**
* returns the points to the current render window
*/
vtkRenderWindow* GetCurrentWindow() const;
/**
* returns the number of points stored in the contour
*/
unsigned int GetNumberOfPoints() const;
/**
* returns the container of the contour points
*/
PointsContainerPointer GetPoints() const;
/**
* set the contour points container.
*/
void SetPoints(PointsContainerPointer points);
/**
* intherited from parent
*/
virtual void UpdateOutputInformation();
/**
* intherited from parent
*/
virtual void SetRequestedRegionToLargestPossibleRegion();
/**
* intherited from parent
*/
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
/**
* intherited from parent
*/
virtual bool VerifyRequestedRegion();
/**
* intherited from parent
*/
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion( const itk::DataObject *data);
protected:
Contour();
Contour(const Contour & other);
virtual ~Contour();
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
private:
/**
* parametric path of a contour;
*/
PathType::Pointer m_ContourPath;
/**
* the current render window
*/
vtkRenderWindow* m_CurrentWindow;
/**
* the bounding box of the contour
*/
BoundingBoxType::Pointer m_BoundingBox;
/**
* container for all contour points
*/
BoundingBoxType::PointsContainer::Pointer m_Vertices;
/**
* decide whether th contour is open or closed
*/
bool m_Closed;
bool m_Selected;
float m_Width;
};
} // namespace mitk
#endif //_MITK_CONTOUR_H_
diff --git a/Modules/Segmentation/DataManagement/mitkContourElement.cpp b/Modules/Segmentation/DataManagement/mitkContourElement.cpp
index 02357705ba..747103e930 100644
--- a/Modules/Segmentation/DataManagement/mitkContourElement.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContourElement.cpp
@@ -1,351 +1,345 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkContourElement.h>
mitk::ContourElement::ContourElement()
{
this->m_Vertices = new VertexListType();
this->m_IsClosed = false;
}
mitk::ContourElement::ContourElement(const mitk::ContourElement &other) :
m_Vertices(other.m_Vertices), m_IsClosed(other.m_IsClosed)
{
}
mitk::ContourElement::~ContourElement()
{
delete this->m_Vertices;
}
void mitk::ContourElement::AddVertex(mitk::Point3D &vertex, bool isControlPoint)
{
this->m_Vertices->push_back(new VertexType(vertex, isControlPoint));
}
void mitk::ContourElement::AddVertex(VertexType &vertex)
{
this->m_Vertices->push_back(&vertex);
}
void mitk::ContourElement::AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint)
{
this->m_Vertices->push_front(new VertexType(vertex, isControlPoint));
}
void mitk::ContourElement::AddVertexAtFront(VertexType &vertex)
{
this->m_Vertices->push_front(&vertex);
}
void mitk::ContourElement::InsertVertexAtIndex(mitk::Point3D &vertex, bool isControlPoint, int index)
{
if(index > 0 && this->GetSize() > index)
{
VertexIterator _where = this->m_Vertices->begin();
_where += index;
this->m_Vertices->insert(_where, new VertexType(vertex, isControlPoint));
}
}
mitk::ContourElement::VertexType* mitk::ContourElement::GetVertexAt(int index)
{
return this->m_Vertices->at(index);
}
mitk::ContourElement::VertexType* mitk::ContourElement::GetVertexAt(const mitk::Point3D &point, float eps)
{
/* current version iterates over the whole deque - should some kind of an octree with spatial query*/
if(eps > 0)
{
- if(true ) //currently no method with better performance is available
- {
- return BruteForceGetVertexAt(point, eps);
- }
- else
- {
- return OptimizedGetVertexAt(point, eps);
- }
+ //currently no method with better performance is available
+ return BruteForceGetVertexAt(point, eps);
}//if eps < 0
return NULL;
}
mitk::ContourElement::VertexType* mitk::ContourElement::BruteForceGetVertexAt(const mitk::Point3D &point, float eps)
{
if(eps > 0)
{
std::deque< std::pair<double, VertexType*> > nearestlist;
ConstVertexIterator it = this->m_Vertices->begin();
ConstVertexIterator end = this->m_Vertices->end();
while(it != end)
{
mitk::Point3D currentPoint = (*it)->Coordinates;
double distance = currentPoint.EuclideanDistanceTo(point);
if(distance < eps)
{
//if list is emtpy, add point to list
if(nearestlist.size() < 1)
{
nearestlist.push_front(std::pair<double, VertexType*>( (*it)->Coordinates.EuclideanDistanceTo(point), (*it) ));
}
//found an approximate point - check if current is closer then first in nearestlist
else if( distance < nearestlist.front().first )
{
//found even closer vertex
nearestlist.push_front(std::pair<double, VertexType*>( (*it)->Coordinates.EuclideanDistanceTo(point), (*it) ));
}
}//if distance > eps
it++;
}//while
if(nearestlist.size() > 0)
{
/*++++++++++++++++++++ return the nearest active point if one was found++++++++++++++++++*/
std::deque< std::pair<double, VertexType*> >::iterator it = nearestlist.begin();
std::deque< std::pair<double, VertexType*> >::iterator end = nearestlist.end();
while(it != end)
{
if( (*it).second->IsControlPoint )
{
return (*it).second;
}
it++;
}
/*---------------------------------------------------------------------------------------*/
//return closest point
return nearestlist.front().second;
}
}
return NULL;
}
mitk::ContourElement::VertexType* mitk::ContourElement::OptimizedGetVertexAt(const mitk::Point3D &point, float eps)
{
if( (eps > 0) && (this->m_Vertices->size()>0) )
{
int k = 1;
int dim = 3;
int nPoints = this->m_Vertices->size();
ANNpointArray pointsArray;
ANNpoint queryPoint;
ANNidxArray indexArray;
ANNdistArray distanceArray;
ANNkd_tree* kdTree;
queryPoint = annAllocPt(dim);
pointsArray = annAllocPts(nPoints, dim);
indexArray = new ANNidx[k];
distanceArray = new ANNdist[k];
int i = 0;
//fill points array with our control points
for(VertexIterator it = this->m_Vertices->begin(); it != this->m_Vertices->end(); it++, i++)
{
mitk::Point3D cur = (*it)->Coordinates;
pointsArray[i][0]= cur[0];
pointsArray[i][1]= cur[1];
pointsArray[i][2]= cur[2];
}
//create the kd tree
kdTree = new ANNkd_tree(pointsArray,nPoints, dim);
//fill mitk::Point3D into ANN query point
queryPoint[0] = point[0];
queryPoint[1] = point[1];
queryPoint[2] = point[2];
//k nearest neighbour search
kdTree->annkSearch(queryPoint, k, indexArray, distanceArray, eps);
VertexType* ret = NULL;
try
{
ret = this->m_Vertices->at(indexArray[0]);
}
catch(std::out_of_range ex)
{
//ret stays NULL
return ret;
}
//clean up ANN
delete [] indexArray;
delete [] distanceArray;
delete kdTree;
annClose();
return ret;
}
return NULL;
}
mitk::ContourElement::VertexListType* mitk::ContourElement::GetVertexList()
{
return this->m_Vertices;
}
bool mitk::ContourElement::IsClosed()
{
return this->m_IsClosed;
}
void mitk::ContourElement::Close()
{
this->m_IsClosed = true;
}
void mitk::ContourElement::Open()
{
this->m_IsClosed = false;
}
void mitk::ContourElement::SetIsClosed( bool isClosed)
{
isClosed ? this->Close() : this->Open();
}
void mitk::ContourElement::Concatenate(mitk::ContourElement* other)
{
if( other->GetSize() > 0)
{
ConstVertexIterator it = other->m_Vertices->begin();
ConstVertexIterator end = other->m_Vertices->end();
//add all vertices of other after last vertex
while(it != end)
{
this->m_Vertices->push_back(*it);
it++;
}
}
}
bool mitk::ContourElement::RemoveVertex(mitk::ContourElement::VertexType* vertex)
{
VertexIterator it = this->m_Vertices->begin();
VertexIterator end = this->m_Vertices->end();
//search for vertex and remove it if exists
while(it != end)
{
if((*it) == vertex)
{
this->m_Vertices->erase(it);
return true;
}
it++;
}
return false;
}
bool mitk::ContourElement::RemoveVertexAt(int index)
{
if( index >= 0 && index < this->m_Vertices->size() )
{
this->m_Vertices->erase(this->m_Vertices->begin()+index);
return true;
}
else
{
return false;
}
}
bool mitk::ContourElement::RemoveVertexAt(mitk::Point3D &point, float eps)
{
/* current version iterates over the whole deque - should be some kind of an octree with spatial query*/
if(eps > 0){
VertexIterator it = this->m_Vertices->begin();
VertexIterator end = this->m_Vertices->end();
while(it != end)
{
mitk::Point3D currentPoint = (*it)->Coordinates;
if(currentPoint.EuclideanDistanceTo(point) < eps)
{
//approximate point found
//now erase it
this->m_Vertices->erase(it);
return true;
}
it++;
}
}
return false;
}
void mitk::ContourElement::Clear()
{
this->m_Vertices->clear();
}
diff --git a/Modules/Segmentation/DataManagement/mitkContourModel.cpp b/Modules/Segmentation/DataManagement/mitkContourModel.cpp
index c70fea2d3c..a7da7afaad 100644
--- a/Modules/Segmentation/DataManagement/mitkContourModel.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContourModel.cpp
@@ -1,552 +1,552 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkContourModel.h>
#include <mitkPlaneGeometry.h>
mitk::ContourModel::ContourModel()
{
//set to initial state
this->InitializeEmpty();
}
mitk::ContourModel::ContourModel(const mitk::ContourModel &other) :
m_ContourSeries(other.m_ContourSeries), m_lineInterpolation(other.m_lineInterpolation)
{
m_SelectedVertex = NULL;
}
mitk::ContourModel::~ContourModel()
{
m_SelectedVertex = NULL;
this->m_ContourSeries.clear();//TODO check destruction
}
void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep) )
{
this->AddVertex(vertex, false, timestep);
}
}
void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertex(vertex, isControlPoint);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
void mitk::ContourModel::AddVertex(VertexType &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertex(vertex);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep) )
{
this->AddVertexAtFront(vertex, false, timestep);
}
}
void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertexAtFront(vertex, isControlPoint);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
void mitk::ContourModel::AddVertexAtFront(VertexType &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertexAtFront(vertex);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
void mitk::ContourModel::InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(index > 0 && this->m_ContourSeries[timestep]->GetSize() > index)
{
this->m_ContourSeries[timestep]->InsertVertexAtIndex(vertex, isControlPoint, index);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
}
int mitk::ContourModel::GetNumberOfVertices( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->GetSize();
}
return -1;
}
const mitk::ContourModel::VertexType* mitk::ContourModel::GetVertexAt(int index, int timestep) const
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->GetVertexAt(index);
}
return NULL;
}
void mitk::ContourModel::Close( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->Close();
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();
}
}
void mitk::ContourModel::Open( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->Open();
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();
}
}
void mitk::ContourModel::SetIsClosed(bool isClosed, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->SetIsClosed(isClosed);
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();
}
}
bool mitk::ContourModel::IsEmptyTimeStep( int t) const
{
return (t < 0) || (this->m_ContourSeries.size() <= t);
}
void mitk::ContourModel::Concatenate(mitk::ContourModel* other, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if( !this->m_ContourSeries[timestep]->IsClosed() )
{
this->m_ContourSeries[timestep]->Concatenate(other->m_ContourSeries[timestep]);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
}
mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorBegin( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IteratorBegin();
}
else
{
mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
}
}
mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorEnd( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IteratorEnd();
}
else
{
mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
}
}
bool mitk::ContourModel::IsClosed( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IsClosed();
}
return false;
}
bool mitk::ContourModel::SelectVertexAt(int index, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return (this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(index));
}
return false;
}
bool mitk::ContourModel::SelectVertexAt(mitk::Point3D &point, float eps, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
}
return this->m_SelectedVertex != NULL;
}
bool mitk::ContourModel::RemoveVertex(VertexType* vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(this->m_ContourSeries[timestep]->RemoveVertex(vertex))
{
this->Modified();
this->InvokeEvent( ContourModelSizeChangeEvent() );
return true;
}
}
return false;
}
bool mitk::ContourModel::RemoveVertexAt(int index, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(this->m_ContourSeries[timestep]->RemoveVertexAt(index))
{
this->Modified();
this->InvokeEvent( ContourModelSizeChangeEvent() );
return true;
}
}
return false;
}
bool mitk::ContourModel::RemoveVertexAt(mitk::Point3D &point, float eps, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(this->m_ContourSeries[timestep]->RemoveVertexAt(point, eps))
{
this->Modified();
this->InvokeEvent( ContourModelSizeChangeEvent() );
return true;
}
}
return false;
}
void mitk::ContourModel::ShiftSelectedVertex(mitk::Vector3D &translate)
{
if(this->m_SelectedVertex)
{
this->ShiftVertex(this->m_SelectedVertex,translate);
this->Modified();
}
}
void mitk::ContourModel::ShiftContour(mitk::Vector3D &translate, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
VertexListType* vList = this->m_ContourSeries[timestep]->GetVertexList();
VertexIterator it = vList->begin();
VertexIterator end = vList->end();
//shift all vertices
while(it != end)
{
this->ShiftVertex((*it),translate);
it++;
}
this->Modified();
this->InvokeEvent( ContourModelShiftEvent() );
}
}
void mitk::ContourModel::ShiftVertex(VertexType* vertex, mitk::Vector3D &vector)
{
vertex->Coordinates[0] += vector[0];
vertex->Coordinates[1] += vector[1];
vertex->Coordinates[2] += vector[2];
}
void mitk::ContourModel::Clear(int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
//clear data at timestep
this->m_ContourSeries[timestep]->Clear();
this->InitializeEmpty();
this->Modified();
}
}
void mitk::ContourModel::Expand( int timeSteps )
{
int oldSize = this->m_ContourSeries.size();
if( timeSteps > 0 && timeSteps > oldSize )
{
Superclass::Expand(timeSteps);
//insert contours for each new timestep
for( int i = oldSize; i < timeSteps; i++)
{
m_ContourSeries.push_back(mitk::ContourElement::New());
}
this->InvokeEvent( ContourModelExpandTimeBoundsEvent() );
}
}
void mitk::ContourModel::SetRequestedRegionToLargestPossibleRegion ()
{
//no support for regions
}
bool mitk::ContourModel::RequestedRegionIsOutsideOfTheBufferedRegion ()
{
//no support for regions
return false;
}
bool mitk::ContourModel::VerifyRequestedRegion ()
{
//no support for regions
return true;
}
const mitk::Geometry3D * mitk::ContourModel::GetUpdatedGeometry (int t)
{
return Superclass::GetUpdatedGeometry(t);
}
mitk::Geometry3D* mitk::ContourModel::GetGeometry (int t)const
{
return Superclass::GetGeometry(t);
}
-void mitk::ContourModel::SetRequestedRegion (itk::DataObject *data)
+void mitk::ContourModel::SetRequestedRegion( const itk::DataObject *data)
{
//no support for regions
}
void mitk::ContourModel::Clear()
{
//clear data and set to initial state again
this->ClearData();
this->InitializeEmpty();
this->Modified();
}
void mitk::ContourModel::ClearData()
{
//call the superclass, this releases the data of BaseData
Superclass::ClearData();
//clear out the time resolved contours
this->m_ContourSeries.clear();
}
void mitk::ContourModel::InitializeEmpty()
{
//clear data at timesteps
this->m_ContourSeries.resize(0);
this->m_ContourSeries.push_back(mitk::ContourElement::New());
//set number of timesteps to one
this->InitializeTimeSlicedGeometry(1);
m_SelectedVertex = NULL;
this->m_lineInterpolation = ContourModel::LINEAR;
}
void mitk::ContourModel::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
//update the bounds of the geometry according to the stored vertices
float mitkBounds[6];
//calculate the boundingbox at each timestep
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
typedef BoundingBoxType::PointsContainer PointsContainer;
int timesteps = this->GetTimeSteps();
//iterate over the timesteps
for(int currenTimeStep = 0; currenTimeStep < timesteps; currenTimeStep++)
{
if( dynamic_cast< mitk::PlaneGeometry* >(this->GetGeometry(currenTimeStep)) )
{
//do not update bounds for 2D geometries, as they are unfortunately defined with min bounds 0!
return;
}
else
{//we have a 3D geometry -> let's update bounds
//only update bounds if the contour was modified
if (this->GetMTime() > this->GetGeometry(currenTimeStep)->GetBoundingBox()->GetMTime())
{
mitkBounds[0] = 0.0;
mitkBounds[1] = 0.0;
mitkBounds[2] = 0.0;
mitkBounds[3] = 0.0;
mitkBounds[4] = 0.0;
mitkBounds[5] = 0.0;
BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
PointsContainer::Pointer points = PointsContainer::New();
VertexIterator it = this->IteratorBegin(currenTimeStep);
VertexIterator end = this->IteratorEnd(currenTimeStep);
//fill the boundingbox with the points
while(it != end)
{
Point3D currentP = (*it)->Coordinates;
BoundingBoxType::PointType p;
p.CastFrom(currentP);
points->InsertElement(points->Size(), p);
it++;
}
//construct the new boundingBox
boundingBox->SetPoints(points);
boundingBox->ComputeBoundingBox();
BoundingBoxType::BoundsArrayType tmp = boundingBox->GetBounds();
mitkBounds[0] = tmp[0];
mitkBounds[1] = tmp[1];
mitkBounds[2] = tmp[2];
mitkBounds[3] = tmp[3];
mitkBounds[4] = tmp[4];
mitkBounds[5] = tmp[5];
//set boundingBox at current timestep
Geometry3D* geometry3d = this->GetGeometry(currenTimeStep);
geometry3d->SetBounds(mitkBounds);
}
}
}
GetTimeSlicedGeometry()->UpdateInformation();
}
void mitk::ContourModel::ExecuteOperation(mitk::Operation* operation)
{
//not supported yet
}
diff --git a/Modules/Segmentation/DataManagement/mitkContourModel.h b/Modules/Segmentation/DataManagement/mitkContourModel.h
index 9980cbb6a4..f5c04594bb 100644
--- a/Modules/Segmentation/DataManagement/mitkContourModel.h
+++ b/Modules/Segmentation/DataManagement/mitkContourModel.h
@@ -1,397 +1,397 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_CONTOURMODEL_H_
#define _MITK_CONTOURMODEL_H_
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkBaseData.h"
#include <mitkContourElement.h>
namespace mitk
{
/**
\brief ContourModel is a structure of linked vertices defining a contour in 3D space.
The vertices are stored in a mitk::ContourElement is stored for each timestep.
The contour line segments are implicitly defined by the given linked vertices.
By default two control points are are linked by a straight line.It is possible to add
vertices at front and end of the contour and to iterate in both directions.
Points are specified containing coordinates and additional (data) information,
see mitk::ContourElement.
For accessing a specific vertex either an index or a position in 3D Space can be used.
The vertices are best accessed by using a VertexIterator.
Interaction with the contour is thus available without any mitk interactor class using the
api of ContourModel. It is possible to shift single vertices also as shifting the whole
contour.
A contour can be either open like a single curved line segment or
closed. A closed contour can for example represent a jordan curve.
\section mitkPointSetDisplayOptions
The default mappers for this data structure are mitk::ContourModelGLMapper2D and
mitk::ContourModelMapper3D. See these classes for display options which can
can be set via properties.
*/
class Segmentation_EXPORT ContourModel : public BaseData
{
public:
mitkClassMacro(ContourModel, BaseData);
itkNewMacro(Self);
mitkCloneMacro(Self);
/*+++++++++++++++ typedefs +++++++++++++++++++++++++++++++*/
typedef mitk::ContourElement::VertexType VertexType;
typedef mitk::ContourElement::VertexListType VertexListType;
typedef mitk::ContourElement::VertexIterator VertexIterator;
typedef std::vector< mitk::ContourElement::Pointer > ContourModelSeries;
/*+++++++++++++++ END typedefs ++++++++++++++++++++++++++++*/
/** \brief Possible interpolation of the line segments between control points */
enum LineSegmentInterpolation{
LINEAR, B_SPLINE
};
/*++++++++++++++++ inline methods +++++++++++++++++++++++*/
/** \brief Get the current selected vertex.
*/
VertexType* GetSelectedVertex()
{
return this->m_SelectedVertex;
}
/** \brief Deselect vertex.
*/
void Deselect()
{
this->m_SelectedVertex = NULL;
}
/** \brief Deselect vertex.
*/
void SetSelectedVertexAsControlPoint(bool isControlPoint=true)
{
if(this->m_SelectedVertex && (this->m_SelectedVertex->IsControlPoint != isControlPoint) )
{
m_SelectedVertex->IsControlPoint = isControlPoint;
this->Modified();
}
}
/** \brief Set the interpolation of the line segments between control points.
*/
void SetLineSegmentInterpolation(LineSegmentInterpolation interpolation)
{
this->m_lineInterpolation = interpolation;
this->Modified();
}
/** \brief Get the interpolation of the line segments between control points.
*/
LineSegmentInterpolation GetLineSegmentInterpolation()
{
return this->m_lineInterpolation;
}
/*++++++++++++++++ END inline methods +++++++++++++++++++++++*/
/** \brief Add a vertex to the contour at given timestep.
The vertex is added at the end of contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeSlicedGeometry will not be expanded.
*/
void AddVertex(mitk::Point3D &vertex, int timestep=0);
/** \brief Add a vertex to the contour at given timestep.
The vertex is added at the end of contour.
\param vertex - coordinate representation of a control point
\param timestep - the timestep at which the vertex will be add ( default 0)
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeSlicedGeometry will not be expanded.
*/
void AddVertex(VertexType &vertex, int timestep=0);
/** \brief Add a vertex to the contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
\pararm isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
will be rendered).
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeSlicedGeometry will not be expanded.
*/
void AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep=0);
/** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
The vertex is added at the FRONT of contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeSlicedGeometry will not be expanded.
*/
void AddVertexAtFront(mitk::Point3D &vertex, int timestep=0);
/** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
The vertex is added at the FRONT of contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeSlicedGeometry will not be expanded.
*/
void AddVertexAtFront(VertexType &vertex, int timestep=0);
/** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
\pararm isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
will be rendered).
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeSlicedGeometry will not be expanded.
*/
void AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep=0);
/** \brief Insert a vertex at given index.
*/
void InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint=false, int timestep=0);
/** \brief Return if the contour is closed or not.
*/
bool IsClosed( int timestep=0);
/** \brief Concatenate two contours.
The starting control point of the other will be added at the end of the contour.
*/
void Concatenate(mitk::ContourModel* other, int timestep=0);
/** \brief Returns a const VertexIterator at the start element of the contour.
@throw mitk::Exception if the timestep is invalid.
*/
VertexIterator IteratorBegin( int timestep=0);
/** \brief Close the contour.
The last control point will be linked with the first point.
*/
virtual void Close( int timestep=0);
/** \brief Set isClosed to false contour.
The link between the last control point the first point will be removed.
*/
virtual void Open( int timestep=0);
/** \brief Set isClosed to given boolean.
false - The link between the last control point the first point will be removed.
true - The last control point will be linked with the first point.
*/
virtual void SetIsClosed(bool isClosed, int timestep=0);
/** \brief Returns a const VertexIterator at the end element of the contour.
@throw mitk::Exception if the timestep is invalid.
*/
VertexIterator IteratorEnd( int timestep=0);
/** \brief Returns the number of vertices at a given timestep.
\pararm timestep - default = 0
*/
int GetNumberOfVertices( int timestep=0);
/** \brief Returns the vertex at the index position within the container.
*/
virtual const VertexType* GetVertexAt(int index, int timestep=0) const;
/** \brief Check if there isn't something at this timestep.
*/
virtual bool IsEmptyTimeStep( int t) const;
/** \brief Mark a vertex at an index in the container as selected.
*/
bool SelectVertexAt(int index, int timestep=0);
/** \brief Mark a vertex at a given position in 3D space.
\pararm point - query point in 3D space
\pararm eps - radius for nearest neighbour search (error bound).
\pararm timestep - search at this timestep
@return true = vertex found; false = no vertex found
*/
bool SelectVertexAt(mitk::Point3D &point, float eps, int timestep=0);
/** \brief Remove a vertex at given index within the container.
@return true = the vertex was successfuly removed; false = wrong index.
*/
bool RemoveVertexAt(int index, int timestep=0);
/** \brief Remove a vertex at given timestep within the container.
@return true = the vertex was successfuly removed.
*/
bool RemoveVertex(VertexType* vertex, int timestep=0);
/** \brief Remove a vertex at a query position in 3D space.
The vertex to be removed will be search by nearest neighbour search.
Note that possibly no vertex at this position and eps is stored inside
the contour.
@return true = the vertex was successfuly removed; false = no vertex found.
*/
bool RemoveVertexAt(mitk::Point3D &point, float eps, int timestep=0);
/** \brief Shift the currently selected vertex by a translation vector.
\pararm translate - the translation vector.
*/
void ShiftSelectedVertex(mitk::Vector3D &translate);
/** \brief Shift the whole contour by a translation vector at given timestep.
\pararm translate - the translation vector.
\pararm timestep - at this timestep the contour will be shifted.
*/
void ShiftContour(mitk::Vector3D &translate, int timestep=0);
/** \brief Clear the storage container at given timestep.
All control points are removed at
timestep.
*/
virtual void Clear(int timestep);
/*++++++++++++++++++ method inherit from base data +++++++++++++++++++++++++++*/
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
virtual void SetRequestedRegionToLargestPossibleRegion ();
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion ();
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
virtual bool VerifyRequestedRegion ();
/**
\brief Get the updated geometry with recomputed bounds.
*/
virtual const mitk::Geometry3D* GetUpdatedGeometry (int t=0);
/**
\brief Get the Geometry3D for timestep t.
*/
virtual mitk::Geometry3D* GetGeometry (int t=0) const;
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
- virtual void SetRequestedRegion (itk::DataObject *data);
+ virtual void SetRequestedRegion( const itk::DataObject *data);
/**
\brief Expand the timebounds of the TimeSlicedGeometry to given number of timesteps.
*/
virtual void Expand( int timeSteps );
/**
\brief Update the OutputInformation of a ContourModel object
The BoundingBox of the contour will be updated, if necessary.
*/
virtual void UpdateOutputInformation();
/**
\brief Clear the storage container.
The object is set to initial state. All control points are removed and the number of
timesteps are set to 1.
*/
virtual void Clear();
/**
\brief overwrite if the Data can be called by an Interactor (StateMachine).
*/
void ExecuteOperation(Operation* operation);
protected:
ContourModel();
ContourModel(const mitk::ContourModel &other);
virtual ~ContourModel();
//inherit from BaseData. called by Clear()
virtual void ClearData();
//inherit from BaseData. Initial state of a contour with no vertices and a single timestep.
virtual void InitializeEmpty();
//Shift a vertex
void ShiftVertex(VertexType* vertex, mitk::Vector3D &vector);
//Storage with time resolved support.
ContourModelSeries m_ContourSeries;
//The currently selected vertex.
VertexType* m_SelectedVertex;
//The interpolation of the line segment between control points.
LineSegmentInterpolation m_lineInterpolation;
};
itkEventMacro( ContourModelEvent, itk::AnyEvent );
itkEventMacro( ContourModelShiftEvent, ContourModelEvent );
itkEventMacro( ContourModelSizeChangeEvent, ContourModelEvent );
itkEventMacro( ContourModelAddEvent, ContourModelSizeChangeEvent );
itkEventMacro( ContourModelRemoveEvent, ContourModelSizeChangeEvent );
itkEventMacro( ContourModelExpandTimeBoundsEvent, ContourModelEvent );
itkEventMacro( ContourModelClosedEvent, ContourModelEvent );
}
#endif
diff --git a/Modules/Segmentation/DataManagement/mitkContourSet.cpp b/Modules/Segmentation/DataManagement/mitkContourSet.cpp
index 034225654d..6e1d2c73c2 100644
--- a/Modules/Segmentation/DataManagement/mitkContourSet.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContourSet.cpp
@@ -1,121 +1,121 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContourSet.h"
mitk::ContourSet::ContourSet() :
m_ContourVector( ContourVectorType() ),
m_NumberOfContours (0)
{
GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
}
mitk::ContourSet::~ContourSet()
{
}
void mitk::ContourSet::AddContour(unsigned int index, mitk::Contour::Pointer contour)
{
m_ContourVector.insert(std::make_pair<unsigned long, mitk::Contour::Pointer>( index , contour) );
}
void mitk::ContourSet::RemoveContour(unsigned long index)
{
m_ContourVector.erase( index );
}
void mitk::ContourSet::UpdateOutputInformation()
{
mitk::ContourSet::ContourVectorType contourVec = GetContours();
mitk::ContourSet::ContourIterator contoursIterator = contourVec.begin();
mitk::ContourSet::ContourIterator contoursIteratorEnd = contourVec.end();
// initialize container
mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
mitk::BoundingBox::PointIdentifier pointid=0;
mitk::Point3D point;
mitk::AffineTransform3D* transform = GetTimeSlicedGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
transform->GetInverse(inverse);
// calculate a bounding box that includes all contours
// \todo probably we should do this additionally for each time-step
while (contoursIterator != contoursIteratorEnd)
{
const Geometry3D* geometry = (*contoursIterator).second->GetUpdatedTimeSlicedGeometry();
unsigned char i;
for(i=0; i<8; ++i)
{
point = inverse->TransformPoint(geometry->GetCornerPoint(i));
if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < mitk::large)
pointscontainer->InsertElement( pointid++, point);
else
{
itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. BoundingObject: " << (*contoursIterator).second );
}
}
++contoursIterator;
}
mitk::BoundingBox::Pointer boundingBox = mitk::BoundingBox::New();
boundingBox->SetPoints(pointscontainer);
boundingBox->ComputeBoundingBox();
Geometry3D* geometry3d = GetGeometry(0);
geometry3d->SetIndexToWorldTransform(transform);
geometry3d->SetBounds(boundingBox->GetBounds());
GetTimeSlicedGeometry()->InitializeEvenlyTimed(geometry3d, GetTimeSlicedGeometry()->GetTimeSteps());
}
void mitk::ContourSet::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::ContourSet::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return true;
}
bool mitk::ContourSet::VerifyRequestedRegion()
{
return true;
}
-void mitk::ContourSet::SetRequestedRegion(itk::DataObject*)
+void mitk::ContourSet::SetRequestedRegion( const itk::DataObject*)
{
}
void mitk::ContourSet::Initialize()
{
m_ContourVector = ContourVectorType();
GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
}
unsigned int mitk::ContourSet::GetNumberOfContours()
{
return m_ContourVector.size();
}
mitk::ContourSet::ContourVectorType mitk::ContourSet::GetContours()
{
return m_ContourVector;
}
diff --git a/Modules/Segmentation/DataManagement/mitkContourSet.h b/Modules/Segmentation/DataManagement/mitkContourSet.h
index 1e11057a05..25af39767a 100644
--- a/Modules/Segmentation/DataManagement/mitkContourSet.h
+++ b/Modules/Segmentation/DataManagement/mitkContourSet.h
@@ -1,114 +1,114 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_CONTOUR_SET_H_
#define _MITK_CONTOUR_SET_H_
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkBaseData.h"
#include "mitkContour.h"
#include <map>
namespace mitk
{
/**
* This class holds stores vertices for drawing a contour
*
*/
class Segmentation_EXPORT ContourSet : public BaseData
{
public:
mitkClassMacro(ContourSet, BaseData);
itkNewMacro(Self);
typedef std::map<unsigned long,Contour::Pointer> ContourVectorType;
typedef ContourVectorType::iterator ContourIterator;
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
/**
* clean up the contour data
*/
void Initialize();
/**
* add a contour
*/
void AddContour(unsigned int index, mitk::Contour::Pointer contour);
/**
* add a contour
*/
void RemoveContour(unsigned long index);
/**
* returns the number of points stored in the contour
*/
unsigned int GetNumberOfContours();
/**
* returns the container of the contour points
*/
ContourVectorType GetContours();
/**
* intherited from parent
*/
virtual void UpdateOutputInformation();
/**
* intherited from parent
*/
virtual void SetRequestedRegionToLargestPossibleRegion();
/**
* intherited from parent
*/
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
/**
* intherited from parent
*/
virtual bool VerifyRequestedRegion();
/**
* intherited from parent
*/
- virtual void SetRequestedRegion(itk::DataObject *data);
+ virtual void SetRequestedRegion( const itk::DataObject *data);
protected:
ContourSet();
virtual ~ContourSet();
private:
/**
* the bounding box of the contour
*/
BoundingBoxType::Pointer m_BoundingBox;
ContourVectorType m_ContourVector;
unsigned int m_NumberOfContours;
};
} // namespace mitk
#endif //_MITK_CONTOUR_SET_H_
diff --git a/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp b/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp
index 3b8eeef742..700ac11a19 100644
--- a/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp
+++ b/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp
@@ -1,370 +1,368 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkExtrudedContour.h"
#include "mitkVector.h"
#include "mitkBaseProcess.h"
-#include <itkSmartPointerForwardReference.txx>
-
#include <vtkLinearExtrusionFilter.h>
#include <vtkPolyData.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkPlanes.h>
#include <vtkClipPolyData.h>
#include <vtkPolygon.h>
#include <vtkFloatArray.h>
#include <vtkDoubleArray.h>
#include <vtkPlane.h>
//vtkButterflySubdivisionFilter * subdivs;
#include <vtkSampleFunction.h>
#include <vtkTriangleFilter.h>
#include <vtkLinearSubdivisionFilter.h>
#include <vtkImageData.h>
#include <vtkCubeSource.h>
mitk::ExtrudedContour::ExtrudedContour()
: m_Contour(NULL), m_ClippingGeometry(NULL), m_AutomaticVectorGeneration(false)
{
GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
FillVector3D(m_Vector, 0.0, 0.0, 1.0);
m_RightVector.Fill(0.0);
m_ExtrusionFilter = vtkLinearExtrusionFilter::New();
m_ExtrusionFilter->CappingOff();
m_ExtrusionFilter->SetExtrusionTypeToVectorExtrusion();
double vtkvector[3]={0,0,1};
// set extrusion vector
m_ExtrusionFilter->SetVector(vtkvector);
m_TriangleFilter = vtkTriangleFilter::New();
m_TriangleFilter->SetInput(m_ExtrusionFilter->GetOutput());
m_SubdivisionFilter = vtkLinearSubdivisionFilter::New();
m_SubdivisionFilter->SetInput(m_TriangleFilter->GetOutput());
m_SubdivisionFilter->SetNumberOfSubdivisions(4);
m_ClippingBox = vtkPlanes::New();
m_ClipPolyDataFilter = vtkClipPolyData::New();
m_ClipPolyDataFilter->SetInput(m_SubdivisionFilter->GetOutput());
m_ClipPolyDataFilter->SetClipFunction(m_ClippingBox);
m_ClipPolyDataFilter->InsideOutOn();
m_Polygon = vtkPolygon::New();
m_ProjectionPlane = mitk::PlaneGeometry::New();
}
mitk::ExtrudedContour::~ExtrudedContour()
{
m_ClipPolyDataFilter->Delete();
m_ClippingBox->Delete();
m_SubdivisionFilter->Delete();
m_TriangleFilter->Delete();
m_ExtrusionFilter->Delete();
m_Polygon->Delete();
}
bool mitk::ExtrudedContour::IsInside(const Point3D& worldPoint) const
{
static double polygonNormal[3]={0.0,0.0,1.0};
// project point onto plane
float xt[3];
itk2vtk(worldPoint, xt);
xt[0] = worldPoint[0]-m_Origin[0];
xt[1] = worldPoint[1]-m_Origin[1];
xt[2] = worldPoint[2]-m_Origin[2];
float dist=xt[0]*m_Normal[0]+xt[1]*m_Normal[1]+xt[2]*m_Normal[2];
xt[0] -= dist*m_Normal[0];
xt[1] -= dist*m_Normal[1];
xt[2] -= dist*m_Normal[2];
double x[3];
x[0] = xt[0]*m_Right[0]+xt[1]*m_Right[1]+xt[2]*m_Right[2];
x[1] = xt[0]*m_Down[0] +xt[1]*m_Down[1] +xt[2]*m_Down[2];
x[2] = 0;
// determine whether it's in the selection loop and then evaluate point
// in polygon only if absolutely necessary.
if ( x[0] >= this->m_ProjectedContourBounds[0] && x[0] <= this->m_ProjectedContourBounds[1] &&
x[1] >= this->m_ProjectedContourBounds[2] && x[1] <= this->m_ProjectedContourBounds[3] &&
this->m_Polygon->PointInPolygon(x, m_Polygon->Points->GetNumberOfPoints(),
((vtkDoubleArray *)this->m_Polygon->Points->GetData())->GetPointer(0),
(double*)const_cast<mitk::ExtrudedContour*>(this)->m_ProjectedContourBounds, polygonNormal) == 1 )
return true;
else
return false;
}
mitk::ScalarType mitk::ExtrudedContour::GetVolume()
{
return -1.0;
}
void mitk::ExtrudedContour::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if(GetMTime() > m_LastCalculateExtrusionTime)
{
BuildGeometry();
BuildSurface();
}
//if ( ( m_CalculateBoundingBox ) && ( m_PolyDataSeries.size() > 0 ) )
// CalculateBoundingBox();
}
void mitk::ExtrudedContour::BuildSurface()
{
if(m_Contour.IsNull())
{
SetVtkPolyData(NULL);
return;
}
// set extrusion contour
vtkPolyData *polyData = vtkPolyData::New();
vtkCellArray *polys = vtkCellArray::New();
polys->InsertNextCell(m_Polygon->GetPointIds());
polyData->SetPoints(m_Polygon->GetPoints());
//float vtkpoint[3];
//unsigned int i, numPts = m_Polygon->GetNumberOfPoints();
//for(i=0; i<numPts; ++i)
//{
// float * vtkpoint = this->m_Polygon->Points->GetPoint(i);
// pointids[i]=loopPoints->InsertNextPoint(vtkpoint);
//}
//polys->InsertNextCell( i, pointids );
//delete [] pointids;
//polyData->SetPoints( loopPoints );
polyData->SetPolys( polys );
polys->Delete();
m_ExtrusionFilter->SetInput(polyData);
polyData->Delete();
// set extrusion scale factor
m_ExtrusionFilter->SetScaleFactor(GetGeometry()->GetExtentInMM(2));
SetVtkPolyData(m_SubdivisionFilter->GetOutput());
//if(m_ClippingGeometry.IsNull())
//{
// SetVtkPolyData(m_SubdivisionFilter->GetOutput());
//}
//else
//{
// m_ClipPolyDataFilter->SetInput(m_SubdivisionFilter->GetOutput());
// mitk::BoundingBox::BoundsArrayType bounds=m_ClippingGeometry->GetBounds();
// m_ClippingBox->SetBounds(bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]);
// m_ClippingBox->SetTransform(GetGeometry()->GetVtkTransform());
// m_ClipPolyDataFilter->SetClipFunction(m_ClippingBox);
// m_ClipPolyDataFilter->SetValue(0);
// SetVtkPolyData(m_ClipPolyDataFilter->GetOutput());
//}
m_LastCalculateExtrusionTime.Modified();
}
void mitk::ExtrudedContour::BuildGeometry()
{
if(m_Contour.IsNull())
return;
// Initialize(1);
Vector3D nullvector; nullvector.Fill(0.0);
float xProj[3];
unsigned int i;
unsigned int numPts = 20; //m_Contour->GetNumberOfPoints();
mitk::Contour::PathPointer path = m_Contour->GetContourPath();
mitk::Contour::PathType::InputType cstart = path->StartOfInput();
mitk::Contour::PathType::InputType cend = path->EndOfInput();
mitk::Contour::PathType::InputType cstep = (cend-cstart)/numPts;
mitk::Contour::PathType::InputType ccur;
// Part I: guarantee/calculate legal vectors
m_Vector.Normalize();
itk2vtk(m_Vector, m_Normal);
// check m_Vector
if(mitk::Equal(m_Vector, nullvector) || m_AutomaticVectorGeneration)
{
if ( m_AutomaticVectorGeneration == false)
itkWarningMacro("Extrusion vector is 0 ("<< m_Vector << "); trying to use normal of polygon");
vtkPoints *loopPoints = vtkPoints::New();
//mitk::Contour::PointsContainerIterator pointsIt = m_Contour->GetPoints()->Begin();
double vtkpoint[3];
unsigned int i=0;
for(i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep)
{
itk2vtk(path->Evaluate(ccur), vtkpoint);
loopPoints->InsertNextPoint(vtkpoint);
}
// Make sure points define a loop with a m_Normal
vtkPolygon::ComputeNormal(loopPoints, m_Normal);
loopPoints->Delete();
vtk2itk(m_Normal, m_Vector);
if(mitk::Equal(m_Vector, nullvector))
{
itkExceptionMacro("Cannot calculate normal of polygon");
}
}
// check m_RightVector
if((mitk::Equal(m_RightVector, nullvector)) || (mitk::Equal(m_RightVector*m_Vector, 0.0)==false))
{
if(mitk::Equal(m_RightVector, nullvector))
{
itkDebugMacro("Right vector is 0. Calculating.");
}
else
{
itkWarningMacro("Right vector ("<<m_RightVector<<") not perpendicular to extrusion vector "<<m_Vector<<": "<<m_RightVector*m_Vector);
}
// calculate a legal m_RightVector
if( mitk::Equal( m_Vector[1], 0.0f ) == false )
{
FillVector3D( m_RightVector, 1.0f, -m_Vector[0]/m_Vector[1], 0.0f );
m_RightVector.Normalize();
}
else
{
FillVector3D( m_RightVector, 0.0f, 1.0f, 0.0f );
}
}
// calculate down-vector
- VnlVector rightDV = m_RightVector.Get_vnl_vector(); rightDV.normalize(); vnl2vtk(rightDV, m_Right);
- VnlVector downDV = vnl_cross_3d( m_Vector.Get_vnl_vector(), rightDV ); downDV.normalize(); vnl2vtk(downDV, m_Down);
+ VnlVector rightDV = m_RightVector.GetVnlVector(); rightDV.normalize(); vnl2vtk(rightDV, m_Right);
+ VnlVector downDV = vnl_cross_3d( m_Vector.GetVnlVector(), rightDV ); downDV.normalize(); vnl2vtk(downDV, m_Down);
// Part II: calculate plane as base for extrusion, project the contour
// on this plane and store as polygon for IsInside test and BoundingBox calculation
// initialize m_ProjectionPlane, yet with origin at 0
m_ProjectionPlane->InitializeStandardPlane(rightDV, downDV);
// create vtkPolygon from contour and simultaneously determine 2D bounds of
// contour projected on m_ProjectionPlane
//mitk::Contour::PointsContainerIterator pointsIt = m_Contour->GetPoints()->Begin();
m_Polygon->Points->Reset();
m_Polygon->Points->SetNumberOfPoints(numPts);
m_Polygon->PointIds->Reset();
m_Polygon->PointIds->SetNumberOfIds(numPts);
mitk::Point2D pt2d;
mitk::Point3D pt3d;
mitk::Point2D min, max;
min.Fill(ScalarTypeNumericTraits::max());
max.Fill(ScalarTypeNumericTraits::min());
xProj[2]=0.0;
for(i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep)
{
pt3d.CastFrom(path->Evaluate(ccur));
m_ProjectionPlane->Map(pt3d, pt2d);
xProj[0]=pt2d[0];
if(pt2d[0]<min[0]) min[0]=pt2d[0];
if(pt2d[0]>max[0]) max[0]=pt2d[0];
xProj[1]=pt2d[1];
if(pt2d[1]<min[1]) min[1]=pt2d[1];
if(pt2d[1]>max[1]) max[1]=pt2d[1];
m_Polygon->Points->SetPoint(i, xProj);
m_Polygon->PointIds->SetId(i, i);
}
// shift parametric origin to (0,0)
for(i=0; i<numPts; ++i)
{
double * pt = this->m_Polygon->Points->GetPoint(i);
pt[0]-=min[0]; pt[1]-=min[1];
itkDebugMacro( << i << ": (" << pt[0] << "," << pt[1] << "," << pt[2] << ")" );
}
this->m_Polygon->GetBounds(m_ProjectedContourBounds);
//m_ProjectedContourBounds[4]=-1.0; m_ProjectedContourBounds[5]=1.0;
// calculate origin (except translation along the normal) and bounds
// of m_ProjectionPlane:
// origin is composed of the minimum x-/y-coordinates of the polygon,
// bounds from the extent of the polygon, both after projecting on the plane
mitk::Point3D origin;
m_ProjectionPlane->Map(min, origin);
ScalarType bounds[6]={0, max[0]-min[0], 0, max[1]-min[1], 0, 1};
m_ProjectionPlane->SetBounds(bounds);
m_ProjectionPlane->SetOrigin(origin);
// Part III: initialize geometry
if(m_ClippingGeometry.IsNotNull())
{
ScalarType min_dist=ScalarTypeNumericTraits::max(), max_dist=ScalarTypeNumericTraits::min(), dist;
unsigned char i;
for(i=0; i<8; ++i)
{
dist = m_ProjectionPlane->SignedDistance( m_ClippingGeometry->GetCornerPoint(i) );
if(dist<min_dist) min_dist=dist;
if(dist>max_dist) max_dist=dist;
}
//incorporate translation along the normal into origin
origin = origin+m_Vector*min_dist;
m_ProjectionPlane->SetOrigin(origin);
bounds[5]=max_dist-min_dist;
}
else
bounds[5]=20;
itk2vtk(origin, m_Origin);
mitk::TimeSlicedGeometry::Pointer timeGeometry = this->GetTimeSlicedGeometry();
mitk::Geometry3D::Pointer g3d = timeGeometry->GetGeometry3D( 0 );
assert( g3d.IsNotNull() );
g3d->SetBounds(bounds);
g3d->SetIndexToWorldTransform(m_ProjectionPlane->GetIndexToWorldTransform());
g3d->TransferItkToVtkTransform();
timeGeometry->InitializeEvenlyTimed(g3d, 1);
}
unsigned long mitk::ExtrudedContour::GetMTime() const
{
unsigned long latestTime = Superclass::GetMTime();
if(m_Contour.IsNotNull())
{
unsigned long localTime;
localTime = m_Contour->GetMTime();
if(localTime > latestTime) latestTime = localTime;
}
return latestTime;
}
diff --git a/Modules/Segmentation/Interactions/mitkBinaryThresholdTool.cpp b/Modules/Segmentation/Interactions/mitkBinaryThresholdTool.cpp
index df071a3a1f..cf4f277074 100644
--- a/Modules/Segmentation/Interactions/mitkBinaryThresholdTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkBinaryThresholdTool.cpp
@@ -1,321 +1,321 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBinaryThresholdTool.h"
#include "mitkBinaryThresholdTool.xpm"
#include "mitkToolManager.h"
#include "mitkBoundingObjectToSegmentationFilter.h"
#include <mitkCoreObjectFactory.h>
#include "mitkLevelWindowProperty.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkOrganTypeProperty.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include "mitkDataStorage.h"
#include "mitkRenderingManager.h"
#include "mitkImageCast.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageTimeSelector.h"
#include <itkImageRegionIterator.h>
#include <itkBinaryThresholdImageFilter.h>
#include "mitkPadImageFilter.h"
#include "mitkMaskAndCutRoiImageFilter.h"
namespace mitk {
MITK_TOOL_MACRO(Segmentation_EXPORT, BinaryThresholdTool, "Thresholding tool");
}
mitk::BinaryThresholdTool::BinaryThresholdTool()
:m_SensibleMinimumThresholdValue(-100),
m_SensibleMaximumThresholdValue(+100),
m_CurrentThresholdValue(0.0),
m_IsFloatImage(false)
{
this->SupportRoiOn();
m_ThresholdFeedbackNode = DataNode::New();
mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties( m_ThresholdFeedbackNode );
m_ThresholdFeedbackNode->SetProperty( "color", ColorProperty::New(1.0, 0.0, 0.0) );
m_ThresholdFeedbackNode->SetProperty( "texture interpolation", BoolProperty::New(false) );
m_ThresholdFeedbackNode->SetProperty( "layer", IntProperty::New( 100 ) );
m_ThresholdFeedbackNode->SetProperty( "levelwindow", LevelWindowProperty::New( LevelWindow(100, 1) ) );
m_ThresholdFeedbackNode->SetProperty( "name", StringProperty::New("Thresholding feedback") );
m_ThresholdFeedbackNode->SetProperty( "opacity", FloatProperty::New(0.3) );
m_ThresholdFeedbackNode->SetProperty( "helper object", BoolProperty::New(true) );
}
mitk::BinaryThresholdTool::~BinaryThresholdTool()
{
}
const char** mitk::BinaryThresholdTool::GetXPM() const
{
return mitkBinaryThresholdTool_xpm;
}
const char* mitk::BinaryThresholdTool::GetName() const
{
return "Thresholding";
}
void mitk::BinaryThresholdTool::Activated()
{
m_ToolManager->RoiDataChanged += mitk::MessageDelegate<mitk::BinaryThresholdTool>(this, &mitk::BinaryThresholdTool::OnRoiDataChanged);
m_OriginalImageNode = m_ToolManager->GetReferenceData(0);
m_NodeForThresholding = m_OriginalImageNode;
if ( m_NodeForThresholding.IsNotNull() )
{
SetupPreviewNodeFor( m_NodeForThresholding );
}
else
{
m_ToolManager->ActivateTool(-1);
}
}
void mitk::BinaryThresholdTool::Deactivated()
{
m_ToolManager->RoiDataChanged -= mitk::MessageDelegate<mitk::BinaryThresholdTool>(this, &mitk::BinaryThresholdTool::OnRoiDataChanged);
m_NodeForThresholding = NULL;
m_OriginalImageNode = NULL;
try
{
if (DataStorage* storage = m_ToolManager->GetDataStorage())
{
storage->Remove( m_ThresholdFeedbackNode );
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
catch(...)
{
// don't care
}
m_ThresholdFeedbackNode->SetData(NULL);
}
void mitk::BinaryThresholdTool::SetThresholdValue(double value)
{
if (m_ThresholdFeedbackNode.IsNotNull())
{
m_CurrentThresholdValue = value;
m_ThresholdFeedbackNode->SetProperty( "levelwindow", LevelWindowProperty::New( LevelWindow(m_CurrentThresholdValue, 0.001) ) );
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void mitk::BinaryThresholdTool::AcceptCurrentThresholdValue(const std::string& organName, const Color& color)
{
CreateNewSegmentationFromThreshold(m_NodeForThresholding, organName, color );
RenderingManager::GetInstance()->RequestUpdateAll();
m_ToolManager->ActivateTool(-1);
}
void mitk::BinaryThresholdTool::CancelThresholding()
{
m_ToolManager->ActivateTool(-1);
}
void mitk::BinaryThresholdTool::SetupPreviewNodeFor( DataNode* nodeForThresholding )
{
if (nodeForThresholding)
{
Image::Pointer image = dynamic_cast<Image*>( nodeForThresholding->GetData() );
Image::Pointer originalImage = dynamic_cast<Image*> (m_OriginalImageNode->GetData());
if (image.IsNotNull())
{
// initialize and a new node with the same image as our reference image
// use the level window property of this image copy to display the result of a thresholding operation
m_ThresholdFeedbackNode->SetData( image );
int layer(50);
nodeForThresholding->GetIntProperty("layer", layer);
m_ThresholdFeedbackNode->SetIntProperty("layer", layer+1);
if (DataStorage* storage = m_ToolManager->GetDataStorage())
{
if (storage->Exists(m_ThresholdFeedbackNode))
storage->Remove(m_ThresholdFeedbackNode);
storage->Add( m_ThresholdFeedbackNode, m_OriginalImageNode );
}
if (image.GetPointer() == originalImage.GetPointer())
{
- if ((originalImage->GetPixelType().GetPixelTypeId() == itk::ImageIOBase::SCALAR)
- &&(originalImage->GetPixelType().GetTypeId() == typeid(float)))
+ if ((originalImage->GetPixelType().GetPixelType() == itk::ImageIOBase::SCALAR)
+ &&(originalImage->GetPixelType().GetComponentType() == itk::ImageIOBase::FLOAT))
m_IsFloatImage = true;
else
m_IsFloatImage = false;
m_SensibleMinimumThresholdValue = static_cast<double>( originalImage->GetScalarValueMin() );
m_SensibleMaximumThresholdValue = static_cast<double>( originalImage->GetScalarValueMax() );
}
LevelWindowProperty::Pointer lwp = dynamic_cast<LevelWindowProperty*>( m_ThresholdFeedbackNode->GetProperty( "levelwindow" ));
if (lwp && !m_IsFloatImage )
{
m_CurrentThresholdValue = static_cast<double>( lwp->GetLevelWindow().GetLevel() );
}
else
{
m_CurrentThresholdValue = (m_SensibleMaximumThresholdValue + m_SensibleMinimumThresholdValue)/2;
}
IntervalBordersChanged.Send(m_SensibleMinimumThresholdValue, m_SensibleMaximumThresholdValue, m_IsFloatImage);
ThresholdingValueChanged.Send(m_CurrentThresholdValue);
}
}
}
void mitk::BinaryThresholdTool::CreateNewSegmentationFromThreshold(DataNode* node, const std::string& organName, const Color& color)
{
if (node)
{
Image::Pointer image = dynamic_cast<Image*>( m_NodeForThresholding->GetData() );
if (image.IsNotNull())
{
// create a new image of the same dimensions and smallest possible pixel type
DataNode::Pointer emptySegmentation = Tool::CreateEmptySegmentationNode( image, organName, color );
if (emptySegmentation)
{
// actually perform a thresholding and ask for an organ type
for (unsigned int timeStep = 0; timeStep < image->GetTimeSteps(); ++timeStep)
{
try
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( image );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer image3D = timeSelector->GetOutput();
if (image3D->GetDimension() == 2)
{
AccessFixedDimensionByItk_2( image3D, ITKThresholding, 2, dynamic_cast<Image*>(emptySegmentation->GetData()), timeStep );
}
else
{
AccessFixedDimensionByItk_2( image3D, ITKThresholding, 3, dynamic_cast<Image*>(emptySegmentation->GetData()), timeStep );
}
}
catch(...)
{
Tool::ErrorMessage("Error accessing single time steps of the original image. Cannot create segmentation.");
}
}
if (m_OriginalImageNode.GetPointer() != m_NodeForThresholding.GetPointer())
{
mitk::PadImageFilter::Pointer padFilter = mitk::PadImageFilter::New();
padFilter->SetInput(0, dynamic_cast<mitk::Image*> (emptySegmentation->GetData()));
padFilter->SetInput(1, dynamic_cast<mitk::Image*> (m_OriginalImageNode->GetData()));
padFilter->SetBinaryFilter(true);
padFilter->SetUpperThreshold(1);
padFilter->SetLowerThreshold(1);
padFilter->Update();
emptySegmentation->SetData(padFilter->GetOutput());
}
if (DataStorage::Pointer storage = m_ToolManager->GetDataStorage())
{
storage->Add( emptySegmentation, m_OriginalImageNode ); // add as a child, because the segmentation "derives" from the original
}
m_ToolManager->SetWorkingData( emptySegmentation );
}
}
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::BinaryThresholdTool::ITKThresholding( itk::Image<TPixel, VImageDimension>* originalImage, Image* segmentation, unsigned int timeStep )
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( segmentation );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer segmentation3D = timeSelector->GetOutput();
typedef itk::Image< Tool::DefaultSegmentationDataType, 3> SegmentationType; // this is sure for new segmentations
SegmentationType::Pointer itkSegmentation;
CastToItkImage( segmentation3D, itkSegmentation );
// iterate over original and segmentation
typedef itk::ImageRegionConstIterator< itk::Image<TPixel, VImageDimension> > InputIteratorType;
typedef itk::ImageRegionIterator< SegmentationType > SegmentationIteratorType;
InputIteratorType inputIterator( originalImage, originalImage->GetLargestPossibleRegion() );
SegmentationIteratorType outputIterator( itkSegmentation, itkSegmentation->GetLargestPossibleRegion() );
inputIterator.GoToBegin();
outputIterator.GoToBegin();
while (!outputIterator.IsAtEnd())
{
if ( inputIterator.Get() >= m_CurrentThresholdValue )
outputIterator.Set( 1 );
else
outputIterator.Set( 0 );
++inputIterator;
++outputIterator;
}
}
void mitk::BinaryThresholdTool::OnRoiDataChanged()
{
mitk::DataNode::Pointer node = m_ToolManager->GetRoiData(0);
if (node.IsNotNull())
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*> (m_NodeForThresholding->GetData());
if (image.IsNull())
return;
mitk::MaskAndCutRoiImageFilter::Pointer roiFilter = mitk::MaskAndCutRoiImageFilter::New();
roiFilter->SetInput(image);
roiFilter->SetRegionOfInterest(node->GetData());
roiFilter->Update();
mitk::DataNode::Pointer tmpNode = mitk::DataNode::New();
mitk::Image::Pointer tmpImage = roiFilter->GetOutput();
tmpNode->SetData(tmpImage);
m_SensibleMaximumThresholdValue = static_cast<int> (roiFilter->GetMaxValue());
m_SensibleMinimumThresholdValue = static_cast<int> (roiFilter->GetMinValue());
SetupPreviewNodeFor( tmpNode );
m_NodeForThresholding = tmpNode;
return;
}
else
{
this->SetupPreviewNodeFor(m_OriginalImageNode);
m_NodeForThresholding = m_OriginalImageNode;
return;
}
}
diff --git a/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp b/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp
index 244041c0ec..21c1c671c6 100644
--- a/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp
@@ -1,340 +1,340 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkCalculateGrayValueStatisticsTool.h"
#include "mitkCalculateGrayValueStatisticsTool.xpm"
#include "mitkImageAccessByItk.h"
#include "mitkProgressBar.h"
#include "mitkStatusBar.h"
#include "mitkImageTimeSelector.h"
#include "mitkImageCast.h"
#include "mitkToolManager.h"
#include <itkCommand.h>
#include <itkHistogram.h>
namespace mitk {
MITK_TOOL_MACRO(Segmentation_EXPORT, CalculateGrayValueStatisticsTool, "Statistics tool");
}
mitk::CalculateGrayValueStatisticsTool::CalculateGrayValueStatisticsTool()
{
}
mitk::CalculateGrayValueStatisticsTool::~CalculateGrayValueStatisticsTool()
{
}
const char** mitk::CalculateGrayValueStatisticsTool::GetXPM() const
{
return mitkCalculateGrayValueStatisticsTool_xpm;
}
const char* mitk::CalculateGrayValueStatisticsTool::GetName() const
{
return "Statistics";
}
std::string mitk::CalculateGrayValueStatisticsTool::GetErrorMessage()
{
return "No statistics generated for these segmentations:";
}
void mitk::CalculateGrayValueStatisticsTool::StartProcessingAllData()
{
// clear/prepare report
m_CompleteReport.str("");
}
bool mitk::CalculateGrayValueStatisticsTool::ProcessOneWorkingData( DataNode* node )
{
if (node)
{
Image::Pointer image = dynamic_cast<Image*>( node->GetData() );
if (image.IsNull()) return false;
DataNode* referencenode = m_ToolManager->GetReferenceData(0);
if (!referencenode) return false;
try
{
ProgressBar::GetInstance()->AddStepsToDo(1);
// add to report
std::string nodename("structure");
node->GetName(nodename);
std::string message = "Calculating statistics for ";
message += nodename;
StatusBar::GetInstance()->DisplayText(message.c_str());
Image::Pointer refImage = dynamic_cast<Image*>( referencenode->GetData() );
Image::Pointer image = dynamic_cast<Image*>( node->GetData() );
m_CompleteReport << "======== Gray value analysis of " << nodename << " ========\n";
if (image.IsNotNull() && refImage.IsNotNull() )
{
for (unsigned int timeStep = 0; timeStep < image->GetTimeSteps(); ++timeStep)
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( refImage );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer refImage3D = timeSelector->GetOutput();
ImageTimeSelector::Pointer timeSelector2 = ImageTimeSelector::New();
timeSelector2->SetInput( image );
timeSelector2->SetTimeNr( timeStep );
timeSelector2->UpdateLargestPossibleRegion();
Image::Pointer image3D = timeSelector2->GetOutput();
if (image3D.IsNotNull() && refImage3D.IsNotNull() )
{
m_CompleteReport << "=== " << nodename << ", time step " << timeStep << " ===\n";
AccessFixedDimensionByItk_2( refImage3D, ITKHistogramming, 3, image3D, m_CompleteReport );
}
}
}
m_CompleteReport << "======== End of analysis for " << nodename << " ===========\n\n\n";
ProgressBar::GetInstance()->Progress();
}
catch(...)
{
return false;
}
}
return true;
}
void mitk::CalculateGrayValueStatisticsTool::FinishProcessingAllData()
{
SegmentationsProcessingTool::FinishProcessingAllData();
// show/send results
StatisticsCompleted.Send();
//MITK_INFO << m_CompleteReport.str() << std::endl;
}
#define ROUND_P(x) ((int)((x)+0.5))
template<typename TPixel, unsigned int VImageDimension>
void mitk::CalculateGrayValueStatisticsTool::CalculateMinMax(
itk::Image<TPixel, VImageDimension>* referenceImage, Image* segmentation, TPixel& minimum,
TPixel& maximum)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::Image<Tool::DefaultSegmentationDataType, VImageDimension> SegmentationType;
typename SegmentationType::Pointer segmentationItk;
CastToItkImage(segmentation, segmentationItk);
typename SegmentationType::RegionType segmentationRegion =
segmentationItk->GetLargestPossibleRegion();
segmentationRegion.Crop(referenceImage->GetLargestPossibleRegion());
itk::ImageRegionConstIteratorWithIndex<SegmentationType> segmentationIterator(segmentationItk,
segmentationRegion);
itk::ImageRegionConstIteratorWithIndex<ImageType> referenceIterator(referenceImage,
segmentationRegion);
segmentationIterator.GoToBegin();
referenceIterator.GoToBegin();
minimum = std::numeric_limits<TPixel>::max();
maximum = std::numeric_limits<TPixel>::min();
while (!segmentationIterator.IsAtEnd())
{
itk::Point<float, 3> pt;
segmentationItk->TransformIndexToPhysicalPoint(segmentationIterator.GetIndex(), pt);
typename ImageType::IndexType ind;
itk::ContinuousIndex<float, 3> contInd;
if (referenceImage->TransformPhysicalPointToContinuousIndex(pt, contInd))
{
for (unsigned int i = 0; i < 3; ++i)
ind[i] = ROUND_P(contInd[i]);
referenceIterator.SetIndex(ind);
if (segmentationIterator.Get() > 0)
{
if (referenceIterator.Get() < minimum)
minimum = referenceIterator.Get();
if (referenceIterator.Get() > maximum)
maximum = referenceIterator.Get();
}
}
++segmentationIterator;
}
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::CalculateGrayValueStatisticsTool::ITKHistogramming(
itk::Image<TPixel, VImageDimension>* referenceImage, Image* segmentation,
std::stringstream& report)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::Image<Tool::DefaultSegmentationDataType, VImageDimension> SegmentationType;
typename SegmentationType::Pointer segmentationItk;
CastToItkImage( segmentation, segmentationItk );
// generate histogram
typename SegmentationType::RegionType segmentationRegion = segmentationItk->GetLargestPossibleRegion();
segmentationRegion.Crop( referenceImage->GetLargestPossibleRegion() );
itk::ImageRegionConstIteratorWithIndex< SegmentationType > segmentationIterator( segmentationItk, segmentationRegion);
itk::ImageRegionConstIteratorWithIndex< ImageType > referenceIterator( referenceImage, segmentationRegion);
segmentationIterator.GoToBegin();
referenceIterator.GoToBegin();
m_ITKHistogram = HistogramType::New();
TPixel minimum = std::numeric_limits<TPixel>::max();
TPixel maximum = std::numeric_limits<TPixel>::min();
CalculateMinMax(referenceImage, segmentation, minimum, maximum);
//initialize the histogram to the range of the cropped region
HistogramType::SizeType size;
#if defined(ITK_USE_REVIEW_STATISTICS)
typedef typename HistogramType::SizeType::ValueType HSizeValueType;
#else
typedef typename HistogramType::SizeType::SizeValueType HSizeValueType;
#endif
size.Fill(static_cast<HSizeValueType> (maximum - minimum + 1));
HistogramType::MeasurementVectorType lowerBound;
HistogramType::MeasurementVectorType upperBound;
lowerBound[0] = minimum;
upperBound[0] = maximum;
m_ITKHistogram->Initialize(size, lowerBound, upperBound);
double mean(0.0);
double sd(0.0);
double voxelCount(0.0);
//iterate through the cropped region add the values to the histogram
while (!segmentationIterator.IsAtEnd())
{
itk::Point< float, 3 > pt;
segmentationItk->TransformIndexToPhysicalPoint( segmentationIterator.GetIndex(), pt );
typename ImageType::IndexType ind;
itk::ContinuousIndex<float, 3> contInd;
if (referenceImage->TransformPhysicalPointToContinuousIndex(pt, contInd))
{
for (unsigned int i = 0; i < 3; ++i) ind[i] = ROUND_P(contInd[i]);
referenceIterator.SetIndex( ind );
if ( segmentationIterator.Get() > 0 )
{
HistogramType::MeasurementVectorType currentMeasurementVector;
currentMeasurementVector[0]
= static_cast<HistogramType::MeasurementType> (referenceIterator.Get());
- m_ITKHistogram->IncreaseFrequency(currentMeasurementVector, 1);
+ m_ITKHistogram->IncreaseFrequencyOfMeasurement(currentMeasurementVector, 1);
mean = (mean * (static_cast<double> (voxelCount) / static_cast<double> (voxelCount + 1))) // 3 points: old center * 2/3 + currentPoint * 1/3;
+ static_cast<double> (referenceIterator.Get()) / static_cast<double> (voxelCount + 1);
voxelCount += 1.0;
}
}
++segmentationIterator;
}
// second pass for SD
segmentationIterator.GoToBegin();
referenceIterator.GoToBegin();
while ( !segmentationIterator.IsAtEnd() )
{
itk::Point< float, 3 > pt;
segmentationItk->TransformIndexToPhysicalPoint( segmentationIterator.GetIndex(), pt );
typename ImageType::IndexType ind;
itk::ContinuousIndex<float, 3> contInd;
if (referenceImage->TransformPhysicalPointToContinuousIndex(pt, contInd))
{
for (unsigned int i = 0; i < 3; ++i) ind[i] = ROUND_P(contInd[i]);
referenceIterator.SetIndex( ind );
if ( segmentationIterator.Get() > 0 )
{
sd += ((static_cast<double>(referenceIterator.Get() ) - mean)*(static_cast<double>(referenceIterator.Get() ) - mean));
}
}
++segmentationIterator;
}
sd /= static_cast<double>(voxelCount - 1);
sd = sqrt( sd );
// generate quantiles
TPixel histogramQuantileValues[5];
histogramQuantileValues[0] = m_ITKHistogram->Quantile(0, 0.05);
histogramQuantileValues[1] = m_ITKHistogram->Quantile(0, 0.25);
histogramQuantileValues[2] = m_ITKHistogram->Quantile(0, 0.50);
histogramQuantileValues[3] = m_ITKHistogram->Quantile(0, 0.75);
histogramQuantileValues[4] = m_ITKHistogram->Quantile(0, 0.95);
// report histogram values
std::locale C("C");
std::locale originalLocale = report.getloc();
report.imbue(C);
report << " Minimum:" << minimum
<< "\n 5% quantile: " << histogramQuantileValues[0]
<< "\n 25% quantile: " << histogramQuantileValues[1]
<< "\n 50% quantile: " << histogramQuantileValues[2]
<< "\n 75% quantile: " << histogramQuantileValues[3]
<< "\n 95% quantile: " << histogramQuantileValues[4]
<< "\n Maximum: " << maximum
<< "\n Mean: " << mean
<< "\n SD: " << sd
<< "\n";
report.imbue(originalLocale);
}
std::string mitk::CalculateGrayValueStatisticsTool::GetReport() const
{
return m_CompleteReport.str();
}
mitk::CalculateGrayValueStatisticsTool::HistogramType::ConstPointer mitk::CalculateGrayValueStatisticsTool::GetHistogram()
{
return m_ITKHistogram.GetPointer();
}
diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
new file mode 100644
index 0000000000..71fdceeff9
--- /dev/null
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
@@ -0,0 +1,349 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkContourModelLiveWireInteractor.h"
+
+#include "mitkToolManager.h"
+
+#include "mitkBaseRenderer.h"
+#include "mitkRenderingManager.h"
+
+#include <mitkPositionEvent.h>
+#include <mitkStateEvent.h>
+
+#include <mitkInteractionConst.h>
+
+
+mitk::ContourModelLiveWireInteractor::ContourModelLiveWireInteractor(DataNode* dataNode)
+:ContourModelInteractor(dataNode)
+{
+ m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
+
+ mitk::ContourModel::Pointer m_ContourLeft = mitk::ContourModel::New();
+ mitk::ContourModel::Pointer m_ContourRight = mitk::ContourModel::New();
+ m_NextActiveVertexDown.Fill(0);
+ m_NextActiveVertexUp.Fill(0);
+}
+
+
+mitk::ContourModelLiveWireInteractor::~ContourModelLiveWireInteractor()
+{
+}
+
+
+
+bool mitk::ContourModelLiveWireInteractor::OnCheckPointClick( Action* action, const StateEvent* stateEvent)
+{
+ const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
+ if (!positionEvent) {
+ this->HandleEvent( new mitk::StateEvent(EIDNO, stateEvent->GetEvent()) );
+ return false;
+ }
+
+
+
+ mitk::StateEvent* newStateEvent = NULL;
+
+ int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
+
+ mitk::ContourModel *contour = dynamic_cast<mitk::ContourModel *>(
+ m_DataNode->GetData() );
+
+
+ contour->Deselect();
+
+ /*
+ * Check distance to any vertex.
+ * Transition YES if click close to a vertex
+ */
+ mitk::Point3D click = positionEvent->GetWorldPosition();
+
+
+ if (contour->SelectVertexAt(click, 1.5, timestep) )
+ {
+ contour->SetSelectedVertexAsControlPoint();
+
+ assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
+ mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
+ newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
+ m_lastMousePosition = click;
+
+
+ mitk::ContourModel *contour = dynamic_cast<mitk::ContourModel *>( m_DataNode->GetData() );
+
+ //
+ m_ContourLeft = mitk::ContourModel::New();
+
+ //get coordinates of next active vertex downwards from selected vertex
+ int downIndex = SplitContourFromSelectedVertex( contour, m_ContourLeft, false, timestep);
+
+ mitk::ContourModel::VertexIterator itDown = contour->IteratorBegin() + downIndex;
+ m_NextActiveVertexDown = (*itDown)->Coordinates;
+
+
+ //
+ m_ContourRight = mitk::ContourModel::New();
+
+ //get coordinates of next active vertex upwards from selected vertex
+ int upIndex = SplitContourFromSelectedVertex( contour, m_ContourRight, true, timestep);
+
+ mitk::ContourModel::VertexIterator itUp = contour->IteratorBegin() + upIndex;
+ m_NextActiveVertexUp = (*itUp)->Coordinates;
+
+ }
+ else
+ {
+ newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
+ }
+
+ this->HandleEvent( newStateEvent );
+
+ return true;
+}
+
+
+
+bool mitk::ContourModelLiveWireInteractor::OnDeletePoint( Action* action, const StateEvent* stateEvent)
+{
+
+ int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
+
+ mitk::ContourModel *contour = dynamic_cast<mitk::ContourModel *>( m_DataNode->GetData() );
+
+ if(contour->GetSelectedVertex())
+ {
+
+ mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
+ newContour->Expand(contour->GetTimeSteps());
+ newContour->Concatenate( m_ContourLeft, timestep );
+
+
+ //recompute contour between neighbored two active control points
+ this->m_LiveWireFilter->SetStartPoint( m_NextActiveVertexDown );
+ this->m_LiveWireFilter->SetEndPoint( m_NextActiveVertexUp );
+ this->m_LiveWireFilter->Update();
+
+ mitk::ContourModel::Pointer liveWireContour = mitk::ContourModel::New();
+ liveWireContour = this->m_LiveWireFilter->GetOutput();
+
+
+ //insert new liveWire computed points
+ newContour->Concatenate( liveWireContour, timestep );
+
+ newContour->Concatenate( m_ContourRight, timestep );
+
+ newContour->SetIsClosed(contour->IsClosed(timestep), timestep);
+
+ m_DataNode->SetData(newContour);
+
+
+ assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
+ mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
+
+ }
+ return true;
+}
+
+
+
+
+bool mitk::ContourModelLiveWireInteractor::OnMovePoint( Action* action, const StateEvent* stateEvent)
+{
+ const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
+ if (!positionEvent) return false;
+
+ int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
+
+ mitk::ContourModel *contour = dynamic_cast<mitk::ContourModel *>( m_DataNode->GetData() );
+
+ mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
+ newContour->Expand(contour->GetTimeSteps());
+
+ /*++++++++++++++ concatenate LEFT ++++++++++++++++++++++++++++++*/
+ newContour->Concatenate( m_ContourLeft, timestep );
+
+
+ mitk::Point3D currentPosition = positionEvent->GetWorldPosition();
+
+
+ /*+++++++++++++++ start computation ++++++++++++++++++++*/
+ //recompute contour between previous active vertex and selected vertex
+ this->m_LiveWireFilter->SetStartPoint( m_NextActiveVertexDown );
+ this->m_LiveWireFilter->SetEndPoint( currentPosition );
+ this->m_LiveWireFilter->Update();
+
+ mitk::ContourModel::Pointer liveWireContour = mitk::ContourModel::New();
+ liveWireContour = this->m_LiveWireFilter->GetOutput();
+
+ //remove point at current position because it is included in next livewire segment too.
+ liveWireContour->RemoveVertexAt( liveWireContour->GetNumberOfVertices(timestep) - 1, timestep);
+
+ /*++++++++++++++ concatenate LIVEWIRE ++++++++++++++++++++++++++++++*/
+ //insert new liveWire computed points
+ newContour->Concatenate( liveWireContour, timestep );
+
+
+ //recompute contour between selected vertex and next active vertex
+ this->m_LiveWireFilter->SetStartPoint( currentPosition );
+ this->m_LiveWireFilter->SetEndPoint( m_NextActiveVertexUp );
+ this->m_LiveWireFilter->Update();
+
+ liveWireContour = this->m_LiveWireFilter->GetOutput();
+
+ //make point at mouse position active again, so it is drawn
+ const_cast<mitk::ContourModel::VertexType*>( liveWireContour->GetVertexAt(0, timestep) )->IsControlPoint = true;
+
+ /*++++++++++++++ concatenate RIGHT ++++++++++++++++++++++++++++++*/
+ //insert new liveWire computed points
+ newContour->Concatenate( liveWireContour, timestep );
+ /*------------------------------------------------*/
+
+
+ newContour->Concatenate( m_ContourRight, timestep );
+
+ newContour->SetIsClosed(contour->IsClosed(timestep), timestep);
+ newContour->Deselect();//just to make sure
+ m_DataNode->SetData(newContour);
+
+ this->m_lastMousePosition = positionEvent->GetWorldPosition();
+
+ assert( positionEvent->GetSender()->GetRenderWindow() );
+ mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
+
+ return true;
+}
+
+
+
+int mitk::ContourModelLiveWireInteractor::SplitContourFromSelectedVertex(mitk::ContourModel* sourceContour, mitk::ContourModel* destinationContour, bool fromSelectedUpwards, int timestep)
+{
+
+ mitk::ContourModel::VertexIterator end =sourceContour->IteratorEnd();
+ mitk::ContourModel::VertexIterator begin =sourceContour->IteratorBegin();
+
+ //search next active control point to left and rigth and set as start and end point for filter
+ mitk::ContourModel::VertexIterator itSelected = sourceContour->IteratorBegin();
+
+
+ //move iterator to position
+ while((*itSelected) != sourceContour->GetSelectedVertex())
+ {
+ itSelected++;
+ }
+
+ //CASE search upwards for next control point
+ if(fromSelectedUpwards)
+ {
+ mitk::ContourModel::VertexIterator itUp = itSelected;
+
+ if(itUp != end)
+ {
+ itUp++;//step once up otherwise the the loop breaks immediately
+ }
+
+ while( itUp != end && !((*itUp)->IsControlPoint)){ itUp++; }
+
+ mitk::ContourModel::VertexIterator it = itUp;
+
+
+ if(itSelected != begin)
+ {
+ //copy the rest of the original contour
+ while(it != end)
+ {
+ destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
+ it++;
+ }
+ }
+ //else do not copy the contour
+
+
+ //return the offset of iterator at one before next-vertex-upwards
+ if(itUp != begin)
+ {
+ return std::distance( begin, itUp) - 1;
+ }
+ else
+ {
+ return std::distance( begin, itUp);
+ }
+
+ }
+ else //CASE search downwards for next control point
+ {
+ mitk::ContourModel::VertexIterator itDown = itSelected;
+ mitk::ContourModel::VertexIterator it = sourceContour->IteratorBegin();
+
+ if( itSelected != begin )
+ {
+ if(itDown != begin)
+ {
+ itDown--;//step once down otherwise the the loop breaks immediately
+ }
+
+ while( itDown != begin && !((*itDown)->IsControlPoint)){ itDown--; }
+
+ if(it != end)//if not empty
+ {
+ //always add the first vertex
+ destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
+ it++;
+ }
+ //copy from begin to itDown
+ while(it <= itDown)
+ {
+ destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
+ it++;
+ }
+ }
+ else
+ {
+ //if selected vertex is the first element search from end of contour downwards
+ itDown = end;
+ itDown--;
+ while(!((*itDown)->IsControlPoint)){itDown--;}
+
+ //move one forward as we don't want the first control point
+ it++;
+ //move iterator to second control point
+ while( (it!=end) && !((*it)->IsControlPoint) ){it++;}
+ //copy from begin to itDown
+ while(it <= itDown)
+ {
+ //copy the contour from second control point to itDown
+ destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
+ it++;
+ }
+ }
+
+
+ //add vertex at itDown - it's not considered during while loop
+ if( it != begin && it != end)
+ {
+ //destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
+ }
+
+ //return the offset of iterator at one after next-vertex-downwards
+ if( itDown != end)
+ {
+ return std::distance( begin, itDown);// + 1;//index of next vertex
+ }
+ else
+ {
+ return std::distance( begin, itDown) - 1;
+ }
+ }
+}
diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
new file mode 100644
index 0000000000..ae44899f95
--- /dev/null
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
@@ -0,0 +1,89 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkContourModelLiveWireInteractor_h_Included
+#define mitkContourModelLiveWireInteractor_h_Included
+
+#include "mitkCommon.h"
+#include "SegmentationExports.h"
+#include "mitkContourModelInteractor.h"
+#include <mitkContourModel.h>
+#include <mitkDataNode.h>
+
+#include <mitkImageLiveWireContourModelFilter.h>
+
+namespace mitk
+{
+
+
+ /**
+ \brief
+
+ \sa Interactor
+ \sa ContourModelInteractor
+
+ \ingroup Interaction
+
+
+ \warning Make sure the working image is properly set, otherwise the algorithm for computing livewire contour segments will not work!
+
+ */
+ class Segmentation_EXPORT ContourModelLiveWireInteractor : public ContourModelInteractor
+ {
+ public:
+
+ mitkClassMacro(ContourModelLiveWireInteractor, ContourModelInteractor);
+ mitkNewMacro1Param(Self, DataNode*);
+
+
+ virtual void SetWorkingImage (mitk::Image* _arg)
+ {
+ if (this->m_WorkingImage != _arg)
+ {
+ this->m_WorkingImage = _arg;
+ this->m_LiveWireFilter->SetInput(this->m_WorkingImage);
+ this->Modified();
+ }
+ }
+
+ protected:
+
+ ContourModelLiveWireInteractor(DataNode* dataNode);
+ virtual ~ContourModelLiveWireInteractor();
+
+
+ virtual bool OnDeletePoint(Action*, const StateEvent*);
+ virtual bool OnMovePoint(Action*, const StateEvent*);
+ virtual bool OnCheckPointClick( Action* action, const StateEvent* stateEvent);
+
+ int SplitContourFromSelectedVertex(mitk::ContourModel* sourceContour,
+ mitk::ContourModel* destinationContour,
+ bool fromSelectedUpwards,
+ int timestep);
+
+ mitk::ImageLiveWireContourModelFilter::Pointer m_LiveWireFilter;
+ mitk::Image::Pointer m_WorkingImage;
+
+ mitk::Point3D m_NextActiveVertexDown;
+ mitk::Point3D m_NextActiveVertexUp;
+ mitk::ContourModel::Pointer m_ContourLeft;
+ mitk::ContourModel::Pointer m_ContourRight;
+
+ };
+
+} // namespace
+
+#endif
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
new file mode 100644
index 0000000000..20082f9f8e
--- /dev/null
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -0,0 +1,653 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkLiveWireTool2D.h"
+
+#include "mitkToolManager.h"
+#include "mitkBaseRenderer.h"
+#include "mitkRenderingManager.h"
+
+#include "mitkLiveWireTool2D.xpm"
+
+#include <mitkInteractionConst.h>
+#include <mitkContourModelLiveWireInteractor.h>
+#include <mitkGlobalInteraction.h>
+
+#include "mitkContourUtils.h"
+#include "mitkContour.h"
+
+#include <itkGradientMagnitudeImageFilter.h>
+
+
+namespace mitk {
+ MITK_TOOL_MACRO(Segmentation_EXPORT, LiveWireTool2D, "LiveWire tool");
+}
+
+
+
+mitk::LiveWireTool2D::LiveWireTool2D()
+:SegTool2D("LiveWireTool")
+{
+ m_Contour = mitk::ContourModel::New();
+ m_ContourModelNode = mitk::DataNode::New();
+ m_ContourModelNode->SetData( m_Contour );
+ m_ContourModelNode->SetProperty("name", StringProperty::New("working contour node"));
+ m_ContourModelNode->SetProperty("visible", BoolProperty::New(true));
+ m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(0.9, 1.0, 0.1), NULL, true );
+ m_ContourModelNode->AddProperty( "selectedcolor", ColorProperty::New(1.0, 0.0, 0.1), NULL, true );
+
+
+ m_LiveWireContour = mitk::ContourModel::New();
+ m_LiveWireContourNode = mitk::DataNode::New();
+ //m_LiveWireContourNode->SetData( m_LiveWireContour );
+ m_LiveWireContourNode->SetProperty("name", StringProperty::New("active livewire node"));
+ m_LiveWireContourNode->SetProperty("visible", BoolProperty::New(true));
+ m_LiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
+ m_LiveWireContourNode->AddProperty( "selectedcolor", ColorProperty::New(0.5, 0.5, 0.1), NULL, true );
+
+
+ m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
+
+
+ // great magic numbers
+ CONNECT_ACTION( AcINITNEWOBJECT, OnInitLiveWire );
+ CONNECT_ACTION( AcADDPOINT, OnAddPoint );
+ CONNECT_ACTION( AcMOVE, OnMouseMoveNoDynamicCosts );
+ CONNECT_ACTION( AcCHECKPOINT, OnCheckPoint );
+ CONNECT_ACTION( AcFINISH, OnFinish );
+ CONNECT_ACTION( AcDELETEPOINT, OnLastSegmentDelete );
+ CONNECT_ACTION( AcADDLINE, OnMouseMoved );
+}
+
+
+
+
+mitk::LiveWireTool2D::~LiveWireTool2D()
+{
+ m_Contours.clear();
+}
+
+
+
+float mitk::LiveWireTool2D::CanHandleEvent( StateEvent const *stateEvent) const
+{
+ mitk::PositionEvent const *positionEvent =
+ dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
+
+ //Key event handling:
+ if (positionEvent == NULL)
+ {
+ //check for delete and escape event
+ if(stateEvent->GetId() == 12 || stateEvent->GetId() == 14)
+ {
+ return 1.0;
+ }
+ //check, if the current state has a transition waiting for that key event.
+ else if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
+ {
+ return 0.5;
+ }
+ else
+ {
+ return 0.0;
+ }
+ }
+ else
+ {
+ if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D )
+ return 0.0; // we don't want anything but 2D
+
+ return 1.0;
+ }
+
+}
+
+
+
+
+const char** mitk::LiveWireTool2D::GetXPM() const
+{
+ return mitkLiveWireTool2D_xpm;
+}
+
+
+
+
+const char* mitk::LiveWireTool2D::GetName() const
+{
+ return "LiveWire";
+}
+
+
+
+
+void mitk::LiveWireTool2D::Activated()
+{
+ Superclass::Activated();
+}
+
+
+
+
+void mitk::LiveWireTool2D::Deactivated()
+{
+ this->FinishTool();
+
+ DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
+ if ( !workingNode ) return;
+
+ Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
+ if ( !workingImage ) return;
+
+ ContourUtils::Pointer contourUtils = mitk::ContourUtils::New();
+
+ /*+++++++++++++++++++++++ for all contours in list (currently created by tool) ++++++++++++++++++++++++++++++++++++*/
+ std::vector< std::pair<mitk::DataNode*, mitk::PlaneGeometry::Pointer> >::iterator it = m_Contours.begin();
+ while(it != m_Contours.end() )
+ {
+
+ //++++++++++if node contains data
+ if( it->first->GetData() )
+ {
+
+ //+++++++++++++++if this is a contourModel
+ mitk::ContourModel* contourModel = dynamic_cast<mitk::ContourModel*>(it->first->GetData());
+ if( contourModel )
+ {
+
+ //++++++++++++++++++++++ for each timestep of this contourModel
+ for( int currentTimestep = 0; currentTimestep < contourModel->GetTimeSlicedGeometry()->GetTimeSteps(); currentTimestep++)
+ {
+
+ //get the segmentation image slice at current timestep
+ mitk::Image::Pointer workingSlice = this->GetAffectedImageSliceAs2DImage(it->second, workingImage, currentTimestep);
+
+ /*++++++++++++++++++++++ transfer to plain old contour to use contour util functionality +++++++++++++++++++++++*/
+ mitk::Contour::Pointer plainOldContour = mitk::Contour::New();
+ mitk::ContourModel::VertexIterator iter = contourModel->IteratorBegin(currentTimestep);
+ while(iter != contourModel->IteratorEnd(currentTimestep) )
+ {
+ plainOldContour->AddVertex( (*iter)->Coordinates );
+ iter++;
+ }
+ /*-------------------------------------------------------------------------------*/
+
+
+ mitk::Contour::Pointer projectedContour = contourUtils->ProjectContourTo2DSlice(workingSlice, plainOldContour, true, false);
+ contourUtils->FillContourInSlice(projectedContour, workingSlice, 1.0);
+
+ //write back to image volume
+ this->WriteBackSegmentationResult(it->second, workingSlice, currentTimestep);
+ }
+
+ //remove contour node from datastorage
+ m_ToolManager->GetDataStorage()->Remove( it->first );
+ }
+ }
+
+ ++it;
+ }
+
+ m_Contours.clear();
+
+ Superclass::Deactivated();
+}
+
+
+
+
+bool mitk::LiveWireTool2D::OnInitLiveWire (Action* action, const StateEvent* stateEvent)
+{
+ const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
+ if (!positionEvent) return false;
+
+ m_LastEventSender = positionEvent->GetSender();
+ m_LastEventSlice = m_LastEventSender->GetSlice();
+
+ if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
+
+
+ int timestep = positionEvent->GetSender()->GetTimeStep();
+
+ m_Contour->Expand(timestep+1);
+
+ m_ToolManager->GetDataStorage()->Add( m_ContourModelNode );
+
+ m_ToolManager->GetDataStorage()->Add( m_LiveWireContourNode );
+
+ //set current slice as input for ImageToLiveWireContourFilter
+ m_WorkingSlice = this->GetAffectedReferenceSlice(positionEvent);
+ m_LiveWireFilter->SetInput(m_WorkingSlice);
+
+ //map click to pixel coordinates
+ mitk::Point3D click = const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition());
+ itk::Index<3> idx;
+ m_WorkingSlice->GetGeometry()->WorldToIndex(click, idx);
+
+ /*+++++++++++++++++++++++ get the pixel the gradient in region of 5x5 ++++++++++++++++++++++++++*/
+ itk::Index<3> indexWithHighestGradient;
+ AccessFixedDimensionByItk_2(m_WorkingSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
+ /*----------------------------------------------------------------------------------------------------------------*/
+
+ //itk::Index to mitk::Point3D
+ click[0] = indexWithHighestGradient[0];
+ click[1] = indexWithHighestGradient[1];
+ click[2] = indexWithHighestGradient[2];
+ m_WorkingSlice->GetGeometry()->IndexToWorld(click, click);
+
+ //set initial start point
+ m_Contour->AddVertex( click, true, timestep );
+ m_LiveWireFilter->SetStartPoint(click);
+
+ m_CreateAndUseDynamicCosts = true;
+
+ //render
+ assert( positionEvent->GetSender()->GetRenderWindow() );
+ mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
+
+ return true;
+}
+
+
+
+
+bool mitk::LiveWireTool2D::OnAddPoint (Action* action, const StateEvent* stateEvent)
+{
+ //complete LiveWire interaction for last segment
+ //add current LiveWire contour to the finished contour and reset
+ //to start new segment and computation
+
+ /* check if event can be handled */
+ const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
+ if (!positionEvent) return false;
+
+ if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
+ /* END check if event can be handled */
+
+
+ int timestep = positionEvent->GetSender()->GetTimeStep();
+
+ //remove duplicate first vertex, it's already contained in m_Contour
+ m_LiveWireContour->RemoveVertexAt(0, timestep);
+
+
+ /* TODO fix this hack*/
+ //set last to active added point
+ if( m_LiveWireContour->GetNumberOfVertices(timestep) > 0)
+ {
+ const_cast<mitk::ContourModel::VertexType*>( m_LiveWireContour->GetVertexAt(m_LiveWireContour->GetNumberOfVertices(timestep)-1, timestep) )->IsControlPoint = true;
+ }
+
+ //merge contours
+ m_Contour->Concatenate(m_LiveWireContour, timestep);
+
+
+ //clear the livewire contour and reset the corresponding datanode
+ m_LiveWireContour->Clear(timestep);
+
+ //set new start point
+ m_LiveWireFilter->SetStartPoint(const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition()));
+
+ if( m_CreateAndUseDynamicCosts )
+ {
+ //use dynamic cost map for next update
+ m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
+ m_LiveWireFilter->SetUseDynamicCostMap(true);
+ //m_CreateAndUseDynamicCosts = false;
+ }
+
+ //render
+ assert( positionEvent->GetSender()->GetRenderWindow() );
+ mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
+
+ return true;
+}
+
+
+
+
+bool mitk::LiveWireTool2D::OnMouseMoved( Action* action, const StateEvent* stateEvent)
+{
+ //compute LiveWire segment from last control point to current mouse position
+
+ /* check if event can be handled */
+ if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
+
+ const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
+ if (!positionEvent) return false;
+ /* END check if event can be handled */
+
+
+ /* actual LiveWire computation */
+ int timestep = positionEvent->GetSender()->GetTimeStep();
+
+ m_LiveWireFilter->SetEndPoint(const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition()));
+
+ m_LiveWireFilter->SetTimestep(timestep);
+ m_LiveWireFilter->Update();
+
+
+ //ContourModel::VertexType* currentVertex = const_cast<ContourModel::VertexType*>(m_LiveWireContour->GetVertexAt(0));
+
+ this->m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
+ this->m_LiveWireContourNode->SetData(this->m_LiveWireFilter->GetOutput());
+
+ /* END actual LiveWire computation */
+
+ //render
+ assert( positionEvent->GetSender()->GetRenderWindow() );
+ mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
+
+ return true;
+}
+
+
+
+bool mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(Action* action, const StateEvent* stateEvent)
+{
+ //do not use dynamic cost map
+ m_LiveWireFilter->SetUseDynamicCostMap(false);
+ OnMouseMoved(action, stateEvent);
+ m_LiveWireFilter->SetUseDynamicCostMap(true);
+ return true;
+}
+
+
+
+
+
+bool mitk::LiveWireTool2D::OnCheckPoint( Action* action, const StateEvent* stateEvent)
+{
+ //check double click on first control point to finish the LiveWire tool
+ //
+ //Check distance to first point.
+ //Transition YES if click close to first control point
+ //
+
+ mitk::StateEvent* newStateEvent = NULL;
+
+ const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
+ if (!positionEvent)
+ {
+ //stay in current state
+ newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
+ }
+ else
+ {
+ int timestep = positionEvent->GetSender()->GetTimeStep();
+
+ mitk::Point3D click = positionEvent->GetWorldPosition();
+
+ mitk::Point3D first = this->m_Contour->GetVertexAt(0, timestep)->Coordinates;
+
+
+ if (first.EuclideanDistanceTo(click) < 1.5)
+ {
+ //finish
+ newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
+ }else
+ {
+ //stay active
+ newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
+ }
+ }
+
+ this->HandleEvent( newStateEvent );
+
+
+ return true;
+}
+
+
+
+
+bool mitk::LiveWireTool2D::OnFinish( Action* action, const StateEvent* stateEvent)
+{
+ // finish livewire tool interaction
+
+ /* check if event can be handled */
+ if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
+
+ const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
+ if (!positionEvent) return false;
+ /* END check if event can be handled */
+
+
+ //actual timestep
+ int timestep = positionEvent->GetSender()->GetTimeStep();
+
+ //remove last control point being added by double click
+ m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices(timestep) - 1, timestep);
+
+ //save contour and corresponding plane geometry to list
+ std::pair<mitk::DataNode*, mitk::PlaneGeometry::Pointer> contourPair(m_ContourModelNode.GetPointer(), dynamic_cast<mitk::PlaneGeometry*>(positionEvent->GetSender()->GetCurrentWorldGeometry2D()->Clone().GetPointer()) );
+ m_Contours.push_back(contourPair);
+
+ m_LiveWireFilter->SetUseDynamicCostMap(false);
+ this->FinishTool();
+
+ return true;
+}
+
+
+
+void mitk::LiveWireTool2D::FinishTool()
+{
+
+ unsigned int numberOfTimesteps = m_Contour->GetTimeSlicedGeometry()->GetTimeSteps();
+
+ //close contour in each timestep
+ for( int i = 0; i <= numberOfTimesteps; i++)
+ {
+ m_Contour->Close(i);
+ }
+
+ //clear LiveWire node
+ m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
+ m_LiveWireContourNode = NULL;
+ m_LiveWireContour = NULL;
+
+
+ //TODO visual feedback for completing livewire tool
+ m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(1.0, 1.0, 0.1), NULL, true );
+ m_ContourModelNode->SetProperty("name", StringProperty::New("contour node"));
+
+ //set the livewire interactor to edit control points
+ mitk::ContourModelLiveWireInteractor::Pointer interactor = mitk::ContourModelLiveWireInteractor::New(m_ContourModelNode);
+ interactor->SetWorkingImage(this->m_WorkingSlice);
+ m_ContourModelNode->SetInteractor(interactor);
+
+ //add interactor to globalInteraction instance
+ mitk::GlobalInteraction::GetInstance()->AddInteractor(interactor);
+ /* END complete livewire tool interaction */
+
+
+ /* reset contours and datanodes */
+ m_Contour = mitk::ContourModel::New();
+ m_ContourModelNode = mitk::DataNode::New();
+ m_ContourModelNode->SetData( m_Contour );
+ m_ContourModelNode->SetProperty("name", StringProperty::New("working contour node"));
+ m_ContourModelNode->SetProperty("visible", BoolProperty::New(true));
+ m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(0.9, 1.0, 0.1), NULL, true );
+ m_ContourModelNode->AddProperty( "points.color", ColorProperty::New(1.0, 0.0, 0.1), NULL, true );
+
+ m_LiveWireContour = mitk::ContourModel::New();
+ m_LiveWireContourNode = mitk::DataNode::New();
+ //m_LiveWireContourNode->SetData( m_LiveWireContour );
+ m_LiveWireContourNode->SetProperty("name", StringProperty::New("active livewire node"));
+ m_LiveWireContourNode->SetProperty("visible", BoolProperty::New(true));
+ m_LiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
+ m_LiveWireContourNode->AddProperty( "points.color", ColorProperty::New(0.5, 0.5, 0.1), NULL, true );
+ /* END reset contours and datanodes */
+}
+
+
+
+
+bool mitk::LiveWireTool2D::OnLastSegmentDelete( Action* action, const StateEvent* stateEvent)
+{
+ int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
+
+ //if last point of current contour will be removed go to start state and remove nodes
+ if( m_Contour->GetNumberOfVertices(timestep) <= 1 )
+ {
+ m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
+ m_ToolManager->GetDataStorage()->Remove( m_ContourModelNode );
+ m_LiveWireContour = mitk::ContourModel::New();
+ m_Contour = mitk::ContourModel::New();
+ m_ContourModelNode->SetData( m_Contour );
+ m_LiveWireContourNode->SetData( m_LiveWireContour );
+ Superclass::Deactivated(); //go to start state
+ }
+ else //remove last segment from contour and reset livewire contour
+ {
+
+ m_LiveWireContour = mitk::ContourModel::New();
+
+ m_LiveWireContourNode->SetData(m_LiveWireContour);
+
+
+ mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
+ newContour->Expand(m_Contour->GetTimeSteps());
+
+ mitk::ContourModel::VertexIterator begin = m_Contour->IteratorBegin();
+
+ //iterate from last point to next active point
+ mitk::ContourModel::VertexIterator newLast = m_Contour->IteratorBegin() + (m_Contour->GetNumberOfVertices() - 1);
+
+ //go at least one down
+ if(newLast != begin)
+ {
+ newLast--;
+ }
+
+ //search next active control point
+ while(newLast != begin && !((*newLast)->IsControlPoint) )
+ {
+ newLast--;
+ }
+
+ //set position of start point for livewire filter to coordinates of the new last point
+ m_LiveWireFilter->SetStartPoint((*newLast)->Coordinates);
+
+ mitk::ContourModel::VertexIterator it = m_Contour->IteratorBegin();
+
+ //fill new Contour
+ while(it <= newLast)
+ {
+ newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
+ it++;
+ }
+
+ newContour->SetIsClosed(m_Contour->IsClosed());
+
+ //set new contour visible
+ m_ContourModelNode->SetData(newContour);
+
+ m_Contour = newContour;
+
+ assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
+ mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
+ }
+
+ return true;
+}
+
+
+template<typename TPixel, unsigned int VImageDimension>
+void mitk::LiveWireTool2D::FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension>* inputImage, itk::Index<3> &index, itk::Index<3> &returnIndex)
+{
+ typedef itk::Image<TPixel, VImageDimension> InputImageType;
+ typedef typename InputImageType::IndexType IndexType;
+
+ unsigned long xMAX = inputImage->GetLargestPossibleRegion().GetSize()[0];
+ unsigned long yMAX = inputImage->GetLargestPossibleRegion().GetSize()[1];
+
+ returnIndex[0] = index[0];
+ returnIndex[1] = index[1];
+ returnIndex[2] = 0.0;
+
+
+ double gradientMagnitude = 0.0;
+ double maxGradientMagnitude = 0.0;
+
+ /*
+ the size and thus the region of 7x7 is only used to calculate the gradient magnitude in that region
+ not for searching the maximum value
+ */
+
+ //maximum value in each direction for size
+ typename InputImageType::SizeType size;
+ size[0] = 7;
+ size[1] = 7;
+
+ //minimum value in each direction for startRegion
+ IndexType startRegion;
+ startRegion[0] = index[0] - 3;
+ startRegion[1] = index[1] - 3;
+ if(startRegion[0] < 0) startRegion[0] = 0;
+ if(startRegion[1] < 0) startRegion[1] = 0;
+ if(xMAX - index[0] < 7) startRegion[0] = xMAX - 7;
+ if(yMAX - index[1] < 7) startRegion[1] = yMAX - 7;
+
+ index[0] = startRegion[0] + 3;
+ index[1] = startRegion[1] + 3;
+
+
+
+ typename InputImageType::RegionType region;
+ region.SetSize( size );
+ region.SetIndex( startRegion );
+
+ typedef typename itk::GradientMagnitudeImageFilter< InputImageType, InputImageType> GradientMagnitudeFilterType;
+ typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
+ gradientFilter->SetInput(inputImage);
+ gradientFilter->GetOutput()->SetRequestedRegion(region);
+
+ gradientFilter->Update();
+ typename InputImageType::Pointer gradientMagnImage;
+ gradientMagnImage = gradientFilter->GetOutput();
+
+
+ IndexType currentIndex;
+ currentIndex[0] = 0;
+ currentIndex[1] = 0;
+
+ // search max (approximate) gradient magnitude
+ for( int x = -1; x <= 1; ++x)
+ {
+ currentIndex[0] = index[0] + x;
+
+ for( int y = -1; y <= 1; ++y)
+ {
+ currentIndex[1] = index[1] + y;
+
+ gradientMagnitude = gradientMagnImage->GetPixel(currentIndex);
+
+ //check for new max
+ if(maxGradientMagnitude < gradientMagnitude)
+ {
+ maxGradientMagnitude = gradientMagnitude;
+ returnIndex[0] = currentIndex[0];
+ returnIndex[1] = currentIndex[1];
+ returnIndex[2] = 0.0;
+ }//end if
+ }//end for y
+
+ currentIndex[1] = index[1];
+ }//end for x
+
+}
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
new file mode 100644
index 0000000000..99366a5b80
--- /dev/null
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
@@ -0,0 +1,121 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkCorrectorTool2D_h_Included
+#define mitkCorrectorTool2D_h_Included
+
+#include "mitkCommon.h"
+#include "SegmentationExports.h"
+#include "mitkSegTool2D.h"
+#include <mitkContourModel.h>
+#include <mitkDataNode.h>
+
+#include <mitkImageLiveWireContourModelFilter.h>
+
+namespace mitk
+{
+
+
+/**
+ \brief A 2D segmentation tool based on LiveWire approach.
+ The contour between the last user added point and the current mouse position
+ is computed by searching the shortest path according to specific features of
+ the image. The contour thus snappest to the boundary of objects.
+
+
+ \sa SegTool2D
+ \sa ImageLiveWireContourModelFilter
+
+ \ingroup Interaction
+ \ingroup ToolManagerEtAl
+
+ \warning Only to be instantiated by mitk::ToolManager.
+*/
+class Segmentation_EXPORT LiveWireTool2D : public SegTool2D
+{
+ public:
+
+ mitkClassMacro(LiveWireTool2D, SegTool2D);
+ itkNewMacro(LiveWireTool2D);
+
+ virtual const char** GetXPM() const;
+ virtual const char* GetName() const;
+
+ protected:
+
+ LiveWireTool2D();
+ virtual ~LiveWireTool2D();
+
+ /**
+ * \brief Calculates how good the data, this statemachine handles, is hit by the event.
+ *
+ */
+ virtual float CanHandleEvent( StateEvent const *stateEvent) const;
+
+ virtual void Activated();
+ virtual void Deactivated();
+
+ /// \brief Initialize tool
+ virtual bool OnInitLiveWire (Action*, const StateEvent*);
+
+ /// \brief Add a control point and finish current segment
+ virtual bool OnAddPoint (Action*, const StateEvent*);
+
+ /// \breif Actual LiveWire computation
+ virtual bool OnMouseMoved(Action*, const StateEvent*);
+
+ /// \brief Check double click on first control point to finish the LiveWire tool
+ virtual bool OnCheckPoint(Action*, const StateEvent*);
+
+ /// \brief Finish LiveWire tool
+ virtual bool OnFinish(Action*, const StateEvent*);
+
+ /// \brief Close the contour
+ virtual bool OnLastSegmentDelete(Action*, const StateEvent*);
+
+ /// \brief Don't use dynamic cost map for LiveWire calculation
+ virtual bool OnMouseMoveNoDynamicCosts(Action*, const StateEvent*);
+
+ /// \brief Finish contour interaction.
+ void FinishTool();
+
+
+ //the contour already set by the user
+ mitk::ContourModel::Pointer m_Contour;
+ //the corresponding datanode
+ mitk::DataNode::Pointer m_ContourModelNode;
+
+ //the current LiveWire computed contour
+ mitk::ContourModel::Pointer m_LiveWireContour;
+ //the corresponding datanode
+ mitk::DataNode::Pointer m_LiveWireContourNode;
+
+ //the current reference image
+ mitk::Image::Pointer m_WorkingSlice;
+
+ mitk::ImageLiveWireContourModelFilter::Pointer m_LiveWireFilter;
+
+ bool m_CreateAndUseDynamicCosts;
+
+ std::vector< std::pair<mitk::DataNode*, mitk::PlaneGeometry::Pointer> > m_Contours;
+
+ template<typename TPixel, unsigned int VImageDimension>
+ void FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension>* inputImage, itk::Index<3> &index, itk::Index<3> &returnIndex);
+};
+
+} // namespace
+
+#endif
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.xpm b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.xpm
new file mode 100644
index 0000000000..e5c4a22a1a
--- /dev/null
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.xpm
@@ -0,0 +1,99 @@
+/* XPM */
+static const char * mitkLiveWireTool2D_xpm[] = {
+"24 24 72 1",
+" c None",
+". c #179FBF",
+"+ c #01AAD2",
+"@ c #00AAD3",
+"# c #0BA4CA",
+"$ c #14A0C1",
+"% c #11A2C4",
+"& c #06A7CE",
+"* c #0AA5CB",
+"= c #2895B1",
+"- c #229AB5",
+"; c #02A9D1",
+"> c #0DA3C8",
+", c #1F99B7",
+"' c #2598B5",
+") c #0CA4C9",
+"! c #13A1C2",
+"~ c #03A8D0",
+"{ c #2795B1",
+"] c #179EBF",
+"^ c #04A9D0",
+"/ c #1C9BBA",
+"( c #2497B3",
+"_ c #1E9AB9",
+": c #209AB9",
+"< c #13A0C3",
+"[ c #03A9D1",
+"} c #189DBE",
+"| c #07A7CD",
+"1 c #1A9CBC",
+"2 c #1E9BBA",
+"3 c #2699B4",
+"4 c #2498B4",
+"5 c #229AB6",
+"6 c #0EA3C8",
+"7 c #07A7CE",
+"8 c #189EBE",
+"9 c #1C9CBA",
+"0 c #04A7CF",
+"a c #11A1C5",
+"b c #07A6CD",
+"c c #09A6CC",
+"d c #2A94AD",
+"e c #1C9CBB",
+"f c #1E9BB8",
+"g c #259AB4",
+"h c #05A7CE",
+"i c #2E92A9",
+"j c #0EA2C6",
+"k c #3A8FA2",
+"l c #1B9CBC",
+"m c #1D9BB9",
+"n c #169FC1",
+"o c #00A9D2",
+"p c #1D9BBA",
+"q c #2B94AC",
+"r c #16A0C1",
+"s c #10A2C6",
+"t c #209BB9",
+"u c #1D9CBB",
+"v c #179FC0",
+"w c #000000",
+"x c #219AB4",
+"y c #FFFFFF",
+"z c #F3F6F1",
+"A c #189EC0",
+"B c #00AAD2",
+"C c #16A7BC",
+"D c #17A0BF",
+"E c #2299B7",
+"F c #1D9BB8",
+"G c #1A9CBD",
+" .+@#$%&@*= ",
+" -;>, '); ",
+" !~{ &) ",
+" ]^ /@ ",
+" (@_ :@ ",
+" <[ }| ",
+" @1 +2 ",
+" @345 67 ",
+" +@890 a^ ",
+" }bcdef gh|i ",
+" jk&@l(mn^op ",
+" qr+@@@@st ",
+" u& ",
+" 0vwwwwwwwww ",
+" @xwwwyyzyzww ",
+" ABwwwwzzzzzzww ",
+" oCwwwwwwwwzzzw ",
+" D@ wwzzw ",
+" c@@@ wzzw ",
+" EFG wwzzw ",
+" wwwwwwwwzzzw ",
+" wwwwzzzzzyww ",
+" wwwwyyyyyww ",
+" wwwwwwwwww "};
diff --git a/Modules/Segmentation/Interactions/mitkRegionGrow3DTool.cpp b/Modules/Segmentation/Interactions/mitkRegionGrow3DTool.cpp
index f76cf37273..0799b20d31 100644
--- a/Modules/Segmentation/Interactions/mitkRegionGrow3DTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkRegionGrow3DTool.cpp
@@ -1,441 +1,441 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkRegionGrow3DTool.h"
#include "mitkToolManager.h"
#include "mitkRenderingManager.h"
#include "mitkLevelWindowProperty.h"
#include "mitkPointSetInteractor.h"
#include "mitkGlobalInteraction.h"
#include "mitkITKImageImport.h"
#include "itkImage.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkConnectedAdaptiveThresholdImageFilter.h"
#include "mitkImageCast.h"
#include "mitkImageAccessByItk.h"
#include "mitkMaskAndCutRoiImageFilter.h"
#include "mitkPadImageFilter.h"
#include "mitkRegionGrow3DTool.xpm"
namespace mitk {
MITK_TOOL_MACRO(Segmentation_EXPORT, RegionGrow3DTool, "RegionGrower 3D");
}
mitk::RegionGrow3DTool::RegionGrow3DTool(): Tool("PressMoveRelease"),
m_LowerThreshold(-5000),
m_UpperThreshold(5000),
m_CurrentRGDirectionIsUpwards(false)
{
CONNECT_ACTION( 42, OnMouseReleased );
this->SupportRoiOn();
m_FeedbackNode = DataNode::New();
m_FeedbackNode->SetProperty( "color", ColorProperty::New(1.0, 0.0, 0.0) );
m_FeedbackNode->SetProperty( "texture interpolation", BoolProperty::New(false) );
m_FeedbackNode->SetProperty( "layer", IntProperty::New( 100 ) );
m_FeedbackNode->SetProperty( "levelwindow", LevelWindowProperty::New( LevelWindow(100, 1) ) );
m_FeedbackNode->SetProperty( "name", StringProperty::New("failsafe region grow feedback") );
m_FeedbackNode->SetProperty( "opacity", FloatProperty::New(0.3) );
m_FeedbackNode->SetProperty( "helper object", BoolProperty::New(true) );
m_FeedbackNode->SetVisibility(false);
m_PointSetNode = mitk::DataNode::New();
m_PointSetNode->SetName("regiongrow3d pointset");
m_PointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PointSetNode->SetProperty("layer", mitk::IntProperty::New(2));
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
m_PointSetNode->SetData(pointSet);
}
mitk::RegionGrow3DTool::~RegionGrow3DTool()
{
}
bool mitk::RegionGrow3DTool::OnMouseReleased(Action*, const StateEvent* stateEvent)
{
mitk::PointSetInteractor::Pointer interactor = dynamic_cast<mitk::PointSetInteractor*> (m_PointSetNode->GetInteractor());
if (interactor.IsNotNull())
{
mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*> (m_PointSetNode->GetData());
if (pointSet.IsNotNull())
{
if (pointSet->GetSize() == 1)
{
//check if we have a valid picture
this->RunSegmentation();
SeedButtonToggled.Send(false);
}
}
}
return true;
}
void mitk::RegionGrow3DTool::Activated()
{
if (m_ToolManager)
{
m_ToolManager->RoiDataChanged += mitk::MessageDelegate<mitk::RegionGrow3DTool>(this, &mitk::RegionGrow3DTool::UpdatePreview);
m_OriginalImageNode = m_ToolManager->GetReferenceData(0);
m_NodeToProceed = m_OriginalImageNode;
if (m_NodeToProceed.IsNotNull())
{
SetupPreviewNodeFor(m_NodeToProceed);
mitk::Image::Pointer image = dynamic_cast<mitk::Image*> (m_OriginalImageNode->GetData());
if (image.IsNotNull())
{
m_RoiMin = image->GetScalarValueMin();
m_RoiMax = image->GetScalarValueMax();
}
}
else
m_ToolManager->ActivateTool(-1);
}
}
void mitk::RegionGrow3DTool::Deactivated()
{
m_ToolManager->RoiDataChanged -= mitk::MessageDelegate<mitk::RegionGrow3DTool>(this, &mitk::RegionGrow3DTool::UpdatePreview);
if (mitk::DataStorage* ds = m_ToolManager->GetDataStorage())
{
ds->Remove(m_PointSetNode);
ds->Remove(m_FeedbackNode);
}
m_FeedbackNode->SetData(NULL);
m_FeedbackNode->SetLevelWindow(NULL);
m_FeedbackNode->SetVisibility(false);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
const char* mitk::RegionGrow3DTool::GetName() const
{
return "RegionGrower 3D";
}
const char** mitk::RegionGrow3DTool::GetXPM() const
{
return mitkRegionGrow3DTool_xpm;
}
void mitk::RegionGrow3DTool::SetSeedPoint(bool toggled)
{
if (!m_ToolManager->GetDataStorage()->Exists(m_PointSetNode)) //no pointSet present
m_ToolManager->GetDataStorage()->Add(m_PointSetNode, m_OriginalImageNode);
//add Interactor if there is none and add it to GlobalInteraction
if (toggled == true) // button is down
{
mitk::PointSetInteractor::Pointer interactor = dynamic_cast<mitk::PointSetInteractor*> (m_PointSetNode->GetInteractor());
if (interactor.IsNull())
{
//create a new interactor and add it to node
interactor = mitk::PointSetInteractor::New("singlepointinteractorwithoutshiftclick", m_PointSetNode, 1);
}
mitk::GlobalInteraction::GetInstance()->AddInteractor(interactor);
}
else
{
mitk::PointSetInteractor::Pointer interactor = dynamic_cast<mitk::PointSetInteractor*> (m_PointSetNode->GetInteractor());
if (interactor.IsNotNull())
{
m_PointSetNode->SetInteractor(NULL);
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(interactor);
}
}
}
void mitk::RegionGrow3DTool::RunSegmentation()
{
//safety if no pointSet or pointSet empty
mitk::PointSet::Pointer seedPointSet = dynamic_cast<mitk::PointSet*> (m_PointSetNode->GetData());
if (seedPointSet.IsNull())
{
return;
}
if (!(seedPointSet->GetSize() > 0))
{
return;
}
mitk::PointSet::PointType seedPoint = seedPointSet->GetPointSet()->GetPoints()->Begin().Value();
mitk::Image::Pointer image = dynamic_cast<mitk::Image*> (m_NodeToProceed->GetData());
if (image.IsNotNull())
{
m_LowerThreshold = static_cast<int> (m_RoiMin);
m_UpperThreshold = static_cast<int> (m_RoiMax);
AccessByItk_2(image, StartRegionGrowing, image->GetGeometry(), seedPoint);
}
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::RegionGrow3DTool::StartRegionGrowing(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Geometry3D* imageGeometry, mitk::PointSet::PointType seedPoint)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
typedef itk::ConnectedAdaptiveThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
if ( !imageGeometry->IsInside(seedPoint) )
{
return;
}
IndexType seedIndex;
imageGeometry->WorldToIndex( seedPoint, seedIndex);// convert world coordinates to image indices
//int seedValue = itkImage->GetPixel(seedIndex);
regionGrower->SetInput( itkImage );
regionGrower->AddSeed( seedIndex );
regionGrower->SetLower( m_LowerThreshold );
regionGrower->SetUpper( m_UpperThreshold );
regionGrower->SetGrowingDirectionIsUpwards( m_CurrentRGDirectionIsUpwards );
try
{
regionGrower->Update();
}
catch( ... )
{
MITK_ERROR << "Something went wrong!" << endl;
return;
}
m_SeedpointValue = regionGrower->GetSeedpointValue();
//initialize slider
if(m_CurrentRGDirectionIsUpwards)
{
UpperThresholdValueChanged.Send(m_UpperThreshold);
LowerThresholdValueChanged.Send(m_SeedpointValue);
}
else
{
UpperThresholdValueChanged.Send(m_SeedpointValue);
LowerThresholdValueChanged.Send(m_LowerThreshold);
}
m_DetectedLeakagePoint = regionGrower->GetLeakagePoint();
- mitk::Image::Pointer resultImage = mitk::ImportItkImage( regionGrower->GetOutput() );
+ mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput())->Clone();
m_FeedbackNode->SetData( resultImage );
m_FeedbackNode->SetVisibility(true);
InitializeLevelWindow();
}
void mitk::RegionGrow3DTool::InitializeLevelWindow()
{
mitk::LevelWindow tempLevelWindow;
m_FeedbackNode->GetLevelWindow(tempLevelWindow, NULL, "levelWindow");
mitk::ScalarType* level = new mitk::ScalarType(0.5);
mitk::ScalarType* window = new mitk::ScalarType(1);
int upper;
if (m_CurrentRGDirectionIsUpwards)
{
upper = m_UpperThreshold - m_SeedpointValue;
}
else
{
upper = m_SeedpointValue - m_LowerThreshold;
}
tempLevelWindow.SetRangeMinMax(mitk::ScalarType(0), mitk::ScalarType(upper));
tempLevelWindow.SetLevelWindow(*level, *window);
m_FeedbackNode->SetLevelWindow(tempLevelWindow, NULL, "levelWindow");
//get the suggested threshold from the detected leakage-point and adjust the slider
if (m_CurrentRGDirectionIsUpwards)
{
SliderValueChanged.Send(m_SeedpointValue + m_DetectedLeakagePoint -1);
}
else
{
SliderValueChanged.Send(m_SeedpointValue - m_DetectedLeakagePoint +1);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::RegionGrow3DTool::ChangeLevelWindow(int value)
{
if (m_FeedbackNode.IsNull())
return;
mitk::LevelWindow tempLevelWindow;
m_FeedbackNode->GetLevelWindow(tempLevelWindow, NULL, "levelWindow"); //get the levelWindow associated with the preview
mitk::ScalarType level;// = this->m_UPPERTHRESHOLD - newValue + 0.5;
mitk::ScalarType* window = new mitk::ScalarType(1);
//adjust the levelwindow according to the position of the slider (newvalue)
if (m_CurrentRGDirectionIsUpwards)
{
level = m_UpperThreshold - value + 0.5;
tempLevelWindow.SetLevelWindow(level, *window);
}
else
{
level = value - m_LowerThreshold +0.5;
tempLevelWindow.SetLevelWindow(level, *window);
}
m_FeedbackNode->SetLevelWindow(tempLevelWindow, NULL, "levelWindow");
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::RegionGrow3DTool::ConfirmSegmentation( std::string name, mitk::Color color)
{
mitk::DataNode::Pointer new_node = mitk::DataNode::New();
new_node->SetColor(color);
new_node->SetName(name);
new_node->SetProperty("binary", mitk::BoolProperty::New("true"));
mitk::Image* image = dynamic_cast<mitk::Image*> (m_FeedbackNode->GetData());
mitk::LevelWindow tempLevelWindow;
m_FeedbackNode->GetLevelWindow( tempLevelWindow, NULL, "levelWindow");
int upperThresholdLabeledImage = (short int) tempLevelWindow.GetRangeMax();
int lowerThresholdLabeledImage = (short int) tempLevelWindow.GetLowerWindowBound() + 1;
typedef itk::Image<int, 3> InputImageType;
typedef itk::Image<unsigned char, 3> SegmentationType;
typedef itk::BinaryThresholdImageFilter<InputImageType, SegmentationType> ThresholdFilterType;
ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
InputImageType::Pointer itkImage;
mitk::CastToItkImage(image, itkImage);
filter->SetInput(itkImage);
filter->SetInsideValue(1);
filter->SetOutsideValue(0);
filter->SetUpperThreshold(upperThresholdLabeledImage);
filter->SetLowerThreshold(lowerThresholdLabeledImage);
filter->Update();
mitk::Image::Pointer new_image = mitk::Image::New();
mitk::CastToMitkImage(filter->GetOutput(), new_image);
//pad to original size
if (m_OriginalImageNode.GetPointer() != m_NodeToProceed.GetPointer())
{
mitk::PadImageFilter::Pointer padFilter = mitk::PadImageFilter::New();
padFilter->SetInput(0, new_image);
padFilter->SetInput(1, dynamic_cast<mitk::Image*> (m_OriginalImageNode->GetData()));
padFilter->SetBinaryFilter(true);
padFilter->SetUpperThreshold(1);
padFilter->SetLowerThreshold(1);
padFilter->Update();
new_image = padFilter->GetOutput();
}
new_node->SetData(new_image);
m_ToolManager->GetDataStorage()->Add(new_node);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_ToolManager->ActivateTool(-1);
}
void mitk::RegionGrow3DTool::CancelSegmentation()
{
m_ToolManager->ActivateTool(-1);
}
void mitk::RegionGrow3DTool::SetupPreviewNodeFor( DataNode* nodeToProceed)
{
if (nodeToProceed)
{
Image::Pointer image = dynamic_cast<Image*>( nodeToProceed->GetData() );
if (image.IsNotNull())
{
m_FeedbackNode->SetData( image );
int layer(50);
nodeToProceed->GetIntProperty("layer", layer);
m_FeedbackNode->SetIntProperty("layer", layer+1);
m_FeedbackNode->SetLevelWindow(NULL);
if (DataStorage* storage = m_ToolManager->GetDataStorage())
{
if (storage->Exists(m_FeedbackNode))
storage->Remove(m_FeedbackNode);
storage->Add( m_FeedbackNode, nodeToProceed );
}
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::RegionGrow3DTool::UpdatePreview()
{
typedef itk::Image<int, 3> ItkImageType;
typedef itk::Image<unsigned char, 3> ItkMaskType;
mitk::DataNode::Pointer node = m_ToolManager->GetRoiData(0);
if (node.IsNull())
{
this->SetupPreviewNodeFor(m_OriginalImageNode);
m_NodeToProceed = m_OriginalImageNode;
mitk::Image::Pointer image = dynamic_cast<mitk::Image*> (m_OriginalImageNode->GetData());
if (image.IsNotNull())
{
m_RoiMin = image->GetScalarValueMin();
m_RoiMax = image->GetScalarValueMax();
}
return;
}
mitk::MaskAndCutRoiImageFilter::Pointer roiFilter = mitk::MaskAndCutRoiImageFilter::New();
roiFilter->SetInput(dynamic_cast<mitk::Image*> (m_NodeToProceed->GetData()));
roiFilter->SetRegionOfInterest(node->GetData());
roiFilter->Update();
mitk::DataNode::Pointer new_node = mitk::DataNode::New();
mitk::Image::Pointer tmpImage = roiFilter->GetOutput();
new_node->SetData(tmpImage);
m_RoiMax = roiFilter->GetMaxValue();
m_RoiMin = roiFilter->GetMinValue();
this->SetupPreviewNodeFor(new_node);
m_NodeToProceed = new_node;
//this->RunSegmentation();
}
void mitk::RegionGrow3DTool::SetCurrentRGDirectionIsUpwards(bool flag)
{
m_CurrentRGDirectionIsUpwards = flag;
}
diff --git a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
index 300a6cd24c..0137573a64 100644
--- a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
@@ -1,670 +1,670 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkRegionGrowingTool.h"
#include "mitkToolManager.h"
#include "mitkOverwriteSliceImageFilter.h"
#include "mitkImageDataItem.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include "mitkApplicationCursor.h"
#include "ipSegmentation.h"
#include "mitkRegionGrowingTool.xpm"
#include "mitkOverwriteDirectedPlaneImageFilter.h"
#include "mitkExtractDirectedPlaneImageFilterNew.h"
namespace mitk {
MITK_TOOL_MACRO(Segmentation_EXPORT, RegionGrowingTool, "Region growing tool");
}
#define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
mitk::RegionGrowingTool::RegionGrowingTool()
:FeedbackContourTool("PressMoveRelease"),
m_LowerThreshold(200),
m_UpperThreshold(200),
m_InitialLowerThreshold(200),
m_InitialUpperThreshold(200),
m_ScreenYDifference(0),
m_OriginalPicSlice(NULL),
m_SeedPointMemoryOffset(0),
m_VisibleWindow(0),
m_DefaultWindow(0),
m_MouseDistanceScaleFactor(0.5),
m_LastWorkingSeed(-1),
m_FillFeedbackContour(true)
{
// great magic numbers
CONNECT_ACTION( 80, OnMousePressed );
CONNECT_ACTION( 90, OnMouseMoved );
CONNECT_ACTION( 42, OnMouseReleased );
}
mitk::RegionGrowingTool::~RegionGrowingTool()
{
}
const char** mitk::RegionGrowingTool::GetXPM() const
{
return mitkRegionGrowingTool_xpm;
}
const char* mitk::RegionGrowingTool::GetName() const
{
return "Region Growing";
}
void mitk::RegionGrowingTool::Activated()
{
Superclass::Activated();
}
void mitk::RegionGrowingTool::Deactivated()
{
Superclass::Deactivated();
}
/**
1 Determine which slice is clicked into
2 Determine if the user clicked inside or outside of the segmentation
3 Depending on the pixel value under the mouse click position, two different things happen: (separated out into OnMousePressedInside and OnMousePressedOutside)
3.1 Create a skeletonization of the segmentation and try to find a nice cut
3.1.1 Call a ipSegmentation algorithm to create a nice cut
3.1.2 Set the result of this algorithm as the feedback contour
3.2 Initialize region growing
3.2.1 Determine memory offset inside the original image
3.2.2 Determine initial region growing parameters from the level window settings of the image
3.2.3 Perform a region growing (which generates a new feedback contour)
*/
bool mitk::RegionGrowingTool::OnMousePressed (Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent) return false;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
//ToolLogger::SetVerboseness(3);
MITK_DEBUG << "OnMousePressed" << std::endl;
if ( FeedbackContourTool::CanHandleEvent(stateEvent) > 0.0 )
{
MITK_DEBUG << "OnMousePressed: FeedbackContourTool says ok" << std::endl;
// 1. Find out which slice the user clicked, find out which slice of the toolmanager's reference and working image corresponds to that
if (positionEvent)
{
MITK_DEBUG << "OnMousePressed: got positionEvent" << std::endl;
m_ReferenceSlice = FeedbackContourTool::GetAffectedReferenceSlice( positionEvent );
m_WorkingSlice = FeedbackContourTool::GetAffectedWorkingSlice( positionEvent );
if ( m_WorkingSlice.IsNotNull() ) // can't do anything without the segmentation
{
MITK_DEBUG << "OnMousePressed: got working slice" << std::endl;
// 2. Determine if the user clicked inside or outside of the segmentation
const Geometry3D* workingSliceGeometry = m_WorkingSlice->GetGeometry();
Point3D mprojectedPointIn2D;
workingSliceGeometry->WorldToIndex( positionEvent->GetWorldPosition(), mprojectedPointIn2D);
itk::Index<2> projectedPointInWorkingSlice2D;
projectedPointInWorkingSlice2D[0] = static_cast<int>( mprojectedPointIn2D[0] - 0.5 );
projectedPointInWorkingSlice2D[1] = static_cast<int>( mprojectedPointIn2D[1] - 0.5 );
if ( workingSliceGeometry->IsIndexInside( projectedPointInWorkingSlice2D ) )
{
MITK_DEBUG << "OnMousePressed: point " << positionEvent->GetWorldPosition() << " (index coordinates " << projectedPointInWorkingSlice2D << ") IS in working slice" << std::endl;
// Convert to ipMITKSegmentationTYPE (because getting pixels relys on that data type)
itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
CastToItkImage( m_WorkingSlice, correctPixelTypeImage );
assert (correctPixelTypeImage.IsNotNull() );
// possible bug in CastToItkImage ?
// direction maxtrix is wrong/broken/not working after CastToItkImage, leading to a failed assertion in
// mitk/Core/DataStructures/mitkSlicedGeometry3D.cpp, 479:
// virtual void mitk::SlicedGeometry3D::SetSpacing(const mitk::Vector3D&): Assertion `aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0' failed
// solution here: we overwrite it with an unity matrix
itk::Image< ipMITKSegmentationTYPE, 2 >::DirectionType imageDirection;
imageDirection.SetIdentity();
correctPixelTypeImage->SetDirection(imageDirection);
Image::Pointer temporarySlice = Image::New();
// temporarySlice = ImportItkImage( correctPixelTypeImage );
CastToMitkImage( correctPixelTypeImage, temporarySlice );
mitkIpPicDescriptor* workingPicSlice = mitkIpPicNew();
CastToIpPicDescriptor(temporarySlice, workingPicSlice);
int initialWorkingOffset = projectedPointInWorkingSlice2D[1] * workingPicSlice->n[0] + projectedPointInWorkingSlice2D[0];
if ( initialWorkingOffset < static_cast<int>( workingPicSlice->n[0] * workingPicSlice->n[1] ) &&
initialWorkingOffset >= 0 )
{
// 3. determine the pixel value under the last click
bool inside = static_cast<ipMITKSegmentationTYPE*>(workingPicSlice->data)[initialWorkingOffset] != 0;
m_PaintingPixelValue = inside ? 0 : 1; // if inside, we want to remove a part, otherwise we want to add something
if ( m_LastWorkingSeed >= static_cast<int>( workingPicSlice->n[0] * workingPicSlice->n[1] ) ||
m_LastWorkingSeed < 0 )
{
inside = false;
}
if ( m_ReferenceSlice.IsNotNull() )
{
MITK_DEBUG << "OnMousePressed: got reference slice" << std::endl;
m_OriginalPicSlice = mitkIpPicNew();
CastToIpPicDescriptor(m_ReferenceSlice, m_OriginalPicSlice);
// 3.1. Switch depending on the pixel value
if (inside)
{
OnMousePressedInside(action, stateEvent, workingPicSlice, initialWorkingOffset);
}
else
{
OnMousePressedOutside(action, stateEvent);
}
}
}
}
}
}
}
MITK_DEBUG << "end OnMousePressed" << std::endl;
return true;
}
/**
3.1 Create a skeletonization of the segmentation and try to find a nice cut
3.1.1 Call a ipSegmentation algorithm to create a nice cut
3.1.2 Set the result of this algorithm as the feedback contour
*/
bool mitk::RegionGrowingTool::OnMousePressedInside(Action* itkNotUsed( action ), const StateEvent* stateEvent, mitkIpPicDescriptor* workingPicSlice, int initialWorkingOffset)
{
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent()); // checked in OnMousePressed
// 3.1.1. Create a skeletonization of the segmentation and try to find a nice cut
// apply the skeletonization-and-cut algorithm
// generate contour to remove
// set m_ReferenceSlice = NULL so nothing will happen during mouse move
// remember to fill the contour with 0 in mouserelease
mitkIpPicDescriptor* segmentationHistory = ipMITKSegmentationCreateGrowerHistory( workingPicSlice, m_LastWorkingSeed, NULL ); // free again
if (segmentationHistory)
{
tCutResult cutContour = ipMITKSegmentationGetCutPoints( workingPicSlice, segmentationHistory, initialWorkingOffset ); // tCutResult is a ipSegmentation type
mitkIpPicFree( segmentationHistory );
if (cutContour.cutIt)
{
// 3.1.2 copy point from float* to mitk::Contour
Contour::Pointer contourInImageIndexCoordinates = Contour::New();
contourInImageIndexCoordinates->Initialize();
Point3D newPoint;
for (int index = 0; index < cutContour.deleteSize; ++index)
{
newPoint[0] = cutContour.deleteCurve[ 2 * index + 0 ];
newPoint[1] = cutContour.deleteCurve[ 2 * index + 1 ];
newPoint[2] = 0.0;
- contourInImageIndexCoordinates->AddVertex( newPoint - 0.5 );
+ contourInImageIndexCoordinates->AddVertex( newPoint - mitk::Point3D::VectorType(0.5) );
}
free(cutContour.traceline);
free(cutContour.deleteCurve); // perhaps visualize this for fun?
free(cutContour.onGradient);
Contour::Pointer contourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( m_WorkingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true: sub 0.5 for ipSegmentation correction
FeedbackContourTool::SetFeedbackContour( *contourInWorldCoordinates );
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
m_FillFeedbackContour = true;
}
else
{
m_FillFeedbackContour = false;
}
}
else
{
m_FillFeedbackContour = false;
}
m_ReferenceSlice = NULL;
return true;
}
/**
3.2 Initialize region growing
3.2.1 Determine memory offset inside the original image
3.2.2 Determine initial region growing parameters from the level window settings of the image
3.2.3 Perform a region growing (which generates a new feedback contour)
*/
bool mitk::RegionGrowingTool::OnMousePressedOutside(Action* itkNotUsed( action ), const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent()); // checked in OnMousePressed
// 3.2 If we have a reference image, then perform an initial region growing, considering the reference image's level window
// if click was outside the image, don't continue
const Geometry3D* sliceGeometry = m_ReferenceSlice->GetGeometry();
Point3D mprojectedPointIn2D;
sliceGeometry->WorldToIndex( positionEvent->GetWorldPosition(), mprojectedPointIn2D );
itk::Index<2> projectedPointIn2D;
projectedPointIn2D[0] = static_cast<int>( mprojectedPointIn2D[0] - 0.5 );
projectedPointIn2D[1] = static_cast<int>( mprojectedPointIn2D[1] - 0.5 );
if ( sliceGeometry->IsIndexInside( mprojectedPointIn2D ) )
{
MITK_DEBUG << "OnMousePressed: point " << positionEvent->GetWorldPosition() << " (index coordinates " << mprojectedPointIn2D << ") IS in reference slice" << std::endl;
// 3.2.1 Remember Y cursor position and initial seed point
//m_ScreenYPositionAtStart = static_cast<int>(positionEvent->GetDisplayPosition()[1]);
m_LastScreenPosition = ApplicationCursor::GetInstance()->GetCursorPosition();
m_ScreenYDifference = 0;
m_SeedPointMemoryOffset = projectedPointIn2D[1] * m_OriginalPicSlice->n[0] + projectedPointIn2D[0];
m_LastWorkingSeed = m_SeedPointMemoryOffset; // remember for skeletonization
if ( m_SeedPointMemoryOffset < static_cast<int>( m_OriginalPicSlice->n[0] * m_OriginalPicSlice->n[1] ) &&
m_SeedPointMemoryOffset >= 0 )
{
// 3.2.2 Get level window from reference DataNode
// Use some logic to determine initial gray value bounds
LevelWindow lw(0, 500);
m_ToolManager->GetReferenceData(0)->GetLevelWindow(lw); // will fill lw if levelwindow property is present, otherwise won't touch it.
ScalarType currentVisibleWindow = lw.GetWindow();
if (!mitk::Equal(currentVisibleWindow, m_VisibleWindow))
{
m_InitialLowerThreshold = currentVisibleWindow / 20.0;
m_InitialUpperThreshold = currentVisibleWindow / 20.0;
m_LowerThreshold = m_InitialLowerThreshold;
m_UpperThreshold = m_InitialUpperThreshold;
// 3.2.3. Actually perform region growing
mitkIpPicDescriptor* result = PerformRegionGrowingAndUpdateContour();
ipMITKSegmentationFree( result);
// display the contour
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
m_FillFeedbackContour = true;
}
}
return true;
}
return false;
}
/**
If in region growing mode (m_ReferenceSlice != NULL), then
1. Calculate the new thresholds from mouse position (relative to first position)
2. Perform a new region growing and update the feedback contour
*/
bool mitk::RegionGrowingTool::OnMouseMoved(Action* action, const StateEvent* stateEvent)
{
if ( FeedbackContourTool::CanHandleEvent(stateEvent) > 0.0 )
{
if ( m_ReferenceSlice.IsNotNull() && m_OriginalPicSlice )
{
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (positionEvent)
{
ApplicationCursor* cursor = ApplicationCursor::GetInstance();
if (!cursor) return false;
m_ScreenYDifference += cursor->GetCursorPosition()[1] - m_LastScreenPosition[1];
cursor->SetCursorPosition( m_LastScreenPosition );
m_LowerThreshold = std::max<mitk::ScalarType>(0.0, m_InitialLowerThreshold - m_ScreenYDifference * m_MouseDistanceScaleFactor);
m_UpperThreshold = std::max<mitk::ScalarType>(0.0, m_InitialUpperThreshold - m_ScreenYDifference * m_MouseDistanceScaleFactor);
// 2. Perform region growing again and show the result
mitkIpPicDescriptor* result = PerformRegionGrowingAndUpdateContour();
ipMITKSegmentationFree( result );
// 3. Update the contour
mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(positionEvent->GetSender()->GetRenderWindow());
}
}
}
return true;
}
/**
If the feedback contour should be filled, then it is done here. (Contour is NOT filled, when skeletonization is done but no nice cut was found)
*/
bool mitk::RegionGrowingTool::OnMouseReleased(Action* action, const StateEvent* stateEvent)
{
if ( FeedbackContourTool::CanHandleEvent(stateEvent) > 0.0 )
{
// 1. If we have a working slice, use the contour to fill a new piece on segmentation on it (or erase a piece that was selected by ipMITKSegmentationGetCutPoints)
if ( m_WorkingSlice.IsNotNull() && m_OriginalPicSlice )
{
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (positionEvent)
{
// remember parameters for next time
m_InitialLowerThreshold = m_LowerThreshold;
m_InitialUpperThreshold = m_UpperThreshold;
if (m_FillFeedbackContour)
{
// 3. use contour to fill a region in our working slice
Contour* feedbackContour( FeedbackContourTool::GetFeedbackContour() );
if (feedbackContour)
{
Contour::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice( m_WorkingSlice, feedbackContour, false, false ); // false: don't add any 0.5
// false: don't constrain the contour to the image's inside
if (projectedContour.IsNotNull())
{
FeedbackContourTool::FillContourInSlice( projectedContour, m_WorkingSlice, m_PaintingPixelValue );
const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
//MITK_DEBUG << "OnMouseReleased: writing back to dimension " << affectedDimension << ", slice " << affectedSlice << " in working image" << std::endl;
// 4. write working slice back into image volume
this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice);
}
}
}
FeedbackContourTool::SetFeedbackContourVisible(false);
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
}
}
}
m_ReferenceSlice = NULL; // don't leak
m_WorkingSlice = NULL;
m_OriginalPicSlice = NULL;
return true;
}
/**
Uses ipSegmentation algorithms to do the actual region growing. The result (binary image) is first smoothed by a 5x5 circle mask, then
its contour is extracted and converted to MITK coordinates.
*/
mitkIpPicDescriptor* mitk::RegionGrowingTool::PerformRegionGrowingAndUpdateContour()
{
// 1. m_OriginalPicSlice and m_SeedPointMemoryOffset are set to sensitive values, as well as m_LowerThreshold and m_UpperThreshold
assert (m_OriginalPicSlice);
if (m_OriginalPicSlice->n[0] != 256 || m_OriginalPicSlice->n[1] != 256) // ???
assert( (m_SeedPointMemoryOffset < static_cast<int>( m_OriginalPicSlice->n[0] * m_OriginalPicSlice->n[1] )) && (m_SeedPointMemoryOffset >= 0) ); // inside the image
// 2. ipSegmentation is used to perform region growing
float ignored;
int oneContourOffset( 0 );
mitkIpPicDescriptor* regionGrowerResult = ipMITKSegmentationGrowRegion4N( m_OriginalPicSlice,
m_SeedPointMemoryOffset, // seed point
true, // grayvalue interval relative to seed point gray value?
m_LowerThreshold,
m_UpperThreshold,
0, // continue until done (maxIterations == 0)
NULL, // allocate new memory (only this time, on mouse move we'll reuse the old buffer)
oneContourOffset, // a pixel that is near the resulting contour
ignored // ignored by us
);
if (!regionGrowerResult || oneContourOffset == -1)
{
Contour::Pointer dummyContour = Contour::New();
dummyContour->Initialize();
FeedbackContourTool::SetFeedbackContour( *dummyContour );
if (regionGrowerResult) ipMITKSegmentationFree(regionGrowerResult);
return NULL;
}
// 3. We smooth the result a little to reduce contour complexity
bool smoothResult( true ); // currently fixed, perhaps remove else block
mitkIpPicDescriptor* smoothedRegionGrowerResult;
if (smoothResult)
{
// Smooth the result (otherwise very detailed contour)
smoothedRegionGrowerResult = SmoothIPPicBinaryImage( regionGrowerResult, oneContourOffset );
ipMITKSegmentationFree( regionGrowerResult );
}
else
{
smoothedRegionGrowerResult = regionGrowerResult;
}
// 4. convert the result of region growing into a mitk::Contour
// At this point oneContourOffset could be useless, if smoothing destroyed a thin bridge. In these
// cases, we have two or more unconnected segmentation regions, and we don't know, which one is touched by oneContourOffset.
// In the bad case, the contour is not the one around our seedpoint, so the result looks very strange to the user.
// -> we remove the point where the contour started so far. Then we look from the bottom of the image for the first segmentation pixel
// and start another contour extraction from there. This is done, until the seedpoint is inside the contour
int numberOfContourPoints( 0 );
int newBufferSize( 0 );
float* contourPoints = ipMITKSegmentationGetContour8N( smoothedRegionGrowerResult, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
if (contourPoints)
{
while ( !ipMITKSegmentationIsInsideContour( contourPoints, // contour
numberOfContourPoints, // points in contour
m_SeedPointMemoryOffset % smoothedRegionGrowerResult->n[0], // test point x
m_SeedPointMemoryOffset / smoothedRegionGrowerResult->n[0] // test point y
) )
{
// we decide that this cannot be part of the segmentation because the seedpoint is not contained in the contour (fill the 4-neighborhood with 0)
ipMITKSegmentationReplaceRegion4N( smoothedRegionGrowerResult, oneContourOffset, 0 );
// move the contour offset to the last row (x position of the seed point)
int rowLength = smoothedRegionGrowerResult->n[0]; // number of pixels in a row
oneContourOffset = m_SeedPointMemoryOffset % smoothedRegionGrowerResult->n[0] // x of seed point
+ rowLength*(smoothedRegionGrowerResult->n[1]-1); // y of last row
while ( oneContourOffset >=0
&& (*(static_cast<ipMITKSegmentationTYPE*>(smoothedRegionGrowerResult->data) + oneContourOffset) == 0) )
{
oneContourOffset -= rowLength; // if pixel at data+oneContourOffset is 0, then move up one row
}
if ( oneContourOffset < 0 )
{
break; // just use the last contour we found
}
free(contourPoints); // release contour memory
contourPoints = ipMITKSegmentationGetContour8N( smoothedRegionGrowerResult, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
}
// copy point from float* to mitk::Contour
Contour::Pointer contourInImageIndexCoordinates = Contour::New();
contourInImageIndexCoordinates->Initialize();
Point3D newPoint;
for (int index = 0; index < numberOfContourPoints; ++index)
{
newPoint[0] = contourPoints[ 2 * index + 0 ];
newPoint[1] = contourPoints[ 2 * index + 1 ];
newPoint[2] = 0;
- contourInImageIndexCoordinates->AddVertex( newPoint - 0.5);
+ contourInImageIndexCoordinates->AddVertex( newPoint - mitk::Point3D::VectorType(0.5));
}
free(contourPoints);
Contour::Pointer contourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( m_ReferenceSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true: sub 0.5 for ipSegmentation correctio
FeedbackContourTool::SetFeedbackContour( *contourInWorldCoordinates );
}
// 5. Result HAS TO BE freed by caller, contains the binary region growing result
return smoothedRegionGrowerResult;
}
/**
Helper method for SmoothIPPicBinaryImage. Smoothes a given part of and image.
\param sourceImage The original binary image.
\param dest The smoothed image (will be written without bounds checking).
\param contourOfs One offset of the contour. Is updated if a pixel is changed (which might change the contour).
\param maskOffsets Memory offsets that describe the smoothing mask.
\param maskSize Entries of the mask.
\param startOffset First pixel that should be smoothed using this mask.
\param endOffset Last pixel that should be smoothed using this mask.
*/
void mitk::RegionGrowingTool::SmoothIPPicBinaryImageHelperForRows( mitkIpPicDescriptor* sourceImage, mitkIpPicDescriptor* dest, int &contourOfs, int* maskOffsets, int maskSize, int startOffset, int endOffset )
{
// work on the very first row
ipMITKSegmentationTYPE* current;
ipMITKSegmentationTYPE* source = ((ipMITKSegmentationTYPE*)sourceImage->data) + startOffset; // + 1! don't read at start-1
ipMITKSegmentationTYPE* end = ((ipMITKSegmentationTYPE*)dest->data) + endOffset;
int ofs = startOffset;
int minority = (maskSize - 1) / 2;
for (current = ((ipMITKSegmentationTYPE*)dest->data) + startOffset; current<end; current++)
{
mitkIpInt1_t sum( 0 );
for (int i = 0; i < maskSize; ++i)
{
sum += *(source+maskOffsets[i]);
}
if (sum > minority)
{
*current = 1;
contourOfs = ofs;
}
else
{
*current = 0;
}
++source;
++ofs;
}
}
/**
Smoothes a binary ipPic image with a 5x5 mask. The image borders (some first and last rows) are treated differently.
*/
mitkIpPicDescriptor* mitk::RegionGrowingTool::SmoothIPPicBinaryImage( mitkIpPicDescriptor* image, int &contourOfs, mitkIpPicDescriptor* dest )
{
if (!image) return NULL;
// Original code from /trunk/mbi-qm/Qmitk/Qmitk2DSegTools/RegionGrowerTool.cpp (first version by T. Boettger?). Reformatted and documented and restructured.
#define MSK_SIZE5x5 21
#define MSK_SIZE3x3 5
#define MSK_SIZE3x1 3
// mask is an array of coordinates that form a rastered circle like this
//
// OOO
// OOOOO
// OOOOO
// OOOOO
// OOO
//
//
int mask5x5[MSK_SIZE5x5][2]
= {
/******/ {-1,-2}, {0,-2}, {1,-2}, /*****/
{-2,-1}, {-1,-1}, {0,-1}, {1,-1}, {2,-1},
{-2, 0}, {-1, 0}, {0, 0}, {1, 0}, {2, 0},
{-2, 1}, {-1, 1}, {0, 1}, {1, 1}, {2, 1},
/******/ {-1, 2}, {0, 2}, {1, 2} /*****/
};
int mask3x3[MSK_SIZE3x3][2]
= {
/******/ {0,-1}, /*****/
{-1, 0}, {0, 0}, {1, 0},
/******/ {0, 1} /*****/
};
int mask3x1[MSK_SIZE3x1][2]
= {
{-1, 0}, {0, 0}, {1, 0}
};
// The following lines iterate over all the pixels of a (sliced) image (except the first and last three rows).
// For each pixel, all the coordinates around it (according to mask) are evaluated (this means 21 pixels).
// If more than 10 of the evaluated pixels are non-zero, then the central pixel is set to 1, else to 0.
// This is determining a majority. If there is no clear majority, then the central pixel itself "decides".
int maskOffset5x5[MSK_SIZE5x5];
int line = image->n[0];
for (int i=0; i<MSK_SIZE5x5; i++)
{
maskOffset5x5[i] = mask5x5[i][0] + line * mask5x5[i][1]; // calculate memory offsets from the x,y mask elements
}
int maskOffset3x3[MSK_SIZE3x3];
for (int i=0; i<MSK_SIZE3x3; i++)
{
maskOffset3x3[i] = mask3x3[i][0] + line * mask3x3[i][1]; // calculate memory offsets from the x,y mask elements
}
int maskOffset3x1[MSK_SIZE3x1];
for (int i=0; i<MSK_SIZE3x1; i++)
{
maskOffset3x1[i] = mask3x1[i][0] + line * mask3x1[i][1]; // calculate memory offsets from the x,y mask elements
}
if (!dest)
{
// create pic if necessary
dest = ipMITKSegmentationNew( image );
}
int spareOut3Rows = 3*image->n[0];
int spareOut1Rows = 1*image->n[0];
if ( image->n[1] > 0 ) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset3x1, MSK_SIZE3x1, 1, dest->n[0] );
if ( image->n[1] > 3 ) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset3x3, MSK_SIZE3x3, spareOut1Rows, dest->n[0]*3 );
if ( image->n[1] > 6 ) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset5x5, MSK_SIZE5x5, spareOut3Rows, dest->n[0]*dest->n[1] - spareOut3Rows );
if ( image->n[1] > 8 ) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset3x3, MSK_SIZE3x3, dest->n[0]*dest->n[1] -spareOut3Rows, dest->n[0]*dest->n[1] - spareOut1Rows );
if ( image->n[1] > 10) SmoothIPPicBinaryImageHelperForRows( image, dest, contourOfs, maskOffset3x1, MSK_SIZE3x1, dest->n[0]*dest->n[1] -spareOut1Rows, dest->n[0]*dest->n[1] - 1 );
// correction for first pixel (sorry for the ugliness)
if ( *((ipMITKSegmentationTYPE*)(dest->data)+1) == 1 )
{
*((ipMITKSegmentationTYPE*)(dest->data)+0) = 1;
}
if (dest->n[0] * dest->n[1] > 2)
{
// correction for last pixel
if ( *((ipMITKSegmentationTYPE*)(dest->data)+dest->n[0]*dest->n[1]-2) == 1 )
{
*((ipMITKSegmentationTYPE*)(dest->data)+dest->n[0]*dest->n[1]-1) = 1;
}
}
return dest;
}
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index 739ed49b80..8fb2bbff62 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,373 +1,400 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSegTool2D.h"
#include "mitkToolManager.h"
#include "mitkDataStorage.h"
#include "mitkBaseRenderer.h"
#include "mitkPlaneGeometry.h"
#include "mitkExtractImageFilter.h"
#include "mitkExtractDirectedPlaneImageFilter.h"
//Include of the new ImageExtractor
#include "mitkExtractDirectedPlaneImageFilterNew.h"
#include "mitkPlanarCircle.h"
#include "mitkOverwriteSliceImageFilter.h"
#include "mitkOverwriteDirectedPlaneImageFilter.h"
#include "mitkGetModuleContext.h"
//Includes for 3DSurfaceInterpolation
#include "mitkImageToContourFilter.h"
#include "mitkSurfaceInterpolationController.h"
//includes for resling and overwriting
#include <mitkExtractSliceFilter.h>
#include <mitkVtkImageOverwrite.h>
#include <vtkSmartPointer.h>
#include <vtkImageData.h>
#include <mitkDiffSliceOperationApplier.h>
#include "mitkOperationEvent.h"
#include "mitkUndoController.h"
#define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
mitk::SegTool2D::SegTool2D(const char* type)
:Tool(type),
- m_LastEventSender(NULL),
- m_LastEventSlice(0),
- m_Contourmarkername ("Position"),
- m_ShowMarkerNodes (false),
- m_3DInterpolationEnabled(true)
+m_LastEventSender(NULL),
+m_LastEventSlice(0),
+m_Contourmarkername ("Position"),
+m_ShowMarkerNodes (false),
+m_3DInterpolationEnabled(true)
{
}
mitk::SegTool2D::~SegTool2D()
{
}
float mitk::SegTool2D::CanHandleEvent( StateEvent const *stateEvent) const
{
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent) return 0.0;
if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D ) return 0.0; // we don't want anything but 2D
//This are the mouse event that are used by the statemachine patterns for zooming and panning. This must be possible although a tool is activ
if (stateEvent->GetId() == EIDRIGHTMOUSEBTN || stateEvent->GetId() == EIDMIDDLEMOUSEBTN || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDCTRL ||
- stateEvent->GetId() == EIDMIDDLEMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDMOUSEMOVE ||
- stateEvent->GetId() == EIDMIDDLEMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNRELEASE )
+ stateEvent->GetId() == EIDMIDDLEMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDMOUSEMOVE ||
+ stateEvent->GetId() == EIDMIDDLEMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNRELEASE )
{
//Since the usual segmentation tools currently do not need right click interaction but the mitkDisplayVectorInteractor
return 0.0;
}
else
{
return 1.0;
}
}
bool mitk::SegTool2D::DetermineAffectedImageSlice( const Image* image, const PlaneGeometry* plane, int& affectedDimension, int& affectedSlice )
{
assert(image);
assert(plane);
// compare normal of plane to the three axis vectors of the image
Vector3D normal = plane->GetNormal();
Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
normal.Normalize();
imageNormal0.Normalize();
imageNormal1.Normalize();
imageNormal2.Normalize();
- imageNormal0.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal0.Get_vnl_vector()) );
- imageNormal1.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal1.Get_vnl_vector()) );
- imageNormal2.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal2.Get_vnl_vector()) );
+ imageNormal0.SetVnlVector( vnl_cross_3d<ScalarType>(normal.GetVnlVector(),imageNormal0.GetVnlVector()) );
+ imageNormal1.SetVnlVector( vnl_cross_3d<ScalarType>(normal.GetVnlVector(),imageNormal1.GetVnlVector()) );
+ imageNormal2.SetVnlVector( vnl_cross_3d<ScalarType>(normal.GetVnlVector(),imageNormal2.GetVnlVector()) );
double eps( 0.00001 );
// axial
if ( imageNormal2.GetNorm() <= eps )
{
affectedDimension = 2;
}
// sagittal
else if ( imageNormal1.GetNorm() <= eps )
{
affectedDimension = 1;
}
// frontal
else if ( imageNormal0.GetNorm() <= eps )
{
affectedDimension = 0;
}
else
{
affectedDimension = -1; // no idea
return false;
}
// determine slice number in image
Geometry3D* imageGeometry = image->GetGeometry(0);
Point3D testPoint = imageGeometry->GetCenter();
Point3D projectedPoint;
plane->Project( testPoint, projectedPoint );
Point3D indexPoint;
imageGeometry->WorldToIndex( projectedPoint, indexPoint );
affectedSlice = ROUND( indexPoint[affectedDimension] );
MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice " << affectedSlice;
// check if this index is still within the image
if ( affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)) ) return false;
return true;
}
+
mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PositionEvent* positionEvent, const Image* image)
{
if (!positionEvent) return NULL;
assert( positionEvent->GetSender() ); // sure, right?
unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image ); // get the timestep of the visible part (time-wise) of the image
// first, we determine, which slice is affected
const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
+ return this->GetAffectedImageSliceAs2DImage(planeGeometry, image, timeStep);
+}
+
+
+mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry* planeGeometry, const Image* image, unsigned int timeStep)
+{
if ( !image || !planeGeometry ) return NULL;
//Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
//set to false to extract a slice
reslice->SetOverwriteMode(false);
reslice->Modified();
//use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
extractor->SetInput( image );
extractor->SetTimeStep( timeStep );
extractor->SetWorldGeometry( planeGeometry );
extractor->SetVtkOutputRequest(false);
extractor->SetResliceTransformByGeometry( image->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
extractor->Modified();
extractor->Update();
Image::Pointer slice = extractor->GetOutput();
/*============= BEGIN undo feature block ========================*/
//specify the undo operation with the non edited slice
m_undoOperation = new DiffSliceOperation(const_cast<mitk::Image*>(image), extractor->GetVtkOutput(), slice->GetGeometry(), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
/*============= END undo feature block ========================*/
return slice;
}
+
mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const PositionEvent* positionEvent)
{
DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
if ( !workingNode ) return NULL;
Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
if ( !workingImage ) return NULL;
return GetAffectedImageSliceAs2DImage( positionEvent, workingImage );
}
+
mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const PositionEvent* positionEvent)
{
DataNode* referenceNode( m_ToolManager->GetReferenceData(0) );
if ( !referenceNode ) return NULL;
Image* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
if ( !referenceImage ) return NULL;
return GetAffectedImageSliceAs2DImage( positionEvent, referenceImage );
}
void mitk::SegTool2D::WriteBackSegmentationResult (const PositionEvent* positionEvent, Image* slice)
{
+ if(!positionEvent) return;
+
const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
+ if( planeGeometry && slice)
+ {
+ DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
+ Image* image = dynamic_cast<Image*>(workingNode->GetData());
+ unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image );
+ this->WriteBackSegmentationResult(planeGeometry, slice, timeStep);
+
+ slice->DisconnectPipeline();
+ ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
+ contourExtractor->SetInput(slice);
+ contourExtractor->Update();
+ mitk::Surface::Pointer contour = contourExtractor->GetOutput();
+
+ if (m_3DInterpolationEnabled && contour->GetVtkPolyData()->GetNumberOfPoints() > 0 )
+ {
+ unsigned int pos = this->AddContourmarker(positionEvent);
+ mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
+ PlanePositionManagerService* service = dynamic_cast<PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
+ mitk::SurfaceInterpolationController::GetInstance()->AddNewContour( contour, service->GetPlanePosition(pos));
+ contour->DisconnectPipeline();
+ }
+ }
+
+}
+
+
+void mitk::SegTool2D::WriteBackSegmentationResult (const PlaneGeometry* planeGeometry, Image* slice, unsigned int timeStep)
+{
+ if(!planeGeometry || !slice) return;
+
+
DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
Image* image = dynamic_cast<Image*>(workingNode->GetData());
- unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image );
- //Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
+ //Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
//Set the slice as 'input'
reslice->SetInputSlice(slice->GetVtkImageData());
//set overwrite mode to true to write back to the image volume
reslice->SetOverwriteMode(true);
reslice->Modified();
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
extractor->SetInput( image );
extractor->SetTimeStep( timeStep );
extractor->SetWorldGeometry( planeGeometry );
extractor->SetVtkOutputRequest(true);
extractor->SetResliceTransformByGeometry( image->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
extractor->Modified();
extractor->Update();
//the image was modified within the pipeline, but not marked so
image->Modified();
image->GetVtkImageData()->Modified();
/*============= BEGIN undo feature block ========================*/
//specify the undo operation with the edited slice
m_doOperation = new DiffSliceOperation(image, extractor->GetVtkOutput(),slice->GetGeometry(), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
//create an operation event for the undo stack
OperationEvent* undoStackItem = new OperationEvent( DiffSliceOperationApplier::GetInstance(), m_doOperation, m_undoOperation, "Segmentation" );
//add it to the undo controller
UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
//clear the pointers as the operation are stored in the undocontroller and also deleted from there
m_undoOperation = NULL;
m_doOperation = NULL;
/*============= END undo feature block ========================*/
- slice->DisconnectPipeline();
- ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
- contourExtractor->SetInput(slice);
- contourExtractor->Update();
- mitk::Surface::Pointer contour = contourExtractor->GetOutput();
-
- if (m_3DInterpolationEnabled)
- {
- unsigned int pos = this->AddContourmarker(positionEvent);
- mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
- PlanePositionManagerService* service = dynamic_cast<PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
- mitk::SurfaceInterpolationController::GetInstance()->AddNewContour( contour, service->GetPlanePosition(pos));
- contour->DisconnectPipeline();
- }
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+
}
void mitk::SegTool2D::SetShowMarkerNodes(bool status)
{
- m_ShowMarkerNodes = status;
+ m_ShowMarkerNodes = status;
}
void mitk::SegTool2D::SetEnable3DInterpolation(bool enabled)
{
m_3DInterpolationEnabled = enabled;
}
unsigned int mitk::SegTool2D::AddContourmarker ( const PositionEvent* positionEvent )
{
const mitk::Geometry2D* plane = dynamic_cast<const Geometry2D*> (dynamic_cast< const mitk::SlicedGeometry3D*>(
positionEvent->GetSender()->GetSliceNavigationController()->GetCurrentGeometry3D())->GetGeometry2D(0));
mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
PlanePositionManagerService* service = dynamic_cast<PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
unsigned int size = service->GetNumberOfPlanePositions();
unsigned int id = service->AddNewPlanePosition(plane, positionEvent->GetSender()->GetSliceNavigationController()->GetSlice()->GetPos());
mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
mitk::Point2D p1;
plane->Map(plane->GetCenter(), p1);
mitk::Point2D p2 = p1;
p2[0] -= plane->GetSpacing()[0];
p2[1] -= plane->GetSpacing()[1];
contourMarker->PlaceFigure( p1 );
contourMarker->SetCurrentControlPoint( p1 );
contourMarker->SetGeometry2D( const_cast<Geometry2D*>(plane));
std::stringstream markerStream;
mitk::DataNode* workingNode (m_ToolManager->GetWorkingData(0));
markerStream << m_Contourmarkername ;
markerStream << " ";
markerStream << id+1;
DataNode::Pointer rotatedContourNode = DataNode::New();
rotatedContourNode->SetData(contourMarker);
rotatedContourNode->SetProperty( "name", StringProperty::New(markerStream.str()) );
rotatedContourNode->SetProperty( "isContourMarker", BoolProperty::New(true));
rotatedContourNode->SetBoolProperty( "PlanarFigureInitializedWindow", true, positionEvent->GetSender() );
rotatedContourNode->SetProperty( "includeInBoundingBox", BoolProperty::New(false));
rotatedContourNode->SetProperty( "helper object", mitk::BoolProperty::New(!m_ShowMarkerNodes));
rotatedContourNode->SetProperty( "planarfigure.drawcontrolpoints", BoolProperty::New(false));
rotatedContourNode->SetProperty( "planarfigure.drawname", BoolProperty::New(false));
rotatedContourNode->SetProperty( "planarfigure.drawoutline", BoolProperty::New(false));
rotatedContourNode->SetProperty( "planarfigure.drawshadow", BoolProperty::New(false));
if (plane)
{
if ( id == size )
{
m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
}
else
{
- mitk::NodePredicateProperty::Pointer isMarker = mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
-
- mitk::DataStorage::SetOfObjects::ConstPointer markers = m_ToolManager->GetDataStorage()->GetDerivations(workingNode,isMarker);
-
- for ( mitk::DataStorage::SetOfObjects::const_iterator iter = markers->begin();
- iter != markers->end();
- ++iter)
+ mitk::NodePredicateProperty::Pointer isMarker = mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
+
+ mitk::DataStorage::SetOfObjects::ConstPointer markers = m_ToolManager->GetDataStorage()->GetDerivations(workingNode,isMarker);
+
+ for ( mitk::DataStorage::SetOfObjects::const_iterator iter = markers->begin();
+ iter != markers->end();
+ ++iter)
+ {
+ std::string nodeName = (*iter)->GetName();
+ unsigned int t = nodeName.find_last_of(" ");
+ unsigned int markerId = atof(nodeName.substr(t+1).c_str())-1;
+ if(id == markerId)
{
- std::string nodeName = (*iter)->GetName();
- unsigned int t = nodeName.find_last_of(" ");
- unsigned int markerId = atof(nodeName.substr(t+1).c_str())-1;
- if(id == markerId)
- {
- return id;
- }
+ return id;
}
- m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
+ }
+ m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
}
}
return id;
}
void mitk::SegTool2D::InteractiveSegmentationBugMessage( const std::string& message )
{
MITK_ERROR << "********************************************************************************" << std::endl
<< " " << message << std::endl
<< "********************************************************************************" << std::endl
<< " " << std::endl
<< " If your image is rotated or the 2D views don't really contain the patient image, try to press the button next to the image selection. " << std::endl
<< " " << std::endl
<< " Please file a BUG REPORT: " << std::endl
<< " http://bugs.mitk.org" << std::endl
<< " Contain the following information:" << std::endl
<< " - What image were you working on?" << std::endl
<< " - Which region of the image?" << std::endl
<< " - Which tool did you use?" << std::endl
<< " - What did you do?" << std::endl
<< " - What happened (not)? What did you expect?" << std::endl;
}
-
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.h b/Modules/Segmentation/Interactions/mitkSegTool2D.h
index fa039ef25a..e49e148054 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.h
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.h
@@ -1,145 +1,151 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkSegTool2D_h_Included
#define mitkSegTool2D_h_Included
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkTool.h"
#include "mitkImage.h"
#include "mitkStateEvent.h"
#include "mitkPositionEvent.h"
#include "mitkPlanePositionManager.h"
#include "mitkRestorePlanePositionOperation.h"
#include "mitkInteractionConst.h"
#include <mitkDiffSliceOperation.h>
namespace mitk
{
class BaseRenderer;
/**
\brief Abstract base class for segmentation tools.
\sa Tool
\ingroup Interaction
\ingroup ToolManagerEtAl
Implements 2D segmentation specific helper methods, that might be of use to
all kind of 2D segmentation tools. At the moment these are:
- Determination of the slice where the user paints upon (DetermineAffectedImageSlice)
- Projection of a 3D contour onto a 2D plane/slice
SegTool2D tries to structure the interaction a bit. If you pass "PressMoveRelease" as the interaction type
of your derived tool, you might implement the methods OnMousePressed, OnMouseMoved, and OnMouseReleased.
Yes, your guess about when they are called is correct.
\warning Only to be instantiated by mitk::ToolManager.
$Author$
*/
class Segmentation_EXPORT SegTool2D : public Tool
{
public:
mitkClassMacro(SegTool2D, Tool);
/**
\brief Calculates for a given Image and PlaneGeometry, which slice of the image (in index corrdinates) is meant by the plane.
\return false, if no slice direction seems right (e.g. rotated planes)
\param affectedDimension The image dimension, which is constant for all points in the plane, e.g. Axial --> 2
\param affectedSlice The index of the image slice
*/
static bool DetermineAffectedImageSlice( const Image* image, const PlaneGeometry* plane, int& affectedDimension, int& affectedSlice );
void SetShowMarkerNodes(bool);
/**
* \brief Enables or disables the 3D interpolation after writing back the 2D segmentation result, and defaults to true.
*/
void SetEnable3DInterpolation(bool);
protected:
SegTool2D(); // purposely hidden
SegTool2D(const char*); // purposely hidden
virtual ~SegTool2D();
/**
* \brief Calculates how good the data, this statemachine handles, is hit by the event.
*
*/
virtual float CanHandleEvent( StateEvent const *stateEvent) const;
/**
\brief Extract the slice of an image that the user just scribbles on.
\return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position.
*/
Image::Pointer GetAffectedImageSliceAs2DImage(const PositionEvent*, const Image* image);
+ /**
+ \brief Extract the slice of an image cut by given plane.
+ \return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position.
+ */
+ Image::Pointer GetAffectedImageSliceAs2DImage(const PlaneGeometry* planeGeometry, const Image* image, unsigned int timeStep);
+
/**
\brief Extract the slice of the currently selected working image that the user just scribbles on.
\return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position,
or just no working image is selected.
*/
Image::Pointer GetAffectedWorkingSlice(const PositionEvent*);
/**
\brief Extract the slice of the currently selected reference image that the user just scribbles on.
\return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position,
or just no reference image is selected.
*/
Image::Pointer GetAffectedReferenceSlice(const PositionEvent*);
void WriteBackSegmentationResult (const PositionEvent*, Image*);
+ void WriteBackSegmentationResult (const PlaneGeometry* planeGeometry, Image*, unsigned int timeStep);
+
/**
\brief Adds a new node called Contourmarker to the datastorage which holds a mitk::PlanarFigure.
By selecting this node the slicestack will be reoriented according to the PlanarFigure's Geometry
*/
unsigned int AddContourmarker ( const PositionEvent* );
void InteractiveSegmentationBugMessage( const std::string& message );
BaseRenderer* m_LastEventSender;
unsigned int m_LastEventSlice;
private:
//The prefix of the contourmarkername. Suffix is a consecutive number
const std::string m_Contourmarkername;
bool m_ShowMarkerNodes;
bool m_3DInterpolationEnabled;
DiffSliceOperation* m_doOperation;
DiffSliceOperation* m_undoOperation;
};
} // namespace
#endif
-
-
diff --git a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
index d6e7710c43..c8752b0f4b 100644
--- a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
@@ -1,320 +1,320 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSetRegionTool.h"
#include "mitkToolManager.h"
#include "mitkOverwriteSliceImageFilter.h"
#include "ipSegmentation.h"
#include "mitkBaseRenderer.h"
#include "mitkImageDataItem.h"
#include "mitkOverwriteDirectedPlaneImageFilter.h"
mitk::SetRegionTool::SetRegionTool(int paintingPixelValue)
:FeedbackContourTool("PressMoveReleaseWithCTRLInversion"),
m_PaintingPixelValue(paintingPixelValue),
m_FillContour(false),
m_StatusFillWholeSlice(false)
{
// great magic numbers
CONNECT_ACTION( 80, OnMousePressed );
//CONNECT_ACTION( 90, OnMouseMoved );
CONNECT_ACTION( 42, OnMouseReleased );
CONNECT_ACTION( 49014, OnInvertLogic );
}
mitk::SetRegionTool::~SetRegionTool()
{
}
void mitk::SetRegionTool::Activated()
{
Superclass::Activated();
}
void mitk::SetRegionTool::Deactivated()
{
Superclass::Deactivated();
}
bool mitk::SetRegionTool::OnMousePressed (Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent) return false;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
// 1. Get the working image
Image::Pointer workingSlice = FeedbackContourTool::GetAffectedWorkingSlice( positionEvent );
if ( workingSlice.IsNull() ) return false; // can't do anything without the segmentation
// if click was outside the image, don't continue
const Geometry3D* sliceGeometry = workingSlice->GetGeometry();
itk::Index<2> projectedPointIn2D;
sliceGeometry->WorldToIndex( positionEvent->GetWorldPosition(), projectedPointIn2D );
if ( !sliceGeometry->IsIndexInside( projectedPointIn2D ) )
{
MITK_ERROR << "point apparently not inside segmentation slice" << std::endl;
return false; // can't use that as a seed point
}
// Convert to ipMITKSegmentationTYPE (because ipMITKSegmentationGetContour8N relys on that data type)
itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
CastToItkImage( workingSlice, correctPixelTypeImage );
assert (correctPixelTypeImage.IsNotNull() );
// possible bug in CastToItkImage ?
// direction maxtrix is wrong/broken/not working after CastToItkImage, leading to a failed assertion in
// mitk/Core/DataStructures/mitkSlicedGeometry3D.cpp, 479:
// virtual void mitk::SlicedGeometry3D::SetSpacing(const mitk::Vector3D&): Assertion `aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0' failed
// solution here: we overwrite it with an unity matrix
itk::Image< ipMITKSegmentationTYPE, 2 >::DirectionType imageDirection;
imageDirection.SetIdentity();
correctPixelTypeImage->SetDirection(imageDirection);
Image::Pointer temporarySlice = Image::New();
// temporarySlice = ImportItkImage( correctPixelTypeImage );
CastToMitkImage( correctPixelTypeImage, temporarySlice );
// check index positions
mitkIpPicDescriptor* originalPicSlice = mitkIpPicNew();
CastToIpPicDescriptor( temporarySlice, originalPicSlice );
int m_SeedPointMemoryOffset = projectedPointIn2D[1] * originalPicSlice->n[0] + projectedPointIn2D[0];
if ( m_SeedPointMemoryOffset >= static_cast<int>( originalPicSlice->n[0] * originalPicSlice->n[1] ) ||
m_SeedPointMemoryOffset < 0 )
{
MITK_ERROR << "Memory offset calculation if mitk::SetRegionTool has some serious flaw! Aborting.." << std::endl;
return false;
}
// 2. Determine the contour that surronds the selected "piece of the image"
// find a contour seed point
unsigned int oneContourOffset = static_cast<unsigned int>( m_SeedPointMemoryOffset ); // safe because of earlier check if m_SeedPointMemoryOffset < 0
/**
* The logic of finding a starting point for the contour is the following:
*
* - If the initial seed point is 0, we are either inside a hole or outside of every segmentation.
* We move to the right until we hit a 1, which must be part of a contour.
*
* - If the initial seed point is 1, then ...
* we now do the same (running to the right) until we hit a 1
*
* In both cases the found contour point is used to extract a contour and
* then a test is applied to find out if the initial seed point is contained
* in the contour. If this is the case, filling should be applied, otherwise
* nothing is done.
*/
unsigned int size = originalPicSlice->n[0] * originalPicSlice->n[1];
/*
unsigned int rowSize = originalPicSlice->n[0];
*/
ipMITKSegmentationTYPE* data = static_cast<ipMITKSegmentationTYPE*>(originalPicSlice->data);
if ( data[oneContourOffset] == 0 ) // initial seed 0
{
for ( ; oneContourOffset < size; ++oneContourOffset )
{
if ( data[oneContourOffset] > 0 ) break;
}
}
else if ( data[oneContourOffset] == 1 ) // initial seed 1
{
unsigned int lastValidPixel = size-1; // initialization, will be changed lateron
bool inSeg = true; // inside segmentation?
for ( ; oneContourOffset < size; ++oneContourOffset )
{
if ( ( data[oneContourOffset] == 0 ) && inSeg ) // pixel 0 and inside-flag set: this happens at the first pixel outside a filled region
{
inSeg = false;
lastValidPixel = oneContourOffset - 1; // store the last pixel position inside a filled region
break;
}
else // pixel 1, inside-flag doesn't matter: this happens while we are inside a filled region
{
inSeg = true; // first iteration lands here
}
}
oneContourOffset = lastValidPixel;
}
else
{
MITK_ERROR << "Fill/Erase was never intended to work with other than binary images." << std::endl;
m_FillContour = false;
return false;
}
if (oneContourOffset == size) // nothing found until end of slice
{
m_FillContour = false;
return false;
}
int numberOfContourPoints( 0 );
int newBufferSize( 0 );
//MITK_INFO << "getting contour from offset " << oneContourOffset << " ("<<oneContourOffset%originalPicSlice->n[0]<<","<<oneContourOffset/originalPicSlice->n[0]<<")"<<std::endl;
float* contourPoints = ipMITKSegmentationGetContour8N( originalPicSlice, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
//MITK_INFO << "contourPoints " << contourPoints << " (N="<<numberOfContourPoints<<")"<<std::endl;
assert(contourPoints == NULL || numberOfContourPoints > 0);
bool cursorInsideContour = ipMITKSegmentationIsInsideContour( contourPoints, numberOfContourPoints, projectedPointIn2D[0], projectedPointIn2D[1]);
// decide if contour should be filled or not
m_FillContour = cursorInsideContour;
if (m_FillContour)
{
// copy point from float* to mitk::Contour
Contour::Pointer contourInImageIndexCoordinates = Contour::New();
contourInImageIndexCoordinates->Initialize();
Point3D newPoint;
for (int index = 0; index < numberOfContourPoints; ++index)
{
newPoint[0] = contourPoints[ 2 * index + 0 ];
newPoint[1] = contourPoints[ 2 * index + 1];
newPoint[2] = 0;
- contourInImageIndexCoordinates->AddVertex( newPoint - 0.5 );
+ contourInImageIndexCoordinates->AddVertex(newPoint - mitk::Point3D::VectorType(0.5));
}
m_SegmentationContourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( workingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true, correct the result from ipMITKSegmentationGetContour8N
// 3. Show the contour
FeedbackContourTool::SetFeedbackContour( *m_SegmentationContourInWorldCoordinates );
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
// always generate a second contour, containing the whole image (used when CTRL is pressed)
{
// copy point from float* to mitk::Contour
Contour::Pointer contourInImageIndexCoordinates = Contour::New();
contourInImageIndexCoordinates->Initialize();
Point3D newPoint;
newPoint[0] = 0; newPoint[1] = 0; newPoint[2] = 0.0;
contourInImageIndexCoordinates->AddVertex( newPoint );
newPoint[0] = originalPicSlice->n[0]; newPoint[1] = 0; newPoint[2] = 0.0;
contourInImageIndexCoordinates->AddVertex( newPoint );
newPoint[0] = originalPicSlice->n[0]; newPoint[1] = originalPicSlice->n[1]; newPoint[2] = 0.0;
contourInImageIndexCoordinates->AddVertex( newPoint );
newPoint[0] = 0; newPoint[1] = originalPicSlice->n[1]; newPoint[2] = 0.0;
contourInImageIndexCoordinates->AddVertex( newPoint );
m_WholeImageContourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( workingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true, correct the result from ipMITKSegmentationGetContour8N
// 3. Show the contour
FeedbackContourTool::SetFeedbackContour( *m_SegmentationContourInWorldCoordinates );
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
free(contourPoints);
return true;
}
bool mitk::SetRegionTool::OnMouseReleased(Action* action, const StateEvent* stateEvent)
{
// 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's working image corresponds to that
FeedbackContourTool::SetFeedbackContourVisible(false);
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent) return false;
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
if (!m_FillContour && !m_StatusFillWholeSlice) return true;
if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
if (!workingNode) return false;
Image* image = dynamic_cast<Image*>(workingNode->GetData());
const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
if ( !image || !planeGeometry ) return false;
Image::Pointer slice = FeedbackContourTool::GetAffectedImageSliceAs2DImage( positionEvent, image );
if ( slice.IsNull() )
{
MITK_ERROR << "Unable to extract slice." << std::endl;
return false;
}
Contour* feedbackContour( FeedbackContourTool::GetFeedbackContour() );
Contour::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice( slice, feedbackContour, false, false ); // false: don't add 0.5 (done by FillContourInSlice)
// false: don't constrain the contour to the image's inside
if (projectedContour.IsNull()) return false;
FeedbackContourTool::FillContourInSlice( projectedContour, slice, m_PaintingPixelValue );
this->WriteBackSegmentationResult(positionEvent, slice);
m_WholeImageContourInWorldCoordinates = NULL;
m_SegmentationContourInWorldCoordinates = NULL;
return true;
}
/**
Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
*/
bool mitk::SetRegionTool::OnInvertLogic(Action* action, const StateEvent* stateEvent)
{
if ( FeedbackContourTool::CanHandleEvent(stateEvent) < 1.0 ) return false;
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent) return false;
if (m_StatusFillWholeSlice)
{
// use contour extracted from image data
if (m_SegmentationContourInWorldCoordinates.IsNotNull())
FeedbackContourTool::SetFeedbackContour( *m_SegmentationContourInWorldCoordinates );
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
else
{
// use some artificial contour
if (m_WholeImageContourInWorldCoordinates.IsNotNull())
FeedbackContourTool::SetFeedbackContour( *m_WholeImageContourInWorldCoordinates );
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
m_StatusFillWholeSlice = !m_StatusFillWholeSlice;
return true;
}
diff --git a/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp b/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp
index 4cf207e539..80f4ead147 100644
--- a/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp
+++ b/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp
@@ -1,277 +1,282 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContourModelGLMapper2D.h"
#include "mitkBaseRenderer.h"
#include "mitkPlaneGeometry.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkContourModel.h"
#include "mitkContourModelSubDivisionFilter.h"
#include <vtkLinearTransform.h>
#include "mitkGL.h"
mitk::ContourModelGLMapper2D::ContourModelGLMapper2D()
{
}
mitk::ContourModelGLMapper2D::~ContourModelGLMapper2D()
{
}
void mitk::ContourModelGLMapper2D::Paint(mitk::BaseRenderer * renderer)
{
+ BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
+
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible ) return;
bool updateNeccesary=true;
int timestep = renderer->GetTimeStep();
mitk::ContourModel::Pointer input = const_cast<mitk::ContourModel*>(this->GetInput());
mitk::ContourModel::Pointer renderingContour = input;
bool subdivision = false;
this->GetDataNode()->GetBoolProperty( "subdivision curve", subdivision, renderer );
if (subdivision)
{
mitk::ContourModel::Pointer subdivContour = mitk::ContourModel::New();
mitk::ContourModelSubDivisionFilter::Pointer subdivFilter = mitk::ContourModelSubDivisionFilter::New();
subdivFilter->SetInput(input);
subdivFilter->Update();
subdivContour = subdivFilter->GetOutput();
if(subdivContour->GetNumberOfVertices() == 0 )
{
subdivContour = input;
}
renderingContour = subdivContour;
}
renderingContour->UpdateOutputInformation();
- if( renderingContour->GetMTime() < this->m_LastUpdateTime )
+ if( renderingContour->GetMTime() < ls->GetLastGenerateDataTime() )
updateNeccesary = false;
if(renderingContour->GetNumberOfVertices(timestep) < 1)
updateNeccesary = false;
if (updateNeccesary)
{
// ok, das ist aus GenerateData kopiert
mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
assert(displayGeometry.IsNotNull());
//apply color and opacity read from the PropertyList
ApplyProperties(renderer);
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("contour.color", renderer));
if(colorprop)
{
//set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
glColor4f(red,green,blue,0.5);
}
mitk::ColorProperty::Pointer selectedcolor = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("points.color", renderer));
if(!selectedcolor)
{
selectedcolor = mitk::ColorProperty::New(1.0,0.0,0.1);
}
vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
// ContourModel::OutputType point;
mitk::Point3D point;
mitk::Point3D p, projected_p;
float vtkp[3];
float lineWidth = 3.0;
if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contour.width")) != NULL)
lineWidth = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("contour.width"))->GetValue();
glLineWidth(lineWidth);
bool drawit=false;
mitk::ContourModel::VertexIterator pointsIt = renderingContour->IteratorBegin(timestep);
Point2D pt2d; // projected_p in display coordinates
Point2D lastPt2d;
while ( pointsIt != renderingContour->IteratorEnd(timestep) )
{
lastPt2d = pt2d;
point = (*pointsIt)->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
Vector3D diff=p-projected_p;
- ScalarType scalardiff = diff.GetSquaredNorm();
+ ScalarType scalardiff = diff.GetNorm();
//draw lines
bool projectmode=false;
- GetDataNode()->GetVisibility(projectmode, renderer, "project");
+ GetDataNode()->GetVisibility(projectmode, renderer, "contour.project-onto-plane");
if(projectmode)
+ {
drawit=true;
- else
+ }
+ else if(scalardiff<0.25)
{
- if(diff.GetSquaredNorm()<0.5)
- drawit=true;
+ drawit=true;
}
+
if(drawit)
{
//lastPt2d is not valid in first step
if( !(pointsIt == renderingContour->IteratorBegin(timestep)) )
{
glBegin (GL_LINES);
glVertex2f(pt2d[0], pt2d[1]);
glVertex2f(lastPt2d[0], lastPt2d[1]);
glEnd();
}
//draw active points
if ((*pointsIt)->IsControlPoint)
{
float pointsize = 4;
Point2D tmp;
Vector2D horz,vert;
- horz[0]=pointsize-scalardiff*2; horz[1]=0;
- vert[0]=0; vert[1]=pointsize-scalardiff*2;
+ horz[1]=0;
+ vert[0]=0;
horz[0]=pointsize;
vert[1]=pointsize;
glColor3f(selectedcolor->GetColor().GetRed(), selectedcolor->GetColor().GetBlue(), selectedcolor->GetColor().GetGreen());
glLineWidth(1);
//a rectangle around the point with the selected color
glBegin (GL_LINE_LOOP);
tmp=pt2d-horz; glVertex2fv(&tmp[0]);
tmp=pt2d+vert; glVertex2fv(&tmp[0]);
tmp=pt2d+horz; glVertex2fv(&tmp[0]);
tmp=pt2d-vert; glVertex2fv(&tmp[0]);
- glEnd ();
+ glEnd();
glLineWidth(1);
//the actual point in the specified color to see the usual color of the point
glColor3f(colorprop->GetColor().GetRed(),colorprop->GetColor().GetGreen(),colorprop->GetColor().GetBlue());
glPointSize(1);
glBegin (GL_POINTS);
tmp=pt2d; glVertex2fv(&tmp[0]);
glEnd ();
}
}
pointsIt++;
}//end while iterate over controlpoints
//close contour if necessary
if(renderingContour->IsClosed(timestep) && drawit)
{
lastPt2d = pt2d;
point = renderingContour->GetVertexAt(0,timestep)->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
glBegin (GL_LINES);
glVertex2f(lastPt2d[0], lastPt2d[1]);
glVertex2f( pt2d[0], pt2d[1] );
glEnd();
}
//draw selected vertex if exists
if(renderingContour->GetSelectedVertex())
{
//transform selected vertex
point = renderingContour->GetSelectedVertex()->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
Vector3D diff=p-projected_p;
- ScalarType scalardiff = diff.GetSquaredNorm();
+ ScalarType scalardiff = diff.GetNorm();
//----------------------------------
//draw point if close to plane
- if(scalardiff<0.5)
+ if(scalardiff<0.25)
{
float pointsize = 3.2;
Point2D tmp;
glColor3f(0.0, 1.0, 0.0);
glLineWidth(1);
//a diamond around the point
glBegin (GL_LINE_LOOP);
//begin from upper left corner and paint clockwise
tmp[0]=pt2d[0]-pointsize; tmp[1]=pt2d[1]+pointsize; glVertex2fv(&tmp[0]);
tmp[0]=pt2d[0]+pointsize; tmp[1]=pt2d[1]+pointsize; glVertex2fv(&tmp[0]);
tmp[0]=pt2d[0]+pointsize; tmp[1]=pt2d[1]-pointsize; glVertex2fv(&tmp[0]);
tmp[0]=pt2d[0]-pointsize; tmp[1]=pt2d[1]-pointsize; glVertex2fv(&tmp[0]);
glEnd ();
}
//------------------------------------
}
}
}
const mitk::ContourModel* mitk::ContourModelGLMapper2D::GetInput(void)
{
return static_cast<const mitk::ContourModel * > ( GetDataNode()->GetData() );
}
void mitk::ContourModelGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "contour.color", ColorProperty::New(0.9, 1.0, 0.1), renderer, overwrite );
node->AddProperty( "points.color", ColorProperty::New(1.0, 0.0, 0.1), renderer, overwrite );
node->AddProperty( "contour.width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
node->AddProperty( "subdivision curve", mitk::BoolProperty::New( false ), renderer, overwrite );
+ node->AddProperty( "contour.project-onto-plane", mitk::BoolProperty::New( false ), renderer, overwrite );
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.h b/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.h
index 1dc114ab1d..1e7778f80e 100644
--- a/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.h
+++ b/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.h
@@ -1,67 +1,69 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITK_ContourModelGLMapper2D_H_
#define MITK_ContourModelGLMapper2D_H_
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkGLMapper.h"
namespace mitk {
class BaseRenderer;
class ContourModel;
/**
* @brief OpenGL-based mapper to display a mitk::Contour object in a 2D render window
*
*
* @ingroup Mapper
*/
class Segmentation_EXPORT ContourModelGLMapper2D : public GLMapper
{
public:
mitkClassMacro(ContourModelGLMapper2D, GLMapper);
itkNewMacro(Self);
/**
* reimplemented from Baseclass
*/
virtual void Paint(BaseRenderer * renderer);
/**
* return a refernce of the rendered data object
*/
const ContourModel* GetInput(void);
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
+ LocalStorageHandler<BaseLocalStorage> m_LSH;
+
protected:
ContourModelGLMapper2D();
virtual ~ContourModelGLMapper2D();
};
} // namespace mitk
#endif
diff --git a/Modules/Segmentation/Rendering/mitkContourModelMapper2D.h b/Modules/Segmentation/Rendering/mitkContourModelMapper2D.h
index c0d3f9b34f..e8e2fd5898 100644
--- a/Modules/Segmentation/Rendering/mitkContourModelMapper2D.h
+++ b/Modules/Segmentation/Rendering/mitkContourModelMapper2D.h
@@ -1,108 +1,108 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_CONTOURMODEL_MAPPER_H_
#define _MITK_CONTOURMODEL_MAPPER_H_
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkBaseRenderer.h"
#include "mitkVtkMapper.h"
#include "mitkContourModel.h"
//#include "mitkContourModelToVtkPolyDataFilter.h"
#include <vtkSmartPointer.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkProp.h>
#include <vtkPolyData.h>
#include <mitkContourModelSubDivisionFilter.h>
namespace mitk {
class Segmentation_EXPORT ContourModelMapper2D : public VtkMapper
{
public:
/** Standard class typedefs. */
mitkClassMacro( ContourModelMapper2D,VtkMapper );
/** Method for creation through the object factory. */
itkNewMacro(Self);
const mitk::ContourModel* GetInput(void);
/** \brief Checks whether this mapper needs to update itself and generate
* data. */
virtual void Update(mitk::BaseRenderer * renderer);
/*+++ methods of MITK-VTK rendering pipeline +++*/
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
/*+++ END methods of MITK-VTK rendering pipeline +++*/
class Segmentation_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
/** \brief Actor of a 2D render window. */
vtkSmartPointer<vtkActor> m_Actor;
/** \brief Mapper of a 2D render window. */
vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
//mitk::ContourModelToVtkPolyDataFilter::Pointer m_contourToPolyData;
vtkSmartPointer<vtkPolyData> m_OutlinePolyData;
/** \brief Timestamp of last update of stored data. */
itk::TimeStamp m_LastUpdateTime;
/** \brief Default constructor of the local storage. */
LocalStorage();
/** \brief Default deconstructor of the local storage. */
~LocalStorage()
{
}
};
/** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
- mitk::Mapper::LocalStorageHandler<LocalStorage> m_LSH;
+ mitk::LocalStorageHandler<LocalStorage> m_LSH;
/** \brief Get the LocalStorage corresponding to the current renderer. */
LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);
/** \brief Set the default properties for general image rendering. */
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
protected:
ContourModelMapper2D();
virtual ~ContourModelMapper2D();
void GenerateDataForRenderer( mitk::BaseRenderer *renderer );
virtual vtkSmartPointer<vtkPolyData> CreateVtkPolyDataFromContour(mitk::ContourModel* inputContour, mitk::BaseRenderer* renderer);
virtual void ApplyContourProperties(mitk::BaseRenderer* renderer);
};
}
#endif
diff --git a/Modules/Segmentation/Rendering/mitkContourModelMapper3D.cpp b/Modules/Segmentation/Rendering/mitkContourModelMapper3D.cpp
index 45075dc3da..8c2971b0dc 100644
--- a/Modules/Segmentation/Rendering/mitkContourModelMapper3D.cpp
+++ b/Modules/Segmentation/Rendering/mitkContourModelMapper3D.cpp
@@ -1,242 +1,242 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkContourModelMapper3D.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkProperty.h>
mitk::ContourModelMapper3D::ContourModelMapper3D()
{
}
mitk::ContourModelMapper3D::~ContourModelMapper3D()
{
}
const mitk::ContourModel* mitk::ContourModelMapper3D::GetInput( void )
{
//convient way to get the data from the dataNode
return static_cast< const mitk::ContourModel * >( GetDataNode()->GetData() );
}
vtkProp* mitk::ContourModelMapper3D::GetVtkProp(mitk::BaseRenderer* renderer)
{
//return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Actor;
}
void mitk::ContourModelMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
/* First convert the contourModel to vtkPolyData, then tube filter it and
* set it input for our mapper
*/
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::ContourModel* inputContour = static_cast< mitk::ContourModel* >( GetDataNode()->GetData() );
localStorage->m_OutlinePolyData = this->CreateVtkPolyDataFromContour(inputContour);
this->ApplyContourProperties(renderer);
//tube filter the polyData
localStorage->m_TubeFilter->SetInput(localStorage->m_OutlinePolyData);
float lineWidth(1.0);
if (this->GetDataNode()->GetFloatProperty( "3D contour width", lineWidth, renderer ))
{
localStorage->m_TubeFilter->SetRadius(lineWidth);
}else
{
- localStorage->m_TubeFilter->SetRadius(0.2);
+ localStorage->m_TubeFilter->SetRadius(0.5);
}
localStorage->m_TubeFilter->CappingOn();
localStorage->m_TubeFilter->SetNumberOfSides(10);
localStorage->m_TubeFilter->Update();
localStorage->m_Mapper->SetInput(localStorage->m_TubeFilter->GetOutput());
}
void mitk::ContourModelMapper3D::Update(mitk::BaseRenderer* renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
mitk::ContourModel* data = static_cast< mitk::ContourModel*>( GetDataNode()->GetData() );
if ( data == NULL )
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep( renderer );
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
// Check if time step is valid
const TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
if ( ( dataTimeGeometry == NULL )
|| ( dataTimeGeometry->GetTimeSteps() == 0 )
|| ( !dataTimeGeometry->IsValidTime( renderer->GetTimeStep() ) ) )
{
//clear the rendered polydata
localStorage->m_Mapper->SetInput(vtkSmartPointer<vtkPolyData>::New());
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
//check if something important has changed and we need to rerender
if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
|| (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2DUpdateTime()) //was the geometry modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2D()->GetMTime())
|| (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
|| (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
{
this->GenerateDataForRenderer( renderer );
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
vtkSmartPointer<vtkPolyData> mitk::ContourModelMapper3D::CreateVtkPolyDataFromContour(mitk::ContourModel* inputContour)
{
unsigned int timestep = this->GetTimestep();
//the points to draw
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
//the lines to connect the points
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
// Create a polydata to store everything in
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
//iterate over the control points
mitk::ContourModel::VertexIterator current = inputContour->IteratorBegin(timestep);
mitk::ContourModel::VertexIterator next = inputContour->IteratorBegin(timestep);
if(next != inputContour->IteratorEnd(timestep))
{
next++;
mitk::ContourModel::VertexIterator end = inputContour->IteratorEnd(timestep);
while(next != end)
{
mitk::ContourModel::VertexType* currentControlPoint = *current;
mitk::ContourModel::VertexType* nextControlPoint = *next;
if( !(currentControlPoint->Coordinates[0] == nextControlPoint->Coordinates[0] &&
currentControlPoint->Coordinates[1] == nextControlPoint->Coordinates[1] &&
currentControlPoint->Coordinates[2] == nextControlPoint->Coordinates[2]))
{
vtkIdType p1 = points->InsertNextPoint(currentControlPoint->Coordinates[0], currentControlPoint->Coordinates[1], currentControlPoint->Coordinates[2]);
vtkIdType p2 = points->InsertNextPoint(nextControlPoint->Coordinates[0], nextControlPoint->Coordinates[1], nextControlPoint->Coordinates[2]);
//add the line between both contorlPoints
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
current++;
next++;
}
if(inputContour->IsClosed(timestep))
{
// If the contour is closed add a line from the last to the first control point
mitk::ContourModel::VertexType* firstControlPoint = *(inputContour->IteratorBegin(timestep));
mitk::ContourModel::VertexType* lastControlPoint = *(--(inputContour->IteratorEnd(timestep)));
if( lastControlPoint->Coordinates[0] != firstControlPoint->Coordinates[0] &&
lastControlPoint->Coordinates[1] != firstControlPoint->Coordinates[1] &&
lastControlPoint->Coordinates[2] != firstControlPoint->Coordinates[2])
{
vtkIdType p2 = points->InsertNextPoint(lastControlPoint->Coordinates[0], lastControlPoint->Coordinates[1], lastControlPoint->Coordinates[2]);
vtkIdType p1 = points->InsertNextPoint(firstControlPoint->Coordinates[0], firstControlPoint->Coordinates[1], firstControlPoint->Coordinates[2]);
//add the line to the cellArray
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
}
// Add the points to the dataset
polyData->SetPoints(points);
// Add the lines to the dataset
polyData->SetLines(lines);
}
return polyData;
}
void mitk::ContourModelMapper3D::ApplyContourProperties(mitk::BaseRenderer* renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
("color", renderer));
if(colorprop)
{
//set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
localStorage->m_Actor->GetProperty()->SetColor(red, green, blue);
}
}
/*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
mitk::ContourModelMapper3D::LocalStorage* mitk::ContourModelMapper3D::GetLocalStorage(mitk::BaseRenderer* renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
mitk::ContourModelMapper3D::LocalStorage::LocalStorage()
{
m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_Actor = vtkSmartPointer<vtkActor>::New();
m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
m_TubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
//set the mapper for the actor
m_Actor->SetMapper(m_Mapper);
}
void mitk::ContourModelMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
- node->AddProperty( "3D contour width", mitk::FloatProperty::New( 0.2 ), renderer, overwrite );
+ node->AddProperty( "3D contour width", mitk::FloatProperty::New( 0.5 ), renderer, overwrite );
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Modules/Segmentation/Rendering/mitkContourModelMapper3D.h b/Modules/Segmentation/Rendering/mitkContourModelMapper3D.h
index a14f65f0ff..19bac4f1fd 100644
--- a/Modules/Segmentation/Rendering/mitkContourModelMapper3D.h
+++ b/Modules/Segmentation/Rendering/mitkContourModelMapper3D.h
@@ -1,110 +1,110 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_CONTOURMODEL_MAPPER_3D_H_
#define _MITK_CONTOURMODEL_MAPPER_3D_H_
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkBaseRenderer.h"
#include "mitkVtkMapper.h"
#include "mitkContourModel.h"
//#include "mitkContourModelToVtkPolyDataFilter.h"
#include <vtkSmartPointer.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkProp.h>
#include <vtkPolyData.h>
#include <vtkTubeFilter.h>
namespace mitk {
class Segmentation_EXPORT ContourModelMapper3D : public VtkMapper
{
public:
/** Standard class typedefs. */
mitkClassMacro( ContourModelMapper3D,VtkMapper );
/** Method for creation through the object factory. */
itkNewMacro(Self);
const mitk::ContourModel* GetInput(void);
/** \brief Checks whether this mapper needs to update itself and generate
* data. */
virtual void Update(mitk::BaseRenderer * renderer);
/*+++ methods of MITK-VTK rendering pipeline +++*/
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
/*+++ END methods of MITK-VTK rendering pipeline +++*/
class Segmentation_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
/** \brief Actor of a 2D render window. */
vtkSmartPointer<vtkActor> m_Actor;
/** \brief Mapper of a 2D render window. */
vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
vtkSmartPointer<vtkTubeFilter> m_TubeFilter;
//mitk::ContourModelToVtkPolyDataFilter::Pointer m_contourToPolyData;
vtkSmartPointer<vtkPolyData> m_OutlinePolyData;
/** \brief Timestamp of last update of stored data. */
itk::TimeStamp m_LastUpdateTime;
/** \brief Default constructor of the local storage. */
LocalStorage();
/** \brief Default deconstructor of the local storage. */
~LocalStorage()
{
}
};
/** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
- mitk::Mapper::LocalStorageHandler<LocalStorage> m_LSH;
+ mitk::LocalStorageHandler<LocalStorage> m_LSH;
/** \brief Get the LocalStorage corresponding to the current renderer. */
LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);
/** \brief Set the default properties for general image rendering. */
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
protected:
ContourModelMapper3D();
virtual ~ContourModelMapper3D();
void GenerateDataForRenderer( mitk::BaseRenderer *renderer );
virtual vtkSmartPointer<vtkPolyData> CreateVtkPolyDataFromContour(mitk::ContourModel* inputContour);
virtual void ApplyContourProperties(mitk::BaseRenderer* renderer);
};
}
#endif
diff --git a/Modules/Segmentation/Testing/CMakeLists.txt b/Modules/Segmentation/Testing/CMakeLists.txt
index 5ce56f7863..263e573340 100644
--- a/Modules/Segmentation/Testing/CMakeLists.txt
+++ b/Modules/Segmentation/Testing/CMakeLists.txt
@@ -1,2 +1,2 @@
MITK_CREATE_MODULE_TESTS()
-mitkAddCustomModuleTest(mitkSegmentationInterpolationTest mitkSegmentationInterpolationTest ${MITK_DATA_DIR}/interpolation_test_manual.nrrd ${MITK_DATA_DIR}/interpolation_test_result.nrrd)
+#mitkAddCustomModuleTest(mitkSegmentationInterpolationTest mitkSegmentationInterpolationTest ${MITK_DATA_DIR}/interpolation_test_manual.nrrd ${MITK_DATA_DIR}/interpolation_test_result.nrrd)
diff --git a/Modules/Segmentation/Testing/files.cmake b/Modules/Segmentation/Testing/files.cmake
index 4442509a79..3662b373c9 100644
--- a/Modules/Segmentation/Testing/files.cmake
+++ b/Modules/Segmentation/Testing/files.cmake
@@ -1,26 +1,26 @@
set(MODULE_TESTS
mitkContourMapper2DTest.cpp
mitkContourTest.cpp
mitkDataNodeSegmentationTest.cpp
- mitkSegmentationInterpolationTest.cpp
+# mitkSegmentationInterpolationTest.cpp
mitkOverwriteSliceFilterTest.cpp
# mitkOverwriteSliceFilterObliquePlaneTest.cpp
mitkContourModelTest.cpp
mitkContourModelIOTest.cpp
)
set(MODULE_IMAGE_TESTS
mitkManualSegmentationToSurfaceFilterTest.cpp
mitkOverwriteSliceImageFilterTest.cpp
)
set(MODULE_CUSTOM_TESTS
)
set(MODULE_TESTIMAGES
US4DCyl.nrrd
Pic3D.nrrd
Pic2DplusT.nrrd
BallBinary30x30x30.nrrd
Png2D-bw.png
binary.stl
ball.stl
)
diff --git a/Modules/Segmentation/files.cmake b/Modules/Segmentation/files.cmake
index 5d11450bea..47bd8f2216 100644
--- a/Modules/Segmentation/files.cmake
+++ b/Modules/Segmentation/files.cmake
@@ -1,70 +1,75 @@
set(CPP_FILES
Algorithms/mitkCalculateSegmentationVolume.cpp
Algorithms/mitkComputeContourSetNormalsFilter.cpp
Algorithms/mitkContourSetToPointSetFilter.cpp
Algorithms/mitkContourUtils.cpp
Algorithms/mitkCorrectorAlgorithm.cpp
Algorithms/mitkCreateDistanceImageFromSurfaceFilter.cpp
Algorithms/mitkDiffImageApplier.cpp
Algorithms/mitkImageToContourFilter.cpp
Algorithms/mitkManualSegmentationToSurfaceFilter.cpp
Algorithms/mitkOverwriteDirectedPlaneImageFilter.cpp
Algorithms/mitkOverwriteSliceImageFilter.cpp
Algorithms/mitkReduceContourSetFilter.cpp
Algorithms/mitkSegmentationObjectFactory.cpp
Algorithms/mitkSegmentationSink.cpp
Algorithms/mitkShapeBasedInterpolationAlgorithm.cpp
Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
Algorithms/mitkShowSegmentationAsSurface.cpp
Algorithms/mitkVtkImageOverwrite.cpp
Algorithms/mitkDiffSliceOperation.cpp
Algorithms/mitkDiffSliceOperationApplier.cpp
Algorithms/mitkContourModelSource.cpp
Algorithms/mitkContourModelToPointSetFilter.cpp
Algorithms/mitkContourModelToSurfaceFilter.cpp
Algorithms/mitkContourModelSubDivisionFilter.cpp
+Algorithms/mitkImageToContourModelFilter.cpp
+Algorithms/mitkImageToLiveWireContourFilter.cpp
+Algorithms/mitkImageLiveWireContourModelFilter.cpp
Controllers/mitkSegmentationInterpolationController.cpp
Controllers/mitkSurfaceInterpolationController.cpp
# DataManagement/mitkApplyDiffImageOperation.cpp
DataManagement/mitkContour.cpp
DataManagement/mitkContourSet.cpp
DataManagement/mitkExtrudedContour.cpp
DataManagement/mitkContourModel.cpp
DataManagement/mitkContourElement.cpp
Interactions/mitkAddContourTool.cpp
Interactions/mitkAutoCropTool.cpp
Interactions/mitkAutoSegmentationTool.cpp
Interactions/mitkBinaryThresholdTool.cpp
Interactions/mitkBinaryThresholdULTool.cpp
Interactions/mitkCalculateGrayValueStatisticsTool.cpp
Interactions/mitkCalculateVolumetryTool.cpp
Interactions/mitkContourInteractor.cpp
Interactions/mitkContourTool.cpp
Interactions/mitkCorrectorTool2D.cpp
Interactions/mitkCreateSurfaceTool.cpp
Interactions/mitkDrawPaintbrushTool.cpp
Interactions/mitkErasePaintbrushTool.cpp
Interactions/mitkEraseRegionTool.cpp
Interactions/mitkExtrudedContourInteractor.cpp
Interactions/mitkFeedbackContourTool.cpp
Interactions/mitkFillRegionTool.cpp
Interactions/mitkPaintbrushTool.cpp
Interactions/mitkRegionGrow3DTool.cpp
Interactions/mitkRegionGrowingTool.cpp
Interactions/mitkSegmentationsProcessingTool.cpp
Interactions/mitkSetRegionTool.cpp
Interactions/mitkSegTool2D.cpp
Interactions/mitkSubtractContourTool.cpp
Interactions/mitkContourModelInteractor.cpp
+Interactions/mitkContourModelLiveWireInteractor.cpp
+Interactions/mitkLiveWireTool2D.cpp
IO/mitkContourModelIOFactory.cpp
IO/mitkContourModelReader.cpp
IO/mitkContourModelWriter.cpp
IO/mitkContourModelWriterFactory.cpp
Rendering/mitkContourMapper2D.cpp
Rendering/mitkContourSetMapper2D.cpp
Rendering/mitkContourSetVtkMapper3D.cpp
Rendering/mitkContourVtkMapper3D.cpp
Rendering/mitkContourModelMapper2D.cpp
Rendering/mitkContourModelMapper3D.cpp
Rendering/mitkContourModelGLMapper2D.cpp
)
diff --git a/Modules/Simulation/CMakeLists.txt b/Modules/Simulation/CMakeLists.txt
index d6ebacd0fb..22e96f0160 100644
--- a/Modules/Simulation/CMakeLists.txt
+++ b/Modules/Simulation/CMakeLists.txt
@@ -1,10 +1,12 @@
if(MITK_USE_SOFA)
MITK_CREATE_MODULE(Simulation
PACKAGE_DEPENDS SOFA
)
if(MSVC)
set(module_compile_flags "${module_compile_flags} /wd4250 /wd4251 /wd4275")
set_target_properties(${MODULE_PROVIDES} PROPERTIES COMPILE_FLAGS "${module_compile_flags}")
endif()
+
+ add_subdirectory(Testing)
endif()
diff --git a/Modules/Simulation/Documentation/doxygen/Manual.dox b/Modules/Simulation/Documentation/doxygen/Manual.dox
index 283292abf0..06b217c3af 100644
--- a/Modules/Simulation/Documentation/doxygen/Manual.dox
+++ b/Modules/Simulation/Documentation/doxygen/Manual.dox
@@ -1,103 +1,126 @@
/**
\page SimulationManualPage The MITK Simulation Module
-The MITK Simulation Module provides medical simulation capabilities by integrating the Simulation Open Framework Architecture (SOFA) into MITK.
+The MITK simulation module provides medical simulation capabilities by integrating the Simulation Open Framework Architecture (SOFA) into MITK.
\section SimulationManualBuildInstructions Build Instructions
-Activate the %CMake option <tt>MITK_USE_SOFA</tt> to automatically download and build SOFA as well as the MITK Simulation Module during the superbuild process.
-Afterwards you can activate simulation-enabled plugins during the MITK build configuration, e.g. <tt>MITK_BUILD_org.mitk.gui.qt.simulation</tt>.
+Activate the %CMake option <tt>MITK_USE_SOFA</tt> when configuring the MITK superbuild.
+SOFA is automatically downloaded and built during the superbuild (as well as the MITK simulation module, which depends on SOFA).
+Simulation-related plugins can be activated when configuring the MITK build, i.e. activate <tt>MITK_BUILD_org.mitk.gui.qt.simulation</tt>, which will automatically activate <tt>MITK_BUILD_org.mitk.simulation</tt> in turn.
-\section SimulationManualIntroduction Introduction
+\subsection SimulationManualSOFAPluginBuildInstructions SOFA Plugins
+
+SOFA plugins are built automatically during the MITK superbuild if they are located in the right directory and contain a %CMake script to build them.
+
+SOFA build configuration is originally qmake-based. However, for seamless MITK superbuild integration a %CMake-based build script is used instead.
+After you activated the %CMake option <tt>MITK_USE_SOFA</tt>, SOFA complete with the %CMake-based build script is downloaded during the superbuild.
+Following the MITK superbuild convention for external projects, it is located in the <tt>SOFA-src</tt> directory right beneath the top-level MITK build directory.
+Following the SOFA convention for plugins, they should be located in <tt>applications/plugins</tt>.
+Hence, create an <tt>applications/plugins</tt> directory in <tt>SOFA-src</tt> and place your plugin here, i.e. <tt>SOFA-src/applications/plugins/myplugin</tt>.
+
+The second and last step is to create a <tt>CMakeLists.txt</tt> file inside your plugin directory.
+Use the %CMake function <tt>add_sofa_library()</tt> to easily set up your plugin build script.
+Below is an example of a <tt>CMakeLists.txt</tt> file for a fictional plugin named "myplugin":
+
+\code
+set(MYPLUGIN_SOURES
+ Topologies/MyTopology.cpp
+ MyInteraction.cpp
+)
-It is strongly recommended that you are at least familiar with the basic concepts of SOFA before you proceed reading.
+set(MYPLUGIN_LIBS
+ sofa_base_topology
+ sofa_user_interaction
+)
-SOFA is intended to be used as a framework by itself. It is split into the following three parts:
+add_sofa_library(myplugin NO_PREFIX)
+\endcode
+
+The naming of <tt>MYPLUGIN_SOURCES</tt> and <tt>MYPLUGIN_LIBS</tt> is crucial for <tt>add_sofa_library(myplugin)</tt> to find the sources and libraries.
+For more information see <tt>SOFA-src/CMake/AddSOFALibrary.cmake</tt>.
+
+Once your plugin is placed in the right directory and provides a <tt>CMakeLists.txt</tt> file it is built during the MITK superbuild.
+Binaries of your plugin are placed in <tt>SOFA-build/bin</tt>.
+
+SOFA plugins can be loaded at runtime via the simulation preferences by clicking the <tt>Add...</tt> button.
+
+\image html SimulationPreferences.png The simulation preferences dialog box.
+
+\section SimulationManualIntroduction Introduction
+
+SOFA is split into the following three parts:
<ul>
<li> Framework
<li> Modules
<li> Applications
</ul>
-While the former two parts make up the actual framework, the latter part is built on top of them and provides end user applications, e.g. runSofa.
+While the former two parts make up the actual framework functionality, the applications part provides end user applications, e.g. <tt>runSofa</tt>.
+The MITK simulation module and plugins replace the applications part of SOFA and make use of the framework and modules parts in terms of a toolkit.
-To be able to integrate SOFA into MITK, the MITK Simulation Module conceptionally replaces the application layer and solely uses the framework and module layer as a toolkit.
+\image html SOFA_MITK.png Conceptional layers and dependencies of SOFA and the MITK simulation module.
-\section SimulationManualHowToUpdate How to update SOFA
+\remark While the framework and modules parts of SOFA are LGPL-licensed, the applications part, which is not used by MITK, is GPL-licensed.
-SOFA is deployed to the MITK superbuild in three ZIP archives, namely
+\section SimulationManualHowToUpdate How to supply SOFA to the MITK Superbuild
-<ul>
- <li> sofa-rev[rev].zip
- <li> sofa-rev[rev]-cmake.zip
- <li> sofa-rev[rev]-gl.zip
-</ul>
+\remark If you are not a member of the MITK staff you can safely skip this section.
+
+SOFA build configuration is originally qmake-based. However, for seamless MITK superbuild integration a %CMake-based build script is used instead.
+To maintain this script and to ensure that it matches the right revision of SOFA we set up a Git repository at <tt>%git\@mitk.org:MITK-SOFA</tt>.
-where [rev] is a substitute for the SVN revision of SOFA, e.g. 8935.
-The follwing process was proven suitable to create these ZIP archives out of a certain SOFA revision.
-Since it is a very time-consuming task you should only update SOFA if it is really necessary!
-
-<ol>
- <li> Follow the instructions of the SOFA framework download website to check out a recent revsion of the trunk form their SVN server into a newly created directory named SOFA-svn (check the dashboard first to see if that revision is likely to compile properly on all supported platforms).
- <li> To get rid of all SVN files in the source directory use SVN export to export the source code to a separate directory named SOFA-rev[rev].
- <li> Delete all irrelevant directories and files in SOFA-rev[rev]. Relevant directories and files are:
- <ul>
- <li> extlibs/eigen-3.1.1, extlibs/miniBoost, extlibs/miniFlowVR, extlibs/newmat, extlibs/tinyxml
- <li> framework
- <li> modules/sofa/component, modules/sofa/simulation, modules/copyright.txt, modules/LGPL-license.txt
- <li> Authors.txt, LICENCE.txt, readme.txt
- </ul>
- <li> Create sofa-rev[rev].zip out of the SOFA-rev[rev] directory.
- <li> Download the old sofa-rev[old_rev].zip and extract it to SOFA-rev[old_rev].
- <li> Download the old sofa-rev[old_rev]-cmake.zip and extract it to SOFA-CMake.
- <li> Download the old sofa-rev[old_rev]-gl.zip and extract it to SOFA-GL.
- <li> Download a directory diff tool like DirDiff for Windows and compare sofa-rev[old_rev] with sofa_rev[rev] to get an overview of what has changed. Note that you have to look at the .pro files to see which files were added or removed to the projects. Just looking at the files in a project directory is not sufficient!
- <li> Adapt the CMake files in SOFA-CMake to the changes.
- <li> Copy SOFA-rev[rev] to SOFA-rev[rev]-Test and also copy SOFA-CMake and SOFA-GL into that directory.
- <li> Manually apply the patch for SOFA you find in the MITK source tree (MITK/CMakeExternals/PatchSOFA-rev[old_rev].cmake.
- <li> Try to build SOFA-rev[rev]-Test. Make changes to SOFA-CMake and SOFA-GL files (don't forget to reapply the patch or even change the patch if necessary) until you can build everything successfully.
- <li> Create sofa-rev[rev]-cmake.zip out of SOFA-CMake and sofa-rev[rev]-gl.zip out of SOFA-GL.
- <li> Upload all three ZIP archives to a easily accessible location like your public DropBox folder.
- <li> Update MITK/CMakeExternals/SOFA.cmake to point to the temporary locations and don't forget to update the MD5 hashes and to use an up-to-date patch file, i.e. PatchSOFA-rev[rev].cmake.
- <li> Try to build MITK. Repeat any of the above steps until you are able to compile and use MITK with SOFA on every supprted plattform.
- <li> Upload the new SOFA archives to mitk.org and adapt the URLs in MITK/CMakeExternals/SOFA.cmake.
-</ol>
+When the repository was updated a package named <tt>SOFA_<hash>.tar.gz</tt> must be created and uploaded to <tt>%http://mitk.org/download/thirdparty/</tt>.
+<hash> consists of the last eight digits of the SHA1 ID of the commit.
+To use the new package for the MITK superbuild, the URL and MD5 of the package must be updated in <tt>CMakeExternals/SOFA.cmake</tt>.
+
+If you need to patch SOFA sources you must append your patch to <tt>CMakeExternals/PatchSOFA-rev<revision>.cmake</tt>.
+Make sure that you keep the filename up to date regarding the revision of SOFA and update the filename for the patch command in <tt>CMakeExternals/SOFA.cmake</tt> too.
+
+The commit messages of the MITK-SOFA repository contain valuable information on which parts of SOFA must be stripped from a newly checked out revision.
+Please continue writing detailed commit messages when updating the repository.
+
+Updating the repository to a new SOFA revision can be a time-consuming task.
+The best way to keep track of changes and additions to the SOFA sources is to use a free folder comparing tool (e.g. dirdiff).
+Especially look at <tt>.pro</tt> files which describe the individual SOFA projects.
\section SimulationManualDrawing Drawing
+It is recommended that you are at least familiar with the basic concepts of SOFA, e.g. scene graphs and visitors, before you proceed reading.
+
Drawing is done by SOFA at three different places:
<ul>
<li> <tt>sofa::component::visualmodel</tt> classes
<li> <tt>sofa::core::visual::DrawTool</tt> class
<li> <tt>sofa::helper::gl</tt> classes and functions
</ul>
These cases are handled by the MITK Simulation Module as follows.
\subsection SimulationManualDrawingVisualModel sofa::component::visualmodel
One of the most important drawing classes is <tt>OglModel</tt> since it makes up most of the visual part of a simulation scene.
It inherits from <tt>VisualModel</tt> (which encapsulates all API-independent drawing code) and contains OpenGL-related code to draw the visual model.
To hook into the drawing of visual models, the MITK Simulation Module creates an alias in the SOFA object system so that every <tt>OglModel</tt> and <tt>VisualModel</tt> node found in a scene file is used to instantiate a MITK <b>SimulationModel</b> class instead.
This class creates VTK actors that contain the visual model rather than drawing it directly.
The simulation mapper, which is responsible for drawing a simulation scene, utilizes the visitor mechanism of SOFA to collect all VTK actors of the scene tree and finally draws them.
\subsection SimulationManualDrawingDrawToolGL sofa::core::visual::DrawTool
The abstract class <tt>DrawTool</tt> and its default OpenGL implementation <tt>DrawToolGL</tt> provide the interface to draw basic primitives, e.g. points, lines, spheres, arrows, and so forth.
It is usually set by a call to <tt> sofa::core::visual::VisualParams::defaultInstance()->drawTool()</tt> at application initialization.
The MITK Simulation Module provide its own VTK-based implementation of <tt>DrawTool</tt>, namely <b>SimulationDrawTool</b>.
This class creates VTK actors instead of drawing anything directly.
There is one <b>SimulationDrawTool</b> per simulation scene and the simulation mapper draws all current VTK actors according to which simulation scene is drawn.
\subsection SimulationManualDrawingGL sofa::helper::gl
Classes and functions in this namespace are problematic since they don't support the SOFA object system and therefore cannot be easily replaced by own implementations.
Currently they are not handled by MITK at all and an OpenGL stub is injected into SOFA so that all draw related methods and functions in this namespace do practically nothing.
This stub is automatically downloaded during the MITK superbuild process (sofa-rev[rev]-gl.zip).
However, a patch is additionally applied by the superbuild script to SOFA which alters a few header files to include the stub header files instead of the original OpenGL/GLUT/GLEW ones.
*/
\ No newline at end of file
diff --git a/Modules/Simulation/Documentation/doxygen/SOFA_MITK.png b/Modules/Simulation/Documentation/doxygen/SOFA_MITK.png
new file mode 100644
index 0000000000..e2b4acf44e
Binary files /dev/null and b/Modules/Simulation/Documentation/doxygen/SOFA_MITK.png differ
diff --git a/Modules/Simulation/Documentation/doxygen/SimulationPreferences.png b/Modules/Simulation/Documentation/doxygen/SimulationPreferences.png
new file mode 100644
index 0000000000..ee82e3ef41
Binary files /dev/null and b/Modules/Simulation/Documentation/doxygen/SimulationPreferences.png differ
diff --git a/Modules/Simulation/Testing/CMakeLists.txt b/Modules/Simulation/Testing/CMakeLists.txt
new file mode 100644
index 0000000000..336c2b4830
--- /dev/null
+++ b/Modules/Simulation/Testing/CMakeLists.txt
@@ -0,0 +1,7 @@
+if(MITK_USE_SOFA)
+ MITK_CREATE_MODULE_TESTS()
+
+ if(WIN32 OR APPLE OR MITK_ENABLE_GUI_TESTING)
+ mitkAddCustomModuleTest(mitkSimulationTest mitkSimulationTest ${MITK_DATA_DIR}/Simulation/liver.scn 0.02 4384)
+ endif()
+endif()
diff --git a/Modules/Simulation/Testing/files.cmake b/Modules/Simulation/Testing/files.cmake
new file mode 100644
index 0000000000..68a6fdc6b2
--- /dev/null
+++ b/Modules/Simulation/Testing/files.cmake
@@ -0,0 +1,7 @@
+set(MODULE_TESTS
+ mitkSimulationTemplateTest.cpp
+)
+
+set(MODULE_CUSTOM_TESTS
+ mitkSimulationTest.cpp
+)
diff --git a/Modules/Simulation/Testing/mitkSimulationDrawToolTest.cpp b/Modules/Simulation/Testing/mitkSimulationDrawToolTest.cpp
new file mode 100644
index 0000000000..93fd18e5f5
--- /dev/null
+++ b/Modules/Simulation/Testing/mitkSimulationDrawToolTest.cpp
@@ -0,0 +1,80 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkNodePredicateDataType.h>
+#include <mitkRenderingTestHelper.h>
+#include <mitkSimulation.h>
+#include <mitkSimulationObjectFactory.h>
+#include <mitkTestingMacros.h>
+#include <sofa/simulation/common/UpdateContextVisitor.h>
+
+int mitkSimulationDrawToolTest(int argc, char* argv[])
+{
+ MITK_TEST_BEGIN("mitkSimulationDrawToolTest")
+
+ MITK_TEST_CONDITION_REQUIRED(argc == 4, "Check if command line has correct number of arguments.")
+
+ MITK_TEST_OUTPUT(<< "Register SimulationObjectFactory.")
+ mitk::RegisterSimulationObjectFactory();
+
+ MITK_TEST_OUTPUT(<< "Create RenderingTestHelper.")
+ mitk::RenderingTestHelper renderingTestHelper(1024, 768, argc, argv);
+ renderingTestHelper.SetMapperIDToRender3D();
+
+ mitk::DataNode* simulationNode = renderingTestHelper.GetDataStorage()->GetNode(mitk::NodePredicateDataType::New("Simulation"));
+ MITK_TEST_CONDITION_REQUIRED(simulationNode != NULL, "Check if simulation scene was loaded correctly.");
+
+ MITK_TEST_OUTPUT(<< "Initialize simulation.")
+ mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(simulationNode->GetData());
+ simulation->SetAsActiveSimulation();
+ simulation->GetRootNode()->execute<sofa::simulation::UpdateContextVisitor>(sofa::core::ExecParams::defaultInstance());
+
+ MITK_TEST_OUTPUT(<< "Set camera.")
+ renderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Frontal);
+ renderingTestHelper.GetVtkRenderer()->ResetCamera();
+
+ simulationNode->SetBoolProperty("Simulation.Visual.Visual Models", false);
+ simulationNode->SetBoolProperty("Simulation.Behavior.Behavior Models", true);
+
+ // renderingTestHelper.SaveReferenceScreenShot(".../CMakeExternals/Source/MITK-Data/Simulation/drawTool1024x768REF.png");
+ MITK_TEST_CONDITION(renderingTestHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "Compare behavior models with reference image.")
+
+ simulationNode->SetBoolProperty("Simulation.Behavior.Behavior Models", false);
+ simulationNode->SetBoolProperty("Simulation.Behavior.Force Fields", true);
+
+ // renderingTestHelper.SaveReferenceScreenShot(".../CMakeExternals/Source/MITK-Data/Simulation/drawTool1024x768REF_1.png");
+ MITK_TEST_CONDITION(renderingTestHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "Compare force fields with reference image.")
+
+ simulationNode->SetBoolProperty("Simulation.Behavior.Force Fields", false);
+ simulationNode->SetBoolProperty("Simulation.Collision.Collision Models", true);
+
+ // renderingTestHelper.SaveReferenceScreenShot(".../CMakeExternals/Source/MITK-Data/Simulation/drawTool1024x768REF_2.png");
+ MITK_TEST_CONDITION(renderingTestHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "Compare collision models with reference image.")
+
+ simulationNode->SetBoolProperty("Simulation.Options.Wire Frame", true);
+
+ // renderingTestHelper.SaveReferenceScreenShot(".../CMakeExternals/Source/MITK-Data/Simulation/drawTool1024x768REF_3.png");
+ MITK_TEST_CONDITION(renderingTestHelper.CompareRenderWindowAgainstReference(argc, argv, 336.0) == true, "Compare collision models (wire frame) with reference image.")
+
+ simulationNode->SetBoolProperty("Simulation.Collision.Collision Models", false);
+ simulationNode->SetBoolProperty("Simulation.Mapping.Visual Mappings", true);
+ simulationNode->SetBoolProperty("Simulation.Options.Wire Frame", false);
+
+ // renderingTestHelper.SaveReferenceScreenShot(".../CMakeExternals/Source/MITK-Data/Simulation/drawTool1024x768REF_4.png");
+ MITK_TEST_CONDITION(renderingTestHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "Compare visual mappings with reference image.")
+
+ MITK_TEST_END()
+}
diff --git a/Modules/Simulation/Testing/mitkSimulationMapper3DTest.cpp b/Modules/Simulation/Testing/mitkSimulationMapper3DTest.cpp
new file mode 100644
index 0000000000..ff48ee627e
--- /dev/null
+++ b/Modules/Simulation/Testing/mitkSimulationMapper3DTest.cpp
@@ -0,0 +1,64 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkNodePredicateDataType.h>
+#include <mitkRenderingTestHelper.h>
+#include <mitkSimulation.h>
+#include <mitkSimulationObjectFactory.h>
+#include <mitkTestingMacros.h>
+#include <sofa/simulation/common/UpdateContextVisitor.h>
+
+int mitkSimulationMapper3DTest(int argc, char* argv[])
+{
+ MITK_TEST_BEGIN("mitkSimulationMapper3DTest")
+
+ MITK_TEST_CONDITION_REQUIRED(argc == 4, "Check if command line has correct number of arguments.")
+
+ MITK_TEST_OUTPUT(<< "Register SimulationObjectFactory.")
+ mitk::RegisterSimulationObjectFactory();
+
+ MITK_TEST_OUTPUT(<< "Create RenderingTestHelper.")
+ mitk::RenderingTestHelper renderingTestHelper(1024, 768, argc, argv);
+ renderingTestHelper.SetMapperIDToRender3D();
+
+ mitk::DataNode* simulationNode = renderingTestHelper.GetDataStorage()->GetNode(mitk::NodePredicateDataType::New("Simulation"));
+ MITK_TEST_CONDITION_REQUIRED(simulationNode != NULL, "Check if simulation scene was loaded correctly.");
+
+ MITK_TEST_OUTPUT(<< "Initialize simulation.")
+ mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(simulationNode->GetData());
+ simulation->SetAsActiveSimulation();
+ simulation->GetRootNode()->execute<sofa::simulation::UpdateContextVisitor>(sofa::core::ExecParams::defaultInstance());
+
+ MITK_TEST_OUTPUT(<< "Set camera.")
+ renderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Frontal);
+ renderingTestHelper.GetVtkRenderer()->ResetCamera();
+
+ // renderingTestHelper.SaveReferenceScreenShot(".../CMakeExternals/Source/MITK-Data/Simulation/mapper1024x768REF.png");
+ MITK_TEST_CONDITION(renderingTestHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "Compare visual models with reference image.")
+
+ simulationNode->SetBoolProperty("Simulation.Options.Normals", true);
+
+ // renderingTestHelper.SaveReferenceScreenShot(".../CMakeExternals/Source/MITK-Data/Simulation/mapper1024x768REF_1.png");
+ MITK_TEST_CONDITION(renderingTestHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "Compare visual model (normals) with reference image.")
+
+ simulationNode->SetBoolProperty("Simulation.Options.Normals", false);
+ simulationNode->SetBoolProperty("Simulation.Options.Wire Frame", true);
+
+ // renderingTestHelper.SaveReferenceScreenShot(".../CMakeExternals/Source/MITK-Data/Simulation/mapper1024x768REF_2.png");
+ MITK_TEST_CONDITION(renderingTestHelper.CompareRenderWindowAgainstReference(argc, argv, 531.0) == true, "Compare visual model (wire frame) with reference image.")
+
+ MITK_TEST_END()
+}
diff --git a/Modules/Simulation/Testing/mitkSimulationTemplateTest.cpp b/Modules/Simulation/Testing/mitkSimulationTemplateTest.cpp
new file mode 100644
index 0000000000..608ad1b712
--- /dev/null
+++ b/Modules/Simulation/Testing/mitkSimulationTemplateTest.cpp
@@ -0,0 +1,315 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkSimulationObjectFactory.h>
+#include <mitkSimulationTemplate.h>
+#include <mitkTestingMacros.h>
+
+#define _MITK_TEST_FOR_EXCEPTION(STATEMENT, EXCEPTION, MESSAGE) \
+ MITK_TEST_OUTPUT_NO_ENDL(<< MESSAGE) \
+ try \
+ { \
+ STATEMENT; \
+ MITK_TEST_OUTPUT(<< " [FAILED]") \
+ mitk::TestManager::GetInstance()->TestFailed(); \
+ } \
+ catch (const EXCEPTION& e) \
+ { \
+ MITK_TEST_OUTPUT(<< "\n " << e.GetDescription() << " [PASSED]") \
+ mitk::TestManager::GetInstance()->TestPassed(); \
+ }
+
+static mitk::DataNode::Pointer CreateDataNode(mitk::SimulationTemplate::Pointer simulationTemplate, bool setProperties = false)
+{
+ if (simulationTemplate.IsNull())
+ mitkThrow() << "Invalid argument (null pointer!)";
+
+ mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
+ dataNode->SetData(simulationTemplate);
+
+ if (setProperties)
+ simulationTemplate->SetProperties(dataNode);
+
+ return dataNode;
+}
+
+static void Parse_InputIsEmpty_ReturnsTrue()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ MITK_TEST_CONDITION(simulationTemplate->Parse(""), "Parse_InputIsEmpty_ReturnsTrue")
+}
+
+static void Parse_AlreadyInitialized_ReturnsFalse()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("");
+ MITK_TEST_CONDITION(!simulationTemplate->Parse(""), "Parse_AlreadyInitialized_ReturnsFalse")
+}
+
+static void Parse_EOFBeforeClosingBrace_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{id='A' default='1'"), mitk::Exception, "Parse_EOFBeforeClosingBrace_ThrowsException")
+}
+
+static void Parse_OpeningBraceBeforeClosingBrace_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{id='A' default='1' {id='B' default='2'}}"), mitk::Exception, "Parse_OpeningBraceBeforeClosingBrace_ThrowsException")
+}
+
+static void Parse_TooShortToBeReference_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{}"), mitk::Exception, "Parse_TooShortToBeReference_ThrowsException")
+}
+
+static void Parse_NumberOfSingleQuotationMarksIsOdd_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{'Flinders's cat'}"), mitk::Exception, "Parse_NumberOfSingleQuotationMarksIsOdd_ThrowsException")
+}
+
+static void Parse_ReferenceDoesNotEndCorrectly_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{'Flinders\\'s cat}"), mitk::Exception, "Parse_ReferenceDoesNotEndCorrectly_ThrowsException")
+}
+
+static void Parse_ReferenceIsEmpty_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{''}"), mitk::Exception, "Parse_ReferenceIsEmpty_ThrowsException")
+}
+
+static void Parse_TooShortToBeTemplate_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{id=}"), mitk::Exception, "Parse_TooShortToBeTemplate_ThrowsException")
+}
+
+static void Parse_IdIsEmpty_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{id=''}"), mitk::Exception, "Parse_IdIsEmpty_ThrowsException")
+}
+
+static void Parse_UnknownType_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{id='Trim' type='Cat'}"), mitk::Exception, "Parse_UnknownType_ThrowsException")
+}
+
+static void Parse_ValueIsAmbiguous_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{id='Matthew' id='Flinders'}"), mitk::Exception, "Parse_ValueIsAmbiguous_ThrowsException")
+}
+
+static void Parse_IdNotFound_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{type='int' value='42'}"), mitk::Exception, "Parse_IdNotFound_ThrowsException")
+}
+
+static void Parse_NoAssignmentToValue_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{id default=''}"), mitk::Exception, "Parse_NoAssignmentToValue_ThrowsException")
+}
+
+static void Parse_ValueIsNotEnclosedWithSingleQuotationMarks_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{id=Flinders\\'s Cat}"), mitk::Exception, "Parse_ValueIsNotEnclosedWithSingleQuotationMarks_ThrowsException")
+}
+
+static void Parse_TypeMismatch_ThrowsException()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ _MITK_TEST_FOR_EXCEPTION(simulationTemplate->Parse("{id='Answer' type='int' default='forty-two'}"), mitk::Exception, "Parse_TypeMismatch_ThrowsException")
+}
+
+static void Parse_ValueContainsEscapedSingleQuotationMark_IsUnescapedAfterParsing()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Flinders\\'s Cat' default='Trim'}");
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate, true);
+ std::string value;
+ dataNode->GetStringProperty("Flinders's Cat", value);
+ MITK_TEST_CONDITION(value == "Trim", "Parse_ValueContainsEscapedSingleQuotationMark_IsUnescapedAfterParsing")
+}
+
+static void Parse_Float_ParsedAsFloatProperty()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Pi' type='float' default='3.14'}");
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate, true);
+ float value;
+ MITK_TEST_CONDITION(dataNode->GetFloatProperty("Pi", value) && mitk::Equal(value, 3.14f), "Parse_Float_ParsedAsFloatProperty")
+}
+
+static void Parse_Int_ParsedAsIntProperty()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Answer' type='int' default='42'}");
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate, true);
+ int value;
+ MITK_TEST_CONDITION(dataNode->GetIntProperty("Answer", value) && value == 42, "Parse_Int_ParsedAsIntProperty")
+}
+
+static void Parse_String_ParsedAsStringProperty()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Cat' type='string' default='Trim'}");
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate, true);
+ std::string value;
+ MITK_TEST_CONDITION(dataNode->GetStringProperty("Cat", value) && value == "Trim", "Parse_String_ParsedAsStringProperty")
+}
+
+static void Parse_FloatDefaultValue_IsZero()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Zero' type='float'}");
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate, true);
+ float value;
+ MITK_TEST_CONDITION(dataNode->GetFloatProperty("Zero", value) && mitk::Equal(value, 0.0f), "Parse_FloatDefaultValue_IsZero")
+}
+
+static void Parse_IntDefaultValue_IsZero()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Zero' type='int'}");
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate, true);
+ int value;
+ MITK_TEST_CONDITION(dataNode->GetIntProperty("Zero", value) && value == 0, "Parse_IntDefaultValue_IsZero")
+}
+
+static void Parse_StringDefaultValue_IsEmpty()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Empty' type='string'}");
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate, true);
+ std::string value;
+ MITK_TEST_CONDITION(dataNode->GetStringProperty("Empty", value) && value.empty(), "Parse_StringDefaultValue_IsEmpty")
+}
+
+static void Parse_NoType_ParsedAsString()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Captain' default='Flinders'}");
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate, true);
+ std::string value;
+ MITK_TEST_CONDITION(dataNode->GetStringProperty("Captain", value) && value == "Flinders", "Parse_NoType_ParsedAsString")
+}
+
+static void SetProperties_InputIsNull_ReturnsFalse()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ MITK_TEST_CONDITION(!simulationTemplate->SetProperties(NULL), "SetProperties_InputIsNull_ReturnsFalse")
+}
+
+static void SetProperties_NotInitialized_ReturnsFalse()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate);
+ MITK_TEST_CONDITION(!simulationTemplate->SetProperties(dataNode), "SetProperties_NotInitialized_ReturnsFalse")
+}
+
+static void SetProperties_InputIsNotOwner_ReturnsFalse()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate1 = mitk::SimulationTemplate::New();
+ simulationTemplate1->Parse("{id='A' default='1'}");
+ mitk::SimulationTemplate::Pointer simulationTemplate2 = mitk::SimulationTemplate::New();
+ simulationTemplate2->Parse("{id='B' default='2'}");
+ mitk::DataNode::Pointer dataNode1 = CreateDataNode(simulationTemplate1);
+ MITK_TEST_CONDITION(!simulationTemplate2->SetProperties(dataNode1), "SetProperties_InputIsNotOwner_ReturnsFalse")
+}
+
+static void SetProperties_ContainsTemplateAndReference_SetsPropertyAndReturnsTrue()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Atoll' default='Bora'} {'Atoll'}");
+ mitk::DataNode::Pointer dataNode = CreateDataNode(simulationTemplate);
+ bool boolResult = simulationTemplate->SetProperties(dataNode);
+ std::size_t numProperties = dataNode->GetPropertyList()->GetMap()->size();
+ std::string stringResult;
+ dataNode->GetStringProperty("Atoll", stringResult);
+ MITK_TEST_CONDITION(boolResult && numProperties == 1 && stringResult == "Bora", "SetProperties_ContainsTemplateAndReference_SetsPropertyAndReturnsTrue")
+}
+
+static void CreateSimulation_NotInitialized_ReturnsEmptyString()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ MITK_TEST_CONDITION(simulationTemplate->CreateSimulation().empty(), "CreateSimulation_NotInitialized_ReturnsEmptyString")
+}
+
+static void CreateSimulation_ContainsInvalidReference_ReturnsEmptyString()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{'Invalid'}");
+ MITK_TEST_CONDITION(simulationTemplate->CreateSimulation().empty(), "CreateSimulation_ContainsInvalidReference_ReturnsEmptyString")
+}
+
+static void CreateSimulation_ContainsTemplateAndReference_ReturnsExpectedString()
+{
+ mitk::SimulationTemplate::Pointer simulationTemplate = mitk::SimulationTemplate::New();
+ simulationTemplate->Parse("{id='Atoll' default='Bora'} {'Atoll'}");
+ MITK_TEST_CONDITION(simulationTemplate->CreateSimulation() == "Bora Bora", "CreateSimulation_ContainsTemplateAndReference_ReturnsExpectedString")
+}
+
+int mitkSimulationTemplateTest(int, char* [])
+{
+ mitk::RegisterSimulationObjectFactory();
+
+ MITK_TEST_BEGIN("mitkSimulationTemplateTest")
+
+ Parse_InputIsEmpty_ReturnsTrue();
+ Parse_AlreadyInitialized_ReturnsFalse();
+ Parse_EOFBeforeClosingBrace_ThrowsException();
+ Parse_OpeningBraceBeforeClosingBrace_ThrowsException();
+ Parse_TooShortToBeReference_ThrowsException();
+ Parse_NumberOfSingleQuotationMarksIsOdd_ThrowsException();
+ Parse_ReferenceDoesNotEndCorrectly_ThrowsException();
+ Parse_ReferenceIsEmpty_ThrowsException();
+ Parse_TooShortToBeTemplate_ThrowsException();
+ Parse_IdIsEmpty_ThrowsException();
+ Parse_UnknownType_ThrowsException();
+ Parse_ValueIsAmbiguous_ThrowsException();
+ Parse_IdNotFound_ThrowsException();
+ Parse_NoAssignmentToValue_ThrowsException();
+ Parse_ValueIsNotEnclosedWithSingleQuotationMarks_ThrowsException();
+ Parse_TypeMismatch_ThrowsException();
+ Parse_ValueContainsEscapedSingleQuotationMark_IsUnescapedAfterParsing();
+ Parse_Float_ParsedAsFloatProperty();
+ Parse_Int_ParsedAsIntProperty();
+ Parse_String_ParsedAsStringProperty();
+ Parse_FloatDefaultValue_IsZero();
+ Parse_IntDefaultValue_IsZero();
+ Parse_StringDefaultValue_IsEmpty();
+ Parse_NoType_ParsedAsString();
+
+ SetProperties_InputIsNull_ReturnsFalse();
+ SetProperties_NotInitialized_ReturnsFalse();
+ SetProperties_InputIsNotOwner_ReturnsFalse();
+ SetProperties_ContainsTemplateAndReference_SetsPropertyAndReturnsTrue();
+
+ CreateSimulation_NotInitialized_ReturnsEmptyString();
+ CreateSimulation_ContainsInvalidReference_ReturnsEmptyString();
+ CreateSimulation_ContainsTemplateAndReference_ReturnsExpectedString();
+
+ MITK_TEST_END()
+}
diff --git a/Modules/Simulation/Testing/mitkSimulationTest.cpp b/Modules/Simulation/Testing/mitkSimulationTest.cpp
new file mode 100644
index 0000000000..aeeb9c07ff
--- /dev/null
+++ b/Modules/Simulation/Testing/mitkSimulationTest.cpp
@@ -0,0 +1,292 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkIOUtil.h>
+#include <mitkSimulation.h>
+#include <mitkSimulationObjectFactory.h>
+#include <mitkTestingMacros.h>
+#include <sofa/core/visual/VisualParams.h>
+#include <sofa/simulation/common/UpdateContextVisitor.h>
+#include <sofa/simulation/tree/GNode.h>
+#include <sstream>
+
+template <typename T>
+static T lexical_cast(const std::string& string)
+{
+ std::istringstream sstream(string);
+ T value;
+
+ sstream >> value;
+
+ if (sstream.fail())
+ {
+ MITK_ERROR << "Lexical cast failed for '" << string << "'!";
+ exit(EXIT_FAILURE);
+ }
+
+ return value;
+}
+
+static mitk::Simulation::Pointer LoadSimulation(const std::string& filename)
+{
+ mitk::DataNode::Pointer dataNode = mitk::IOUtil::LoadDataNode(filename);
+ mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(dataNode->GetData());
+
+ if (simulation.IsNull())
+ mitkThrow() << "Could not load '" << filename << "'!";
+
+ return simulation;
+}
+
+static bool IsActiveSimulation(mitk::Simulation::Pointer simulation)
+{
+ if (simulation.IsNull())
+ mitkThrow() << "Invalid argument (null pointer)!";
+
+ sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
+ mitk::SimulationDrawTool* drawTool = simulation->GetDrawTool();
+
+ sofa::simulation::Simulation* activeSimulation = sofa::simulation::getSimulation();
+ sofa::core::visual::DrawTool*& activeDrawTool = sofa::core::visual::VisualParams::defaultInstance()->drawTool();
+
+ return sofaSimulation == activeSimulation && drawTool == activeDrawTool;
+}
+
+static bool NoActiveSimulation()
+{
+ sofa::simulation::Simulation* activeSimulation = sofa::simulation::getSimulation();
+ sofa::core::visual::DrawTool*& activeDrawTool = sofa::core::visual::VisualParams::defaultInstance()->drawTool();
+
+ return activeSimulation == NULL && activeDrawTool == NULL;
+}
+
+static void DrawSimulation(mitk::Simulation::Pointer simulation, bool updateContext = true)
+{
+ if (simulation.IsNull())
+ mitkThrow() << "Invalid argument (null pointer)!";
+
+ sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
+
+ if (!rootNode)
+ mitkThrow() << "Invalid argument (simulation is not initialized)!";
+
+ simulation->SetAsActiveSimulation();
+
+ if (updateContext)
+ rootNode->execute<sofa::simulation::UpdateContextVisitor>(sofa::core::ExecParams::defaultInstance());
+
+ sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
+
+ sofaSimulation->updateVisual(rootNode.get());
+ sofaSimulation->draw(sofa::core::visual::VisualParams::defaultInstance(), rootNode.get());
+}
+
+static vtkIdType GetNumberOfPolys(mitk::Surface::Pointer surface, unsigned int t = 0)
+{
+ vtkIdType numPolys = 0;
+
+ if (surface.IsNotNull())
+ {
+ vtkPolyData* polyData = surface->GetVtkPolyData();
+
+ if (polyData != NULL)
+ numPolys = polyData->GetNumberOfPolys();
+ }
+
+ return numPolys;
+}
+
+static void SetActiveSimulation_InputIsNull_NoActiveSimulation()
+{
+ mitk::Simulation::SetActiveSimulation(NULL);
+ MITK_TEST_CONDITION(NoActiveSimulation(), "SetActiveSimulation_InputIsNull_NoActiveSimulation")
+}
+
+static void SetAsActiveSimulation_NotInitialized_IsActiveSimulation()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ simulation->SetAsActiveSimulation();
+ MITK_TEST_CONDITION(IsActiveSimulation(simulation), "SetAsActiveSimulation_NotInitialized_IsActiveSimulation")
+}
+
+static void SetAsActiveSimulation_Initialized_IsActiveSimulation(const std::string& filename)
+{
+ mitk::Simulation::Pointer simulation = LoadSimulation(filename);
+ simulation->SetAsActiveSimulation();
+ MITK_TEST_CONDITION(IsActiveSimulation(simulation), "SetAsActiveSimulation_Initialized_IsActiveSimulation")
+}
+
+static void GetRootNode_NotInitialized_ReturnsNull()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ MITK_TEST_CONDITION(!simulation->GetRootNode(), "GetRootNode_NotInitialized_ReturnsNull")
+}
+
+static void GetRootNode_Initialized_ReturnsRootNode(const std::string& filename)
+{
+ mitk::Simulation::Pointer simulation = LoadSimulation(filename);
+ MITK_TEST_CONDITION(simulation->GetRootNode(), "GetRootNode_Initialized_ReturnsRootNode")
+}
+
+static void GetDefaultDT_NotInitialized_ReturnsZero()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ MITK_TEST_CONDITION(mitk::Equal(simulation->GetDefaultDT(), 0.0), "GetDefaultDT_NotInitialized_ReturnsZero")
+}
+
+static void GetDefaultDT_Initialized_ReturnsDefaultDT(const std::string& filename, double dt)
+{
+ mitk::Simulation::Pointer simulation = LoadSimulation(filename);
+ MITK_TEST_CONDITION(mitk::Equal(simulation->GetDefaultDT(), dt), "GetDefaultDT_Initialized_ReturnsDefaultDT")
+}
+
+static void GetDrawTool_Always_ReturnsDrawTool()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ MITK_TEST_CONDITION(simulation->GetDrawTool() != NULL, "GetDrawTool_Always_ReturnsDrawTool")
+}
+
+static void GetSimulation_Always_ReturnsSimulation()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ MITK_TEST_CONDITION(simulation->GetSimulation(), "GetSimulation_Always_ReturnsSimulation")
+}
+
+static void SetRootNode_InputIsNull_RootNodeIsNull()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ simulation->SetRootNode(NULL);
+ MITK_TEST_CONDITION(!simulation->GetRootNode(), "SetRootNode_InputIsNull_RootNodeIsNull")
+}
+
+static void SetRootNode_InputIsValid_RootNodeEqualsInput()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ sofa::simulation::Node::SPtr rootNode = sofa::core::objectmodel::SPtr_dynamic_cast<sofa::simulation::Node>(sofa::core::objectmodel::New<sofa::simulation::tree::GNode>());
+ simulation->SetRootNode(rootNode.get());
+ MITK_TEST_CONDITION(simulation->GetRootNode() == rootNode, "SetRootNode_InputIsValid_RootNodeEqualsInput")
+}
+
+static void SetDefaultDT_InputIsPositive_DefaultDTEqualsInput()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ const double dt = 0.1;
+ simulation->SetDefaultDT(dt);
+ MITK_TEST_CONDITION(mitk::Equal(simulation->GetDefaultDT(), dt), "SetDefaultDT_InputIsPositive_DefaultDTEqualsInput")
+}
+
+static void SetDefaultDT_InputIsNegative_DefaultDTIsZero()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ simulation->SetDefaultDT(-0.1);
+ MITK_TEST_CONDITION(mitk::Equal(simulation->GetDefaultDT(), 0.0), "SetDefaultDT_InputIsNegative_DefaultDTIsZero")
+}
+
+static void TakeSnapshot_NotInitialized_ReturnsNull()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ MITK_TEST_CONDITION(simulation->TakeSnapshot().IsNull(), "TakeSnapshot_SimulationIsNotInitialized_ReturnsNull");
+}
+
+static void TakeSnapshot_SimulationWasDrawn_ReturnsSurface(const std::string& filename, vtkIdType numPolys)
+{
+ mitk::Simulation::Pointer simulation = LoadSimulation(filename);
+ DrawSimulation(simulation);
+ mitk::Surface::Pointer snapshot = simulation->TakeSnapshot();
+ MITK_TEST_CONDITION(GetNumberOfPolys(snapshot) == numPolys, "TakeSnapshot_SimulationWasDrawn_ReturnsSurface");
+}
+
+static void AppendSnapshot_NotInitialized_ReturnsFalse()
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ mitk::Surface::Pointer record = mitk::Surface::New();
+ MITK_TEST_CONDITION(!simulation->AppendSnapshot(record), "AppendSnapshot_NotInitialized_ReturnsFalse");
+}
+
+static void AppendSnapshot_InputIsNull_ReturnsFalse(const std::string& filename)
+{
+ mitk::Simulation::Pointer simulation = mitk::Simulation::New();
+ MITK_TEST_CONDITION(!simulation->AppendSnapshot(NULL), "AppendSnapshot_InputIsNull_ReturnsFalse");
+}
+
+static void AppendSnapshot_InputIsEmpty_AppendsSnapshotAndReturnsTrue(const std::string& filename, vtkIdType numPolys)
+{
+ mitk::Simulation::Pointer simulation = LoadSimulation(filename);
+ DrawSimulation(simulation);
+ mitk::Surface::Pointer record = mitk::Surface::New();
+ MITK_TEST_CONDITION(simulation->AppendSnapshot(record) && GetNumberOfPolys(record) == numPolys, "AppendSnapshot_InputIsEmpty_AppendsSnapshotAndReturnsTrue")
+}
+
+static void AppendSnapshot_InputIsNotEmpty_AppendsSnapshotAndReturnsTrue(const std::string& filename, vtkIdType numPolys)
+{
+ mitk::Simulation::Pointer simulation = LoadSimulation(filename);
+ DrawSimulation(simulation);
+ mitk::Surface::Pointer record = mitk::Surface::New();
+ simulation->AppendSnapshot(record);
+ MITK_TEST_CONDITION(simulation->AppendSnapshot(record) && GetNumberOfPolys(record, 1) == numPolys, "AppendSnapshot_InputIsNotEmpty_AppendsSnapshotAndReturnsTrue")
+}
+
+int mitkSimulationTest(int argc, char* argv[])
+{
+ if (argc != 4)
+ {
+ MITK_ERROR << "Invalid argument count!\n"
+ << "Usage: mitkSimulationTest <filename> <dt> <numPolys>\n"
+ << " <filename> Path to simulation scene\n"
+ << " <dt> Default time step\n"
+ << " <numPolys> Total polygon count of all visual models";
+
+ return EXIT_FAILURE;
+ }
+
+ const std::string filename = argv[1];
+ const double dt = lexical_cast<double>(argv[2]);
+ const vtkIdType numPolys = lexical_cast<vtkIdType>(argv[3]);
+
+ mitk::RegisterSimulationObjectFactory();
+
+ MITK_TEST_BEGIN("mitkSimulationTest")
+
+ SetActiveSimulation_InputIsNull_NoActiveSimulation();
+ SetAsActiveSimulation_NotInitialized_IsActiveSimulation();
+ SetAsActiveSimulation_Initialized_IsActiveSimulation(filename);
+
+ GetRootNode_NotInitialized_ReturnsNull();
+ GetRootNode_Initialized_ReturnsRootNode(filename);
+
+ GetDefaultDT_NotInitialized_ReturnsZero();
+ GetDefaultDT_Initialized_ReturnsDefaultDT(filename, dt);
+
+ GetDrawTool_Always_ReturnsDrawTool();
+
+ GetSimulation_Always_ReturnsSimulation();
+
+ SetRootNode_InputIsNull_RootNodeIsNull();
+ SetRootNode_InputIsValid_RootNodeEqualsInput();
+
+ SetDefaultDT_InputIsPositive_DefaultDTEqualsInput();
+ SetDefaultDT_InputIsNegative_DefaultDTIsZero();
+
+ TakeSnapshot_NotInitialized_ReturnsNull();
+ TakeSnapshot_SimulationWasDrawn_ReturnsSurface(filename, numPolys);
+
+ AppendSnapshot_NotInitialized_ReturnsFalse();
+ AppendSnapshot_InputIsNull_ReturnsFalse(filename);
+ AppendSnapshot_InputIsEmpty_AppendsSnapshotAndReturnsTrue(filename, numPolys);
+ AppendSnapshot_InputIsNotEmpty_AppendsSnapshotAndReturnsTrue(filename, numPolys);
+
+ MITK_TEST_END()
+}
diff --git a/Modules/Simulation/files.cmake b/Modules/Simulation/files.cmake
index 92064e233b..4284af92e6 100644
--- a/Modules/Simulation/files.cmake
+++ b/Modules/Simulation/files.cmake
@@ -1,10 +1,13 @@
set(CPP_FILES
mitkSimulation.cpp
mitkSimulationDrawTool.cpp
- mitkSimulationPropAssemblyVisitor.cpp
mitkSimulationIOFactory.cpp
mitkSimulationMapper3D.cpp
- mitkSimulationReader.cpp
- mitkSimulationObjectFactory.cpp
mitkSimulationModel.cpp
+ mitkSimulationObjectFactory.cpp
+ mitkSimulationPropAssemblyVisitor.cpp
+ mitkSimulationReader.cpp
+ mitkSimulationTemplate.cpp
+ mitkSimulationTemplateIOFactory.cpp
+ mitkSimulationTemplateReader.cpp
)
diff --git a/Modules/Simulation/mitkSimulation.cpp b/Modules/Simulation/mitkSimulation.cpp
index c499c7b059..1cc4e05103 100644
--- a/Modules/Simulation/mitkSimulation.cpp
+++ b/Modules/Simulation/mitkSimulation.cpp
@@ -1,238 +1,243 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSimulation.h"
#include "mitkSimulationPropAssemblyVisitor.h"
#include <mitkDataNode.h>
#include <mitkSurface.h>
#include <sofa/core/visual/VisualParams.h>
-#include <sofa/simulation/bgl/BglSimulation.h>
-#include <sofa/simulation/graph/DAGSimulation.h>
#include <sofa/simulation/tree/TreeSimulation.h>
#include <vtkActor.h>
#include <vtkAppendPolyData.h>
#include <vtkMapper.h>
#include <vtkPolyData.h>
#include <vtkPropAssembly.h>
#include <vtkPropCollection.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
-const float mitk::Simulation::ScaleFactor = 1000.0f;
+const float mitk::Simulation::ScaleFactor = 1.0f; // 1000.0f
-static sofa::simulation::Simulation::SPtr CreateSimulation(mitk::Simulation::SimulationType type = mitk::Simulation::Tree)
+static sofa::simulation::Simulation::SPtr CreateSimulation()
{
- if (type == mitk::Simulation::DAG)
- return sofa::core::objectmodel::New<sofa::simulation::graph::DAGSimulation>();
- else if (type == mitk::Simulation::Bgl)
- return sofa::core::objectmodel::New<sofa::simulation::bgl::BglSimulation>();
- else
- return sofa::core::objectmodel::New<sofa::simulation::tree::TreeSimulation>();
+ const std::string key = "MultiMappingObject";
+
+ if (sofa::simulation::xml::BaseElement::NodeFactory::HasKey(key))
+ sofa::simulation::xml::BaseElement::NodeFactory::ResetEntry(key);
+
+ return sofa::core::objectmodel::New<sofa::simulation::tree::TreeSimulation>();
}
void mitk::Simulation::SetActiveSimulation(mitk::Simulation* simulation)
{
if (simulation == NULL)
{
sofa::simulation::setSimulation(NULL);
sofa::core::visual::VisualParams::defaultInstance()->drawTool() = NULL;
}
else
{
sofa::simulation::Simulation* sofaSimulation = simulation->m_Simulation.get();
if (sofa::simulation::getSimulation() != sofaSimulation)
{
sofa::simulation::setSimulation(sofaSimulation);
sofa::core::visual::VisualParams::defaultInstance()->drawTool() = &simulation->m_DrawTool;
}
}
}
mitk::Simulation::Simulation()
: m_Simulation(CreateSimulation()),
m_DefaultDT(0.0)
{
}
mitk::Simulation::~Simulation()
{
if (m_Simulation != NULL)
{
if (m_RootNode != NULL)
m_Simulation->unload(m_RootNode);
if (sofa::simulation::getSimulation() == m_Simulation.get())
SetActiveSimulation(NULL);
}
}
-void mitk::Simulation::AppendSnapshot(mitk::Surface::Pointer surface) const
+bool mitk::Simulation::AppendSnapshot(mitk::Surface::Pointer surface) const
{
- if (surface.IsNull())
- return;
+ if (surface.IsNotNull())
+ {
+ vtkSmartPointer<vtkPolyData> snapshot = this->CreateSnapshot();
- vtkSmartPointer<vtkPolyData> snapshot = this->CreateSnapshot();
+ if (snapshot != NULL)
+ {
+ unsigned int timeStep = surface->GetSizeOfPolyDataSeries();
- if (snapshot != NULL)
- {
- unsigned int timeStep = surface->GetSizeOfPolyDataSeries();
+ if (timeStep != 0 && surface->GetVtkPolyData(timeStep - 1) == NULL)
+ --timeStep;
- if (timeStep != 0 && surface->GetVtkPolyData(timeStep - 1) == NULL)
- --timeStep;
+ surface->SetVtkPolyData(snapshot, timeStep);
- surface->SetVtkPolyData(snapshot, timeStep);
+ return true;
+ }
}
+
+ return false;
}
vtkSmartPointer<vtkPolyData> mitk::Simulation::CreateSnapshot() const
{
if (m_RootNode == NULL)
return NULL;
vtkSmartPointer<vtkPropAssembly> propAssembly = vtkSmartPointer<vtkPropAssembly>::New();
SimulationPropAssemblyVisitor propAssemblyVisitor(propAssembly);
m_RootNode->executeVisitor(&propAssemblyVisitor);
vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();
vtkPropCollection* propCollection = propAssembly->GetParts();
vtkProp* prop = NULL;
+ if (propCollection->GetNumberOfItems() == 0)
+ return NULL;
+
for (propCollection->InitTraversal(); (prop = propCollection->GetNextProp()) != NULL; )
{
vtkActor* actor = vtkActor::SafeDownCast(prop);
vtkPolyData* polyData = vtkPolyData::SafeDownCast(actor->GetMapper()->GetInput());
appendFilter->AddInput(polyData);
}
vtkSmartPointer<vtkTransform> scaleTransform = vtkSmartPointer<vtkTransform>::New();
scaleTransform->Scale(ScaleFactor, ScaleFactor, ScaleFactor);
vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
transformFilter->SetInputConnection(appendFilter->GetOutputPort());
transformFilter->SetTransform(scaleTransform);
transformFilter->Update();
vtkSmartPointer<vtkPolyData> snapshot = vtkSmartPointer<vtkPolyData>::New();
snapshot->ShallowCopy(transformFilter->GetOutputDataObject(0));
return snapshot;
}
double mitk::Simulation::GetDefaultDT() const
{
return m_DefaultDT;
}
mitk::SimulationDrawTool* mitk::Simulation::GetDrawTool()
{
return &m_DrawTool;
}
sofa::simulation::Node::SPtr mitk::Simulation::GetRootNode() const
{
return m_RootNode;
}
sofa::simulation::Simulation::SPtr mitk::Simulation::GetSimulation() const
{
return m_Simulation;
}
bool mitk::Simulation::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
void mitk::Simulation::SetAsActiveSimulation()
{
SetActiveSimulation(this);
}
void mitk::Simulation::SetDefaultDT(double dt)
{
m_DefaultDT = std::max(0.0, dt);
}
-void mitk::Simulation::SetRequestedRegion(itk::DataObject*)
+void mitk::Simulation::SetRequestedRegion(const itk::DataObject*)
{
}
void mitk::Simulation::SetRequestedRegionToLargestPossibleRegion()
{
}
void mitk::Simulation::SetRootNode(sofa::simulation::Node* rootNode)
{
m_RootNode.reset(rootNode);
}
mitk::Surface::Pointer mitk::Simulation::TakeSnapshot() const
{
vtkSmartPointer<vtkPolyData> snapshot = this->CreateSnapshot();
if (snapshot == NULL)
return NULL;
Surface::Pointer surface = Surface::New();
surface->SetVtkPolyData(snapshot);
return surface;
}
void mitk::Simulation::UpdateOutputInformation()
{
if (this->GetSource().IsNotNull())
this->GetSource()->UpdateOutputInformation();
if (m_RootNode != NULL)
{
const sofa::defaulttype::BoundingBox& boundingBox = m_RootNode->f_bbox.getValue();
const sofa::defaulttype::Vector3& min = boundingBox.minBBox();
const sofa::defaulttype::Vector3& max = boundingBox.maxBBox();
mitk::Geometry3D::BoundsArrayType bounds;
bounds[0] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(min.x() * ScaleFactor);
bounds[1] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(max.x() * ScaleFactor);
bounds[2] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(min.y() * ScaleFactor);
bounds[3] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(max.y() * ScaleFactor);
bounds[4] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(min.z() * ScaleFactor);
bounds[5] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(max.z() * ScaleFactor);
if(this->GetGeometry() != NULL)
{
this->GetGeometry()->SetBounds(bounds);
}
else
{
Geometry3D::Pointer geometry = Geometry3D::New();
geometry->SetBounds(bounds);
this->SetGeometry(geometry);
}
}
this->GetTimeSlicedGeometry()->UpdateInformation();
}
bool mitk::Simulation::VerifyRequestedRegion()
{
return true;
}
diff --git a/Modules/Simulation/mitkSimulation.h b/Modules/Simulation/mitkSimulation.h
index d58c61a614..9d8d0ffb07 100644
--- a/Modules/Simulation/mitkSimulation.h
+++ b/Modules/Simulation/mitkSimulation.h
@@ -1,77 +1,161 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkSimulation_h
#define mitkSimulation_h
#include "mitkSimulationDrawTool.h"
#include <mitkSurface.h>
#include <SimulationExports.h>
#include <sofa/simulation/common/Simulation.h>
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>
namespace mitk
{
+ /** \brief Encapsulates a SOFA simulation.
+ *
+ * Call GetSimulation() to access the initially default constructed SOFA simulation.
+ * Directly after loading a scene into the SOFA simulation you must set its root node by calling SetRootNode().
+ * You should set the simulation scene's default time step as well by calling SetDefaultDT().
+ * Make sure to manually initilalize the SOFA simulation.
+ *
+ * SOFA can conceptionally handle only one simulation at a time, however, MITK %Simulation allows to load several simulation scenes in parallel.
+ * Therefore it is necessary to set a simulation as active simulation when using it.
+ * You can do this either by calling SetAsActiveSimulation() or by calling the static SetActiveSimulation() method.
+ *
+ * You can take snapshots of simulations represented as 3D surfaces by calling TakeSnapshot() or easily record simulations as 3D+t surfaces by calling AppendSnapshot().
+ */
class Simulation_EXPORT Simulation : public BaseData
{
public:
- enum SimulationType
- {
- Tree,
- DAG,
- Bgl
- };
-
mitkClassMacro(Simulation, BaseData);
itkNewMacro(Self);
+ /** \brief %Set the active simulation.
+ *
+ * \param[in] simulation The new active simulation or NULL.
+ * \sa SetAsActiveSimulation()
+ */
static void SetActiveSimulation(Self* simulation);
+ /** \brief Scale factor by which all objects in a simulation scene are scaled for visualization.
+ */
static const float ScaleFactor;
- void AppendSnapshot(Surface::Pointer surface) const;
+ /** \brief Append snapshot of scene at current simulation time to given Surface.
+ *
+ * \param[in] surface Surface to which the current scene is appended as 3D surface.
+ * \return Returns true if a snapshot was successfully appended to the surface.
+ * \sa TakeSnapshot()
+ */
+ bool AppendSnapshot(Surface::Pointer surface) const;
+
+ /** \brief Get default time step of simulation scene.
+ *
+ * You need to manually set the default time step by calling SetDefaultDT().
+ *
+ * \return The default time step of the simulation scene if available or 0.0 otherwise.
+ */
double GetDefaultDT() const;
+
+ /** \brief Get simulation draw tool.
+ *
+ * Usually called only by the corresponding mapper or to reset the draw tool manually.
+ *
+ * \return The simulation draw tool.
+ */
SimulationDrawTool* GetDrawTool();
+
+ /** \brief Get root node of simulation scene.
+ *
+ * You must manually set the root node by calling SetRootNode() first.
+ * This is usually done directly after setting/loading a simulation scene.
+ *
+ * \return The root node of the encapsulated SOFA simulation scene.
+ */
sofa::simulation::Node::SPtr GetRootNode() const;
+
+ /** \brief Get SOFA simulation.
+ *
+ * The encapsulated SOFA simulation is default constructed during construction.
+ * Use this method to gain access to it or to initially load a scene into the simulation.
+ * Make sure to also call SetRootNode() and SetDefaultDT() in the latter case.
+ *
+ * \return The encapsulated SOFA simulation.
+ */
sofa::simulation::Simulation::SPtr GetSimulation() const;
+
bool RequestedRegionIsOutsideOfTheBufferedRegion();
+
+ /** \brief %Set this simulation as active simulation.
+ *
+ * You must set a simulation as active simulation prior to use it.
+ *
+ * \sa SetActiveSimulation()
+ */
void SetAsActiveSimulation();
+
+ /** \brief %Set default simulation scene time step.
+ *
+ * You should call this method after you loaded a scene into the encapsulated SOFA simulation and set the root node.
+ *
+ * \param[in] dt Default time step of encapsulated simulation scene.
+ * \sa GetSimulation(), SetRootNode()
+ */
void SetDefaultDT(double dt);
- void SetRequestedRegion(itk::DataObject* data);
+
+ void SetRequestedRegion(const itk::DataObject* data);
+
void SetRequestedRegionToLargestPossibleRegion();
+
+ /** \brief %Set the simulation scene root node of the encapsulated simulation.
+ *
+ * This is usually the first method you call after you accessed the encapsulated simulation by calling GetSimulation() to set or load the simulation scene.
+ *
+ * \param[in] rootNode Root Node of the simulation scene corresponding to the encapsulated SOFA simulation.
+ */
void SetRootNode(sofa::simulation::Node* rootNode);
+
+ /** \brief Take a snapshot of the encapsulated simulation scene at current simulation time.
+ *
+ * Snapshots cannot be created if the simulation scene contains no visual models or only hidden visual models.
+ *
+ * \return Snapshot represented as 3D surface or NULL.
+ */
Surface::Pointer TakeSnapshot() const;
+
void UpdateOutputInformation();
+
bool VerifyRequestedRegion();
private:
Simulation();
~Simulation();
Simulation(Self&);
Self& operator=(const Self&);
vtkSmartPointer<vtkPolyData> CreateSnapshot() const;
sofa::simulation::Simulation::SPtr m_Simulation;
sofa::simulation::Node::SPtr m_RootNode;
SimulationDrawTool m_DrawTool;
double m_DefaultDT;
};
}
#endif
diff --git a/Modules/Simulation/mitkSimulationDrawTool.cpp b/Modules/Simulation/mitkSimulationDrawTool.cpp
index 456a907ce4..c6ee8dbe5f 100644
--- a/Modules/Simulation/mitkSimulationDrawTool.cpp
+++ b/Modules/Simulation/mitkSimulationDrawTool.cpp
@@ -1,577 +1,589 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSimulation.h"
#include "mitkSimulationDrawTool.h"
#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <vtkFloatArray.h>
#include <vtkLineSource.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkPolyDataNormals.h>
#include <vtkProperty.h>
#include <vtkSphereSource.h>
#include <vtkTubeFilter.h>
mitk::SimulationDrawTool::SimulationDrawTool()
: m_PolygonMode(0),
m_Wireframe(false),
m_Update(true)
{
}
mitk::SimulationDrawTool::~SimulationDrawTool()
{
m_Actors.clear();
}
void mitk::SimulationDrawTool::DisableUpdate()
{
m_Update = false;
}
std::vector<vtkSmartPointer<vtkActor> > mitk::SimulationDrawTool::GetActors() const
{
return m_Actors;
}
void mitk::SimulationDrawTool::InitProperty(vtkProperty* property) const
{
if (m_Wireframe)
property->SetRepresentationToWireframe();
else
property->SetRepresentationToSurface();
}
void mitk::SimulationDrawTool::Reset()
{
m_Actors.clear();
m_Update = true;
}
void mitk::SimulationDrawTool::drawPoints(const std::vector<Vector3>& points, float pointSize, const Vec4f color)
{
if (!m_Update || points.empty())
return;
unsigned int numPoints = points.size();
vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer< ::vtkPoints>::New();
vtkPoints->SetNumberOfPoints(numPoints);
vtkSmartPointer<vtkCellArray> cellArray = vtkSmartPointer<vtkCellArray>::New();
for (unsigned int i = 0; i < numPoints; ++i)
{
vtkPoints->SetPoint(i, points[i].elems);
cellArray->InsertNextCell(1);
cellArray->InsertCellPoint(i);
}
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(vtkPoints);
polyData->SetVerts(cellArray);
vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
polyDataMapper->SetInput(polyData);
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(polyDataMapper);
actor->SetScale(Simulation::ScaleFactor);
vtkProperty* property = actor->GetProperty();
property->SetColor(color.x(), color.y(), color.z());
property->SetPointSize(pointSize);
m_Actors.push_back(actor);
}
+void mitk::SimulationDrawTool::drawPoints(const std::vector<Vector3>&, float, const std::vector<Vec4f>)
+{
+}
+
void mitk::SimulationDrawTool::drawLines(const std::vector<Vector3>& points, float lineWidth, const Vec4f color)
{
if (!m_Update || points.empty())
return;
unsigned int numPoints = points.size();
std::vector<Vec2i> indices;
for (unsigned int i = 0; i < numPoints; i += 2)
indices.push_back(Vec2i(i, i + 1));
this->drawLines(points, indices, lineWidth, color);
}
void mitk::SimulationDrawTool::drawLines(const std::vector<Vector3>& points, const std::vector<Vec2i>& indices, float lineWidth, const Vec4f color)
{
if (!m_Update || points.empty())
return;
unsigned int numPoints = points.size();
vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer< ::vtkPoints>::New();
vtkPoints->SetNumberOfPoints(numPoints);
for (unsigned int i = 0; i < numPoints; ++i)
vtkPoints->SetPoint(i, points[i].elems);
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(vtkPoints);
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
unsigned int numIndices = indices.size();
for (unsigned int i = 0; i < numIndices; ++i)
{
lines->InsertNextCell(2);
lines->InsertCellPoint(indices[i].elems[0]);
lines->InsertCellPoint(indices[i].elems[1]);
}
polyData->SetLines(lines);
vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
polyDataMapper->SetInput(polyData);
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(polyDataMapper);
actor->SetScale(Simulation::ScaleFactor);
vtkProperty* property = actor->GetProperty();
property->SetLineWidth(lineWidth);
property->SetColor(color.x(), color.y(), color.z());
m_Actors.push_back(actor);
}
void mitk::SimulationDrawTool::drawTriangles(const std::vector<Vector3>& points, const Vec4f color)
{
if (!m_Update || points.empty())
return;
unsigned int numPoints = points.size();
vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer< ::vtkPoints>::New();
vtkPoints->SetNumberOfPoints(numPoints);
for (unsigned int i = 0; i < numPoints; ++i)
vtkPoints->SetPoint(i, points[i].elems);
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(vtkPoints);
vtkSmartPointer<vtkCellArray> triangles = vtkSmartPointer<vtkCellArray>::New();
for (unsigned int i = 0; i < points.size(); i += 3)
{
triangles->InsertNextCell(3);
triangles->InsertCellPoint(i);
triangles->InsertCellPoint(i + 1);
triangles->InsertCellPoint(i + 2);
}
polyData->SetPolys(triangles);
vtkSmartPointer<vtkPolyDataNormals> polyDataNormals = vtkSmartPointer<vtkPolyDataNormals>::New();
polyDataNormals->ComputeCellNormalsOff();
polyDataNormals->SetInput(polyData);
polyDataNormals->SplittingOff();
vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
polyDataMapper->SetInput(polyDataNormals->GetOutput());
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(polyDataMapper);
actor->SetScale(Simulation::ScaleFactor);
vtkProperty* property = actor->GetProperty();
this->InitProperty(property);
property->SetColor(color.x(), color.y(), color.z());
m_Actors.push_back(actor);
}
void mitk::SimulationDrawTool::drawTriangles(const std::vector<Vector3>& points, const Vector3 normal, const Vec4f color)
{
if (!m_Update || points.empty())
return;
unsigned int numPoints = points.size();
unsigned int numNormals = numPoints / 3;
vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer< ::vtkPoints>::New();
vtkPoints->SetNumberOfPoints(numPoints);
for (unsigned int i = 0; i < numPoints; ++i)
vtkPoints->SetPoint(i, points[i].elems);
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(vtkPoints);
vtkSmartPointer<vtkCellArray> triangles = vtkSmartPointer<vtkCellArray>::New();
for (unsigned int i = 0; i < points.size(); i += 3)
{
triangles->InsertNextCell(3);
triangles->InsertCellPoint(i);
triangles->InsertCellPoint(i + 1);
triangles->InsertCellPoint(i + 2);
}
polyData->SetPolys(triangles);
vtkSmartPointer<vtkFloatArray> normals = vtkSmartPointer<vtkFloatArray>::New();
normals->SetNumberOfComponents(3);
normals->SetNumberOfTuples(numNormals);
normals->SetName("Normals");
for (unsigned int i = 0; i < numNormals; ++i)
normals->SetTuple(i, normal.elems);
polyData->GetCellData()->SetNormals(normals);
vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
polyDataMapper->SetInput(polyData);
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(polyDataMapper);
actor->SetScale(Simulation::ScaleFactor);
vtkProperty* property = actor->GetProperty();
this->InitProperty(property);
property->SetColor(color.x(), color.y(), color.z());
m_Actors.push_back(actor);
}
void mitk::SimulationDrawTool::drawTriangles(const std::vector<Vector3>& points, const std::vector<Vec3i>& indices, const std::vector<Vector3>& normals, const Vec4f color)
{
if (!m_Update || points.empty() || indices.empty() || normals.empty())
return;
unsigned int numPoints = points.size();
vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer< ::vtkPoints>::New();
vtkPoints->SetNumberOfPoints(numPoints);
for (unsigned int i = 0; i < numPoints; ++i)
vtkPoints->SetPoint(i, points[i].elems);
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(vtkPoints);
vtkSmartPointer<vtkCellArray> triangles = vtkSmartPointer<vtkCellArray>::New();
unsigned int numIndices = indices.size();
for (unsigned int i = 0; i < numIndices; ++i)
{
triangles->InsertNextCell(3);
triangles->InsertCellPoint(indices[i].elems[0]);
triangles->InsertCellPoint(indices[i].elems[1]);
triangles->InsertCellPoint(indices[i].elems[2]);
}
polyData->SetPolys(triangles);
unsigned int numNormals = normals.size();
vtkSmartPointer<vtkFloatArray> vtkNormals = vtkSmartPointer<vtkFloatArray>::New();
vtkNormals->SetNumberOfComponents(3);
vtkNormals->SetNumberOfTuples(numNormals);
vtkNormals->SetName("Normals");
for (unsigned int i = 0; i < numNormals; ++i)
vtkNormals->SetTuple(i, normals[i].elems);
polyData->GetCellData()->SetNormals(vtkNormals);
vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
polyDataMapper->SetInput(polyData);
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(polyDataMapper);
actor->SetScale(Simulation::ScaleFactor);
vtkProperty* property = actor->GetProperty();
this->InitProperty(property);
property->SetColor(color.x(), color.y(), color.z());
m_Actors.push_back(actor);
}
void mitk::SimulationDrawTool::drawTriangles(const std::vector<Vector3>&, const std::vector<Vector3>&, const std::vector<Vec4f>&)
{
}
void mitk::SimulationDrawTool::drawTriangleStrip(const std::vector<Vector3>&, const std::vector<Vector3>&, const Vec4f)
{
}
void mitk::SimulationDrawTool::drawTriangleFan(const std::vector<Vector3>&, const std::vector<Vector3>&, const Vec4f)
{
}
void mitk::SimulationDrawTool::drawFrame(const Vector3& position, const Quaternion& orientation, const Vec3f& size)
{
if (!m_Update)
return;
float minSize = std::min(std::min(size.x(), size.y()), size.z());
float maxSize = std::max(std::max(size.x(), size.y()), size.z());
if (maxSize > minSize * 2.0f)
{
if (minSize > 0.0f)
maxSize = minSize * 2.0f;
else
minSize = maxSize * 0.707f;
}
const float radii[] = { minSize * 0.1f, maxSize * 0.2f };
bool wireframeBackup = m_Wireframe;
m_Wireframe = false;
if (size.x() != 0.0f)
{
Vector3 point2 = position + orientation.rotate(Vec3f(size.x(), 0.0f, 0.0f));
Vector3 point3 = point2 + orientation.rotate(Vec3f(radii[1], 0.0f, 0.0f));
Vec4f red(1.0f, 0.0f, 0.0f, 1.0f);
this->drawCylinder(position, point2, radii[0], red);
this->drawCone(point2, point3, radii[1], 0.0f, red);
}
if (size.y() != 0.0f)
{
Vector3 point2 = position + orientation.rotate(Vec3f(0.0f, size.y(), 0.0f));
Vector3 point3 = point2 + orientation.rotate(Vec3f(0.0f, radii[1], 0.0f));
Vec4f green(0.0f, 1.0f, 0.0f, 1.0f);
this->drawCylinder(position, point2, radii[0], green);
this->drawCone(point2, point3, radii[1], 0.0f, green);
}
if (size.z() != 0.0f)
{
Vector3 point2 = position + orientation.rotate(Vec3f(0.0f, 0.0f, size.z()));
Vector3 point3 = point2 + orientation.rotate(Vec3f(0.0f, 0.0f, radii[1]));
Vec4f blue(0.0f, 0.0f, 1.0f, 1.0f);
this->drawCylinder(position, point2, radii[0], blue);
this->drawCone(point2, point3, radii[1], 0.0f, blue);
}
m_Wireframe = wireframeBackup;
}
+void mitk::SimulationDrawTool::drawFrame(const Vector3&, const Quaternion&, const Vec3f&, const Vec4f&)
+{
+}
+
void mitk::SimulationDrawTool::drawSpheres(const std::vector<Vector3>& points, const std::vector<float>& radii, const Vec4f color)
{
if (!m_Update || points.empty())
return;
unsigned int numSpheres = points.size();
for (unsigned int i = 0; i < numSpheres; ++i)
{
vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
sphereSource->SetCenter(const_cast<double*>(points[i].elems));
sphereSource->SetRadius(radii[i]);
sphereSource->SetPhiResolution(16);
sphereSource->SetThetaResolution(32);
sphereSource->LatLongTessellationOn();
vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
polyDataMapper->SetInputConnection(sphereSource->GetOutputPort());
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(polyDataMapper);
actor->SetScale(Simulation::ScaleFactor);
vtkProperty* property = actor->GetProperty();
this->InitProperty(property);
property->SetColor(color.x(), color.y(), color.z());
m_Actors.push_back(actor);
}
}
void mitk::SimulationDrawTool::drawSpheres(const std::vector<Vector3>& points, float radius, const Vec4f color)
{
if (!m_Update || points.empty())
return;
unsigned int numPoints = points.size();
std::vector<float> radii(numPoints, radius);
this->drawSpheres(points, radii, color);
}
void mitk::SimulationDrawTool::drawCone(const Vector3& point1, const Vector3& point2, float radius1, float radius2, const Vec4f color, int subdivisions)
{
if (!m_Update)
return;
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
points->SetNumberOfPoints(2);
points->SetPoint(0, point1.elems);
points->SetPoint(1, point2.elems);
vtkSmartPointer<vtkCellArray> line = vtkSmartPointer<vtkCellArray>::New();
line->InsertNextCell(2);
line->InsertCellPoint(0);
line->InsertCellPoint(1);
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(points);
polyData->SetLines(line);
const char* radiiName = "Radii";
vtkSmartPointer<vtkFloatArray> radii = vtkSmartPointer<vtkFloatArray>::New();
radii->SetName(radiiName);
radii->SetNumberOfTuples(2);
radii->SetTuple1(0, radius1);
radii->SetTuple1(1, radius2);
vtkPointData* pointData = polyData->GetPointData();
pointData->AddArray(radii);
pointData->SetActiveScalars(radiiName);
vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
tubeFilter->SetInput(polyData);
tubeFilter->CappingOn();
tubeFilter->SetNumberOfSides(subdivisions);
tubeFilter->SetVaryRadiusToVaryRadiusByAbsoluteScalar();
vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
polyDataMapper->SetInputConnection(tubeFilter->GetOutputPort());
polyDataMapper->ScalarVisibilityOff();
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(polyDataMapper);
actor->SetScale(Simulation::ScaleFactor);
vtkProperty* property = actor->GetProperty();
this->InitProperty(property);
property->SetColor(color.x(), color.y(), color.z());
m_Actors.push_back(actor);
}
void mitk::SimulationDrawTool::drawCube(const float&, const Vec4f&, const int&)
{
}
void mitk::SimulationDrawTool::drawCylinder(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color, int subdivisions)
{
if (!m_Update)
return;
this->drawCone(point1, point2, radius, radius, color, subdivisions);
}
void mitk::SimulationDrawTool::drawCapsule(const Vector3&, const Vector3&, float, const Vec4f, int)
{
}
void mitk::SimulationDrawTool::drawArrow(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color, int subdivisions)
{
if (!m_Update)
return;
Vector3 point3 = point1 * 0.2f + point2 * 0.8f;
this->drawCylinder(point1, point3, radius, color, subdivisions);
this->drawCone(point3, point2, radius * 2.5f, 0.0f, color, subdivisions);
}
void mitk::SimulationDrawTool::drawPlus(const float& edgeRadius, const Vec4f& color, const int& subdivisions)
{
if (!m_Update)
return;
this->drawCylinder(Vector3(-1.0, 0.0, 0.0), Vector3(1.0, 0.0, 0.0), edgeRadius, color, subdivisions);
this->drawCylinder(Vector3(0.0, -1.0, 0.0), Vector3(0.0, 1.0, 0.0), edgeRadius, color, subdivisions);
this->drawCylinder(Vector3(0.0, 0.0, -1.0), Vector3(0.0, 0.0, 1.0), edgeRadius, color, subdivisions);
}
void mitk::SimulationDrawTool::drawPoint(const Vector3&, const Vec4f&)
{
}
void mitk::SimulationDrawTool::drawPoint(const Vector3&, const Vector3&, const Vec4f&)
{
}
void mitk::SimulationDrawTool::drawTriangle(const Vector3&, const Vector3&, const Vector3&, const Vector3&)
{
}
void mitk::SimulationDrawTool::drawTriangle(const Vector3&, const Vector3&, const Vector3&, const Vector3&, const Vec4f&)
{
}
void mitk::SimulationDrawTool::drawTriangle(const Vector3&, const Vector3&, const Vector3&, const Vector3&, const Vec4f&, const Vec4f&, const Vec4f&)
{
}
void mitk::SimulationDrawTool::drawSphere(const Vector3&, float)
{
}
+void mitk::SimulationDrawTool::drawBoundingBox(const Vector3&, const Vector3&)
+{
+}
+
void mitk::SimulationDrawTool::pushMatrix()
{
}
void mitk::SimulationDrawTool::popMatrix()
{
}
void mitk::SimulationDrawTool::multMatrix(float*)
{
}
void mitk::SimulationDrawTool::scale(float)
{
}
void mitk::SimulationDrawTool::setMaterial(const Vec4f&, std::string)
{
}
void mitk::SimulationDrawTool::resetMaterial(const Vec4f&, std::string)
{
}
void mitk::SimulationDrawTool::setPolygonMode(int mode, bool wireframe)
{
if (!m_Update)
return;
m_PolygonMode = mode;
m_Wireframe = wireframe;
}
void mitk::SimulationDrawTool::setLightingEnabled(bool)
{
}
void mitk::SimulationDrawTool::writeOverlayText(int, int, unsigned int, const Vec4f&, const char*)
{
}
diff --git a/Modules/Simulation/mitkSimulationDrawTool.h b/Modules/Simulation/mitkSimulationDrawTool.h
index 948638a254..ae23cfd035 100644
--- a/Modules/Simulation/mitkSimulationDrawTool.h
+++ b/Modules/Simulation/mitkSimulationDrawTool.h
@@ -1,107 +1,110 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkSimulationDrawTool_h
#define mitkSimulationDrawTool_h
#include <SimulationExports.h>
#include <sofa/core/visual/DrawTool.h>
#include <vtkActor.h>
#include <vtkSmartPointer.h>
class vtkProperty;
namespace mitk
{
/** \brief Utility class used by SOFA classes to draw objects other than visual models.
*
* Implements the <tt>sofa::core::visual::DrawTool</tt> interface and replaces the default SOFA OpenGL implementation <tt>sofa::core::visual::DrawToolGL</tt>.
* All draw methods create a VTK actor and append it to an internal list which can be queried by calling GetActors() to finally draw them.
* In contrary to the original concept of <tt>DrawToolGL</tt>, which is set once during initialization of SOFA applications, every mitk::Simulation has its own exclusive copy of mitk::SimulationDrawTool.
* Since SOFA can handle only a single <tt>DrawTool</tt> at once it must be ensured that the correct mitk::SimulationDrawTool is set when switching the active simulation.
*
* Each draw method checks if it is necessary to generate a new up-to-date VTK actor, i.e. after a simulation step, or if it is sufficient to use the already generated one.
* This decision is controlled through the methods Reset() and DisableUpdate().
* The former method must be called right before a simulation step and mitk::SimulationMapper3D calls the latter method during rendering to disable unnecessary updates until the next simulation step.
*/
class Simulation_EXPORT SimulationDrawTool : public sofa::core::visual::DrawTool
{
public:
SimulationDrawTool();
~SimulationDrawTool();
/** \brief Disables creation of new VTK actors when calling draw methods.
*/
void DisableUpdate();
/** \brief Returns current list of VTK actors which were generated by draw methods since the last reset.
*
* \note Do not delete the VTK actors returned by this method.
*/
std::vector<vtkSmartPointer<vtkActor> > GetActors() const;
/** \brief Clears internal lists of current VTK objects and enables creation of new VTK actors when calling draw methods.
*/
void Reset();
void drawPoints(const std::vector<Vector3>& points, float pointSize, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
+ void drawPoints(const std::vector<Vector3>& points, float pointSize, const std::vector<Vec4f> colors);
void drawLines(const std::vector<Vector3>& points, float lineWidth, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawLines(const std::vector<Vector3>& points, const std::vector<Vec2i>& indices, float lineWidth, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawTriangles(const std::vector<Vector3>& points, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawTriangles(const std::vector<Vector3>& points, const Vector3 normal, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawTriangles(const std::vector<Vector3>& points, const std::vector<Vec3i>& indices, const std::vector<Vector3>& normals, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawTriangles(const std::vector<Vector3>& points, const std::vector<Vector3>& normals, const std::vector<Vec4f>& colors);
void drawTriangleStrip(const std::vector<Vector3>& points, const std::vector<Vector3>& normals, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawTriangleFan(const std::vector<Vector3>& points, const std::vector<Vector3>& normals, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawFrame(const Vector3& position, const Quaternion& orientation, const Vec3f& size);
+ void drawFrame(const Vector3& position, const Quaternion& orientation, const Vec3f& size, const Vec4f& color);
void drawSpheres(const std::vector<Vector3>& points, const std::vector<float>& radii, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawSpheres(const std::vector<Vector3>& points, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawCone(const Vector3& point1, const Vector3& point2, float radius1, float radius2, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16);
void drawCube(const float& edgeRadius, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), const int& subdivisions = 16);
void drawCylinder(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16);
void drawCapsule(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16);
void drawArrow(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16);
void drawPlus(const float& edgeRadius, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), const int& subdivisions = 16);
void drawPoint(const Vector3& position, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawPoint(const Vector3& position, const Vector3& normal, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawTriangle(const Vector3& point1, const Vector3& point2, const Vector3& point3, const Vector3& normal);
void drawTriangle(const Vector3& point1, const Vector3& point2, const Vector3& point3, const Vector3& normal, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
void drawTriangle(const Vector3& point1, const Vector3& point2, const Vector3& point3, const Vector3& normal, const Vec4f& color1, const Vec4f& color2, const Vec4f& color3);
void drawSphere(const Vector3& position, float radius);
+ void drawBoundingBox(const Vector3& min, const Vector3& max);
void pushMatrix();
void popMatrix();
void multMatrix(float* matrix);
void scale(float factor);
void setMaterial(const Vec4f& color, std::string name = "");
void resetMaterial(const Vec4f& color, std::string name = "");
void setPolygonMode(int mode, bool wireframe);
void setLightingEnabled(bool isEnabled);
void writeOverlayText(int x, int y, unsigned int fontSize, const Vec4f& color, const char* text);
private:
SimulationDrawTool(const SimulationDrawTool&);
SimulationDrawTool& operator=(const SimulationDrawTool&);
void InitProperty(vtkProperty* property) const;
std::vector<vtkSmartPointer<vtkActor> > m_Actors;
int m_PolygonMode;
bool m_Wireframe;
bool m_Update;
};
}
#endif
diff --git a/Modules/Simulation/mitkSimulationMapper3D.h b/Modules/Simulation/mitkSimulationMapper3D.h
index d9b854218b..464810a818 100644
--- a/Modules/Simulation/mitkSimulationMapper3D.h
+++ b/Modules/Simulation/mitkSimulationMapper3D.h
@@ -1,65 +1,65 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkSimulationMapper3D_h
#define mitkSimulationMapper3D_h
#include <mitkVtkMapper3D.h>
#include <SimulationExports.h>
#include <vtkSmartPointer.h>
#include <vtkPropAssembly.h>
namespace mitk
{
class Simulation_EXPORT SimulationMapper3D : public VtkMapper3D
{
class LocalStorage
{
public:
LocalStorage();
~LocalStorage();
vtkSmartPointer<vtkPropAssembly> m_VtkProp;
private:
LocalStorage(const LocalStorage&);
LocalStorage& operator=(const LocalStorage&);
};
public:
static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false);
mitkClassMacro(SimulationMapper3D, VtkMapper3D);
itkNewMacro(Self);
void ApplyProperties(vtkActor* actor, BaseRenderer* renderer);
vtkProp* GetVtkProp(BaseRenderer* renderer);
protected:
void GenerateDataForRenderer(BaseRenderer* renderer);
private:
SimulationMapper3D();
~SimulationMapper3D();
SimulationMapper3D(const Self&);
Self& operator=(const Self&);
- mitk::Mapper::LocalStorageHandler<LocalStorage> m_LocalStorageHandler;
+ mitk::LocalStorageHandler<LocalStorage> m_LocalStorageHandler;
};
}
#endif
diff --git a/Modules/Simulation/mitkSimulationObjectFactory.cpp b/Modules/Simulation/mitkSimulationObjectFactory.cpp
index ff1c0cef4b..0e70e52e6e 100644
--- a/Modules/Simulation/mitkSimulationObjectFactory.cpp
+++ b/Modules/Simulation/mitkSimulationObjectFactory.cpp
@@ -1,128 +1,136 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSimulation.h"
#include "mitkSimulationMapper3D.h"
-#include "mitkSimulationObjectFactory.h"
#include "mitkSimulationModel.h"
+#include "mitkSimulationObjectFactory.h"
+#include "mitkSimulationTemplate.h"
#include <mitkCoreObjectFactory.h>
#include <sofa/component/init.h>
#include <sofa/core/ObjectFactory.h>
#include <sofa/simulation/common/xml/initXml.h>
+static void InitializeSOFA()
+{
+ sofa::component::init();
+ sofa::simulation::xml::initXml();
+
+ int SimulationModelClass = sofa::core::RegisterObject("").add<mitk::SimulationModel>();
+ sofa::core::ObjectFactory::AddAlias("OglModel", "SimulationModel", true);
+ sofa::core::ObjectFactory::AddAlias("VisualModel", "SimulationModel", true);
+}
+
mitk::SimulationObjectFactory::SimulationObjectFactory()
- : m_SimulationIOFactory(SimulationIOFactory::New())
+ : m_SimulationIOFactory(SimulationIOFactory::New()),
+ m_SimulationTemplateIOFactory(SimulationTemplateIOFactory::New())
{
itk::ObjectFactoryBase::RegisterFactory(m_SimulationIOFactory);
+ itk::ObjectFactoryBase::RegisterFactory(m_SimulationTemplateIOFactory);
- const std::string description = "SOFA Scene Files";
+ std::string description = "SOFA Scene Files";
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.scn", description));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.xml", description));
- sofa::component::init();
- sofa::simulation::xml::initXml();
+ description = "SOFA Scene File Templates";
+ m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.scn.template", description));
+ m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.xml.template", description));
- int SimulationModelClass = sofa::core::RegisterObject("").add<SimulationModel>();
- sofa::core::ObjectFactory::AddAlias("OglModel", "SimulationModel", true);
- sofa::core::ObjectFactory::AddAlias("VisualModel", "SimulationModel", true);
+ InitializeSOFA();
}
mitk::SimulationObjectFactory::~SimulationObjectFactory()
{
+ itk::ObjectFactoryBase::UnRegisterFactory(m_SimulationTemplateIOFactory);
itk::ObjectFactoryBase::UnRegisterFactory(m_SimulationIOFactory);
}
mitk::Mapper::Pointer mitk::SimulationObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId slotId)
{
mitk::Mapper::Pointer mapper;
if (dynamic_cast<Simulation*>(node->GetData()) != NULL)
{
if (slotId == mitk::BaseRenderer::Standard3D)
mapper = mitk::SimulationMapper3D::New();
if (mapper.IsNotNull())
mapper->SetDataNode(node);
}
return mapper;
}
const char* mitk::SimulationObjectFactory::GetDescription() const
{
return "mitk::SimulationObjectFactory";
}
const char* mitk::SimulationObjectFactory::GetFileExtensions()
{
std::string fileExtensions;
this->CreateFileExtensions(m_FileExtensionsMap, fileExtensions);
return fileExtensions.c_str();
}
mitk::CoreObjectFactoryBase::MultimapType mitk::SimulationObjectFactory::GetFileExtensionsMap()
{
return m_FileExtensionsMap;
}
const char* mitk::SimulationObjectFactory::GetITKSourceVersion() const
{
return ITK_SOURCE_VERSION;
}
const char* mitk::SimulationObjectFactory::GetSaveFileExtensions()
{
std::string saveFileExtensions;
this->CreateFileExtensions(m_FileExtensionsMap, saveFileExtensions);
return saveFileExtensions.c_str();
}
mitk::CoreObjectFactoryBase::MultimapType mitk::SimulationObjectFactory::GetSaveFileExtensionsMap()
{
return m_SaveFileExtensionsMap;
}
void mitk::SimulationObjectFactory::SetDefaultProperties(mitk::DataNode* node)
{
if (node != NULL)
{
if (dynamic_cast<Simulation*>(node->GetData()) != NULL)
+ {
SimulationMapper3D::SetDefaultProperties(node);
+ }
+ else if (dynamic_cast<SimulationTemplate*>(node->GetData()) != NULL)
+ {
+ SimulationTemplate* simulationTemplate = static_cast<SimulationTemplate*>(node->GetData());
+ simulationTemplate->SetProperties(node);
+ }
}
}
-class RegisterSimulationObjectFactory
+void mitk::RegisterSimulationObjectFactory()
{
-public:
- RegisterSimulationObjectFactory()
- : m_Factory(mitk::SimulationObjectFactory::New())
- {
- mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
- }
+ static bool alreadyRegistered = false;
- ~RegisterSimulationObjectFactory()
+ if (!alreadyRegistered)
{
- mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory);
+ mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::SimulationObjectFactory::New());
+ alreadyRegistered = true;
}
-
-private:
- RegisterSimulationObjectFactory(const RegisterSimulationObjectFactory&);
- RegisterSimulationObjectFactory& operator=(const RegisterSimulationObjectFactory&);
-
- mitk::SimulationObjectFactory::Pointer m_Factory;
-};
-
-static RegisterSimulationObjectFactory registerSimulationObjectFactory;
+}
diff --git a/Modules/Simulation/mitkSimulationObjectFactory.h b/Modules/Simulation/mitkSimulationObjectFactory.h
index 501eb21f84..c07742ed6b 100644
--- a/Modules/Simulation/mitkSimulationObjectFactory.h
+++ b/Modules/Simulation/mitkSimulationObjectFactory.h
@@ -1,53 +1,57 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkSimulationObjectFactory_h
#define mitkSimulationObjectFactory_h
#include "mitkSimulationIOFactory.h"
+#include "mitkSimulationTemplateIOFactory.h"
#include <mitkCoreObjectFactoryBase.h>
namespace mitk
{
class Simulation_EXPORT SimulationObjectFactory : public CoreObjectFactoryBase
{
public:
mitkClassMacro(SimulationObjectFactory, CoreObjectFactoryBase);
itkFactorylessNewMacro(Self);
Mapper::Pointer CreateMapper(DataNode* node, MapperSlotId slotId);
const char* GetDescription() const;
const char* GetFileExtensions();
MultimapType GetFileExtensionsMap();
const char* GetITKSourceVersion() const;
const char* GetSaveFileExtensions();
MultimapType GetSaveFileExtensionsMap();
void SetDefaultProperties(DataNode* node);
private:
SimulationObjectFactory();
~SimulationObjectFactory();
SimulationObjectFactory(const Self&);
Self& operator=(const Self&);
SimulationIOFactory::Pointer m_SimulationIOFactory;
+ SimulationTemplateIOFactory::Pointer m_SimulationTemplateIOFactory;
MultimapType m_FileExtensionsMap;
MultimapType m_SaveFileExtensionsMap;
};
+
+ Simulation_EXPORT void RegisterSimulationObjectFactory();
}
#endif
diff --git a/Modules/Simulation/mitkSimulationPropAssemblyVisitor.h b/Modules/Simulation/mitkSimulationPropAssemblyVisitor.h
index 5bb8be8294..5183584802 100644
--- a/Modules/Simulation/mitkSimulationPropAssemblyVisitor.h
+++ b/Modules/Simulation/mitkSimulationPropAssemblyVisitor.h
@@ -1,43 +1,49 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkSimulationPropAssemblyVisitor_h
#define mitkSimulationPropAssemblyVisitor_h
#include <SimulationExports.h>
#include <sofa/simulation/common/Visitor.h>
class vtkPropAssembly;
namespace mitk
{
+ /** \brief Collects all VTK actors of all simulation models (mitk::SimulationModel) present in a simulation scene.
+ */
class Simulation_EXPORT SimulationPropAssemblyVisitor : public sofa::simulation::Visitor
{
public:
+ /** \brief Sole public constructor.
+ *
+ * \param[in] propAssembly VTK prop assembly to which all found VTK actors will be appended as parts.
+ */
explicit SimulationPropAssemblyVisitor(vtkPropAssembly* propAssembly, const sofa::core::ExecParams* params = sofa::core::ExecParams::defaultInstance());
~SimulationPropAssemblyVisitor();
Result processNodeTopDown(sofa::simulation::Node* node);
private:
SimulationPropAssemblyVisitor(const SimulationPropAssemblyVisitor&);
SimulationPropAssemblyVisitor& operator=(const SimulationPropAssemblyVisitor&);
vtkPropAssembly* m_PropAssembly;
};
}
#endif
diff --git a/Modules/Simulation/mitkSimulationReader.cpp b/Modules/Simulation/mitkSimulationReader.cpp
index c2f1c84b1f..88046a5ea7 100644
--- a/Modules/Simulation/mitkSimulationReader.cpp
+++ b/Modules/Simulation/mitkSimulationReader.cpp
@@ -1,114 +1,126 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSimulation.h"
#include "mitkSimulationReader.h"
#include <algorithm>
#include <sofa/core/visual/VisualParams.h>
#include <sofa/helper/system/SetDirectory.h>
bool mitk::SimulationReader::CanReadFile(const std::string& filename, const std::string&, const std::string&)
{
std::string::size_type length = filename.length();
if (length < 5)
return false;
std::string ext = filename.substr(length - 4);
std::transform(ext.begin(), ext.end(), ext.begin(), tolower);
if (ext == ".scn" || ext == ".xml")
return true;
return false;
}
mitk::SimulationReader::SimulationReader()
{
mitk::Simulation::Pointer output = mitk::Simulation::New();
this->SetNumberOfRequiredOutputs(1);
this->SetNthOutput(0, output.GetPointer());
}
mitk::SimulationReader::~SimulationReader()
{
}
void mitk::SimulationReader::GenerateData()
{
- Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(this->GetOutput(0));
+ Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(this->GetOutput());
sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
sofa::simulation::Simulation::SPtr currentSofaSimulation = sofa::simulation::getSimulation();
sofa::core::visual::VisualParams* visualParams = sofa::core::visual::VisualParams::defaultInstance();
sofa::core::visual::DrawTool* currentDrawTool = visualParams->drawTool();
simulation->SetAsActiveSimulation();
std::string path = sofa::helper::system::SetDirectory::GetParentDir(m_FileName.c_str());
sofa::helper::system::DataRepository.addFirstPath(path);
sofa::simulation::Node::SPtr rootNode = sofa::core::objectmodel::SPtr_dynamic_cast<sofa::simulation::Node>(sofaSimulation->load(m_FileName.c_str()));
if (rootNode == NULL)
{
sofa::helper::system::DataRepository.removePath(path);
mitkThrow() << "Could not load '" << m_FileName << "'!";
}
simulation->SetRootNode(rootNode.get());
simulation->SetDefaultDT(rootNode->getDt());
sofaSimulation->init(rootNode.get());
sofa::helper::system::DataRepository.removePath(path);
sofa::simulation::setSimulation(currentSofaSimulation.get());
visualParams->drawTool() = currentDrawTool;
}
void mitk::SimulationReader::GenerateOutputInformation()
{
}
const char* mitk::SimulationReader::GetFileName() const
{
return m_FileName.c_str();
}
void mitk::SimulationReader::SetFileName(const char* aFileName)
{
m_FileName = aFileName;
}
const char* mitk::SimulationReader::GetFilePattern() const
{
return m_FilePattern.c_str();
}
void mitk::SimulationReader::SetFilePattern(const char* aFilePattern)
{
m_FilePattern = aFilePattern;
}
const char* mitk::SimulationReader::GetFilePrefix() const
{
return m_FilePrefix.c_str();
}
void mitk::SimulationReader::SetFilePrefix(const char* aFilePrefix)
{
m_FilePrefix = aFilePrefix;
}
+
+mitk::BaseDataSource::DataObjectPointer mitk::SimulationReader::MakeOutput(DataObjectPointerArraySizeType)
+{
+ return mitk::Simulation::New().GetPointer();
+}
+
+mitk::BaseDataSource::DataObjectPointer mitk::SimulationReader::MakeOutput(const DataObjectIdentifierType& name)
+{
+ return this->IsIndexedOutputName(name)
+ ? this->MakeOutput(this->MakeIndexFromOutputName(name))
+ : mitk::Simulation::New().GetPointer();
+}
diff --git a/Modules/Simulation/mitkSimulationReader.h b/Modules/Simulation/mitkSimulationReader.h
index 8d8783ac6a..adb1dcfe8d 100644
--- a/Modules/Simulation/mitkSimulationReader.h
+++ b/Modules/Simulation/mitkSimulationReader.h
@@ -1,59 +1,63 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkSimulationReader_h
#define mitkSimulationReader_h
-#include <mitkBaseProcess.h>
+#include <mitkBaseDataSource.h>
#include <mitkFileReader.h>
+#include <SimulationExports.h>
namespace mitk
{
- class Simulation_EXPORT SimulationReader : public BaseProcess, FileReader
+ class Simulation_EXPORT SimulationReader : public BaseDataSource, FileReader
{
public:
static bool CanReadFile(const std::string& filename, const std::string& filePrefix, const std::string& filePattern);
- mitkClassMacro(SimulationReader, BaseProcess);
+ mitkClassMacro(SimulationReader, BaseDataSource);
itkNewMacro(Self);
const char* GetFileName() const;
void SetFileName(const char* aFileName);
const char* GetFilePattern() const;
void SetFilePattern(const char* aFilePattern);
const char* GetFilePrefix() const;
void SetFilePrefix(const char* aFilePrefix);
+ BaseDataSource::DataObjectPointer MakeOutput(DataObjectPointerArraySizeType);
+ BaseDataSource::DataObjectPointer MakeOutput(const DataObjectIdentifierType& name);
+
protected:
void GenerateData();
void GenerateOutputInformation();
private:
SimulationReader();
~SimulationReader();
SimulationReader(const Self &);
Self & operator=(const Self &);
std::string m_FileName;
std::string m_FilePattern;
std::string m_FilePrefix;
};
}
#endif
diff --git a/Modules/Simulation/mitkSimulationTemplate.cpp b/Modules/Simulation/mitkSimulationTemplate.cpp
new file mode 100644
index 0000000000..ff17db6d05
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationTemplate.cpp
@@ -0,0 +1,416 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkSimulationTemplate.h"
+#include <mitkProperties.h>
+#include <sstream>
+#include <vector>
+
+typedef std::vector<std::pair<std::string::size_type, std::string::size_type> > TemplateIndex;
+typedef std::vector<std::pair<std::string, mitk::BaseProperty::Pointer> > VariableContents;
+
+static TemplateIndex CreateTemplateIndex(const std::string& contents)
+{
+ TemplateIndex templateIndex;
+
+ std::string::size_type begin = 0;
+ begin = contents.find('{', 0);
+
+ while (begin != std::string::npos)
+ {
+ std::string::size_type end = contents.find('}', begin);
+
+ if (end == std::string::npos)
+ mitkThrow() << "Could not create template index: Expected closing brace before end of file!";
+
+ if (contents.substr(begin + 1, end).find('{') != std::string::npos)
+ mitkThrow() << "Could not create template index: Expected closing brace before opening brace!";
+
+ templateIndex.push_back(std::make_pair(begin, ++end - begin));
+
+ begin = contents.find('{', end);
+ }
+
+ return templateIndex;
+}
+
+static std::vector<std::string> ParseStaticContents(const std::string& contents, const TemplateIndex& templateIndex)
+{
+ std::vector<std::string> staticContents;
+ std::string::size_type index = 0;
+
+ for (TemplateIndex::const_iterator it = templateIndex.begin(); it != templateIndex.end(); ++it)
+ {
+ staticContents.push_back(contents.substr(index, it->first - index));
+ index = it->first + it->second;
+ }
+
+ staticContents.push_back(contents.substr(index));
+
+ return staticContents;
+}
+
+static std::size_t CountSingleQuotationMarks(const std::string& string)
+{
+ if (string.empty())
+ return 0;
+
+ const std::string::size_type length = string.length();
+ std::size_t n = string[0] == '\'' ? 1 : 0;
+
+ for (std::string::size_type i = 1; i != length; ++i)
+ {
+ if (string[i] == '\'' && string[i - 1] != '\\')
+ ++n;
+ }
+
+ return n;
+}
+
+static bool IsEven(std::size_t number)
+{
+ return number % 2 == 0;
+}
+
+static bool ValueExists(const std::string& templ, const std::string& valueName)
+{
+ std::string::size_type index = templ.find(valueName);
+ std::string::size_type definiteIndex = std::string::npos;
+
+ while (index != std::string::npos)
+ {
+ if (IsEven(CountSingleQuotationMarks(templ.substr(0, index))))
+ {
+ definiteIndex = index;
+ break;
+ }
+
+ index = templ.find(valueName, index + 1);
+ }
+
+ return definiteIndex != std::string::npos;
+}
+
+static std::string UnescapeSingleQuotationMarks(const std::string& escapedString)
+{
+ std::string::size_type length = escapedString.length();
+ std::string::size_type max_i = length - 2;
+
+ std::vector<char> unescapedString;
+ unescapedString.reserve(length);
+
+ for (std::string::size_type i = 0; i != length; ++i)
+ {
+ char c = escapedString[i];
+
+ if (c == '\\' && i <= max_i && escapedString[i + 1] == '\'')
+ continue;
+
+ unescapedString.push_back(c);
+ }
+
+ return std::string(unescapedString.begin(), unescapedString.end());
+}
+
+static std::string ParseValue(const std::string& templ, const std::string& valueName)
+{
+ const char* spaces = " \t\n";
+
+ std::string::size_type index = templ.find(valueName);
+ std::string::size_type definiteIndex = std::string::npos;
+
+ while (index != std::string::npos)
+ {
+ if (IsEven(CountSingleQuotationMarks(templ.substr(0, index))))
+ {
+ if (definiteIndex != std::string::npos)
+ mitkThrow() << "Could not parse " << templ << ": " << valueName << " is ambiguous!";
+
+ definiteIndex = index;
+ }
+
+ index = templ.find(valueName, index + 1);
+ }
+
+ if (definiteIndex == std::string::npos)
+ mitkThrow() << "Could not parse " << templ << ": " << valueName << " not found!";
+
+ index = templ.find_first_not_of(spaces, definiteIndex + valueName.length());
+
+ if (index == std::string::npos || templ[index] != '=')
+ mitkThrow() << "Could not parse " << templ << ": Expected assignment to " << valueName << "!";
+
+ index = templ.find_first_not_of(spaces, index + 1);
+
+ if (index == std::string::npos || templ[index] != '\'')
+ mitkThrow() << "Could not parse " << templ << ": Value of " << valueName << " is not enclosed within single quotation marks!";
+
+ std::string::size_type index2 = std::string::npos;
+ std::string::size_type length = templ.length();
+
+ for (std::string::size_type i = ++index; i != length; ++i)
+ {
+ if (templ[i] == '\'' && templ[i - 1] != '\\')
+ {
+ index2 = i;
+ break;
+ }
+ }
+
+ return UnescapeSingleQuotationMarks(templ.substr(index, index2 - index));
+}
+
+template <typename T>
+static T lexical_cast(const std::string& string)
+{
+ std::istringstream sstream(string);
+ T value;
+
+ sstream >> value;
+
+ if (sstream.fail())
+ mitkThrow() << "Lexical cast failed for '" << string << "'!";
+
+ return value;
+}
+
+static std::pair<std::string, mitk::BaseProperty::Pointer> ParseReference(const std::string& ref)
+{
+ std::string id = "{}";
+ std::string string = ref.substr(2, ref.length() - 4);
+
+ if (string.empty())
+ mitkThrow() << "Could not parse " << ref << ": Reference is empty!";
+
+ return std::make_pair(id, mitk::StringProperty::New(string));
+}
+
+static std::pair<std::string, mitk::BaseProperty::Pointer> ParseTemplate(const std::string& templ)
+{
+ std::string::size_type length = templ.length();
+
+ if (length < 4) // {''}
+ mitkThrow() << "Could not parse " << templ << ": Too short to be reference or template!";
+
+ if(!IsEven(CountSingleQuotationMarks(templ)))
+ mitkThrow() << "Could not parse " << templ << ": Number of single quotation marks is odd!";
+
+ if(templ[1] == '\'')
+ {
+ if (templ[length - 2] != '\'')
+ mitkThrow() << "Could not parse " << templ << ": Reference does not end with '}!";
+
+ return ParseReference(templ);
+ }
+
+ if (length < 7) // {id=''}
+ mitkThrow() << "Could not parse " << templ << ": Too short to be template!";
+
+ std::string id = ParseValue(templ, "id");
+
+ if (id.empty())
+ mitkThrow() << "Could not parse " << templ << ": Id is empty!";
+
+ std::string type = ValueExists(templ, "type")
+ ? ParseValue(templ, "type")
+ : "string";
+
+ std::string defaultValue = ValueExists(templ, "default")
+ ? ParseValue(templ, "default")
+ : "";
+
+ mitk::BaseProperty::Pointer property;
+
+ if (type == "float")
+ {
+ float value = !defaultValue.empty()
+ ? lexical_cast<float>(defaultValue)
+ : 0.0;
+
+ property = mitk::FloatProperty::New(value);
+ }
+ else if (type == "int")
+ {
+ int value = !defaultValue.empty()
+ ? lexical_cast<int>(defaultValue)
+ : 0.0;
+
+ property = mitk::IntProperty::New(value);
+ }
+ else if (type == "string")
+ {
+ std::string value = !defaultValue.empty()
+ ? defaultValue
+ : "";
+
+ property = mitk::StringProperty::New(value);
+ }
+
+ if (property.IsNull())
+ mitkThrow() << "Could not parse " << templ << ": Unknown type '" << type << "'!";
+
+ return std::make_pair(id, property);
+}
+
+static VariableContents ParseVariableContents(const std::string& contents, const TemplateIndex& templateIndex)
+{
+ VariableContents variableContents;
+
+ for (TemplateIndex::const_iterator it = templateIndex.begin(); it != templateIndex.end(); ++it)
+ {
+ std::string templ = contents.substr(it->first, it->second);
+ variableContents.push_back(ParseTemplate(templ));
+ }
+
+ return variableContents;
+}
+
+template <typename T1, typename T2>
+class FirstEqualTo
+{
+public:
+ FirstEqualTo(const T1& value)
+ : m_Value(value)
+ {
+ }
+
+ bool operator()(const std::pair<T1, T2>& pair) const
+ {
+ return pair.first == m_Value;
+ }
+
+private:
+ T1 m_Value;
+};
+
+mitk::SimulationTemplate::SimulationTemplate()
+ : m_IsInitialized(false)
+{
+}
+
+mitk::SimulationTemplate::~SimulationTemplate()
+{
+}
+
+std::string mitk::SimulationTemplate::CreateSimulation() const
+{
+ if (!m_IsInitialized)
+ {
+ MITK_DEBUG << "Simulation template is not initialized!";
+ return "";
+ }
+
+ std::string contents;
+
+ for (VariableContents::size_type i = 0; i < m_VariableContents.size(); ++i)
+ {
+ contents += m_StaticContents[i];
+
+ if (m_VariableContents[i].first == "{}")
+ {
+ VariableContents::const_iterator it = std::find_if(m_VariableContents.begin(), m_VariableContents.end(),
+ FirstEqualTo<std::string, mitk::BaseProperty::Pointer>(m_VariableContents[i].second->GetValueAsString()));
+
+ if (it == m_VariableContents.end())
+ {
+ MITK_DEBUG << "Template '" << m_VariableContents[i].second << "' not found!";
+ return "";
+ }
+
+ contents += it->second->GetValueAsString();
+ }
+ else
+ {
+ contents += m_VariableContents[i].second->GetValueAsString();
+ }
+ }
+
+ contents += m_StaticContents.back();
+
+ return contents;
+}
+
+bool mitk::SimulationTemplate::Parse(const std::string& contents)
+{
+ if (m_IsInitialized)
+ {
+ MITK_DEBUG << "Simulation template is already initialized!";
+ return false;
+ }
+
+ TemplateIndex templateIndex = CreateTemplateIndex(contents);
+ std::vector<std::string> staticContents = ParseStaticContents(contents, templateIndex);
+ VariableContents variableContents = ParseVariableContents(contents, templateIndex);
+
+ std::swap(m_StaticContents, staticContents);
+ std::swap(m_VariableContents, variableContents);
+ m_IsInitialized = true;
+
+ return true;
+}
+
+bool mitk::SimulationTemplate::RequestedRegionIsOutsideOfTheBufferedRegion()
+{
+ return false;
+}
+
+bool mitk::SimulationTemplate::SetProperties(mitk::DataNode::Pointer dataNode) const
+{
+ if (dataNode.IsNull())
+ {
+ MITK_DEBUG << "Data node does not exist!";
+ return false;
+ }
+
+ if (!m_IsInitialized)
+ {
+ MITK_DEBUG << "Simulation template is not initialized!";
+ return false;
+ }
+
+ if (dynamic_cast<SimulationTemplate*>(dataNode->GetData()) != this)
+ {
+ MITK_DEBUG << "Data node does not own this simulation template!";
+ return false;
+ }
+
+ for(VariableContents::const_iterator it = m_VariableContents.begin(); it != m_VariableContents.end(); ++it)
+ {
+ if (it->first != "{}")
+ dataNode->SetProperty(it->first.c_str(), it->second.GetPointer());
+ }
+
+ return true;
+}
+
+void mitk::SimulationTemplate::SetRequestedRegion(const itk::DataObject*)
+{
+}
+
+void mitk::SimulationTemplate::SetRequestedRegionToLargestPossibleRegion()
+{
+}
+
+void mitk::SimulationTemplate::UpdateOutputInformation()
+{
+ if (this->GetSource().IsNotNull())
+ this->GetSource()->UpdateOutputInformation();
+}
+
+bool mitk::SimulationTemplate::VerifyRequestedRegion()
+{
+ return true;
+}
diff --git a/Modules/Simulation/mitkSimulationTemplate.h b/Modules/Simulation/mitkSimulationTemplate.h
new file mode 100644
index 0000000000..bf3e461782
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationTemplate.h
@@ -0,0 +1,102 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkSimulationTemplate_h
+#define mitkSimulationTemplate_h
+
+#include <mitkBaseData.h>
+#include <mitkBaseProperty.h>
+#include <mitkDataNode.h>
+#include <SimulationExports.h>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace mitk
+{
+ /** \brief %Simulation templates are extended simulation scenes which can contain variables.
+ *
+ * These variables are mapped to properties (mitk::BaseProperty) to be easily adjustable.
+ * A simulation template is an intermediate format and cannot be loaded by SOFA as simulation scene.
+ * However, a simulation scene based on a simulation template can be created easily.
+ *
+ * For information on the syntax of simulation templates, see \ref org_mitk_gui_qt_simulationSimulationTemplates.
+ *
+ * Call Parse() to initialize the class by parsing a simulation scene template.
+ * Parsed templates are represented by properties which you must set manually for the corresponding data node (mitk::DataNode) by calling SetProperties().
+ * To create a simulation scene based on the simulation template call CreateSimulation().
+ */
+ class Simulation_EXPORT SimulationTemplate : public BaseData
+ {
+ public:
+ mitkClassMacro(SimulationTemplate, BaseData);
+ itkNewMacro(Self);
+
+ /** \brief Create simulation scene based on parsed simulation scene template.
+ *
+ * You must parse a simulation scene template before calling this method.
+ * In case of error this method writes a message to MITK_DEBUG and returns an empty string.
+ *
+ * \return %Simulation scene as string or empty string in case of error.
+ * \sa Parse()
+ */
+ std::string CreateSimulation() const;
+
+ /** \brief Initialize class by parsing a simulation scene template.
+ *
+ * For more information on the syntax of simulation templates, see \ref org_mitk_gui_qt_simulationSimulationTemplates.
+ * An mitk::Exception with a meaningful description is thrown for any possible error related to parsing.
+ *
+ * \param[in] contents %Simulation scene template.
+ * \exception mitk::Exception An error occurred during parsing.
+ * \return False if class is already initialized.
+ */
+ bool Parse(const std::string& contents);
+
+ bool RequestedRegionIsOutsideOfTheBufferedRegion();
+
+ /** \brief Add properties which represent simulation template variables to given data node.
+ *
+ * You must parse a simulation scene template before calling this method.
+ * In case of error this method writes a message to MITK_DEBUG and returns false.
+ *
+ * \return False if class is not initialized, data node is null, or data node doesn't own this simulatiom template.
+ * \sa Parse()
+ */
+ bool SetProperties(DataNode::Pointer dataNode) const;
+
+ void SetRequestedRegion(const itk::DataObject* data);
+
+ void SetRequestedRegionToLargestPossibleRegion();
+
+ void UpdateOutputInformation();
+
+ bool VerifyRequestedRegion();
+
+ private:
+ SimulationTemplate();
+ ~SimulationTemplate();
+
+ SimulationTemplate(Self&);
+ Self& operator=(const Self&);
+
+ bool m_IsInitialized;
+ std::vector<std::string> m_StaticContents;
+ std::vector<std::pair<std::string, BaseProperty::Pointer> > m_VariableContents;
+ };
+}
+
+#endif
diff --git a/Modules/Simulation/mitkSimulationTemplateIOFactory.cpp b/Modules/Simulation/mitkSimulationTemplateIOFactory.cpp
new file mode 100644
index 0000000000..67ddfd2373
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationTemplateIOFactory.cpp
@@ -0,0 +1,45 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkSimulationTemplateIOFactory.h"
+#include "mitkSimulationTemplateReader.h"
+#include <itkVersion.h>
+#include <mitkIOAdapter.h>
+
+mitk::SimulationTemplateIOFactory::SimulationTemplateIOFactory()
+{
+
+ this->RegisterOverride(
+ "mitkIOAdapter",
+ "mitkSimulationTemplateReader",
+ "Simulation Template IO",
+ true,
+ itk::CreateObjectFunction<IOAdapter<SimulationTemplateReader> >::New());
+}
+
+mitk::SimulationTemplateIOFactory::~SimulationTemplateIOFactory()
+{
+}
+
+const char* mitk::SimulationTemplateIOFactory::GetDescription() const
+{
+ return "mitk::SimulationTemplateIOFactory";
+}
+
+const char* mitk::SimulationTemplateIOFactory::GetITKSourceVersion() const
+{
+ return ITK_SOURCE_VERSION;
+}
diff --git a/Modules/Simulation/mitkSimulationTemplateIOFactory.h b/Modules/Simulation/mitkSimulationTemplateIOFactory.h
new file mode 100644
index 0000000000..b616a1001e
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationTemplateIOFactory.h
@@ -0,0 +1,44 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkSimulationTemplateIOFactory_h
+#define mitkSimulationTemplateIOFactory_h
+
+#include <itkObjectFactoryBase.h>
+#include <mitkCommon.h>
+#include <SimulationExports.h>
+
+namespace mitk
+{
+ class Simulation_EXPORT SimulationTemplateIOFactory : public itk::ObjectFactoryBase
+ {
+ public:
+ mitkClassMacro(SimulationTemplateIOFactory, itk::ObjectFactoryBase);
+ itkFactorylessNewMacro(Self);
+
+ const char* GetDescription() const;
+ const char* GetITKSourceVersion() const;
+
+ private:
+ SimulationTemplateIOFactory();
+ ~SimulationTemplateIOFactory();
+
+ SimulationTemplateIOFactory(const Self&);
+ Self& operator=(const Self&);
+ };
+};
+
+#endif
diff --git a/Modules/Simulation/mitkSimulationTemplateReader.cpp b/Modules/Simulation/mitkSimulationTemplateReader.cpp
new file mode 100644
index 0000000000..2f2da94410
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationTemplateReader.cpp
@@ -0,0 +1,125 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkSimulationTemplate.h"
+#include "mitkSimulationTemplateReader.h"
+#include <algorithm>
+#include <fstream>
+#include <string>
+
+static std::string ReadFile(const std::string& fileName)
+{
+ std::ifstream file(fileName.c_str());
+
+ if (!file.is_open())
+ mitkThrow() << "Could not load '" << fileName << "'!";
+
+ std::string contents;
+
+ file.seekg(0, std::ios::end);
+ contents.resize(file.tellg());
+ file.seekg(0, std::ios::beg);
+ file.read(&contents[0], contents.size());
+
+ file.close();
+
+ if (contents.empty())
+ mitkThrow() << fileName << " is empty!";
+
+ return contents;
+}
+
+bool mitk::SimulationTemplateReader::CanReadFile(const std::string& filename, const std::string&, const std::string&)
+{
+ std::string::size_type length = filename.length();
+
+ if (length < 14)
+ return false;
+
+ std::string ext = filename.substr(length - 13);
+ std::transform(ext.begin(), ext.end(), ext.begin(), tolower);
+
+ if (ext == ".scn.template" || ext == ".xml.template")
+ return true;
+
+ return false;
+}
+
+mitk::SimulationTemplateReader::SimulationTemplateReader()
+{
+ mitk::SimulationTemplate::Pointer output = mitk::SimulationTemplate::New();
+
+ this->SetNumberOfRequiredOutputs(1);
+ this->SetNthOutput(0, output.GetPointer());
+}
+
+mitk::SimulationTemplateReader::~SimulationTemplateReader()
+{
+}
+
+void mitk::SimulationTemplateReader::GenerateData()
+{
+ SimulationTemplate::Pointer simulationTemplate = dynamic_cast<mitk::SimulationTemplate*>(this->GetOutput(0));
+
+ std::string contents = ReadFile(m_FileName);
+ simulationTemplate->Parse(contents);
+}
+
+void mitk::SimulationTemplateReader::GenerateOutputInformation()
+{
+}
+
+const char* mitk::SimulationTemplateReader::GetFileName() const
+{
+ return m_FileName.c_str();
+}
+
+void mitk::SimulationTemplateReader::SetFileName(const char* aFileName)
+{
+ m_FileName = aFileName;
+}
+
+const char* mitk::SimulationTemplateReader::GetFilePattern() const
+{
+ return m_FilePattern.c_str();
+}
+
+void mitk::SimulationTemplateReader::SetFilePattern(const char* aFilePattern)
+{
+ m_FilePattern = aFilePattern;
+}
+
+const char* mitk::SimulationTemplateReader::GetFilePrefix() const
+{
+ return m_FilePrefix.c_str();
+}
+
+void mitk::SimulationTemplateReader::SetFilePrefix(const char* aFilePrefix)
+{
+ m_FilePrefix = aFilePrefix;
+}
+
+mitk::BaseDataSource::DataObjectPointer mitk::SimulationTemplateReader::MakeOutput(DataObjectPointerArraySizeType)
+{
+ return mitk::SimulationTemplate::New().GetPointer();
+}
+
+mitk::BaseDataSource::DataObjectPointer mitk::SimulationTemplateReader::MakeOutput(const DataObjectIdentifierType& name)
+{
+ return this->IsIndexedOutputName(name)
+ ? this->MakeOutput(this->MakeIndexFromOutputName(name))
+ : mitk::SimulationTemplate::New().GetPointer();
+}
diff --git a/Modules/Simulation/mitkSimulationReader.h b/Modules/Simulation/mitkSimulationTemplateReader.h
similarity index 67%
copy from Modules/Simulation/mitkSimulationReader.h
copy to Modules/Simulation/mitkSimulationTemplateReader.h
index 8d8783ac6a..6c8f1b95a8 100644
--- a/Modules/Simulation/mitkSimulationReader.h
+++ b/Modules/Simulation/mitkSimulationTemplateReader.h
@@ -1,59 +1,63 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#ifndef mitkSimulationReader_h
-#define mitkSimulationReader_h
+#ifndef mitkSimulationTemplateReader_h
+#define mitkSimulationTemplateReader_h
-#include <mitkBaseProcess.h>
+#include <mitkBaseDataSource.h>
#include <mitkFileReader.h>
+#include <SimulationExports.h>
namespace mitk
{
- class Simulation_EXPORT SimulationReader : public BaseProcess, FileReader
+ class Simulation_EXPORT SimulationTemplateReader : public BaseDataSource, FileReader
{
public:
static bool CanReadFile(const std::string& filename, const std::string& filePrefix, const std::string& filePattern);
- mitkClassMacro(SimulationReader, BaseProcess);
+ mitkClassMacro(SimulationTemplateReader, BaseDataSource);
itkNewMacro(Self);
const char* GetFileName() const;
void SetFileName(const char* aFileName);
const char* GetFilePattern() const;
void SetFilePattern(const char* aFilePattern);
const char* GetFilePrefix() const;
void SetFilePrefix(const char* aFilePrefix);
+ BaseDataSource::DataObjectPointer MakeOutput(DataObjectPointerArraySizeType);
+ BaseDataSource::DataObjectPointer MakeOutput(const DataObjectIdentifierType& name);
+
protected:
void GenerateData();
void GenerateOutputInformation();
private:
- SimulationReader();
- ~SimulationReader();
+ SimulationTemplateReader();
+ ~SimulationTemplateReader();
- SimulationReader(const Self &);
+ SimulationTemplateReader(const Self &);
Self & operator=(const Self &);
std::string m_FileName;
std::string m_FilePattern;
std::string m_FilePrefix;
};
}
#endif
diff --git a/Modules/ToFHardware/Kinect/mitkKinectController.cpp b/Modules/ToFHardware/Kinect/mitkKinectController.cpp
index 0373d74c28..3a6123c8ee 100644
--- a/Modules/ToFHardware/Kinect/mitkKinectController.cpp
+++ b/Modules/ToFHardware/Kinect/mitkKinectController.cpp
@@ -1,294 +1,290 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkKinectController.h"
#include <XnCppWrapper.h>
namespace mitk
{
class KinectController::KinectControllerPrivate
{
public:
KinectControllerPrivate();
~KinectControllerPrivate();
bool ErrorText(unsigned int error);
//OpenNI related stuff
xn::Context m_Context; ///< OpenNI context
xn::DepthGenerator m_DepthGenerator; ///< Depth generator to access depth image of kinect
xn::ImageGenerator m_ImageGenerator; ///< Image generator to access RGB image of kinect
xn::IRGenerator m_IRGenerator; ///< IR generator to access IR image of kinect
bool m_ConnectionCheck; ///< check if camera is connected or not
bool m_UseIR; ///< flag indicating whether IR image is used or not
unsigned int m_CaptureWidth; ///< image width
unsigned int m_CaptureHeight; ///< image height
};
KinectController::KinectControllerPrivate::KinectControllerPrivate():
m_Context(NULL),
m_DepthGenerator(NULL),
m_ImageGenerator(NULL),
m_IRGenerator(NULL),
m_ConnectionCheck(false),
m_UseIR(false),
m_CaptureWidth(640),
m_CaptureHeight(480)
{
}
KinectController::KinectControllerPrivate::~KinectControllerPrivate()
{
}
bool KinectController::KinectControllerPrivate::ErrorText(unsigned int error)
{
if(error != XN_STATUS_OK)
{
MITK_ERROR << "Kinect Camera Error " << xnGetStatusString(error);
mitkThrow() << "Kinect Camera Error " << xnGetStatusString(error);
return false;
}
else return true;
}
KinectController::KinectController(): d(new KinectControllerPrivate)
{
}
KinectController::~KinectController()
{
delete d;
}
bool KinectController::OpenCameraConnection()
{
if (!d->m_ConnectionCheck)
{
// Initialize the OpenNI status
d->m_ConnectionCheck = d->ErrorText(d->m_Context.Init());
if (!d->m_ConnectionCheck) return false;
// Create a depth generator and set its resolution
XnMapOutputMode DepthMode;
d->m_ConnectionCheck = d->ErrorText(d->m_DepthGenerator.Create(d->m_Context));
if (!d->m_ConnectionCheck) return false;
d->m_DepthGenerator.GetMapOutputMode(DepthMode);
DepthMode.nXRes = xn::Resolution((XnResolution)XN_RES_VGA).GetXResolution();
DepthMode.nYRes = xn::Resolution((XnResolution)XN_RES_VGA).GetYResolution();
d->m_ConnectionCheck = d->ErrorText(d->m_DepthGenerator.SetMapOutputMode(DepthMode));
if (!d->m_ConnectionCheck) return false;
if (d->m_UseIR)
{
// Create the IR generator and set its resolution
d->m_ConnectionCheck = d->ErrorText(d->m_IRGenerator.Create(d->m_Context));
if (!d->m_ConnectionCheck) return false;
XnMapOutputMode IRMode;
d->m_IRGenerator.GetMapOutputMode(IRMode);
IRMode.nXRes = XN_VGA_X_RES;
IRMode.nYRes = XN_VGA_Y_RES;
IRMode.nFPS = 30;
d->m_ConnectionCheck = d->ErrorText(d->m_IRGenerator.SetMapOutputMode(IRMode));
if (!d->m_ConnectionCheck) return false;
}
else
{
// Create an image generator and set its resolution
XnMapOutputMode ImageMode;
d->m_ConnectionCheck = d->ErrorText(d->m_ImageGenerator.Create(d->m_Context));
if (!d->m_ConnectionCheck) return false;
d->m_ImageGenerator.GetMapOutputMode(ImageMode);
ImageMode.nXRes = xn::Resolution((XnResolution)XN_RES_VGA).GetXResolution();
ImageMode.nYRes = xn::Resolution((XnResolution)XN_RES_VGA).GetYResolution();
d->m_ConnectionCheck = d->ErrorText(d->m_ImageGenerator.SetMapOutputMode(ImageMode));
if (!d->m_ConnectionCheck) return false;
}
// Camera registration
if ( d->m_DepthGenerator.IsCapabilitySupported(XN_CAPABILITY_ALTERNATIVE_VIEW_POINT) )
{
if (d->m_UseIR)
{
d->m_ConnectionCheck = d->ErrorText(d->m_DepthGenerator.GetAlternativeViewPointCap().SetViewPoint(d->m_IRGenerator));
//if (!d->m_ConnectionCheck) return false;
}
else
{
d->m_ConnectionCheck = d->ErrorText(d->m_DepthGenerator.GetAlternativeViewPointCap().SetViewPoint(d->m_ImageGenerator));
//if (!d->m_ConnectionCheck) return false;
}
}
else
{
std::cout << "Alternative view point not supported by the depth generator..." << std::endl;
}
if (d->m_UseIR)
{
if ( d->m_IRGenerator.IsCapabilitySupported(XN_CAPABILITY_ALTERNATIVE_VIEW_POINT) )
{
d->m_ConnectionCheck = d->ErrorText(d->m_IRGenerator.GetAlternativeViewPointCap().SetViewPoint(d->m_DepthGenerator));
//if (!d->m_ConnectionCheck) return false;
}
else
{
std::cout << "Alternative view point not supported by the depth generator..." << std::endl;
}
}
- // Mirror data
- d->m_ConnectionCheck = d->ErrorText(d->m_Context.SetGlobalMirror(!d->m_Context.GetGlobalMirror()));
- if (!d->m_ConnectionCheck) return false;
-
// Start data generation
d->m_ConnectionCheck = d->ErrorText(d->m_Context.StartGeneratingAll());
if (!d->m_ConnectionCheck) return false;
// // Update the connected flag
// d->m_ConnectionCheck = true;
}
return d->m_ConnectionCheck;
}
bool KinectController::CloseCameraConnection()
{
d->m_ConnectionCheck = !d->ErrorText(d->m_Context.StopGeneratingAll());
return !d->m_ConnectionCheck;
}
bool KinectController::UpdateCamera()
{
bool updateSuccessful = d->ErrorText(d->m_Context.WaitAndUpdateAll());
xn::DepthMetaData DepthMD;
d->m_DepthGenerator.GetMetaData(DepthMD);
d->m_CaptureWidth = DepthMD.XRes();
d->m_CaptureHeight = DepthMD.YRes();
return updateSuccessful;
}
// TODO flag image
void KinectController::GetDistances(float* distances)
{
xn::DepthMetaData DepthMD;
d->m_DepthGenerator.GetMetaData(DepthMD);
const XnDepthPixel* DepthData = DepthMD.Data();
for (unsigned int i=0; i<d->m_CaptureWidth*d->m_CaptureHeight; i++)
{
distances[i] = DepthData[i];
}
}
void KinectController::GetRgb(unsigned char* rgb)
{
if (!d->m_UseIR)
{
xn::ImageMetaData ImageMD;
d->m_ImageGenerator.GetMetaData(ImageMD);
const XnRGB24Pixel* rgbPixelArray = ImageMD.RGB24Data();
for (int i=0; i<d->m_CaptureWidth*d->m_CaptureHeight; i++)
{
rgb[i*3] = rgbPixelArray[i].nRed;
rgb[i*3+1] = rgbPixelArray[i].nGreen;
rgb[i*3+2] = rgbPixelArray[i].nBlue;
}
}
}
void KinectController::GetAllData(float* distances, float* amplitudes, unsigned char* rgb)
{
// get current distance data
xn::DepthMetaData DepthMD;
d->m_DepthGenerator.GetMetaData(DepthMD);
const XnDepthPixel* DepthData = DepthMD.Data();
// IR data
xn::IRMetaData IRData;
const XnIRPixel* IRPixelData;
// Image data
xn::ImageMetaData ImageMD;
const XnRGB24Pixel* rgbPixelArray;
if (d->m_UseIR)
{
d->m_IRGenerator.GetMetaData(IRData);
IRPixelData = IRData.Data();
}
else
{
// get current rgb data
d->m_ImageGenerator.GetMetaData(ImageMD);
rgbPixelArray = ImageMD.RGB24Data();
}
for (unsigned int i=0; i<d->m_CaptureWidth*d->m_CaptureHeight; i++)
{
distances[i] = DepthData[i];
if (d->m_UseIR)
{
amplitudes[i] = IRPixelData[i];
}
else
{
rgb[i*3] = rgbPixelArray[i].nRed;
rgb[i*3+1] = rgbPixelArray[i].nGreen;
rgb[i*3+2] = rgbPixelArray[i].nBlue;
}
}
}
void KinectController::GetAmplitudes( float* amplitudes )
{
if (d->m_UseIR)
{
xn::IRMetaData IRData;
d->m_IRGenerator.GetMetaData(IRData);
const XnIRPixel* IRPixelData = IRData.Data();
for (unsigned int i=0; i<d->m_CaptureWidth*d->m_CaptureHeight; i++)
{
amplitudes[i] = IRPixelData[i];
}
}
}
void KinectController::GetIntensities( float* intensities )
{
}
unsigned int KinectController::GetCaptureWidth() const
{
return d->m_CaptureWidth;
}
unsigned int KinectController::GetCaptureHeight() const
{
return d->m_CaptureHeight;
}
bool KinectController::GetUseIR() const
{
return d->m_UseIR;
}
void KinectController::SetUseIR(bool useIR)
{
if (d->m_UseIR!=useIR)
{
d->m_UseIR = useIR;
this->Modified();
}
}
}
diff --git a/Modules/ToFHardware/Kinect/mitkKinectDeviceFactory.h b/Modules/ToFHardware/Kinect/mitkKinectDeviceFactory.h
index eeff536474..e58b73a102 100644
--- a/Modules/ToFHardware/Kinect/mitkKinectDeviceFactory.h
+++ b/Modules/ToFHardware/Kinect/mitkKinectDeviceFactory.h
@@ -1,87 +1,92 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkKinectDeviceFactory_h
#define __mitkKinectDeviceFactory_h
#include "mitkKinectModuleExports.h"
#include "mitkKinectDevice.h"
#include "mitkAbstractToFDeviceFactory.h"
#include <mitkCameraIntrinsics.h>
#include <mitkCameraIntrinsicsProperty.h>
namespace mitk
{
/**
* \brief KinectDeviceFactory is an implementation of the factory pattern to generate Microsoft Kinect devices.
* KinectDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
* This offers users the oppertunity to generate new KinectDevices via a global instance of this factory.
* @ingroup ToFHardware
*/
class MITK_KINECTMODULE_EXPORT KinectDeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
public:
KinectDeviceFactory()
{
this->m_DeviceNumber = 1;
}
/*!
\brief Defining the Factorie´s Name, here for the Kinect.
*/
std::string GetFactoryName()
{
return std::string("Kinect Factory");
}
//Interating the Device name on calling the Factory
std::string GetCurrentDeviceName()
{
std::stringstream name;
if (m_DeviceNumber>1)
{
name << "Kinect " << m_DeviceNumber;
}
else
{
name << "Kinect ";
}
m_DeviceNumber++;
return name.str();
}
private:
/*!
\brief Create an instance of a KinectDevice.
*/
ToFCameraDevice::Pointer createToFCameraDevice()
{
KinectDevice::Pointer device = KinectDevice::New();
//Set default camera intrinsics for the kinect RGB camera.
//(OpenNI warps the distance data into the RGB space).
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
pathToDefaulCalibrationFile.append("/CalibrationFiles/Kinect_RGB_camera.xml");
cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
+ device->SetBoolProperty("HasRGBImage", true);
+ device->SetBoolProperty("HasAmplitudeImage", false);
+ device->SetBoolProperty("HasIntensityImage", false);
+ device->SetBoolProperty("KinectReconstructionMode", true);
+
return device.GetPointer();
}
//Member variable as variable for our DeviceNumber
int m_DeviceNumber;
};
}
#endif
diff --git a/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESAController.cpp b/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESAController.cpp
index 873ed4980b..e70fe3c957 100644
--- a/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESAController.cpp
+++ b/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESAController.cpp
@@ -1,123 +1,123 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraMESAController.h"
#include <libMesaSR.h>
#include <string.h>
CMesaDevice* m_MESAHandle=0;
namespace mitk
{
ToFCameraMESAController::ToFCameraMESAController(): m_MESARes(0), m_PixelNumber(40000), m_NumberOfBytes(0),
m_CaptureWidth(0), m_CaptureHeight(0), m_NumImg(0), m_MaxRangeFactor(0.0), m_ConnectionCheck(false),
m_InputFileName("")
{
}
ToFCameraMESAController::~ToFCameraMESAController()
{
}
bool ToFCameraMESAController::CloseCameraConnection()
{
m_MESARes = SR_Close(m_MESAHandle); //res=SR_Close(srCam);
- m_ConnectionCheck = ErrorText(m_MESARes);
+ m_ConnectionCheck = !ErrorText(m_MESARes); // if disconnection was successful set connection check to false
m_MESAHandle = 0;
return m_ConnectionCheck;
}
bool ToFCameraMESAController::ErrorText(int error)
{
//if(error != MESA_OK)
//{
// //pmdGetLastError (m_MESAHandle, m_MESAError, 128);
// //MITK_ERROR << "Camera Error " << m_MESAError;
// return false;
//}
//else return true;
return true;
}
bool ToFCameraMESAController::UpdateCamera()
{
m_MESARes = SR_Acquire(m_MESAHandle); //res=SR_Acquire(srCam);
//return ErrorText(m_MESARes);
return true;
}
bool ToFCameraMESAController::GetAmplitudes(float* amplitudeArray)
{
unsigned short* data;
data = (unsigned short*)SR_GetImage(m_MESAHandle, 1);
for (int i=0; i<this->m_PixelNumber; i++)
{
if (data[i] & 0x8000) // bit 16 indicates saturation
{
amplitudeArray[i] = 0;
}
else
{
unsigned short value = data[i] & 0x7fff; // bit 16 indicates saturation
unsigned short value2 = value >> 2; // bits 1 and 2 are reserved/unused
amplitudeArray[i] = value2;
}
}
return true;
}
bool ToFCameraMESAController::GetIntensities(float* intensityArray)
{
unsigned short* data;
data = (unsigned short*)SR_GetImage(m_MESAHandle, 1);
for (int i=0; i<this->m_PixelNumber; i++)
{
intensityArray[i] = data[i];
}
return true;
}
bool ToFCameraMESAController::GetDistances(float* distanceArray)
{
//this->m_MESARes = pmdGetDistances(m_MESAHandle, distanceArray, this->m_NumberOfBytes);
//return ErrorText(this->m_MESARes);
unsigned short* data;
/*
for(i=0; i<m_NumImg; i++)
{
data = SR_GetImage(m_MESAHandle, i);
}
*/
data = (unsigned short*)SR_GetImage(m_MESAHandle, 0);
for (int i=0; i<this->m_PixelNumber; i++)
{
if (data[i] < 0xFFF8)
{
distanceArray[i] = data[i] * this->m_MaxRangeFactor;
}
else
{
distanceArray[i] = 0.0;
}
}
return true;
}
void ToFCameraMESAController::SetInputFileName(std::string inputFileName)
{
this->m_InputFileName = inputFileName;
}
}
diff --git a/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESASR4000DeviceFactory.h b/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESASR4000DeviceFactory.h
index da792364d4..56796f6b6b 100644
--- a/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESASR4000DeviceFactory.h
+++ b/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESASR4000DeviceFactory.h
@@ -1,85 +1,89 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraMESASR4000DeviceFactory_h
#define __mitkToFCameraMESASR4000DeviceFactory_h
#include "mitkMESASR4000ModuleExports.h"
#include "mitkToFCameraMESASR4000Device.h"
#include "mitkAbstractToFDeviceFactory.h"
#include <mitkCameraIntrinsics.h>
#include <mitkCameraIntrinsicsProperty.h>
#include <mitkToFConfig.h>
namespace mitk
{
/**
* \brief ToFPMDRawPlayerDeviceFactory is an implementation of the factory pattern to generate MESASR4000Devices.
* ToFCameraMESASR4000DeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
* This offers users the oppertunity to generate new Raw Player Devices via a global instance of this factory.
* @ingroup ToFHardware
*/
class MITK_MESASR4000MODULE_EXPORT ToFCameraMESASR4000DeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
public:
ToFCameraMESASR4000DeviceFactory()
{
this->m_DeviceNumber = 1;
}
/*!
\brief Defining the Factorie´s Name, here for the MESASR4000DeviceFactory
*/
std::string GetFactoryName()
{
return std::string("MESA SR4000 Factory");
}
std::string GetCurrentDeviceName()
{
std::stringstream name;
if(m_DeviceNumber>1)
{
name << "MESA SR4000 "<< m_DeviceNumber;
}
else
{
name << "MESA SR4000";
}
m_DeviceNumber++;
return name.str();
}
private:
/*!
\brief Create an instance of a ToFPMDRawDataDevice.
*/
ToFCameraDevice::Pointer createToFCameraDevice()
{
ToFCameraMESASR4000Device::Pointer device = ToFCameraMESASR4000Device::New();
//Set default camera intrinsics for the Mesa-SR4000-camera.
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
pathToDefaulCalibrationFile.append("/CalibrationFiles/Mesa-SR4000_Camera.xml");
cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
+ device->SetBoolProperty("HasRGBImage", false);
+ device->SetBoolProperty("HasAmplitudeImage", true);
+ device->SetBoolProperty("HasIntensityImage", true);
+
return device.GetPointer();
}
int m_DeviceNumber;
};
}
#endif
diff --git a/Modules/ToFHardware/PMD/CMakeLists.txt b/Modules/ToFHardware/PMD/CMakeLists.txt
index 9da71da566..c4e91aae72 100644
--- a/Modules/ToFHardware/PMD/CMakeLists.txt
+++ b/Modules/ToFHardware/PMD/CMakeLists.txt
@@ -1,109 +1,107 @@
#Begin PMD Module
OPTION(MITK_USE_TOF_PMDCAMCUBE "Enable support for Cam Cube camera" OFF)
IF(WIN32)
IF(_PLATFORM_STRING MATCHES "W32")
OPTION(MITK_USE_TOF_PMDCAMBOARD "Enable support for PMD camboard" OFF)
ENDIF(_PLATFORM_STRING MATCHES "W32")
ElSE(WIN32)
OPTION(MITK_USE_TOF_PMDCAMBOARD "Enable support for PMD camboard" OFF)
ENDIF(WIN32)
IF(WIN32)
IF(_PLATFORM_STRING MATCHES "W32")
- OPTION(MITK_USE_TOF_PMDO3 "Enable support for PMD camboard" OFF)
+ OPTION(MITK_USE_TOF_PMDO3 "Enable support for PMD O3" OFF)
ENDIF(_PLATFORM_STRING MATCHES "W32")
ENDIF(WIN32)
SET(MITK_USE_PMD OFF)
IF(MITK_USE_TOF_PMDO3 OR MITK_USE_TOF_PMDCAMCUBE OR MITK_USE_TOF_PMDCAMBOARD)
SET(MITK_USE_PMD ON)
ENDIF(MITK_USE_TOF_PMDO3 OR MITK_USE_TOF_PMDCAMCUBE OR MITK_USE_TOF_PMDCAMBOARD)
#Creating Basics for all PMD devices
IF(MITK_USE_PMD)
#-----Setting generall Path-----
FIND_LIBRARY(MITK_PMD_LIB pmdaccess2 DOC "PMD access library.")
GET_FILENAME_COMPONENT(MITK_PMD_SDK_DIR ${MITK_PMD_LIB} PATH)
SET(MITK_PMD_SDK_DIR ${MITK_PMD_SDK_DIR}/..)
FIND_PATH(MITK_PMD_INCLUDE_DIR pmdsdk2.h ${MITK_PMD_SDK_DIR}/include DOC "Include directory of PMD-SDK.")
Set(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_PMD_SDK_DIR}/include)
Set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_PMD_LIB})
#-----Creating the PMD-Module itself-----
MITK_CREATE_MODULE(mitkPMDModule
SUBPROJECTS MITK-ToF
INCLUDE_DIRS ${MITK_BIN_DIR}
INTERNAL_INCLUDE_DIRS ${INCLUDE_DIRS_INTERNAL}
DEPENDS mitkToFHardware
EXPORT_DEFINE MITK_PMDMODULE_EXPORT
ADDITIONAL_LIBS ${ADDITIONAL_LIBS}
AUTOLOAD_WITH mitkToFHardware
)
Message("PMD Module generated")
add_subdirectory(Testing)
ENDIF(MITK_USE_PMD)
#Only for CamCube
IF(MITK_USE_TOF_PMDCAMCUBE)
SET(MITK_TOF_PMD_CAMCUBE_SOURCE ${MITK_PMD_SDK_DIR}/plugins/camcube3.${_PLATFORM_STRING}.pap)
SET(MITK_TOF_PMD_CAMCUBE_PROC ${MITK_PMD_SDK_DIR}/plugins/camcubeproc.${_PLATFORM_STRING}.ppp)
SET(MITK_TOF_PMD_FILE_SOURCE ${MITK_PMD_SDK_DIR}/plugins/pmdfile.${_PLATFORM_STRING}.pcp)
SET(MITK_TOF_AVAILABLE_CAMERAS ${MITK_TOF_AVAILABLE_CAMERAS},PMD CamCube 2.0/3.0,PMD CamCubeRaw 2.0/3.0,PMD Player,PMD Raw Data Player)
MITK_INSTALL(FILES ${MITK_PMD_LIB})
IF(WIN32)
MITK_INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/camcube3.W32.pap CONFIGURATIONS Release)
MITK_INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/camcubeproc.W32.ppp CONFIGURATIONS Release)
MITK_INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/camcube3.W64.pap CONFIGURATIONS Release)
MITK_INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/camcubeproc.W64.ppp CONFIGURATIONS Release)
MITK_INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/pmdfile.W32.pcp CONFIGURATIONS Release)
ENDIF(WIN32)
Message("PMDCamCube activated")
ENDIF(MITK_USE_TOF_PMDCAMCUBE)
#-------------------------------Begin CamBoard hardware-------------------------------------------
IF(MITK_USE_TOF_PMDCAMBOARD)
SET(MITK_TOF_PMD_CAMBOARD_SOURCE ${MITK_PMD_SDK_DIR}/plugins/camboard.${_PLATFORM_STRING}.pap)
SET(MITK_TOF_PMD_CAMBOARD_PROC ${MITK_PMD_SDK_DIR}/plugins/camboardproc.${_PLATFORM_STRING}.ppp)
SET(MITK_TOF_AVAILABLE_CAMERAS ${MITK_TOF_AVAILABLE_CAMERAS},PMD CamBoard,PMD CamBoardRaw)
# FILE(GLOB MITK_TOF_PMD_CAMBOARD_SOURCE camboard.${_PLATFORM_STRING}.pap)
# FILE(GLOB MITK_TOF_PMD_CAMBOARD_PROC camboardproc.${_PLATFORM_STRING}.ppp)
# FILE(GLOB MITK_TOF_PMD_FILE_SOURCE ${MITK_PMD_SDK_DIR}/plugins/pmdfile.${_PLATFORM_STRING}.pcp)
IF(WIN32)
INSTALL(FILES ${MITK_PMD_SDK_DIR}/bin/pmdaccess2.dll DESTINATION bin CONFIGURATIONS Release)
INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/camboard.W32.pap DESTINATION bin CONFIGURATIONS Release)
INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/camboardproc.W32.ppp DESTINATION bin CONFIGURATIONS Release)
# INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/camboard.W64.pap DESTINATION bin CONFIGURATIONS Release)
# INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/camboardproc.W64.ppp DESTINATION bin CONFIGURATIONS Release)
# INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/pmdfile.W32.pcp DESTINATION bin CONFIGURATIONS Release)
ENDIF(WIN32)
Message("PMDCamBoard activated")
ENDIF(MITK_USE_TOF_PMDCAMBOARD)
#----------------------------------------Begin PMD O3 hardware--------------------------------------------
IF(WIN32)
# only if PMD O3 is enabled
IF(MITK_USE_TOF_PMDO3)
Message("PMDO3 is activated")
SET(MITK_TOF_PMD_O3D_SOURCE ${MITK_PMD_SDK_DIR}/plugins/o3d.${_PLATFORM_STRING}.pcp)
SET(MITK_TOF_PMD_O3D_PROC ${MITK_PMD_SDK_DIR}/plugins/o3d.${_PLATFORM_STRING}.pcp)
SET(MITK_TOF_AVAILABLE_CAMERAS ${MITK_TOF_AVAILABLE_CAMERAS},PMD O3D)
- FILE(GLOB MITK_TOF_PMD_O3D_SOURCE o3d.${_PLATFORM_STRING}.pcp)
- FILE(GLOB MITK_TOF_PMD_O3D_PROC o3d.${_PLATFORM_STRING}.pcp)
MITK_INSTALL(FILES ${MITK_PMD_SDK_DIR}/bin/pmdaccess2.dll CONFIGURATIONS Release)
MITK_INSTALL(FILES ${MITK_PMD_SDK_DIR}/plugins/o3d.W32.pcp CONFIGURATIONS Release)
ENDIF(MITK_USE_TOF_PMDO3)
ENDIF(WIN32)
#Generate the mitkToFPMDConfig.h file which is used internally
CONFIGURE_FILE(mitkToFPMDConfig.h.in ${PROJECT_BINARY_DIR}/mitkToFPMDConfig.h @ONLY)
diff --git a/Modules/ToFHardware/PMD/Testing/mitkToFCameraPMDCamBoardControllerTest.cpp b/Modules/ToFHardware/PMD/Testing/mitkToFCameraPMDCamBoardControllerTest.cpp
index 8f37a2d5bb..980d435d46 100644
--- a/Modules/ToFHardware/PMD/Testing/mitkToFCameraPMDCamBoardControllerTest.cpp
+++ b/Modules/ToFHardware/PMD/Testing/mitkToFCameraPMDCamBoardControllerTest.cpp
@@ -1,49 +1,44 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkToFCameraPMDCamBoardController.h>
/**Documentation
* test for the class "ToFCameraPMDCamBoardController".
*/
int mitkToFCameraPMDCamBoardControllerTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("ToFCameraPMDCamBoardController");
mitk::ToFCameraPMDCamBoardController::Pointer testObject = mitk::ToFCameraPMDCamBoardController::New();
MITK_TEST_CONDITION_REQUIRED(!testObject.GetPointer()==NULL,"Testing initialzation!");
MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureHeight()== 200 ,"Testing initialization of CaptureHeight");
MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureWidth()== 200 ,"Testing initialization of CaptureWidth");
MITK_TEST_CONDITION_REQUIRED(testObject->OpenCameraConnection(),"Testing opening of camera connection!");
MITK_TEST_CONDITION_REQUIRED(testObject->UpdateCamera(),"Testing UpdateCamera()");
MITK_TEST_CONDITION_REQUIRED(testObject->SetDistanceOffset(0.5f),"Testing SetDistanceOffset()");
MITK_TEST_OUTPUT(<<"Call GetDistanceOffset()");
MITK_INFO<<testObject->GetDistanceOffset();
MITK_TEST_CONDITION_REQUIRED(testObject->SetRegionOfInterest(3,5,200,201),"Testing SetRegionOfInterest()");
MITK_TEST_OUTPUT(<<"Call GetRegionOfInterest()");
MITK_INFO<<testObject->GetRegionOfInterest();
- MITK_TEST_CONDITION_REQUIRED(testObject->SetExposureMode(0),"Testing SetExposureMode()");
MITK_TEST_CONDITION_REQUIRED(testObject->SetFieldOfView(35.7f),"Testing SetFieldOfView()");
- MITK_TEST_CONDITION_REQUIRED(testObject->SetFPNCalibration(true),"Testing SetFPNCalibration()");
- MITK_TEST_CONDITION_REQUIRED(testObject->SetFPPNCalibration(true),"Testing SetFPPNCalibration()");
- MITK_TEST_CONDITION_REQUIRED(testObject->SetLinearityCalibration(true),"Testing SetLinearityCalibration()");
- MITK_TEST_CONDITION_REQUIRED(testObject->SetLensCalibration(true),"Testing SetLensCalibration()");
MITK_TEST_CONDITION_REQUIRED(testObject->CloseCameraConnection(),"Testing closing of camera connection!");
MITK_TEST_END();
}
diff --git a/Modules/ToFHardware/PMD/Testing/mitkToFCameraPMDControllerTest.cpp b/Modules/ToFHardware/PMD/Testing/mitkToFCameraPMDControllerTest.cpp
index 78c681e34b..e00a983872 100644
--- a/Modules/ToFHardware/PMD/Testing/mitkToFCameraPMDControllerTest.cpp
+++ b/Modules/ToFHardware/PMD/Testing/mitkToFCameraPMDControllerTest.cpp
@@ -1,89 +1,91 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// mitk includes
#include <mitkTestingMacros.h>
#include <mitkToFCameraPMDController.h>
#include <mitkCommon.h>
#include <mitkToFConfig.h>
// itk includes
#include "itkObject.h"
#include "itkObjectFactory.h"
/**Documentation
* test for the class "ToFCameraPMDController".
*/
//creating a concrete test implementation of the abstract class
namespace mitk
{
/**
* @brief The ToFCameraPMDControllerTest class
* Special class to test the abstract class ToFCameraPMDController.
*/
class ToFCameraPMDControllerTest : public ToFCameraPMDController
{
public:
mitkClassMacro( ToFCameraPMDControllerTest, ToFCameraPMDController);
itkNewMacro( ToFCameraPMDControllerTest );
inline bool OpenCameraConnection(){return true;};
protected:
inline ToFCameraPMDControllerTest(){};
inline ~ToFCameraPMDControllerTest(){};
+ inline void TransformCameraOutput(float* in, float* out, bool isDist){};
+
private:
};
} // end namespace mitk
int mitkToFCameraPMDControllerTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("ToFCameraPMDController");
// initialize test
mitk::ToFCameraPMDControllerTest::Pointer testObject = mitk::ToFCameraPMDControllerTest::New();
try
{
MITK_TEST_CONDITION_REQUIRED(!(testObject.GetPointer() == NULL) ,"Testing initialization class");
MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureHeight()== 200 ,"Testing initialization of CaptureHeight");
MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureWidth()== 200 ,"Testing initialization of CaptureWidth");
int numberOfPixels = testObject->GetCaptureHeight()*testObject->GetCaptureWidth();
float* dataArray = new float[numberOfPixels];
char* sourceArray = new char[numberOfPixels];
short* shortSource = new short[numberOfPixels];
MITK_TEST_CONDITION_REQUIRED(testObject->OpenCameraConnection(),"Testing OpenCameraConnection()");
MITK_TEST_CONDITION_REQUIRED(testObject->UpdateCamera(),"Testing UpdateCamera() with no camera connected");
MITK_TEST_CONDITION_REQUIRED(testObject->GetAmplitudes(dataArray),"Testing GetAmplitudes(float*) with no camera connected");
MITK_TEST_CONDITION_REQUIRED(testObject->GetAmplitudes(sourceArray,dataArray),"Testing GetAmplitudes(char*,float*) with no camera connected");
MITK_TEST_CONDITION_REQUIRED(testObject->GetIntensities(dataArray),"Testing GetIntensities(float*) with no camera connected");
MITK_TEST_CONDITION_REQUIRED(testObject->GetIntensities(sourceArray,dataArray),"Testing GetIntensities(char*,float*) with no camera connected");
MITK_TEST_CONDITION_REQUIRED(testObject->GetDistances(dataArray),"Testing GetDistances(float*) with no camera connected");
MITK_TEST_CONDITION_REQUIRED(testObject->GetDistances(sourceArray,dataArray),"Testing GetDistances(char*,float*) with no camera connected");
MITK_TEST_CONDITION_REQUIRED(testObject->GetSourceData(sourceArray),"Testing GetSourceData(char*) with no camera connected");
MITK_TEST_CONDITION_REQUIRED(testObject->GetShortSourceData(shortSource), "Testing GetShortSourceData(short*) with no camera connected");
MITK_TEST_CONDITION_REQUIRED(testObject->CloseCameraConnection(),"Testing closing of connection");
delete [] dataArray;
delete [] sourceArray;
delete [] shortSource;
}
catch(std::exception &e)
{
MITK_INFO << e.what();
}
MITK_TEST_END();
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.cpp b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.cpp
index 0bf9cc56ef..25011746c2 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.cpp
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.cpp
@@ -1,307 +1,172 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraPMDCamBoardController.h"
#include "mitkToFConfig.h"
#include <pmdsdk2.h>
#include "mitkToFPMDConfig.h"
// vnl includes
#include "vnl/vnl_matrix.h"
//Plugin defines for CamBoard
#define SOURCE_PARAM ""
#define PROC_PARAM ""
extern PMDHandle m_PMDHandle; //TODO
extern PMDDataDescription m_DataDescription; //TODO
-struct SourceDataStruct {
- PMDDataDescription dataDescription;
- char sourceData;
-};
-
namespace mitk
{
- ToFCameraPMDCamBoardController::ToFCameraPMDCamBoardController(): m_InternalCaptureWidth(0),
- m_InternalCaptureHeight(0), m_InternalPixelNumber(0)
+ ToFCameraPMDCamBoardController::ToFCameraPMDCamBoardController()
{
m_SourcePlugin = MITK_TOF_PMDCAMBOARD_SOURCE_PLUGIN;
m_SourceParam = SOURCE_PARAM;
m_ProcPlugin = MITK_TOF_PMDCAMBOARD_PROCESSING_PLUGIN;
m_ProcParam = PROC_PARAM;
}
ToFCameraPMDCamBoardController::~ToFCameraPMDCamBoardController()
{
}
bool ToFCameraPMDCamBoardController::OpenCameraConnection()
{
if(!m_ConnectionCheck)
{
m_PMDRes = pmdOpen (&m_PMDHandle , m_SourcePlugin , m_SourceParam , m_ProcPlugin , m_ProcParam );
m_ConnectionCheck = ErrorText(m_PMDRes);
if (!m_ConnectionCheck)
{
return m_ConnectionCheck;
}
// get image properties from camera
this->UpdateCamera();
this->m_PMDRes = pmdGetSourceDataDescription(m_PMDHandle, &m_DataDescription);
ErrorText(m_PMDRes);
- this->m_InternalCaptureWidth = m_DataDescription.img.numColumns;
- this->m_CaptureWidth = 200;
- this->m_InternalCaptureHeight = m_DataDescription.img.numRows;
- this->m_CaptureHeight = 200;
- this->m_InternalPixelNumber = m_InternalCaptureWidth*m_InternalCaptureHeight;
+ this->m_CaptureWidth = m_DataDescription.img.numColumns;
+ this->m_InternalCaptureWidth = 200;
+ this->m_CaptureHeight = m_DataDescription.img.numRows;
+ this->m_InternalCaptureHeight = 200;
this->m_PixelNumber = m_CaptureWidth*m_CaptureHeight;
- this->m_NumberOfBytes = m_InternalPixelNumber * sizeof(float);
+ this->m_NumberOfBytes = m_PixelNumber * sizeof(float);
this->m_SourceDataSize = m_DataDescription.size;
this->m_SourceDataStructSize = m_DataDescription.size + sizeof(PMDDataDescription);
MITK_INFO << "Datasource size: " << this->m_SourceDataSize <<std::endl;
MITK_INFO << "Integration Time: " << this->GetIntegrationTime();
MITK_INFO << "Modulation Frequency: " << this->GetModulationFrequency();
return m_ConnectionCheck;
}
else return m_ConnectionCheck;
}
bool mitk::ToFCameraPMDCamBoardController::SetDistanceOffset( float offset )
{
std::stringstream command;
command<<"SetSoftOffset "<<offset;
this->m_PMDRes = pmdSourceCommand(m_PMDHandle,0,0,command.str().c_str());
return ErrorText(this->m_PMDRes);
}
float mitk::ToFCameraPMDCamBoardController::GetDistanceOffset()
{
char offset[16];
this->m_PMDRes = pmdSourceCommand(m_PMDHandle, offset, 16, "GetSoftOffset");
ErrorText(this->m_PMDRes);
return atof(offset);
}
bool mitk::ToFCameraPMDCamBoardController::SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height )
{
// CAVE: This function does not work properly, don't use unless you know what you're doing!!
// check if leftUpperCornerX and width are divisible by 3 otherwise round to the next value divisible by 3
unsigned int factor = leftUpperCornerX/3;
leftUpperCornerX = 3*factor;
factor = width/3;
width = 3*factor;
std::stringstream command;
command<<"SetROI "<<leftUpperCornerX<<" "<<leftUpperCornerY<<" "<<width<<" "<<height;
this->m_PMDRes = pmdSourceCommand(m_PMDHandle,0,0,command.str().c_str());
return ErrorText(this->m_PMDRes);
}
bool mitk::ToFCameraPMDCamBoardController::SetRegionOfInterest( unsigned int roi[4] )
{
return this->SetRegionOfInterest(roi[0],roi[1],roi[2],roi[3]);
}
unsigned int* mitk::ToFCameraPMDCamBoardController::GetRegionOfInterest()
{
/*
char result[64];
this->m_PMDRes = pmdSourceCommand(m_PMDHandle, result, 64, "GetROI");
ErrorText(this->m_PMDRes);
// convert char array to uint array
unsigned int roi[4];
std::stringstream currentValue;
int counter = 0;
std::string resultString = result;
char blank = ' ';
for (int i=0; i<64; i++)
{
if (result[i]!=blank)
{
currentValue<<result[i];
}
else
{
if (counter<4)
{
roi[counter] = atoi(currentValue.str().c_str());
counter++;
// empty the stream
currentValue.str("");
currentValue.clear();
}
}
}
return roi;
*/
return NULL;
}
- bool mitk::ToFCameraPMDCamBoardController::SetExposureMode( int mode )
- {
- if (mode==0) // normal mode
- {
- this->m_PMDRes = pmdSourceCommand(m_PMDHandle, 0, 0, "SetExposureMode Normal");
- return ErrorText(this->m_PMDRes);
- }
- else if (mode==1) // SMB mode
- {
- this->m_PMDRes = pmdSourceCommand(m_PMDHandle, 0, 0, "SetExposureMode SMB");
- return ErrorText(this->m_PMDRes);
- }
- else
- {
- MITK_ERROR<<"Specified exposure mode not supported. Exposure mode must be 0 (Normal) or 1 (SMB)";
- return false;
- }
- }
-
bool mitk::ToFCameraPMDCamBoardController::SetFieldOfView( float fov )
{
+ //return true;
std::stringstream commandStream;
commandStream<<"SetFOV "<<fov;
this->m_PMDRes = pmdProcessingCommand(m_PMDHandle, 0, 0, commandStream.str().c_str());
return ErrorText(this->m_PMDRes);
}
- bool mitk::ToFCameraPMDCamBoardController::SetFPNCalibration( bool on )
- {
- if(on)
- {
- this->m_PMDRes=pmdSourceCommand(m_PMDHandle,0,0,"SetFPNCalibration On");
- return this->ErrorText(this->m_PMDRes);
- }
- else
- {
- this->m_PMDRes=pmdSourceCommand(m_PMDHandle,0,0,"SetFPNCalibration Off");
- return this->ErrorText(this->m_PMDRes);
- }
- }
-
- bool mitk::ToFCameraPMDCamBoardController::SetFPPNCalibration( bool on )
- {
- if(on)
- {
- this->m_PMDRes=pmdProcessingCommand(m_PMDHandle,0,0,"SetFPPNCalibration On");
- return this->ErrorText(this->m_PMDRes);
- }
- else
- {
- this->m_PMDRes=pmdProcessingCommand(m_PMDHandle,0,0,"SetFPPNCalibration Off");
- return this->ErrorText(this->m_PMDRes);
- }
- }
-
- bool mitk::ToFCameraPMDCamBoardController::SetLinearityCalibration( bool on )
- {
- if(on)
- {
- this->m_PMDRes=pmdProcessingCommand(m_PMDHandle,0,0,"SetLinearityCalibration On");
- return this->ErrorText(this->m_PMDRes);
- }
- else
- {
- this->m_PMDRes=pmdProcessingCommand(m_PMDHandle,0,0,"SetLinearityCalibration Off");
- return this->ErrorText(this->m_PMDRes);
- }
- }
-
- bool mitk::ToFCameraPMDCamBoardController::SetLensCalibration( bool on )
- {
- if (on)
- {
- this->m_PMDRes = pmdProcessingCommand(m_PMDHandle, 0, 0, "SetLensCalibration On");
- return ErrorText(this->m_PMDRes);
- }
- else
- {
- this->m_PMDRes = pmdProcessingCommand(m_PMDHandle, 0, 0, "SetLensCalibration Off");
- return ErrorText(this->m_PMDRes);
- }
- }
-
- bool ToFCameraPMDCamBoardController::GetAmplitudes(float* amplitudeArray)
- {
- float* tempArray = new float[m_InternalCaptureWidth*m_InternalCaptureHeight];
- this->m_PMDRes = pmdGetAmplitudes(m_PMDHandle, tempArray, this->m_NumberOfBytes);
- this->TransformCameraOutput(tempArray, amplitudeArray, false);
- delete[] tempArray;
- return ErrorText(this->m_PMDRes);
- }
-
- bool ToFCameraPMDCamBoardController::GetAmplitudes(char* sourceData, float* amplitudeArray)
- {
- float* tempArray = new float[m_InternalCaptureWidth*m_InternalCaptureHeight];
- this->m_PMDRes = pmdCalcAmplitudes(m_PMDHandle, tempArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
- this->TransformCameraOutput(tempArray, amplitudeArray, false);
- delete[] tempArray;
- return ErrorText(this->m_PMDRes);
- }
-
- bool ToFCameraPMDCamBoardController::GetIntensities(float* intensityArray)
- {
- float* tempArray = new float[m_InternalCaptureWidth*m_InternalCaptureHeight];
- this->m_PMDRes = pmdGetIntensities(m_PMDHandle, tempArray, this->m_NumberOfBytes);
- this->TransformCameraOutput(tempArray, intensityArray, false);
- delete[] tempArray;
- return ErrorText(this->m_PMDRes);
- }
-
- bool ToFCameraPMDCamBoardController::GetIntensities(char* sourceData, float* intensityArray)
- {
- float* tempArray = new float[m_InternalCaptureWidth*m_InternalCaptureHeight];
- this->m_PMDRes = pmdCalcIntensities(m_PMDHandle, tempArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
- this->TransformCameraOutput(tempArray, intensityArray, false);
- delete[] tempArray;
- return ErrorText(this->m_PMDRes);
- }
-
- bool ToFCameraPMDCamBoardController::GetDistances(float* distanceArray)
- {
- float* tempArray = new float[m_InternalCaptureWidth*m_InternalCaptureHeight];
- this->m_PMDRes = pmdGetDistances(m_PMDHandle, tempArray, this->m_NumberOfBytes);
- this->TransformCameraOutput(tempArray, distanceArray, true);
- delete[] tempArray;
- return ErrorText(this->m_PMDRes);
- }
-
- bool ToFCameraPMDCamBoardController::GetDistances(char* sourceData, float* distanceArray)
- {
- float* tempArray = new float[m_InternalCaptureWidth*m_InternalCaptureHeight];
- this->m_PMDRes = pmdCalcDistances(m_PMDHandle, tempArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
- this->TransformCameraOutput(tempArray, distanceArray, true);
- delete[] tempArray;
- return ErrorText(this->m_PMDRes);
- }
-
- void ToFCameraPMDCamBoardController::TransformCameraOutput( float* in, float* out, bool isDist )
+ void ToFCameraPMDCamBoardController::TransformCameraOutput( float* in, float* out, bool isDist)
{
- vnl_matrix<float> inMat = vnl_matrix<float>(m_InternalCaptureHeight,m_InternalCaptureWidth);
+ vnl_matrix<float> inMat = vnl_matrix<float>(m_CaptureHeight,m_CaptureWidth);
inMat.copy_in(in);
- vnl_matrix<float> outMat = vnl_matrix<float>(m_CaptureHeight, m_CaptureWidth);
- vnl_matrix<float> temp = vnl_matrix<float>(m_CaptureHeight, m_CaptureWidth);
- temp = inMat.extract(m_CaptureHeight, m_CaptureWidth, 0,1);
+ vnl_matrix<float> outMat = vnl_matrix<float>(m_InternalCaptureHeight, m_InternalCaptureWidth);
+ vnl_matrix<float> temp = vnl_matrix<float>(m_InternalCaptureHeight, m_InternalCaptureWidth);
+ temp = inMat.extract(m_InternalCaptureHeight, m_InternalCaptureWidth, 0,1);
outMat = temp.transpose();
if(isDist)
{
outMat*=1000;
}
outMat.copy_out(out);
inMat.clear();
outMat.clear();
temp.clear();
}
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.h
index 58f2bb6d4a..8c554a3e2b 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.h
@@ -1,147 +1,97 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDCamBoardController_h
#define __mitkToFCameraPMDCamBoardController_h
#include "mitkPMDModuleExports.h"
#include "mitkCommon.h"
#include "mitkToFCameraPMDController.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace mitk
{
/**
* @brief Interface to the Time-of-Flight (ToF) camera PMD CamBoard
*
*
* @ingroup ToFHardware
*/
- class MITK_PMDMODULE_EXPORT ToFCameraPMDCamBoardController : public mitk::ToFCameraPMDController
+ class MITK_PMDMODULE_EXPORT ToFCameraPMDCamBoardController : public ToFCameraPMDController
{
public:
- mitkClassMacro( ToFCameraPMDCamBoardController , mitk::ToFCameraPMDController );
+ mitkClassMacro( ToFCameraPMDCamBoardController , ToFCameraPMDController );
itkNewMacro( Self );
/*!
\brief opens a connection to the ToF camera and initializes the hardware specific members
\return returns whether the connection was successful (true) or not (false)
*/
virtual bool OpenCameraConnection();
/*!
\brief sets an additional distance offset which will be added to all distance values.
\param offset offset in m
*/
bool SetDistanceOffset( float offset );
/*!
\brief returns the currently applied distance offset in m
\param offset offset in m
*/
float GetDistanceOffset();
/*!
\brief Setting the region of interest, the camera is configured to only output a certain area of the image.
\param leftUpperCornerX x value of left upper corner of region
\param leftUpperCornerX y value of left upper corner of region
\param width width of region
\param height height of region
*/
bool SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height );
/*!
\brief Setting the region of interest, the camera is configured to only output a certain area of the image.
\param roi region of interest. roi[0]: x value of left upper corner, roi[1]: y value of left upper corner, roi[2]: width, roi[3]: height
*/
bool SetRegionOfInterest( unsigned int roi[4] );
/*!
\brief returns the region of interest currently set
\return currently set region of interest.
*/
unsigned int* GetRegionOfInterest();
/*!
- \brief sets the exposure mode of the CamBoard
- \param mode exposure mode. 0: normal mode (one exposure), 1: Suppression of motion blur (SMB), minimizes the time needed to capture
- a distance image from the camera which results in a reduced amount of motion artifact but may lead to increased noise.
- */
- bool SetExposureMode( int mode );
- /*!
\brief Sets the field of view of the camera lens.
\param fov field of view in degrees. The default value is 40 degrees.
*/
bool SetFieldOfView( float fov );
- /*
- \brief Enable/Disable PMD fixed pattern noise (FPN) calibration
- \param on enabled (true), disabled (false)
- */
- bool SetFPNCalibration( bool on );
- /*
- \brief Enable/Disable PMD fixed pattern phase noise (FPPN) calibration
- \param on enabled (true), disabled (false)
- */
- bool SetFPPNCalibration( bool on );
- /*
- \brief Enable/Disable PMD linearity calibration
- \param on enabled (true), disabled (false)
- */
- bool SetLinearityCalibration( bool on );
- /*
- \brief Enable/Disable PMD lens calibration
- \param on enabled (true), disabled (false)
- */
- bool SetLensCalibration( bool on );
- /*
- \brief Returns amplitude data, performs camera data transform
- \param output data array
- */
- bool GetAmplitudes(float* amplitudeArray);
- bool GetAmplitudes(char* sourceData, float* amplitudeArray);
- /*
- \brief Returns intensity data, performs camera data transform
- \param output data array
- */
- bool GetIntensities(float* intensityArray);
- bool GetIntensities(char* sourceData, float* intensityArray);
- /*
- \brief Returns distance data, performs camera data transform
- \param output data array
- */
- bool GetDistances(float* distanceArray);
- bool GetDistances(char* sourceData, float* distanceArray);
- itkGetMacro(InternalCaptureWidth, int);
- itkGetMacro(InternalCaptureHeight, int);
protected:
ToFCameraPMDCamBoardController();
~ToFCameraPMDCamBoardController();
- private:
+
/*
\brief Transform the output of the camera, i.e. cut invalid pixels, and rotate 90°
counterclockwise
\param input data array of original size (207x204)
\param rotated output data array of reduced size (200x200)
*/
- void TransformCameraOutput(float* in, float* out, bool isDist);
+ virtual void TransformCameraOutput(float* in, float* out, bool isDist);
- // member variables
- unsigned int m_InternalCaptureWidth; ///< variable holds the original image data width
- unsigned int m_InternalCaptureHeight; ///< variable holds the original image data height
- unsigned int m_InternalPixelNumber; ///< variable holds the original number of pixel
};
} //END mitk namespace
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDevice.cpp b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDevice.cpp
index af172fcfeb..9c28501f66 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDevice.cpp
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDevice.cpp
@@ -1,128 +1,46 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraPMDCamBoardDevice.h"
#include "mitkToFCameraPMDCamBoardController.h"
#include "mitkRealTimeClock.h"
#include "itkMultiThreader.h"
namespace mitk
{
ToFCameraPMDCamBoardDevice::ToFCameraPMDCamBoardDevice()
{
m_Controller = ToFCameraPMDCamBoardController::New();
}
ToFCameraPMDCamBoardDevice::~ToFCameraPMDCamBoardDevice()
{
}
void ToFCameraPMDCamBoardDevice::SetRegionOfInterest(unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height)
{
if (m_Controller.IsNotNull())
{
dynamic_cast<ToFCameraPMDCamBoardController*>(m_Controller.GetPointer())->SetRegionOfInterest(leftUpperCornerX,leftUpperCornerY,width,height);
}
}
void ToFCameraPMDCamBoardDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
{
this->m_PropertyList->SetProperty(propertyKey, propertyValue);
-
- ToFCameraPMDCamBoardController::Pointer myController = dynamic_cast<mitk::ToFCameraPMDCamBoardController*>(this->m_Controller.GetPointer());
-
- bool boolValue = false;
- GetBoolProperty(propertyKey, boolValue);
- if (strcmp(propertyKey, "SetFPNCalibration") == 0)
- {
- myController->SetFPNCalibration(boolValue);
- }
- else if (strcmp(propertyKey, "SetFPPNCalibration") == 0)
- {
- myController->SetFPPNCalibration(boolValue);
- }
- else if (strcmp(propertyKey, "SetLinearityCalibration") == 0)
- {
- myController->SetLinearityCalibration(boolValue);
- }
- else if (strcmp(propertyKey, "SetLensCalibration") == 0)
- {
- myController->SetLensCalibration(boolValue);
- }
- else if (strcmp(propertyKey, "SetExposureMode") == 0)
- {
- if (boolValue)
- {
- myController->SetExposureMode(1);
- }
- else
- {
- myController->SetExposureMode(0);
- }
- }
}
- void ToFCameraPMDCamBoardDevice::GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* sourceDataArray,
- int requiredImageSequence, int& capturedImageSequence, unsigned char* rgbDataArray)
- {
- if (m_CameraActive)
- {
- // 1) copy the image buffer
- // 2) convert the distance values from m to mm
-
- // check for empty buffer
- if (this->m_ImageSequence < 0)
- {
- // buffer empty
- MITK_INFO << "Buffer empty!! ";
- capturedImageSequence = this->m_ImageSequence;
- return;
- }
- // determine position of image in buffer
- int pos = 0;
- if ((requiredImageSequence < 0) || (requiredImageSequence > this->m_ImageSequence))
- {
- capturedImageSequence = this->m_ImageSequence;
- pos = this->m_CurrentPos;
- //MITK_INFO << "Required image not found! Required: " << requiredImageSequence << " delivered/current: " << this->m_ImageSequence;
- }
- else if (requiredImageSequence <= this->m_ImageSequence - this->m_BufferSize)
- {
- capturedImageSequence = (this->m_ImageSequence - this->m_BufferSize) + 1;
- pos = (this->m_CurrentPos + 1) % this->m_BufferSize;
- //MITK_INFO << "Out of buffer! Required: " << requiredImageSequence << " delivered: " << capturedImageSequence << " current: " << this->m_ImageSequence;
- }
- else // (requiredImageSequence > this->m_ImageSequence - this->m_BufferSize) && (requiredImageSequence <= this->m_ImageSequence)
- {
- capturedImageSequence = requiredImageSequence;
- pos = (this->m_CurrentPos + (10-(this->m_ImageSequence - requiredImageSequence))) % this->m_BufferSize;
- }
-
- m_ImageMutex->Lock();
- this->m_Controller->GetDistances(this->m_SourceDataBuffer[pos], distanceArray);
- this->m_Controller->GetAmplitudes(this->m_SourceDataBuffer[pos], amplitudeArray);
- this->m_Controller->GetIntensities(this->m_SourceDataBuffer[pos], intensityArray);
- memcpy(sourceDataArray, this->m_SourceDataBuffer[this->m_CurrentPos], this->m_SourceDataSize);
- m_ImageMutex->Unlock();
-
- }
- else
- {
- MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
- }
- }
-
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDevice.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDevice.h
index aa5561a6b6..f29bbba43b 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDevice.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDevice.h
@@ -1,71 +1,71 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDCamBoardDevice_h
#define __mitkToFCameraPMDCamBoardDevice_h
#include "mitkPMDModuleExports.h"
#include "mitkCommon.h"
#include "mitkToFCameraDevice.h"
#include "mitkToFCameraPMDDevice.h"
#include "mitkToFCameraPMDCamBoardController.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
#include "itkMultiThreader.h"
#include "itkFastMutexLock.h"
namespace mitk
{
/**
* @brief Device class representing a PMD CamBoard camera
*
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDCamBoardDevice : public ToFCameraPMDDevice
{
public:
mitkClassMacro( ToFCameraPMDCamBoardDevice , ToFCameraPMDDevice );
itkNewMacro( Self );
/*!
\brief set a BaseProperty
*/
virtual void SetProperty( const char *propertyKey, BaseProperty* propertyValue );
/*!
\brief Setting the region of interest, the camera is configured to only output a certain area of the image.
\param leftUpperCornerX x value of left upper corner of region
\param leftUpperCornerX y value of left upper corner of region
\param width width of region
\param height height of region
*/
void SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height );
- void GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* sourceDataArray, int requiredImageSequence, int& capturedImageSequence, unsigned char* rgbDataArray);
+ //void GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* sourceDataArray, int requiredImageSequence, int& capturedImageSequence, unsigned char* rgbDataArray);
protected:
ToFCameraPMDCamBoardDevice();
~ToFCameraPMDCamBoardDevice();
private:
};
} //END mitk namespace
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDeviceFactory.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDeviceFactory.h
index 74f57d097f..22293cbb8f 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDeviceFactory.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardDeviceFactory.h
@@ -1,87 +1,91 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDCamBoardDeviceFactory_h
#define __mitkToFCameraPMDCamBoardDeviceFactory_h
#include "mitkPMDModuleExports.h"
#include "mitkToFCameraPMDCamBoardDevice.h"
#include "mitkAbstractToFDeviceFactory.h"
#include <mitkCameraIntrinsics.h>
#include <mitkCameraIntrinsicsProperty.h>
#include <mitkToFConfig.h>
namespace mitk
{
/**
* \brief ToFPMDCamBoardDeviceFactory is an implementation of the factory pattern to generate CamBoard devices.
* ToFPMDCamBoardDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
* This offers users the oppertunity to generate new CamBoard Devices via a global instance of this factory.
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDCamBoardDeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
public:
ToFCameraPMDCamBoardDeviceFactory()
{
this->m_DeviceNumber=1;
}
/*!
\brief Defining the Factorie´s Name, here for the ToFPMDCamBoard.
*/
std::string GetFactoryName()
{
return std::string("PMD CamBoard Factory ");
}
std::string GetCurrentDeviceName()
{
std::stringstream name;
if(m_DeviceNumber>1)
{
name << "PMD CamBoard "<< m_DeviceNumber;
}
else
{
name << "PMD CamBoard";
}
m_DeviceNumber++;
return name.str();
}
private:
/*!
\brief Create an instance of a ToFPMDCamBoardDevice.
*/
ToFCameraDevice::Pointer createToFCameraDevice()
{
ToFCameraPMDCamBoardDevice::Pointer device = ToFCameraPMDCamBoardDevice::New();
//Set default camera intrinsics for the CamBoard-camera.
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
pathToDefaulCalibrationFile.append("/CalibrationFiles/PMDCamBoard_camera.xml");
cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
+ device->SetBoolProperty("HasRGBImage", false);
+ device->SetBoolProperty("HasAmplitudeImage", true);
+ device->SetBoolProperty("HasIntensityImage", true);
+
return device.GetPointer();
}
int m_DeviceNumber;
};
}
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.cpp b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.cpp
index c144594a9f..22a7f76d03 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.cpp
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.cpp
@@ -1,231 +1,251 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraPMDCamCubeController.h"
#include "mitkToFConfig.h"
#include "mitkToFPMDConfig.h"
#include <pmdsdk2.h>
+#include "vnl/vnl_matrix.h"
+
//Plugin defines for CamCube
#define SOURCE_PARAM ""
#define PROC_PARAM ""
extern PMDHandle m_PMDHandle; //TODO
extern PMDDataDescription m_DataDescription; //TODO
namespace mitk
{
ToFCameraPMDCamCubeController::ToFCameraPMDCamCubeController()
{
m_SourcePlugin = MITK_TOF_PMDCAMCUBE_SOURCE_PLUGIN;
m_SourceParam = SOURCE_PARAM;
m_ProcPlugin = MITK_TOF_PMDCAMCUBE_PROCESSING_PLUGIN;
m_ProcParam = PROC_PARAM;
}
ToFCameraPMDCamCubeController::~ToFCameraPMDCamCubeController()
{
}
bool ToFCameraPMDCamCubeController::OpenCameraConnection()
{
if(!m_ConnectionCheck)
{
m_PMDRes = pmdOpen(&m_PMDHandle , m_SourcePlugin , m_SourceParam , m_ProcPlugin , m_ProcParam );
m_ConnectionCheck = ErrorText(m_PMDRes);
if (!m_ConnectionCheck)
{
return m_ConnectionCheck;
}
// get image properties from camera
this->UpdateCamera();
m_PMDRes = pmdGetSourceDataDescription(m_PMDHandle, &m_DataDescription);
ErrorText(m_PMDRes);
m_CaptureWidth = m_DataDescription.img.numColumns;
m_CaptureHeight = m_DataDescription.img.numRows;
+ m_InternalCaptureWidth = m_CaptureWidth;
+ m_InternalCaptureHeight = m_CaptureHeight;
m_PixelNumber = m_CaptureWidth*m_CaptureHeight;
m_NumberOfBytes = m_PixelNumber * sizeof(float);
m_SourceDataSize = m_DataDescription.size;
m_SourceDataStructSize = m_DataDescription.size + sizeof(PMDDataDescription);
char serial[16];
m_PMDRes = pmdSourceCommand (m_PMDHandle, serial, 16, "GetSerialNumber");
ErrorText(m_PMDRes);
MITK_INFO << "Serial-No: " << serial <<std::endl;
MITK_INFO << "Datasource size: " << this->m_SourceDataSize <<std::endl;
MITK_INFO << "Integration Time: " << this->GetIntegrationTime();
MITK_INFO << "Modulation Frequence: " << this->GetModulationFrequency();
return m_ConnectionCheck;
}
else return m_ConnectionCheck;
}
bool mitk::ToFCameraPMDCamCubeController::SetDistanceOffset( float offset )
{
std::stringstream command;
command<<"SetSoftOffset "<<offset;
this->m_PMDRes = pmdSourceCommand(m_PMDHandle,0,0,command.str().c_str());
return ErrorText(this->m_PMDRes);
}
float mitk::ToFCameraPMDCamCubeController::GetDistanceOffset()
{
char offset[16];
this->m_PMDRes = pmdSourceCommand(m_PMDHandle, offset, 16, "GetSoftOffset");
ErrorText(this->m_PMDRes);
return atof(offset);
}
bool mitk::ToFCameraPMDCamCubeController::SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height )
{
// check if leftUpperCornerX and width are divisible by 3 otherwise round to the next value divisible by 3
unsigned int factor = leftUpperCornerX/3;
leftUpperCornerX = 3*factor;
factor = width/3;
width = 3*factor;
std::stringstream command;
command<<"SetROI "<<leftUpperCornerX<<" "<<leftUpperCornerY<<" "<<width<<" "<<height;
this->m_PMDRes = pmdSourceCommand(m_PMDHandle,0,0,command.str().c_str());
return ErrorText(this->m_PMDRes);
}
bool mitk::ToFCameraPMDCamCubeController::SetRegionOfInterest( unsigned int roi[4] )
{
return this->SetRegionOfInterest(roi[0],roi[1],roi[2],roi[3]);
}
unsigned int* mitk::ToFCameraPMDCamCubeController::GetRegionOfInterest()
{
/*
char result[64];
this->m_PMDRes = pmdSourceCommand(m_PMDHandle, result, 64, "GetROI");
ErrorText(this->m_PMDRes);
// convert char array to uint array
unsigned int roi[4];
std::stringstream currentValue;
int counter = 0;
std::string resultString = result;
char blank = ' ';
for (int i=0; i<64; i++)
{
if (result[i]!=blank)
{
currentValue<<result[i];
}
else
{
if (counter<4)
{
roi[counter] = atoi(currentValue.str().c_str());
counter++;
// empty the stream
currentValue.str("");
currentValue.clear();
}
}
}
return roi;
*/
return NULL;
}
bool mitk::ToFCameraPMDCamCubeController::SetExposureMode( int mode )
{
if (mode==0) // normal mode
{
this->m_PMDRes = pmdSourceCommand(m_PMDHandle, 0, 0, "SetExposureMode Normal");
return ErrorText(this->m_PMDRes);
}
else if (mode==1) // SMB mode
{
this->m_PMDRes = pmdSourceCommand(m_PMDHandle, 0, 0, "SetExposureMode SMB");
return ErrorText(this->m_PMDRes);
}
else
{
MITK_ERROR<<"Specified exposure mode not supported. Exposure mode must be 0 (Normal) or 1 (SMB)";
return false;
}
}
bool mitk::ToFCameraPMDCamCubeController::SetFieldOfView( float fov )
{
std::stringstream commandStream;
commandStream<<"SetFOV "<<fov;
this->m_PMDRes = pmdProcessingCommand(m_PMDHandle, 0, 0, commandStream.str().c_str());
return ErrorText(this->m_PMDRes);
}
bool mitk::ToFCameraPMDCamCubeController::SetFPNCalibration( bool on )
{
if(on)
{
this->m_PMDRes=pmdSourceCommand(m_PMDHandle,0,0,"SetFPNCalibration On");
return this->ErrorText(this->m_PMDRes);
}
else
{
this->m_PMDRes=pmdSourceCommand(m_PMDHandle,0,0,"SetFPNCalibration Off");
return this->ErrorText(this->m_PMDRes);
}
}
bool mitk::ToFCameraPMDCamCubeController::SetFPPNCalibration( bool on )
{
if(on)
{
this->m_PMDRes=pmdProcessingCommand(m_PMDHandle,0,0,"SetFPPNCalibration On");
return this->ErrorText(this->m_PMDRes);
}
else
{
this->m_PMDRes=pmdProcessingCommand(m_PMDHandle,0,0,"SetFPPNCalibration Off");
return this->ErrorText(this->m_PMDRes);
}
}
bool mitk::ToFCameraPMDCamCubeController::SetLinearityCalibration( bool on )
{
if(on)
{
this->m_PMDRes=pmdProcessingCommand(m_PMDHandle,0,0,"SetLinearityCalibration On");
return this->ErrorText(this->m_PMDRes);
}
else
{
this->m_PMDRes=pmdProcessingCommand(m_PMDHandle,0,0,"SetLinearityCalibration Off");
return this->ErrorText(this->m_PMDRes);
}
}
bool mitk::ToFCameraPMDCamCubeController::SetLensCalibration( bool on )
{
if (on)
{
this->m_PMDRes = pmdProcessingCommand(m_PMDHandle, 0, 0, "SetLensCalibration On");
return ErrorText(this->m_PMDRes);
}
else
{
this->m_PMDRes = pmdProcessingCommand(m_PMDHandle, 0, 0, "SetLensCalibration Off");
return ErrorText(this->m_PMDRes);
}
}
+
+ void ToFCameraPMDCamCubeController::TransformCameraOutput( float* in, float* out, bool isDist )
+ {
+ vnl_matrix<float> inMat = vnl_matrix<float>(m_CaptureHeight,m_CaptureWidth);
+ inMat.copy_in(in);
+ vnl_matrix<float> outMat = vnl_matrix<float>(m_InternalCaptureHeight, m_InternalCaptureWidth);
+ outMat = inMat.extract(m_InternalCaptureHeight, m_InternalCaptureWidth, 0,0);
+ outMat.fliplr();
+ if(isDist)
+ {
+ outMat*=1000;
+ }
+ outMat.copy_out(out);
+ inMat.clear();
+ outMat.clear();
+ }
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.h
index 06071cf610..69f10504d7 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.h
@@ -1,126 +1,128 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDCamCubeController_h
#define __mitkToFCameraPMDCamCubeController_h
#include "mitkPMDModuleExports.h"
#include "mitkCommon.h"
#include "mitkToFCameraPMDController.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace mitk
{
/**
* @brief Interface to the Time-of-Flight (ToF) camera PMD CamCube
*
*
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDCamCubeController : public ToFCameraPMDController
{
public:
mitkClassMacro( ToFCameraPMDCamCubeController , ToFCameraPMDController );
itkNewMacro( Self );
/*!
\brief opens a connection to the ToF camera and initializes the hardware specific members
\return returns whether the connection was successful (true) or not (false)
*/
virtual bool OpenCameraConnection();
/*!
\brief sets an additional distance offset which will be added to all distance values.
\param offset offset in m
\return returns whether set operation was successful (true) or not (false)
*/
bool SetDistanceOffset( float offset );
/*!
\brief returns the currently applied distance offset in m
\param offset offset in m
*/
float GetDistanceOffset();
/*!
\brief Setting the region of interest, the camera is configured to only output a certain area of the image.
\param leftUpperCornerX x value of left upper corner of region
\param leftUpperCornerX y value of left upper corner of region
\param width width of region
\param height height of region
\return returns whether set operation was successful (true) or not (false)
*/
bool SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height );
/*!
\brief Setting the region of interest, the camera is configured to only output a certain area of the image.
\param roi region of interest. roi[0]: x value of left upper corner, roi[1]: y value of left upper corner, roi[2]: width, roi[3]: height
\return returns whether set operation was successful (true) or not (false)
*/
bool SetRegionOfInterest( unsigned int roi[4] );
/*!
\brief returns the region of interest currently set
\return currently set region of interest.
*/
unsigned int* GetRegionOfInterest();
/*!
\brief sets the exposure mode of the CamCube
\param mode exposure mode. 0: normal mode (one exposure), 1: Suppression of motion blur (SMB), minimizes the time needed to capture
a distance image from the camera which results in a reduced amount of motion artifact but may lead to increased noise.
\return returns whether set operation was successful (true) or not (false)
*/
bool SetExposureMode( int mode );
/*!
\brief Sets the field of view of the camera lens.
\param fov field of view in degrees. The default value is 40 degrees.
\return returns whether set operation was successful (true) or not (false)
*/
bool SetFieldOfView( float fov );
/*!
\brief Enable/Disable PMD fixed pattern noise (FPN) calibration
\param on enabled (true), disabled (false)
\return returns whether set operation was successful (true) or not (false)
*/
bool SetFPNCalibration( bool on );
/*!
\brief Enable/Disable PMD fixed pattern phase noise (FPPN) calibration
\param on enabled (true), disabled (false)
\return returns whether set operation was successful (true) or not (false)
*/
bool SetFPPNCalibration( bool on );
/*!
\brief Enable/Disable PMD linearity calibration
\param on enabled (true), disabled (false)
\return returns whether set operation was successful (true) or not (false)
*/
bool SetLinearityCalibration( bool on );
/*!
\brief Enable/Disable PMD lens calibration
\param on enabled (true), disabled (false)
\return returns whether set operation was successful (true) or not (false)
*/
bool SetLensCalibration( bool on );
protected:
+ virtual void TransformCameraOutput(float* in, float* out, bool isDist);
+
ToFCameraPMDCamCubeController();
~ToFCameraPMDCamCubeController();
private:
};
} //END mitk namespace
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeDeviceFactory.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeDeviceFactory.h
index 9c9c9c35c6..4d2e129ce1 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeDeviceFactory.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeDeviceFactory.h
@@ -1,87 +1,90 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDCamCubeDeviceFactory_h
#define __mitkToFCameraPMDCamCubeDeviceFactory_h
#include "mitkPMDModuleExports.h"
#include "mitkToFCameraPMDCamCubeDevice.h"
#include "mitkAbstractToFDeviceFactory.h"
#include <mitkCameraIntrinsics.h>
#include <mitkCameraIntrinsicsProperty.h>
#include <mitkToFConfig.h>
namespace mitk
{
/**
* \brief ToFPMDCamBoardDeviceFactory is an implementation of the factory pattern to generate Cam Cube Devices.
* ToFPMDCamCubeDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
* This offers users the oppertunity to generate new Cam Cube Devices via a global instance of this factory.
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDCamCubeDeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
public:
ToFCameraPMDCamCubeDeviceFactory()
{
this->m_DeviceNumber=1;
}
/*!
\brief Defining the Factorie´s Name, here for the ToFPMDCamCube.
*/
std::string GetFactoryName()
{
return std::string("PMD Camcube 2.0/3.0 Factory ");
}
std::string GetCurrentDeviceName()
{
std::stringstream name;
if(m_DeviceNumber>1)
{
name << "PMD CamCube 2.0/3.0 "<< m_DeviceNumber;
}
else
{
name << "PMD CamCube 2.0/3.0 ";
}
m_DeviceNumber++;
return name.str();
}
private:
/*!
\brief Create an instance of a ToFPMDCamCubeDevice.
*/
ToFCameraDevice::Pointer createToFCameraDevice()
{
ToFCameraPMDCamCubeDevice::Pointer device = ToFCameraPMDCamCubeDevice::New();
//Set default camera intrinsics for the CamCube Amplitude Camera.
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
pathToDefaulCalibrationFile.append("/CalibrationFiles/PMDCamCube3_camera.xml");
MITK_INFO <<pathToDefaulCalibrationFile;
cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
+ device->SetBoolProperty("HasRGBImage", false);
+ device->SetBoolProperty("HasAmplitudeImage", true);
+ device->SetBoolProperty("HasIntensityImage", true);
return device.GetPointer();
}
int m_DeviceNumber;
};
}
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDController.cpp b/Modules/ToFHardware/PMD/mitkToFCameraPMDController.cpp
index b7782bb07f..dea574ea64 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDController.cpp
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDController.cpp
@@ -1,180 +1,201 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraPMDController.h"
#include <pmdsdk2.h>
#include <string.h>
+// vnl includes
+#include "vnl/vnl_matrix.h"
+
PMDHandle m_PMDHandle; //TODO
PMDDataDescription m_DataDescription; //TODO
struct SourceDataStruct {
PMDDataDescription dataDescription;
char sourceData;
};
namespace mitk
{
ToFCameraPMDController::ToFCameraPMDController(): m_PMDRes(0), m_PixelNumber(40000), m_NumberOfBytes(0),
- m_CaptureWidth(200), m_CaptureHeight(200), m_SourceDataSize(0), m_SourceDataStructSize(0), m_ConnectionCheck(false),
+ m_CaptureWidth(200), m_CaptureHeight(200),m_InternalCaptureWidth(m_CaptureWidth),m_InternalCaptureHeight(m_CaptureHeight), m_SourceDataSize(0), m_SourceDataStructSize(0), m_ConnectionCheck(false),
m_InputFileName("")
{
}
ToFCameraPMDController::~ToFCameraPMDController()
{
}
bool ToFCameraPMDController::CloseCameraConnection()
{
m_PMDRes = pmdClose(m_PMDHandle);
m_ConnectionCheck = ErrorText(m_PMDRes);
m_PMDHandle = 0;
return m_ConnectionCheck;
}
bool ToFCameraPMDController::ErrorText(int error)
{
if(error != PMD_OK)
{
pmdGetLastError (m_PMDHandle, m_PMDError, 128);
- MITK_ERROR << "PMD CamCube Error " << m_PMDError;
- mitkThrow() << "PMD CamCube Error " << m_PMDError;
+ MITK_ERROR << "PMD Error " << m_PMDError;
+ mitkThrow() << "PMD Error " << m_PMDError;
return false;
}
else return true;
}
bool ToFCameraPMDController::UpdateCamera()
{
m_PMDRes = pmdUpdate(m_PMDHandle);
return ErrorText(m_PMDRes);
}
bool ToFCameraPMDController::GetAmplitudes(float* amplitudeArray)
{
- this->m_PMDRes = pmdGetAmplitudes(m_PMDHandle, amplitudeArray, this->m_NumberOfBytes);
+ float* tempArray = new float[m_CaptureWidth*m_CaptureHeight];
+ this->m_PMDRes = pmdGetAmplitudes(m_PMDHandle, tempArray, this->m_NumberOfBytes);
+ TransformCameraOutput(tempArray, amplitudeArray, false);
+ delete[] tempArray;
return ErrorText(this->m_PMDRes);
}
bool ToFCameraPMDController::GetAmplitudes(char* sourceData, float* amplitudeArray)
{
- this->m_PMDRes = pmdCalcAmplitudes(m_PMDHandle, amplitudeArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
+ float* tempArray = new float[m_CaptureWidth*m_CaptureHeight];
+ this->m_PMDRes = pmdCalcAmplitudes(m_PMDHandle, tempArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
+ TransformCameraOutput(tempArray, amplitudeArray, false);
+ delete[] tempArray;
return ErrorText(this->m_PMDRes);
}
bool ToFCameraPMDController::GetIntensities(float* intensityArray)
{
- this->m_PMDRes = pmdGetIntensities(m_PMDHandle, intensityArray, this->m_NumberOfBytes);
+ float* tempArray = new float[m_CaptureWidth*m_CaptureHeight];
+ this->m_PMDRes = pmdGetIntensities(m_PMDHandle, tempArray, this->m_NumberOfBytes);
+ TransformCameraOutput(tempArray, intensityArray, false);
+ delete[] tempArray;
return ErrorText(this->m_PMDRes);
}
bool ToFCameraPMDController::GetIntensities(char* sourceData, float* intensityArray)
{
- this->m_PMDRes = pmdCalcIntensities(m_PMDHandle, intensityArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
+ float* tempArray = new float[m_CaptureWidth*m_CaptureHeight];
+ this->m_PMDRes = pmdCalcIntensities(m_PMDHandle, tempArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
+ TransformCameraOutput(tempArray, intensityArray, false);
+ delete[] tempArray;
return ErrorText(this->m_PMDRes);
}
bool ToFCameraPMDController::GetDistances(float* distanceArray)
{
- this->m_PMDRes = pmdGetDistances(m_PMDHandle, distanceArray, this->m_NumberOfBytes);
+ float* tempArray = new float[m_CaptureWidth*m_CaptureHeight];
+ this->m_PMDRes = pmdGetDistances(m_PMDHandle, tempArray, this->m_NumberOfBytes);
+ TransformCameraOutput(tempArray, distanceArray, true);
+ delete[] tempArray;
return ErrorText(this->m_PMDRes);
}
bool ToFCameraPMDController::GetDistances(char* sourceData, float* distanceArray)
{
- this->m_PMDRes = pmdCalcDistances(m_PMDHandle, distanceArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
+ float* tempArray = new float[m_CaptureWidth*m_CaptureHeight];
+ this->m_PMDRes = pmdCalcDistances(m_PMDHandle, tempArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
+ TransformCameraOutput(tempArray, distanceArray, true);
+ delete[] tempArray;
return ErrorText(this->m_PMDRes);
}
bool ToFCameraPMDController::GetSourceData(char* sourceDataArray)
{
this->m_PMDRes = pmdGetSourceDataDescription(m_PMDHandle, &m_DataDescription);
if (!ErrorText(this->m_PMDRes))
{
return false;
}
memcpy(&((SourceDataStruct*)sourceDataArray)->dataDescription, &m_DataDescription, sizeof(m_DataDescription));
this->m_PMDRes = pmdGetSourceData(m_PMDHandle, &((SourceDataStruct*)sourceDataArray)->sourceData, this->m_SourceDataSize);
return ErrorText(this->m_PMDRes);
}
bool ToFCameraPMDController::GetShortSourceData( short* sourceData)
{
this->m_PMDRes = pmdGetSourceDataDescription(m_PMDHandle,&m_DataDescription);
ErrorText( this->m_PMDRes);
this->m_PMDRes = pmdGetSourceData(m_PMDHandle,sourceData,m_DataDescription.size);
return ErrorText( this->m_PMDRes);
}
int ToFCameraPMDController::SetIntegrationTime(unsigned int integrationTime)
{
if(!m_ConnectionCheck)
{
return integrationTime;
}
unsigned int result;
this->m_PMDRes = pmdGetValidIntegrationTime(m_PMDHandle, &result, 0, CloseTo, integrationTime);
MITK_INFO << "Valid Integration Time = " << result;
ErrorText(this->m_PMDRes);
if (this->m_PMDRes != 0)
{
return 0;
}
this->m_PMDRes = pmdSetIntegrationTime(m_PMDHandle, 0, result);
ErrorText(this->m_PMDRes);
return result;
}
int ToFCameraPMDController::GetIntegrationTime()
{
unsigned int integrationTime = 0;
this->m_PMDRes = pmdGetIntegrationTime(m_PMDHandle, &integrationTime, 0);
ErrorText(this->m_PMDRes);
return integrationTime;
}
int ToFCameraPMDController::SetModulationFrequency(unsigned int modulationFrequency)
{
if(!m_ConnectionCheck)
{
return modulationFrequency;
}
unsigned int result;
this->m_PMDRes = pmdGetValidModulationFrequency(m_PMDHandle, &result, 0, AtLeast, (modulationFrequency*1000000));
MITK_INFO << "Valid Modulation Frequency = " << result;
ErrorText(this->m_PMDRes);
if (this->m_PMDRes != 0)
{
return 0;
}
this->m_PMDRes = pmdSetModulationFrequency(m_PMDHandle, 0, result);
ErrorText(this->m_PMDRes);
return (result/1000000);;
}
int ToFCameraPMDController::GetModulationFrequency()
{
unsigned int modulationFrequency = 0;
this->m_PMDRes = pmdGetModulationFrequency (m_PMDHandle, &modulationFrequency, 0);
ErrorText(this->m_PMDRes);
return (modulationFrequency/1000000);
}
void ToFCameraPMDController::SetInputFileName(std::string inputFileName)
{
this->m_InputFileName = inputFileName;
}
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDController.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDController.h
index f2f4fc55cb..8fce336a0e 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDController.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDController.h
@@ -1,180 +1,201 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDController_h
#define __mitkToFCameraPMDController_h
#include "mitkPMDModuleExports.h"
#include "mitkCommon.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace mitk
{
/**
* @brief Virtual interface and base class for all PMD Time-of-Flight devices. Wraps PMD API provided in PMDSDK2
* Provides methods for accessing current distance, amplitude, intensity and raw data.
* Allows to set parameters like modulation frequency and integration time.
*
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDController : public itk::Object
{
public:
mitkClassMacro( ToFCameraPMDController , itk::Object );
/*!
\brief opens a connection to the ToF camera. Has to be implemented by the sub class
\throws mitkException In case of no connection, an exception is thrown!
*/
//TODO return value
virtual bool OpenCameraConnection() = 0;
/*!
\brief closes the connection to the camera
*/
//TODO return value
virtual bool CloseCameraConnection();
/*!
\brief Gets the current amplitude array from the device
\param amplitudeArray float array where the amplitude data will be saved
*/
virtual bool GetAmplitudes(float* amplitudeArray);
/*!
\brief Calculates the current amplitude data from the raw source data using the processing plugin of the PMDSDK
\param sourceData raw data array
\param amplitudeArray float array where the amplitude data will be saved
*/
virtual bool GetAmplitudes(char* sourceData, float* amplitudeArray);
/*!
\brief Gets the current intensity array from the device
\param intensityArray float array where the intensity data will be saved
*/
virtual bool GetIntensities(float* intensityArray);
/*!
\brief Calculates the current intensity data from the raw source data using the processing plugin of the PMDSDK
\param sourceData raw data array
\param intensityArray float array where the intensity data will be saved
*/
virtual bool GetIntensities(char* sourceData, float* intensityArray);
/*!
\brief Gets the current distance array from the device
\param distanceArray float array where the distance data will be saved
*/
virtual bool GetDistances(float* distanceArray);
/*!
\brief Calculates the current distance data from the raw source data using the processing plugin of the PMDSDK
\param sourceData raw data array
\param distanceArray float array where the distance data will be saved
*/
virtual bool GetDistances(char* sourceData, float* distanceArray);
/*!
\brief Gets the PMD raw data from the ToF device.
\param sourceDataArray array where the raw data will be saved
*/
virtual bool GetSourceData(char* sourceDataArray);
/*!
\brief Convenience method to get the PMD raw data from the ToF device as short array.
\param sourceData array where the short raw data will be saved
*/
bool GetShortSourceData(short* sourceData);
/*!
\brief calls update on the camera -> a new ToF-image is aquired
\throws mitkException In case of no connection, an exception is thrown!
*/
virtual bool UpdateCamera();
/*!
\brief Returns the currently set modulation frequency.
\return modulation frequency
*/
virtual int GetModulationFrequency();
/*!
\brief Sets the modulation frequency of the ToF device.
The method automatically calculates a valid value from the given frequency to
make sure that only valid frequencies are used.
\param modulationFrequency modulation frequency
\return frequency set after validation step
*/
virtual int SetModulationFrequency(unsigned int modulationFrequency);
/*!
\brief Returns the currently set integration time.
\return integration time
*/
virtual int GetIntegrationTime();
/*!
\brief Sets the integration time of the ToF device.
The method automatically calculates a valid value from the given integration time to
make sure that only valid times are used.
\param integrationTime integration time
\return integration time set after validation step
*/
virtual int SetIntegrationTime(unsigned int integrationTime);
/*!
\brief set input file name used by PMD player classes
*/
virtual void SetInputFileName(std::string inputFileName);
/*!
\brief Access the resolution of the image in x direction
\return widht of image in pixel
*/
itkGetMacro(CaptureWidth, unsigned int);
/*!
\brief Access the resolution of the image in y direction
\return height of image in pixel
*/
itkGetMacro(CaptureHeight, unsigned int);
+ /*!
+ \brief Access the chosen width of the resulting image in x direction
+ \return widht of image in pixel
+ */
+ itkGetMacro(InternalCaptureWidth, unsigned int);
+ /*!
+ \brief Access the chosen width of the resulting image in y direction
+ \return height of image in pixel
+ */
+ itkGetMacro(InternalCaptureHeight, unsigned int);
itkGetMacro(SourceDataStructSize, int);
protected:
ToFCameraPMDController();
~ToFCameraPMDController();
/*!
\brief Method printing the current error message to the console and returning whether the previous command was successful
\param error error number returned by the PMD function
\return flag indicating if an error occured (false) or not (true)
*/
bool ErrorText(int error);
+ /*
+ \brief Abstract method that should be used to transform the camera output (e.g. flip / rotate / select region of interest).
+ To be implemented by subclasses
+ \param input data array of original size (m_CaptureWidth x m_CaptureHeight)
+ \param rotated output data array of reduced size (m_InternalCaptureWidth x m_InternalCaputureHeight)
+ \param isDist flag indicating whether the input contains PMD distance information
+ */
+ virtual void TransformCameraOutput(float* in, float* out, bool isDist)=0;
+
char m_PMDError[128]; ///< member holding the current error text
int m_PMDRes; ///< holds the current result message provided by PMD
int m_PixelNumber; ///< holds the number of pixels contained in the image
int m_NumberOfBytes; ///< holds the number of bytes contained in the image
- unsigned int m_CaptureWidth; ///< holds the width of the image in pixel
- unsigned int m_CaptureHeight; ///< holds the height of the image in pixel
+ unsigned int m_CaptureWidth; ///< holds the width of the image in pixel as it is originally acquired by the camera
+ unsigned int m_CaptureHeight; ///< holds the height of the image in pixel as it is originally acquired by the camera
+ unsigned int m_InternalCaptureWidth; ///< holds the width of the image in pixel as it is requested by the user (cf. TransformCameraOutput()) Default: m_CaptureWidth
+ unsigned int m_InternalCaptureHeight; ///< holds the height of the image in pixel as is it requested by the user (cf. TransformCameraOutput()) Default: m_CaptureHeight
int m_SourceDataSize; ///< size of the original PMD source data
int m_SourceDataStructSize; ///< size of the PMD source data struct and the PMD source data
bool m_ConnectionCheck; ///< flag showing whether the camera is connected (true) or not (false)
std::string m_InputFileName; ///< input file name used by PMD player classes
char *m_SourcePlugin; ///< holds name of source plugin to be loaded (e.g. camcube3.W64.pap for CamCube 3.0 on Win64 platform)
char *m_SourceParam; ///< holds source parameter(s)
char *m_ProcPlugin; ///< holds name of processing plugin to be loaded (e.g. camcubeproc.W64.pap for CamCube 3.0 on Win64 platform)
char *m_ProcParam; ///< holds processing parameter(s)
private:
};
} //END mitk namespace
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDDevice.cpp b/Modules/ToFHardware/PMD/mitkToFCameraPMDDevice.cpp
index c6d395b67c..82d0afcdfc 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDDevice.cpp
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDDevice.cpp
@@ -1,397 +1,397 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraPMDDevice.h"
#include "mitkRealTimeClock.h"
#include "itkMultiThreader.h"
#include <itksys/SystemTools.hxx>
namespace mitk
{
ToFCameraPMDDevice::ToFCameraPMDDevice() :
m_SourceDataBuffer(NULL), m_SourceDataArray(NULL)
{
}
ToFCameraPMDDevice::~ToFCameraPMDDevice()
{
this->CleanUpSourceData();
CleanupPixelArrays();
}
bool ToFCameraPMDDevice::OnConnectCamera()
{
bool ok = false;
if (m_Controller)
{
ok = m_Controller->OpenCameraConnection();
if (ok)
{
- this->m_CaptureWidth = m_Controller->GetCaptureWidth();
- this->m_CaptureHeight = m_Controller->GetCaptureHeight();
+ this->m_CaptureWidth = m_Controller->GetInternalCaptureWidth();
+ this->m_CaptureHeight = m_Controller->GetInternalCaptureHeight();
this->m_SourceDataSize = m_Controller->GetSourceDataStructSize();
this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
// allocate buffers
this->AllocatePixelArrays();
this->AllocateSourceData();
this->m_CameraConnected = true;
}
}
return ok;
}
bool ToFCameraPMDDevice::DisconnectCamera()
{
bool ok = false;
if (m_Controller)
{
ok = m_Controller->CloseCameraConnection();
if (ok)
{
m_CameraConnected = false;
}
}
return ok;
}
void ToFCameraPMDDevice::StartCamera()
{
if (m_CameraConnected)
{
// get the first image
this->m_Controller->UpdateCamera();
this->m_ImageMutex->Lock();
//this->m_Controller->GetSourceData(this->m_SourceDataArray);
this->m_Controller->GetSourceData(this->m_SourceDataBuffer[this->m_FreePos]);
this->m_FreePos = (this->m_FreePos+1) % this->m_BufferSize;
this->m_CurrentPos = (this->m_CurrentPos+1) % this->m_BufferSize;
this->m_ImageSequence++;
this->m_ImageMutex->Unlock();
this->m_CameraActiveMutex->Lock();
this->m_CameraActive = true;
this->m_CameraActiveMutex->Unlock();
this->m_ThreadID = this->m_MultiThreader->SpawnThread(this->Acquire, this);
// wait a little to make sure that the thread is started
itksys::SystemTools::Delay(10);
}
else
{
MITK_INFO<<"Camera not connected";
}
}
void ToFCameraPMDDevice::UpdateCamera()
{
if (m_Controller)
{
m_Controller->UpdateCamera();
}
}
ITK_THREAD_RETURN_TYPE ToFCameraPMDDevice::Acquire(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
ToFCameraPMDDevice* toFCameraDevice = (ToFCameraPMDDevice*)pInfo->UserData;
if (toFCameraDevice!=NULL)
{
mitk::RealTimeClock::Pointer realTimeClock;
realTimeClock = mitk::RealTimeClock::New();
double t1, t2;
t1 = realTimeClock->GetCurrentStamp();
int n = 100;
bool overflow = false;
bool printStatus = false;
while (toFCameraDevice->IsCameraActive())
{
// update the ToF camera
toFCameraDevice->UpdateCamera();
// get the source data from the camera and write it at the next free position in the buffer
toFCameraDevice->m_ImageMutex->Lock();
toFCameraDevice->m_Controller->GetSourceData(toFCameraDevice->m_SourceDataBuffer[toFCameraDevice->m_FreePos]);
toFCameraDevice->m_ImageMutex->Unlock();
// call modified to indicate that cameraDevice was modified
toFCameraDevice->Modified();
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
TODO Buffer Handling currently only works for buffer size 1
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
//toFCameraDevice->m_ImageSequence++;
toFCameraDevice->m_FreePos = (toFCameraDevice->m_FreePos+1) % toFCameraDevice->m_BufferSize;
toFCameraDevice->m_CurrentPos = (toFCameraDevice->m_CurrentPos+1) % toFCameraDevice->m_BufferSize;
toFCameraDevice->m_ImageSequence++;
if (toFCameraDevice->m_FreePos == toFCameraDevice->m_CurrentPos)
{
// buffer overflow
//MITK_INFO << "Buffer overflow!! ";
//toFCameraDevice->m_CurrentPos = (toFCameraDevice->m_CurrentPos+1) % toFCameraDevice->m_BufferSize;
//toFCameraDevice->m_ImageSequence++;
overflow = true;
}
if (toFCameraDevice->m_ImageSequence % n == 0)
{
printStatus = true;
}
if (overflow)
{
overflow = false;
}
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
END TODO Buffer Handling currently only works for buffer size 1
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
// print current framerate
if (printStatus)
{
t2 = realTimeClock->GetCurrentStamp() - t1;
//MITK_INFO << "t2: " << t2 <<" Time (s) for 1 image: " << (t2/1000) / n << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFCameraDevice->m_ImageSequence;
MITK_INFO << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFCameraDevice->m_ImageSequence;
t1 = realTimeClock->GetCurrentStamp();
printStatus = false;
}
} // end of while loop
}
return ITK_THREAD_RETURN_VALUE;
}
// TODO: Buffer size currently set to 1. Once Buffer handling is working correctly, method may be reactivated
// void ToFCameraPMDDevice::ResetBuffer(int bufferSize)
// {
// this->m_BufferSize = bufferSize;
// this->m_CurrentPos = -1;
// this->m_FreePos = 0;
// }
void ToFCameraPMDDevice::GetAmplitudes(float* amplitudeArray, int& imageSequence)
{
if (m_CameraActive)
{
// 1) copy the image buffer
// 2) Flip around y- axis (vertical axis)
m_ImageMutex->Lock();
this->m_Controller->GetAmplitudes(this->m_SourceDataBuffer[this->m_CurrentPos], this->m_AmplitudeArray);
m_ImageMutex->Unlock();
for (int i=0; i<this->m_CaptureHeight; i++)
{
for (int j=0; j<this->m_CaptureWidth; j++)
{
amplitudeArray[i*this->m_CaptureWidth+j] = this->m_AmplitudeArray[(i+1)*this->m_CaptureWidth-1-j];
}
}
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDDevice::GetIntensities(float* intensityArray, int& imageSequence)
{
if (m_CameraActive)
{
// 1) copy the image buffer
// 2) Flip around y- axis (vertical axis)
m_ImageMutex->Lock();
this->m_Controller->GetIntensities(this->m_SourceDataBuffer[this->m_CurrentPos], this->m_IntensityArray);
m_ImageMutex->Unlock();
for (int i=0; i<this->m_CaptureHeight; i++)
{
for (int j=0; j<this->m_CaptureWidth; j++)
{
intensityArray[i*this->m_CaptureWidth+j] = this->m_IntensityArray[(i+1)*this->m_CaptureWidth-1-j];
}
}
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
m_ImageMutex->Unlock();
}
void ToFCameraPMDDevice::GetDistances(float* distanceArray, int& imageSequence)
{
if (m_CameraActive)
{
// 1) copy the image buffer
// 2) convert the distance values from m to mm
// 3) Flip around y- axis (vertical axis)
m_ImageMutex->Lock();
this->m_Controller->GetDistances(this->m_SourceDataBuffer[this->m_CurrentPos], this->m_DistanceArray);
m_ImageMutex->Unlock();
for (int i=0; i<this->m_CaptureHeight; i++)
{
for (int j=0; j<this->m_CaptureWidth; j++)
{
- distanceArray[i*this->m_CaptureWidth+j] = 1000 * this->m_DistanceArray[(i+1)*this->m_CaptureWidth-1-j];
+ distanceArray[i*this->m_CaptureWidth+j] = this->m_DistanceArray[(i+1)*this->m_CaptureWidth-1-j];
}
}
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDDevice::GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* sourceDataArray,
int requiredImageSequence, int& capturedImageSequence, unsigned char* rgbDataArray)
{
if (m_CameraActive)
{
// 1) copy the image buffer
// 2) convert the distance values from m to mm
// 3) Flip around y- axis (vertical axis)
// check for empty buffer
if (this->m_ImageSequence < 0)
{
// buffer empty
MITK_INFO << "Buffer empty!! ";
capturedImageSequence = this->m_ImageSequence;
return;
}
// determine position of image in buffer
int pos = 0;
if ((requiredImageSequence < 0) || (requiredImageSequence > this->m_ImageSequence))
{
capturedImageSequence = this->m_ImageSequence;
pos = this->m_CurrentPos;
//MITK_INFO << "Required image not found! Required: " << requiredImageSequence << " delivered/current: " << this->m_ImageSequence;
}
else if (requiredImageSequence <= this->m_ImageSequence - this->m_BufferSize)
{
capturedImageSequence = (this->m_ImageSequence - this->m_BufferSize) + 1;
pos = (this->m_CurrentPos + 1) % this->m_BufferSize;
//MITK_INFO << "Out of buffer! Required: " << requiredImageSequence << " delivered: " << capturedImageSequence << " current: " << this->m_ImageSequence;
}
else // (requiredImageSequence > this->m_ImageSequence - this->m_BufferSize) && (requiredImageSequence <= this->m_ImageSequence)
{
capturedImageSequence = requiredImageSequence;
pos = (this->m_CurrentPos + (10-(this->m_ImageSequence - requiredImageSequence))) % this->m_BufferSize;
}
m_ImageMutex->Lock();
this->m_Controller->GetDistances(this->m_SourceDataBuffer[pos], this->m_DistanceArray);
this->m_Controller->GetAmplitudes(this->m_SourceDataBuffer[pos], this->m_AmplitudeArray);
this->m_Controller->GetIntensities(this->m_SourceDataBuffer[pos], this->m_IntensityArray);
memcpy(sourceDataArray, this->m_SourceDataBuffer[this->m_CurrentPos], this->m_SourceDataSize);
m_ImageMutex->Unlock();
memcpy(distanceArray, this->m_DistanceArray, this->m_CaptureWidth*this->m_CaptureHeight*sizeof(float));
memcpy(intensityArray, this->m_IntensityArray, this->m_CaptureWidth*this->m_CaptureHeight*sizeof(float));
memcpy(amplitudeArray, this->m_AmplitudeArray, this->m_CaptureWidth*this->m_CaptureHeight*sizeof(float));
//int u, v;
//for (int i=0; i<this->m_CaptureHeight; i++)
//{
// for (int j=0; j<this->m_CaptureWidth; j++)
// {
// u = i*this->m_CaptureWidth+j;
// v = (i+1)*this->m_CaptureWidth-1-j;
// distanceArray[u] = 1000 * this->m_DistanceArray[v]; // unit in minimeter
// //distanceArray[u] = this->m_DistanceArray[v]; // unit in meter
// amplitudeArray[u] = this->m_AmplitudeArray[v];
// intensityArray[u] = this->m_IntensityArray[v];
// }
//}
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
ToFCameraPMDController::Pointer ToFCameraPMDDevice::GetController()
{
return this->m_Controller;
}
void ToFCameraPMDDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
{
ToFCameraDevice::SetProperty(propertyKey,propertyValue);
if (strcmp(propertyKey, "ModulationFrequency") == 0)
{
int modulationFrequency = 0;
GetIntProperty(propertyKey, modulationFrequency);
modulationFrequency = m_Controller->SetModulationFrequency(modulationFrequency);
static_cast<mitk::IntProperty*>(propertyValue)->SetValue(modulationFrequency);
this->m_PropertyList->SetProperty(propertyKey, propertyValue );
}
else if (strcmp(propertyKey, "IntegrationTime") == 0)
{
int integrationTime = 0;
GetIntProperty(propertyKey, integrationTime);
integrationTime = m_Controller->SetIntegrationTime(integrationTime);
static_cast<mitk::IntProperty*>(propertyValue)->SetValue(integrationTime);
this->m_PropertyList->SetProperty(propertyKey, propertyValue );
}
}
void ToFCameraPMDDevice::AllocateSourceData()
{
// clean up if array and data have already been allocated
CleanUpSourceData();
// (re-) allocate memory
this->m_SourceDataArray = new char[this->m_SourceDataSize];
for(int i=0; i<this->m_SourceDataSize; i++) {this->m_SourceDataArray[i]=0;}
this->m_SourceDataBuffer = new char*[this->m_MaxBufferSize];
for(int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_SourceDataBuffer[i] = new char[this->m_SourceDataSize];
}
}
void ToFCameraPMDDevice::CleanUpSourceData()
{
if (m_SourceDataArray)
{
delete[] m_SourceDataArray;
}
if (m_SourceDataBuffer)
{
for(int i=0; i<this->m_MaxBufferSize; i++)
{
delete[] this->m_SourceDataBuffer[i];
}
delete[] this->m_SourceDataBuffer;
}
}
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDO3Controller.cpp b/Modules/ToFHardware/PMD/mitkToFCameraPMDO3Controller.cpp
index 590e516821..43cf9484cc 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDO3Controller.cpp
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDO3Controller.cpp
@@ -1,71 +1,92 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraPMDO3Controller.h"
#include <pmdsdk2.h>
#include "mitkToFConfig.h"
#include "mitkToFPMDConfig.h"
+#include "vnl/vnl_matrix.h"
+
// IP Adress of the Camera, change here if needed
#define CAMERA_ADDR "192.168.0.69"
#define SOURCE_PARAM "192.168.0.69"
#define PROC_PARAM ""
extern PMDHandle m_PMDHandle; //TODO
extern PMDDataDescription m_DataDescription; //TODO
namespace mitk
{
ToFCameraPMDO3Controller::ToFCameraPMDO3Controller()
{
m_IPAddress = CAMERA_ADDR;
m_SourcePlugin = MITK_TOF_PMDO3_SOURCE_PLUGIN;
m_SourceParam = SOURCE_PARAM;
m_ProcPlugin = MITK_TOF_PMDO3_PROCESSING_PLUGIN;
m_ProcParam = PROC_PARAM;
}
ToFCameraPMDO3Controller::~ToFCameraPMDO3Controller()
{
}
bool ToFCameraPMDO3Controller::OpenCameraConnection()
{
if(!m_ConnectionCheck)
{
m_PMDRes = pmdOpen (&m_PMDHandle , m_SourcePlugin , m_SourceParam , m_ProcPlugin , m_ProcParam );
m_ConnectionCheck = ErrorText(m_PMDRes);
// get image properties from camera
this->UpdateCamera();
m_PMDRes = pmdGetSourceDataDescription(m_PMDHandle, &m_DataDescription);
ErrorText(m_PMDRes);
m_CaptureWidth = m_DataDescription.img.numColumns;
m_CaptureHeight = m_DataDescription.img.numRows;
+ m_InternalCaptureWidth = m_CaptureWidth;
+ m_InternalCaptureHeight = m_CaptureHeight;
m_PixelNumber = m_CaptureWidth*m_CaptureHeight;
m_NumberOfBytes = m_PixelNumber * sizeof(float);
m_SourceDataSize = m_DataDescription.size;
m_SourceDataStructSize = m_DataDescription.size + sizeof(PMDDataDescription);
MITK_INFO << "Datasource size: " << m_SourceDataSize <<std::endl;
MITK_INFO << "Integration Time: " << this->GetIntegrationTime();
MITK_INFO << "Modulation Frequence: " << this->GetModulationFrequency();
return m_ConnectionCheck;
}
else return m_ConnectionCheck;
}
+ void ToFCameraPMDO3Controller::TransformCameraOutput(float* in, float* out, bool isDist)
+ {
+ vnl_matrix<float> inMat = vnl_matrix<float>(m_CaptureHeight,m_CaptureWidth);
+ inMat.copy_in(in);
+ vnl_matrix<float> outMat = vnl_matrix<float>(m_InternalCaptureHeight, m_InternalCaptureWidth);
+ vnl_matrix<float> temp = vnl_matrix<float>(m_InternalCaptureHeight, m_InternalCaptureWidth);
+ outMat = inMat.extract(m_InternalCaptureHeight, m_InternalCaptureWidth, 0,0);
+ outMat.fliplr();
+ if(isDist)
+ {
+ outMat*=1000;
+ }
+ outMat.copy_out(out);
+ inMat.clear();
+ outMat.clear();
+ temp.clear();
+ }
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDO3Controller.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDO3Controller.h
index 907322e58c..25486c9706 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDO3Controller.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDO3Controller.h
@@ -1,58 +1,63 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDO3Controller_h
#define __mitkToFCameraPMDO3Controller_h
#include "mitkPMDModuleExports.h"
#include "mitkCommon.h"
#include "mitkToFCameraPMDController.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace mitk
{
/**
* @brief Interface to the Time-of-Flight (ToF) camera PMD O3
* Connection is established over Ethernet connection. IP address must be specified.
*
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDO3Controller : public mitk::ToFCameraPMDController
{
public:
mitkClassMacro( ToFCameraPMDO3Controller , mitk::ToFCameraPMDController );
itkNewMacro( Self );
/*!
\brief opens a connection to the PMD O3 ToF camera
*/
virtual bool OpenCameraConnection();
protected:
ToFCameraPMDO3Controller();
~ToFCameraPMDO3Controller();
+ /*
+ \brief method that transforms camera input such that it is ordered correctly.
+ */
+ void TransformCameraOutput(float* in, float* out, bool isDist);
+
private:
char *m_IPAddress; ///< holds the ip adress the O3 camera is connected to
};
} //END mitk namespace
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDO3DeviceFactory.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDO3DeviceFactory.h
index 37fa879413..ec5bb6c314 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDO3DeviceFactory.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDO3DeviceFactory.h
@@ -1,90 +1,93 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDO3DeviceFactory_h
#define __mitkToFCameraPMDO3DeviceFactory_h
#include "mitkPMDModuleExports.h"
#include "mitkToFCameraPMDO3Device.h"
#include "mitkAbstractToFDeviceFactory.h"
#include <mitkCameraIntrinsics.h>
#include <mitkCameraIntrinsicsProperty.h>
#include <mitkToFConfig.h>
namespace mitk
{
/**
* \brief ToFCameraPMDO3DeviceFactory is an implementation of the factory pattern to generate Do3 Devices.
* ToFPMDCamCubeDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
* This offers users the oppertunity to generate new Cam Cube Devices via a global instance of this factory.
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDO3DeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
public:
ToFCameraPMDO3DeviceFactory()
{
this->m_DeviceNumber =1;
}
/*!
\brief Defining the Factorie´s Name, here for the ToFPMDO3Device
*/
std::string GetFactoryName()
{
return std::string("PMD O3D Factory");
}
std::string GetCurrentDeviceName()
{
std::stringstream name;
if(m_DeviceNumber>1)
{
name << "PMD O3 "<< m_DeviceNumber;
}
else
{
name << "PMD O3";
}
m_DeviceNumber++;
return name.str();
}
private:
/*!
\brief Create an instance of a ToFPMDO3DeviceFactory.
*/
ToFCameraDevice::Pointer createToFCameraDevice()
{
ToFCameraPMDO3Device::Pointer device = ToFCameraPMDO3Device::New();
-//-------------------------Intrinsics for 03 are missing-----------------------------------
- //Set default camera intrinsics for the CamBoard-camera.
- mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
- std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
-
- pathToDefaulCalibrationFile.append("/CalibrationFiles/Default_Parameters.xml");
- cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
- device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
-
-//------------------------------------------------------------------------------------------
+ //-------------------------Intrinsics for 03 are missing-----------------------------------
+ //Set default camera intrinsics for the CamBoard-camera.
+ mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
+ std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
+
+ pathToDefaulCalibrationFile.append("/CalibrationFiles/Default_Parameters.xml");
+ cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
+ device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
+
+ //------------------------------------------------------------------------------------------
+ device->SetBoolProperty("HasRGBImage", false);
+ device->SetBoolProperty("HasAmplitudeImage", true);
+ device->SetBoolProperty("HasIntensityImage", true);
return device.GetPointer();
}
int m_DeviceNumber;
};
}
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerController.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerController.h
index 45acb47266..6ea136693f 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerController.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerController.h
@@ -1,75 +1,80 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDPlayerController_h
#define __mitkToFCameraPMDPlayerController_h
#include "mitkPMDModuleExports.h"
#include "mitkToFCameraPMDController.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace mitk
{
/**
* @brief Interface to read ToF data from a PMD file
*
*
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDPlayerController : public ToFCameraPMDController
{
public:
mitkClassMacro( ToFCameraPMDPlayerController , ToFCameraPMDController );
itkNewMacro( Self );
itkSetMacro(PMDFileName, std::string);
itkGetMacro(PMDFileName, std::string);
/*!
\brief opens a connection to the ToF camera
*/
bool OpenCameraConnection();
/*!
\brief convenience method setting the modulation frequency in the PMDDataDescription
\param modulationFrequency modulation frequency
\return currently set modulation frequency in PMDDataDescription
*/
int SetModulationFrequency(unsigned int modulationFrequency);
/*!
\brief convenience method setting the integration time in the PMDDataDescription
\param integrationTime integration time
\return currently set integration time in PMDDataDescription
*/
int SetIntegrationTime(unsigned int integrationTime);
protected:
+ /*
+ \brief Transform method used for phyical camera devices. For the player no transform is needed.
+ */
+ virtual void TransformCameraOutput(float* in, float* out, bool isDist){};
+
ToFCameraPMDPlayerController();
~ToFCameraPMDPlayerController();
std::string m_PMDFileName; ///< File name of the pmd data stream
private:
unsigned int m_NumOfFrames; ///< Number of frames
};
} //END mitk namespace
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerDeviceFactory.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerDeviceFactory.h
index 1ec824224d..f9054dbece 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerDeviceFactory.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerDeviceFactory.h
@@ -1,90 +1,93 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDPlayerDeviceFactory_h
#define __mitkToFCameraPMDPlayerDeviceFactory_h
#include "mitkPMDModuleExports.h"
#include "mitkToFCameraPMDPlayerDevice.h"
#include "mitkAbstractToFDeviceFactory.h"
#include <mitkCameraIntrinsics.h>
#include <mitkCameraIntrinsicsProperty.h>
#include <mitkToFConfig.h>
namespace mitk
{
/**
* \brief ToFPMDPlayerDeviceFactory is an implementation of the factory pattern to generate PMD Player Devices.
* ToFPMDPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
* This offers users the oppertunity to generate new PMD Player Devices via a global instance of this factory.
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDPlayerDeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
public:
ToFCameraPMDPlayerDeviceFactory()
{
this->m_DeviceNumber=1;
}
/*!
\brief Defining the Factorie´s Name, here for the ToFPMDPlayer.
*/
std::string GetFactoryName()
{
return std::string("PMD Player Factory");
}
std::string GetCurrentDeviceName()
{
std::stringstream name;
if(m_DeviceNumber>1)
{
name << "PMD Player "<< m_DeviceNumber;
}
else
{
name << "PMD Player";
}
m_DeviceNumber++;
return name.str();
}
private:
/*!
\brief Create an instance of a ToFPMDPlayerDevice.
*/
ToFCameraDevice::Pointer createToFCameraDevice()
{
ToFCameraPMDPlayerDevice::Pointer device = ToFCameraPMDPlayerDevice::New();
//-------------------------If no Intrinsics are specified------------------------------
//Set default camera intrinsics for the PMD-Player.
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
pathToDefaulCalibrationFile.append("/CalibrationFiles/Default_Parameters.xml");
cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
-
//------------------------------------------------------------------------------------------
+ device->SetBoolProperty("HasRGBImage", false);
+ device->SetBoolProperty("HasAmplitudeImage", true);
+ device->SetBoolProperty("HasIntensityImage", true);
+
return device.GetPointer();
}
int m_DeviceNumber;
};
}
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamBoardDevice.cpp b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamBoardDevice.cpp
index ba0853421c..7e573eb7b6 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamBoardDevice.cpp
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamBoardDevice.cpp
@@ -1,215 +1,182 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraPMDRawDataCamBoardDevice.h"
#include "mitkToFCameraPMDCamBoardController.h"
// vtk includes
#include "vtkSmartPointer.h"
namespace mitk
{
ToFCameraPMDRawDataCamBoardDevice::ToFCameraPMDRawDataCamBoardDevice()
{
m_Controller = ToFCameraPMDCamBoardController::New();
}
ToFCameraPMDRawDataCamBoardDevice::~ToFCameraPMDRawDataCamBoardDevice()
{
}
bool ToFCameraPMDRawDataCamBoardDevice::ConnectCamera()
{
bool ok = Superclass::ConnectCamera();
if(ok)
{
- this->m_OriginControllerHeight = static_cast<ToFCameraPMDCamBoardController*>(m_Controller.GetPointer())->GetInternalCaptureHeight();
- this->m_OriginControllerWidth = static_cast<ToFCameraPMDCamBoardController*>(m_Controller.GetPointer())->GetInternalCaptureWidth();
+ this->m_OriginControllerHeight = static_cast<ToFCameraPMDCamBoardController*>(m_Controller.GetPointer())->GetCaptureHeight();
+ this->m_OriginControllerWidth = static_cast<ToFCameraPMDCamBoardController*>(m_Controller.GetPointer())->GetCaptureWidth();
this->m_PixelNumber = m_OriginControllerHeight* m_OriginControllerWidth;
this->AllocatePixelArrays();
this->AllocateSourceData();
}
return ok;
}
void ToFCameraPMDRawDataCamBoardDevice::GetChannelSourceData(short* sourceData, vtkShortArray* vtkChannelArray )
{
int i = 0;
//unsigned int channelDataPosition = 0;
unsigned int channelSize = (this->m_OriginControllerHeight*this->m_OriginControllerWidth*2);
this->SetChannelSize(channelSize);
signed short* channel1;
signed short* channel2;
signed short* channel3;
signed short* channel4;
vtkSmartPointer<vtkShortArray> cvtkChannelArray = vtkSmartPointer<vtkShortArray>::New();
cvtkChannelArray->SetNumberOfComponents(channelSize);
cvtkChannelArray->SetNumberOfTuples(4);
cvtkChannelArray->Allocate(1);
channel1 = sourceData;
cvtkChannelArray->InsertTupleValue(0,channel1);
sourceData += channelSize;
channel2 = sourceData;
cvtkChannelArray->InsertTupleValue(1,channel2);
sourceData += channelSize;
channel3 = sourceData;
cvtkChannelArray->InsertTupleValue(2,channel3);
sourceData += channelSize;
channel4 = sourceData;
cvtkChannelArray->InsertTupleValue(3,channel4);
vtkChannelArray->DeepCopy(cvtkChannelArray);
- cvtkChannelArray->Delete();
}
void ToFCameraPMDRawDataCamBoardDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
{
ToFCameraPMDRawDataDevice::SetProperty(propertyKey,propertyValue);
this->m_PropertyList->SetProperty(propertyKey, propertyValue);
-
- ToFCameraPMDCamBoardController::Pointer myController = dynamic_cast<mitk::ToFCameraPMDCamBoardController*>(this->m_Controller.GetPointer());
-
- bool boolValue = false;
- GetBoolProperty(propertyKey, boolValue);
- if (strcmp(propertyKey, "SetFPNCalibration") == 0)
- {
- myController->SetFPNCalibration(boolValue);
- }
- else if (strcmp(propertyKey, "SetFPPNCalibration") == 0)
- {
- myController->SetFPPNCalibration(boolValue);
- }
- else if (strcmp(propertyKey, "SetLinearityCalibration") == 0)
- {
- myController->SetLinearityCalibration(boolValue);
- }
- else if (strcmp(propertyKey, "SetLensCalibration") == 0)
- {
- myController->SetLensCalibration(boolValue);
- }
- else if (strcmp(propertyKey, "SetExposureMode") == 0)
- {
- if (boolValue)
- {
- myController->SetExposureMode(1);
- }
- else
- {
- myController->SetExposureMode(0);
- }
- }
}
void ToFCameraPMDRawDataCamBoardDevice::GetAmplitudes(float* amplitudeArray, int& imageSequence)
{
if (m_CameraActive)
{
this->ResizeOutputImage(m_AmplitudeArray,amplitudeArray);
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDRawDataCamBoardDevice::GetIntensities(float* intensityArray, int& imageSequence)
{
if (m_CameraActive)
{
this->ResizeOutputImage(m_IntensityArray, intensityArray);
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDRawDataCamBoardDevice::GetDistances(float* distanceArray, int& imageSequence)
{
if (m_CameraActive)
{
this->ResizeOutputImage(m_DistanceArray, distanceArray);
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDRawDataCamBoardDevice::GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* sourceDataArray,
int requiredImageSequence, int& capturedImageSequence, unsigned char* rgbDataArray)
{
if (m_CameraActive)
{
// check for empty buffer
if (this->m_ImageSequence < 0)
{
// buffer empty
MITK_INFO << "Buffer empty!! ";
capturedImageSequence = this->m_ImageSequence;
return;
}
// determine position of image in buffer
int pos = 0;
if ((requiredImageSequence < 0) || (requiredImageSequence > this->m_ImageSequence))
{
capturedImageSequence = this->m_ImageSequence;
pos = this->m_CurrentPos;
//MITK_INFO << "Required image not found! Required: " << requiredImageSequence << " delivered/current: " << this->m_ImageSequence;
}
else if (requiredImageSequence <= this->m_ImageSequence - this->m_BufferSize)
{
capturedImageSequence = (this->m_ImageSequence - this->m_BufferSize) + 1;
pos = (this->m_CurrentPos + 1) % this->m_BufferSize;
//MITK_INFO << "Out of buffer! Required: " << requiredImageSequence << " delivered: " << capturedImageSequence << " current: " << this->m_ImageSequence;
}
else // (requiredImageSequence > this->m_ImageSequence - this->m_BufferSize) && (requiredImageSequence <= this->m_ImageSequence)
{
capturedImageSequence = requiredImageSequence;
pos = (this->m_CurrentPos + (10-(this->m_ImageSequence - requiredImageSequence))) % this->m_BufferSize;
}
this->ResizeOutputImage(m_DistanceArray, distanceArray);
this->ResizeOutputImage(m_AmplitudeArray, amplitudeArray);
this->ResizeOutputImage(m_IntensityArray, intensityArray);
memcpy(sourceDataArray, this->m_SourceDataBuffer[this->m_CurrentPos], this->m_SourceDataSize);
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDRawDataCamBoardDevice::ResizeOutputImage(float* in, float* out)
{
vnl_matrix<float> inMat = vnl_matrix<float>(m_OriginControllerHeight, m_OriginControllerWidth);
inMat.copy_in(in);
vnl_matrix<float> outMat = vnl_matrix<float>(m_CaptureHeight,m_CaptureWidth);
vnl_matrix<float> temp = vnl_matrix<float>(m_CaptureHeight,m_CaptureWidth);
temp = inMat.extract(m_CaptureHeight,m_CaptureWidth, 0, 4);
outMat = temp.transpose(); // rotate the image data
outMat.flipud(); // flip image upside down
outMat.copy_out(out);
inMat.clear(); // clean data
outMat.clear();
temp.clear();
}
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDevice.cpp b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDevice.cpp
index a6ad0885dd..be7da17d1d 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDevice.cpp
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDevice.cpp
@@ -1,105 +1,104 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraPMDRawDataCamCubeDevice.h"
#include "mitkToFCameraPMDCamCubeController.h"
// vtk includes
#include "vtkSmartPointer.h"
namespace mitk
{
ToFCameraPMDRawDataCamCubeDevice::ToFCameraPMDRawDataCamCubeDevice()
{
m_Controller = ToFCameraPMDCamCubeController::New();
}
ToFCameraPMDRawDataCamCubeDevice::~ToFCameraPMDRawDataCamCubeDevice()
{
}
void ToFCameraPMDRawDataCamCubeDevice::GetChannelSourceData(short* sourceData, vtkShortArray* vtkChannelArray )
{
int i = 0;
unsigned int channelSize = (this->GetCaptureHeight()*this->GetCaptureWidth()*2);
this->SetChannelSize(channelSize);
signed short* channel1;
signed short* channel2;
signed short* channel3;
signed short* channel4;
vtkSmartPointer<vtkShortArray> tempVTKChannelArray = vtkSmartPointer<vtkShortArray>::New();
tempVTKChannelArray->SetNumberOfComponents(channelSize);
tempVTKChannelArray->SetNumberOfTuples(4);
tempVTKChannelArray->Allocate(1);
sourceData += 256;
channel1 = sourceData;
tempVTKChannelArray->InsertTupleValue(0,channel1);
sourceData += channelSize;
sourceData += 256;
channel2 = sourceData;
tempVTKChannelArray->InsertTupleValue(1,channel2);
sourceData += channelSize;
sourceData += 256;
channel3 = sourceData;
tempVTKChannelArray->InsertTupleValue(2,channel3);
sourceData += channelSize;
sourceData += 256;
channel4 = sourceData;
tempVTKChannelArray->InsertTupleValue(3,channel4);
vtkChannelArray->DeepCopy(tempVTKChannelArray);
- tempVTKChannelArray->Delete();
}
void ToFCameraPMDRawDataCamCubeDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
{
ToFCameraPMDRawDataDevice::SetProperty(propertyKey,propertyValue);
this->m_PropertyList->SetProperty(propertyKey, propertyValue);
ToFCameraPMDCamCubeController::Pointer myController = dynamic_cast<mitk::ToFCameraPMDCamCubeController*>(this->m_Controller.GetPointer());
bool boolValue = false;
GetBoolProperty(propertyKey, boolValue);
if (strcmp(propertyKey, "SetFPNCalibration") == 0)
{
myController->SetFPNCalibration(boolValue);
}
else if (strcmp(propertyKey, "SetFPPNCalibration") == 0)
{
myController->SetFPPNCalibration(boolValue);
}
else if (strcmp(propertyKey, "SetLinearityCalibration") == 0)
{
myController->SetLinearityCalibration(boolValue);
}
else if (strcmp(propertyKey, "SetLensCalibration") == 0)
{
myController->SetLensCalibration(boolValue);
}
else if (strcmp(propertyKey, "SetExposureMode") == 0)
{
if (boolValue)
{
myController->SetExposureMode(1);
}
else
{
myController->SetExposureMode(0);
}
}
}
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDeviceFactory.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDeviceFactory.h
index f4ba0fe70b..f1b84d8004 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDeviceFactory.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDeviceFactory.h
@@ -1,86 +1,90 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFCameraPMDRawDataCamCubeDeviceFactory_h
#define __mitkToFCameraPMDRawDataCamCubeDeviceFactory_h
#include "mitkPMDModuleExports.h"
#include "mitkToFCameraPMDRawDataCamCubeDevice.h"
#include "mitkAbstractToFDeviceFactory.h"
#include <mitkCameraIntrinsics.h>
#include <mitkCameraIntrinsicsProperty.h>
#include <mitkToFConfig.h>
namespace mitk
{
/**
* \brief ToFPMDRawPlayerDeviceFactory is an implementation of the factory pattern to generate Raw Player Devices.
* ToFPMDRawPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
* This offers users the oppertunity to generate new Raw Player Devices via a global instance of this factory.
* @ingroup ToFHardware
*/
class MITK_PMDMODULE_EXPORT ToFCameraPMDRawDataCamCubeDeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
public:
ToFCameraPMDRawDataCamCubeDeviceFactory()
{
this->m_DeviceNumber = 1;
}
/*!
\brief Defining the Factorie´s Name, here for the RawDataDeviceFactory.
*/
std::string GetFactoryName()
{
return std::string("PMD RAW Data Camcube Factory ");
}
std::string GetCurrentDeviceName()
{
std::stringstream name;
if(m_DeviceNumber>1)
{
name << "PMD Raw Data CamCube 2.0/3.0 "<< m_DeviceNumber;
}
else
{
name << "PMD Raw Data CamCube 2.0/3.0";
}
m_DeviceNumber++;
return name.str();
}
private:
/*!
\brief Create an instance of a ToFPMDRawDataDevice.
*/
ToFCameraDevice::Pointer createToFCameraDevice()
{
ToFCameraPMDRawDataCamCubeDevice::Pointer device = ToFCameraPMDRawDataCamCubeDevice::New();
//Set default camera intrinsics for the RawDataCamCube-Camera.
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
pathToDefaulCalibrationFile.append("/CalibrationFiles/PMDCamCube3_camera.xml");
cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
+ device->SetBoolProperty("HasRGBImage", false);
+ device->SetBoolProperty("HasAmplitudeImage", true);
+ device->SetBoolProperty("HasIntensityImage", true);
+
return device.GetPointer();
}
int m_DeviceNumber;
};
}
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataDevice.cpp b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataDevice.cpp
index cc4fa289c0..d2b4cdc362 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataDevice.cpp
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataDevice.cpp
@@ -1,482 +1,482 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraPMDRawDataDevice.h"
#include "mitkRealTimeClock.h"
#ifdef MITK_USE_TOF_PMDCAMBOARD
#include "mitkToFCameraPMDCamBoardController.h"
#endif
#ifdef MITK_USE_TOF_PMDCAMCUBE
#include "mitkToFCameraPMDCamCubeController.h"
#endif
#ifdef MITK_USE_TOF_PMDO3
#include "mitkToFCameraPMDO3Controller.h"
#endif
#include "itkMultiThreader.h"
#include <itksys/SystemTools.hxx>
namespace mitk
{
ToFCameraPMDRawDataDevice::ToFCameraPMDRawDataDevice() :
m_SourceDataBuffer(NULL), m_SourceDataArray(NULL), m_ShortSourceData(NULL),
m_OriginControllerWidth(0), m_OriginControllerHeight(0)
{
m_RawDataSource = ThreadedToFRawDataReconstruction::New();
}
ToFCameraPMDRawDataDevice::~ToFCameraPMDRawDataDevice()
{
this->CleanUpSourceData();
}
bool ToFCameraPMDRawDataDevice::OnConnectCamera()
{
bool ok = false;
if (m_Controller.IsNotNull())
{
ok = m_Controller->OpenCameraConnection();
if (ok)
{
- this->m_CaptureWidth = m_Controller->GetCaptureWidth();
- this->m_CaptureHeight = m_Controller->GetCaptureHeight();
+ this->m_CaptureWidth = m_Controller->GetInternalCaptureWidth();
+ this->m_CaptureHeight = m_Controller->GetInternalCaptureHeight();
this->m_OriginControllerHeight = m_CaptureHeight;
this->m_OriginControllerWidth = m_CaptureWidth;
this->m_SourceDataSize = m_Controller->GetSourceDataStructSize();
this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
// allocate buffers
this->AllocatePixelArrays();
this->AllocateSourceData();
this->m_CameraConnected = true;
}
}
return ok;
}
bool ToFCameraPMDRawDataDevice::DisconnectCamera()
{
bool ok = false;
if (m_Controller)
{
ok = m_Controller->CloseCameraConnection();
if (ok)
{
m_CameraConnected = false;
}
}
return ok;
}
void ToFCameraPMDRawDataDevice::StartCamera()
{
if (m_CameraConnected)
{
// get the first image
this->m_Controller->UpdateCamera();
this->m_ImageMutex->Lock();
this->m_Controller->GetSourceData(this->m_SourceDataBuffer[this->m_FreePos]);
this->m_FreePos = (this->m_FreePos+1) % this->m_BufferSize;
this->m_CurrentPos = (this->m_CurrentPos+1) % this->m_BufferSize;
this->m_ImageSequence++;
this->m_ImageMutex->Unlock();
this->m_CameraActiveMutex->Lock();
this->m_CameraActive = true;
this->m_CameraActiveMutex->Unlock();
this->m_ThreadID = this->m_MultiThreader->SpawnThread(this->Acquire, this);
// wait a little to make sure that the thread is started
itksys::SystemTools::Delay(100);
}
else
{
MITK_INFO<<"Camera not connected";
}
}
void ToFCameraPMDRawDataDevice::StopCamera()
{
m_CameraActiveMutex->Lock();
m_CameraActive = false;
m_CameraActiveMutex->Unlock();
itksys::SystemTools::Delay(100);
if (m_MultiThreader.IsNotNull())
{
m_MultiThreader->TerminateThread(m_ThreadID);
}
// wait a little to make sure that the thread is terminated
itksys::SystemTools::Delay(10);
}
bool ToFCameraPMDRawDataDevice::IsCameraActive()
{
m_CameraActiveMutex->Lock();
bool ok = m_CameraActive;
m_CameraActiveMutex->Unlock();
return ok;
}
void ToFCameraPMDRawDataDevice::UpdateCamera()
{
if (m_Controller)
{
m_Controller->UpdateCamera();
}
}
ITK_THREAD_RETURN_TYPE ToFCameraPMDRawDataDevice::Acquire(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
ToFCameraPMDRawDataDevice* toFCameraDevice = (ToFCameraPMDRawDataDevice*)pInfo->UserData;
if (toFCameraDevice!=NULL)
{
mitk::RealTimeClock::Pointer realTimeClock = mitk::RealTimeClock::New();
double t1, t2;
t1 = realTimeClock->GetCurrentStamp();
int n = 100;
bool overflow = false;
bool printStatus = false;
while (toFCameraDevice->IsCameraActive())
{
// update the ToF camera
toFCameraDevice->UpdateCamera();
// get the source data from the camera and write it at the next free position in the buffer
// call modified to indicate that cameraDevice was modified
toFCameraDevice->Modified();
vtkShortArray* channelData = vtkShortArray::New();
//toFCameraDevice->m_ImageMutex->Lock();
toFCameraDevice->m_Controller->GetShortSourceData(toFCameraDevice->m_ShortSourceData);
toFCameraDevice->GetChannelSourceData( toFCameraDevice->m_ShortSourceData, channelData );
//toFCameraDevice->m_ImageMutex->Unlock();
if(!toFCameraDevice->m_RawDataSource->GetInit())
{
toFCameraDevice->m_RawDataSource->Initialize(toFCameraDevice->m_OriginControllerWidth,
toFCameraDevice->m_OriginControllerHeight,
toFCameraDevice->m_Controller->GetModulationFrequency(),
toFCameraDevice->GetChannelSize());
}
toFCameraDevice->m_RawDataSource->SetChannelData(channelData);
toFCameraDevice->m_RawDataSource->Update();
toFCameraDevice->m_ImageMutex->Lock();
toFCameraDevice->m_Controller->GetSourceData(toFCameraDevice->m_SourceDataArray);
toFCameraDevice->m_RawDataSource->GetAllData(toFCameraDevice->m_DistanceArray,
toFCameraDevice->m_AmplitudeArray, toFCameraDevice->m_IntensityArray);
toFCameraDevice->m_ImageMutex->Unlock();
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
TODO Buffer Handling currently only works for buffer size 1
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
toFCameraDevice->m_FreePos = (toFCameraDevice->m_FreePos+1) % toFCameraDevice->m_BufferSize;
toFCameraDevice->m_CurrentPos = (toFCameraDevice->m_CurrentPos+1) % toFCameraDevice->m_BufferSize;
toFCameraDevice->m_ImageSequence++;
if (toFCameraDevice->m_FreePos == toFCameraDevice->m_CurrentPos)
{
overflow = true;
}
if (toFCameraDevice->m_ImageSequence % n == 0)
{
printStatus = true;
}
channelData->Delete();
if (overflow)
{
overflow = false;
}
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
END TODO Buffer Handling currently only works for buffer size 1
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
// print current frame rate
if (printStatus)
{
t2 = realTimeClock->GetCurrentStamp() - t1;
//MITK_INFO << "t2: " << t2 <<" Time (s) for 1 image: " << (t2/1000) / n << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFCameraDevice->m_ImageSequence;
MITK_INFO << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFCameraDevice->m_ImageSequence;
t1 = realTimeClock->GetCurrentStamp();
printStatus = false;
}
} // end of while loop
}
return ITK_THREAD_RETURN_VALUE;
}
// TODO: Buffer size currently set to 1. Once Buffer handling is working correctly, method may be reactivated
// void ToFCameraPMDDevice::ResetBuffer(int bufferSize)
// {
// this->m_BufferSize = bufferSize;
// this->m_CurrentPos = -1;
// this->m_FreePos = 0;
// }
void ToFCameraPMDRawDataDevice::GetAmplitudes(float* amplitudeArray, int& imageSequence)
{
if (m_CameraActive)
{
memcpy(amplitudeArray, this->m_AmplitudeArray, this->m_PixelNumber*sizeof(float));
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDRawDataDevice::GetIntensities(float* intensityArray, int& imageSequence)
{
if (m_CameraActive)
{
memcpy(intensityArray, this->m_IntensityArray, this->m_PixelNumber*sizeof(float));
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDRawDataDevice::GetDistances(float* distanceArray, int& imageSequence)
{
if (m_CameraActive)
{
memcpy(distanceArray, this->m_DistanceArray, this->m_PixelNumber*sizeof(float));
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDRawDataDevice::GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* sourceDataArray,
int requiredImageSequence, int& capturedImageSequence, unsigned char* rgbDataArray)
{
if (m_CameraActive)
{
// 1) copy the image buffer
// 2) convert the distance values from m to mm
// 3) Flip around y- axis (vertical axis)
// check for empty buffer
if (this->m_ImageSequence < 0)
{
// buffer empty
MITK_INFO << "Buffer empty!! ";
capturedImageSequence = this->m_ImageSequence;
return;
}
// determine position of image in buffer
int pos = 0;
if ((requiredImageSequence < 0) || (requiredImageSequence > this->m_ImageSequence))
{
capturedImageSequence = this->m_ImageSequence;
pos = this->m_CurrentPos;
//MITK_INFO << "Required image not found! Required: " << requiredImageSequence << " delivered/current: " << this->m_ImageSequence;
}
else if (requiredImageSequence <= this->m_ImageSequence - this->m_BufferSize)
{
capturedImageSequence = (this->m_ImageSequence - this->m_BufferSize) + 1;
pos = (this->m_CurrentPos + 1) % this->m_BufferSize;
//MITK_INFO << "Out of buffer! Required: " << requiredImageSequence << " delivered: " << capturedImageSequence << " current: " << this->m_ImageSequence;
}
else // (requiredImageSequence > this->m_ImageSequence - this->m_BufferSize) && (requiredImageSequence <= this->m_ImageSequence)
{
capturedImageSequence = requiredImageSequence;
pos = (this->m_CurrentPos + (10-(this->m_ImageSequence - requiredImageSequence))) % this->m_BufferSize;
}
memcpy(distanceArray, this->m_DistanceArray, this->m_PixelNumber*sizeof(float));
memcpy(amplitudeArray, this->m_AmplitudeArray, this->m_PixelNumber*sizeof(float));
memcpy(intensityArray, this->m_IntensityArray, this->m_PixelNumber*sizeof(float));
memcpy(sourceDataArray, this->m_SourceDataBuffer[this->m_CurrentPos], this->m_SourceDataSize);
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
void ToFCameraPMDRawDataDevice::XYAxisFlipImage( float* imageData, float* &flippedData, int xAxis, int yAxis, int dimension )
{
int captureWidth = this->GetCaptureWidth();
int captureHeight = this->GetCaptureHeight();
//
//flips image around x- axis (horizontal axis)
//
if(xAxis == 1 && yAxis != 1)
{
for (int i=0; i<captureHeight; i++)
{
for (int j=0; j<captureWidth; j++)
{
for (int k=0; k<dimension; k++)
{
flippedData[i*captureWidth*dimension+j*dimension+k] = imageData[((captureHeight-1-i)*captureWidth*dimension)+((j)*dimension+k)];
}
}
}
}
//
// flips image around y- axis (vertical axis)
//
if(xAxis!=1 && yAxis == 1)
{
for (int i=0; i<captureHeight; i++)
{
for (int j=0; j<captureWidth; j++)
{
for (int k=0; k<dimension; k++)
{
flippedData[i*captureWidth*dimension+j*dimension+k] = imageData[(i+1)*captureWidth*dimension-1-j*dimension-k];
}
}
}
}
//
//flips image around x- and y- axis
//
else if(xAxis == 1 && yAxis == 1)
{
for (int i=0; i<captureHeight; i++)
{
for (int j=0; j<captureWidth; j++)
{
for (int k=0; k<dimension; k++)
{
flippedData[i*captureWidth*dimension+j*dimension+k] = imageData[((captureHeight-i)*(captureWidth)*dimension-1)-(j*dimension-k)];
}
}
}
}
}
ToFCameraPMDController::Pointer ToFCameraPMDRawDataDevice::GetController()
{
return this->m_Controller;
}
void ToFCameraPMDRawDataDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
{
ToFCameraDevice::SetProperty(propertyKey,propertyValue);
this->m_PropertyList->SetProperty(propertyKey, propertyValue);
if (strcmp(propertyKey, "ModulationFrequency") == 0)
{
int modulationFrequency = 0;
GetIntProperty(propertyKey, modulationFrequency);
m_Controller->SetModulationFrequency(modulationFrequency);
}
else if (strcmp(propertyKey, "IntegrationTime") == 0)
{
int integrationTime = 0;
GetIntProperty(propertyKey, integrationTime);
m_Controller->SetIntegrationTime(integrationTime);
}
}
void ToFCameraPMDRawDataDevice::CleanupPixelArrays()
{
if (m_IntensityArray)
{
delete [] m_IntensityArray;
}
if (m_DistanceArray)
{
delete [] m_DistanceArray;
}
if (m_AmplitudeArray)
{
delete [] m_AmplitudeArray;
}
if (m_ShortSourceData)
{
delete [] m_ShortSourceData;
}
}
void ToFCameraPMDRawDataDevice::AllocatePixelArrays()
{
// free memory if it was already allocated
CleanupPixelArrays();
// allocate buffer
this->m_IntensityArray = new float[this->m_PixelNumber];
for(int i=0; i<this->m_PixelNumber; i++) {this->m_IntensityArray[i]=0.0;}
this->m_DistanceArray = new float[this->m_PixelNumber];
for(int i=0; i<this->m_PixelNumber; i++) {this->m_DistanceArray[i]=0.0;}
this->m_AmplitudeArray = new float[this->m_PixelNumber];
for(int i=0; i<this->m_PixelNumber; i++) {this->m_AmplitudeArray[i]=0.0;}
this->m_ShortSourceData = new short[this->m_SourceDataSize];
for(int i=0; i<this->m_SourceDataSize; i++) {this->m_ShortSourceData[i]=0.0;}
}
void ToFCameraPMDRawDataDevice::AllocateSourceData()
{
// clean up if array and data have already been allocated
CleanUpSourceData();
// (re-) allocate memory
this->m_SourceDataArray = new char[this->m_SourceDataSize];
for(int i=0; i<this->m_SourceDataSize; i++) {this->m_SourceDataArray[i]=0;}
this->m_SourceDataBuffer = new char*[this->m_MaxBufferSize];
for(int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_SourceDataBuffer[i] = new char[this->m_SourceDataSize];
}
}
void ToFCameraPMDRawDataDevice::CleanUpSourceData()
{
if (m_SourceDataArray)
{
delete[] m_SourceDataArray;
}
if (m_SourceDataBuffer)
{
for(int i=0; i<this->m_MaxBufferSize; i++)
{
delete[] this->m_SourceDataBuffer[i];
}
delete[] this->m_SourceDataBuffer;
}
}
}
diff --git a/Modules/ToFHardware/Testing/CMakeLists.txt b/Modules/ToFHardware/Testing/CMakeLists.txt
index 153cd81e2e..18a8ecaa80 100644
--- a/Modules/ToFHardware/Testing/CMakeLists.txt
+++ b/Modules/ToFHardware/Testing/CMakeLists.txt
@@ -1 +1,19 @@
MITK_CREATE_MODULE_TESTS()
+if(BUILD_TESTING AND MODULE_IS_ENABLED)
+#Only enabled for Windows and Mac nightlies.
+#If you want to run this on linux, just enable the flag in the superbuild.
+if(WIN32 OR APPLE OR MITK_ENABLE_GUI_TESTING)
+
+mitkAddCustomModuleTest(mitkPlayerLoadAndRenderDepthDataTest_KinectDepthImage #testname
+mitkPlayerLoadAndRenderDepthDataTest #testclassname
+Kinect_LiverPhantom_DistanceImage.nrrd #input image
+-V ${MITK_DATA_DIR}/ToF-Data/ReferenceScreenshots/Kinect_LiverPhantom_DistanceImage640x480REF.png #reference image
+)
+
+mitkAddCustomModuleTest(mitkPlayerLoadAndRenderRGBDataTest_KinectRGBImage mitkPlayerLoadAndRenderRGBDataTest Kinect_LiverPhantom_RGBImage.nrrd -V ${MITK_DATA_DIR}/ToF-Data/ReferenceScreenshots/Kinect_LiverPhantom_RGBImage640x480REF.png)
+
+#rendering tests cannot run in parallel
+SET_PROPERTY(TEST mitkPlayerLoadAndRenderDepthDataTest_KinectDepthImage mitkPlayerLoadAndRenderRGBDataTest_KinectRGBImage PROPERTY RUN_SERIAL TRUE)
+
+endif(WIN32 OR APPLE OR MITK_ENABLE_GUI_TESTING)
+endif(BUILD_TESTING AND MODULE_IS_ENABLED)
diff --git a/Modules/ToFHardware/Testing/files.cmake b/Modules/ToFHardware/Testing/files.cmake
index b7c8e3aa46..fbff7863fc 100644
--- a/Modules/ToFHardware/Testing/files.cmake
+++ b/Modules/ToFHardware/Testing/files.cmake
@@ -1,28 +1,16 @@
set(MODULE_TESTS
#mitkThreadedToFRawDataReconstructionTest.cpp
-# mitkKinectControllerTest.cpp
-# mitkKinectDeviceTest.cpp
-# mitkToFCameraPMDCamBoardControllerTest.cpp
-# mitkToFCameraPMDCamBoardDeviceTest.cpp
-# mitkToFCameraPMDRawDataCamBoardDeviceTest.cpp
-# mitkToFCameraPMDRawDataCamCubeDeviceTest.cpp
-# mitkToFCameraPMDCamCubeControllerTest.cpp
-# mitkToFCameraPMDCamCubeDeviceTest.cpp
-# mitkToFCameraPMDPlayerControllerTest.cpp
-# mitkToFCameraPMDPlayerDeviceTest.cpp
-# mitkToFCameraPMDControllerTest.cpp
-# mitkToFCameraPMDDeviceTest.cpp
-# mitkToFCameraPMDRawDataDeviceTest.cpp
- #mitkToFCameraPMDMITKPlayerControllerTest.cpp
- #mitkToFCameraPMDMITKPlayerDeviceTest.cpp
-# mitkToFCameraPMDO3ControllerTest.cpp
-# mitkToFCameraPMDO3DeviceTest.cpp
mitkToFImageCsvWriterTest.cpp
mitkToFImageGrabberTest.cpp
#mitkToFImageRecorderTest.cpp
#mitkToFImageRecorderFilterTest.cpp
mitkToFImageWriterTest.cpp
mitkToFNrrdImageWriterTest.cpp
mitkToFOpenCVImageGrabberTest.cpp
)
+set(MODULE_CUSTOM_TESTS
+ mitkPlayerLoadAndRenderDepthDataTest.cpp
+ mitkPlayerLoadAndRenderRGBDataTest.cpp
+)
+
diff --git a/Modules/ToFHardware/Testing/mitkPlayerLoadAndRenderDepthDataTest.cpp b/Modules/ToFHardware/Testing/mitkPlayerLoadAndRenderDepthDataTest.cpp
new file mode 100644
index 0000000000..428b208843
--- /dev/null
+++ b/Modules/ToFHardware/Testing/mitkPlayerLoadAndRenderDepthDataTest.cpp
@@ -0,0 +1,106 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//MITK
+#include "mitkTestingMacros.h"
+#include "mitkRenderingTestHelper.h"
+#include "mitkToFCameraMITKPlayerDevice.h"
+
+//VTK
+#include <vtkRegressionTestImage.h>
+
+#include <mitkToFConfig.h>
+#include <mitkPixelType.h>
+#include <itksys/SystemTools.hxx>
+
+
+int mitkPlayerLoadAndRenderDepthDataTest(int argc, char* argv[])
+{
+ MITK_TEST_BEGIN("mitkPlayerLoadAndRenderDepthDataTest");
+
+ try
+ {
+ mitk::ToFCameraMITKPlayerDevice::Pointer playerDevice = mitk::ToFCameraMITKPlayerDevice::New();
+
+ MITK_TEST_CONDITION_REQUIRED(argc >=2, "Testing if enough input parameters are set. Usage: Testname, ImageName (must be in MITK_TOF_DATA_DIR), -V /path/to/reference/screenshot");
+ std::string dirname = MITK_TOF_DATA_DIR;
+ std::string distanceFileName = dirname + "/" + argv[1];
+ playerDevice->SetProperty("DistanceImageFileName",mitk::StringProperty::New(distanceFileName));
+
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->IsCameraActive()==false,"The device (player) should not be active before starting.");
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->ConnectCamera()==true,"ConnectCamera() should return true in case of success.");
+ MITK_TEST_OUTPUT(<< "Device connected");
+ playerDevice->StartCamera();
+ MITK_TEST_OUTPUT(<< "Device started");
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->IsCameraActive()==true,"After starting the device, the device should be active.");
+
+ //initialize an array with the correct size
+ unsigned int captureWidth = playerDevice->GetCaptureWidth();
+ unsigned int captureHeight = playerDevice->GetCaptureHeight();
+ unsigned int numberOfPixels = captureWidth*captureHeight;
+ float* distances = new float[numberOfPixels];
+ int imageSequence = 0;
+
+ //fill the array with the device output
+ playerDevice->GetDistances(distances,imageSequence);
+
+ //initialize an image and fill it with the array
+ unsigned int dimension[2];
+ dimension[0] = captureWidth;
+ dimension[1] = captureHeight;
+ mitk::Image::Pointer mitkDepthImage = mitk::Image::New();
+ mitkDepthImage->Initialize(mitk::PixelType(mitk::MakeScalarPixelType<float>()), 2, dimension,1);
+ mitkDepthImage->SetSlice(distances);
+
+ //create a node to pass it to the mitkRenderingTestHelper
+ mitk::DataNode::Pointer node = mitk::DataNode::New();
+ node->SetData(mitkDepthImage);
+
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+ //Set the opacity for all images
+ //for now this test renders in sagittal view direction
+ renderingHelper.AddNodeToStorage(node);
+
+ //use this to generate a reference screenshot or save the file:
+ bool generateReferenceScreenshot = false;
+ if(generateReferenceScreenshot)
+ {
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/output.png");
+ }
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ //Wait some time to avoid threading issues.
+ itksys::SystemTools::Delay(1000);
+ playerDevice->StopCamera();
+ MITK_TEST_OUTPUT(<< "Device stopped");
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->IsCameraActive()==false,"After stopping the device, the device should be inactive.");
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->DisconnectCamera()==true, "DisconnectCamera() should return true in case of success.");
+ MITK_TEST_OUTPUT(<< "Device disconnected");
+ delete[] distances;
+ }
+ catch(std::exception &e)
+ {
+ MITK_ERROR << "Unknown exception occured: " << e.what();
+ }
+
+ MITK_TEST_END();
+}
diff --git a/Modules/ToFHardware/Testing/mitkPlayerLoadAndRenderRGBDataTest.cpp b/Modules/ToFHardware/Testing/mitkPlayerLoadAndRenderRGBDataTest.cpp
new file mode 100644
index 0000000000..69757d567a
--- /dev/null
+++ b/Modules/ToFHardware/Testing/mitkPlayerLoadAndRenderRGBDataTest.cpp
@@ -0,0 +1,107 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//MITK
+#include "mitkTestingMacros.h"
+#include "mitkRenderingTestHelper.h"
+#include "mitkToFCameraMITKPlayerDevice.h"
+
+//VTK
+#include <vtkRegressionTestImage.h>
+
+#include <mitkToFConfig.h>
+#include <mitkPixelType.h>
+#include <itksys/SystemTools.hxx>
+
+
+int mitkPlayerLoadAndRenderRGBDataTest(int argc, char* argv[])
+{
+ MITK_TEST_BEGIN("mitkPlayerLoadAndRenderRGBDataTest");
+
+ try
+ {
+ mitk::ToFCameraMITKPlayerDevice::Pointer playerDevice = mitk::ToFCameraMITKPlayerDevice::New();
+
+ MITK_TEST_CONDITION_REQUIRED(argc >=2, "Testing if enough input parameters are set. Usage: Testname, ImageName (must be in MITK_TOF_DATA_DIR), -V /path/to/reference/screenshot");
+ std::string dirname = MITK_TOF_DATA_DIR;
+ std::string rgbFileName = dirname + "/" + argv[1];
+ playerDevice->SetProperty("RGBImageFileName",mitk::StringProperty::New(rgbFileName));
+
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->IsCameraActive()==false,"The device (player) should not be active before starting.");
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->ConnectCamera()==true,"ConnectCamera() should return true in case of success.");
+ MITK_TEST_OUTPUT(<< "Device connected");
+ playerDevice->StartCamera();
+ MITK_TEST_OUTPUT(<< "Device started");
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->IsCameraActive()==true,"After starting the device, the device should be active.");
+
+ //initialize an array with the correct size
+ unsigned int captureWidth = playerDevice->GetCaptureWidth();
+ unsigned int captureHeight = playerDevice->GetCaptureHeight();
+ unsigned int numberOfPixels = captureWidth*captureHeight;
+ unsigned char* rgbDataArray = new unsigned char[numberOfPixels*3];
+ int imageSequence = 0;
+
+ //fill the array with the device output
+ playerDevice->GetRgb(rgbDataArray, imageSequence);
+
+ //initialize an image and fill it with the array
+ unsigned int dimension[2];
+ dimension[0] = captureWidth;
+ dimension[1] = captureHeight;
+ mitk::Image::Pointer rgbImage = mitk::Image::New();
+ rgbImage->Initialize(mitk::PixelType(mitk::MakePixelType<unsigned char, itk::RGBPixel<unsigned char>, 3>()), 2, dimension,1);
+ rgbImage->SetSlice(rgbDataArray);
+
+ //create a node to pass it to the mitkRenderingTestHelper
+ mitk::DataNode::Pointer node = mitk::DataNode::New();
+ node->SetData(rgbImage);
+
+ // load all arguments into a datastorage, take last argument as reference rendering
+ // setup a renderwindow of fixed size X*Y
+ // render the datastorage
+ // compare rendering to reference image
+ mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
+ //Set the opacity for all images
+ //for now this test renders in sagittal view direction
+ renderingHelper.AddNodeToStorage(node);
+ renderingHelper.Render();
+
+ //use this to generate a reference screenshot or save the file:
+ bool generateReferenceScreenshot = false;
+ if(generateReferenceScreenshot)
+ {
+ renderingHelper.SaveReferenceScreenShot("/home/kilgus/Pictures/output.png");
+ }
+
+ //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
+ MITK_TEST_CONDITION( renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, "CompareRenderWindowAgainstReference test result positive?" );
+
+ //Wait some time to avoid threading issues.
+ itksys::SystemTools::Delay(1000);
+ playerDevice->StopCamera();
+ MITK_TEST_OUTPUT(<< "Device stopped");
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->IsCameraActive()==false,"After stopping the device, the device should be inactive.");
+ MITK_TEST_CONDITION_REQUIRED(playerDevice->DisconnectCamera()==true, "DisconnectCamera() should return true in case of success.");
+ MITK_TEST_OUTPUT(<< "Device disconnected");
+ delete[] rgbDataArray;
+ }
+ catch(std::exception &e)
+ {
+ MITK_ERROR << "Unknown exception occured: " << e.what();
+ }
+
+ MITK_TEST_END();
+}
diff --git a/Modules/ToFHardware/Testing/mitkToFImageGrabberTest.cpp b/Modules/ToFHardware/Testing/mitkToFImageGrabberTest.cpp
index e34013e937..e567ae513d 100644
--- a/Modules/ToFHardware/Testing/mitkToFImageGrabberTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFImageGrabberTest.cpp
@@ -1,114 +1,114 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkToFImageGrabber.h>
#include <mitkImageDataItem.h>
#include <mitkPicFileReader.h>
#include <mitkToFCameraMITKPlayerDevice.h>
#include <mitkToFConfig.h>
static bool CompareImages(mitk::Image::Pointer image1, mitk::Image::Pointer image2)
{
//check if epsilon is exceeded
unsigned int sliceDimension = image1->GetDimension(0)*image1->GetDimension(1);
bool picturesEqual = true;
float* floatArray1 = (float*)image1->GetSliceData(0, 0, 0)->GetData();
float* floatArray2 = (float*)image2->GetSliceData(0, 0, 0)->GetData();
for(unsigned int i = 0; i < sliceDimension; i++)
{
if(!(mitk::Equal(floatArray1[i], floatArray2[i])))
{
picturesEqual = false;
}
}
return picturesEqual;
}
/**Documentation
* test for the class "ToFImageGrabber".
*/
int mitkToFImageGrabberTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("ToFImageGrabber");
std::string dirName = MITK_TOF_DATA_DIR;
mitk::ToFImageGrabber::Pointer tofImageGrabber = mitk::ToFImageGrabber::New();
mitk::ToFCameraMITKPlayerDevice::Pointer tofCameraMITKPlayerDevice = mitk::ToFCameraMITKPlayerDevice::New();
tofImageGrabber->SetCameraDevice(tofCameraMITKPlayerDevice);
MITK_TEST_CONDITION_REQUIRED(tofCameraMITKPlayerDevice==tofImageGrabber->GetCameraDevice(),"Test Set/GetCameraDevice()");
int modulationFrequency = 20;
tofImageGrabber->SetModulationFrequency(modulationFrequency);
MITK_TEST_CONDITION_REQUIRED(modulationFrequency==tofImageGrabber->GetModulationFrequency(),"Test Set/GetModulationFrequency()");
int integrationTime = 500;
tofImageGrabber->SetIntegrationTime(integrationTime);
MITK_TEST_CONDITION_REQUIRED(integrationTime==tofImageGrabber->GetIntegrationTime(),"Test Set/GetIntegrationTime()");
MITK_TEST_OUTPUT(<<"Test methods with invalid file name");
MITK_TEST_FOR_EXCEPTION(std::logic_error, tofImageGrabber->ConnectCamera());
MITK_TEST_OUTPUT(<<"Call StartCamera()");
tofImageGrabber->StartCamera();
MITK_TEST_OUTPUT(<<"Call StopCamera()");
tofImageGrabber->StopCamera();
MITK_TEST_CONDITION_REQUIRED(!tofImageGrabber->DisconnectCamera(),"Test DisconnectCamera() with no file name set");
std::string distanceFileName = dirName + "/PMDCamCube2_MF0_IT0_1Images_DistanceImage.pic";
tofImageGrabber->SetProperty("DistanceImageFileName",mitk::StringProperty::New(distanceFileName));
std::string amplitudeFileName = dirName + "/PMDCamCube2_MF0_IT0_1Images_AmplitudeImage.pic";
tofImageGrabber->SetProperty("AmplitudeImageFileName",mitk::StringProperty::New(amplitudeFileName));
std::string intensityFileName = dirName + "/PMDCamCube2_MF0_IT0_1Images_IntensityImage.pic";
tofImageGrabber->SetProperty("IntensityImageFileName",mitk::StringProperty::New(intensityFileName));
// Load images with PicFileReader for comparison
mitk::PicFileReader::Pointer picFileReader = mitk::PicFileReader::New();
mitk::Image::Pointer expectedResultImage = NULL;
MITK_TEST_OUTPUT(<<"Test ToFImageGrabber using ToFCameraMITKPlayerDevice");
MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->ConnectCamera(),"Test ConnectCamera()");
MITK_TEST_CONDITION_REQUIRED(!tofImageGrabber->IsCameraActive(),"IsCameraActive() before StartCamera()");
MITK_TEST_OUTPUT(<<"Call StartCamera()");
tofImageGrabber->StartCamera();
MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->IsCameraActive(),"IsCameraActive() after StartCamera()");
picFileReader->SetFileName(distanceFileName);
picFileReader->Update();
expectedResultImage = picFileReader->GetOutput();
int captureWidth = expectedResultImage->GetDimension(0);
int captureHeight = expectedResultImage->GetDimension(1);
MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->GetCaptureWidth()==captureWidth,"Test GetCaptureWidth()");
MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->GetCaptureHeight()==captureHeight,"Test GetCaptureHeight()");
MITK_TEST_OUTPUT(<<"Call Update()");
tofImageGrabber->Update();
- mitk::Image::Pointer distanceImage = tofImageGrabber->GetOutput(0);
- MITK_TEST_CONDITION_REQUIRED(CompareImages(expectedResultImage,distanceImage),"Test GetOutput(0)");
+ mitk::Image::Pointer distanceImage = tofImageGrabber->GetOutput();
+ MITK_TEST_CONDITION_REQUIRED(CompareImages(expectedResultImage,distanceImage),"Test GetOutput()");
picFileReader->SetFileName(amplitudeFileName);
picFileReader->Update();
mitk::Image::Pointer amplitudeImage = tofImageGrabber->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(CompareImages(expectedResultImage,amplitudeImage),"Test GetOutput(1)");
picFileReader->SetFileName(intensityFileName);
picFileReader->Update();
mitk::Image::Pointer intensityImage = tofImageGrabber->GetOutput(2);
MITK_TEST_CONDITION_REQUIRED(CompareImages(expectedResultImage,intensityImage),"Test GetOutput(2)");
MITK_TEST_OUTPUT(<<"Call StopCamera()");
tofImageGrabber->StopCamera();
MITK_TEST_CONDITION_REQUIRED(!tofImageGrabber->IsCameraActive(),"IsCameraActive() after StopCamera()");
MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->DisconnectCamera(),"Test DisconnectCamera()");
MITK_TEST_CONDITION_REQUIRED(!tofImageGrabber->IsCameraActive(),"IsCameraActive() after DisconnectCamera()");
MITK_TEST_END();;
}
diff --git a/Modules/ToFHardware/Testing/mitkToFImageRecorderFilterTest.cpp b/Modules/ToFHardware/Testing/mitkToFImageRecorderFilterTest.cpp
index 196b7fea14..1815dd2736 100644
--- a/Modules/ToFHardware/Testing/mitkToFImageRecorderFilterTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFImageRecorderFilterTest.cpp
@@ -1,167 +1,167 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkImageDataItem.h>
#include <mitkItkImageFileReader.h>
#include <mitkToFConfig.h>
#include <mitkToFImageRecorderFilter.h>
#include <mitkToFImageWriter.h>
#include <itkImage.h>
#include <itkImageRegionIterator.h>
#include <itkMersenneTwisterRandomVariateGenerator.h>
mitk::Image::Pointer CreateTestImage(unsigned int dimX, unsigned int dimY)
{
typedef itk::Image<float,2> ItkImageType2D;
typedef itk::ImageRegionIterator<ItkImageType2D> ItkImageRegionIteratorType2D;
ItkImageType2D::Pointer image = ItkImageType2D::New();
ItkImageType2D::IndexType start;
start[0] = 0;
start[1] = 0;
ItkImageType2D::SizeType size;
size[0] = dimX;
size[1] = dimY;
ItkImageType2D::RegionType region;
region.SetSize(size);
region.SetIndex( start);
ItkImageType2D::SpacingType spacing;
spacing[0] = 1.0;
spacing[1] = 1.0;
image->SetRegions( region );
image->SetSpacing ( spacing );
image->Allocate();
//Obtaining image data from ToF camera//
//Correlate inten values to PixelIndex//
ItkImageRegionIteratorType2D imageIterator(image,image->GetLargestPossibleRegion());
imageIterator.GoToBegin();
itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
while (!imageIterator.IsAtEnd())
{
double pixelValue = randomGenerator->GetUniformVariate(0.0,1000.0);
imageIterator.Set(pixelValue);
++imageIterator;
}
mitk::Image::Pointer mitkImage = mitk::Image::New();
mitk::CastToMitkImage(image,mitkImage);
return mitkImage;
}
static bool CompareImages(mitk::Image::Pointer image1, mitk::Image::Pointer image2)
{
//check if epsilon is exceeded
unsigned int sliceDimension = image1->GetDimension(0)*image1->GetDimension(1);
bool picturesEqual = true;
float* floatArray1 = (float*)image1->GetSliceData(0, 0, 0)->GetData();
float* floatArray2 = (float*)image2->GetSliceData(0, 0, 0)->GetData();
for(unsigned int i = 0; i < sliceDimension; i++)
{
if(!(mitk::Equal(floatArray1[i], floatArray2[i])))
{
picturesEqual = false;
}
}
return picturesEqual;
}
/**Documentation
* test for the class "ToFImageRecorderFilter".
*/
int mitkToFImageRecorderFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("ToFImageRecorder");
mitk::ToFImageRecorderFilter::Pointer tofImageRecorderFilter = mitk::ToFImageRecorderFilter::New();
std::string dirName = MITK_TOF_DATA_DIR;
MITK_TEST_OUTPUT(<< "Test SetFileName()");
std::string testFileName = dirName + "test.pic";
MITK_TEST_FOR_EXCEPTION_BEGIN(std::logic_error);
tofImageRecorderFilter->SetFileName(testFileName);
MITK_TEST_FOR_EXCEPTION_END(std::logic_error);
testFileName = dirName + "test.nrrd";
tofImageRecorderFilter->SetFileName(testFileName);
mitk::ToFImageWriter::Pointer tofImageWriter = tofImageRecorderFilter->GetToFImageWriter();
std::string requiredName = dirName + "test_DistanceImage.nrrd";
std::string name = tofImageWriter->GetDistanceImageFileName();
MITK_TEST_CONDITION_REQUIRED(requiredName==name,"Test for distance image file name");
requiredName = dirName + "test_AmplitudeImage.nrrd";
name = tofImageWriter->GetAmplitudeImageFileName();
MITK_TEST_CONDITION_REQUIRED(requiredName==name,"Test for amplitude image file name");
requiredName = dirName + "test_IntensityImage.nrrd";
name = tofImageWriter->GetIntensityImageFileName();
MITK_TEST_CONDITION_REQUIRED(requiredName==name,"Test for intensity image file name");
mitk::Image::Pointer testDistanceImage = CreateTestImage(200,200);
mitk::Image::Pointer testAmplitudeImage = CreateTestImage(200,200);
mitk::Image::Pointer testIntensityImage = CreateTestImage(200,200);
MITK_TEST_OUTPUT(<< "Apply filter");
tofImageRecorderFilter->StartRecording();
tofImageRecorderFilter->SetInput(0,testDistanceImage);
tofImageRecorderFilter->SetInput(1,testAmplitudeImage);
tofImageRecorderFilter->SetInput(2,testIntensityImage);
tofImageRecorderFilter->Update();
MITK_TEST_OUTPUT(<< "Test outputs of filter");
- mitk::Image::Pointer outputDistanceImage = tofImageRecorderFilter->GetOutput(0);
+ mitk::Image::Pointer outputDistanceImage = tofImageRecorderFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(CompareImages(testDistanceImage,outputDistanceImage),"Test output 0 (distance image)");
mitk::Image::Pointer outputAmplitudeImage = tofImageRecorderFilter->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(CompareImages(testAmplitudeImage,outputAmplitudeImage),"Test output 1 (amplitude image)");
mitk::Image::Pointer outputIntensityImage = tofImageRecorderFilter->GetOutput(2);
MITK_TEST_CONDITION_REQUIRED(CompareImages(testIntensityImage,outputIntensityImage),"Test output 2 (intensity image)");
tofImageRecorderFilter->StopRecording();
MITK_TEST_OUTPUT(<< "Test content of written files");
mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
std::string testDistanceImageName = dirName + "test_DistanceImage.nrrd";
imageReader->SetFileName(testDistanceImageName);
imageReader->Update();
mitk::Image::Pointer loadedDistanceImage = imageReader->GetOutput();
MITK_TEST_CONDITION_REQUIRED(CompareImages(testDistanceImage,loadedDistanceImage),"Test loaded image 0 (distance image)");
std::string testAmplitudeImageName = dirName + "test_AmplitudeImage.nrrd";
imageReader->SetFileName(testAmplitudeImageName);
imageReader->Update();
mitk::Image::Pointer loadedAmplitudeImage = imageReader->GetOutput();
MITK_TEST_CONDITION_REQUIRED(CompareImages(testAmplitudeImage,loadedAmplitudeImage),"Test loaded image 1 (amplitude image)");
std::string testIntensityImageName = dirName + "test_IntensityImage.nrrd";
imageReader->SetFileName(testIntensityImageName);
imageReader->Update();
mitk::Image::Pointer loadedIntensityImage = imageReader->GetOutput();
MITK_TEST_CONDITION_REQUIRED(CompareImages(testIntensityImage,loadedIntensityImage),"Test loaded image 2 (intensity image)");
//clean up and delete saved image files
if( remove( testDistanceImageName.c_str() ) != 0 )
{
MITK_ERROR<<"File: test_DistanceImage.nrrd not successfully deleted!";
}
if( remove( testAmplitudeImageName.c_str() ) != 0 )
{
MITK_ERROR<<"File: test_AmplitudeImage.nrrd not successfully deleted!";
}
if( remove( testIntensityImageName.c_str() ) != 0 )
{
MITK_ERROR<<"File: test_IntensityImage.nrrd not successfully deleted!";
}
MITK_TEST_END();
}
diff --git a/Modules/ToFHardware/mitkToFCameraDevice.cpp b/Modules/ToFHardware/mitkToFCameraDevice.cpp
index f56d85b4e8..490a4bb78a 100644
--- a/Modules/ToFHardware/mitkToFCameraDevice.cpp
+++ b/Modules/ToFHardware/mitkToFCameraDevice.cpp
@@ -1,188 +1,195 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraDevice.h"
#include <itksys/SystemTools.hxx>
//Microservices
#include <usGetModuleContext.h>
#include "mitkModuleContext.h"
namespace mitk
{
ToFCameraDevice::ToFCameraDevice():m_BufferSize(1),m_MaxBufferSize(100),m_CurrentPos(-1),m_FreePos(0),
m_CaptureWidth(204),m_CaptureHeight(204),m_PixelNumber(41616),m_SourceDataSize(0),
m_ThreadID(0),m_CameraActive(false),m_CameraConnected(false),m_ImageSequence(0)
{
this->m_AmplitudeArray = NULL;
this->m_IntensityArray = NULL;
this->m_DistanceArray = NULL;
this->m_PropertyList = mitk::PropertyList::New();
+ //By default, all devices have no further images (just a distance image)
+ //If a device provides more data (e.g. RGB, Intensity, Amplitde images,
+ //the property has to be true.
+ this->m_PropertyList->SetBoolProperty("HasRGBImage", false);
+ this->m_PropertyList->SetBoolProperty("HasIntensityImage", false);
+ this->m_PropertyList->SetBoolProperty("HasAmplitudeImage", false);
+
this->m_MultiThreader = itk::MultiThreader::New();
this->m_ImageMutex = itk::FastMutexLock::New();
this->m_CameraActiveMutex = itk::FastMutexLock::New();
this->m_RGBImageWidth = this->m_CaptureWidth;
this->m_RGBImageHeight = this->m_CaptureHeight;
this->m_RGBPixelNumber = this->m_RGBImageWidth* this->m_RGBImageHeight;
}
ToFCameraDevice::~ToFCameraDevice()
{
}
void ToFCameraDevice::SetBoolProperty( const char* propertyKey, bool boolValue )
{
SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
}
void ToFCameraDevice::SetIntProperty( const char* propertyKey, int intValue )
{
SetProperty(propertyKey, mitk::IntProperty::New(intValue));
}
void ToFCameraDevice::SetFloatProperty( const char* propertyKey, float floatValue )
{
SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
}
void ToFCameraDevice::SetStringProperty( const char* propertyKey, const char* stringValue )
{
SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
}
void ToFCameraDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
{
this->m_PropertyList->SetProperty(propertyKey, propertyValue);
}
BaseProperty* ToFCameraDevice::GetProperty(const char *propertyKey)
{
return this->m_PropertyList->GetProperty(propertyKey);
}
bool ToFCameraDevice::GetBoolProperty(const char *propertyKey, bool& boolValue)
{
mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty*>(this->GetProperty(propertyKey));
if(boolprop.IsNull())
return false;
boolValue = boolprop->GetValue();
return true;
}
bool ToFCameraDevice::GetStringProperty(const char *propertyKey, std::string& string)
{
mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty*>(this->GetProperty(propertyKey));
if(stringProp.IsNull())
{
return false;
}
else
{
string = stringProp->GetValue();
return true;
}
}
bool ToFCameraDevice::GetIntProperty(const char *propertyKey, int& integer)
{
mitk::IntProperty::Pointer intProp = dynamic_cast<mitk::IntProperty*>(this->GetProperty(propertyKey));
if(intProp.IsNull())
{
return false;
}
else
{
integer = intProp->GetValue();
return true;
}
}
void ToFCameraDevice::CleanupPixelArrays()
{
if (m_IntensityArray)
{
delete [] m_IntensityArray;
}
if (m_DistanceArray)
{
delete [] m_DistanceArray;
}
if (m_AmplitudeArray)
{
delete [] m_AmplitudeArray;
}
}
void ToFCameraDevice::AllocatePixelArrays()
{
// free memory if it was already allocated
CleanupPixelArrays();
// allocate buffer
this->m_IntensityArray = new float[this->m_PixelNumber];
for(int i=0; i<this->m_PixelNumber; i++) {this->m_IntensityArray[i]=0.0;}
this->m_DistanceArray = new float[this->m_PixelNumber];
for(int i=0; i<this->m_PixelNumber; i++) {this->m_DistanceArray[i]=0.0;}
this->m_AmplitudeArray = new float[this->m_PixelNumber];
for(int i=0; i<this->m_PixelNumber; i++) {this->m_AmplitudeArray[i]=0.0;}
}
int ToFCameraDevice::GetRGBCaptureWidth()
{
return this->m_RGBImageWidth;
}
int ToFCameraDevice::GetRGBCaptureHeight()
{
return this->m_RGBImageHeight;
}
void ToFCameraDevice::StopCamera()
{
m_CameraActiveMutex->Lock();
m_CameraActive = false;
m_CameraActiveMutex->Unlock();
itksys::SystemTools::Delay(100);
if (m_MultiThreader.IsNotNull())
{
m_MultiThreader->TerminateThread(m_ThreadID);
}
// wait a little to make sure that the thread is terminated
itksys::SystemTools::Delay(100);
}
bool ToFCameraDevice::IsCameraActive()
{
m_CameraActiveMutex->Lock();
bool ok = m_CameraActive;
m_CameraActiveMutex->Unlock();
return ok;
}
bool ToFCameraDevice::ConnectCamera()
{
// Prepare connection, fail if this fails.
if (! this->OnConnectCamera()) return false;
// Get Context and Module
mitk::ModuleContext* context = GetModuleContext();
return true;
}
bool ToFCameraDevice::IsCameraConnected()
{
return m_CameraConnected;
}
}
diff --git a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
index 5782ec28fd..02c02a5002 100644
--- a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
+++ b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
@@ -1,399 +1,402 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFCameraMITKPlayerDevice.h"
#include "mitkToFCameraMITKPlayerController.h"
#include "mitkRealTimeClock.h"
#include "itkMultiThreader.h"
#include <itksys/SystemTools.hxx>
namespace mitk
{
ToFCameraMITKPlayerDevice::ToFCameraMITKPlayerDevice() :
m_DistanceDataBuffer(NULL), m_AmplitudeDataBuffer(NULL), m_IntensityDataBuffer(NULL), m_RGBDataBuffer(NULL)
{
m_Controller = ToFCameraMITKPlayerController::New();
}
ToFCameraMITKPlayerDevice::~ToFCameraMITKPlayerDevice()
{
DisconnectCamera();
CleanUpDataBuffers();
}
bool ToFCameraMITKPlayerDevice::OnConnectCamera()
{
bool ok = m_Controller->OpenCameraConnection();
if (ok)
{
this->m_CaptureWidth = m_Controller->GetCaptureWidth();
this->m_CaptureHeight = m_Controller->GetCaptureHeight();
this->m_RGBImageWidth = m_Controller->GetCaptureWidth();
this->m_RGBImageHeight = m_Controller->GetCaptureHeight();
this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
AllocatePixelArrays();
AllocateDataBuffers();
m_CameraConnected = true;
}
return ok;
}
bool ToFCameraMITKPlayerDevice::DisconnectCamera()
{
bool ok = m_Controller->CloseCameraConnection();
if (ok)
{
m_CameraConnected = false;
}
return ok;
}
void ToFCameraMITKPlayerDevice::StartCamera()
{
if (m_CameraConnected)
{
// get the first image
this->m_Controller->UpdateCamera();
this->m_ImageMutex->Lock();
this->m_Controller->GetDistances(this->m_DistanceDataBuffer[this->m_FreePos]);
this->m_Controller->GetAmplitudes(this->m_AmplitudeDataBuffer[this->m_FreePos]);
this->m_Controller->GetIntensities(this->m_IntensityDataBuffer[this->m_FreePos]);
this->m_Controller->GetRgb(this->m_RGBDataBuffer[this->m_FreePos]);
this->m_FreePos = (this->m_FreePos+1) % this->m_BufferSize;
this->m_CurrentPos = (this->m_CurrentPos+1) % this->m_BufferSize;
this->m_ImageSequence++;
this->m_ImageMutex->Unlock();
this->m_CameraActiveMutex->Lock();
this->m_CameraActive = true;
this->m_CameraActiveMutex->Unlock();
this->m_ThreadID = this->m_MultiThreader->SpawnThread(this->Acquire, this);
// wait a little to make sure that the thread is started
itksys::SystemTools::Delay(10);
}
else
{
MITK_INFO<<"Camera not connected";
}
}
void ToFCameraMITKPlayerDevice::UpdateCamera()
{
m_Controller->UpdateCamera();
}
ITK_THREAD_RETURN_TYPE ToFCameraMITKPlayerDevice::Acquire(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
ToFCameraMITKPlayerDevice* toFCameraDevice = (ToFCameraMITKPlayerDevice*)pInfo->UserData;
if (toFCameraDevice!=NULL)
{
mitk::RealTimeClock::Pointer realTimeClock;
realTimeClock = mitk::RealTimeClock::New();
int n = 100;
double t1, t2;
t1 = realTimeClock->GetCurrentStamp();
bool overflow = false;
bool printStatus = false;
while (toFCameraDevice->IsCameraActive())
{
// update the ToF camera
toFCameraDevice->UpdateCamera();
// get image data from controller and write it to the according buffer
toFCameraDevice->m_Controller->GetDistances(toFCameraDevice->m_DistanceDataBuffer[toFCameraDevice->m_FreePos]);
toFCameraDevice->m_Controller->GetAmplitudes(toFCameraDevice->m_AmplitudeDataBuffer[toFCameraDevice->m_FreePos]);
toFCameraDevice->m_Controller->GetIntensities(toFCameraDevice->m_IntensityDataBuffer[toFCameraDevice->m_FreePos]);
toFCameraDevice->m_Controller->GetRgb(toFCameraDevice->m_RGBDataBuffer[toFCameraDevice->m_FreePos]);
toFCameraDevice->Modified();
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
TODO Buffer Handling currently only works for buffer size 1
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
toFCameraDevice->m_ImageMutex->Lock();
toFCameraDevice->m_FreePos = (toFCameraDevice->m_FreePos+1) % toFCameraDevice->m_BufferSize;
toFCameraDevice->m_CurrentPos = (toFCameraDevice->m_CurrentPos+1) % toFCameraDevice->m_BufferSize;
toFCameraDevice->m_ImageSequence++;
if (toFCameraDevice->m_FreePos == toFCameraDevice->m_CurrentPos)
{
// buffer overflow
//MITK_INFO << "Buffer overflow!! ";
//toFCameraDevice->m_CurrentPos = (toFCameraDevice->m_CurrentPos+1) % toFCameraDevice->m_BufferSize;
//toFCameraDevice->m_ImageSequence++;
overflow = true;
}
if (toFCameraDevice->m_ImageSequence % n == 0)
{
printStatus = true;
}
toFCameraDevice->m_ImageMutex->Unlock();
if (overflow)
{
//itksys::SystemTools::Delay(10);
overflow = false;
}
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
END TODO Buffer Handling currently only works for buffer size 1
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
// print current framerate
if (printStatus)
{
t2 = realTimeClock->GetCurrentStamp() - t1;
MITK_INFO << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFCameraDevice->m_ImageSequence;
t1 = realTimeClock->GetCurrentStamp();
printStatus = false;
}
} // end of while loop
}
return ITK_THREAD_RETURN_VALUE;
}
// TODO: Buffer size currently set to 1. Once Buffer handling is working correctly, method may be reactivated
// void ToFCameraMITKPlayerDevice::ResetBuffer(int bufferSize)
// {
// this->m_BufferSize = bufferSize;
// this->m_CurrentPos = -1;
// this->m_FreePos = 0;
// }
void ToFCameraMITKPlayerDevice::GetAmplitudes(float* amplitudeArray, int& imageSequence)
{
m_ImageMutex->Lock();
/*!!!!!!!!!!!!!!!!!!!!!!
TODO Buffer handling???
!!!!!!!!!!!!!!!!!!!!!!!!*/
// write amplitude image data to float array
for (int i=0; i<this->m_PixelNumber; i++)
{
amplitudeArray[i] = this->m_AmplitudeDataBuffer[this->m_CurrentPos][i];
}
imageSequence = this->m_ImageSequence;
m_ImageMutex->Unlock();
}
void ToFCameraMITKPlayerDevice::GetIntensities(float* intensityArray, int& imageSequence)
{
m_ImageMutex->Lock();
/*!!!!!!!!!!!!!!!!!!!!!!
TODO Buffer handling???
!!!!!!!!!!!!!!!!!!!!!!!!*/
// write intensity image data to float array
for (int i=0; i<this->m_PixelNumber; i++)
{
intensityArray[i] = this->m_IntensityDataBuffer[this->m_CurrentPos][i];
}
imageSequence = this->m_ImageSequence;
m_ImageMutex->Unlock();
}
void ToFCameraMITKPlayerDevice::GetDistances(float* distanceArray, int& imageSequence)
{
m_ImageMutex->Lock();
/*!!!!!!!!!!!!!!!!!!!!!!
TODO Buffer handling???
!!!!!!!!!!!!!!!!!!!!!!!!*/
// write distance image data to float array
for (int i=0; i<this->m_PixelNumber; i++)
{
distanceArray[i] = this->m_DistanceDataBuffer[this->m_CurrentPos][i];
}
imageSequence = this->m_ImageSequence;
m_ImageMutex->Unlock();
}
void ToFCameraMITKPlayerDevice::GetRgb(unsigned char* rgbArray, int& imageSequence)
{
m_ImageMutex->Lock();
/*!!!!!!!!!!!!!!!!!!!!!!
TODO Buffer handling???
!!!!!!!!!!!!!!!!!!!!!!!!*/
// write intensity image data to unsigned char array
for (int i=0; i<this->m_PixelNumber*3; i++)
{
rgbArray[i] = this->m_RGBDataBuffer[this->m_CurrentPos][i];
}
imageSequence = this->m_ImageSequence;
m_ImageMutex->Unlock();
}
void ToFCameraMITKPlayerDevice::GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* /*sourceDataArray*/,
int requiredImageSequence, int& capturedImageSequence, unsigned char* rgbDataArray)
{
/*!!!!!!!!!!!!!!!!!!!!!!
TODO Document this method!
!!!!!!!!!!!!!!!!!!!!!!!!*/
m_ImageMutex->Lock();
//check for empty buffer
if (this->m_ImageSequence < 0)
{
// buffer empty
MITK_INFO << "Buffer empty!! ";
capturedImageSequence = this->m_ImageSequence;
m_ImageMutex->Unlock();
return;
}
// determine position of image in buffer
int pos = 0;
if ((requiredImageSequence < 0) || (requiredImageSequence > this->m_ImageSequence))
{
capturedImageSequence = this->m_ImageSequence;
pos = this->m_CurrentPos;
}
else if (requiredImageSequence <= this->m_ImageSequence - this->m_BufferSize)
{
capturedImageSequence = (this->m_ImageSequence - this->m_BufferSize) + 1;
pos = (this->m_CurrentPos + 1) % this->m_BufferSize;
}
else // (requiredImageSequence > this->m_ImageSequence - this->m_BufferSize) && (requiredImageSequence <= this->m_ImageSequence)
{
capturedImageSequence = requiredImageSequence;
pos = (this->m_CurrentPos + (10-(this->m_ImageSequence - requiredImageSequence))) % this->m_BufferSize;
}
if(this->m_DistanceDataBuffer&&this->m_AmplitudeDataBuffer&&this->m_IntensityDataBuffer&&this->m_RGBDataBuffer)
{
// write image data to float arrays
for (int i=0; i<this->m_PixelNumber; i++)
{
distanceArray[i] = this->m_DistanceDataBuffer[pos][i];
amplitudeArray[i] = this->m_AmplitudeDataBuffer[pos][i];
intensityArray[i] = this->m_IntensityDataBuffer[pos][i];
if (rgbDataArray)
{
rgbDataArray[i] = this->m_RGBDataBuffer[pos][i];
}
}
if (rgbDataArray)
{
for (int j=this->m_PixelNumber; j<this->m_PixelNumber*3; j++)
{
rgbDataArray[j] = this->m_RGBDataBuffer[pos][j];
}
}
}
m_ImageMutex->Unlock();
}
void ToFCameraMITKPlayerDevice::SetInputFileName(std::string inputFileName)
{
this->m_InputFileName = inputFileName;
this->m_Controller->SetInputFileName(inputFileName);
}
void ToFCameraMITKPlayerDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
{
this->m_PropertyList->SetProperty(propertyKey, propertyValue);
ToFCameraMITKPlayerController::Pointer myController = dynamic_cast<mitk::ToFCameraMITKPlayerController*>(this->m_Controller.GetPointer());
std::string strValue;
GetStringProperty(propertyKey, strValue);
if (strcmp(propertyKey, "DistanceImageFileName") == 0)
{
myController->SetDistanceImageFileName(strValue);
}
else if (strcmp(propertyKey, "AmplitudeImageFileName") == 0)
{
+ this->m_PropertyList->SetBoolProperty("HasAmplitudeImage", true);
myController->SetAmplitudeImageFileName(strValue);
}
else if (strcmp(propertyKey, "IntensityImageFileName") == 0)
{
+ this->m_PropertyList->SetBoolProperty("HasIntensityImage", true);
myController->SetIntensityImageFileName(strValue);
}
else if (strcmp(propertyKey, "RGBImageFileName") == 0)
{
+ this->m_PropertyList->SetBoolProperty("HasRGBImage", true);
myController->SetRGBImageFileName(strValue);
}
}
void ToFCameraMITKPlayerDevice::CleanUpDataBuffers()
{
if (m_DistanceDataBuffer)
{
for(int i=0; i<this->m_MaxBufferSize; i++)
{
delete[] this->m_DistanceDataBuffer[i];
}
delete[] this->m_DistanceDataBuffer;
}
if (m_AmplitudeDataBuffer)
{
for(int i=0; i<this->m_MaxBufferSize; i++)
{
delete[] this->m_AmplitudeDataBuffer[i];
}
delete[] this->m_AmplitudeDataBuffer;
}
if (m_IntensityDataBuffer)
{
for(int i=0; i<this->m_MaxBufferSize; i++)
{
delete[] this->m_IntensityDataBuffer[i];
}
delete[] this->m_IntensityDataBuffer;
}
if (m_RGBDataBuffer)
{
for(int i=0; i<this->m_MaxBufferSize; i++)
{
delete[] this->m_RGBDataBuffer[i];
}
delete[] this->m_RGBDataBuffer;
}
}
void ToFCameraMITKPlayerDevice::AllocateDataBuffers()
{
// free memory if it was already allocated
this->CleanUpDataBuffers();
// allocate buffers
this->m_DistanceDataBuffer = new float*[this->m_MaxBufferSize];
for(int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_DistanceDataBuffer[i] = new float[this->m_PixelNumber];
}
this->m_AmplitudeDataBuffer = new float*[this->m_MaxBufferSize];
for(int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_AmplitudeDataBuffer[i] = new float[this->m_PixelNumber];
}
this->m_IntensityDataBuffer = new float*[this->m_MaxBufferSize];
for(int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_IntensityDataBuffer[i] = new float[this->m_PixelNumber];
}
this->m_RGBDataBuffer = new unsigned char*[this->m_MaxBufferSize];
for(int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_RGBDataBuffer[i] = new unsigned char[this->m_PixelNumber*3];
}
}
}
diff --git a/Modules/ToFHardware/mitkToFImageGrabber.cpp b/Modules/ToFHardware/mitkToFImageGrabber.cpp
index 8072466c39..58718a01f3 100644
--- a/Modules/ToFHardware/mitkToFImageGrabber.cpp
+++ b/Modules/ToFHardware/mitkToFImageGrabber.cpp
@@ -1,341 +1,349 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFImageGrabber.h"
//#include "mitkToFCameraPMDCamCubeDevice.h"
#include "itkCommand.h"
namespace mitk
{
ToFImageGrabber::ToFImageGrabber():m_CaptureWidth(204),m_CaptureHeight(204),m_PixelNumber(41616),
m_ImageSequence(0), m_RGBImageWidth(0), m_RGBImageHeight(0), m_RGBPixelNumber(0),
- m_IntensityArray(NULL), m_DistanceArray(NULL), m_AmplitudeArray(NULL), m_SourceDataArray(NULL), m_RgbDataArray(NULL)
+ m_IntensityArray(NULL), m_DistanceArray(NULL), m_AmplitudeArray(NULL), m_SourceDataArray(NULL), m_RgbDataArray(NULL),
+ m_DistanceImageInitialized(false),m_IntensityImageInitialized(false),m_AmplitudeImageInitialized(false),m_RGBImageInitialized(false)
{
// Create the output. We use static_cast<> here because we know the default
// output must be of type TOutputImage
OutputImageType::Pointer output0 = static_cast<OutputImageType*>(this->MakeOutput(0).GetPointer());
OutputImageType::Pointer output1 = static_cast<OutputImageType*>(this->MakeOutput(1).GetPointer());
OutputImageType::Pointer output2 = static_cast<OutputImageType*>(this->MakeOutput(2).GetPointer());
OutputImageType::Pointer output3 = static_cast<OutputImageType*>(this->MakeOutput(3).GetPointer());
mitk::ImageSource::SetNumberOfRequiredOutputs(3);
mitk::ImageSource::SetNthOutput(0, output0.GetPointer());
mitk::ImageSource::SetNthOutput(1, output1.GetPointer());
mitk::ImageSource::SetNthOutput(2, output2.GetPointer());
mitk::ImageSource::SetNthOutput(3, output3.GetPointer());
}
ToFImageGrabber::~ToFImageGrabber()
{
if (m_IntensityArray||m_AmplitudeArray||m_DistanceArray||m_RgbDataArray)
{
if (m_ToFCameraDevice)
{
m_ToFCameraDevice->RemoveObserver(m_DeviceObserverTag);
}
this->DisconnectCamera();
this->CleanUpImageArrays();
}
}
- mitk::ImageSource::DataObjectPointer mitk::ImageSource::MakeOutput(unsigned int)
- {
- return static_cast<itk::DataObject*>(OutputImageType::New().GetPointer());
- }
-
void ToFImageGrabber::GenerateData()
{
int requiredImageSequence = 0;
int capturedImageSequence = 0;
unsigned int dimensions[3];
dimensions[0] = this->m_ToFCameraDevice->GetCaptureWidth();
dimensions[1] = this->m_ToFCameraDevice->GetCaptureHeight();
dimensions[2] = 1;
mitk::PixelType FloatType = MakeScalarPixelType<float>();
// acquire new image data
this->m_ToFCameraDevice->GetAllImages(this->m_DistanceArray, this->m_AmplitudeArray, this->m_IntensityArray, this->m_SourceDataArray,
requiredImageSequence, this->m_ImageSequence, this->m_RgbDataArray );
- mitk::Image::Pointer distanceImage = this->GetOutput(0);
- if (!distanceImage->IsInitialized())
+ mitk::Image::Pointer distanceImage = this->GetOutput();
+ //if (!distanceImage->IsInitialized())
+ if (!m_DistanceImageInitialized)
{
distanceImage->ReleaseData();
distanceImage->Initialize(FloatType, 3, dimensions, 1);
+ m_DistanceImageInitialized = true;
}
mitk::Image::Pointer amplitudeImage = this->GetOutput(1);
- if (!amplitudeImage->IsInitialized())
+ //if (!amplitudeImage->IsInitialized())
+ if (!m_AmplitudeImageInitialized)
{
amplitudeImage->ReleaseData();
amplitudeImage->Initialize(FloatType, 3, dimensions, 1);
+ m_AmplitudeImageInitialized = true;
}
mitk::Image::Pointer intensityImage = this->GetOutput(2);
- if (!intensityImage->IsInitialized())
+ //if (!intensityImage->IsInitialized())
+ if (!m_IntensityImageInitialized)
{
intensityImage->ReleaseData();
intensityImage->Initialize(FloatType, 3, dimensions, 1);
+ m_IntensityImageInitialized = true;
}
unsigned int rgbDimension[3];
rgbDimension[0] = this->GetRGBImageWidth();
rgbDimension[1] = this->GetRGBImageHeight();
rgbDimension[2] = 1 ;
mitk::Image::Pointer rgbImage = this->GetOutput(3);
- if (!rgbImage->IsInitialized())
+ //if (!rgbImage->IsInitialized())
+ if (!m_RGBImageInitialized)
{
rgbImage->ReleaseData();
rgbImage->Initialize(mitk::PixelType(MakePixelType<unsigned char, itk::RGBPixel<unsigned char>, 3>()), 3, rgbDimension,1);
+ m_RGBImageInitialized = true;
}
capturedImageSequence = this->m_ImageSequence;
if (m_DistanceArray)
{
distanceImage->SetSlice(this->m_DistanceArray, 0, 0, 0);
}
if (m_AmplitudeArray)
{
amplitudeImage->SetSlice(this->m_AmplitudeArray, 0, 0, 0);
}
if (m_IntensityArray)
{
intensityImage->SetSlice(this->m_IntensityArray, 0, 0, 0);
}
if (m_RgbDataArray)
{
rgbImage->SetSlice(this->m_RgbDataArray, 0, 0, 0);
}
}
bool ToFImageGrabber::ConnectCamera()
{
bool ok = m_ToFCameraDevice->ConnectCamera();
if (ok)
{
this->m_CaptureWidth = this->m_ToFCameraDevice->GetCaptureWidth();
this->m_CaptureHeight = this->m_ToFCameraDevice->GetCaptureHeight();
this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
this->m_RGBImageWidth = this->m_ToFCameraDevice->GetRGBCaptureWidth();
this->m_RGBImageHeight = this->m_ToFCameraDevice->GetRGBCaptureHeight();
this->m_RGBPixelNumber = this->m_RGBImageWidth * this->m_RGBImageHeight;
this->m_SourceDataSize = m_ToFCameraDevice->GetSourceDataSize();
this->AllocateImageArrays();
}
return ok;
}
bool ToFImageGrabber::DisconnectCamera()
{
bool success = m_ToFCameraDevice->DisconnectCamera();
-
+ // reset initialized flag of outputs to allow reinitializing when using new device
+ m_DistanceImageInitialized = false;
+ m_IntensityImageInitialized = false;
+ m_AmplitudeImageInitialized = false;
+ m_RGBImageInitialized = false;
return success;
}
void ToFImageGrabber::StartCamera()
{
m_ToFCameraDevice->StartCamera();
}
void ToFImageGrabber::StopCamera()
{
m_ToFCameraDevice->StopCamera();
}
bool ToFImageGrabber::IsCameraActive()
{
return m_ToFCameraDevice->IsCameraActive();
}
bool ToFImageGrabber::IsCameraConnected()
{
return m_ToFCameraDevice->IsCameraConnected();
}
void ToFImageGrabber::SetCameraDevice(ToFCameraDevice* aToFCameraDevice)
{
m_ToFCameraDevice = aToFCameraDevice;
itk::SimpleMemberCommand<ToFImageGrabber>::Pointer modifiedCommand = itk::SimpleMemberCommand<ToFImageGrabber>::New();
modifiedCommand->SetCallbackFunction(this, &ToFImageGrabber::OnToFCameraDeviceModified);
m_DeviceObserverTag = m_ToFCameraDevice->AddObserver(itk::ModifiedEvent(), modifiedCommand);
this->Modified();
}
ToFCameraDevice* ToFImageGrabber::GetCameraDevice()
{
return m_ToFCameraDevice;
}
int ToFImageGrabber::GetCaptureWidth()
{
return m_CaptureWidth;
}
int ToFImageGrabber::GetCaptureHeight()
{
return m_CaptureHeight;
}
int ToFImageGrabber::GetPixelNumber()
{
return m_PixelNumber;
}
int ToFImageGrabber::GetRGBImageWidth()
{
return m_RGBImageWidth;
}
int ToFImageGrabber::GetRGBImageHeight()
{
return m_RGBImageHeight;
}
int ToFImageGrabber::GetRGBPixelNumber()
{
return m_RGBPixelNumber;
}
int ToFImageGrabber::SetModulationFrequency(int modulationFrequency)
{
this->m_ToFCameraDevice->SetProperty("ModulationFrequency",mitk::IntProperty::New(modulationFrequency));
this->Modified();
modulationFrequency = this->GetModulationFrequency(); // return the new valid modulation frequency from the camera
return modulationFrequency;
}
int ToFImageGrabber::SetIntegrationTime(int integrationTime)
{
this->m_ToFCameraDevice->SetProperty("IntegrationTime",mitk::IntProperty::New(integrationTime));
this->Modified();
integrationTime = this->GetIntegrationTime(); // return the new valid integration time from the camera
return integrationTime;
}
int ToFImageGrabber::GetIntegrationTime()
{
int integrationTime = 0;
this->m_ToFCameraDevice->GetIntProperty("IntegrationTime",integrationTime);
return integrationTime;
}
int ToFImageGrabber::GetModulationFrequency()
{
int modulationFrequency = 0;
this->m_ToFCameraDevice->GetIntProperty("ModulationFrequency",modulationFrequency);
return modulationFrequency;
}
void ToFImageGrabber::SetBoolProperty( const char* propertyKey, bool boolValue )
{
SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
}
void ToFImageGrabber::SetIntProperty( const char* propertyKey, int intValue )
{
SetProperty(propertyKey, mitk::IntProperty::New(intValue));
}
void ToFImageGrabber::SetFloatProperty( const char* propertyKey, float floatValue )
{
SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
}
void ToFImageGrabber::SetStringProperty( const char* propertyKey, const char* stringValue )
{
SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
}
void ToFImageGrabber::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
{
this->m_ToFCameraDevice->SetProperty(propertyKey, propertyValue);
}
bool ToFImageGrabber::GetBoolProperty( const char* propertyKey)
{
mitk::BoolProperty::Pointer boolProp = dynamic_cast<mitk::BoolProperty*>(GetProperty(propertyKey));
if(!boolProp) return false;
return boolProp->GetValue();
}
int ToFImageGrabber::GetIntProperty( const char* propertyKey)
{
mitk::IntProperty::Pointer intProp = dynamic_cast<mitk::IntProperty*>(GetProperty(propertyKey));
return intProp->GetValue();
}
float ToFImageGrabber::GetFloatProperty( const char* propertyKey)
{
mitk::FloatProperty::Pointer floatProp = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey));
return floatProp->GetValue();
}
const char* ToFImageGrabber::GetStringProperty( const char* propertyKey)
{
mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty*>(GetProperty(propertyKey));
return stringProp->GetValue();
}
BaseProperty* ToFImageGrabber::GetProperty( const char *propertyKey)
{
return this->m_ToFCameraDevice->GetProperty(propertyKey);
}
void ToFImageGrabber::OnToFCameraDeviceModified()
{
this->Modified();
}
void ToFImageGrabber::CleanUpImageArrays()
{
// free buffer
if (m_IntensityArray)
{
delete [] m_IntensityArray;
m_IntensityArray = NULL;
}
if (m_DistanceArray)
{
delete [] m_DistanceArray;
m_DistanceArray = NULL;
}
if (m_AmplitudeArray)
{
delete [] m_AmplitudeArray;
m_AmplitudeArray = NULL;
}
if (m_SourceDataArray)
{
delete [] m_SourceDataArray;
m_SourceDataArray = NULL;
}
if (m_RgbDataArray)
{
delete [] m_RgbDataArray;
m_RgbDataArray = NULL;
}
}
void ToFImageGrabber::AllocateImageArrays()
{
// cleanup memory if necessary
this->CleanUpImageArrays();
// allocate buffer
m_IntensityArray = new float[m_PixelNumber];
m_DistanceArray = new float[m_PixelNumber];
m_AmplitudeArray = new float[m_PixelNumber];
m_SourceDataArray = new char[m_SourceDataSize];
m_RgbDataArray = new unsigned char[m_RGBPixelNumber*3];
}
}
diff --git a/Modules/ToFHardware/mitkToFImageGrabber.h b/Modules/ToFHardware/mitkToFImageGrabber.h
index a87cdf9d28..b52adc668d 100644
--- a/Modules/ToFHardware/mitkToFImageGrabber.h
+++ b/Modules/ToFHardware/mitkToFImageGrabber.h
@@ -1,203 +1,206 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkToFImageGrabber_h
#define __mitkToFImageGrabber_h
#include "mitkToFHardwareExports.h"
#include "mitkCommon.h"
#include "mitkImageSource.h"
#include "mitkToFCameraDevice.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace mitk
{
/**Documentation
* \brief Image source providing ToF images. Interface for filters provided in ToFProcessing module
*
* This class internally holds a ToFCameraDevice to access the images acquired by a ToF camera.
*
* Provided images include: distance image (output 0), amplitude image (output 1), intensity image (output 2)
*
* \ingroup ToFHardware
*/
class MITK_TOFHARDWARE_EXPORT ToFImageGrabber : public mitk::ImageSource
{
public:
mitkClassMacro( ToFImageGrabber , ImageSource );
itkNewMacro( Self );
/*!
\brief Establish a connection to the ToF camera
*/
virtual bool ConnectCamera();
/*!
\brief Disconnects the ToF camera
*/
virtual bool DisconnectCamera();
/*!
\brief Starts the continuous updating of the camera.
A separate thread updates the source data, the main thread processes the source data and creates images and coordinates
*/
virtual void StartCamera();
/*!
\brief Stops the continuous updating of the camera
*/
virtual void StopCamera();
/*!
\brief Returns true if the camera is connected and started
*/
virtual bool IsCameraActive();
/*!
\brief Returns true if the camera is connected
*/
virtual bool IsCameraConnected();
/*!
\brief Sets the ToF device, the image grabber is grabbing the images from
\param aToFCameraDevice device internally used for grabbing the images from the camera
*/
void SetCameraDevice(ToFCameraDevice* aToFCameraDevice);
/*!
\brief Get the currently set ToF camera device
\return device currently used for grabbing images from the camera
*/
ToFCameraDevice* GetCameraDevice();
/*!
\brief Set the modulation frequency used by the ToF camera.
For default values see the corresponding device classes
\param modulationFrequency modulation frequency in Hz
*/
int SetModulationFrequency(int modulationFrequency);
/*!
\brief Get the modulation frequency used by the ToF camera.
\return modulation frequency in MHz
*/
int GetModulationFrequency();
/*!
\brief Set the integration time used by the ToF camera.
For default values see the corresponding device classes
\param integrationTime integration time in ms
*/
int SetIntegrationTime(int integrationTime);
/*!
\brief Get the integration time in used by the ToF camera.
\return integration time in ms
*/
int GetIntegrationTime();
/*!
\brief Get the dimension in x direction of the ToF image
\return width of the image
*/
int GetCaptureWidth();
/*!
\brief Get the dimension in y direction of the ToF image
\return height of the image
*/
int GetCaptureHeight();
/*!
\brief Get the number of pixel in the ToF image
\return number of pixel
*/
int GetPixelNumber();
/*!
\brief Get the dimension in x direction of the ToF image
\return width of the image
*/
int GetRGBImageWidth();
/*!
\brief Get the dimension in y direction of the ToF image
\return height of the image
*/
int GetRGBImageHeight();
/*!
\brief Get the number of pixel in the ToF image
\return number of pixel
*/
int GetRGBPixelNumber();
// properties
void SetBoolProperty( const char* propertyKey, bool boolValue );
void SetIntProperty( const char* propertyKey, int intValue );
void SetFloatProperty( const char* propertyKey, float floatValue );
void SetStringProperty( const char* propertyKey, const char* stringValue );
void SetProperty( const char *propertyKey, BaseProperty* propertyValue );
bool GetBoolProperty( const char* propertyKey);
int GetIntProperty( const char* propertyKey);
float GetFloatProperty( const char* propertyKey);
const char* GetStringProperty( const char* propertyKey);
BaseProperty* GetProperty( const char *propertyKey);
protected:
///
/// called when the ToFCameraDevice was modified
///
void OnToFCameraDeviceModified();
/*!
\brief clean up memory allocated for the image arrays m_IntensityArray, m_DistanceArray, m_AmplitudeArray and m_SourceDataArray
*/
virtual void CleanUpImageArrays();
/*!
\brief Allocate memory for the image arrays m_IntensityArray, m_DistanceArray, m_AmplitudeArray and m_SourceDataArray
*/
virtual void AllocateImageArrays();
ToFCameraDevice::Pointer m_ToFCameraDevice; ///< Device allowing access to ToF image data
int m_CaptureWidth; ///< Width of the captured ToF image
int m_CaptureHeight; ///< Height of the captured ToF image
int m_PixelNumber; ///< Number of pixels in the image
int m_RGBImageWidth;
int m_RGBImageHeight;
int m_RGBPixelNumber;
int m_ImageSequence; ///< counter for currently acquired images
int m_SourceDataSize; ///< size of the source data in bytes
float* m_IntensityArray; ///< member holding the current intensity array
float* m_DistanceArray; ///< member holding the current distance array
float* m_AmplitudeArray; ///< member holding the current amplitude array
char* m_SourceDataArray;///< member holding the current source data array
unsigned char* m_RgbDataArray; ///< member holding the current rgb data array
unsigned long m_DeviceObserverTag; ///< tag of the observer for the ToFCameraDevice
-
+ bool m_DistanceImageInitialized; ///< flag indicating whether the distance image is initialized or not
+ bool m_IntensityImageInitialized; ///< flag indicating whether the intensity image is initialized or not
+ bool m_AmplitudeImageInitialized; ///< flag indicating whether the amplitude image is initialized or not
+ bool m_RGBImageInitialized; ///< flag indicating whether the RGB image is initialized or not
ToFImageGrabber();
~ToFImageGrabber();
/*!
\brief Method generating the outputs of this filter. Called in the updated process of the pipeline.
0: distance image
1: amplitude image
2: intensity image
*/
void GenerateData();
private:
};
} //END mitk namespace
#endif
diff --git a/Modules/ToFHardware/mitkToFImageRecorder.cpp b/Modules/ToFHardware/mitkToFImageRecorder.cpp
index 15c9362359..c264ceea47 100644
--- a/Modules/ToFHardware/mitkToFImageRecorder.cpp
+++ b/Modules/ToFHardware/mitkToFImageRecorder.cpp
@@ -1,268 +1,268 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFImageRecorder.h"
#include "mitkRealTimeClock.h"
#include "itkMultiThreader.h"
#include <itksys/SystemTools.hxx>
#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop
namespace mitk
{
ToFImageRecorder::ToFImageRecorder()
{
this->m_ToFCameraDevice = NULL;
this->m_MultiThreader = itk::MultiThreader::New();
this->m_AbortMutex = itk::FastMutexLock::New();
this->m_ThreadID = 0;
this->m_NumOfFrames = 0;
this->m_ToFImageWriter = NULL;
this->m_DistanceImageSelected = true;
this->m_AmplitudeImageSelected = true;
this->m_IntensityImageSelected = true;
this->m_RGBImageSelected = true;
this->m_Abort = false;
this->m_ToFCaptureWidth = 0;
this->m_ToFCaptureHeight = 0;
this->m_RGBCaptureWidth = 0;
this->m_RGBCaptureHeight = 0;
this->m_FileFormat = "";
this->m_ToFPixelNumber = 0;
this->m_RGBPixelNumber = 0;
this->m_SourceDataSize = 0;
this->m_ToFImageType = ToFImageWriter::ToFImageType3D;
this->m_RecordMode = ToFImageRecorder::PerFrames;
this->m_DistanceImageFileName = "";
this->m_AmplitudeImageFileName = "";
this->m_IntensityImageFileName = "";
this->m_RGBImageFileName = "";
this->m_ImageSequence = 0;
this->m_DistanceArray = NULL;
this->m_AmplitudeArray = NULL;
this->m_IntensityArray = NULL;
this->m_RGBArray = NULL;
this->m_SourceDataArray = NULL;
}
ToFImageRecorder::~ToFImageRecorder()
{
delete[] m_DistanceArray;
delete[] m_AmplitudeArray;
delete[] m_IntensityArray;
delete[] m_RGBArray;
delete[] m_SourceDataArray;
}
void ToFImageRecorder::StopRecording()
{
this->m_AbortMutex->Lock();
this->m_Abort = true;
this->m_AbortMutex->Unlock();
}
void ToFImageRecorder::StartRecording()
{
if (this->m_ToFCameraDevice.IsNull())
{
throw std::invalid_argument("ToFCameraDevice is NULL.");
return;
}
if (this->m_FileFormat.compare(".csv") == 0)
{
this->m_ToFImageWriter = ToFImageCsvWriter::New();
}
else if(this->m_FileFormat.compare(".nrrd") == 0)
{
this->m_ToFImageWriter = ToFNrrdImageWriter::New();
this->m_ToFImageWriter->SetExtension(m_FileFormat);
}
else
{
throw std::logic_error("No file format specified!");
}
this->m_RGBCaptureWidth = this->m_ToFCameraDevice->GetRGBCaptureWidth();
this->m_RGBCaptureHeight = this->m_ToFCameraDevice->GetRGBCaptureHeight();
this->m_RGBPixelNumber = this->m_RGBCaptureWidth * this->m_RGBCaptureHeight;
this->m_ToFCaptureWidth = this->m_ToFCameraDevice->GetCaptureWidth();
this->m_ToFCaptureHeight = this->m_ToFCameraDevice->GetCaptureHeight();
this->m_ToFPixelNumber = this->m_ToFCaptureWidth * this->m_ToFCaptureHeight;
this->m_SourceDataSize = this->m_ToFCameraDevice->GetSourceDataSize();
// allocate buffer
if(m_IntensityArray == NULL)
{
this->m_IntensityArray = new float[m_ToFPixelNumber];
}
if(this->m_DistanceArray == NULL)
{
this->m_DistanceArray = new float[m_ToFPixelNumber];
}
if(this->m_AmplitudeArray == NULL)
{
this->m_AmplitudeArray = new float[m_ToFPixelNumber];
}
if(this->m_RGBArray == NULL)
{
this->m_RGBArray = new unsigned char[m_RGBPixelNumber*3];
}
if(this->m_SourceDataArray == NULL)
{
this->m_SourceDataArray = new char[m_SourceDataSize];
}
this->m_ToFImageWriter->SetDistanceImageFileName(this->m_DistanceImageFileName);
this->m_ToFImageWriter->SetAmplitudeImageFileName(this->m_AmplitudeImageFileName);
this->m_ToFImageWriter->SetIntensityImageFileName(this->m_IntensityImageFileName);
this->m_ToFImageWriter->SetRGBImageFileName(this->m_RGBImageFileName);
this->m_ToFImageWriter->SetRGBCaptureWidth(this->m_RGBCaptureWidth);
this->m_ToFImageWriter->SetRGBCaptureHeight(this->m_RGBCaptureHeight);
- this->m_ToFImageWriter->SetToFCaptureHeight(this->m_ToFCaptureHeight);
+ //this->m_ToFImageWriter->SetToFCaptureHeight(this->m_ToFCaptureHeight);
this->m_ToFImageWriter->SetToFCaptureWidth(this->m_ToFCaptureWidth);
this->m_ToFImageWriter->SetToFCaptureHeight(this->m_ToFCaptureHeight);
this->m_ToFImageWriter->SetToFImageType(this->m_ToFImageType);
this->m_ToFImageWriter->SetDistanceImageSelected(this->m_DistanceImageSelected);
this->m_ToFImageWriter->SetAmplitudeImageSelected(this->m_AmplitudeImageSelected);
this->m_ToFImageWriter->SetIntensityImageSelected(this->m_IntensityImageSelected);
this->m_ToFImageWriter->SetRGBImageSelected(this->m_RGBImageSelected);
this->m_ToFImageWriter->Open();
this->m_AbortMutex->Lock();
this->m_Abort = false;
this->m_AbortMutex->Unlock();
this->m_ThreadID = this->m_MultiThreader->SpawnThread(this->RecordData, this);
}
void ToFImageRecorder::WaitForThreadBeingTerminated()
{
this->m_MultiThreader->TerminateThread(this->m_ThreadID);
}
ITK_THREAD_RETURN_TYPE ToFImageRecorder::RecordData(void* pInfoStruct)
{
struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
ToFImageRecorder* toFImageRecorder = (ToFImageRecorder*)pInfo->UserData;
if (toFImageRecorder!=NULL)
{
ToFCameraDevice::Pointer toFCameraDevice = toFImageRecorder->GetCameraDevice();
mitk::RealTimeClock::Pointer realTimeClock;
realTimeClock = mitk::RealTimeClock::New();
int n = 100;
double t1 = 0;
double t2 = 0;
t1 = realTimeClock->GetCurrentStamp();
bool overflow = false;
bool printStatus = false;
int requiredImageSequence = 0;
int numOfFramesRecorded = 0;
bool abort = false;
toFImageRecorder->m_AbortMutex->Lock();
abort = toFImageRecorder->m_Abort;
toFImageRecorder->m_AbortMutex->Unlock();
while ( !abort )
{
if ( ((toFImageRecorder->m_RecordMode == ToFImageRecorder::PerFrames) && (numOfFramesRecorded < toFImageRecorder->m_NumOfFrames)) ||
(toFImageRecorder->m_RecordMode == ToFImageRecorder::Infinite) )
{
toFCameraDevice->GetAllImages(toFImageRecorder->m_DistanceArray, toFImageRecorder->m_AmplitudeArray,
toFImageRecorder->m_IntensityArray, toFImageRecorder->m_SourceDataArray, requiredImageSequence, toFImageRecorder->m_ImageSequence, toFImageRecorder->m_RGBArray );
if (toFImageRecorder->m_ImageSequence >= requiredImageSequence)
{
if (toFImageRecorder->m_ImageSequence > requiredImageSequence)
{
MITK_INFO << "Problem! required: " << requiredImageSequence << " captured: " << toFImageRecorder->m_ImageSequence;
}
requiredImageSequence = toFImageRecorder->m_ImageSequence + 1;
toFImageRecorder->m_ToFImageWriter->Add( toFImageRecorder->m_DistanceArray,
toFImageRecorder->m_AmplitudeArray, toFImageRecorder->m_IntensityArray, toFImageRecorder->m_RGBArray );
numOfFramesRecorded++;
if (numOfFramesRecorded % n == 0)
{
printStatus = true;
}
if (printStatus)
{
t2 = realTimeClock->GetCurrentStamp() - t1;
MITK_INFO << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFImageRecorder->m_ImageSequence;
t1 = realTimeClock->GetCurrentStamp();
printStatus = false;
}
}
toFImageRecorder->m_AbortMutex->Lock();
abort = toFImageRecorder->m_Abort;
toFImageRecorder->m_AbortMutex->Unlock();
}
else
{
abort = true;
}
} // end of while loop
toFImageRecorder->InvokeEvent(itk::AbortEvent());
toFImageRecorder->m_ToFImageWriter->Close();
}
return ITK_THREAD_RETURN_VALUE;
}
void ToFImageRecorder::SetCameraDevice(ToFCameraDevice* aToFCameraDevice)
{
this->m_ToFCameraDevice = aToFCameraDevice;
}
ToFCameraDevice* ToFImageRecorder::GetCameraDevice()
{
return this->m_ToFCameraDevice;
}
ToFImageWriter::ToFImageType ToFImageRecorder::GetToFImageType()
{
return this->m_ToFImageType;
}
void ToFImageRecorder::SetToFImageType(ToFImageWriter::ToFImageType toFImageType)
{
this->m_ToFImageType = toFImageType;
}
ToFImageRecorder::RecordMode ToFImageRecorder::GetRecordMode()
{
return this->m_RecordMode;
}
void ToFImageRecorder::SetRecordMode(ToFImageRecorder::RecordMode recordMode)
{
this->m_RecordMode = recordMode;
}
}
diff --git a/Modules/ToFHardware/mitkToFNrrdImageWriter.cpp b/Modules/ToFHardware/mitkToFNrrdImageWriter.cpp
index 22c344f963..adb80b6aab 100644
--- a/Modules/ToFHardware/mitkToFNrrdImageWriter.cpp
+++ b/Modules/ToFHardware/mitkToFNrrdImageWriter.cpp
@@ -1,271 +1,281 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// mitk includes
#include <mitkToFNrrdImageWriter.h>
// itk includes
#include "itksys/SystemTools.hxx"
#include "itkNrrdImageIO.h"
namespace mitk
{
ToFNrrdImageWriter::ToFNrrdImageWriter(): ToFImageWriter(),
m_DistanceOutfile(), m_AmplitudeOutfile(), m_IntensityOutfile()
{
m_Extension = std::string(".nrrd");
}
ToFNrrdImageWriter::~ToFNrrdImageWriter()
{
}
void ToFNrrdImageWriter::Open()
{
this->CheckForFileExtension(this->m_DistanceImageFileName);
this->CheckForFileExtension(this->m_AmplitudeImageFileName);
this->CheckForFileExtension(this->m_IntensityImageFileName);
this->CheckForFileExtension(this->m_RGBImageFileName);
this->m_ToFPixelNumber = this->m_ToFCaptureWidth * this->m_ToFCaptureHeight;
this->m_ToFImageSizeInBytes = this->m_ToFPixelNumber * sizeof(float);
this->m_RGBPixelNumber = this->m_RGBCaptureWidth * this->m_RGBCaptureHeight;
this->m_RGBImageSizeInBytes = this->m_RGBPixelNumber * sizeof(unsigned char) * 3;
if (this->m_DistanceImageSelected)
{
this->OpenStreamFile( this->m_DistanceOutfile, this->m_DistanceImageFileName);
}
if (this->m_AmplitudeImageSelected)
{
this->OpenStreamFile(this->m_AmplitudeOutfile, this->m_AmplitudeImageFileName);
}
if (this->m_IntensityImageSelected)
{
this->OpenStreamFile(this->m_IntensityOutfile, this->m_IntensityImageFileName);
}
if (this->m_RGBImageSelected)
{
this->OpenStreamFile(this->m_RGBOutfile, this->m_RGBImageFileName);
}
this->m_NumOfFrames = 0;
}
void ToFNrrdImageWriter::Close()
{
if (this->m_DistanceImageSelected)
{
this->CloseStreamFile(this->m_DistanceOutfile, this->m_DistanceImageFileName);
}
if (this->m_AmplitudeImageSelected)
{
this->CloseStreamFile(this->m_AmplitudeOutfile, this->m_AmplitudeImageFileName);
}
if (this->m_IntensityImageSelected)
{
this->CloseStreamFile(this->m_IntensityOutfile, this->m_IntensityImageFileName);
}
if (this->m_RGBImageSelected)
{
this->CloseStreamFile(this->m_RGBOutfile, this->m_RGBImageFileName);
}
}
void ToFNrrdImageWriter::Add(float* distanceFloatData, float* amplitudeFloatData, float* intensityFloatData, unsigned char* rgbData)
{
if (this->m_DistanceImageSelected)
{
this->m_DistanceOutfile.write( (char*) distanceFloatData, this->m_ToFImageSizeInBytes);
}
if (this->m_AmplitudeImageSelected)
{
this->m_AmplitudeOutfile.write( (char*)amplitudeFloatData, this->m_ToFImageSizeInBytes);
}
if (this->m_IntensityImageSelected)
{
this->m_IntensityOutfile.write(( char* )intensityFloatData, this->m_ToFImageSizeInBytes);
}
if (this->m_RGBImageSelected)
{
this->m_RGBOutfile.write(( char* )rgbData, this->m_RGBImageSizeInBytes);
}
this->m_NumOfFrames++;
}
void ToFNrrdImageWriter::OpenStreamFile( std::ofstream &outfile, std::string outfileName )
{
outfile.open(outfileName.c_str(), std::ofstream::binary);
if(!outfile.is_open())
{
MITK_ERROR << "Error opening outfile: " << outfileName;
throw std::logic_error("Error opening outfile.");
return;
}
}
void ToFNrrdImageWriter::CloseStreamFile( std::ofstream &outfile, std::string fileName )
{
if (this->m_NumOfFrames == 0)
{
outfile.close();
throw std::logic_error("File is empty.");
return;
}
// flush the last data to the file and convert the stream data to nrrd file
outfile.flush();
this->ConvertStreamToNrrdFormat( fileName );
outfile.close();
}
void ToFNrrdImageWriter::ConvertStreamToNrrdFormat( std::string fileName )
{
int CaptureWidth = 0;
int CaptureHeight = 0;
int PixelNumber = 0;
int ImageSizeInBytes = 0;
if (fileName==this->m_RGBImageFileName)
{
CaptureWidth = this->m_RGBCaptureWidth;
CaptureHeight = this->m_RGBCaptureHeight;
PixelNumber = this->m_RGBPixelNumber;
ImageSizeInBytes = this->m_RGBImageSizeInBytes;
} else
{
CaptureWidth = this->m_ToFCaptureWidth;
CaptureHeight = this->m_ToFCaptureHeight;
PixelNumber = this->m_ToFPixelNumber;
ImageSizeInBytes = this->m_ToFImageSizeInBytes;
}
Image::Pointer imageTemplate = Image::New();
int dimension ;
unsigned int* dimensions;
if(m_ToFImageType == ToFImageType2DPlusT)
{
dimension = 4;
dimensions = new unsigned int[dimension];
dimensions[0] = CaptureWidth;
dimensions[1] = CaptureHeight;
dimensions[2] = 1;
dimensions[3] = this->m_NumOfFrames;
}
else if( m_ToFImageType == ToFImageType3D)
{
dimension = 3;
dimensions = new unsigned int[dimension];
dimensions[0] = CaptureWidth;
dimensions[1] = CaptureHeight;
dimensions[2] = this->m_NumOfFrames;
}
else
{
throw std::logic_error("No image type set, please choose between 2D+t and 3D!");
}
float* floatData;
unsigned char* rgbData;
if (fileName==this->m_RGBImageFileName)
{
rgbData = new unsigned char[PixelNumber*3];
for(int i=0; i<PixelNumber*3; i++)
{
rgbData[i] = i + 0.0;
}
mitk::PixelType RGBType = MakePixelType<unsigned char, itk::RGBPixel<unsigned char>, 3>();
imageTemplate->Initialize( RGBType,dimension, dimensions, 1);
imageTemplate->SetSlice(rgbData, 0, 0, 0);
}
else
{
floatData = new float[PixelNumber];
for(int i=0; i<PixelNumber; i++)
{
floatData[i] = i + 0.0;
}
mitk::PixelType FloatType = MakeScalarPixelType<float>();
imageTemplate->Initialize( FloatType,dimension, dimensions, 1);
imageTemplate->SetSlice(floatData, 0, 0, 0);
}
itk::NrrdImageIO::Pointer nrrdWriter = itk::NrrdImageIO::New();
nrrdWriter->SetNumberOfDimensions(dimension);
- nrrdWriter->SetPixelTypeInfo(imageTemplate->GetPixelType().GetTypeId());
+ nrrdWriter->SetPixelType( imageTemplate->GetPixelType().GetPixelType());
+ nrrdWriter->SetComponentType( (itk::ImageIOBase::IOComponentType) imageTemplate->GetPixelType().GetComponentType());
if(imageTemplate->GetPixelType().GetNumberOfComponents() > 1)
{
nrrdWriter->SetNumberOfComponents(imageTemplate->GetPixelType().GetNumberOfComponents());
}
itk::ImageIORegion ioRegion( dimension );
mitk::Vector3D spacing = imageTemplate->GetGeometry()->GetSpacing();
mitk::Point3D origin = imageTemplate->GetGeometry()->GetOrigin();
for(unsigned int i = 0; i < dimension; i++)
{
nrrdWriter->SetDimensions(i,dimensions[i]);
nrrdWriter->SetSpacing(i,spacing[i]);
nrrdWriter->SetOrigin(i,origin[i]);
mitk::Vector3D direction;
direction.Set_vnl_vector(imageTemplate->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
vnl_vector< double > axisDirection(dimension);
for(unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction[j]/spacing[i];
}
nrrdWriter->SetDirection( i, axisDirection );
ioRegion.SetSize(i, imageTemplate->GetLargestPossibleRegion().GetSize(i) );
ioRegion.SetIndex(i, imageTemplate->GetLargestPossibleRegion().GetIndex(i) );
}
nrrdWriter->SetIORegion(ioRegion);
nrrdWriter->SetFileName(fileName);
nrrdWriter->SetUseStreamedWriting(true);
std::ifstream stream(fileName.c_str(), std::ifstream::binary);
if (fileName==m_RGBImageFileName)
{
unsigned int size = PixelNumber*3 * this->m_NumOfFrames;
unsigned int sizeInBytes = size * sizeof(unsigned char);
unsigned char* data = new unsigned char[size];
stream.read((char*)data, sizeInBytes);
nrrdWriter->Write(data);
stream.close();
delete[] data;
}
else
{
unsigned int size = PixelNumber * this->m_NumOfFrames;
unsigned int sizeInBytes = size * sizeof(float);
float* data = new float[size];
stream.read((char*)data, sizeInBytes);
- nrrdWriter->Write(data);
+ try
+ {
+ nrrdWriter->Write(data);
+ }
+ catch (itk::ExceptionObject* e)
+ {
+ MITK_ERROR<< e->what();
+ return;
+ }
+
stream.close();
delete[] data;
}
delete[] dimensions;
if (fileName==m_RGBImageFileName)
{
delete[] rgbData;
}
else
{
delete[] floatData;
}
}
} // end namespace mitk
diff --git a/Modules/ToFHardware/mitkToFOpenCVImageGrabber.cpp b/Modules/ToFHardware/mitkToFOpenCVImageGrabber.cpp
index fc9cec7c22..ad92814dde 100644
--- a/Modules/ToFHardware/mitkToFOpenCVImageGrabber.cpp
+++ b/Modules/ToFHardware/mitkToFOpenCVImageGrabber.cpp
@@ -1,179 +1,179 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFOpenCVImageGrabber.h"
// mitk includes
#include "mitkImageDataItem.h"
#include <mitkImageStatisticsHolder.h>
#include "vtkSmartPointer.h"
#include "vtkColorTransferFunction.h"
#include "vtkFloatArray.h"
namespace mitk
{
ToFOpenCVImageGrabber::ToFOpenCVImageGrabber()
{
m_CurrentOpenCVIntensityImage = NULL;
m_CurrentOpenCVAmplitudeImage = NULL;
m_CurrentOpenCVDistanceImage = NULL;
m_ImageType = 0;
m_ImageDepth = IPL_DEPTH_32F;
m_ImageGrabber = NULL;
}
ToFOpenCVImageGrabber::~ToFOpenCVImageGrabber()
{
}
cv::Mat ToFOpenCVImageGrabber::GetImage()
{
m_ImageGrabber->Update();
unsigned int numOfPixel = m_ImageGrabber->GetCaptureWidth()*m_ImageGrabber->GetCaptureHeight();
// copy current mitk images
unsigned int dimensions[4];
dimensions[0] = this->m_ImageGrabber->GetCaptureWidth();
dimensions[1] = this->m_ImageGrabber->GetCaptureHeight();
dimensions[2] = 1;
dimensions[3] = 1;
// create single component float pixel type
mitk::PixelType FloatType = MakeScalarPixelType<float>();
mitk::Image::Pointer currentMITKIntensityImage = mitk::Image::New();
currentMITKIntensityImage->Initialize(FloatType, 2, dimensions);
currentMITKIntensityImage->SetSlice((float*)m_ImageGrabber->GetOutput(2)->GetSliceData()->GetData(),0,0,0);
mitk::Image::Pointer currentMITKAmplitudeImage = mitk::Image::New();
currentMITKAmplitudeImage->Initialize(FloatType, 2, dimensions);
currentMITKAmplitudeImage->SetSlice((float*)m_ImageGrabber->GetOutput(1)->GetSliceData()->GetData(),0,0,0);
mitk::Image::Pointer currentMITKDistanceImage = mitk::Image::New();
currentMITKDistanceImage->Initialize(FloatType, 2, dimensions);
- currentMITKDistanceImage->SetSlice((float*)m_ImageGrabber->GetOutput(0)->GetSliceData()->GetData(),0,0,0);
+ currentMITKDistanceImage->SetSlice((float*)m_ImageGrabber->GetOutput()->GetSliceData()->GetData(),0,0,0);
// copy mitk images to OpenCV images
if (m_ImageDepth==IPL_DEPTH_32F)
{
if (m_ImageType==1)
{
float* amplitudeFloatData = (float*)currentMITKAmplitudeImage->GetSliceData(0, 0, 0)->GetData();
memcpy(m_CurrentOpenCVAmplitudeImage->imageData,(unsigned char*)amplitudeFloatData,numOfPixel*sizeof(float));
cv::Mat image(m_CurrentOpenCVAmplitudeImage);
return image;
}
else if (m_ImageType==2)
{
float* intensityFloatData = (float*)currentMITKIntensityImage->GetSliceData(0, 0, 0)->GetData();
memcpy(m_CurrentOpenCVIntensityImage->imageData,(unsigned char*)intensityFloatData,numOfPixel*sizeof(float));
cv::Mat image(m_CurrentOpenCVIntensityImage);
return image;
}
else
{
float* distanceFloatData = (float*)currentMITKDistanceImage->GetSliceData(0, 0, 0)->GetData();
memcpy(m_CurrentOpenCVDistanceImage->imageData,(unsigned char*)distanceFloatData,numOfPixel*sizeof(float));
cv::Mat image(m_CurrentOpenCVDistanceImage);
return image;
}
}
else
{
if (m_ImageType==1)
{
this->MapScalars(currentMITKAmplitudeImage, m_CurrentOpenCVAmplitudeImage);
cv::Mat image(m_CurrentOpenCVAmplitudeImage);
return image;
}
else if (m_ImageType==2)
{
this->MapScalars(currentMITKIntensityImage, m_CurrentOpenCVIntensityImage);
cv::Mat image(m_CurrentOpenCVIntensityImage);
return image;
}
else
{
this->MapScalars(currentMITKDistanceImage, m_CurrentOpenCVDistanceImage);
cv::Mat image(m_CurrentOpenCVDistanceImage);
return image;
}
}
}
void ToFOpenCVImageGrabber::SetImageType(unsigned int imageType)
{
m_ImageType = imageType;
}
void ToFOpenCVImageGrabber::SetImageDepth(unsigned int imageDepth)
{
m_ImageDepth = imageDepth;
}
void ToFOpenCVImageGrabber::SetToFImageGrabber(ToFImageGrabber::Pointer imageGrabber)
{
m_ImageGrabber = imageGrabber;
//initialize OpenCV images
m_CurrentOpenCVIntensityImage = cvCreateImage(cvSize(m_ImageGrabber->GetCaptureWidth(), m_ImageGrabber->GetCaptureHeight()), m_ImageDepth, 1);
m_CurrentOpenCVAmplitudeImage = cvCreateImage(cvSize(m_ImageGrabber->GetCaptureWidth(), m_ImageGrabber->GetCaptureHeight()), m_ImageDepth, 1);
m_CurrentOpenCVDistanceImage = cvCreateImage(cvSize(m_ImageGrabber->GetCaptureWidth(), m_ImageGrabber->GetCaptureHeight()), m_ImageDepth, 1);
}
ToFImageGrabber::Pointer ToFOpenCVImageGrabber::GetToFImageGrabber()
{
return m_ImageGrabber;
}
void ToFOpenCVImageGrabber::StartCapturing()
{
if (m_ImageGrabber.IsNotNull())
{
m_ImageGrabber->ConnectCamera();
m_ImageGrabber->StartCamera();
}
}
void ToFOpenCVImageGrabber::StopCapturing()
{
if (m_ImageGrabber.IsNotNull())
{
m_ImageGrabber->StopCamera();
m_ImageGrabber->DisconnectCamera();
}
}
void ToFOpenCVImageGrabber::MapScalars( mitk::Image::Pointer mitkImage, IplImage* openCVImage)
{
unsigned int numOfPixel = m_ImageGrabber->GetCaptureWidth()*m_ImageGrabber->GetCaptureHeight();
float* floatData = (float*)mitkImage->GetSliceData(0, 0, 0)->GetData();
vtkSmartPointer<vtkColorTransferFunction> colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
vtkSmartPointer<vtkFloatArray> floatArrayInt = vtkSmartPointer<vtkFloatArray>::New();
floatArrayInt->Initialize();
floatArrayInt->SetArray(floatData, numOfPixel, 0);
mitk::ScalarType min = mitkImage->GetStatistics()->GetScalarValueMin();
mitk::ScalarType max = mitkImage->GetStatistics()->GetScalarValueMaxNoRecompute();
MITK_INFO<<"Minimum: "<<min;
MITK_INFO<<"Maximum: "<<max;
colorTransferFunction->RemoveAllPoints();
colorTransferFunction->AddRGBPoint(min, 0, 0, 0);
colorTransferFunction->AddRGBPoint(max, 1, 1, 1);
colorTransferFunction->SetColorSpaceToHSV();
//TODO other depth values
colorTransferFunction->MapScalarsThroughTable(floatArrayInt, (unsigned char*)openCVImage->imageData, VTK_LUMINANCE);
}
}
diff --git a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
index 548d80464d..75f3bbdb18 100644
--- a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
@@ -1,393 +1,393 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkToFCompositeFilter.h>
#include <mitkInstantiateAccessFunctions.h>
//#include <mitkOclToFCompositeFilter.h>
#include <itkImage.h>
mitk::ToFCompositeFilter::ToFCompositeFilter() : m_SegmentationMask(NULL), m_ImageWidth(0), m_ImageHeight(0), m_ImageSize(0),
m_IplDistanceImage(NULL), m_IplOutputImage(NULL), m_ItkInputImage(NULL), m_ApplyTemporalMedianFilter(false), m_ApplyAverageFilter(false),
m_ApplyMedianFilter(false), m_ApplyThresholdFilter(false), m_ApplyMaskSegmentation(false), m_ApplyBilateralFilter(false), m_DataBuffer(NULL),
m_DataBufferCurrentIndex(0), m_DataBufferMaxSize(0), m_TemporalMedianFilterNumOfFrames(10), m_ThresholdFilterMin(1),
m_ThresholdFilterMax(7000), m_BilateralFilterDomainSigma(2), m_BilateralFilterRangeSigma(60), m_BilateralFilterKernelRadius(0)
{
}
mitk::ToFCompositeFilter::~ToFCompositeFilter()
{
cvReleaseImage(&(this->m_IplDistanceImage));
cvReleaseImage(&(this->m_IplOutputImage));
if (m_DataBuffer!=NULL)
{
delete [] m_DataBuffer;
}
}
void mitk::ToFCompositeFilter::SetInput( mitk::Image* distanceImage )
{
this->SetInput(0, distanceImage);
}
void mitk::ToFCompositeFilter::SetInput( unsigned int idx, mitk::Image* distanceImage )
{
if ((distanceImage == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one
{
this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
}
else
{
if (idx==0) //create IPL image holding distance data
{
if (distanceImage->GetData())
{
this->m_ImageWidth = distanceImage->GetDimension(0);
this->m_ImageHeight = distanceImage->GetDimension(1);
this->m_ImageSize = this->m_ImageWidth * this->m_ImageHeight * sizeof(float);
if (this->m_IplDistanceImage != NULL)
{
cvReleaseImage(&(this->m_IplDistanceImage));
}
float* distanceFloatData = (float*)distanceImage->GetSliceData(0, 0, 0)->GetData();
this->m_IplDistanceImage = cvCreateImage(cvSize(this->m_ImageWidth, this->m_ImageHeight), IPL_DEPTH_32F, 1);
memcpy(this->m_IplDistanceImage->imageData, (void*)distanceFloatData, this->m_ImageSize);
if (this->m_IplOutputImage != NULL)
{
cvReleaseImage(&(this->m_IplOutputImage));
}
this->m_IplOutputImage = cvCreateImage(cvSize(this->m_ImageWidth, this->m_ImageHeight), IPL_DEPTH_32F, 1);
CreateItkImage(this->m_ItkInputImage);
}
}
this->ProcessObject::SetNthInput(idx, distanceImage); // Process object is not const-correct so the const_cast is required here
}
this->CreateOutputsForAllInputs();
}
mitk::Image* mitk::ToFCompositeFilter::GetInput()
{
return this->GetInput(0);
}
mitk::Image* mitk::ToFCompositeFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < 1)
return NULL; //TODO: geeignete exception werfen
return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
}
void mitk::ToFCompositeFilter::GenerateData()
{
// copy input 1...n to output 1...n
for (unsigned int idx=0; idx<this->GetNumberOfOutputs(); idx++)
{
mitk::Image::Pointer outputImage = this->GetOutput(idx);
mitk::Image::Pointer inputImage = this->GetInput(idx);
if (outputImage.IsNotNull()&&inputImage.IsNotNull())
{
outputImage->CopyInformation(inputImage);
outputImage->Initialize(inputImage->GetPixelType(),inputImage->GetDimension(),inputImage->GetDimensions());
outputImage->SetSlice(inputImage->GetSliceData()->GetData());
}
}
- mitk::Image::Pointer outputDistanceImage = this->GetOutput(0);
+ mitk::Image::Pointer outputDistanceImage = this->GetOutput();
float* outputDistanceFloatData = (float*)outputDistanceImage->GetSliceData(0, 0, 0)->GetData();
mitk::Image::Pointer inputDistanceImage = this->GetInput();
// copy initial distance image to ipl image
float* distanceFloatData = (float*)inputDistanceImage->GetSliceData(0, 0, 0)->GetData();
memcpy(this->m_IplDistanceImage->imageData, (void*)distanceFloatData, this->m_ImageSize);
if (m_ApplyThresholdFilter||m_ApplyMaskSegmentation)
{
ProcessSegmentation(this->m_IplDistanceImage);
}
if (this->m_ApplyTemporalMedianFilter||this->m_ApplyAverageFilter)
{
ProcessStreamedQuickSelectMedianImageFilter(this->m_IplDistanceImage);
}
if (this->m_ApplyMedianFilter)
{
ProcessCVMedianFilter(this->m_IplDistanceImage, this->m_IplOutputImage);
memcpy( this->m_IplDistanceImage->imageData, this->m_IplOutputImage->imageData, this->m_ImageSize );
}
if (this->m_ApplyBilateralFilter)
{
float* itkFloatData = this->m_ItkInputImage->GetBufferPointer();
memcpy(itkFloatData, this->m_IplDistanceImage->imageData, this->m_ImageSize );
ItkImageType2D::Pointer itkOutputImage = ProcessItkBilateralFilter(this->m_ItkInputImage);
memcpy( this->m_IplDistanceImage->imageData, itkOutputImage->GetBufferPointer(), this->m_ImageSize );
//ProcessCVBilateralFilter(this->m_IplDistanceImage, this->m_OutputIplImage, domainSigma, rangeSigma, kernelRadius);
//memcpy( distanceFloatData, this->m_OutputIplImage->imageData, distanceImageSize );
}
memcpy( outputDistanceFloatData, this->m_IplDistanceImage->imageData, this->m_ImageSize );
}
void mitk::ToFCompositeFilter::CreateOutputsForAllInputs()
{
this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create outputs for all inputs
- for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
+ for (unsigned int idx = 0; idx < this->GetNumberOfIndexedInputs(); ++idx)
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
void mitk::ToFCompositeFilter::GenerateOutputInformation()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if (output->IsInitialized())
return;
itkDebugMacro(<<"GenerateOutputInformation()");
output->Initialize(input->GetPixelType(), *input->GetTimeSlicedGeometry());
output->SetPropertyList(input->GetPropertyList()->Clone());
}
void mitk::ToFCompositeFilter::ProcessSegmentation(IplImage* inputIplImage)
{
char* segmentationMask;
if (m_SegmentationMask.IsNotNull())
{
segmentationMask = (char*)m_SegmentationMask->GetSliceData(0, 0, 0)->GetData();
}
else
{
segmentationMask = NULL;
}
float *f = (float*)inputIplImage->imageData;
for(int i=0; i<this->m_ImageWidth*this->m_ImageHeight; i++)
{
if (this->m_ApplyThresholdFilter)
{
if (f[i]<=m_ThresholdFilterMin)
{
f[i] = 0.0;
}
else if (f[i]>=m_ThresholdFilterMax)
{
f[i] = 0.0;
}
}
if (this->m_ApplyMaskSegmentation)
{
if (segmentationMask)
{
if (segmentationMask[i]==0)
{
f[i] = 0.0;
}
}
}
}
}
ItkImageType2D::Pointer mitk::ToFCompositeFilter::ProcessItkBilateralFilter(ItkImageType2D::Pointer inputItkImage)
{
ItkImageType2D::Pointer outputItkImage;
BilateralFilterType::Pointer bilateralFilter = BilateralFilterType::New();
bilateralFilter->SetInput(inputItkImage);
bilateralFilter->SetDomainSigma(m_BilateralFilterDomainSigma);
bilateralFilter->SetRangeSigma(m_BilateralFilterRangeSigma);
//bilateralFilter->SetRadius(m_BilateralFilterKernelRadius);
outputItkImage = bilateralFilter->GetOutput();
outputItkImage->Update();
return outputItkImage;
}
void mitk::ToFCompositeFilter::ProcessCVBilateralFilter(IplImage* inputIplImage, IplImage* outputIplImage)
{
int diameter = m_BilateralFilterKernelRadius;
double sigmaColor = m_BilateralFilterRangeSigma;
double sigmaSpace = m_BilateralFilterDomainSigma;
cvSmooth(inputIplImage, outputIplImage, CV_BILATERAL, diameter, 0, sigmaColor, sigmaSpace);
}
void mitk::ToFCompositeFilter::ProcessCVMedianFilter(IplImage* inputIplImage, IplImage* outputIplImage, int radius)
{
cvSmooth(inputIplImage, outputIplImage, CV_MEDIAN, radius, 0, 0, 0);
}
void mitk::ToFCompositeFilter::ProcessStreamedQuickSelectMedianImageFilter(IplImage* inputIplImage)
{
float* data = (float*)inputIplImage->imageData;
int imageSize = inputIplImage->width * inputIplImage->height;
float* tmpArray;
if (this->m_TemporalMedianFilterNumOfFrames == 0)
{
return;
}
if (m_TemporalMedianFilterNumOfFrames != this->m_DataBufferMaxSize) // reset
{
//delete current buffer
for( int i=0; i<this->m_DataBufferMaxSize; i++ ) {
delete[] this->m_DataBuffer[i];
}
if (this->m_DataBuffer != NULL)
{
delete[] this->m_DataBuffer;
}
this->m_DataBufferMaxSize = m_TemporalMedianFilterNumOfFrames;
// create new buffer with current size
this->m_DataBuffer = new float*[this->m_DataBufferMaxSize];
for(int i=0; i<this->m_DataBufferMaxSize; i++)
{
this->m_DataBuffer[i] = NULL;
}
this->m_DataBufferCurrentIndex = 0;
}
int currentBufferSize = this->m_DataBufferMaxSize;
tmpArray = new float[this->m_DataBufferMaxSize];
// copy data to buffer
if (this->m_DataBuffer[this->m_DataBufferCurrentIndex] == NULL)
{
this->m_DataBuffer[this->m_DataBufferCurrentIndex] = new float[imageSize];
currentBufferSize = this->m_DataBufferCurrentIndex + 1;
}
for(int j=0; j<imageSize; j++)
{
this->m_DataBuffer[this->m_DataBufferCurrentIndex][j] = data[j];
}
float tmpValue = 0.0f;
for(int i=0; i<imageSize; i++)
{
if (m_ApplyAverageFilter)
{
tmpValue = 0.0f;
for(int j=0; j<currentBufferSize; j++)
{
tmpValue+=this->m_DataBuffer[j][i];
}
data[i] = tmpValue/currentBufferSize;
}
else if (m_ApplyTemporalMedianFilter)
{
for(int j=0; j<currentBufferSize; j++)
{
tmpArray[j] = this->m_DataBuffer[j][i];
}
data[i] = quick_select(tmpArray, currentBufferSize);
}
}
this->m_DataBufferCurrentIndex = (this->m_DataBufferCurrentIndex + 1) % this->m_DataBufferMaxSize;
delete[] tmpArray;
}
#define ELEM_SWAP(a,b) { register float t=(a);(a)=(b);(b)=t; }
float mitk::ToFCompositeFilter::quick_select(float arr[], int n)
{
int low = 0;
int high = n-1;
int median = (low + high)/2;
int middle = 0;
int ll = 0;
int hh = 0;
for (;;) {
if (high <= low) /* One element only */
return arr[median] ;
if (high == low + 1) { /* Two elements only */
if (arr[low] > arr[high])
ELEM_SWAP(arr[low], arr[high]) ;
return arr[median] ;
}
/* Find median of low, middle and high items; swap into position low */
middle = (low + high) / 2;
if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ;
if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ;
if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ;
/* Swap low item (now in position middle) into position (low+1) */
ELEM_SWAP(arr[middle], arr[low+1]) ;
/* Nibble from each end towards middle, swapping items when stuck */
ll = low + 1;
hh = high;
for (;;) {
do ll++; while (arr[low] > arr[ll]) ;
do hh--; while (arr[hh] > arr[low]) ;
if (hh < ll)
break;
ELEM_SWAP(arr[ll], arr[hh]) ;
}
/* Swap middle item (in position low) back into correct position */
ELEM_SWAP(arr[low], arr[hh]) ;
/* Re-set active partition */
if (hh <= median)
low = ll;
if (hh >= median)
high = hh - 1;
}
}
#undef ELEM_SWAP
void mitk::ToFCompositeFilter::SetTemporalMedianFilterParameter(int tmporalMedianFilterNumOfFrames)
{
this->m_TemporalMedianFilterNumOfFrames = tmporalMedianFilterNumOfFrames;
}
void mitk::ToFCompositeFilter::SetThresholdFilterParameter(int min, int max)
{
if (min > max)
{
min = max;
}
this->m_ThresholdFilterMin = min;
this->m_ThresholdFilterMax = max;
}
void mitk::ToFCompositeFilter::SetBilateralFilterParameter(double domainSigma, double rangeSigma, int kernelRadius = 0)
{
this->m_BilateralFilterDomainSigma = domainSigma;
this->m_BilateralFilterRangeSigma = rangeSigma;
this->m_BilateralFilterKernelRadius = kernelRadius;
}
void mitk::ToFCompositeFilter::CreateItkImage(ItkImageType2D::Pointer &itkInputImage)
{
itkInputImage = ItkImageType2D::New();
ItkImageType2D::IndexType startIndex;
startIndex[0] = 0; // first index on X
startIndex[1] = 0; // first index on Y
ItkImageType2D::SizeType size;
size[0] = this->m_ImageWidth; // size along X
size[1] = this->m_ImageHeight; // size along Y
ItkImageType2D::RegionType region;
region.SetSize( size );
region.SetIndex( startIndex );
itkInputImage->SetRegions( region );
itkInputImage->Allocate();
}
diff --git a/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp b/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
index ea7141db72..390486ccbe 100644
--- a/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
@@ -1,206 +1,206 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFDistanceImageToPointSetFilter.h"
#include "mitkImageDataItem.h"
#include "mitkPointSet.h"
#include "mitkToFProcessingCommon.h"
mitk::ToFDistanceImageToPointSetFilter::ToFDistanceImageToPointSetFilter()
: m_Subset(NULL), m_CameraIntrinsics(), m_InterPixelDistance()
{
m_InterPixelDistance.Fill(0.045);
m_CameraIntrinsics = mitk::CameraIntrinsics::New();
m_CameraIntrinsics->SetFocalLength(5.9421434211923247e+02,5.9104053696870778e+02);
m_CameraIntrinsics->SetPrincipalPoint(3.3930780975300314e+02,2.4273913761751615e+02);
m_CameraIntrinsics->SetDistorsionCoeffs(-0.36874385358645773f,-0.14339503290129013,0.0033210108720361795,-0.004277703352074105);
m_ReconstructionMode = true;
}
mitk::ToFDistanceImageToPointSetFilter::~ToFDistanceImageToPointSetFilter()
{
}
void mitk::ToFDistanceImageToPointSetFilter::SetInput(const mitk::Image* distanceImage )
{
this->SetInput(0,distanceImage);
}
void mitk::ToFDistanceImageToPointSetFilter::SetInput( unsigned int idx,const mitk::Image* distanceImage )
{
if ((distanceImage == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one
{
this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
}
else
{
this->ProcessObject::SetNthInput(idx, const_cast<mitk::Image*>(distanceImage)); // Process object is not const-correct so the const_cast is required here
this->CreateOutputsForAllInputs();
}
}
mitk::Image* mitk::ToFDistanceImageToPointSetFilter::GetInput()
{
return this->GetInput(0);
}
mitk::Image* mitk::ToFDistanceImageToPointSetFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
}
void mitk::ToFDistanceImageToPointSetFilter::SetSubset(std::vector<mitk::Index3D> subset)
{
// check if points of PointSet are inside the input image
mitk::Image::Pointer input = this->GetInput();
unsigned int xDim = input->GetDimension(0);
unsigned int yDim = input->GetDimension(1);
bool pointSetValid = true;
for (unsigned int i=0; i<subset.size(); i++)
{
mitk::Index3D currentIndex = subset.at(i);
if (currentIndex[0]<0||currentIndex[0]>xDim||currentIndex[1]<0||currentIndex[1]>yDim)
{
pointSetValid = false;
}
}
if (pointSetValid)
{
m_Subset = subset;
}
else
{
MITK_ERROR<<"One or more indizes are located outside the image domain";
}
}
void mitk::ToFDistanceImageToPointSetFilter::SetSubset( mitk::PointSet::Pointer pointSet)
{
std::vector<mitk::Index3D> subset;
for (int i=0; i<pointSet->GetSize(); i++)
{
mitk::Point3D currentPoint = pointSet->GetPoint(i);
mitk::Index3D currentIndex;
currentIndex[0] = currentPoint[0];
currentIndex[1] = currentPoint[1];
currentIndex[2] = currentPoint[2];
subset.push_back(currentIndex);
}
this->SetSubset(subset);
}
void mitk::ToFDistanceImageToPointSetFilter::GenerateData()
{
//calculate world coordinates
mitk::ToFProcessingCommon::ToFPoint2D focalLengthInPixelUnits;
mitk::ToFProcessingCommon::ToFScalarType focalLengthInMm;
if (m_ReconstructionMode)
{
focalLengthInPixelUnits[0] = m_CameraIntrinsics->GetFocalLengthX();
focalLengthInPixelUnits[1] = m_CameraIntrinsics->GetFocalLengthY();
}
else
focalLengthInMm = (m_CameraIntrinsics->GetFocalLengthX()*m_InterPixelDistance[0]+m_CameraIntrinsics->GetFocalLengthY()*m_InterPixelDistance[1])/2.0;
mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
principalPoint[0] = m_CameraIntrinsics->GetPrincipalPointX();
principalPoint[1] = m_CameraIntrinsics->GetPrincipalPointY();
mitk::PointSet::Pointer output = this->GetOutput();
assert(output);
mitk::Image::Pointer input = this->GetInput();
assert(input);
//compute subset of points if input PointSet is defined
if (m_Subset.size()!=0)
{
for (unsigned int i=0; i<m_Subset.size(); i++)
{
mitk::Index3D currentIndex = m_Subset.at(i);;
mitk::ToFProcessingCommon::ToFScalarType distance = (double)input->GetPixelValueByIndex(currentIndex);
mitk::Point3D currentPoint;
if (m_ReconstructionMode)
currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(currentIndex,distance,focalLengthInPixelUnits,principalPoint);
else
currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(currentIndex,distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
output->InsertPoint(i,currentPoint);
}
}
else //compute PointSet holding cartesian coordinates for every image point
{
int xDimension = (int)input->GetDimension(0);
int yDimension = (int)input->GetDimension(1);
int pointCount = 0;
for (int j=0; j<yDimension; j++)
{
for (int i=0; i<xDimension; i++)
{
mitk::Index3D pixel;
pixel[0] = i;
pixel[1] = j;
pixel[2] = 0;
mitk::ToFProcessingCommon::ToFScalarType distance = (double)input->GetPixelValueByIndex(pixel);
mitk::Point3D currentPoint;
if (m_ReconstructionMode)
currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthInPixelUnits,principalPoint);
else
currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
if (distance>mitk::eps)
{
output->InsertPoint( pointCount, currentPoint );
pointCount++;
}
}
}
}
}
void mitk::ToFDistanceImageToPointSetFilter::CreateOutputsForAllInputs()
{
this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create outputs for all inputs
- for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
+ for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
void mitk::ToFDistanceImageToPointSetFilter::GenerateOutputInformation()
{
this->GetOutput();
itkDebugMacro(<<"GenerateOutputInformation()");
}
void mitk::ToFDistanceImageToPointSetFilter::SetReconstructionMode(bool withoutInterpixdist)
{
this->m_ReconstructionMode = withoutInterpixdist;
}
bool mitk::ToFDistanceImageToPointSetFilter::GetReconstructionMode()
{
return (this->m_ReconstructionMode);
}
diff --git a/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp b/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp
index 2b24b19331..8ed0845682 100644
--- a/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp
@@ -1,301 +1,302 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkToFDistanceImageToSurfaceFilter.h>
#include <mitkInstantiateAccessFunctions.h>
#include <mitkSurface.h>
#include <itkImage.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <vtkFloatArray.h>
#include <vtkSmartPointer.h>
#include <vtkIdList.h>
#include <math.h>
mitk::ToFDistanceImageToSurfaceFilter::ToFDistanceImageToSurfaceFilter() :
m_IplScalarImage(NULL), m_CameraIntrinsics(), m_TextureImageWidth(0), m_TextureImageHeight(0), m_InterPixelDistance(), m_TextureIndex(0)
{
m_InterPixelDistance.Fill(0.045);
m_CameraIntrinsics = mitk::CameraIntrinsics::New();
m_CameraIntrinsics->SetFocalLength(295.78960196187319,296.1255427948447);
m_CameraIntrinsics->SetFocalLength(5.9421434211923247e+02,5.9104053696870778e+02);
m_CameraIntrinsics->SetPrincipalPoint(3.3930780975300314e+02,2.4273913761751615e+02);
m_CameraIntrinsics->SetDistorsionCoeffs(-0.36874385358645773f,-0.14339503290129013,0.0033210108720361795,-0.004277703352074105);
m_ReconstructionMode = WithInterPixelDistance;
}
mitk::ToFDistanceImageToSurfaceFilter::~ToFDistanceImageToSurfaceFilter()
{
}
void mitk::ToFDistanceImageToSurfaceFilter::SetInput( Image* distanceImage, mitk::CameraIntrinsics::Pointer cameraIntrinsics )
{
this->SetCameraIntrinsics(cameraIntrinsics);
this->SetInput(0,distanceImage);
}
void mitk::ToFDistanceImageToSurfaceFilter::SetInput( unsigned int idx, Image* distanceImage, mitk::CameraIntrinsics::Pointer cameraIntrinsics )
{
this->SetCameraIntrinsics(cameraIntrinsics);
this->SetInput(idx,distanceImage);
}
void mitk::ToFDistanceImageToSurfaceFilter::SetInput( mitk::Image* distanceImage )
{
this->SetInput(0,distanceImage);
}
void mitk::ToFDistanceImageToSurfaceFilter::SetInput( unsigned int idx, mitk::Image* distanceImage )
{
if ((distanceImage == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one
this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
else
this->ProcessObject::SetNthInput(idx, distanceImage); // Process object is not const-correct so the const_cast is required here
this->CreateOutputsForAllInputs();
}
mitk::Image* mitk::ToFDistanceImageToSurfaceFilter::GetInput()
{
return this->GetInput(0);
}
mitk::Image* mitk::ToFDistanceImageToSurfaceFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < 1)
{
mitkThrow() << "No input given for ToFDistanceImageToSurfaceFilter";
}
return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
}
void mitk::ToFDistanceImageToSurfaceFilter::GenerateData()
{
mitk::Surface::Pointer output = this->GetOutput();
assert(output);
mitk::Image::Pointer input = this->GetInput();
assert(input);
// mesh points
int xDimension = input->GetDimension(0);
int yDimension = input->GetDimension(1);
unsigned int size = xDimension*yDimension; //size of the image-array
std::vector<bool> isPointValid;
isPointValid.resize(size);
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
points->SetDataTypeToDouble();
vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkFloatArray> scalarArray = vtkSmartPointer<vtkFloatArray>::New();
vtkSmartPointer<vtkFloatArray> textureCoords = vtkSmartPointer<vtkFloatArray>::New();
textureCoords->SetNumberOfComponents(2);
textureCoords->Allocate(size);
//Make a vtkIdList to save the ID's of the polyData corresponding to the image
//pixel ID's. See below for more documentation.
m_VertexIdList = vtkSmartPointer<vtkIdList>::New();
//Allocate the object once else it would automatically allocate new memory
//for every vertex and perform a copy which is expensive.
m_VertexIdList->Allocate(size);
m_VertexIdList->SetNumberOfIds(size);
for(int i = 0; i < size; ++i)
{
m_VertexIdList->SetId(i, 0);
}
float* scalarFloatData = NULL;
if (this->m_IplScalarImage) // if scalar image is defined use it for texturing
{
scalarFloatData = (float*)this->m_IplScalarImage->imageData;
}
else if (this->GetInput(m_TextureIndex)) // otherwise use intensity image (input(2))
{
scalarFloatData = (float*)this->GetInput(m_TextureIndex)->GetData();
}
float* inputFloatData = (float*)(input->GetSliceData(0, 0, 0)->GetData());
//calculate world coordinates
mitk::ToFProcessingCommon::ToFPoint2D focalLengthInPixelUnits;
mitk::ToFProcessingCommon::ToFScalarType focalLengthInMm;
if((m_ReconstructionMode == WithOutInterPixelDistance) || (m_ReconstructionMode == Kinect))
{
focalLengthInPixelUnits[0] = m_CameraIntrinsics->GetFocalLengthX();
focalLengthInPixelUnits[1] = m_CameraIntrinsics->GetFocalLengthY();
}
else if( m_ReconstructionMode == WithInterPixelDistance)
{
//convert focallength from pixel to mm
focalLengthInMm = (m_CameraIntrinsics->GetFocalLengthX()*m_InterPixelDistance[0]+m_CameraIntrinsics->GetFocalLengthY()*m_InterPixelDistance[1])/2.0;
}
mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
principalPoint[0] = m_CameraIntrinsics->GetPrincipalPointX();
principalPoint[1] = m_CameraIntrinsics->GetPrincipalPointY();
mitk::Point3D origin = input->GetGeometry()->GetOrigin();
for (int j=0; j<yDimension; j++)
{
for (int i=0; i<xDimension; i++)
{
unsigned int pixelID = i+j*xDimension;
mitk::ToFProcessingCommon::ToFScalarType distance = (double)inputFloatData[pixelID];
mitk::ToFProcessingCommon::ToFPoint3D cartesianCoordinates;
switch (m_ReconstructionMode)
{
case WithOutInterPixelDistance:
{
cartesianCoordinates = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i+origin[0],j+origin[1],distance,focalLengthInPixelUnits,principalPoint);
break;
}
case WithInterPixelDistance:
{
cartesianCoordinates = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i+origin[0],j+origin[1],distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
break;
}
case Kinect:
{
cartesianCoordinates = mitk::ToFProcessingCommon::KinectIndexToCartesianCoordinates(i+origin[0],j+origin[1],distance,focalLengthInPixelUnits,principalPoint);
break;
}
default:
{
MITK_ERROR << "Incorrect reconstruction mode!";
}
}
//Epsilon here, because we may have small float values like 0.00000001 which in fact represents 0.
if (distance<=mitk::eps)
{
isPointValid[pixelID] = false;
}
else
{
isPointValid[pixelID] = true;
//VTK would insert empty points into the polydata if we use
//points->InsertPoint(pixelID, cartesianCoordinates.GetDataPointer()).
//If we use points->InsertNextPoint(...) instead, the ID's do not
//correspond to the image pixel ID's. Thus, we have to save them
//in the vertexIdList.
m_VertexIdList->SetId(pixelID, points->InsertNextPoint(cartesianCoordinates.GetDataPointer()));
if((i >= 1) && (j >= 1))
{
//This little piece of art explains the ID's:
//
// P(x_1y_1)---P(xy_1)
// | |
// | |
// | |
// P(x_1y)-----P(xy)
//
//We can only start triangulation if we are at vertex (1,1),
//because we need the other 3 vertices near this one.
//To go one pixel line back in the image array, we have to
//subtract 1x xDimension.
vtkIdType xy = pixelID;
vtkIdType x_1y = pixelID-1;
vtkIdType xy_1 = pixelID-xDimension;
vtkIdType x_1y_1 = xy_1-1;
//Find the corresponding vertex ID's in the saved vertexIdList:
vtkIdType xyV = m_VertexIdList->GetId(xy);
vtkIdType x_1yV = m_VertexIdList->GetId(x_1y);
vtkIdType xy_1V = m_VertexIdList->GetId(xy_1);
vtkIdType x_1y_1V = m_VertexIdList->GetId(x_1y_1);
if (isPointValid[xy]&&isPointValid[x_1y]&&isPointValid[x_1y_1]&&isPointValid[xy_1]) // check if points of cell are valid
{
polys->InsertNextCell(3);
polys->InsertCellPoint(x_1yV);
polys->InsertCellPoint(xyV);
polys->InsertCellPoint(x_1y_1V);
polys->InsertNextCell(3);
polys->InsertCellPoint(x_1y_1V);
polys->InsertCellPoint(xyV);
polys->InsertCellPoint(xy_1V);
}
}
//Scalar values are necessary for mapping colors/texture onto the surface
if (scalarFloatData)
{
scalarArray->InsertTuple1(m_VertexIdList->GetId(pixelID), scalarFloatData[pixelID]);
}
//These Texture Coordinates will map color pixel and vertices 1:1 (e.g. for Kinect).
float xNorm = (((float)i)/xDimension);// correct video texture scale for kinect
float yNorm = ((float)j)/yDimension; //don't flip. we don't need to flip.
textureCoords->InsertTuple2(m_VertexIdList->GetId(pixelID), xNorm, yNorm);
}
}
}
vtkSmartPointer<vtkPolyData> mesh = vtkSmartPointer<vtkPolyData>::New();
mesh->SetPoints(points);
mesh->SetPolys(polys);
//Pass the scalars to the polydata (if they were set).
if (scalarArray->GetNumberOfTuples()>0)
{
mesh->GetPointData()->SetScalars(scalarArray);
}
//Pass the TextureCoords to the polydata anyway (to save them).
mesh->GetPointData()->SetTCoords(textureCoords);
output->SetVtkPolyData(mesh);
}
void mitk::ToFDistanceImageToSurfaceFilter::CreateOutputsForAllInputs()
{
this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create outputs for all inputs
for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
void mitk::ToFDistanceImageToSurfaceFilter::GenerateOutputInformation()
{
this->GetOutput();
itkDebugMacro(<<"GenerateOutputInformation()");
+
}
void mitk::ToFDistanceImageToSurfaceFilter::SetScalarImage(IplImage* iplScalarImage)
{
this->m_IplScalarImage = iplScalarImage;
this->Modified();
}
IplImage* mitk::ToFDistanceImageToSurfaceFilter::GetScalarImage()
{
return this->m_IplScalarImage;
}
void mitk::ToFDistanceImageToSurfaceFilter::SetTextureImageWidth(int width)
{
this->m_TextureImageWidth = width;
}
void mitk::ToFDistanceImageToSurfaceFilter::SetTextureImageHeight(int height)
{
this->m_TextureImageHeight = height;
}
diff --git a/Modules/ToFProcessing/mitkToFSurfaceVtkMapper3D.h b/Modules/ToFProcessing/mitkToFSurfaceVtkMapper3D.h
index 960833158f..5d4f12b1e5 100644
--- a/Modules/ToFProcessing/mitkToFSurfaceVtkMapper3D.h
+++ b/Modules/ToFProcessing/mitkToFSurfaceVtkMapper3D.h
@@ -1,186 +1,186 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKTOFSURFACEDATAVTKMAPPER3D_H_HEADER_INCLUDED_C1907273
#define MITKTOFSURFACEDATAVTKMAPPER3D_H_HEADER_INCLUDED_C1907273
#include "mitkCommon.h"
#include "mitkVtkMapper.h"
#include "mitkSurface.h"
#include "mitkBaseRenderer.h"
#include <vtkActor.h>
#include <vtkOpenGLPolyDataMapper.h>
#include <vtkPainterPolyDataMapper.h>
#include <vtkPolyDataMapper.h>
#include <vtkPolyDataNormals.h>
#include <vtkPlaneCollection.h>
#include <vtkScalarsToColors.h>
#include <vtkSmartPointer.h>
#include "mitkToFProcessingExports.h"
namespace mitk {
//##Documentation
//## @brief Vtk-based mapper for Surface
//##
//## @ingroup Mapper
/**
* @brief Vtk-based mapper for Surface
*
* Properties that can be set for surfaces and influence the surfaceVTKMapper3D are:
*
* - \b "color": (ColorProperty) Diffuse color of the surface object (this property will be read when material.diffuseColor is not defined)
* - \b "Opacity": (FloatProperty) Opacity of the surface object
* - \b "material.ambientColor": (ColorProperty) Ambient color of the surface object
* - \b "material.ambientCoefficient": ( FloatProperty) Ambient coefficient of the surface object
* - \b "material.diffuseColor": ( ColorProperty) Diffuse color of the surface object
* - \b "material.diffuseCoefficient": (FloatProperty) Diffuse coefficient of the surface object
* - \b "material.specularColor": (ColorProperty) Specular Color of the surface object
* - \b "material.specularCoefficient": (FloatProperty) Specular coefficient of the surface object
* - \b "material.specularPower": (FloatProperty) Specular power of the surface object
* - \b "material.interpolation": (VtkInterpolationProperty) Interpolation
* - \b "material.representation": (VtkRepresentationProperty*) Representation
* - \b "material.wireframeLineWidth": (FloatProperty) Width in pixels of the lines drawn.
* - \b "scalar visibility": (BoolProperty) If the scarlars of the surface are visible
* Properties to look for are:
*
* - \b "scalar visibility": if set to on, scalars assigned to the data are shown
* Turn this on if using a lookup table.
* - \b "ScalarsRangeMinimum": Optional. Can be used to store the scalar min, e.g.
* for the level window settings.
* - \b "ScalarsRangeMaximum": Optional. See above.
*
* There might be still some other, deprecated properties. These will not be documented anymore.
* Please check the source if you really need them.
*
* @ingroup Mapper
*/
class mitkToFProcessing_EXPORT ToFSurfaceVtkMapper3D : public VtkMapper
{
public:
mitkClassMacro(ToFSurfaceVtkMapper3D, VtkMapper);
itkNewMacro(Self);
itkSetMacro(GenerateNormals, bool);
itkGetMacro(GenerateNormals, bool);
//enable ImmediateModeRendering for vtkMapping
//yet to solve bug 1398
void SetImmediateModeRenderingOn(int on = 1);
itkGetMacro(ImmediateModeRenderingOn, int);
//virtual const mitk::ToFSurface* GetInput();
virtual const mitk::Surface* GetInput();
virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer);
virtual void ApplyProperties(vtkActor* actor, mitk::BaseRenderer* renderer);
static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
void SetTexture(vtkImageData *img);
vtkSmartPointer<vtkTexture> GetTexture();
itkSetMacro(TextureWidth, int);
itkSetMacro(TextureHeight, int);
void SetVtkScalarsToColors(vtkScalarsToColors* vtkScalarsToColors);
vtkScalarsToColors* GetVtkScalarsToColors();
protected:
ToFSurfaceVtkMapper3D();
virtual ~ToFSurfaceVtkMapper3D();
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
virtual void ResetMapper( mitk::BaseRenderer* renderer );
/** Checks whether the specified property is a ClippingProperty and if yes,
* adds it to m_ClippingPlaneCollection (internal method). */
virtual void CheckForClippingProperty( mitk::BaseRenderer* renderer, mitk::BaseProperty *property );
bool m_GenerateNormals;
//enable ImmediateModeRendering for the vtkMapper
int m_ImmediateModeRenderingOn;
vtkSmartPointer<vtkTexture> m_Texture; // pointer to the texture/video image
int m_TextureWidth; // width of the texture/video image
int m_TextureHeight; // height of the texture/video image
vtkScalarsToColors* m_VtkScalarsToColors; // vtk color transfer funtion
public:
class LocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
vtkActor* m_Actor;
vtkPolyDataMapper *m_VtkPolyDataMapper;
vtkPolyDataNormals *m_VtkPolyDataNormals;
vtkPlaneCollection *m_ClippingPlaneCollection;
itk::TimeStamp m_ShaderTimestampUpdate;
LocalStorage()
{
m_VtkPolyDataMapper = vtkOpenGLPolyDataMapper::New();
m_VtkPolyDataNormals = vtkPolyDataNormals::New();
m_Actor = vtkActor::New();
m_ClippingPlaneCollection = vtkPlaneCollection::New();
m_Actor->SetMapper(m_VtkPolyDataMapper);
}
~LocalStorage()
{
m_VtkPolyDataMapper->Delete();
m_VtkPolyDataNormals->Delete();
m_Actor->Delete();
m_ClippingPlaneCollection->Delete();
}
};
- mitk::Mapper::LocalStorageHandler<LocalStorage> m_LSH;
+ mitk::LocalStorageHandler<LocalStorage> m_LSH;
static void ApplyMitkPropertiesToVtkProperty(mitk::DataNode *node, vtkProperty* property, mitk::BaseRenderer* renderer);
static void SetDefaultPropertiesForVtkProperty(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite);
};
} // namespace mitk
#endif /* MITKTOFSURFACEDATAVTKMAPPER3D_H_HEADER_INCLUDED_C1907273 */
diff --git a/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
index a11cd28691..5462735d7d 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
@@ -1,382 +1,375 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//#define _USE_MATH_DEFINES
#include <QmitkToFConnectionWidget.h>
//QT headers
#include <qmessagebox.h>
#include <qfiledialog.h>
#include <qcombobox.h>
//mitk headers
#include "mitkToFConfig.h"
#include "mitkCameraIntrinsics.h"
#include "mitkCameraIntrinsicsProperty.h"
//itk headers
#include <itksys/SystemTools.hxx>
//Setting the View_ID
const std::string QmitkToFConnectionWidget::VIEW_ID = "org.mitk.views.qmitktofconnectionwidget2";
//Constructor of QmitkToFConnectionWidget
QmitkToFConnectionWidget::QmitkToFConnectionWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
{
this->m_IntegrationTime = 0;
this->m_ModulationFrequency = 0;
this->m_ToFImageGrabber = mitk::ToFImageGrabber::New();
//Setting m_Controls= NULL on Startup-> CreateQtPartControl will generate the Gui Widget if !m_Controls
m_Controls = NULL;
//Calling CreateQtPartControl
CreateQtPartControl(this);
}
//Destructor of QmitkToFConnectionWidget
QmitkToFConnectionWidget::~QmitkToFConnectionWidget()
{
- //Keno´s MitkServiceListWidget must not be deinizialized here. Qmitk methods destroy their children automatically before self-destruction
+ //MitkServiceListWidget must not be deinizialized here. Qmitk methods destroy their children automatically before self-destruction
}
void QmitkToFConnectionWidget::CreateQtPartControl(QWidget *parent) //Definition of CreateQtPartControll-Methode in QmitkToFConnectionWidget; Input= Pointer
{
if (!m_Controls) //Define if not alreaddy exists
{
// create GUI widgets
m_Controls = new Ui::QmitkToFConnectionWidgetControls2;
m_Controls->setupUi(parent);
//and hide them on startup
this->HideAllParameterWidgets();
// initzializing MitkServiceListWidget here
std::string empty= "";
m_Controls->m_DeviceList->Initialize<mitk::ToFCameraDevice>("ToFDeviceName", empty);// the empty could just be any kind of filter
this->CreateConnections();
- //OnSelectCamera(); //todo: warum geht das hier nicht? -> Sasch fragen
}
}
//Creating the SIGNAL-SLOT-Connectuions
void QmitkToFConnectionWidget::CreateConnections()
{
if ( m_Controls )
{
//ConnectCameraButton as a trigger for OnConnectCamera()
connect( (QObject*)(m_Controls->m_ConnectCameraButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnConnectCamera()) );
//QmitkServiceListWidget::ServiceSelectionChanged as a Signal for the OnSlectCamera() slot
connect( m_Controls->m_DeviceList, SIGNAL(ServiceSelectionChanged(mitk::ServiceReference)), this, SLOT(OnSelectCamera()));
/*Creating an other Datanode structur for Kinect is done here: As soon as a Kinect is connected, the KinectParameterWidget is enabled,
which can be used to trigger the KinectAcqusitionModeChanged-Method, to create a working Data-Node-structure*/
connect( m_Controls->m_KinectParameterWidget, SIGNAL(AcquisitionModeChanged()), this, SIGNAL(KinectAcquisitionModeChanged()) );
}
}
mitk::ToFImageGrabber::Pointer QmitkToFConnectionWidget::GetToFImageGrabber()
{
return m_ToFImageGrabber;
}
//The OnSelectCamer-Method is in charge of activating the appropiate ParameterWidgets
void QmitkToFConnectionWidget::OnSelectCamera()
{
//Here we are getting our decvie through the QmitkServiceListWidget-Instance m_DeviceList through the GetSelectedService-Method
mitk::ToFCameraDevice* device = m_Controls->m_DeviceList->GetSelectedService<mitk::ToFCameraDevice>();
//getting the selectedCamera through a static Method used to transform the device->GetNameOfClass
QString selectedCamera = QString::fromStdString(device->GetNameOfClass());
this->HideAllParameterWidgets();
//reactivating the Widgets on slecting a device
if (selectedCamera.contains("PMD")) //Check if selectedCamera string contains ".." for each device
{
this->m_Controls->m_PMDParameterWidget->show(); //and activate the correct widget
}
else if (selectedCamera.contains("MESA"))
{
this->m_Controls->m_MESAParameterWidget->show();
}
else if (selectedCamera.contains("Kinect"))
{
this->m_Controls->m_KinectParameterWidget->show();
}
+ m_Controls->m_ConnectCameraButton->setEnabled(true); //ConnectCameraButton gets enabled
emit (selectedCamera);
}
//This Methods hides all Widgets (later each widget is activated on its own)
void QmitkToFConnectionWidget::HideAllParameterWidgets()
{
this->m_Controls->m_PMDParameterWidget->hide();
this->m_Controls->m_MESAParameterWidget->hide();
this->m_Controls->m_KinectParameterWidget->hide();
}
//OnConnectCamera-Method; represents one of the main parts of ToFConnectionWidget2.
void QmitkToFConnectionWidget::OnConnectCamera()
{
- //Introducing the boolean variable playerMode and set it to false by default
- bool playerMode = false;
-
//After connecting a device
if (m_Controls->m_ConnectCameraButton->text()=="Connect")
{
-
- //Reset the status of some GUI-Elements
- m_Controls->m_ConnectCameraButton->setEnabled(false); //ConnectCameraButton gets disabled, what leads to other changes later
- m_Controls->m_DeviceList->setEnabled(false); //Deactivating the Instance of QmitkServiceListWidget
- //repaint the widget
- this->repaint();
-
- QString tmpFileName("");
- QString fileFilter("");
-
//Getting the device- and the slectedCamera-variables using the ServiceListWidget as we did it in the CameraSelect-Method
mitk::ToFCameraDevice* device = m_Controls->m_DeviceList->GetSelectedService<mitk::ToFCameraDevice>();
- QString selectedCamera = QString::fromStdString(device->GetNameOfClass());
-
- emit ToFCameraSelected(selectedCamera);
-
- //Creating a new instance of m_ToFImageGrabber
- this->m_ToFImageGrabber = NULL;
- this->m_ToFImageGrabber = mitk::ToFImageGrabber::New();
-
- //Feeding it with the Info from ServiceListWidget
- this->m_ToFImageGrabber->SetCameraDevice(device);
-
- // Calling Alex FixForKinect, if the Kinect is selected
- if (selectedCamera.contains("Kinect") )
+ if (device)
{
- MITK_INFO<< "Kinect is connected here";
- //If the particular property is selected, the suitable data-node will be generated
- this->m_ToFImageGrabber->SetBoolProperty("RGB", m_Controls->m_KinectParameterWidget->IsAcquisitionModeRGB());//--------------------------------------------------------
- this->m_ToFImageGrabber->SetBoolProperty("IR", m_Controls->m_KinectParameterWidget->IsAcquisitionModeIR());
- }
+ QString tmpFileName("");
+ QString fileFilter("");
+ QString selectedCamera = QString::fromStdString(device->GetNameOfClass());
-//Activation of "PlayerMode". If the selectedCamera String contains "Player", we start the Player Mode
- if (selectedCamera.contains("Player"))
- {
- playerMode = true;
- //IF PMD-Player selected
- if (selectedCamera.contains("PMD"))
- {
- fileFilter.append("PMD Files (*.pmd)"); //And seting the corresponding fileFilter
- }
- else
- {
- fileFilter.append("NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic)");
- }
- }
+ emit ToFCameraSelected(selectedCamera);
- // if a player was selected, the playerMode-variable is true, and we will enter the following code
- if (playerMode)
- {
- //open a QFileDialog to chose the corresponding file from the disc
- tmpFileName = QFileDialog::getOpenFileName(NULL, "Play Image From...", "", fileFilter);
+ //Feeding it with the Info from ServiceListWidget
+ this->m_ToFImageGrabber->SetCameraDevice(device);
- //If no fileName is returned by the Dialog,Button and Widget have to return to default(disconnected) + Opening a MessageBox
- if (tmpFileName.isEmpty())
+ // Calling Alex FixForKinect, if the Kinect is selected
+ if (selectedCamera.contains("Kinect") )
{
- m_Controls->m_ConnectCameraButton->setChecked(false);
- m_Controls->m_ConnectCameraButton->setEnabled(true); //re-enabling the ConnectCameraButton
- m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
-
- this->OnSelectCamera(); //Calling the OnSelctCamera-Method -> Hides all Widget and just activates the needed ones
- QMessageBox::information( this, "Template functionality", "Please select a valid image before starting some action.");
- return;
+ MITK_INFO<< "Kinect is connected here";
+ //If the particular property is selected, the suitable data-node will be generated
+ this->m_ToFImageGrabber->SetBoolProperty("RGB", m_Controls->m_KinectParameterWidget->IsAcquisitionModeRGB());//--------------------------------------------------------
+ this->m_ToFImageGrabber->SetBoolProperty("IR", m_Controls->m_KinectParameterWidget->IsAcquisitionModeIR());
}
- if(selectedCamera.contains("PMDPlayer")) //If PMD-Player is selected, set ToFImageGrabberProperty correspondingly
- {
- this->m_ToFImageGrabber->SetStringProperty("PMDFileName", tmpFileName.toStdString().c_str() );
- }
- else //Default action
+ //Activation of "PlayerMode". If the selectedCamera String contains "Player", we start the Player Mode
+ if (selectedCamera.contains("Player"))
{
- std::string msg = "";
- try
+ //IF PMD-Player selected
+ if (selectedCamera.contains("PMD"))
{
- //get 3 corresponding file names
- std::string dir = itksys::SystemTools::GetFilenamePath( tmpFileName.toStdString() );
- std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( tmpFileName.toStdString() );
- std::string extension = itksys::SystemTools::GetFilenameLastExtension( tmpFileName.toStdString() );
-
- //"Incorrect format"-warning while using .nrrd or .pic files
- if (extension != ".pic" && extension != ".nrrd")
- {
- msg = msg + "Invalid file format, please select a \".nrrd\"-file";
- throw std::logic_error(msg.c_str());
- }
-
- //Checking for npos. If available, check for the Amplitude-, Intensity- and RGBImage
+ fileFilter.append("PMD Files (*.pmd)"); //And seting the corresponding fileFilter
+ }
+ else
+ {
+ fileFilter.append("NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic)");
+ }
- int found = baseFilename.rfind("_DistanceImage"); //Defining "found" variable+checking if baseFilname contains "_DistanceImage". If not, found == npos(0)
+ //open a QFileDialog to chose the corresponding file from the disc
+ tmpFileName = QFileDialog::getOpenFileName(NULL, "Play Image From...", "", fileFilter);
- if (found == std::string::npos) //If found =0
- {
- found = baseFilename.rfind("_AmplitudeImage"); //If "_AmplitudeImage" is found, the found variable is 1-> the next if statment is false
- }
+ //If no fileName is returned by the Dialog,Button and Widget have to return to default(disconnected) + Opening a MessageBox
+ if (tmpFileName.isEmpty())
+ {
+ m_Controls->m_ConnectCameraButton->setChecked(false);
+ m_Controls->m_ConnectCameraButton->setEnabled(true); //re-enabling the ConnectCameraButton
+ m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
- if (found == std::string::npos)
- {
- found = baseFilename.rfind("_IntensityImage"); //found = true if baseFilename cotains "_IntesityImage"
- }
+ this->OnSelectCamera(); //Calling the OnSelctCamera-Method -> Hides all Widget and just activates the needed ones
+ QMessageBox::information( this, "Template functionality", "Please select a valid image before starting some action.");
+ return;
+ }
- if (found == std::string::npos)
+ if(selectedCamera.contains("PMDPlayer")) //If PMD-Player is selected, set ToFImageGrabberProperty correspondingly
+ {
+ this->m_ToFImageGrabber->SetStringProperty("PMDFileName", tmpFileName.toStdString().c_str() );
+ }
+ else //Default action
+ {
+ std::string msg = "";
+ try
{
- found = baseFilename.rfind("_RGBImage");
+ //get 3 corresponding file names
+ std::string dir = itksys::SystemTools::GetFilenamePath( tmpFileName.toStdString() );
+ std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( tmpFileName.toStdString() );
+ std::string extension = itksys::SystemTools::GetFilenameLastExtension( tmpFileName.toStdString() );
+
+ //"Incorrect format"-warning while using .nrrd or .pic files
+ if (extension != ".pic" && extension != ".nrrd")
+ {
+ msg = msg + "Invalid file format, please select a \".nrrd\"-file";
+ throw std::logic_error(msg.c_str());
+ }
+
+ //Checking for npos. If available, check for the Amplitude-, Intensity- and RGBImage
+
+ int found = baseFilename.rfind("_DistanceImage"); //Defining "found" variable+checking if baseFilname contains "_DistanceImage". If not, found == npos(0)
+
+ if (found == std::string::npos) //If found =0
+ {
+ found = baseFilename.rfind("_AmplitudeImage"); //If "_AmplitudeImage" is found, the found variable is 1-> the next if statment is false
+ }
+
+ if (found == std::string::npos)
+ {
+ found = baseFilename.rfind("_IntensityImage"); //found = true if baseFilename cotains "_IntesityImage"
+ }
+
+ if (found == std::string::npos)
+ {
+ found = baseFilename.rfind("_RGBImage");
+ }
+
+ if (found == std::string::npos) //If none of the Nodes is found, display an error
+ {
+ msg = msg + "Input file name must end with \"_DistanceImage\", \"_AmplitudeImage\", \"_IntensityImage\" or \"_RGBImage\"!";
+ throw std::logic_error(msg.c_str());
+ }
+
+ std::string baseFilenamePrefix = baseFilename.substr(0,found);//Set the baseFilenamePrefix as a substring from baseFilname
+
+ //Set corresponding FileNames
+ std::string distanceImageFileName = dir + "/" + baseFilenamePrefix + "_DistanceImage" + extension; //Set the name as: directory+FilenamePrefix+""+extension
+ std::string amplitudeImageFileName = dir + "/" + baseFilenamePrefix + "_AmplitudeImage" + extension;
+ std::string intensityImageFileName = dir + "/" + baseFilenamePrefix + "_IntensityImage" + extension;
+ std::string rgbImageFileName = dir + "/" + baseFilenamePrefix + "_RGBImage" + extension;
+
+
+ if (!itksys::SystemTools::FileExists(distanceImageFileName.c_str(), true))
+ {
+ this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", "");
+ }
+ else
+ {
+ this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", distanceImageFileName.c_str());
+ }
+ if (!itksys::SystemTools::FileExists(amplitudeImageFileName.c_str(), true))
+ {
+ }
+ else
+ {
+ this->m_ToFImageGrabber->SetStringProperty("AmplitudeImageFileName", amplitudeImageFileName.c_str());
+ }
+ if (!itksys::SystemTools::FileExists(intensityImageFileName.c_str(), true))
+ {
+ this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", "");
+ }
+ else
+ {
+ this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", intensityImageFileName.c_str());
+ }
+ if (!itksys::SystemTools::FileExists(rgbImageFileName.c_str(), true))
+ {
+ this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", "");
+ }
+ else
+ {
+ this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", rgbImageFileName.c_str());
+ }
}
- if (found == std::string::npos) //If none of the Nodes is found, display an error
+ catch (std::exception &e)
{
- msg = msg + "Input file name must end with \"_DistanceImage\", \"_AmplitudeImage\", \"_IntensityImage\" or \"_RGBImage\"!";
- throw std::logic_error(msg.c_str());
+ MITK_ERROR << e.what();
+ QMessageBox::critical( this, "Error", e.what() );
+ m_Controls->m_ConnectCameraButton->setChecked(false);
+ m_Controls->m_ConnectCameraButton->setEnabled(true);
+ m_Controls->m_DeviceList->setEnabled(true);
+ this->OnSelectCamera();
+ return;
}
+ }
+ }
+ //End "PlayerMode"
- std::string baseFilenamePrefix = baseFilename.substr(0,found);//Set the baseFilenamePrefix as a substring from baseFilname
+ //Reset the ConnectCameraButton to disconnected
+ m_Controls->m_ConnectCameraButton->setText("Disconnect");
- //Set corresponding FileNames
- std::string distanceImageFileName = dir + "/" + baseFilenamePrefix + "_DistanceImage" + extension; //Set the name as: directory+FilenamePrefix+""+extension
- std::string amplitudeImageFileName = dir + "/" + baseFilenamePrefix + "_AmplitudeImage" + extension;
- std::string intensityImageFileName = dir + "/" + baseFilenamePrefix + "_IntensityImage" + extension;
- std::string rgbImageFileName = dir + "/" + baseFilenamePrefix + "_RGBImage" + extension;
+ //if a connection could be established
+ try
+ {
+ if (this->m_ToFImageGrabber->ConnectCamera())
+ {
+ this->m_Controls->m_PMDParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
+ this->m_Controls->m_MESAParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
+ this->m_Controls->m_KinectParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
- if (!itksys::SystemTools::FileExists(distanceImageFileName.c_str(), true))
- {
- this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", "");
- }
- else
- {
- this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", distanceImageFileName.c_str());
- }
- if (!itksys::SystemTools::FileExists(amplitudeImageFileName.c_str(), true))
- {
- }
- else
- {
- this->m_ToFImageGrabber->SetStringProperty("AmplitudeImageFileName", amplitudeImageFileName.c_str());
- }
- if (!itksys::SystemTools::FileExists(intensityImageFileName.c_str(), true))
+ //Activating the respective widgets
+ if (selectedCamera.contains("PMD"))
{
- this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", "");
+ this->m_Controls->m_PMDParameterWidget->ActivateAllParameters();
}
- else
+ else if (selectedCamera.contains("MESA"))
{
- this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", intensityImageFileName.c_str());
+ this->m_Controls->m_MESAParameterWidget->ActivateAllParameters();
}
- if (!itksys::SystemTools::FileExists(rgbImageFileName.c_str(), true))
+ else if (selectedCamera.contains("Kinect"))
{
- this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", "");
+ this->m_Controls->m_KinectParameterWidget->ActivateAllParameters();
}
else
{
- this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", rgbImageFileName.c_str());
+ this->HideAllParameterWidgets();
}
+ // send connect signal to the caller functionality
+ emit ToFCameraConnected();
}
-
- catch (std::exception &e)
+ else
+ //##### TODO: Remove this else part once all controllers are throwing exceptions
+ //if they cannot to any device!
{
- MITK_ERROR << e.what();
- QMessageBox::critical( this, "Error", e.what() );
+ //Throw an error if the Connection failed and reset the Widgets <- better catch an exception!
+ QMessageBox::critical( this, "Error", "Connection failed. Check if you have installed the latest driver for your system." );
m_Controls->m_ConnectCameraButton->setChecked(false);
m_Controls->m_ConnectCameraButton->setEnabled(true);
- m_Controls->m_DeviceList->setEnabled(true);
+ m_Controls->m_ConnectCameraButton->setText("Connect");
+ m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
this->OnSelectCamera();
return;
}
- }
- }
-//End "PlayerMode"
-
- m_Controls->m_ConnectCameraButton->setText("Disconnect"); //Reset the ConnectCameraButton to disconnected
-
- //if a connection could be established
- try
- {
-
- if (this->m_ToFImageGrabber->ConnectCamera())
- {
- this->m_Controls->m_PMDParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
- this->m_Controls->m_MESAParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
- this->m_Controls->m_KinectParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
-
- //Activating the respective widgets
- if (selectedCamera.contains("PMD"))
+ }catch(std::exception &e)
{
- this->m_Controls->m_PMDParameterWidget->ActivateAllParameters();
- }
- else if (selectedCamera.contains("MESA"))
- {
- this->m_Controls->m_MESAParameterWidget->ActivateAllParameters();
- }
- else if (selectedCamera.contains("Kinect"))
- {
- this->m_Controls->m_KinectParameterWidget->ActivateAllParameters();
- }
- else
- {
- this->HideAllParameterWidgets();
- }
- // send connect signal to the caller functionality
- emit ToFCameraConnected();
- }
- else
- //##### TODO: Remove this else part once all controllers are throwing exceptions
- //if they cannot to any device!
- {
- //Throw an error if the Connection failed and reset the Widgets <- better catch an exception!
- QMessageBox::critical( this, "Error", "Connection failed. Check if you have installed the latest driver for your system." );
- m_Controls->m_ConnectCameraButton->setChecked(false);
- m_Controls->m_ConnectCameraButton->setEnabled(true);
- m_Controls->m_ConnectCameraButton->setText("Connect");
- m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
- this->OnSelectCamera();
- return;
- }
- }catch(std::exception &e)
- {
//catch exceptions of camera which cannot connect give a better reason
QMessageBox::critical( this, "Connection failed.", e.what() );
m_Controls->m_ConnectCameraButton->setChecked(false);
m_Controls->m_ConnectCameraButton->setEnabled(true);
m_Controls->m_ConnectCameraButton->setText("Connect");
m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
this->OnSelectCamera();
return;
- }
- m_Controls->m_ConnectCameraButton->setEnabled(true);
+ }
+ m_Controls->m_ConnectCameraButton->setEnabled(true);
- // ask wether camera parameters (intrinsics, ...) should be loaded
- if (QMessageBox::question(this,"Camera parameters","Do you want to specify your own camera intrinsics?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
+ // ask wether camera parameters (intrinsics, ...) should be loaded
+ if (QMessageBox::question(this,"Camera parameters","Do you want to specify your own camera intrinsics?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
+ {
+ QString fileName = QFileDialog::getOpenFileName(this,"Open camera intrinsics","/","*.xml");
+ mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
+ cameraIntrinsics->FromXMLFile(fileName.toStdString());
+ this->m_ToFImageGrabber->SetProperty("CameraIntrinsics",mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
+ }
+ ////Reset the status of some GUI-Elements
+ m_Controls->m_DeviceList->setEnabled(false); //Deactivating the Instance of QmitkServiceListWidget
+ //repaint the widget
+ this->repaint();
+ }
+ else
{
- QString fileName = QFileDialog::getOpenFileName(this,"Open camera intrinsics","/","*.xml");
- mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
- cameraIntrinsics->FromXMLFile(fileName.toStdString());
- this->m_ToFImageGrabber->SetProperty("CameraIntrinsics",mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
+ QMessageBox::information(this,"Camera connection","No camera selected, please select a range camera");
+ m_Controls->m_ConnectCameraButton->setChecked(false);
}
}
else if (m_Controls->m_ConnectCameraButton->text()=="Disconnect")
{
this->m_ToFImageGrabber->StopCamera();
this->m_ToFImageGrabber->DisconnectCamera();
m_Controls->m_ConnectCameraButton->setText("Connect");
m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
this->OnSelectCamera();
// send disconnect signal to the caller functionality
emit ToFCameraDisconnected();
}
}
diff --git a/Modules/ToFUI/Qmitk/QmitkToFConnectionWidgetControls.ui b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidgetControls.ui
index c82e5926ed..8a3e078f40 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFConnectionWidgetControls.ui
+++ b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidgetControls.ui
@@ -1,150 +1,153 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkToFConnectionWidgetControls2</class>
<widget class="QWidget" name="QmitkToFConnectionWidgetControls2">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>579</width>
<height>307</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="windowTitle">
<string>QmitkToFConnection</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="3" column="0">
<widget class="QmitkToFMESAParameterWidget" name="m_MESAParameterWidget" native="true"/>
</item>
<item row="1" column="0">
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QmitkServiceListWidget" name="m_DeviceList" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>100</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>16777215</width>
<height>100</height>
</size>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_ConnectCameraButton">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>200</width>
<height>80</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>16777215</width>
<height>80</height>
</size>
</property>
<property name="font">
<font>
<pointsize>10</pointsize>
</font>
</property>
<property name="toolTip">
<string>Connect to camera</string>
</property>
<property name="text">
<string>Connect</string>
</property>
<property name="icon">
<iconset resource="../resources/QmitkToFUtilWidget.qrc">
<normaloff>:/images/powerRed.png</normaloff>
<normalon>:/images/powerGreen.png</normalon>:/images/powerRed.png</iconset>
</property>
<property name="iconSize">
<size>
<width>30</width>
<height>30</height>
</size>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label">
<property name="font">
<font>
<pointsize>11</pointsize>
</font>
</property>
<property name="text">
<string>ToF camera connection</string>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QmitkToFPMDParameterWidget" name="m_PMDParameterWidget" native="true"/>
</item>
<item row="4" column="0">
<widget class="QmitkKinectParameterWidget" name="m_KinectParameterWidget" native="true"/>
</item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
<customwidget>
<class>QmitkToFPMDParameterWidget</class>
<extends>QWidget</extends>
<header>QmitkToFPMDParameterWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkToFMESAParameterWidget</class>
<extends>QWidget</extends>
<header>QmitkToFMESAParameterWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkKinectParameterWidget</class>
<extends>QWidget</extends>
<header>QmitkKinectParameterWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkServiceListWidget</class>
<extends>QWidget</extends>
<header>QmitkServiceListWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources>
<include location="../resources/QmitkToFUtilWidget.qrc"/>
</resources>
<connections/>
</ui>
diff --git a/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.cpp
index 781c6806fb..56ef51e478 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.cpp
@@ -1,409 +1,409 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#define _USE_MATH_DEFINES
#include "QmitkToFRecorderWidget.h"
//QT headers
#include <qmessagebox.h>
#include <QComboBox>
#include <QLabel>
#include <QLayout>
#include <QGridLayout>
#include <QCheckBox>
//mitk headers
#include <mitkToFImageWriter.h>
//itk headers
#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop
#include <itksys/SystemTools.hxx>
struct QFileDialogArgs;
class QFileDialogPrivate;
const std::string QmitkToFRecorderWidget::VIEW_ID = "org.mitk.views.qmitktofrecorderwidget";
QmitkToFRecorderWidget::QmitkToFRecorderWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
{
this->m_ToFImageRecorder = NULL;
this->m_ToFImageGrabber = NULL;
this->m_RecordMode = mitk::ToFImageRecorder::PerFrames;
this-> m_Controls = NULL;
CreateQtPartControl(this);
}
QmitkToFRecorderWidget::~QmitkToFRecorderWidget()
{
}
void QmitkToFRecorderWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
this->m_Controls = new Ui::QmitkToFRecorderWidgetControls;
this->m_Controls->setupUi(parent);
this->CreateConnections();
}
}
void QmitkToFRecorderWidget::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_PlayButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnPlay()) );
connect( (QObject*)(m_Controls->m_StopButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnStop()) );
connect( (QObject*)(m_Controls->m_StartRecordingButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnStartRecorder()) );
connect( (QObject*)(m_Controls->m_RecordModeComboBox), SIGNAL(currentIndexChanged(int)),(QObject*) this, SLOT(OnChangeRecordModeComboBox(int)) );
connect(this, SIGNAL(RecordingStopped()), this, SLOT(OnRecordingStopped()), Qt::BlockingQueuedConnection);
}
}
void QmitkToFRecorderWidget::SetParameter(mitk::ToFImageGrabber* toFImageGrabber, mitk::ToFImageRecorder* toFImageRecorder)
{
this->m_ToFImageGrabber = toFImageGrabber;
this->m_ToFImageRecorder = toFImageRecorder;
this->m_StopRecordingCommand = CommandType::New();
this->m_StopRecordingCommand->SetCallbackFunction(this, &QmitkToFRecorderWidget::StopRecordingCallback);
this->m_ToFImageRecorder->RemoveAllObservers();
this->m_ToFImageRecorder->AddObserver(itk::AbortEvent(), this->m_StopRecordingCommand);
m_Controls->m_PlayButton->setChecked(false);
m_Controls->m_PlayButton->setEnabled(true);
m_Controls->m_StartRecordingButton->setChecked(false);
m_Controls->m_RecorderGroupBox->setEnabled(true);
}
void QmitkToFRecorderWidget::StopRecordingCallback()
{
emit RecordingStopped();
}
void QmitkToFRecorderWidget::ResetGUIToInitial()
{
m_Controls->m_PlayButton->setChecked(false);
m_Controls->m_PlayButton->setEnabled(true);
m_Controls->m_RecorderGroupBox->setEnabled(false);
}
void QmitkToFRecorderWidget::OnRecordingStopped()
{
m_Controls->m_StartRecordingButton->setChecked(false);
m_Controls->m_RecorderGroupBox->setEnabled(true);
}
void QmitkToFRecorderWidget::OnStop()
{
StopCamera();
StopRecorder();
ResetGUIToInitial();
emit ToFCameraStopped();
}
void QmitkToFRecorderWidget::OnPlay()
{
m_Controls->m_PlayButton->setChecked(true);
m_Controls->m_PlayButton->setEnabled(false);
m_Controls->m_RecorderGroupBox->setEnabled(true);
this->repaint();
StartCamera();
emit ToFCameraStarted();
}
void QmitkToFRecorderWidget::StartCamera()
{
bool ok = false;
if (!m_ToFImageGrabber->IsCameraActive())
{
m_ToFImageGrabber->StartCamera();
}
}
void QmitkToFRecorderWidget::StopCamera()
{
if( m_ToFImageGrabber.IsNotNull() )
m_ToFImageGrabber->StopCamera();
}
void QmitkToFRecorderWidget::StopRecorder()
{
if( m_ToFImageRecorder.IsNotNull() )
{
this->m_ToFImageRecorder->StopRecording();
}
}
void QmitkToFRecorderWidget::OnStartRecorder()
{
m_Controls->m_StartRecordingButton->setChecked(true);
m_Controls->m_RecorderGroupBox->setEnabled(false);
this->repaint();
int numOfFrames = m_Controls->m_NumOfFramesSpinBox->value();
try
{
bool fileOK = true;
bool distanceImageSelected = true;
bool amplitudeImageSelected = true;
bool intensityImageSelected = true;
- bool rgbImageSelected = true;
+ bool rgbImageSelected = false;
bool rawDataSelected = false;
QString tmpFileName("");
QString selectedFilter("");
QString imageFileName("");
mitk::ToFImageWriter::ToFImageType tofImageType;
tmpFileName = QmitkToFRecorderWidget::getSaveFileName(tofImageType,
distanceImageSelected, amplitudeImageSelected, intensityImageSelected, rgbImageSelected, rawDataSelected,
NULL, "Save Image To...", imageFileName, "NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic);;Text (*.csv)", &selectedFilter);
if (tmpFileName.isEmpty())
{
fileOK = false;
}
else
{
imageFileName = tmpFileName;
}
if (fileOK)
{
std::string dir = itksys::SystemTools::GetFilenamePath( imageFileName.toStdString() );
std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( imageFileName.toStdString() );
std::string extension = itksys::SystemTools::GetFilenameLastExtension( imageFileName.toStdString() );
int integrationTime = this->m_ToFImageGrabber->GetIntegrationTime();
int modulationFreq = this->m_ToFImageGrabber->GetModulationFrequency();
QString integrationTimeStr;
integrationTimeStr.setNum(integrationTime);
QString modulationFreqStr;
modulationFreqStr.setNum(modulationFreq);
QString numOfFramesStr("");
if (this->m_RecordMode == mitk::ToFImageRecorder::PerFrames)
{
numOfFramesStr.setNum(numOfFrames);
}
std::string distImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(),
integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_DistanceImage");
MITK_INFO << "Save distance data to: " << distImageFileName;
std::string amplImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(),
integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_AmplitudeImage");
MITK_INFO << "Save amplitude data to: " << amplImageFileName;
std::string intenImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(),
integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_IntensityImage");
MITK_INFO << "Save intensity data to: " << intenImageFileName;
std::string rgbImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(),
integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_RGBImage");
MITK_INFO << "Save intensity data to: " << rgbImageFileName;
if (selectedFilter.compare("Text (*.csv)") == 0)
{
this->m_ToFImageRecorder->SetFileFormat(".csv");
}
else if (selectedFilter.compare("PIC Images - deprecated (*.pic)") == 0)
{
//default
this->m_ToFImageRecorder->SetFileFormat(".pic");
QMessageBox::warning(NULL, "Deprecated File Format!",
"Please note that *.pic file format is deprecated and not longer supported! The suggested file format for images is *.nrrd!");
}
else if (selectedFilter.compare("NRRD Images (*.nrrd)") == 0)
{
this->m_ToFImageRecorder->SetFileFormat(".nrrd");
}
else
{
QMessageBox::warning(NULL, "Unsupported file format!", "Please specify one of the supported file formats *.nrrd, *.csv!");
return;
}
numOfFrames = m_Controls->m_NumOfFramesSpinBox->value();
this->m_ToFImageRecorder->SetDistanceImageFileName(distImageFileName);
this->m_ToFImageRecorder->SetAmplitudeImageFileName(amplImageFileName);
this->m_ToFImageRecorder->SetIntensityImageFileName(intenImageFileName);
this->m_ToFImageRecorder->SetRGBImageFileName(rgbImageFileName);
this->m_ToFImageRecorder->SetToFImageType(tofImageType);
this->m_ToFImageRecorder->SetDistanceImageSelected(distanceImageSelected);
this->m_ToFImageRecorder->SetAmplitudeImageSelected(amplitudeImageSelected);
this->m_ToFImageRecorder->SetIntensityImageSelected(intensityImageSelected);
this->m_ToFImageRecorder->SetRGBImageSelected(rgbImageSelected);
this->m_ToFImageRecorder->SetRecordMode(this->m_RecordMode);
this->m_ToFImageRecorder->SetNumOfFrames(numOfFrames);
emit RecordingStarted();
this->m_ToFImageRecorder->StartRecording();
}
else
{
this->OnRecordingStopped();
}
}
catch(std::exception& e)
{
QMessageBox::critical(NULL, "Error", QString(e.what()));
this->OnRecordingStopped();
}
}
QString QmitkToFRecorderWidget::getSaveFileName(mitk::ToFImageWriter::ToFImageType& tofImageType,
bool& distanceImageSelected,
bool& amplitudeImageSelected,
bool& intensityImageSelected,
bool& rgbImageSelected,
bool& rawDataSelected,
QWidget *parent,
const QString &caption,
const QString &dir,
const QString &filter,
QString *selectedFilter,
QFileDialog::Options options
)
{
QString selectedFileName = "";
QComboBox* combo = new QComboBox;
combo->addItem("3D");
combo->addItem("2D + t");
QHBoxLayout* checkBoxGroup = new QHBoxLayout();
QCheckBox* distanceImageCheckBox = new QCheckBox;
distanceImageCheckBox->setText("Distance image");
distanceImageCheckBox->setChecked(true);
QCheckBox* amplitudeImageCheckBox = new QCheckBox;
amplitudeImageCheckBox->setText("Amplitude image");
amplitudeImageCheckBox->setChecked(true);
QCheckBox* intensityImageCheckBox = new QCheckBox;
intensityImageCheckBox->setText("Intensity image");
intensityImageCheckBox->setChecked(true);
QCheckBox* rgbImageCheckBox = new QCheckBox;
rgbImageCheckBox->setText("RGB image");
- rgbImageCheckBox->setChecked(true);
+ rgbImageCheckBox->setChecked(false);
QCheckBox* rawDataCheckBox = new QCheckBox;
rawDataCheckBox->setText("Raw data");
rawDataCheckBox->setChecked(false);
rawDataCheckBox->setEnabled(false);
checkBoxGroup->addWidget(distanceImageCheckBox);
checkBoxGroup->addWidget(amplitudeImageCheckBox);
checkBoxGroup->addWidget(intensityImageCheckBox);
checkBoxGroup->addWidget(rgbImageCheckBox);
checkBoxGroup->addWidget(rawDataCheckBox);
QFileDialog* fileDialog = new QFileDialog(parent, caption, dir, filter);
QLayout* layout = fileDialog->layout();
QGridLayout* gridbox = qobject_cast<QGridLayout*>(layout);
if (gridbox)
{
gridbox->addWidget(new QLabel("ToF-Image type:"));
gridbox->addWidget(combo);
int lastRow = gridbox->rowCount();
gridbox->addLayout(checkBoxGroup, lastRow, 0, 1, -1);
}
fileDialog->setLayout(gridbox);
fileDialog->setAcceptMode(QFileDialog::AcceptSave);
if (selectedFilter)
{
fileDialog->selectNameFilter(*selectedFilter);
}
if (fileDialog->exec() == QDialog::Accepted)
{
if (selectedFilter)
{
*selectedFilter = fileDialog->selectedFilter();
}
if (combo->currentIndex() == 0)
{
tofImageType = mitk::ToFImageWriter::ToFImageType3D;
}
else
{
tofImageType = mitk::ToFImageWriter::ToFImageType2DPlusT;
}
distanceImageSelected = distanceImageCheckBox->isChecked();
amplitudeImageSelected = amplitudeImageCheckBox->isChecked();
intensityImageSelected = intensityImageCheckBox->isChecked();
rgbImageSelected = rgbImageCheckBox->isChecked();
rawDataSelected = rawDataCheckBox->isChecked();
selectedFileName = fileDialog->selectedFiles().value(0);
}
delete fileDialog;
return selectedFileName;
}
std::string QmitkToFRecorderWidget::prepareFilename(std::string dir,
std::string baseFilename,
std::string modulationFreq,
std::string integrationTime,
std::string numOfFrames,
std::string extension,
std::string imageType)
{
std::string filenName("");
filenName.append(dir);
filenName.append("/");
filenName.append(baseFilename);
filenName.append("_MF");
filenName.append(modulationFreq);
filenName.append("_IT");
filenName.append(integrationTime);
filenName.append("_");
filenName.append(numOfFrames);
filenName.append("Images");
filenName.append(imageType);
filenName.append(extension);
return filenName;
}
void QmitkToFRecorderWidget::OnChangeRecordModeComboBox(int index)
{
if (index == 0)
{
this->m_RecordMode = mitk::ToFImageRecorder::PerFrames;
m_Controls->m_NumOfFramesSpinBox->setEnabled(true);
}
else
{
this->m_RecordMode = mitk::ToFImageRecorder::Infinite;
m_Controls->m_NumOfFramesSpinBox->setEnabled(false);
}
}
diff --git a/Modules/US/Testing/mitkUSPipelineTest.cpp b/Modules/US/Testing/mitkUSPipelineTest.cpp
index fbf87a9aed..272b0cba31 100644
--- a/Modules/US/Testing/mitkUSPipelineTest.cpp
+++ b/Modules/US/Testing/mitkUSPipelineTest.cpp
@@ -1,98 +1,98 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkUSVideoDevice.h"
#include "mitkTestingMacros.h"
#include "mitkUSImageToUSImageFilter.h"
#include "mitkPadImageFilter.h"
// START TESTFILER
// This is an specialization of the USImageToUSImageFIlter
class TestUSFilter : public mitk::USImageToUSImageFilter
{
protected:
TestUSFilter() : mitk::USImageToUSImageFilter(){};
virtual ~TestUSFilter(){};
public:
mitkClassMacro(TestUSFilter, mitk::USImageToUSImageFilter);
itkNewMacro(Self);
virtual void GenerateOutputInformation()
{
mitk::Image::Pointer inputImage = (mitk::Image*) this->GetInput(0);
- mitk::Image::Pointer output = (mitk::Image*) this->GetOutput(0);
+ mitk::Image::Pointer output = (mitk::Image*) this->GetPrimaryOutput();
if(inputImage.IsNull()) return;
};
void GenerateData()
{
mitk::USImage::Pointer ni = this->GetInput(0);
mitk::USImage::Pointer result = mitk::USImage::New();
result->Initialize(ni);
result->SetImportVolume(ni->GetData());
mitk::USImageMetadata::Pointer meta = ni->GetMetadata();
meta->SetDeviceComment("Test");
result->SetMetadata(meta);
SetNthOutput(0, result);
};
};
// END TESTFILTER
class mitkUSPipelineTestClass
{
public:
static void TestPipelineUS(std::string videoFilePath)
{
// Set up a pipeline
mitk::USVideoDevice::Pointer videoDevice = mitk::USVideoDevice::New("C:\\Users\\maerz\\Videos\\Debut\\us.avi", "Manufacturer", "Model");
TestUSFilter::Pointer filter = TestUSFilter::New();
videoDevice->Update();
filter->SetInput(videoDevice->GetOutput());
filter->Update();
MITK_TEST_CONDITION_REQUIRED(videoDevice.IsNotNull(), "videoDevice should not be null after instantiation");
- //mitk::USImage::Pointer result = dynamic_cast<mitk::USImage *> (filter->GetOutput(0));
+ //mitk::USImage::Pointer result = dynamic_cast<mitk::USImage *> (filter->GetOutput());
mitk::USImage::Pointer result = filter->GetOutput(0);
MITK_TEST_CONDITION_REQUIRED(result.IsNotNull(), "resulting images should not be null");
std::string model = result->GetMetadata()->GetDeviceModel();
MITK_TEST_CONDITION_REQUIRED(model.compare("Model") == 0 , "Resulting images should have their metadata set correctly");
}
};
/**
* This function is setting up a pipeline and checks the output for validity.
*/
int mitkUSPipelineTest(int argc , char* argv[])
{
MITK_TEST_BEGIN("mitkUSPipelineTest");
#ifdef WIN32 // Video file compression is currently only supported under windows.
// US Pipelines need to be reworked :(
// mitkUSPipelineTestClass::TestPipelineUS(argv[1]);
#endif
MITK_TEST_END();
}
diff --git a/Modules/US/USFilters/mitkUSImageVideoSource.cpp b/Modules/US/USFilters/mitkUSImageVideoSource.cpp
index ace4e5b8fa..2e4a5e60d6 100644
--- a/Modules/US/USFilters/mitkUSImageVideoSource.cpp
+++ b/Modules/US/USFilters/mitkUSImageVideoSource.cpp
@@ -1,168 +1,168 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// MITK HEADER
#include "mitkUSImageVideoSource.h"
#include "mitkImage.h"
//OpenCV HEADER
#include <cv.h>
#include <highgui.h>
//Other
#include <stdio.h>
mitk::USImageVideoSource::USImageVideoSource()
: itk::Object(),
m_VideoCapture(new cv::VideoCapture()),
m_IsVideoReady(false),
m_IsGreyscale(false),
m_OpenCVToMitkFilter(mitk::OpenCVToMitkImageFilter::New()),
m_ResolutionOverrideWidth(0),
m_ResolutionOverrideHeight(0),
m_ResolutionOverride(false)
{
m_OpenCVToMitkFilter->SetCopyBuffer(false);
}
mitk::USImageVideoSource::~USImageVideoSource()
{
}
void mitk::USImageVideoSource::SetVideoFileInput(std::string path)
{
m_VideoCapture->open(path.c_str());
if(!m_VideoCapture->isOpened()) // check if we succeeded
m_IsVideoReady = false;
else
m_IsVideoReady = true;
// If Override is enabled, use it
if (m_ResolutionOverride) {
m_VideoCapture->set(CV_CAP_PROP_FRAME_WIDTH, this->m_ResolutionOverrideWidth);
m_VideoCapture->set(CV_CAP_PROP_FRAME_HEIGHT, this->m_ResolutionOverrideHeight);
}
}
void mitk::USImageVideoSource::SetCameraInput(int deviceID)
{
m_VideoCapture->open(deviceID);
if(!m_VideoCapture->isOpened()) // check if we succeeded
m_IsVideoReady = false;
else
m_IsVideoReady = true;
// If Override is enabled, use it
if (m_ResolutionOverride) {
m_VideoCapture->set(CV_CAP_PROP_FRAME_WIDTH, this->m_ResolutionOverrideWidth);
m_VideoCapture->set(CV_CAP_PROP_FRAME_HEIGHT, this->m_ResolutionOverrideHeight);
}
}
void mitk::USImageVideoSource::SetColorOutput(bool isColor){
m_IsGreyscale = !isColor;
}
int mitk::USImageVideoSource::GetImageHeight()
{
if (m_VideoCapture) return m_VideoCapture->get(CV_CAP_PROP_FRAME_HEIGHT);
else return 0;
}
int mitk::USImageVideoSource::GetImageWidth()
{
if (m_VideoCapture) return m_VideoCapture->get(CV_CAP_PROP_FRAME_WIDTH);
else return 0;
}
void mitk::USImageVideoSource::SetRegionOfInterest(int topLeftX, int topLeftY, int bottomRightX, int bottomRightY)
{
// First, let's do some basic checks to make sure rectangle is inside of actual image
if (topLeftX < 0) topLeftX = 0;
if (topLeftY < 0) topLeftY = 0;
// We can try and correct too large boundaries
if (bottomRightX > m_VideoCapture->get(CV_CAP_PROP_FRAME_WIDTH)) bottomRightX = m_VideoCapture->get(CV_CAP_PROP_FRAME_WIDTH);
if (bottomRightY > m_VideoCapture->get(CV_CAP_PROP_FRAME_HEIGHT)) bottomRightY = m_VideoCapture->get(CV_CAP_PROP_FRAME_HEIGHT);
// Nothing to save, throw an exception
if (topLeftX > bottomRightX) mitkThrow() << "Invalid boundaries supplied to USImageVideoSource::SetRegionOfInterest()";
if (topLeftY > bottomRightY) mitkThrow() << "Invalid boundaries supplied to USImageVideoSource::SetRegionOfInterest()";
m_CropRegion = cv::Rect(topLeftX, topLeftY, bottomRightX - topLeftX, bottomRightY - topLeftY);
}
void mitk::USImageVideoSource::RemoveRegionOfInterest(){
m_CropRegion.width = 0;
m_CropRegion.height = 0;
}
mitk::USImage::Pointer mitk::USImageVideoSource::GetNextImage()
{
// Loop video if necessary
if (m_VideoCapture->get(CV_CAP_PROP_POS_AVI_RATIO) >= 0.99 )
m_VideoCapture->set(CV_CAP_PROP_POS_AVI_RATIO, 0);
// Setup pointers
cv::Mat image;
cv::Mat buffer;
// Retrieve image
*m_VideoCapture >> image; // get a new frame from camera
// if Region of interest is set, crop image
if (m_CropRegion.width > 0){
buffer = image(m_CropRegion);
image.release();
image = buffer;
}
// If this source is set to deliver greyscale images, convert it
if (m_IsGreyscale)
{
cv::cvtColor(image, buffer, CV_RGB2GRAY, 1);
image.release();
image = buffer;
}
// Convert to MITK-Image
IplImage ipl_img = image;
this->m_OpenCVToMitkFilter->SetOpenCVImage(&ipl_img);
this->m_OpenCVToMitkFilter->Update();
// OpenCVToMitkImageFilter returns a standard mitk::image. We then transform it into an USImage
- mitk::USImage::Pointer result = mitk::USImage::New(this->m_OpenCVToMitkFilter->GetOutput(0));
+ mitk::USImage::Pointer result = mitk::USImage::New(this->m_OpenCVToMitkFilter->GetOutput());
// Clean up
buffer.release();
image.release();
return result;
}
void mitk::USImageVideoSource::OverrideResolution(int width, int height){
this->m_ResolutionOverrideHeight = height;
this->m_ResolutionOverrideWidth = width;
if (m_VideoCapture != 0)
{
m_VideoCapture->set(CV_CAP_PROP_FRAME_WIDTH, width);
m_VideoCapture->set(CV_CAP_PROP_FRAME_HEIGHT, height);
}
}
diff --git a/Modules/US/USModel/mitkUSDevice.cpp b/Modules/US/USModel/mitkUSDevice.cpp
index 386d973f56..d5065210bf 100644
--- a/Modules/US/USModel/mitkUSDevice.cpp
+++ b/Modules/US/USModel/mitkUSDevice.cpp
@@ -1,319 +1,312 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkUSDevice.h"
//Microservices
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usServiceProperties.h>
#include "mitkModuleContext.h"
const std::string mitk::USDevice::US_INTERFACE_NAME = "org.mitk.services.UltrasoundDevice";
const std::string mitk::USDevice::US_PROPKEY_LABEL = US_INTERFACE_NAME + ".label";
const std::string mitk::USDevice::US_PROPKEY_ISACTIVE = US_INTERFACE_NAME + ".isActive";
const std::string mitk::USDevice::US_PROPKEY_CLASS = US_INTERFACE_NAME + ".class";
mitk::USDevice::USImageCropArea mitk::USDevice::GetCropArea()
{
MITK_INFO << "Return Crop Area L:" << m_CropArea.cropLeft << " R:" << m_CropArea.cropRight << " T:" << m_CropArea.cropTop << " B:" << m_CropArea.cropBottom;
return m_CropArea;
}
mitk::USDevice::USDevice(std::string manufacturer, std::string model) : mitk::ImageSource()
{
// Initialize Members
m_Metadata = mitk::USImageMetadata::New();
m_Metadata->SetDeviceManufacturer(manufacturer);
m_Metadata->SetDeviceModel(model);
m_IsActive = false;
USImageCropArea empty;
empty.cropBottom = 0;
empty.cropTop = 0;
empty.cropLeft = 0;
empty.cropRight = 0;
this->m_CropArea = empty;
m_IsConnected = false;
//set number of outputs
this->SetNumberOfOutputs(1);
//create a new output
mitk::USImage::Pointer newOutput = mitk::USImage::New();
this->SetNthOutput(0,newOutput);
}
mitk::USDevice::USDevice(mitk::USImageMetadata::Pointer metadata) : mitk::ImageSource()
{
m_Metadata = metadata;
m_IsActive = false;
m_IsConnected = false;
USImageCropArea empty;
empty.cropBottom = 0;
empty.cropTop = 0;
empty.cropLeft = 0;
empty.cropRight = 0;
this->m_CropArea = empty;
//set number of outputs
this->SetNumberOfOutputs(1);
//create a new output
mitk::USImage::Pointer newOutput = mitk::USImage::New();
this->SetNthOutput(0,newOutput);
}
mitk::USDevice::~USDevice()
{
}
mitk::ServiceProperties mitk::USDevice::ConstructServiceProperties()
{
ServiceProperties props;
std::string yes = "true";
std::string no = "false";
if(this->GetIsActive())
props[mitk::USDevice::US_PROPKEY_ISACTIVE] = yes;
else
props[mitk::USDevice::US_PROPKEY_ISACTIVE] = no;
std::string isActive;
if (GetIsActive()) isActive = " (Active)";
else isActive = " (Inactive)";
// e.g.: Zonare MyLab5 (Active)
props[ mitk::USDevice::US_PROPKEY_LABEL] = m_Metadata->GetDeviceManufacturer() + " " + m_Metadata->GetDeviceModel() + isActive;
if( m_Calibration.IsNotNull() )
props[ mitk::USImageMetadata::PROP_DEV_ISCALIBRATED ] = yes;
else
props[ mitk::USImageMetadata::PROP_DEV_ISCALIBRATED ] = no;
props[ mitk::USDevice::US_PROPKEY_CLASS ] = GetDeviceClass();
props[ mitk::USImageMetadata::PROP_DEV_MANUFACTURER ] = m_Metadata->GetDeviceManufacturer();
props[ mitk::USImageMetadata::PROP_DEV_MODEL ] = m_Metadata->GetDeviceModel();
props[ mitk::USImageMetadata::PROP_DEV_COMMENT ] = m_Metadata->GetDeviceComment();
props[ mitk::USImageMetadata::PROP_PROBE_NAME ] = m_Metadata->GetProbeName();
props[ mitk::USImageMetadata::PROP_PROBE_FREQUENCY ] = m_Metadata->GetProbeFrequency();
props[ mitk::USImageMetadata::PROP_ZOOM ] = m_Metadata->GetZoom();
return props;
}
bool mitk::USDevice::Connect()
{
if (GetIsConnected())
{
MITK_WARN << "Tried to connect an ultrasound device that was already connected. Ignoring call...";
return false;
}
// Prepare connection, fail if this fails.
if (! this->OnConnection()) return false;
// Update state
m_IsConnected = true;
// Get Context and Module
mitk::ModuleContext* context = GetModuleContext();
ServiceProperties props = ConstructServiceProperties();
m_ServiceRegistration = context->RegisterService<mitk::USDevice>(this, props);
// This makes sure that the SmartPointer to this device does not invalidate while the device is connected
this->Register();
return true;
}
bool mitk::USDevice::Disconnect()
{
if ( ! GetIsConnected())
{
MITK_WARN << "Tried to disconnect an ultrasound device that was not connected. Ignoring call...";
return false;
}
// Prepare connection, fail if this fails.
if (! this->OnDisconnection()) return false;
// Update state
m_IsConnected = false;
// Unregister
m_ServiceRegistration.Unregister();
m_ServiceRegistration = 0;
// Undo the manual registration done in Connect(). Pointer will invalidte, if no one holds a reference to this object anymore.
this->UnRegister();
return true;
}
bool mitk::USDevice::Activate()
{
if (! this->GetIsConnected()) return false;
m_IsActive = true; // <- Necessary to safely allow Subclasses to start threading based on activity state
m_IsActive = OnActivation();
ServiceProperties props = ConstructServiceProperties();
this->m_ServiceRegistration.SetProperties(props);
return m_IsActive;
}
void mitk::USDevice::Deactivate()
{
m_IsActive= false;
ServiceProperties props = ConstructServiceProperties();
this->m_ServiceRegistration.SetProperties(props);
OnDeactivation();
}
void mitk::USDevice::AddProbe(mitk::USProbe::Pointer probe)
{
for(int i = 0; i < m_ConnectedProbes.size(); i++)
{
if (m_ConnectedProbes[i]->IsEqualToProbe(probe)) return;
}
this->m_ConnectedProbes.push_back(probe);
}
void mitk::USDevice::ActivateProbe(mitk::USProbe::Pointer probe){
// currently, we may just add the probe. This behaviour should be changed, should more complicated SDK applications emerge
AddProbe(probe);
int index = -1;
for(int i = 0; i < m_ConnectedProbes.size(); i++)
{
if (m_ConnectedProbes[i]->IsEqualToProbe(probe)) index = i;
}
// index now contains the position of the original instance of this probe
m_ActiveProbe = m_ConnectedProbes[index];
}
void mitk::USDevice::DeactivateProbe(){
m_ActiveProbe = 0;
}
mitk::USImage* mitk::USDevice::GetOutput()
{
if (this->GetNumberOfOutputs() < 1)
return NULL;
- return static_cast<USImage*>(this->ProcessObject::GetOutput(0));
+ return static_cast<USImage*>(this->ProcessObject::GetPrimaryOutput());
}
mitk::USImage* mitk::USDevice::GetOutput(unsigned int idx)
{
if (this->GetNumberOfOutputs() < 1)
return NULL;
return static_cast<USImage*>(this->ProcessObject::GetOutput(idx));
}
void mitk::USDevice::GraftOutput(itk::DataObject *graft)
{
this->GraftNthOutput(0, graft);
}
void mitk::USDevice::GraftNthOutput(unsigned int idx, itk::DataObject *graft)
{
if ( idx >= this->GetNumberOfOutputs() )
{
itkExceptionMacro(<<"Requested to graft output " << idx <<
" but this filter only has " << this->GetNumberOfOutputs() << " Outputs.");
}
if ( !graft )
{
itkExceptionMacro(<<"Requested to graft output with a NULL pointer object" );
}
itk::DataObject* output = this->GetOutput(idx);
if ( !output )
{
itkExceptionMacro(<<"Requested to graft output that is a NULL pointer" );
}
// Call Graft on USImage to copy member data
output->Graft( graft );
}
-
-itk::ProcessObject::DataObjectPointer mitk::USDevice::MakeOutput( unsigned int /*idx */)
-{
- mitk::USImage::Pointer p = mitk::USImage::New();
- return static_cast<itk::DataObject*>(p.GetPointer());
-}
-
bool mitk::USDevice::ApplyCalibration(mitk::USImage::Pointer image){
if ( m_Calibration.IsNull() ) return false;
image->GetGeometry()->SetIndexToWorldTransform(m_Calibration);
return true;
}
//########### GETTER & SETTER ##################//
void mitk::USDevice::setCalibration (mitk::AffineTransform3D::Pointer calibration){
if (calibration.IsNull())
{
MITK_ERROR << "Null pointer passed to SetCalibration of mitk::USDevice. Ignoring call.";
return;
}
m_Calibration = calibration;
m_Metadata->SetDeviceIsCalibrated(true);
if (m_ServiceRegistration != 0)
{
ServiceProperties props = ConstructServiceProperties();
this->m_ServiceRegistration.SetProperties(props);
}
}
bool mitk::USDevice::GetIsActive()
{
return m_IsActive;
}
bool mitk::USDevice::GetIsConnected()
{
// a device is connected if it is registered with the Microservice Registry
return (m_ServiceRegistration != 0);
}
std::string mitk::USDevice::GetDeviceManufacturer(){
return this->m_Metadata->GetDeviceManufacturer();
}
std::string mitk::USDevice::GetDeviceModel(){
return this->m_Metadata->GetDeviceModel();
}
std::string mitk::USDevice::GetDeviceComment(){
return this->m_Metadata->GetDeviceComment();
}
std::vector<mitk::USProbe::Pointer> mitk::USDevice::GetConnectedProbes()
{
return m_ConnectedProbes;
}
diff --git a/Modules/US/USModel/mitkUSDevice.h b/Modules/US/USModel/mitkUSDevice.h
index ffb9aa1501..e6c8ae5465 100644
--- a/Modules/US/USModel/mitkUSDevice.h
+++ b/Modules/US/USModel/mitkUSDevice.h
@@ -1,313 +1,313 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKUSDevice_H_HEADER_INCLUDED_
#define MITKUSDevice_H_HEADER_INCLUDED_
// STL
#include <vector>
// MitkUS
#include "mitkUSProbe.h"
#include "mitkUSImageMetadata.h"
#include "mitkUSImage.h"
#include <MitkUSExports.h>
// MITK
#include <mitkCommon.h>
#include <mitkImageSource.h>
// ITK
#include <itkObjectFactory.h>
// Microservices
#include <usServiceInterface.h>
#include <usServiceRegistration.h>
#include <usServiceProperties.h>
namespace mitk {
/**Documentation
* \brief A device holds information about it's model, make and the connected probes. It is the
* common super class for all devices and acts as an image source for mitkUSImages. It is the base class
* for all US Devices, and every new device should extend it.
*
* US Devices support output of calibrated images, i.e. images that include a specific geometry.
* To achieve this, call SetCalibration, and make sure that the subclass also calls apply
* transformation at some point (The USDevice does not automatically apply the transformation to the image)
*
* Note that SmartPointers to USDevices will not invalidate while the device is still connected.
* \ingroup US
*/
class MitkUS_EXPORT USDevice : public mitk::ImageSource
{
public:
mitkClassMacro(USDevice, mitk::ImageSource);
struct USImageCropArea
{
int cropLeft;
int cropRight;
int cropBottom;
int cropTop;
};
/**
*\brief These constants are used in conjunction with Microservices
*/
static const std::string US_INTERFACE_NAME; // Common Interface name of all US Devices. Used to refer to this device via Microservices
static const std::string US_PROPKEY_LABEL; // Human readable text represntation of this device
static const std::string US_PROPKEY_ISACTIVE; // Whether this Device is active or not.
static const std::string US_PROPKEY_CLASS; // Class Name of this Object
/**
* \brief Connects this device. A connected device is ready to deliver images (i.e. be Activated). A Connected Device can be active. A disconnected Device cannot be active.
* Internally calls onConnect and then registers the device with the service. A device usually should
* override the OnConnection() method, but never the Connect() method, since this will possibly exclude the device
* from normal service management. The exact flow of events is:
* 0. Check if the device is already connected. If yes, return true anyway, but don't do anything.
* 1. Call OnConnection() Here, a device should establish it's connection with the hardware Afterwards, it should be ready to start transmitting images at any time.
* 2. If OnConnection() returns true ("successful"), then the device is registered with the service.
* 3. if not, it the method itself returns false or may throw an expection, depeneding on the device implementation.
*
*/
bool Connect();
/**
* \brief Works analogously to mitk::USDevice::Connect(). Don't override this Method, but onDisconnection instead.
*/
bool Disconnect();
/**
* \brief Activates this device. After the activation process, the device will start to produce images. This Method will fail, if the device is not connected.
*/
bool Activate();
/**
* \brief Deactivates this device. After the deactivation process, the device will no longer produce images, but still be connected.
*/
void Deactivate();
/**
* \brief Add a probe to the device without connecting to it.
* This should usually be done before connecting to the probe.
*/
virtual void AddProbe(mitk::USProbe::Pointer probe);
/**
* \brief Connect to a probe and activate it. The probe should be added first.
* Usually, a VideoDevice will simply add a probe it wants to connect to,
* but an SDK Device might require adding a probe first.
*/
virtual void ActivateProbe(mitk::USProbe::Pointer probe);
/**
* \brief Deactivates the currently active probe.
*/
virtual void DeactivateProbe();
/**
* \brief Removes a probe from the ist of currently added probes.
*/
//virtual void removeProbe(mitk::USProbe::Pointer probe);
/**
* \brief Returns a vector containing all connected probes.
*/
std::vector<mitk::USProbe::Pointer> GetConnectedProbes();
/**
*\brief return the output (output with id 0) of the filter
*/
USImage* GetOutput(void);
/**
*\brief return the output with id idx of the filter
*/
USImage* GetOutput(unsigned int idx);
/**
*\brief Graft the specified DataObject onto this ProcessObject's output.
*
* See itk::ImageSource::GraftNthOutput for details
*/
virtual void GraftNthOutput(unsigned int idx, itk::DataObject *graft);
/**
* \brief Graft the specified DataObject onto this ProcessObject's output.
*
* See itk::ImageSource::Graft Output for details
*/
virtual void GraftOutput(itk::DataObject *graft);
- /**
- * \brief Make a DataObject of the correct type to used as the specified output.
- *
- * This method is automatically called when DataObject::DisconnectPipeline()
- * is called. DataObject::DisconnectPipeline, disconnects a data object
- * from being an output of its current source. When the data object
- * is disconnected, the ProcessObject needs to construct a replacement
- * output data object so that the ProcessObject is in a valid state.
- * Subclasses of USImageVideoSource that have outputs of different
- * data types must overwrite this method so that proper output objects
- * are created.
- */
- virtual DataObjectPointer MakeOutput(unsigned int idx);
+// /**
+// * \brief Make a DataObject of the correct type to used as the specified output.
+// *
+// * This method is automatically called when DataObject::DisconnectPipeline()
+// * is called. DataObject::DisconnectPipeline, disconnects a data object
+// * from being an output of its current source. When the data object
+// * is disconnected, the ProcessObject needs to construct a replacement
+// * output data object so that the ProcessObject is in a valid state.
+// * Subclasses of USImageVideoSource that have outputs of different
+// * data types must overwrite this method so that proper output objects
+// * are created.
+// */
+// virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx);
//########### GETTER & SETTER ##################//
/**
* \brief Returns the Class of the Device. This Method must be reimplemented by every Inheriting Class.
*/
virtual std::string GetDeviceClass() = 0;
/**
* \brief True, if the device is currently generating image data, false otherwise.
*/
bool GetIsActive();
/**
* \brief True, if the device is currently ready to start transmitting image data or is already
* transmitting image data. A disconnected device cannot be activated.
*/
bool GetIsConnected();
/**
* \brief Sets a transformation as Calibration data. It also marks the device as Calibrated. This data is not automatically applied to the image. Subclasses must call ApplyTransformation
* to achieve this.
*/
void setCalibration (mitk::AffineTransform3D::Pointer calibration);
/**
* \brief Returns the current Calibration
*/
itkGetMacro(Calibration, mitk::AffineTransform3D::Pointer);
/**
* \brief Returns the currently active probe or null, if none is active
*/
itkGetMacro(ActiveProbe, mitk::USProbe::Pointer);
/* @return Returns the area that will be cropped from the US image. Is disabled / [0,0,0,0] by default. */
mitk::USDevice::USImageCropArea GetCropArea();
std::string GetDeviceManufacturer();
std::string GetDeviceModel();
std::string GetDeviceComment();
protected:
mitk::USProbe::Pointer m_ActiveProbe;
std::vector<mitk::USProbe::Pointer> m_ConnectedProbes;
bool m_IsActive;
bool m_IsConnected;
/* @brief defines the area that should be cropped from the US image */
USImageCropArea m_CropArea;
/*
* \brief This Method constructs the service properties which can later be used to
* register the object with the Microservices
* Return service properties
*/
mitk::ServiceProperties ConstructServiceProperties();
/**
* \brief Is called during the connection process. Override this method in your subclass to handle the actual connection.
* Return true if successful and false if unsuccessful. Additionally, you may throw an exception to clarify what went wrong.
*/
virtual bool OnConnection() = 0;
/**
* \brief Is called during the disconnection process. Override this method in your subclass to handle the actual disconnection.
* Return true if successful and false if unsuccessful. Additionally, you may throw an exception to clarify what went wrong.
*/
virtual bool OnDisconnection() = 0;
/**
* \brief Is called during the activation process. After this method is finished, the device should be generating images
*/
virtual bool OnActivation() = 0;
/**
* \brief Is called during the deactivation process. After a call to this method the device should still be connected, but not producing images anymore.
*/
virtual void OnDeactivation() = 0;
/**
* \brief This metadata set is privately used to imprint USImages with Metadata later.
* At instantiation time, it only contains Information about the Device,
* At scan time, it integrates this data with the probe information and imprints it on
* the produced images. This field is intentionally hidden from outside interference.
*/
mitk::USImageMetadata::Pointer m_Metadata;
/**
* \brief Enforces minimal Metadata to be set.
*/
USDevice(std::string manufacturer, std::string model);
/**
* \brief Constructs a device with the given Metadata. Make sure the Metadata contains meaningful content!
*/
USDevice(mitk::USImageMetadata::Pointer metadata);
virtual ~USDevice();
/**
* \brief Grabs the next frame from the Video input. This method is called internally, whenever Update() is invoked by an Output.
*/
void GenerateData() = 0;
/**
* \brief The Calibration Transformation of this US-Device. This will automatically be written into the image once
*/
mitk::AffineTransform3D::Pointer m_Calibration;
/**
* \brief Convenience method that can be used by subclasses to apply the Calibration Data to the image. A subclass has to call
* this method or set the transformation itself for the output to be calibrated! Returns true if a Calibration was set and false otherwise
* (Usually happens when no transformation was set yet).
*/
bool ApplyCalibration(mitk::USImage::Pointer image);
private:
/**
* \brief The device's ServiceRegistration object that allows to modify it's Microservice registraton details.
*/
mitk::ServiceRegistration m_ServiceRegistration;
};
} // namespace mitk
// This is the microservice declaration. Do not meddle!
US_DECLARE_SERVICE_INTERFACE(mitk::USDevice, "org.mitk.services.UltrasoundDevice")
-#endif
\ No newline at end of file
+#endif
diff --git a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp
index 738643af9a..9ec8b1e00d 100644
--- a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp
+++ b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp
@@ -1,169 +1,169 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//#define _USE_MATH_DEFINES
#include <QmitkUSNewVideoDeviceWidget.h>
//QT headers
//mitk headers
//itk headers
const std::string QmitkUSNewVideoDeviceWidget::VIEW_ID = "org.mitk.views.QmitkUSNewVideoDeviceWidget";
QmitkUSNewVideoDeviceWidget::QmitkUSNewVideoDeviceWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
{
m_Controls = NULL;
CreateQtPartControl(this);
//disable a few UI components which are not needed at the moment
m_Controls->probe_label->setVisible(false);
m_Controls->probe_label2->setVisible(false);
m_Controls->zoom_label->setVisible(false);
m_Controls->m_Probe->setVisible(false);
m_Controls->m_Zoom->setVisible(false);
}
QmitkUSNewVideoDeviceWidget::~QmitkUSNewVideoDeviceWidget()
{
}
//////////////////// INITIALIZATION /////////////////////
void QmitkUSNewVideoDeviceWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkUSNewVideoDeviceWidgetControls;
m_Controls->setupUi(parent);
this->CreateConnections();
}
}
void QmitkUSNewVideoDeviceWidget::CreateConnections()
{
if ( m_Controls )
{
connect( m_Controls->m_BtnDone, SIGNAL(clicked()), this, SLOT(OnClickedDone()) );
connect( m_Controls->m_BtnCancel, SIGNAL(clicked()), this, SLOT(OnClickedCancel()) );
connect( m_Controls->m_RadioDeviceSource, SIGNAL(clicked()), this, SLOT(OnDeviceTypeSelection()) );
connect( m_Controls->m_RadioFileSource, SIGNAL(clicked()), this, SLOT(OnDeviceTypeSelection()) );
}
// Hide & show stuff
m_Controls->m_FilePathSelector->setVisible(false);
}
///////////// Methods & Slots Handling Direct Interaction /////////////////
void QmitkUSNewVideoDeviceWidget::OnClickedDone(){
m_Active = false;
// Assemble Metadata
mitk::USImageMetadata::Pointer metadata = mitk::USImageMetadata::New();
metadata->SetDeviceComment(m_Controls->m_Comment->text().toStdString());
metadata->SetDeviceModel(m_Controls->m_Model->text().toStdString());
metadata->SetDeviceManufacturer(m_Controls->m_Manufacturer->text().toStdString());
metadata->SetProbeName(m_Controls->m_Probe->text().toStdString());
metadata->SetZoom(m_Controls->m_Zoom->text().toStdString());
// Create Device
mitk::USVideoDevice::Pointer newDevice;
if (m_Controls->m_RadioDeviceSource->isChecked()){
int deviceID = m_Controls->m_DeviceSelector->value();
newDevice = mitk::USVideoDevice::New(deviceID, metadata);
} else {
std::string filepath = m_Controls->m_FilePathSelector->text().toStdString();
newDevice = mitk::USVideoDevice::New(filepath, metadata);
}
// Set Video Options
newDevice->GetSource()->SetColorOutput(! m_Controls->m_CheckGreyscale->isChecked());
// If Resolution override is activated, apply it
if (m_Controls->m_CheckResolutionOverride->isChecked())
{
int width = m_Controls->m_ResolutionWidth->value();
int height = m_Controls->m_ResolutionHeight->value();
newDevice->GetSource()->OverrideResolution(width, height);
newDevice->GetSource()->SetResolutionOverride(true);
}
newDevice->Connect();
emit Finished();
}
void QmitkUSNewVideoDeviceWidget::OnClickedCancel(){
m_TargetDevice = 0;
m_Active = false;
emit Finished();
}
void QmitkUSNewVideoDeviceWidget::OnDeviceTypeSelection(){
m_Controls->m_FilePathSelector->setVisible(m_Controls->m_RadioFileSource->isChecked());
m_Controls->m_DeviceSelector->setVisible(m_Controls->m_RadioDeviceSource->isChecked());
}
///////////////// Methods & Slots Handling Logic //////////////////////////
void QmitkUSNewVideoDeviceWidget::EditDevice(mitk::USDevice::Pointer device)
{
// If no VideoDevice is given, throw an exception
if (device->GetDeviceClass().compare("org.mitk.modules.us.USVideoDevice") != 0){
// TODO Alert if bad path
- mitkThrow() << "NewVideoDeviceWidget recieved an incompatible Device Type to edit. Devicetype was: " << device->GetDeviceClass();
+ mitkThrow() << "NewVideoDeviceWidget recieved an incompatible device type to edit. Type was: " << device->GetDeviceClass();
}
m_TargetDevice = static_cast<mitk::USVideoDevice*> (device.GetPointer());
m_Active = true;
}
void QmitkUSNewVideoDeviceWidget::CreateNewDevice()
{
m_TargetDevice = 0;
InitFields(mitk::USImageMetadata::New());
m_Active = true;
}
/////////////////////// HOUSEHOLDING CODE ///////////////////////////////
QListWidgetItem* QmitkUSNewVideoDeviceWidget::ConstructItemFromDevice(mitk::USDevice::Pointer device){
QListWidgetItem *result = new QListWidgetItem;
std::string text = device->GetDeviceManufacturer() + "|" + device->GetDeviceModel();
result->setText(text.c_str());
return result;
}
void QmitkUSNewVideoDeviceWidget::InitFields(mitk::USImageMetadata::Pointer metadata){
this->m_Controls->m_Manufacturer->setText (metadata->GetDeviceManufacturer().c_str());
this->m_Controls->m_Model->setText (metadata->GetDeviceModel().c_str());
this->m_Controls->m_Comment->setText (metadata->GetDeviceComment().c_str());
this->m_Controls->m_Probe->setText (metadata->GetProbeName().c_str());
this->m_Controls->m_Zoom->setText (metadata->GetZoom().c_str());
}
diff --git a/Modules/USUI/Qmitk/mitkUSDevicePersistence.cpp b/Modules/USUI/Qmitk/mitkUSDevicePersistence.cpp
index fae0a09fe9..b038c4e2c9 100644
--- a/Modules/USUI/Qmitk/mitkUSDevicePersistence.cpp
+++ b/Modules/USUI/Qmitk/mitkUSDevicePersistence.cpp
@@ -1,186 +1,198 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkUSDevicePersistence.h"
//Microservices
-#include "usServiceReference.h"
-#include "usModuleContext.h"
+#include <usServiceReference.h>
+#include <usModuleContext.h>
#include <usGetModuleContext.h>
#include <mitkModuleContext.h>
+//QT
+#include <QMessageBox>
+
mitk::USDevicePersistence::USDevicePersistence() : m_devices("MITK US","Device Settings")
- {
- }
+{
+}
void mitk::USDevicePersistence::StoreCurrentDevices()
- {
+{
mitk::ModuleContext* thisContext = mitk::GetModuleContext();
std::list<mitk::ServiceReference> services = thisContext->GetServiceReferences<mitk::USDevice>();
MITK_INFO << "Trying to save " << services.size() << " US devices.";
int numberOfSavedDevices = 0;
for(std::list<mitk::ServiceReference>::iterator it = services.begin(); it != services.end(); ++it)
- {
+ {
mitk::USDevice::Pointer currentDevice = thisContext->GetService<mitk::USDevice>(*it);
//check if it is a USVideoDevice
- if (currentDevice->GetDeviceClass()=="org.mitk.modules.us.USVideoDevice")
- {
+ if (currentDevice->GetDeviceClass() == "org.mitk.modules.us.USVideoDevice")
+ {
mitk::USVideoDevice::Pointer currentVideoDevice = dynamic_cast<mitk::USVideoDevice*>(currentDevice.GetPointer());
QString identifier = "device" + QString::number(numberOfSavedDevices);
m_devices.setValue(identifier,USVideoDeviceToString(currentVideoDevice));
numberOfSavedDevices++;
- }
+ }
else
- {
+ {
MITK_WARN << "Saving of US devices of the type " << currentDevice->GetDeviceClass() << " is not supported at the moment. Skipping device.";
- }
}
+ }
m_devices.setValue("numberOfSavedDevices",numberOfSavedDevices);
MITK_INFO << "Successfully saved " << numberOfSavedDevices << " US devices.";
- }
+}
void mitk::USDevicePersistence::RestoreLastDevices()
- {
+{
int numberOfSavedDevices = m_devices.value("numberOfSavedDevices").toInt();
for(int i=0; i<numberOfSavedDevices; i++)
+ {
+ // Try each device. If an exception occurs: Ignore device and notify user
+ try
+ {
+ QString currentString = m_devices.value("device"+QString::number(i)).toString();
+ mitk::USVideoDevice::Pointer currentDevice = StringToUSVideoDevice(currentString);
+ currentDevice->Connect();
+ }
+ catch (...)
{
- QString currentString = m_devices.value("device"+QString::number(i)).toString();
- mitk::USVideoDevice::Pointer currentDevice = StringToUSVideoDevice(currentString);
- currentDevice->Connect();
+ MITK_ERROR << "Error occured while loading a USVideoDevice from persistence. Device assumed corrupt, will be deleted.";
+ QMessageBox::warning(NULL, "Could not load device" ,"A stored ultrasound device is corrupted and could not be loaded. The device will be deleted.");
}
+ }
MITK_INFO << "Restoring " << numberOfSavedDevices << " US devices.";
- }
+}
QString mitk::USDevicePersistence::USVideoDeviceToString(mitk::USVideoDevice::Pointer d)
{
-QString manufacturer = d->GetDeviceManufacturer().c_str();
-QString model = d->GetDeviceModel().c_str();
-QString comment = d->GetDeviceComment().c_str();
-int source = d->GetDeviceID();
-std::string file = d->GetFilePath();
-if (file == "") file = "none";
-int greyscale = d->GetSource()->GetIsGreyscale();
-int resOverride = d->GetSource()->GetResolutionOverride();
-int resWidth = d->GetSource()->GetResolutionOverrideWidth();
-int resHight = d->GetSource()->GetResolutionOverrideHeight();
-int cropRight = d->GetCropArea().cropRight;
-int cropLeft = d->GetCropArea().cropLeft;
-int cropBottom = d->GetCropArea().cropBottom;
-int cropTop = d->GetCropArea().cropTop;
-char seperator = '|';
-
-QString returnValue = manufacturer + seperator
- + model + seperator
- + comment + seperator
- + QString::number(source) + seperator
- + file.c_str() + seperator
- + QString::number(greyscale) + seperator
- + QString::number(resOverride) + seperator
- + QString::number(resWidth) + seperator
- + QString::number(resHight) + seperator
- + QString::number(cropRight) + seperator
- + QString::number(cropLeft) + seperator
- + QString::number(cropBottom) + seperator
- + QString::number(cropTop)
- ;
-
-MITK_INFO << "Output String: " << returnValue.toStdString();
-return returnValue;
+ QString manufacturer = d->GetDeviceManufacturer().c_str();
+ QString model = d->GetDeviceModel().c_str();
+ QString comment = d->GetDeviceComment().c_str();
+ int source = d->GetDeviceID();
+ std::string file = d->GetFilePath();
+ if (file == "") file = "none";
+ int greyscale = d->GetSource()->GetIsGreyscale();
+ int resOverride = d->GetSource()->GetResolutionOverride();
+ int resWidth = d->GetSource()->GetResolutionOverrideWidth();
+ int resHight = d->GetSource()->GetResolutionOverrideHeight();
+ int cropRight = d->GetCropArea().cropRight;
+ int cropLeft = d->GetCropArea().cropLeft;
+ int cropBottom = d->GetCropArea().cropBottom;
+ int cropTop = d->GetCropArea().cropTop;
+ char seperator = '|';
+
+ QString returnValue = manufacturer + seperator
+ + model + seperator
+ + comment + seperator
+ + QString::number(source) + seperator
+ + file.c_str() + seperator
+ + QString::number(greyscale) + seperator
+ + QString::number(resOverride) + seperator
+ + QString::number(resWidth) + seperator
+ + QString::number(resHight) + seperator
+ + QString::number(cropRight) + seperator
+ + QString::number(cropLeft) + seperator
+ + QString::number(cropBottom) + seperator
+ + QString::number(cropTop)
+ ;
+
+ MITK_INFO << "Output String: " << returnValue.toStdString();
+ return returnValue;
}
mitk::USVideoDevice::Pointer mitk::USDevicePersistence::StringToUSVideoDevice(QString s)
{
-MITK_INFO << "Input String: " << s.toStdString();
-std::vector<std::string> data;
-std::string seperators = "|";
-std::string text = s.toStdString();
-split(text,seperators,data);
-if(data.size() != 13)
+ MITK_INFO << "Input String: " << s.toStdString();
+ std::vector<std::string> data;
+ std::string seperators = "|";
+ std::string text = s.toStdString();
+ split(text,seperators,data);
+ if(data.size() != 13)
{
- MITK_ERROR << "Cannot parse US device! (Size: " << data.size() << ")";
- return mitk::USVideoDevice::New("INVALID","INVALID","INVALID");
+ MITK_ERROR << "Cannot parse US device! (Size: " << data.size() << ")";
+ return mitk::USVideoDevice::New("INVALID","INVALID","INVALID");
}
-std::string manufacturer = data.at(0);
-std::string model = data.at(1);
-std::string comment = data.at(2);
-int source = (QString(data.at(3).c_str())).toInt();
-std::string file = data.at(4);
-bool greyscale = (QString(data.at(5).c_str())).toInt();
-bool resOverride = (QString(data.at(6).c_str())).toInt();
-int resWidth = (QString(data.at(7).c_str())).toInt();
-int resHight = (QString(data.at(8).c_str())).toInt();
-mitk::USDevice::USImageCropArea cropArea;
-cropArea.cropRight = (QString(data.at(9).c_str())).toInt();
-cropArea.cropLeft = (QString(data.at(10).c_str())).toInt();
-cropArea.cropBottom = (QString(data.at(11).c_str())).toInt();
-cropArea.cropTop = (QString(data.at(12).c_str())).toInt();
-
-// Assemble Metadata
-mitk::USImageMetadata::Pointer metadata = mitk::USImageMetadata::New();
-metadata->SetDeviceManufacturer(manufacturer);
-metadata->SetDeviceComment(comment);
-metadata->SetDeviceModel(model);
-metadata->SetProbeName("");
-metadata->SetZoom("");
-
-// Create Device
-mitk::USVideoDevice::Pointer returnValue;
-if (file == "none")
+ std::string manufacturer = data.at(0);
+ std::string model = data.at(1);
+ std::string comment = data.at(2);
+ int source = (QString(data.at(3).c_str())).toInt();
+ std::string file = data.at(4);
+ bool greyscale = (QString(data.at(5).c_str())).toInt();
+ bool resOverride = (QString(data.at(6).c_str())).toInt();
+ int resWidth = (QString(data.at(7).c_str())).toInt();
+ int resHight = (QString(data.at(8).c_str())).toInt();
+ mitk::USDevice::USImageCropArea cropArea;
+ cropArea.cropRight = (QString(data.at(9).c_str())).toInt();
+ cropArea.cropLeft = (QString(data.at(10).c_str())).toInt();
+ cropArea.cropBottom = (QString(data.at(11).c_str())).toInt();
+ cropArea.cropTop = (QString(data.at(12).c_str())).toInt();
+
+ // Assemble Metadata
+ mitk::USImageMetadata::Pointer metadata = mitk::USImageMetadata::New();
+ metadata->SetDeviceManufacturer(manufacturer);
+ metadata->SetDeviceComment(comment);
+ metadata->SetDeviceModel(model);
+ metadata->SetProbeName("");
+ metadata->SetZoom("");
+
+ // Create Device
+ mitk::USVideoDevice::Pointer returnValue;
+ if (file == "none")
{
- returnValue = mitk::USVideoDevice::New(source, metadata);
+ returnValue = mitk::USVideoDevice::New(source, metadata);
}
-else
+ else
{
- returnValue = mitk::USVideoDevice::New(file, metadata);
+ returnValue = mitk::USVideoDevice::New(file, metadata);
}
-// Set Video Options
-returnValue->GetSource()->SetColorOutput(!greyscale);
+ // Set Video Options
+ returnValue->GetSource()->SetColorOutput(!greyscale);
-// If Resolution override is activated, apply it
-if (resOverride)
- {
- returnValue->GetSource()->OverrideResolution(resWidth, resHight);
- returnValue->GetSource()->SetResolutionOverride(true);
- }
+ // If Resolution override is activated, apply it
+ if (resOverride)
+ {
+ returnValue->GetSource()->OverrideResolution(resWidth, resHight);
+ returnValue->GetSource()->SetResolutionOverride(true);
+ }
-// Set Crop Area
-returnValue->SetCropArea(cropArea);
+ // Set Crop Area
+ returnValue->SetCropArea(cropArea);
-return returnValue;
+ return returnValue;
}
void mitk::USDevicePersistence::split(std::string& text, std::string& separators, std::vector<std::string>& words)
- {
+{
int n = text.length();
int start, stop;
start = text.find_first_not_of(separators);
while ((start >= 0) && (start < n))
{
stop = text.find_first_of(separators, start);
if ((stop < 0) || (stop > n)) stop = n;
words.push_back(text.substr(start, stop - start));
- start = text.find_first_not_of(separators, stop+1);
- }
+ start = text.find_first_not_of(separators, stop + 1);
}
+}
diff --git a/Plugins/PluginList.cmake b/Plugins/PluginList.cmake
index 4e4182cfbb..0ee96249d6 100644
--- a/Plugins/PluginList.cmake
+++ b/Plugins/PluginList.cmake
@@ -1,46 +1,48 @@
# Plug-ins must be ordered according to their dependencies
set(MITK_EXT_PLUGINS
org.mitk.core.services:ON
org.mitk.gui.common:ON
org.mitk.planarfigure:ON
org.mitk.core.ext:OFF
org.mitk.core.jobs:OFF
org.mitk.diffusionimaging:OFF
+ org.mitk.simulation:OFF
org.mitk.gui.qt.application:ON
org.mitk.gui.qt.coreapplication:OFF
org.mitk.gui.qt.ext:OFF
org.mitk.gui.qt.extapplication:OFF
org.mitk.gui.qt.common:ON
org.mitk.gui.qt.stdmultiwidgeteditor:ON
org.mitk.gui.qt.common.legacy:OFF
org.mitk.gui.qt.cmdlinemodules:OFF
org.mitk.gui.qt.diffusionimagingapp:OFF
org.mitk.gui.qt.datamanager:ON
org.mitk.gui.qt.datamanagerlight:OFF
+ org.mitk.gui.qt.properties:OFF
org.mitk.gui.qt.basicimageprocessing:OFF
org.mitk.gui.qt.dicom:OFF
org.mitk.gui.qt.diffusionimaging:OFF
org.mitk.gui.qt.dtiatlasapp:OFF
org.mitk.gui.qt.examples:OFF
org.mitk.gui.qt.examplesopencv:OFF
org.mitk.gui.qt.igtexamples:OFF
org.mitk.gui.qt.igttracking:OFF
org.mitk.gui.qt.imagecropper:OFF
org.mitk.gui.qt.imagenavigator:ON
org.mitk.gui.qt.materialeditor:OFF
org.mitk.gui.qt.measurementtoolbox:OFF
org.mitk.gui.qt.meshdecimation:OFF
org.mitk.gui.qt.moviemaker:OFF
org.mitk.gui.qt.pointsetinteraction:OFF
org.mitk.gui.qt.python:OFF
org.mitk.gui.qt.registration:OFF
org.mitk.gui.qt.segmentation:OFF
org.mitk.gui.qt.simulation:OFF
org.mitk.gui.qt.toftutorial:OFF
org.mitk.gui.qt.tofutil:OFF
org.mitk.gui.qt.ugvisualization:OFF
org.mitk.gui.qt.ultrasound:OFF
org.mitk.gui.qt.volumevisualization:OFF
)
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
index 023f5f748d..e0275f5124 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
@@ -1,1312 +1,1312 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkBasicImageProcessingView.h"
// QT includes (GUI)
#include <qlabel.h>
#include <qspinbox.h>
#include <qpushbutton.h>
#include <qcheckbox.h>
#include <qgroupbox.h>
#include <qradiobutton.h>
#include <qmessagebox.h>
// Berry includes (selection service)
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// MITK includes (GUI)
#include "QmitkStdMultiWidget.h"
#include "QmitkDataNodeSelectionProvider.h"
#include "mitkDataNodeObject.h"
// MITK includes (general)
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateDimension.h"
#include "mitkNodePredicateAnd.h"
#include "mitkImageTimeSelector.h"
#include "mitkVectorImageMapper2D.h"
#include "mitkProperties.h"
// Includes for image casting between ITK and MITK
#include "mitkImageCast.h"
#include "mitkITKImageImport.h"
// ITK includes (general)
#include <itkVectorImage.h>
#include <itkImageFileWriter.h>
// Morphological Operations
#include <itkBinaryBallStructuringElement.h>
#include <itkGrayscaleDilateImageFilter.h>
#include <itkGrayscaleErodeImageFilter.h>
#include <itkGrayscaleMorphologicalOpeningImageFilter.h>
#include <itkGrayscaleMorphologicalClosingImageFilter.h>
// Smoothing
#include <itkMedianImageFilter.h>
#include <itkDiscreteGaussianImageFilter.h>
#include <itkTotalVariationDenoisingImageFilter.h>
// Threshold
#include <itkBinaryThresholdImageFilter.h>
// Inversion
#include <itkInvertIntensityImageFilter.h>
// Derivatives
#include <itkGradientMagnitudeRecursiveGaussianImageFilter.h>
#include <itkLaplacianImageFilter.h>
#include <itkSobelEdgeDetectionImageFilter.h>
// Resampling
#include <itkResampleImageFilter.h>
#include <itkNearestNeighborInterpolateImageFunction.h>
#include <itkCastImageFilter.h>
#include <itkLinearInterpolateImageFunction.h>
// Image Arithmetics
#include <itkAddImageFilter.h>
#include <itkSubtractImageFilter.h>
#include <itkMultiplyImageFilter.h>
#include <itkDivideImageFilter.h>
// Boolean operations
#include <itkOrImageFilter.h>
#include <itkAndImageFilter.h>
#include <itkXorImageFilter.h>
// Flip Image
#include <itkFlipImageFilter.h>
// Convenient Definitions
typedef itk::Image<short, 3> ImageType;
typedef itk::Image<unsigned char, 3> SegmentationImageType;
typedef itk::Image<double, 3> FloatImageType;
typedef itk::Image<itk::Vector<float,3>, 3> VectorImageType;
typedef itk::BinaryBallStructuringElement<ImageType::PixelType, 3> BallType;
typedef itk::GrayscaleDilateImageFilter<ImageType, ImageType, BallType> DilationFilterType;
typedef itk::GrayscaleErodeImageFilter<ImageType, ImageType, BallType> ErosionFilterType;
typedef itk::GrayscaleMorphologicalOpeningImageFilter<ImageType, ImageType, BallType> OpeningFilterType;
typedef itk::GrayscaleMorphologicalClosingImageFilter<ImageType, ImageType, BallType> ClosingFilterType;
typedef itk::MedianImageFilter< ImageType, ImageType > MedianFilterType;
typedef itk::DiscreteGaussianImageFilter< ImageType, ImageType> GaussianFilterType;
typedef itk::TotalVariationDenoisingImageFilter<FloatImageType, FloatImageType> TotalVariationFilterType;
typedef itk::TotalVariationDenoisingImageFilter<VectorImageType, VectorImageType> VectorTotalVariationFilterType;
typedef itk::BinaryThresholdImageFilter< ImageType, ImageType > ThresholdFilterType;
typedef itk::InvertIntensityImageFilter< ImageType, ImageType > InversionFilterType;
typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< ImageType, ImageType > GradientFilterType;
typedef itk::LaplacianImageFilter< FloatImageType, FloatImageType > LaplacianFilterType;
typedef itk::SobelEdgeDetectionImageFilter< FloatImageType, FloatImageType > SobelFilterType;
typedef itk::ResampleImageFilter< ImageType, ImageType > ResampleImageFilterType;
typedef itk::ResampleImageFilter< ImageType, ImageType > ResampleImageFilterType2;
typedef itk::CastImageFilter< ImageType, FloatImageType > ImagePTypeToFloatPTypeCasterType;
typedef itk::AddImageFilter< ImageType, ImageType, ImageType > AddFilterType;
typedef itk::SubtractImageFilter< ImageType, ImageType, ImageType > SubtractFilterType;
typedef itk::MultiplyImageFilter< ImageType, ImageType, ImageType > MultiplyFilterType;
typedef itk::DivideImageFilter< ImageType, ImageType, FloatImageType > DivideFilterType;
typedef itk::OrImageFilter< ImageType, ImageType > OrImageFilterType;
typedef itk::AndImageFilter< ImageType, ImageType > AndImageFilterType;
typedef itk::XorImageFilter< ImageType, ImageType > XorImageFilterType;
typedef itk::FlipImageFilter< ImageType > FlipImageFilterType;
typedef itk::LinearInterpolateImageFunction< ImageType, double > LinearInterpolatorType;
typedef itk::NearestNeighborInterpolateImageFunction< ImageType, double > NearestInterpolatorType;
QmitkBasicImageProcessing::QmitkBasicImageProcessing()
: QmitkFunctionality(),
m_Controls(NULL),
m_SelectedImageNode(NULL),
m_TimeStepperAdapter(NULL),
m_SelectionListener(NULL)
{
}
QmitkBasicImageProcessing::~QmitkBasicImageProcessing()
{
//berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
//if(s)
// s->RemoveSelectionListener(m_SelectionListener);
}
void QmitkBasicImageProcessing::CreateQtPartControl(QWidget *parent)
{
if (m_Controls == NULL)
{
m_Controls = new Ui::QmitkBasicImageProcessingViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
//setup predictaes for combobox
mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
m_Controls->m_ImageSelector2->SetDataStorage(this->GetDefaultDataStorage());
m_Controls->m_ImageSelector2->SetPredicate(mitk::NodePredicateAnd::New(dimensionPredicate, imagePredicate));
}
m_Controls->gbTwoImageOps->hide();
m_SelectedImageNode = mitk::DataStorageSelection::New(this->GetDefaultDataStorage(), false);
}
void QmitkBasicImageProcessing::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->cbWhat1), SIGNAL( activated(int) ), this, SLOT( SelectAction(int) ) );
connect( (QObject*)(m_Controls->btnDoIt), SIGNAL(clicked()),(QObject*) this, SLOT(StartButtonClicked()));
connect( (QObject*)(m_Controls->cbWhat2), SIGNAL( activated(int) ), this, SLOT( SelectAction2(int) ) );
connect( (QObject*)(m_Controls->btnDoIt2), SIGNAL(clicked()),(QObject*) this, SLOT(StartButton2Clicked()));
connect( (QObject*)(m_Controls->rBOneImOp), SIGNAL( clicked() ), this, SLOT( ChangeGUI() ) );
connect( (QObject*)(m_Controls->rBTwoImOp), SIGNAL( clicked() ), this, SLOT( ChangeGUI() ) );
connect( (QObject*)(m_Controls->cbParam4), SIGNAL( activated(int) ), this, SLOT( SelectInterpolator(int) ) );
}
m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls->sliceNavigatorTime,
GetActiveStdMultiWidget()->GetTimeNavigationController()->GetTime(), "sliceNavigatorTimeFromBIP");
}
void QmitkBasicImageProcessing::Activated()
{
QmitkFunctionality::Activated();
this->m_Controls->cbWhat1->clear();
this->m_Controls->cbWhat1->insertItem( NOACTIONSELECTED, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Please select operation", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( CATEGORY_DENOISING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Denoising ---", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( GAUSSIAN, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Gaussian", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( MEDIAN, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Median", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( TOTALVARIATION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Total Variation", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( CATEGORY_MORPHOLOGICAL, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Morphological ---", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( DILATION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Dilation", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( EROSION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Erosion", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( OPENING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Opening", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( CLOSING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Closing", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( CATEGORY_EDGE_DETECTION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Edge Detection ---", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( GRADIENT, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Gradient", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( LAPLACIAN, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Laplacian (2nd Derivative)", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( SOBEL, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Sobel Operator", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( CATEGORY_MISC, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Misc ---", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( THRESHOLD, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Threshold", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( INVERSION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Image Inversion", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( DOWNSAMPLING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Downsampling", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( FLIPPING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Flipping", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat1->insertItem( RESAMPLING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Resample to", 0, QApplication::UnicodeUTF8) ));
this->m_Controls->cbWhat2->clear();
this->m_Controls->cbWhat2->insertItem( TWOIMAGESNOACTIONSELECTED, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Please select on operation", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( CATEGORY_ARITHMETIC, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Arithmetric operations ---", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( ADD, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Add to Image 1:", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( SUBTRACT, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Subtract from Image 1:", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( MULTIPLY, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Multiply with Image 1:", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( RESAMPLE_TO, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Resample Image 1 to fit geometry:", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( DIVIDE, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Divide Image 1 by:", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( CATEGORY_BOOLEAN, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Boolean operations ---", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( AND, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "AND", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( OR, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "OR", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbWhat2->insertItem( XOR, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "XOR", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbParam4->clear();
this->m_Controls->cbParam4->insertItem( LINEAR, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Linear", 0, QApplication::UnicodeUTF8) ) );
this->m_Controls->cbParam4->insertItem( NEAREST, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Nearest neighbor", 0, QApplication::UnicodeUTF8) ) );
m_Controls->dsbParam1->hide();
m_Controls->dsbParam2->hide();
m_Controls->dsbParam3->hide();
m_Controls->tlParam3->hide();
m_Controls->tlParam4->hide();
m_Controls->cbParam4->hide();
}
//datamanager selection changed
void QmitkBasicImageProcessing::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
{
//any nodes there?
if (!nodes.empty())
{
// reset GUI
// this->ResetOneImageOpPanel();
m_Controls->sliceNavigatorTime->setEnabled(false);
m_Controls->leImage1->setText("Select an Image in Data Manager");
m_Controls->tlWhat1->setEnabled(false);
m_Controls->cbWhat1->setEnabled(false);
m_Controls->tlWhat2->setEnabled(false);
m_Controls->cbWhat2->setEnabled(false);
m_SelectedImageNode->RemoveAllNodes();
//get the selected Node
mitk::DataNode* _DataNode = nodes.front();
*m_SelectedImageNode = _DataNode;
//try to cast to image
mitk::Image::Pointer tempImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
//no image
if( tempImage.IsNull() || (tempImage->IsInitialized() == false) )
{
m_Controls->leImage1->setText("Not an image.");
return;
}
//2D image
if( tempImage->GetDimension() < 3)
{
m_Controls->leImage1->setText("2D images are not supported.");
return;
}
//image
m_Controls->leImage1->setText(QString(m_SelectedImageNode->GetNode()->GetName().c_str()));
// button coding
if ( tempImage->GetDimension() > 3 )
{
m_Controls->sliceNavigatorTime->setEnabled(true);
m_Controls->tlTime->setEnabled(true);
}
m_Controls->tlWhat1->setEnabled(true);
m_Controls->cbWhat1->setEnabled(true);
m_Controls->tlWhat2->setEnabled(true);
m_Controls->cbWhat2->setEnabled(true);
}
}
void QmitkBasicImageProcessing::ChangeGUI()
{
if(m_Controls->rBOneImOp->isChecked())
{
m_Controls->gbTwoImageOps->hide();
m_Controls->gbOneImageOps->show();
}
else if(m_Controls->rBTwoImOp->isChecked())
{
m_Controls->gbOneImageOps->hide();
m_Controls->gbTwoImageOps->show();
}
}
void QmitkBasicImageProcessing::ResetOneImageOpPanel()
{
m_Controls->tlParam1->setText("Param1");
m_Controls->tlParam2->setText("Param2");
m_Controls->cbWhat1->setCurrentIndex(0);
m_Controls->tlTime->setEnabled(false);
this->ResetParameterPanel();
m_Controls->btnDoIt->setEnabled(false);
m_Controls->cbHideOrig->setEnabled(false);
}
void QmitkBasicImageProcessing::ResetParameterPanel()
{
m_Controls->tlParam->setEnabled(false);
m_Controls->tlParam1->setEnabled(false);
m_Controls->tlParam2->setEnabled(false);
m_Controls->tlParam3->setEnabled(false);
m_Controls->tlParam4->setEnabled(false);
m_Controls->sbParam1->setEnabled(false);
m_Controls->sbParam2->setEnabled(false);
m_Controls->dsbParam1->setEnabled(false);
m_Controls->dsbParam2->setEnabled(false);
m_Controls->dsbParam3->setEnabled(false);
m_Controls->cbParam4->setEnabled(false);
m_Controls->sbParam1->setValue(0);
m_Controls->sbParam2->setValue(0);
m_Controls->dsbParam1->setValue(0);
m_Controls->dsbParam2->setValue(0);
m_Controls->dsbParam3->setValue(0);
m_Controls->sbParam1->show();
m_Controls->sbParam2->show();
m_Controls->dsbParam1->hide();
m_Controls->dsbParam2->hide();
m_Controls->dsbParam3->hide();
m_Controls->cbParam4->hide();
m_Controls->tlParam3->hide();
m_Controls->tlParam4->hide();
}
void QmitkBasicImageProcessing::ResetTwoImageOpPanel()
{
m_Controls->cbWhat2->setCurrentIndex(0);
m_Controls->tlImage2->setEnabled(false);
m_Controls->m_ImageSelector2->setEnabled(false);
m_Controls->btnDoIt2->setEnabled(false);
}
void QmitkBasicImageProcessing::SelectAction(int action)
{
if ( ! m_SelectedImageNode->GetNode() ) return;
// Prepare GUI
this->ResetParameterPanel();
m_Controls->btnDoIt->setEnabled(false);
m_Controls->cbHideOrig->setEnabled(false);
QString text1 = "No Parameters";
QString text2 = "No Parameters";
QString text3 = "No Parameters";
QString text4 = "No Parameters";
if (action != 19)
{
m_Controls->dsbParam1->hide();
m_Controls->dsbParam2->hide();
m_Controls->dsbParam3->hide();
m_Controls->tlParam3->hide();
m_Controls->tlParam4->hide();
m_Controls->sbParam1->show();
m_Controls->sbParam2->show();
m_Controls->cbParam4->hide();
}
// check which operation the user has selected and set parameters and GUI accordingly
switch (action)
{
case 2:
{
m_SelectedAction = GAUSSIAN;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
text1 = "&Variance:";
m_Controls->sbParam1->setMinimum( 0 );
m_Controls->sbParam1->setMaximum( 200 );
m_Controls->sbParam1->setValue( 2 );
break;
}
case 3:
{
m_SelectedAction = MEDIAN;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
text1 = "&Radius:";
m_Controls->sbParam1->setMinimum( 0 );
m_Controls->sbParam1->setMaximum( 200 );
m_Controls->sbParam1->setValue( 3 );
break;
}
case 4:
{
m_SelectedAction = TOTALVARIATION;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
m_Controls->tlParam2->setEnabled(true);
m_Controls->sbParam2->setEnabled(true);
text1 = "Number Iterations:";
text2 = "Regularization\n(Lambda/1000):";
m_Controls->sbParam1->setMinimum( 1 );
m_Controls->sbParam1->setMaximum( 1000 );
m_Controls->sbParam1->setValue( 40 );
m_Controls->sbParam2->setMinimum( 0 );
m_Controls->sbParam2->setMaximum( 100000 );
m_Controls->sbParam2->setValue( 1 );
break;
}
case 6:
{
m_SelectedAction = DILATION;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
text1 = "&Radius:";
m_Controls->sbParam1->setMinimum( 0 );
m_Controls->sbParam1->setMaximum( 200 );
m_Controls->sbParam1->setValue( 3 );
break;
}
case 7:
{
m_SelectedAction = EROSION;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
text1 = "&Radius:";
m_Controls->sbParam1->setMinimum( 0 );
m_Controls->sbParam1->setMaximum( 200 );
m_Controls->sbParam1->setValue( 3 );
break;
}
case 8:
{
m_SelectedAction = OPENING;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
text1 = "&Radius:";
m_Controls->sbParam1->setMinimum( 0 );
m_Controls->sbParam1->setMaximum( 200 );
m_Controls->sbParam1->setValue( 3 );
break;
}
case 9:
{
m_SelectedAction = CLOSING;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
text1 = "&Radius:";
m_Controls->sbParam1->setMinimum( 0 );
m_Controls->sbParam1->setMaximum( 200 );
m_Controls->sbParam1->setValue( 3 );
break;
}
case 11:
{
m_SelectedAction = GRADIENT;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
text1 = "Sigma of Gaussian Kernel:\n(in Image Spacing Units)";
m_Controls->sbParam1->setMinimum( 0 );
m_Controls->sbParam1->setMaximum( 200 );
m_Controls->sbParam1->setValue( 2 );
break;
}
case 12:
{
m_SelectedAction = LAPLACIAN;
break;
}
case 13:
{
m_SelectedAction = SOBEL;
break;
}
case 15:
{
m_SelectedAction = THRESHOLD;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
m_Controls->tlParam2->setEnabled(true);
m_Controls->sbParam2->setEnabled(true);
text1 = "Lower threshold:";
text2 = "Upper threshold:";
m_Controls->sbParam1->setMinimum( -100000 );
m_Controls->sbParam1->setMaximum( 100000 );
m_Controls->sbParam1->setValue( 0 );
m_Controls->sbParam2->setMinimum( -100000 );
m_Controls->sbParam2->setMaximum( 100000 );
m_Controls->sbParam2->setValue( 300 );
break;
}
case 16:
{
m_SelectedAction = INVERSION;
break;
}
case 17:
{
m_SelectedAction = DOWNSAMPLING;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
text1 = "Downsampling by Factor:";
m_Controls->sbParam1->setMinimum( 1 );
m_Controls->sbParam1->setMaximum( 100 );
m_Controls->sbParam1->setValue( 2 );
break;
}
case 18:
{
m_SelectedAction = FLIPPING;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(true);
text1 = "Flip across axis:";
m_Controls->sbParam1->setMinimum( 0 );
m_Controls->sbParam1->setMaximum( 2 );
m_Controls->sbParam1->setValue( 1 );
break;
}
case 19:
{
m_SelectedAction = RESAMPLING;
m_Controls->tlParam1->setEnabled(true);
m_Controls->sbParam1->setEnabled(false);
m_Controls->sbParam1->hide();
m_Controls->dsbParam1->show();
m_Controls->dsbParam1->setEnabled(true);
m_Controls->tlParam2->setEnabled(true);
m_Controls->sbParam2->setEnabled(false);
m_Controls->sbParam2->hide();
m_Controls->dsbParam2->show();
m_Controls->dsbParam2->setEnabled(true);
m_Controls->tlParam3->show();
m_Controls->tlParam3->setEnabled(true);
m_Controls->dsbParam3->show();
m_Controls->dsbParam3->setEnabled(true);
m_Controls->tlParam4->show();
m_Controls->tlParam4->setEnabled(true);
m_Controls->cbParam4->show();
m_Controls->cbParam4->setEnabled(true);
m_Controls->dsbParam1->setMinimum(0.01);
m_Controls->dsbParam1->setMaximum(10.0);
m_Controls->dsbParam1->setSingleStep(0.1);
m_Controls->dsbParam1->setValue(0.3);
m_Controls->dsbParam2->setMinimum(0.01);
m_Controls->dsbParam2->setMaximum(10.0);
m_Controls->dsbParam2->setSingleStep(0.1);
m_Controls->dsbParam2->setValue(0.3);
m_Controls->dsbParam3->setMinimum(0.01);
m_Controls->dsbParam3->setMaximum(10.0);
m_Controls->dsbParam3->setSingleStep(0.1);
m_Controls->dsbParam3->setValue(1.5);
text1 = "x-spacing:";
text2 = "y-spacing:";
text3 = "z-spacing:";
text4 = "Interplation:";
break;
}
default: return;
}
m_Controls->tlParam->setEnabled(true);
m_Controls->tlParam1->setText(text1);
m_Controls->tlParam2->setText(text2);
m_Controls->tlParam3->setText(text3);
m_Controls->tlParam4->setText(text4);
m_Controls->btnDoIt->setEnabled(true);
m_Controls->cbHideOrig->setEnabled(true);
}
void QmitkBasicImageProcessing::StartButtonClicked()
{
if(!m_SelectedImageNode->GetNode()) return;
this->BusyCursorOn();
mitk::Image::Pointer newImage;
try
{
newImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
}
catch ( std::exception &e )
{
QString exceptionString = "An error occured during image loading:\n";
exceptionString.append( e.what() );
QMessageBox::warning( NULL, "Basic Image Processing", exceptionString , QMessageBox::Ok, QMessageBox::NoButton );
this->BusyCursorOff();
return;
}
// check if input image is valid, casting does not throw exception when casting from 'NULL-Object'
if ( (! newImage) || (newImage->IsInitialized() == false) )
{
this->BusyCursorOff();
QMessageBox::warning( NULL, "Basic Image Processing", "Input image is broken or not initialized. Returning.", QMessageBox::Ok, QMessageBox::NoButton );
return;
}
// check if operation is done on 4D a image time step
if(newImage->GetDimension() > 3)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(newImage);
timeSelector->SetTimeNr( ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos() );
timeSelector->Update();
newImage = timeSelector->GetOutput();
}
// check if image or vector image
ImageType::Pointer itkImage = ImageType::New();
VectorImageType::Pointer itkVecImage = VectorImageType::New();
int isVectorImage = newImage->GetPixelType().GetNumberOfComponents();
if(isVectorImage > 1)
{
CastToItkImage( newImage, itkVecImage );
}
else
{
CastToItkImage( newImage, itkImage );
}
std::stringstream nameAddition("");
int param1 = m_Controls->sbParam1->value();
int param2 = m_Controls->sbParam2->value();
double dparam1 = m_Controls->dsbParam1->value();
double dparam2 = m_Controls->dsbParam2->value();
double dparam3 = m_Controls->dsbParam3->value();
try{
switch (m_SelectedAction)
{
case GAUSSIAN:
{
GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
gaussianFilter->SetInput( itkImage );
gaussianFilter->SetVariance( param1 );
gaussianFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(gaussianFilter->GetOutput());
+ newImage = mitk::ImportItkImage(gaussianFilter->GetOutput())->Clone();
nameAddition << "_Gaussian_var_" << param1;
std::cout << "Gaussian filtering successful." << std::endl;
break;
}
case MEDIAN:
{
MedianFilterType::Pointer medianFilter = MedianFilterType::New();
MedianFilterType::InputSizeType size;
size.Fill(param1);
medianFilter->SetRadius( size );
medianFilter->SetInput(itkImage);
medianFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(medianFilter->GetOutput());
+ newImage = mitk::ImportItkImage(medianFilter->GetOutput())->Clone();
nameAddition << "_Median_radius_" << param1;
std::cout << "Median Filtering successful." << std::endl;
break;
}
case TOTALVARIATION:
{
if(isVectorImage > 1)
{
VectorTotalVariationFilterType::Pointer TVFilter
= VectorTotalVariationFilterType::New();
TVFilter->SetInput( itkVecImage.GetPointer() );
TVFilter->SetNumberIterations(param1);
TVFilter->SetLambda(double(param2)/1000.);
TVFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(TVFilter->GetOutput());
+ newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
}
else
{
FloatImageType::Pointer fImage = FloatImageType::New();
CastToItkImage( newImage, fImage );
TotalVariationFilterType::Pointer TVFilter
= TotalVariationFilterType::New();
TVFilter->SetInput( fImage.GetPointer() );
TVFilter->SetNumberIterations(param1);
TVFilter->SetLambda(double(param2)/1000.);
TVFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(TVFilter->GetOutput());
+ newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
}
nameAddition << "_TV_Iter_" << param1 << "_L_" << param2;
std::cout << "Total Variation Filtering successful." << std::endl;
break;
}
case DILATION:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
DilationFilterType::Pointer dilationFilter = DilationFilterType::New();
dilationFilter->SetInput( itkImage );
dilationFilter->SetKernel( binaryBall );
dilationFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(dilationFilter->GetOutput());
+ newImage = mitk::ImportItkImage(dilationFilter->GetOutput())->Clone();
nameAddition << "_Dilated_by_" << param1;
std::cout << "Dilation successful." << std::endl;
break;
}
case EROSION:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
ErosionFilterType::Pointer erosionFilter = ErosionFilterType::New();
erosionFilter->SetInput( itkImage );
erosionFilter->SetKernel( binaryBall );
erosionFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(erosionFilter->GetOutput());
+ newImage = mitk::ImportItkImage(erosionFilter->GetOutput())->Clone();
nameAddition << "_Eroded_by_" << param1;
std::cout << "Erosion successful." << std::endl;
break;
}
case OPENING:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
OpeningFilterType::Pointer openFilter = OpeningFilterType::New();
openFilter->SetInput( itkImage );
openFilter->SetKernel( binaryBall );
openFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(openFilter->GetOutput());
+ newImage = mitk::ImportItkImage(openFilter->GetOutput())->Clone();
nameAddition << "_Opened_by_" << param1;
std::cout << "Opening successful." << std::endl;
break;
}
case CLOSING:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
ClosingFilterType::Pointer closeFilter = ClosingFilterType::New();
closeFilter->SetInput( itkImage );
closeFilter->SetKernel( binaryBall );
closeFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(closeFilter->GetOutput());
+ newImage = mitk::ImportItkImage(closeFilter->GetOutput())->Clone();
nameAddition << "_Closed_by_" << param1;
std::cout << "Closing successful." << std::endl;
break;
}
case GRADIENT:
{
GradientFilterType::Pointer gradientFilter = GradientFilterType::New();
gradientFilter->SetInput( itkImage );
gradientFilter->SetSigma( param1 );
gradientFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(gradientFilter->GetOutput());
+ newImage = mitk::ImportItkImage(gradientFilter->GetOutput())->Clone();
nameAddition << "_Gradient_sigma_" << param1;
std::cout << "Gradient calculation successful." << std::endl;
break;
}
case LAPLACIAN:
{
// the laplace filter requires a float type image as input, we need to cast the itkImage
// to correct type
ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
caster->SetInput( itkImage );
caster->Update();
FloatImageType::Pointer fImage = caster->GetOutput();
LaplacianFilterType::Pointer laplacianFilter = LaplacianFilterType::New();
laplacianFilter->SetInput( fImage );
laplacianFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(laplacianFilter->GetOutput());
+ newImage = mitk::ImportItkImage(laplacianFilter->GetOutput())->Clone();
nameAddition << "_Second_Derivative";
std::cout << "Laplacian filtering successful." << std::endl;
break;
}
case SOBEL:
{
// the sobel filter requires a float type image as input, we need to cast the itkImage
// to correct type
ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
caster->SetInput( itkImage );
caster->Update();
FloatImageType::Pointer fImage = caster->GetOutput();
SobelFilterType::Pointer sobelFilter = SobelFilterType::New();
sobelFilter->SetInput( fImage );
sobelFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(sobelFilter->GetOutput());
+ newImage = mitk::ImportItkImage(sobelFilter->GetOutput())->Clone();
nameAddition << "_Sobel";
std::cout << "Edge Detection successful." << std::endl;
break;
}
case THRESHOLD:
{
ThresholdFilterType::Pointer thFilter = ThresholdFilterType::New();
thFilter->SetLowerThreshold(param1 < param2 ? param1 : param2);
thFilter->SetUpperThreshold(param2 > param1 ? param2 : param1);
thFilter->SetInsideValue(1);
thFilter->SetOutsideValue(0);
thFilter->SetInput(itkImage);
thFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(thFilter->GetOutput());
+ newImage = mitk::ImportItkImage(thFilter->GetOutput())->Clone();
nameAddition << "_Threshold";
std::cout << "Thresholding successful." << std::endl;
break;
}
case INVERSION:
{
InversionFilterType::Pointer invFilter = InversionFilterType::New();
mitk::ScalarType min = newImage->GetScalarValueMin();
mitk::ScalarType max = newImage->GetScalarValueMax();
invFilter->SetMaximum( max + min );
invFilter->SetInput(itkImage);
invFilter->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(invFilter->GetOutput());
+ newImage = mitk::ImportItkImage(invFilter->GetOutput())->Clone();
nameAddition << "_Inverted";
std::cout << "Image inversion successful." << std::endl;
break;
}
case DOWNSAMPLING:
{
ResampleImageFilterType::Pointer downsampler = ResampleImageFilterType::New();
downsampler->SetInput( itkImage );
NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
downsampler->SetInterpolator( interpolator );
downsampler->SetDefaultPixelValue( 0 );
ResampleImageFilterType::SpacingType spacing = itkImage->GetSpacing();
spacing *= (double) param1;
downsampler->SetOutputSpacing( spacing );
downsampler->SetOutputOrigin( itkImage->GetOrigin() );
downsampler->SetOutputDirection( itkImage->GetDirection() );
ResampleImageFilterType::SizeType size = itkImage->GetLargestPossibleRegion().GetSize();
for ( int i = 0; i < 3; ++i )
{
size[i] /= param1;
}
downsampler->SetSize( size );
downsampler->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(downsampler->GetOutput());
+ newImage = mitk::ImportItkImage(downsampler->GetOutput())->Clone();
nameAddition << "_Downsampled_by_" << param1;
std::cout << "Downsampling successful." << std::endl;
break;
}
case FLIPPING:
{
FlipImageFilterType::Pointer flipper = FlipImageFilterType::New();
flipper->SetInput( itkImage );
itk::FixedArray<bool, 3> flipAxes;
for(int i=0; i<3; ++i)
{
if(i == param1)
{
flipAxes[i] = true;
}
else
{
flipAxes[i] = false;
}
}
flipper->SetFlipAxes(flipAxes);
flipper->UpdateLargestPossibleRegion();
- newImage = mitk::ImportItkImage(flipper->GetOutput());
+ newImage = mitk::ImportItkImage(flipper->GetOutput())->Clone();
std::cout << "Image flipping successful." << std::endl;
break;
}
case RESAMPLING:
{
std::string selectedInterpolator;
ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New();
switch (m_SelectedInterpolation)
{
case LINEAR:
{
LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
resampler->SetInterpolator(interpolator);
selectedInterpolator = "Linear";
break;
}
case NEAREST:
{
NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
resampler->SetInterpolator(interpolator);
selectedInterpolator = "Nearest";
break;
}
default:
{
LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
resampler->SetInterpolator(interpolator);
selectedInterpolator = "Linear";
break;
}
}
resampler->SetInput( itkImage );
resampler->SetOutputOrigin( itkImage->GetOrigin() );
ImageType::SizeType input_size = itkImage->GetLargestPossibleRegion().GetSize();
ImageType::SpacingType input_spacing = itkImage->GetSpacing();
ImageType::SizeType output_size;
ImageType::SpacingType output_spacing;
output_size[0] = input_size[0] * (input_spacing[0] / dparam1);
output_size[1] = input_size[1] * (input_spacing[1] / dparam2);
output_size[2] = input_size[2] * (input_spacing[2] / dparam3);
output_spacing [0] = dparam1;
output_spacing [1] = dparam2;
output_spacing [2] = dparam3;
resampler->SetSize( output_size );
resampler->SetOutputSpacing( output_spacing );
resampler->SetOutputDirection( itkImage->GetDirection() );
resampler->UpdateLargestPossibleRegion();
ImageType::Pointer resampledImage = resampler->GetOutput();
newImage = mitk::ImportItkImage( resampledImage );
nameAddition << "_Resampled_" << selectedInterpolator;
std::cout << "Resampling successful." << std::endl;
break;
}
default:
this->BusyCursorOff();
return;
}
}
catch (...)
{
this->BusyCursorOff();
QMessageBox::warning(NULL, "Warning", "Problem when applying filter operation. Check your input...");
return;
}
newImage->DisconnectPipeline();
// adjust level/window to new image
mitk::LevelWindow levelwindow;
levelwindow.SetAuto( newImage );
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
levWinProp->SetLevelWindow( levelwindow );
// compose new image name
std::string name = m_SelectedImageNode->GetNode()->GetName();
if (name.find(".pic.gz") == name.size() -7 )
{
name = name.substr(0,name.size() -7);
}
name.append( nameAddition.str() );
// create final result MITK data storage node
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetProperty( "levelwindow", levWinProp );
result->SetProperty( "name", mitk::StringProperty::New( name.c_str() ) );
result->SetData( newImage );
// for vector images, a different mapper is needed
if(isVectorImage > 1)
{
mitk::VectorImageMapper2D::Pointer mapper =
mitk::VectorImageMapper2D::New();
result->SetMapper(1,mapper);
}
// reset GUI to ease further processing
// this->ResetOneImageOpPanel();
// add new image to data storage and set as active to ease further processing
GetDefaultDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
if ( m_Controls->cbHideOrig->isChecked() == true )
m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
// TODO!! m_Controls->m_ImageSelector1->SetSelectedNode(result);
// show the results
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->BusyCursorOff();
}
void QmitkBasicImageProcessing::SelectAction2(int operation)
{
// check which operation the user has selected and set parameters and GUI accordingly
switch (operation)
{
case 2:
m_SelectedOperation = ADD;
break;
case 3:
m_SelectedOperation = SUBTRACT;
break;
case 4:
m_SelectedOperation = MULTIPLY;
break;
case 5:
m_SelectedOperation = DIVIDE;
break;
case 6:
m_SelectedOperation = RESAMPLE_TO;
break;
case 8:
m_SelectedOperation = AND;
break;
case 9:
m_SelectedOperation = OR;
break;
case 10:
m_SelectedOperation = XOR;
break;
default:
// this->ResetTwoImageOpPanel();
return;
}
m_Controls->tlImage2->setEnabled(true);
m_Controls->m_ImageSelector2->setEnabled(true);
m_Controls->btnDoIt2->setEnabled(true);
}
void QmitkBasicImageProcessing::StartButton2Clicked()
{
mitk::Image::Pointer newImage1 = dynamic_cast<mitk::Image*>
(m_SelectedImageNode->GetNode()->GetData());
mitk::Image::Pointer newImage2 = dynamic_cast<mitk::Image*>
(m_Controls->m_ImageSelector2->GetSelectedNode()->GetData());
// check if images are valid
if( (!newImage1) || (!newImage2) || (newImage1->IsInitialized() == false) || (newImage2->IsInitialized() == false) )
{
itkGenericExceptionMacro(<< "At least one of the input images are broken or not initialized. Returning");
return;
}
this->BusyCursorOn();
// this->ResetTwoImageOpPanel();
// check if 4D image and use filter on correct time step
int time = ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos();
if(time>=0)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(newImage1);
timeSelector->SetTimeNr( time );
timeSelector->UpdateLargestPossibleRegion();
newImage1 = timeSelector->GetOutput();
newImage1->DisconnectPipeline();
timeSelector->SetInput(newImage2);
timeSelector->SetTimeNr( time );
timeSelector->UpdateLargestPossibleRegion();
newImage2 = timeSelector->GetOutput();
newImage2->DisconnectPipeline();
}
// reset GUI for better usability
// this->ResetTwoImageOpPanel();
ImageType::Pointer itkImage1 = ImageType::New();
ImageType::Pointer itkImage2 = ImageType::New();
CastToItkImage( newImage1, itkImage1 );
CastToItkImage( newImage2, itkImage2 );
// Remove temp image
newImage2 = NULL;
std::string nameAddition = "";
try
{
switch (m_SelectedOperation)
{
case ADD:
{
AddFilterType::Pointer addFilter = AddFilterType::New();
addFilter->SetInput1( itkImage1 );
addFilter->SetInput2( itkImage2 );
addFilter->UpdateLargestPossibleRegion();
- newImage1 = mitk::ImportItkImage(addFilter->GetOutput());
+ newImage1 = mitk::ImportItkImage(addFilter->GetOutput())->Clone();
nameAddition = "_Added";
}
break;
case SUBTRACT:
{
SubtractFilterType::Pointer subFilter = SubtractFilterType::New();
subFilter->SetInput1( itkImage1 );
subFilter->SetInput2( itkImage2 );
subFilter->UpdateLargestPossibleRegion();
- newImage1 = mitk::ImportItkImage(subFilter->GetOutput());
+ newImage1 = mitk::ImportItkImage(subFilter->GetOutput())->Clone();
nameAddition = "_Subtracted";
}
break;
case MULTIPLY:
{
MultiplyFilterType::Pointer multFilter = MultiplyFilterType::New();
multFilter->SetInput1( itkImage1 );
multFilter->SetInput2( itkImage2 );
multFilter->UpdateLargestPossibleRegion();
- newImage1 = mitk::ImportItkImage(multFilter->GetOutput());
+ newImage1 = mitk::ImportItkImage(multFilter->GetOutput())->Clone();
nameAddition = "_Multiplied";
}
break;
case DIVIDE:
{
DivideFilterType::Pointer divFilter = DivideFilterType::New();
divFilter->SetInput1( itkImage1 );
divFilter->SetInput2( itkImage2 );
divFilter->UpdateLargestPossibleRegion();
- newImage1 = mitk::ImportItkImage<FloatImageType>(divFilter->GetOutput());
+ newImage1 = mitk::ImportItkImage<FloatImageType>(divFilter->GetOutput())->Clone();
nameAddition = "_Divided";
}
break;
case AND:
{
AndImageFilterType::Pointer andFilter = AndImageFilterType::New();
andFilter->SetInput1( itkImage1 );
andFilter->SetInput2( itkImage2 );
andFilter->UpdateLargestPossibleRegion();
- newImage1 = mitk::ImportItkImage(andFilter->GetOutput());
+ newImage1 = mitk::ImportItkImage(andFilter->GetOutput())->Clone();
nameAddition = "_AND";
break;
}
case OR:
{
OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
orFilter->SetInput1( itkImage1 );
orFilter->SetInput2( itkImage2 );
orFilter->UpdateLargestPossibleRegion();
- newImage1 = mitk::ImportItkImage(orFilter->GetOutput());
+ newImage1 = mitk::ImportItkImage(orFilter->GetOutput())->Clone();
nameAddition = "_OR";
break;
}
case XOR:
{
XorImageFilterType::Pointer xorFilter = XorImageFilterType::New();
xorFilter->SetInput1( itkImage1 );
xorFilter->SetInput2( itkImage2 );
xorFilter->UpdateLargestPossibleRegion();
- newImage1 = mitk::ImportItkImage(xorFilter->GetOutput());
+ newImage1 = mitk::ImportItkImage(xorFilter->GetOutput())->Clone();
nameAddition = "_XOR";
break;
}
case RESAMPLE_TO:
{
itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer nn_interpolator
= itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
ResampleImageFilterType2::Pointer resampleFilter = ResampleImageFilterType2::New();
resampleFilter->SetInput( itkImage1 );
resampleFilter->SetReferenceImage( itkImage2 );
resampleFilter->SetUseReferenceImage( true );
resampleFilter->SetInterpolator( nn_interpolator );
resampleFilter->SetDefaultPixelValue( 0 );
- ImageType::Pointer resampledImage = resampleFilter->GetOutput();
+ ImageType::Pointer resampledImage = resampleFilter->GetOutput()->Clone();
try
{
resampleFilter->UpdateLargestPossibleRegion();
}
catch( const itk::ExceptionObject &e)
{
MITK_WARN << "Updating resampling filter failed. ";
MITK_WARN << "REASON: " << e.what();
}
- newImage1 = mitk::ImportItkImage( resampledImage );
+ newImage1 = mitk::ImportItkImage( resampledImage )->Clone();
nameAddition = "_Resampled";
break;
}
default:
std::cout << "Something went wrong..." << std::endl;
this->BusyCursorOff();
return;
}
}
catch (const itk::ExceptionObject& e )
{
this->BusyCursorOff();
QMessageBox::warning(NULL, "ITK Exception", e.what() );
QMessageBox::warning(NULL, "Warning", "Problem when applying arithmetic operation to two images. Check dimensions of input images.");
return;
}
// disconnect pipeline; images will not be reused
newImage1->DisconnectPipeline();
itkImage1 = NULL;
itkImage2 = NULL;
// adjust level/window to new image and compose new image name
mitk::LevelWindow levelwindow;
levelwindow.SetAuto( newImage1 );
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
levWinProp->SetLevelWindow( levelwindow );
std::string name = m_SelectedImageNode->GetNode()->GetName();
if (name.find(".pic.gz") == name.size() -7 )
{
name = name.substr(0,name.size() -7);
}
// create final result MITK data storage node
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetProperty( "levelwindow", levWinProp );
result->SetProperty( "name", mitk::StringProperty::New( (name + nameAddition ).c_str() ));
result->SetData( newImage1 );
GetDefaultDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
// show only the newly created image
m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
m_Controls->m_ImageSelector2->GetSelectedNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
// show the newly created image
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->BusyCursorOff();
}
void QmitkBasicImageProcessing::SelectInterpolator(int interpolator)
{
switch (interpolator)
{
case 0:
{
m_SelectedInterpolation = LINEAR;
break;
}
case 1:
{
m_SelectedInterpolation = NEAREST;
break;
}
}
}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/files.cmake b/Plugins/org.mitk.gui.qt.datamanager/files.cmake
index 9fdc79856e..c4a92460d6 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/files.cmake
+++ b/Plugins/org.mitk.gui.qt.datamanager/files.cmake
@@ -1,52 +1,43 @@
set(SRC_CPP_FILES
berrySingleNodeSelection.cpp
QmitkDataManagerView.cpp
QmitkDataManagerPreferencePage.cpp
QmitkDataManagerHotkeysPrefPage.cpp
)
set(INTERNAL_CPP_FILES
mitkPluginActivator.cpp
- QmitkLineEdit.cpp
QmitkPropertyListView.cpp
- QmitkPropertyTreeItem.cpp
- QmitkPropertyTreeFilterProxyModel.cpp
- QmitkPropertyTreeModel.cpp
- QmitkPropertyTreeView.cpp
QmitkNodeTableViewKeyFilter.cpp
QmitkInfoDialog.cpp
)
set(MOC_H_FILES
src/QmitkDataManagerView.h
src/QmitkDataManagerPreferencePage.h
src/QmitkDataManagerHotkeysPrefPage.h
- src/internal/QmitkLineEdit.h
src/internal/QmitkNodeTableViewKeyFilter.h
src/internal/QmitkPropertyListView.h
- src/internal/QmitkPropertyTreeFilterProxyModel.h
- src/internal/QmitkPropertyTreeModel.h
- src/internal/QmitkPropertyTreeView.h
src/internal/QmitkInfoDialog.h
src/internal/mitkPluginActivator.h
)
set(CPP_FILES )
set(CACHED_RESOURCE_FILES
plugin.xml
resources/DataManager_48.png
resources/propertylist.png
)
set(QRC_FILES
resources/datamanager.qrc
)
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/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerPreferencePage.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerPreferencePage.cpp
index 30a48891bd..b4f8ae1be8 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerPreferencePage.cpp
@@ -1,97 +1,102 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkDataManagerPreferencePage.h"
#include "QmitkDataManagerView.h"
#include <QLabel>
#include <QPushButton>
#include <QFormLayout>
#include <QCheckBox>
#include <berryIPreferencesService.h>
#include <berryPlatform.h>
QmitkDataManagerPreferencePage::QmitkDataManagerPreferencePage()
: m_MainControl(0)
{
}
void QmitkDataManagerPreferencePage::Init(berry::IWorkbench::Pointer )
{
}
void QmitkDataManagerPreferencePage::CreateQtControl(QWidget* parent)
{
berry::IPreferencesService::Pointer prefService
= berry::Platform::GetServiceRegistry()
.GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
m_DataManagerPreferencesNode = prefService->GetSystemPreferences()->Node(QmitkDataManagerView::VIEW_ID);
m_MainControl = new QWidget(parent);
m_EnableSingleEditing = new QCheckBox;
m_PlaceNewNodesOnTop = new QCheckBox;
m_ShowHelperObjects = new QCheckBox;
m_ShowNodesContainingNoData = new QCheckBox;
+ m_GlobalReinitOnNodeDelete = new QCheckBox;
m_UseSurfaceDecimation = new QCheckBox;
QFormLayout *formLayout = new QFormLayout;
formLayout->addRow("&Single click property editing:", m_EnableSingleEditing);
formLayout->addRow("&Place new nodes on top:", m_PlaceNewNodesOnTop);
formLayout->addRow("&Show helper objects:", m_ShowHelperObjects);
formLayout->addRow("&Show nodes containing no data", m_ShowNodesContainingNoData);
+ formLayout->addRow("&Call global reinit if node is deleted", m_GlobalReinitOnNodeDelete);
formLayout->addRow("&Use surface decimation:", m_UseSurfaceDecimation);
m_MainControl->setLayout(formLayout);
this->Update();
}
QWidget* QmitkDataManagerPreferencePage::GetQtControl() const
{
return m_MainControl;
}
bool QmitkDataManagerPreferencePage::PerformOk()
{
m_DataManagerPreferencesNode->PutBool("Single click property editing"
, m_EnableSingleEditing->isChecked());
m_DataManagerPreferencesNode->PutBool("Place new nodes on top"
, m_PlaceNewNodesOnTop->isChecked());
m_DataManagerPreferencesNode->PutBool("Show helper objects"
, m_ShowHelperObjects->isChecked());
m_DataManagerPreferencesNode->PutBool("Show nodes containing no data"
, m_ShowNodesContainingNoData->isChecked());
+ m_DataManagerPreferencesNode->PutBool("Call global reinit if node is deleted"
+ , m_GlobalReinitOnNodeDelete->isChecked());
m_DataManagerPreferencesNode->PutBool("Use surface decimation"
, m_UseSurfaceDecimation->isChecked());
return true;
}
void QmitkDataManagerPreferencePage::PerformCancel()
{
}
void QmitkDataManagerPreferencePage::Update()
{
m_EnableSingleEditing->setChecked(m_DataManagerPreferencesNode->GetBool("Single click property editing", true));
m_PlaceNewNodesOnTop->setChecked(m_DataManagerPreferencesNode->GetBool("Place new nodes on top", true));
m_ShowHelperObjects->setChecked(m_DataManagerPreferencesNode->GetBool("Show helper objects", false));
m_ShowNodesContainingNoData->setChecked(m_DataManagerPreferencesNode->GetBool("Show nodes containing no data", false));
m_UseSurfaceDecimation->setChecked(m_DataManagerPreferencesNode->GetBool("Use surface decimation", true));
+ m_GlobalReinitOnNodeDelete->setChecked(m_DataManagerPreferencesNode->GetBool("Call global reinit if node is deleted", true));
}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerPreferencePage.h b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerPreferencePage.h
index 41c1d47666..149b161c9f 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerPreferencePage.h
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerPreferencePage.h
@@ -1,67 +1,68 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QMITKDATAMANAGERPREFERENCEPAGE_H_
#define QMITKDATAMANAGERPREFERENCEPAGE_H_
#include "berryIQtPreferencePage.h"
#include <org_mitk_gui_qt_datamanager_Export.h>
#include <berryIPreferences.h>
class QWidget;
class QCheckBox;
struct MITK_QT_DATAMANAGER QmitkDataManagerPreferencePage : public QObject, public berry::IQtPreferencePage
{
Q_OBJECT
Q_INTERFACES(berry::IPreferencePage)
public:
QmitkDataManagerPreferencePage();
void Init(berry::IWorkbench::Pointer workbench);
void CreateQtControl(QWidget* widget);
QWidget* GetQtControl() const;
///
/// \see IPreferencePage::PerformOk()
///
virtual bool PerformOk();
///
/// \see IPreferencePage::PerformCancel()
///
virtual void PerformCancel();
///
/// \see IPreferencePage::Update()
///
virtual void Update();
protected:
QWidget* m_MainControl;
QCheckBox* m_EnableSingleEditing;
QCheckBox* m_PlaceNewNodesOnTop;
QCheckBox* m_ShowHelperObjects;
QCheckBox* m_ShowNodesContainingNoData;
+ QCheckBox* m_GlobalReinitOnNodeDelete;
QCheckBox* m_UseSurfaceDecimation;
berry::IPreferences::Pointer m_DataManagerPreferencesNode;
};
#endif /* QMITKDATAMANAGERPREFERENCEPAGE_H_ */
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
index 5c23ba5cb3..d3fba8ddec 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
@@ -1,942 +1,950 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkDataManagerView.h"
#include <itkOtsuThresholdImageFilter.h>
//# Own Includes
//## mitk
#include "mitkDataStorageEditorInput.h"
#include "mitkIDataStorageReference.h"
#include "mitkNodePredicateDataType.h"
#include "mitkCoreObjectFactory.h"
#include "mitkPACSPlugin.h"
#include "mitkDataNodeFactory.h"
#include "mitkColorProperty.h"
#include "mitkCommon.h"
#include "mitkDelegateManager.h"
#include "mitkNodePredicateData.h"
#include "mitkNodePredicateNot.h"
#include "mitkNodePredicateProperty.h"
#include "mitkEnumerationProperty.h"
#include "mitkProperties.h"
#include <mitkNodePredicateAnd.h>
#include <mitkITKImageImport.h>
#include <mitkIDataStorageService.h>
#include <mitkIRenderingManager.h>
//## Qmitk
#include <QmitkDnDFrameWidget.h>
#include <QmitkDataStorageTableModel.h>
#include <QmitkPropertiesTableEditor.h>
#include <QmitkCommonFunctionality.h>
#include <QmitkIOUtil.h>
#include <QmitkDataStorageTreeModel.h>
#include <QmitkCustomVariants.h>
#include "src/internal/QmitkNodeTableViewKeyFilter.h"
#include "src/internal/QmitkInfoDialog.h"
//## Berry
#include <berryIEditorPart.h>
#include <berryIWorkbenchPage.h>
#include <berryIPreferencesService.h>
#include <berryPlatform.h>
#include <berryPlatformUI.h>
#include <berryIEditorRegistry.h>
//# Toolkit Includes
#include <QTableView>
#include <QGroupBox>
#include <QGridLayout>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QLabel>
#include <QListView>
#include <QMenu>
#include <QAction>
#include <QComboBox>
#include <QApplication>
#include <QCursor>
#include <QHeaderView>
#include <QTreeView>
#include <QWidgetAction>
#include <QSplitter>
#include <QPushButton>
#include <QMotifStyle>
#include <QFileDialog>
#include <QMessageBox>
#include <QToolBar>
#include <QKeyEvent>
#include <QColor>
#include <QColorDialog>
#include <QSizePolicy>
#include <QSignalMapper>
#include "mitkDataNodeObject.h"
#include "mitkIContextMenuAction.h"
#include "berryIExtensionPointService.h"
const std::string QmitkDataManagerView::VIEW_ID = "org.mitk.views.datamanager";
QmitkDataManagerView::QmitkDataManagerView()
+ : m_GlobalReinitOnNodeDelete(true)
{
}
QmitkDataManagerView::~QmitkDataManagerView()
{
//Remove all registered actions from each descriptor
for (std::vector< std::pair< QmitkNodeDescriptor*, QAction* > >::iterator it = m_DescriptorActionList.begin();it != m_DescriptorActionList.end(); it++)
{
// first== the NodeDescriptor; second== the registered QAction
(it->first)->RemoveAction(it->second);
}
}
void QmitkDataManagerView::CreateQtPartControl(QWidget* parent)
{
m_CurrentRowCount = 0;
m_Parent = parent;
//# Preferences
berry::IPreferencesService::Pointer prefService
= berry::Platform::GetServiceRegistry()
.GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
berry::IBerryPreferences::Pointer prefs
= (prefService->GetSystemPreferences()->Node(VIEW_ID))
.Cast<berry::IBerryPreferences>();
assert( prefs );
prefs->OnChanged.AddListener( berry::MessageDelegate1<QmitkDataManagerView
, const berry::IBerryPreferences*>( this
, &QmitkDataManagerView::OnPreferencesChanged ) );
//# GUI
m_NodeTreeModel = new QmitkDataStorageTreeModel(this->GetDataStorage());
m_NodeTreeModel->setParent( parent );
m_NodeTreeModel->SetPlaceNewNodesOnTop(
prefs->GetBool("Place new nodes on top", true) );
m_NodeTreeModel->SetShowHelperObjects(
prefs->GetBool("Show helper objects", false) );
m_NodeTreeModel->SetShowNodesContainingNoData(
prefs->GetBool("Show nodes containing no data", false) );
m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
//# Tree View (experimental)
m_NodeTreeView = new QTreeView;
m_NodeTreeView->setSelectionMode( QAbstractItemView::ExtendedSelection );
m_NodeTreeView->setSelectionBehavior( QAbstractItemView::SelectRows );
m_NodeTreeView->setAlternatingRowColors(true);
m_NodeTreeView->setDragEnabled(true);
m_NodeTreeView->setDropIndicatorShown(true);
m_NodeTreeView->setAcceptDrops(true);
m_NodeTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
m_NodeTreeView->setModel(m_NodeTreeModel);
m_NodeTreeView->setTextElideMode(Qt::ElideMiddle);
m_NodeTreeView->installEventFilter(new QmitkNodeTableViewKeyFilter(this));
QObject::connect( m_NodeTreeView, SIGNAL(customContextMenuRequested(const QPoint&))
, this, SLOT(NodeTableViewContextMenuRequested(const QPoint&)) );
QObject::connect( m_NodeTreeModel, SIGNAL(rowsInserted (const QModelIndex&, int, int))
, this, SLOT(NodeTreeViewRowsInserted ( const QModelIndex&, int, int )) );
QObject::connect( m_NodeTreeModel, SIGNAL(rowsRemoved (const QModelIndex&, int, int))
, this, SLOT(NodeTreeViewRowsRemoved( const QModelIndex&, int, int )) );
QObject::connect( m_NodeTreeView->selectionModel()
, SIGNAL( selectionChanged ( const QItemSelection &, const QItemSelection & ) )
, this
, SLOT( NodeSelectionChanged ( const QItemSelection &, const QItemSelection & ) ) );
//# m_NodeMenu
m_NodeMenu = new QMenu(m_NodeTreeView);
// # Actions
berry::IEditorRegistry* editorRegistry = berry::PlatformUI::GetWorkbench()->GetEditorRegistry();
std::list<berry::IEditorDescriptor::Pointer> editors = editorRegistry->GetEditors("*.mitk");
if (editors.size() > 1)
{
m_ShowInMapper = new QSignalMapper(this);
foreach(berry::IEditorDescriptor::Pointer descriptor, editors)
{
QAction* action = new QAction(QString::fromStdString(descriptor->GetLabel()), this);
m_ShowInActions << action;
m_ShowInMapper->connect(action, SIGNAL(triggered()), m_ShowInMapper, SLOT(map()));
m_ShowInMapper->setMapping(action, QString::fromStdString(descriptor->GetId()));
}
connect(m_ShowInMapper, SIGNAL(mapped(QString)), this, SLOT(ShowIn(QString)));
}
QmitkNodeDescriptor* unknownDataNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetUnknownDataNodeDescriptor();
QmitkNodeDescriptor* imageDataNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Image");
QmitkNodeDescriptor* surfaceDataNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Surface");
QAction* globalReinitAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"), "Global Reinit", this);
QObject::connect( globalReinitAction, SIGNAL( triggered(bool) )
, this, SLOT( GlobalReinit(bool) ) );
unknownDataNodeDescriptor->AddAction(globalReinitAction);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor, globalReinitAction));
QAction* saveAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Save_48.png"), "Save...", this);
QObject::connect( saveAction, SIGNAL( triggered(bool) )
, this, SLOT( SaveSelectedNodes(bool) ) );
unknownDataNodeDescriptor->AddAction(saveAction);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,saveAction));
QAction* removeAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Remove_48.png"), "Remove", this);
QObject::connect( removeAction, SIGNAL( triggered(bool) )
, this, SLOT( RemoveSelectedNodes(bool) ) );
unknownDataNodeDescriptor->AddAction(removeAction);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,removeAction));
QAction* reinitAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"), "Reinit", this);
QObject::connect( reinitAction, SIGNAL( triggered(bool) )
, this, SLOT( ReinitSelectedNodes(bool) ) );
unknownDataNodeDescriptor->AddAction(reinitAction);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,reinitAction));
// find contextMenuAction extension points and add them to the node descriptor
berry::IExtensionPointService::Pointer extensionPointService = berry::Platform::GetExtensionPointService();
berry::IConfigurationElement::vector cmActions(
extensionPointService->GetConfigurationElementsFor("org.mitk.gui.qt.datamanager.contextMenuActions") );
berry::IConfigurationElement::vector::iterator cmActionsIt;
std::string cmNodeDescriptorName;
std::string cmLabel;
std::string cmIcon;
std::string cmClass;
QmitkNodeDescriptor* tmpDescriptor;
QAction* contextMenuAction;
QVariant cmActionDataIt;
m_ConfElements.clear();
int i=1;
for (cmActionsIt = cmActions.begin()
; cmActionsIt != cmActions.end()
; ++cmActionsIt)
{
cmIcon.erase();
if((*cmActionsIt)->GetAttribute("nodeDescriptorName", cmNodeDescriptorName)
&& (*cmActionsIt)->GetAttribute("label", cmLabel)
&& (*cmActionsIt)->GetAttribute("class", cmClass))
{
(*cmActionsIt)->GetAttribute("icon", cmIcon);
// create context menu entry here
tmpDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(QString::fromStdString(cmNodeDescriptorName));
if(!tmpDescriptor)
{
MITK_WARN << "cannot add action \"" << cmLabel << "\" because descriptor " << cmNodeDescriptorName << " does not exist";
continue;
}
contextMenuAction = new QAction( QString::fromStdString(cmLabel), parent);
tmpDescriptor->AddAction(contextMenuAction);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(tmpDescriptor,contextMenuAction));
m_ConfElements[contextMenuAction] = *cmActionsIt;
cmActionDataIt.setValue<int>(i);
contextMenuAction->setData( cmActionDataIt );
connect( contextMenuAction, SIGNAL( triggered(bool) ) , this, SLOT( ContextMenuActionTriggered(bool) ) );
++i;
}
}
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( OpacityChanged(int) ) );
QLabel* _OpacityLabel = new QLabel("Opacity: ");
QHBoxLayout* _OpacityWidgetLayout = new QHBoxLayout;
_OpacityWidgetLayout->setContentsMargins(4,4,4,4);
_OpacityWidgetLayout->addWidget(_OpacityLabel);
_OpacityWidgetLayout->addWidget(m_OpacitySlider);
QWidget* _OpacityWidget = new QWidget;
_OpacityWidget->setLayout(_OpacityWidgetLayout);
QWidgetAction* opacityAction = new QWidgetAction(this);
opacityAction ->setDefaultWidget(_OpacityWidget);
QObject::connect( opacityAction , SIGNAL( changed() )
, this, SLOT( OpacityActionChanged() ) );
unknownDataNodeDescriptor->AddAction(opacityAction , false);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,opacityAction));
m_ColorButton = new QPushButton;
m_ColorButton->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum);
//m_ColorButton->setText("Change color");
QObject::connect( m_ColorButton, SIGNAL( clicked() )
, this, SLOT( ColorChanged() ) );
QLabel* _ColorLabel = new QLabel("Color: ");
_ColorLabel->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
QHBoxLayout* _ColorWidgetLayout = new QHBoxLayout;
_ColorWidgetLayout->setContentsMargins(4,4,4,4);
_ColorWidgetLayout->addWidget(_ColorLabel);
_ColorWidgetLayout->addWidget(m_ColorButton);
QWidget* _ColorWidget = new QWidget;
_ColorWidget->setLayout(_ColorWidgetLayout);
QWidgetAction* colorAction = new QWidgetAction(this);
colorAction->setDefaultWidget(_ColorWidget);
QObject::connect( colorAction, SIGNAL( changed() )
, this, SLOT( ColorActionChanged() ) );
unknownDataNodeDescriptor->AddAction(colorAction, false);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,colorAction));
m_TextureInterpolation = new QAction("Texture Interpolation", this);
m_TextureInterpolation->setCheckable ( true );
QObject::connect( m_TextureInterpolation, SIGNAL( changed() )
, this, SLOT( TextureInterpolationChanged() ) );
QObject::connect( m_TextureInterpolation, SIGNAL( toggled(bool) )
, this, SLOT( TextureInterpolationToggled(bool) ) );
imageDataNodeDescriptor->AddAction(m_TextureInterpolation, false);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(imageDataNodeDescriptor,m_TextureInterpolation));
m_SurfaceRepresentation = new QAction("Surface Representation", this);
m_SurfaceRepresentation->setMenu(new QMenu);
QObject::connect( m_SurfaceRepresentation->menu(), SIGNAL( aboutToShow() )
, this, SLOT( SurfaceRepresentationMenuAboutToShow() ) );
surfaceDataNodeDescriptor->AddAction(m_SurfaceRepresentation, false);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(surfaceDataNodeDescriptor, m_SurfaceRepresentation));
QAction* showOnlySelectedNodes
= new QAction(QIcon(":/org.mitk.gui.qt.datamanager/ShowSelectedNode_48.png")
, "Show only selected nodes", this);
QObject::connect( showOnlySelectedNodes, SIGNAL( triggered(bool) )
, this, SLOT( ShowOnlySelectedNodes(bool) ) );
unknownDataNodeDescriptor->AddAction(showOnlySelectedNodes);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor, showOnlySelectedNodes));
QAction* toggleSelectedVisibility
= new QAction(QIcon(":/org.mitk.gui.qt.datamanager/InvertShowSelectedNode_48.png")
, "Toggle visibility", this);
QObject::connect( toggleSelectedVisibility, SIGNAL( triggered(bool) )
, this, SLOT( ToggleVisibilityOfSelectedNodes(bool) ) );
unknownDataNodeDescriptor->AddAction(toggleSelectedVisibility);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,toggleSelectedVisibility));
QAction* actionShowInfoDialog
= new QAction(QIcon(":/org.mitk.gui.qt.datamanager/ShowDataInfo_48.png")
, "Details...", this);
QObject::connect( actionShowInfoDialog, SIGNAL( triggered(bool) )
, this, SLOT( ShowInfoDialogForSelectedNodes(bool) ) );
unknownDataNodeDescriptor->AddAction(actionShowInfoDialog);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,actionShowInfoDialog));
//obsolete...
//QAction* otsuFilterAction = new QAction("Apply Otsu Filter", this);
//QObject::connect( otsuFilterAction, SIGNAL( triggered(bool) )
// , this, SLOT( OtsuFilter(bool) ) );
// //Otsu filter does not work properly, remove it temporarily
// imageDataNodeDescriptor->AddAction(otsuFilterAction);
// m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(imageDataNodeDescriptor,otsuFilterAction));
QGridLayout* _DndFrameWidgetLayout = new QGridLayout;
_DndFrameWidgetLayout->addWidget(m_NodeTreeView, 0, 0);
_DndFrameWidgetLayout->setContentsMargins(0,0,0,0);
m_DndFrameWidget = new QmitkDnDFrameWidget(m_Parent);
m_DndFrameWidget->setLayout(_DndFrameWidgetLayout);
QVBoxLayout* layout = new QVBoxLayout(parent);
layout->addWidget(m_DndFrameWidget);
layout->setContentsMargins(0,0,0,0);
m_Parent->setLayout(layout);
}
void QmitkDataManagerView::SetFocus()
{
}
void QmitkDataManagerView::ContextMenuActionTriggered( bool )
{
QAction* action = qobject_cast<QAction*> ( sender() );
std::map<QAction*, berry::IConfigurationElement::Pointer>::iterator it
= m_ConfElements.find( action );
if( it == m_ConfElements.end() )
{
MITK_WARN << "associated conf element for action " << action->text().toStdString() << " not found";
return;
}
berry::IConfigurationElement::Pointer confElem = it->second;
mitk::IContextMenuAction* contextMenuAction = confElem->CreateExecutableExtension<mitk::IContextMenuAction>("class");
std::string className;
std::string smoothed;
confElem->GetAttribute("class", className);
confElem->GetAttribute("smoothed", smoothed);
if(className == "QmitkThresholdAction")
{
contextMenuAction->SetDataStorage(this->GetDataStorage());
}
else if(className == "QmitkOtsuAction")
{
contextMenuAction->SetDataStorage(this->GetDataStorage());
}
else if(className == "QmitkCreatePolygonModelAction")
{
contextMenuAction->SetDataStorage(this->GetDataStorage());
if(smoothed == "false")
{
contextMenuAction->SetSmoothed(false);
}
else
{
contextMenuAction->SetSmoothed(true);
}
contextMenuAction->SetDecimated(m_SurfaceDecimation);
}
else if(className == "QmitkStatisticsAction")
{
contextMenuAction->SetFunctionality(this);
}
+ else if(className == "QmitkCreateSimulationAction")
+ {
+ contextMenuAction->SetDataStorage(this->GetDataStorage());
+ }
contextMenuAction->Run( this->GetCurrentSelection() ); // run the action
}
void QmitkDataManagerView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
{
if( m_NodeTreeModel->GetPlaceNewNodesOnTopFlag() != prefs->GetBool("Place new nodes on top", true) )
m_NodeTreeModel->SetPlaceNewNodesOnTop( !m_NodeTreeModel->GetPlaceNewNodesOnTopFlag() );
if( m_NodeTreeModel->GetShowHelperObjectsFlag()!= prefs->GetBool("Show helper objects", false) )
m_NodeTreeModel->SetShowHelperObjects( !m_NodeTreeModel->GetShowHelperObjectsFlag() );
if( m_NodeTreeModel->GetShowNodesContainingNoDataFlag()!= prefs->GetBool("Show nodes containing no data", false) )
m_NodeTreeModel->SetShowNodesContainingNoData( !m_NodeTreeModel->GetShowNodesContainingNoDataFlag() );
+ m_GlobalReinitOnNodeDelete = prefs->GetBool("Call global reinit if node is deleted", true);
+
m_NodeTreeView->expandAll();
m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
this->GlobalReinit();
}
void QmitkDataManagerView::NodeTableViewContextMenuRequested( const QPoint & pos )
{
QModelIndex selected = m_NodeTreeView->indexAt ( pos );
mitk::DataNode::Pointer node = m_NodeTreeModel->GetNode(selected);
QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
if(!selectedNodes.isEmpty())
{
m_NodeMenu->clear();
QList<QAction*> actions;
if(selectedNodes.size() == 1 )
{
actions = QmitkNodeDescriptorManager::GetInstance()->GetActions(node);
for(QList<QAction*>::iterator it = actions.begin(); it != actions.end(); ++it)
{
(*it)->setData(QVariant::fromValue(node.GetPointer()));
}
}
else
actions = QmitkNodeDescriptorManager::GetInstance()->GetActions(selectedNodes);
if (!m_ShowInActions.isEmpty())
{
QMenu* showInMenu = m_NodeMenu->addMenu("Show In");
showInMenu->addActions(m_ShowInActions);
}
m_NodeMenu->addActions(actions);
m_NodeMenu->popup(QCursor::pos());
}
}
void QmitkDataManagerView::OpacityChanged(int value)
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
if(node)
{
float opacity = static_cast<float>(value)/100.0f;
node->SetFloatProperty("opacity", opacity);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkDataManagerView::OpacityActionChanged()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
if(node)
{
float opacity = 0.0;
if(node->GetFloatProperty("opacity", opacity))
{
m_OpacitySlider->setValue(static_cast<int>(opacity*100));
}
}
}
void QmitkDataManagerView::ColorChanged()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
if(node)
{
QColor color = QColorDialog::getColor();
m_ColorButton->setAutoFillBackground(true);
node->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0,color.green()/255.0,color.blue()/255.0));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkDataManagerView::ColorActionChanged()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
if(node)
{
mitk::Color color;
mitk::ColorProperty::Pointer colorProp;
node->GetProperty(colorProp,"color");
if(colorProp.IsNull())
return;
color = colorProp->GetValue();
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255));
styleSheet.append(")");
m_ColorButton->setStyleSheet(styleSheet);
}
}
void QmitkDataManagerView::TextureInterpolationChanged()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
if(node)
{
bool textureInterpolation = false;
node->GetBoolProperty("texture interpolation", textureInterpolation);
m_TextureInterpolation->setChecked(textureInterpolation);
}
}
void QmitkDataManagerView::TextureInterpolationToggled( bool checked )
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
if(node)
{
node->SetBoolProperty("texture interpolation", checked);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkDataManagerView::SurfaceRepresentationMenuAboutToShow()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
if(!node)
return;
mitk::EnumerationProperty* representationProp =
dynamic_cast<mitk::EnumerationProperty*> (node->GetProperty("material.representation"));
if(!representationProp)
return;
// clear menu
m_SurfaceRepresentation->menu()->clear();
QAction* tmp;
// create menu entries
for(mitk::EnumerationProperty::EnumConstIterator it=representationProp->Begin(); it!=representationProp->End()
; it++)
{
tmp = m_SurfaceRepresentation->menu()->addAction(QString::fromStdString(it->second));
tmp->setCheckable(true);
if(it->second == representationProp->GetValueAsString())
{
tmp->setChecked(true);
}
QObject::connect( tmp, SIGNAL( triggered(bool) )
, this, SLOT( SurfaceRepresentationActionToggled(bool) ) );
}
}
void QmitkDataManagerView::SurfaceRepresentationActionToggled( bool /*checked*/ )
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_NodeTreeView->selectionModel()->currentIndex());
if(!node)
return;
mitk::EnumerationProperty* representationProp =
dynamic_cast<mitk::EnumerationProperty*> (node->GetProperty("material.representation"));
if(!representationProp)
return;
QAction* senderAction = qobject_cast<QAction*> ( QObject::sender() );
if(!senderAction)
return;
std::string activatedItem = senderAction->text().toStdString();
if ( activatedItem != representationProp->GetValueAsString() )
{
if ( representationProp->IsValidEnumerationValue( activatedItem ) )
{
representationProp->SetValue( activatedItem );
representationProp->InvokeEvent( itk::ModifiedEvent() );
representationProp->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void QmitkDataManagerView::SaveSelectedNodes( bool )
{
QModelIndexList indexesOfSelectedRows = m_NodeTreeView->selectionModel()->selectedRows();
mitk::DataNode* node = 0;
unsigned int indexesOfSelectedRowsSize = indexesOfSelectedRows.size();
for (unsigned int i = 0; i<indexesOfSelectedRowsSize; ++i)
{
node = m_NodeTreeModel->GetNode(indexesOfSelectedRows.at(i));
// if node is not defined or if the node contains geometry data do not remove it
if ( node != 0 )
{
mitk::BaseData::Pointer data = node->GetData();
if (data.IsNotNull())
{
QString error;
try
{
mitk::QmitkIOUtil::SaveBaseDataWithDialog( data.GetPointer(), node->GetName().c_str(), m_Parent );
}
catch(std::exception& e)
{
error = e.what();
}
catch(...)
{
error = "Unknown error occured";
}
if( !error.isEmpty() )
QMessageBox::critical( m_Parent, "Error saving...", error );
}
}
}
}
void QmitkDataManagerView::ReinitSelectedNodes( bool )
{
mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
if (renderWindow == NULL)
renderWindow = this->OpenRenderWindowPart(false);
QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
foreach(mitk::DataNode::Pointer node, selectedNodes)
{
mitk::BaseData::Pointer basedata = node->GetData();
if ( basedata.IsNotNull() &&
basedata->GetTimeSlicedGeometry()->IsValid() )
{
renderWindow->GetRenderingManager()->InitializeViews(
basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
renderWindow->GetRenderingManager()->RequestUpdateAll();
}
}
}
void QmitkDataManagerView::RemoveSelectedNodes( bool )
{
QModelIndexList indexesOfSelectedRows = m_NodeTreeView->selectionModel()->selectedRows();
if(indexesOfSelectedRows.size() < 1)
{
return;
}
std::vector<mitk::DataNode*> selectedNodes;
mitk::DataNode* node = 0;
QString question = tr("Do you really want to remove ");
for (QModelIndexList::iterator it = indexesOfSelectedRows.begin()
; it != indexesOfSelectedRows.end(); it++)
{
node = m_NodeTreeModel->GetNode(*it);
// if node is not defined or if the node contains geometry data do not remove it
if ( node != 0 /*& strcmp(node->GetData()->GetNameOfClass(), "Geometry2DData") != 0*/ )
{
selectedNodes.push_back(node);
question.append(QString::fromStdString(node->GetName()));
question.append(", ");
}
}
// remove the last two characters = ", "
question = question.remove(question.size()-2, 2);
question.append(" from data storage?");
QMessageBox::StandardButton answerButton = QMessageBox::question( m_Parent
, tr("DataManager")
, question
, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
if(answerButton == QMessageBox::Yes)
{
for (std::vector<mitk::DataNode*>::iterator it = selectedNodes.begin()
; it != selectedNodes.end(); it++)
{
node = *it;
this->GetDataStorage()->Remove(node);
- this->GlobalReinit(false);
+ if (m_GlobalReinitOnNodeDelete)
+ this->GlobalReinit(false);
}
}
}
void QmitkDataManagerView::MakeAllNodesInvisible( bool )
{
QList<mitk::DataNode::Pointer> nodes = m_NodeTreeModel->GetNodeSet();
foreach(mitk::DataNode::Pointer node, nodes)
{
node->SetVisibility(false);
}
- //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkDataManagerView::ShowOnlySelectedNodes( bool )
{
QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
QList<mitk::DataNode::Pointer> allNodes = m_NodeTreeModel->GetNodeSet();
foreach(mitk::DataNode::Pointer node, allNodes)
{
node->SetVisibility(selectedNodes.contains(node));
}
- //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkDataManagerView::ToggleVisibilityOfSelectedNodes( bool )
{
QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
bool isVisible = false;
foreach(mitk::DataNode::Pointer node, selectedNodes)
{
isVisible = false;
node->GetBoolProperty("visible", isVisible);
node->SetVisibility(!isVisible);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkDataManagerView::ShowInfoDialogForSelectedNodes( bool )
{
QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
QmitkInfoDialog _QmitkInfoDialog(selectedNodes, this->m_Parent);
_QmitkInfoDialog.exec();
}
void QmitkDataManagerView::Load( bool )
{
QStringList fileNames = QFileDialog::getOpenFileNames(NULL, "Load data", "", mitk::CoreObjectFactory::GetInstance()->GetFileExtensions());
for ( QStringList::Iterator it = fileNames.begin(); it != fileNames.end(); ++it )
{
FileOpen((*it).toAscii(), 0);
}
}
void QmitkDataManagerView::FileOpen( const char * fileName, mitk::DataNode* parentNode )
{
mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
try
{
factory->SetFileName( fileName );
QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
factory->Update();
for ( unsigned int i = 0 ; i < factory->GetNumberOfOutputs( ); ++i )
{
mitk::DataNode::Pointer node = factory->GetOutput( i );
if ( ( node.IsNotNull() ) && ( node->GetData() != NULL ) )
{
this->GetDataStorage()->Add(node, parentNode);
mitk::BaseData::Pointer basedata = node->GetData();
mitk::RenderingManager::GetInstance()->InitializeViews(
basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
catch ( itk::ExceptionObject & ex )
{
itkGenericOutputMacro( << "Exception during file open: " << ex );
}
QApplication::restoreOverrideCursor();
}
QItemSelectionModel *QmitkDataManagerView::GetDataNodeSelectionModel() const
{
return m_NodeTreeView->selectionModel();
}
void QmitkDataManagerView::GlobalReinit( bool )
{
mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
if (renderWindow == NULL)
renderWindow = this->OpenRenderWindowPart(false);
// no render window available
if (renderWindow == NULL) return;
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred
= mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
, mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
renderWindow->GetRenderingManager()->InitializeViews(bounds);
}
void QmitkDataManagerView::OtsuFilter( bool )
{
QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
mitk::Image::Pointer mitkImage = 0;
foreach(mitk::DataNode::Pointer node, selectedNodes)
{
mitkImage = dynamic_cast<mitk::Image*>( node->GetData() );
if(mitkImage.IsNull())
continue;
try
{
// get selected mitk image
const unsigned short dim = 3;
typedef short InputPixelType;
typedef unsigned char OutputPixelType;
typedef itk::Image< InputPixelType, dim > InputImageType;
typedef itk::Image< OutputPixelType, dim > OutputImageType;
typedef itk::OtsuThresholdImageFilter< InputImageType, OutputImageType > FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetOutsideValue( 1 );
filter->SetInsideValue( 0 );
InputImageType::Pointer itkImage;
mitk::CastToItkImage(mitkImage, itkImage);
filter->SetInput( itkImage );
filter->Update();
mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
std::string nameOfResultImage = node->GetName();
nameOfResultImage.append("Otsu");
resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
resultNode->SetProperty("binary", mitk::BoolProperty::New(true) );
- resultNode->SetData( mitk::ImportItkImage ( filter->GetOutput() ) );
+ resultNode->SetData( mitk::ImportItkImage(filter->GetOutput())->Clone());
this->GetDataStorage()->Add(resultNode, node);
}
catch( std::exception& err )
{
MITK_ERROR(this->GetClassName()) << err.what();
}
}
}
void QmitkDataManagerView::NodeTreeViewRowsRemoved (
const QModelIndex & /*parent*/, int /*start*/, int /*end*/ )
{
m_CurrentRowCount = m_NodeTreeModel->rowCount();
}
void QmitkDataManagerView::NodeTreeViewRowsInserted( const QModelIndex & parent, int, int )
{
m_NodeTreeView->setExpanded(parent, true);
// a new row was inserted
if( m_CurrentRowCount == 0 && m_NodeTreeModel->rowCount() == 1 )
{
this->OpenRenderWindowPart();
m_CurrentRowCount = m_NodeTreeModel->rowCount();
/*
std::vector<mitk::DataNode*> nodes = m_NodeTreeModel->GetNodeSet();
if(nodes.size() == 1)
{
QModelIndex treeIndex = m_NodeTreeModel->GetIndex(nodes.front());
m_NodeTreeView->selectionModel()->setCurrentIndex( treeIndex, QItemSelectionModel::ClearAndSelect );
}
*/
}
}
void QmitkDataManagerView::NodeSelectionChanged( const QItemSelection & /*selected*/, const QItemSelection & /*deselected*/ )
{
QList<mitk::DataNode::Pointer> nodes = m_NodeTreeModel->GetNodeSet();
foreach(mitk::DataNode::Pointer node, nodes)
{
if ( node.IsNotNull() )
node->SetBoolProperty("selected", false);
}
nodes.clear();
nodes = this->GetCurrentSelection();
foreach(mitk::DataNode::Pointer node, nodes)
{
if ( node.IsNotNull() )
node->SetBoolProperty("selected", true);
}
//changing the selection does NOT require any rendering processes!
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkDataManagerView::ShowIn(const QString &editorId)
{
berry::IWorkbenchPage::Pointer page = this->GetSite()->GetPage();
berry::IEditorInput::Pointer input(new mitk::DataStorageEditorInput(this->GetDataStorageReference()));
page->OpenEditor(input, editorId.toStdString(), false, berry::IWorkbenchPage::MATCH_ID);
}
mitk::IRenderWindowPart* QmitkDataManagerView::OpenRenderWindowPart(bool activatedEditor)
{
if (activatedEditor)
{
return this->GetRenderWindowPart(QmitkAbstractView::ACTIVATE | QmitkAbstractView::OPEN);
}
else
{
return this->GetRenderWindowPart(QmitkAbstractView::BRING_TO_FRONT | QmitkAbstractView::OPEN);
}
}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.h b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.h
index df68129a89..bb4b25ed30 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.h
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.h
@@ -1,246 +1,249 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QMITKDATAMANAGERVIEW_H_
#define QMITKDATAMANAGERVIEW_H_
// BlueBerry includes
#include <berryIBerryPreferences.h>
/// Qmitk
#include <QmitkAbstractView.h>
#include <QmitkNodeDescriptorManager.h>
/// Qt
#include <QItemSelection>
#include <org_mitk_gui_qt_datamanager_Export.h>
// Forward declarations
class QMenu;
class QAction;
class QComboBox;
class QWidgetAction;
class QSlider;
class QModelIndex;
class QTreeView;
class QPushButton;
class QToolBar;
class QMenu;
class QSignalMapper;
class QmitkDnDFrameWidget;
class QmitkDataStorageTreeModel;
///
/// \ingroup org_mitk_gui_qt_datamanager_internal
///
/// \brief A View class that can show all data tree nodes of a certain DataStorage
///
/// \TODO: complete PACS support, in save dialog show regular filename
///
class MITK_QT_DATAMANAGER QmitkDataManagerView : public QmitkAbstractView
{
Q_OBJECT
public:
static const std::string VIEW_ID; // = "org.mitk.extapp.defaultperspective"
///
/// \brief Standard ctor.
///
QmitkDataManagerView();
///
/// \brief Standard dtor.
///
virtual ~QmitkDataManagerView();
public slots:
///
/// Invoked when the opacity slider changed
///
void OpacityChanged(int value);
///
/// Invoked when the opacity action changed
/// In this function the the opacity slider is set to the selected nodes opacity value
///
void OpacityActionChanged();
///
/// Invoked when the color button is pressed
///
void ColorChanged();
///
/// Invoked when the color action changed
///
void ColorActionChanged();
///
/// Invoked when the color button is pressed
///
void TextureInterpolationChanged();
///
/// Invoked when the color action changed
///
void TextureInterpolationToggled ( bool checked );
///
/// SurfaceRepresentationActionToggled
///
void SurfaceRepresentationMenuAboutToShow ();
///public
/// SurfaceRepresentationActionToggled
///
void SurfaceRepresentationActionToggled ( bool checked );
///
/// \brief Shows a node context menu.
///
void NodeTableViewContextMenuRequested( const QPoint & index );
///
/// \brief Invoked when an element should be saved.
///
void SaveSelectedNodes( bool checked = false );
///
/// \brief Invoked when an element should be removed.
///
void RemoveSelectedNodes( bool checked = false );
///
/// \brief Invoked when an element should be reinitiliased.
///
void ReinitSelectedNodes( bool checked = false );
///
/// \brief Invoked when the visibility of the selected nodes should be toggled.
///
void MakeAllNodesInvisible ( bool checked = false );
///
/// \brief Makes all selected nodes visible, all other nodes invisible.
///
void ShowOnlySelectedNodes ( bool checked = false );
///
/// \brief Invoked when the visibility of the selected nodes should be toggled.
///
void ToggleVisibilityOfSelectedNodes ( bool checked = false );
///
/// \brief Invoked when infos of the selected nodes should be shown in a dialog.
///
void ShowInfoDialogForSelectedNodes ( bool checked = false );
///
/// \brief Shows a load dialog.
///
void Load ( bool checked = false );
///
/// \brief Reinits everything.
///
void GlobalReinit ( bool checked = false );
///
/// Invoked when the preferences were changed
///
void OnPreferencesChanged(const berry::IBerryPreferences*);
///
/// \brief will be toggled when a extension point context menu action is toggled
/// this is a proxy method which will load the corresponding extension class
/// and run IContextMenuAction
///
void ContextMenuActionTriggered( bool );
/// Invoked when the median action is invoked
void OtsuFilter( bool checked = false );
/// When rows are inserted auto expand them
void NodeTreeViewRowsInserted ( const QModelIndex & parent, int start, int end );
/// will setup m_CurrentRowCount
void NodeTreeViewRowsRemoved ( const QModelIndex & parent, int start, int end );
/// Whenever the selection changes set the "selected" property respectively
void NodeSelectionChanged( const QItemSelection & selected, const QItemSelection & deselected );
/// Opens the editor with the given id using the current data storage
void ShowIn(const QString& editorId);
protected:
///
/// \brief Create the view here.
///
virtual void CreateQtPartControl(QWidget* parent);
void SetFocus();
///
/// \brief Shows a file open dialog.
///
void FileOpen( const char * fileName, mitk::DataNode* parentNode );
protected:
QWidget* m_Parent;
QmitkDnDFrameWidget* m_DndFrameWidget;
///
/// \brief A plain widget as the base pane.
///
QmitkDataStorageTreeModel* m_NodeTreeModel;
///
/// Holds the preferences for the datamanager.
///
berry::IBerryPreferences::Pointer m_DataManagerPreferencesNode;
///
/// saves the configuration elements for the context menu actions from extension points
///
std::map<QAction*, berry::IConfigurationElement::Pointer> m_ConfElements;
///
/// \brief The Table view to show the selected nodes.
///
QTreeView* m_NodeTreeView;
///
/// \brief The context menu that shows up when right clicking on a node.
///
QMenu* m_NodeMenu;
///
/// \brief flag indicating whether a surface created from a selected decimation is decimated with vtkQuadricDecimation or not
///
bool m_SurfaceDecimation;
///# A list of ALL actions for the Context Menu
std::vector< std::pair< QmitkNodeDescriptor*, QAction* > > m_DescriptorActionList;
/// A Slider widget to change the opacity of a node
QSlider* m_OpacitySlider;
/// button to change the color of a node
QPushButton* m_ColorButton;
/// TextureInterpolation action
QAction* m_TextureInterpolation;
/// SurfaceRepresentation action
QAction* m_SurfaceRepresentation;
/// Maps "Show in" actions to editor ids
QSignalMapper* m_ShowInMapper;
/// A list of "Show in" actions
QList<QAction*> m_ShowInActions;
/// saves the current amount of rows shown in the datamanager
size_t m_CurrentRowCount;
+ /// if true, GlobalReinit() is called if a node is deleted
+ bool m_GlobalReinitOnNodeDelete;
+
private:
QItemSelectionModel* GetDataNodeSelectionModel() const;
/// Reopen multi widget editor if it has been closed
mitk::IRenderWindowPart *OpenRenderWindowPart(bool activatedEditor = true);
};
#endif /*QMITKDATAMANAGERVIEW_H_*/
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkLineEdit.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkLineEdit.cpp
deleted file mode 100644
index 5ba5087943..0000000000
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkLineEdit.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#include "QmitkLineEdit.h"
-#include <QApplication>
-
-QmitkLineEdit::QmitkLineEdit(QWidget *parent)
- : QLineEdit(parent)
-{
- initialize();
-}
-
-QmitkLineEdit::QmitkLineEdit(const QString &defaultText, QWidget *parent)
- : QLineEdit(parent),
- m_DefaultText(defaultText)
-{
- initialize();
-}
-
-QmitkLineEdit::~QmitkLineEdit()
-{
-}
-
-void QmitkLineEdit::initialize()
-{
- m_DefaultPalette.setColor(QPalette::Text, QApplication::palette().color(QPalette::Disabled, QPalette::Text));
-
- showDefaultText(true);
-
- connect(this, SIGNAL(focusChanged(bool)), this, SLOT(onFocusChanged(bool)));
- connect(this, SIGNAL(textChanged(QString)), this, SLOT(onTextChanged(QString)));
-}
-
-QString QmitkLineEdit::defaultText() const
-{
- return m_DefaultText;
-}
-
-void QmitkLineEdit::setDefaultText(const QString &defaultText)
-{
- m_DefaultText = defaultText;
-}
-
-void QmitkLineEdit::focusInEvent(QFocusEvent *event)
-{
- QLineEdit::focusInEvent(event);
- emit(focusChanged(true));
-}
-
-void QmitkLineEdit::focusOutEvent(QFocusEvent *event)
-{
- QLineEdit::focusOutEvent(event);
- emit(focusChanged(false));
-}
-
-void QmitkLineEdit::onFocusChanged(bool hasFocus)
-{
- if (hasFocus)
- {
- if (text() == m_DefaultText && palette() == m_DefaultPalette)
- showDefaultText(false);
- }
- else
- {
- if (text().isEmpty())
- showDefaultText(true);
- }
-}
-
-void QmitkLineEdit::onTextChanged(const QString &text)
-{
- if (palette() == m_DefaultPalette)
- setPalette(m_Palette);
-}
-
-void QmitkLineEdit::showDefaultText(bool show)
-{
- blockSignals(true);
-
- if (show)
- {
- setPalette(m_DefaultPalette);
- setText(m_DefaultText);
- }
- else
- {
- setPalette(m_Palette);
- clear();
- }
-
- blockSignals(false);
-}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeFilterProxyModel.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeFilterProxyModel.cpp
deleted file mode 100644
index d3b5871978..0000000000
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeFilterProxyModel.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#include "QmitkPropertyTreeFilterProxyModel.h"
-#include <mitkLogMacros.h>
-
-QmitkPropertyTreeFilterProxyModel::QmitkPropertyTreeFilterProxyModel(QObject *parent)
-: QSortFilterProxyModel(parent)
-{
-}
-
-QmitkPropertyTreeFilterProxyModel::~QmitkPropertyTreeFilterProxyModel()
-{
-}
-
-bool QmitkPropertyTreeFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
-{
- return filterAcceptsAnyChildRows(sourceModel()->index(sourceRow, 0, sourceParent));
-}
-
-bool QmitkPropertyTreeFilterProxyModel::filterAcceptsAnyChildRows(const QModelIndex &sourceParent) const
-{
- QString propertyName = sourceModel()->data(sourceParent).toString();
-
- if (propertyName.contains(filterRegExp()))
- return true;
-
- if (sourceModel()->hasChildren(sourceParent))
- {
- for (int row = 0; row < sourceModel()->rowCount(sourceParent); ++row)
- {
- if (filterAcceptsAnyChildRows(sourceModel()->index(row, 0, sourceParent)))
- return true;
- }
- }
-
- return false;
-}
-
-bool QmitkPropertyTreeFilterProxyModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
-{
- return sourceModel()->data(left).toString().compare(sourceModel()->data(right).toString(), Qt::CaseInsensitive) > 0;
-}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeItem.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeItem.cpp
deleted file mode 100644
index 588a741ddc..0000000000
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeItem.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#include "QmitkPropertyTreeItem.h"
-#include <QStringList>
-
-QmitkPropertyTreeItem::QmitkPropertyTreeItem(const QList<QVariant> &data)
-: m_Data(data),
- m_Parent(NULL)
-{
-}
-
-QmitkPropertyTreeItem::~QmitkPropertyTreeItem()
-{
- qDeleteAll(m_Children);
-}
-
-void QmitkPropertyTreeItem::AppendChild(QmitkPropertyTreeItem *child)
-{
- if (child == NULL)
- return;
-
- // If property name contains no full stop we can append the property directly.
- if (!child->GetData(0).toString().contains('.'))
- {
- m_Children.append(child);
- child->m_Parent = this;
- }
- else
- {
- // Property name contains full stop(s). We split the name appropriately.
- QStringList names = child->GetData(0).toString().split('.');
-
- // Traverse the subtree and insert items if they are not already present.
- QmitkPropertyTreeItem *parent_ = this;
-
- for (int i = 0; i < names.count(); ++i)
- {
- // Subtree present/recently created, append actual property as a leaf item
- if (i == names.count() - 1)
- {
- QList<QVariant> data;
- data << names[i] << child->m_Data[1];
- parent_->AppendChild(new QmitkPropertyTreeItem(data));
-
- delete child;
- child = NULL;
- }
- else
- {
- QmitkPropertyTreeItem *child_ = NULL;
-
- for (int j = 0; j < parent_->m_Children.count(); ++j)
- {
- if (parent_->m_Children[j]->GetData(0).toString() == names[i])
- {
- child_ = parent_->m_Children[j];
- break;
- }
- }
-
- if (child_ == NULL)
- {
- QList<QVariant> data;
- data << names[i] << QVariant();
- child_ = new QmitkPropertyTreeItem(data);
- parent_->AppendChild(child_);
- }
-
- parent_ = child_;
- }
- }
- }
-}
-
-QmitkPropertyTreeItem * QmitkPropertyTreeItem::GetChild(int row)
-{
- return m_Children.value(row);
-}
-
-int QmitkPropertyTreeItem::GetChildCount() const
-{
- return m_Children.count();
-}
-
-int QmitkPropertyTreeItem::GetColumnCount() const
-{
- return m_Data.count();
-}
-
-QVariant QmitkPropertyTreeItem::GetData(int column) const
-{
- return m_Data.value(column);
-}
-
-QmitkPropertyTreeItem * QmitkPropertyTreeItem::GetParent()
-{
- return m_Parent;
-}
-
-int QmitkPropertyTreeItem::GetRow() const
-{
- if (m_Parent != NULL)
- return m_Parent->m_Children.indexOf(const_cast<QmitkPropertyTreeItem *>(this));
-
- return 0;
-}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeModel.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeModel.cpp
deleted file mode 100644
index 079220af99..0000000000
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeModel.cpp
+++ /dev/null
@@ -1,313 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#include "QmitkPropertyTreeItem.h"
-#include "QmitkPropertyTreeModel.h"
-#include <mitkProperties.h>
-#include <mitkColorProperty.h>
-#include <mitkEnumerationProperty.h>
-#include <mitkStringProperty.h>
-#include <mitkRenderingManager.h>
-#include <QColor>
-
-QmitkPropertyTreeModel::QmitkPropertyTreeModel(QObject *parent)
-: QAbstractItemModel(parent),
- m_Properties(NULL),
- m_RootItem(NULL)
-{
- CreateRootItem();
-}
-
-void QmitkPropertyTreeModel::SetProperties(mitk::PropertyList *properties)
-{
- if (properties == m_Properties)
- return;
-
- beginResetModel();
-
- if (m_RootItem != NULL)
- {
- delete m_RootItem;
- m_RootItem = NULL;
- m_Properties = NULL;
- }
-
- CreateRootItem();
-
- if (properties != NULL && !properties->IsEmpty())
- {
- m_Properties = properties;
-
- std::map<std::string, mitk::BaseProperty::Pointer>::const_iterator end = properties->GetMap()->end();
-
- for (std::map<std::string, mitk::BaseProperty::Pointer>::const_iterator iter = properties->GetMap()->begin(); iter != end; ++iter)
- {
- QList<QVariant> data;
- data << iter->first.c_str() << QVariant::fromValue<void *>((reinterpret_cast<void *>(iter->second.GetPointer())));
- m_RootItem->AppendChild(new QmitkPropertyTreeItem(data));
- }
- }
-
- endResetModel();
-}
-
-void QmitkPropertyTreeModel::CreateRootItem()
-{
- if (m_RootItem == NULL)
- {
- QList<QVariant> rootData;
- rootData << "Property" << "Value";
- m_RootItem = new QmitkPropertyTreeItem(rootData);
- }
-}
-
-QmitkPropertyTreeModel::~QmitkPropertyTreeModel()
-{
- delete m_RootItem;
-}
-
-int QmitkPropertyTreeModel::columnCount(const QModelIndex &parent) const
-{
- if (parent.isValid())
- return static_cast<QmitkPropertyTreeItem *>(parent.internalPointer())->GetColumnCount();
- else
- return m_RootItem->GetColumnCount();
-}
-
-QVariant QmitkPropertyTreeModel::data(const QModelIndex &index, int role) const
-{
- if (!index.isValid())
- return QVariant();
-
- if (index.column() == 0 && role == Qt::DisplayRole)
- return static_cast<QmitkPropertyTreeItem *>(index.internalPointer())->GetData(index.column());
-
- if (index.column() == 1 && static_cast<QmitkPropertyTreeItem *>(index.internalPointer())->GetData(index.column()).isValid())
- {
- mitk::BaseProperty *property = reinterpret_cast<mitk::BaseProperty *>(static_cast<QmitkPropertyTreeItem *>(index.internalPointer())->GetData(index.column()).value<void *>());
-
- if (mitk::ColorProperty *colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
- {
- if (role == Qt::DisplayRole || role == Qt::EditRole)
- {
- mitk::Color mitkColor = colorProperty->GetColor();
- QColor qtColor(static_cast<int>(mitkColor.GetRed() * 255), static_cast<int>(mitkColor.GetGreen() * 255), static_cast<int>(mitkColor.GetBlue() * 255));
- return QVariant::fromValue<QColor>(qtColor);
- }
- }
- else if (mitk::BoolProperty *boolProperty = dynamic_cast<mitk::BoolProperty *>(property))
- {
- if (role == Qt::CheckStateRole)
- return boolProperty->GetValue() ? Qt::Checked : Qt::Unchecked;
- }
- else if (mitk::StringProperty *stringProperty = dynamic_cast<mitk::StringProperty *>(property))
- {
- if (role == Qt::DisplayRole || role == Qt::EditRole)
- return QString(stringProperty->GetValue());
- }
- else if (mitk::IntProperty *intProperty = dynamic_cast<mitk::IntProperty *>(property))
- {
- if (role == Qt::DisplayRole || role == Qt::EditRole)
- return intProperty->GetValue();
- }
- else if (mitk::FloatProperty *floatProperty = dynamic_cast<mitk::FloatProperty *>(property))
- {
- if (role == Qt::DisplayRole || role == Qt::EditRole)
- return floatProperty->GetValue();
- }
- else if (mitk::DoubleProperty *doubleProperty = dynamic_cast<mitk::DoubleProperty *>(property))
- {
- if (role == Qt::DisplayRole || role == Qt::EditRole)
- return doubleProperty->GetValue();
- }
- else if (mitk::EnumerationProperty *enumProperty = dynamic_cast<mitk::EnumerationProperty *>(property))
- {
- if (role == Qt::DisplayRole)
- {
- return QString::fromStdString(enumProperty->GetValueAsString());
- }
- else if (role == Qt::EditRole)
- {
- QStringList values;
-
- for (mitk::EnumerationProperty::EnumConstIterator iter = enumProperty->Begin(); iter != enumProperty->End(); ++iter)
- values << QString::fromStdString(iter->second);
-
- return QVariant(values);
- }
- }
- else
- {
- if (role == Qt::DisplayRole)
- return QString::fromStdString(property->GetValueAsString());
- }
- }
-
- return QVariant();
-}
-
-Qt::ItemFlags QmitkPropertyTreeModel::flags(const QModelIndex &index) const
-{
- Qt::ItemFlags flags = QAbstractItemModel::flags(index);
-
- if (index.column() == 1)
- {
- if (index.data(Qt::EditRole).isValid())
- flags |= Qt::ItemIsEditable;
-
- if (index.data(Qt::CheckStateRole).isValid())
- flags |= Qt::ItemIsUserCheckable;
- }
-
- return flags;
-}
-
-QVariant QmitkPropertyTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
-{
- if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
- return m_RootItem->GetData(section);
-
- return QVariant();
-}
-
-QModelIndex QmitkPropertyTreeModel::index(int row, int column, const QModelIndex &parent) const
-{
- if (!hasIndex(row, column, parent))
- return QModelIndex();
-
- QmitkPropertyTreeItem *parentItem = parent.isValid() ? static_cast<QmitkPropertyTreeItem *>(parent.internalPointer()) : m_RootItem;
- QmitkPropertyTreeItem *childItem = parentItem->GetChild(row);
-
- if (childItem != NULL)
- return createIndex(row, column, childItem);
- else
- return QModelIndex();
-}
-
-QModelIndex QmitkPropertyTreeModel::parent(const QModelIndex &child) const
-{
- if (!child.isValid())
- return QModelIndex();
-
- QmitkPropertyTreeItem *parentItem = static_cast<QmitkPropertyTreeItem *>(child.internalPointer())->GetParent();
-
- if (parentItem == m_RootItem)
- return QModelIndex();
-
- return createIndex(parentItem->GetRow(), 0, parentItem);
-}
-
-int QmitkPropertyTreeModel::rowCount(const QModelIndex &parent) const
-{
- if (parent.column() > 0)
- return 0;
-
- QmitkPropertyTreeItem *parentItem = parent.isValid() ? static_cast<QmitkPropertyTreeItem *>(parent.internalPointer()) : m_RootItem;
-
- return parentItem->GetChildCount();
-}
-
-bool QmitkPropertyTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
-{
- if (index.isValid() && (role == Qt::EditRole || role == Qt::CheckStateRole))
- {
- if (index.column() == 1)
- {
- mitk::BaseProperty *property = reinterpret_cast<mitk::BaseProperty *>(static_cast<QmitkPropertyTreeItem *>(index.internalPointer())->GetData(index.column()).value<void *>());
-
- if (mitk::ColorProperty *colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
- {
- QColor qtColor = value.value<QColor>();
-
- if (!qtColor.isValid())
- return false;
-
- mitk::Color mitkColor = colorProperty->GetColor();
- mitkColor.SetRed(qtColor.red() / 255.0);
- mitkColor.SetGreen(qtColor.green() / 255.0);
- mitkColor.SetBlue(qtColor.blue() / 255.0);
- colorProperty->SetColor(mitkColor);
-
- m_Properties->InvokeEvent(itk::ModifiedEvent());
- m_Properties->Modified();
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- else if (mitk::BoolProperty *boolProperty = dynamic_cast<mitk::BoolProperty *>(property))
- {
- boolProperty->SetValue(value.toInt() == Qt::Checked ? true : false);
-
- m_Properties->InvokeEvent(itk::ModifiedEvent());
- m_Properties->Modified();
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- else if (mitk::StringProperty *stringProperty = dynamic_cast<mitk::StringProperty *>(property))
- {
- stringProperty->SetValue(value.toString().toStdString());
-
- m_Properties->InvokeEvent(itk::ModifiedEvent());
- m_Properties->Modified();
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- else if (mitk::IntProperty *intProperty = dynamic_cast<mitk::IntProperty *>(property))
- {
- int intValue = value.toInt();
-
- if (intValue != intProperty->GetValue())
- {
- intProperty->SetValue(intValue);
- m_Properties->InvokeEvent(itk::ModifiedEvent());
- m_Properties->Modified();
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- }
- else if (mitk::FloatProperty *floatProperty = dynamic_cast<mitk::FloatProperty *>(property))
- {
- float floatValue = value.toFloat();
-
- if (abs(floatValue - floatProperty->GetValue()) >= mitk::eps)
- {
- floatProperty->SetValue(floatValue);
- m_Properties->InvokeEvent(itk::ModifiedEvent());
- m_Properties->Modified();
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- }
- else if (mitk::EnumerationProperty *enumProperty = dynamic_cast<mitk::EnumerationProperty *>(property))
- {
- std::string activatedItem = value.toString().toStdString();
-
- if (activatedItem != enumProperty->GetValueAsString())
- {
- enumProperty->SetValue(activatedItem);
- m_Properties->InvokeEvent(itk::ModifiedEvent());
- m_Properties->Modified();
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- }
- }
-
- emit dataChanged(index, index);
- return true;
- }
-
- return false;
-}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeModel.h b/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeModel.h
deleted file mode 100644
index caf5c9a2a4..0000000000
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeModel.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#ifndef QMITKPROPERTYTREEMODEL_H
-#define QMITKPROPERTYTREEMODEL_H
-
-#include <QAbstractItemModel>
-#include <mitkPropertyList.h>
-
-class QmitkPropertyTreeItem;
-
-class QmitkPropertyTreeModel : public QAbstractItemModel
-{
- Q_OBJECT
-
-public:
- QmitkPropertyTreeModel(QObject *parent = NULL);
- ~QmitkPropertyTreeModel();
-
- void SetProperties(mitk::PropertyList *properties);
-
- int columnCount(const QModelIndex &parent) const;
- QVariant data(const QModelIndex &index, int role) const;
- Qt::ItemFlags flags(const QModelIndex &index) const;
- QVariant headerData(int section, Qt::Orientation orientation, int role) const;
- QModelIndex index(int row, int column, const QModelIndex &parent) const;
- QModelIndex parent(const QModelIndex &child) const;
- int rowCount(const QModelIndex &parent) const;
- bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
-
-private:
- void CreateRootItem();
-
- mitk::PropertyList *m_Properties;
- QmitkPropertyTreeItem *m_RootItem;
-};
-
-#endif
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeView.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeView.cpp
deleted file mode 100644
index a4adf64d62..0000000000
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeView.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#include "QmitkPropertyTreeView.h"
-#include "QmitkPropertyTreeModel.h"
-#include "QmitkLineEdit.h"
-#include "QmitkPropertyTreeFilterProxyModel.h"
-#include <QmitkPropertyDelegate.h>
-#include <QVBoxLayout>
-#include <QTreeView>
-#include <sstream>
-
-const std::string QmitkPropertyTreeView::VIEW_ID = "org.mitk.views.propertytreeview";
-
-QmitkPropertyTreeView::QmitkPropertyTreeView()
- : m_Filter(NULL),
- m_Model(NULL),
- m_ProxyModel(NULL),
- m_Delegate(NULL),
- m_TreeView(NULL)
-{
-}
-
-QmitkPropertyTreeView::~QmitkPropertyTreeView()
-{
- if (m_Delegate != NULL)
- delete m_Delegate;
-
- if (m_ProxyModel != NULL)
- delete m_ProxyModel;
-
- if (m_Model != NULL)
- delete m_Model;
-}
-
-void QmitkPropertyTreeView::CreateQtPartControl(QWidget *parent)
-{
- m_Filter = new QmitkLineEdit("Filter", parent);
-
- m_Model = new QmitkPropertyTreeModel;
-
- m_ProxyModel = new QmitkPropertyTreeFilterProxyModel;
- m_ProxyModel->setSourceModel(m_Model);
- m_ProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
- m_ProxyModel->setDynamicSortFilter(true);
-
- m_Delegate = new QmitkPropertyDelegate;
-
- connect(m_Filter, SIGNAL(textChanged(const QString &)), this, SLOT(OnFilterChanged(const QString &)));
-
- m_TreeView = new QTreeView(parent);
-
- m_TreeView->setModel(m_ProxyModel);
- m_TreeView->setItemDelegateForColumn(1, m_Delegate);
- m_TreeView->setSortingEnabled(true);
- m_TreeView->setIndentation(16);
- m_TreeView->setAlternatingRowColors(true);
- m_TreeView->setSelectionMode(QAbstractItemView::SingleSelection);
- m_TreeView->setSelectionBehavior(QAbstractItemView::SelectItems);
-
- QVBoxLayout *layout = new QVBoxLayout(parent);
-
- layout->addWidget(m_Filter);
- layout->addWidget(m_TreeView);
-}
-
-void QmitkPropertyTreeView::OnFilterChanged(const QString &filter)
-{
- m_ProxyModel->setFilterWildcard(filter);
- m_TreeView->expandAll();
-}
-
-void QmitkPropertyTreeView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer> &nodes)
-{
- std::string partName = "Properties";
-
- if (nodes.empty() || nodes.front().IsNull())
- {
- SetPartName(partName);
- m_Model->SetProperties(NULL);
- }
- else
- {
- std::ostringstream extPartName;
- extPartName << partName << " (" << nodes.front()->GetName() << ")";
- SetPartName(extPartName.str().c_str());
-
- m_Model->SetProperties(nodes.front()->GetPropertyList());
- }
-}
-
-void QmitkPropertyTreeView::SetFocus()
-{
- m_Filter->setFocus();
-}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeView.h b/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeView.h
deleted file mode 100644
index da2ed3aef7..0000000000
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeView.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#ifndef QMITKPROPERTYTREEVIEW_H
-#define QMITKPROPERTYTREEVIEW_H
-
-#include <org_mitk_gui_qt_datamanager_Export.h>
-#include <QmitkAbstractView.h>
-
-class QmitkLineEdit;
-class QmitkPropertyDelegate;
-class QmitkPropertyTreeModel;
-class QmitkPropertyTreeFilterProxyModel;
-class QTreeView;
-
-class MITK_QT_DATAMANAGER QmitkPropertyTreeView : public QmitkAbstractView
-{
- Q_OBJECT
-
-public:
- berryObjectMacro(QmitkPropertyTreeView)
-
- static const std::string VIEW_ID;
-
- QmitkPropertyTreeView();
- ~QmitkPropertyTreeView();
-
- void CreateQtPartControl(QWidget *parent);
- void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes);
-
-protected:
- void SetFocus();
-
-private slots:
- void OnFilterChanged(const QString &filter);
-
-private:
- QmitkPropertyTreeView(const QmitkPropertyTreeView &);
- QmitkPropertyTreeView & operator=(const QmitkPropertyTreeView &);
-
- QmitkLineEdit *m_Filter;
- QmitkPropertyTreeModel *m_Model;
- QmitkPropertyTreeFilterProxyModel *m_ProxyModel;
- QmitkPropertyDelegate *m_Delegate;
- QTreeView *m_TreeView;
-};
-
-#endif
diff --git a/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox
index 10ce7a89b0..676fef35c4 100644
--- a/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox
@@ -1,121 +1,121 @@
/**
\page org_mitk_gui_qt_dicom The Dicom Plugin
\image html dcm-icon.png "Icon of Dicom"
-\note To this article requires a basic knowlage of DICOM.
+\note This article requires a basic knowledge of DICOM.
Available sections:
- \ref org_mitk_gui_qt_dicomOverview
- \ref org_mitk_gui_qt_dicomDataHandling
- \ref org_mitk_gui_qt_dicomQueryRetrieve
\section org_mitk_gui_qt_dicomOverview Overview
The DICOM editor is an experimental editor which allows for loading of DICOM images as well as server communication.
It features a highly experimental query/retrieve (you need to configure your PACS correspondingly) as well as a DICOM browser.
The DICOM browser allows you to navigate the DICOM folder/cd depending on its metadata (patient/study/series)
and import selected series for viewing in your MITK based application.
It also allows you to store your dicom data in an internal database so you can easily access often used dicom images.
It is based on the <a href="http://www.commontk.org/index.php/Documentation/Dicom_Overview">commonTK (CTK) DICOM funcionality</a>.
\section org_mitk_gui_qt_dicomDataHandling Data handling
\image html DicomPluginControls.png "The dicom Plugin controls"
In the image above you see the start page of the dicom plugin. On top of the start page you see four buttons. The Local Storage,
the Import CD, the Import Folder and the Query Retrieve button. If you press one of these buttons, the dicom plugin will switch to your local dicom image storage or will start importing dicom images
from CD or a folder on your hard drive or it will open the query retrieve screen.
<ul>
<li> Click the 'Local Storage' button to open the local storage screen.
<li> Click the 'Import CD' button to import DICOM data from a CD.
<li> Click the 'Import Folder' button to import DICOM date from a directory.
<li> Click the 'Query Retrieve' button to open the query retrieve screen.
</ul>
\subsection org_mitk_gui_qt_dicomStorage Data storage
\image html DicomPluginExtended.png "The DICOM data storage"
If you open the dicom plugin the dicom data storage will be displayed. You are able to see all your stored dicom image data.
You can browse your data by clicking on the left arrow beside the name of your data. There are three levels available.
The first level is the patient level where you can see the patient data. On the second level you can see the dicom studies for the patient.
on the third level you can see all available series refering to it's study.
You can delete the data by selecting it and pressing the delete button.
Be careful if you have selected a patient or a study all refering data be deleted.
So if you delete a patient the patient and all studies and series refered to the patient will be deleted.
If you delete a study all series of the study will be deleted.
If you want to view the dicom data you have to select a series and click on the View button.
The data will appear in the DataManager and will be dispayed.
\image html DicomDisplayDataManager.png "Viewed image"
<ul>
<li> Click on the arrow on the left of your data to expand or hide dicom data levels.
<li> Click the 'Delete' button to delete selected DICOM data.
<li> Click the 'View' button to view DICOM data.
</ul>
\subsection org_mitk_gui_qt_dicomImport Data import
\image html ImportDialogCopy.png "The import dialog checked"
There are two diffrent ways to import DICOM data.
The First one is to directly imort it into your DICOM data storage. To achieve this you should toggle the checkbox 'Copy on import'.
The second approach is, to have a look at the data first before importing it.
To do that you simply don't check 'Copy on import'.
This will leed you to the leed you to the 'External Dicom Data' screen which provides you a preview of the data containing in youre choosen folder.
You can import the data here by selecting it and pressing the 'Download' button.
It is also possible to view DICOM series directly in Mitk by selecting it here and pressing the 'View' button.
<ul>
<li> Click 'Import Folder' or 'Import CD' button to open the import dialog.</li>
<ul>
<li> Enable the 'Copy on import' checkbox and choose a folder to import into data storage directly.</li>
<li> Disable the 'Copy on import' checkbox to get to the 'External Dicom Data' screen.</li>
<ul>
<li> Click on the arrow on the left of your data to expand or hide dicom data levels.
<li> Click the 'Download' button to download selected DICOM data to your DICOM data storage.
<li> Click the 'View' button to view DICOM data.
</ul>
</ul>
</ul>
\section org_mitk_gui_qt_dicomQueryRetrieve Query/Retrieve
\warning This plugin is experimental and not all of the described features behave as expected.
\note The query retrieve plugin only works if the PACS you are calling knows your machine settings.
There are also issues when you are running a firewall.
The query retrieve workflow allows you to get DICOM data from a server.
\image html DicomQueryRetrieve.png "The query retrieve screen"
\subsection org_mitk_gui_qt_dicomQuery Query
\image html DicomNodes.png "The DICOM network configuration"
By performing a DICOM query you will ask a server for it's DICOM data.
This requires to setup the DICOM network configuration of your system and the server.
By clicking on 'Add Server' a new plain server field will appear. Now you can give it a name of your choice.
Fill the servers "DICOM name" the AETitle. Type in it's url, it's port and the specific DICOM protocoll you want to use for image transfer.
\note I recommend not to use CGET because most of the PACS systems (Image Servers) don't support that protocoll.
You can configure the DICOM network configuration of your machine by editing the 'Calling AETiltle', the 'Storage AETitle' and The 'Storage Port' text fields.
But normaly you don't have to change your configuration.
\image html DicomFilterWidget.png "The DICOM search options"
After you have finished your network configuration and before you start the query you should use the 'Search Options' to specify your query.
Otherwise all data on the server will be queried and you will have to wait for a long time.
You can specify your query by searching for a specific patient name or a study or a serie or a specific DICOM object by it's id.
You are allowed to include or exclude DICOM modalities from your query and you can specify a specific time in which the DICOM images you are searching fo might been captured.
When you finished that you can click the query button and the queried DICOM data will appear.
<ul>
<li> Click on the 'Add Server' button.
<ul>
<li> Edit 'Name' field.
<li> Edit 'AETitle' field.
<li> Edit 'Adress' field.
<li> Edit 'Port' field.
</ul>
<li> Set search options.
<li> Click on 'Query' button.
</ul>
\subsection org_mitk_gui_qt_dicomRetrieve Retrieve
\image html DicomRetrieve.png "The queried DICOM data."
After the query you are able to select the queried data and click the 'Retrieve' button.
This will store the queried DICOM data into your DICOM storage.
Click on the 'Local Storage' button and work with your new data.
<ul>
<li> Click on the 'Retrieve' button to retrieve the data to your DICOM storage.
<li> Click on the 'Local Storage' button.
</ul>
*/
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkFiberfoxViewUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkFiberfoxViewUserManual.dox
index 22ba4ed943..6c04946775 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkFiberfoxViewUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkFiberfoxViewUserManual.dox
@@ -1,106 +1,109 @@
/**
\page org_mitk_views_fiberfoxview Fiberfox
This view provides the user interface for Fiberfox [1], an interactive simulation tool for defining artificial white matter fibers and generating corresponding diffusion weighted images. Arbitrary fiber configurations like bent, crossing, kissing, twisting, and fanning bundles can be intuitively defined by positioning only a few 3D waypoints to trigger the automated generation of synthetic fibers. From these fibers a diffusion weighted signal is simulated using a flexible combination of various diffusion models. It can be modified using specified acquisition settings such as gradient direction, b-value, signal-to-noise ratio, image size, and resolution.
<b>Available sections:</b>
- \ref QmitkFiberfoxViewUserManualFiberDefinition
- \ref QmitkFiberfoxViewUserManualSignalGeneration
- \ref QmitkFiberfoxViewUserManualKnownIssues
- \ref QmitkFiberfoxViewUserManualReferences
\image html Fiberfox.png Fig. 1: Screenshot of the Fiberfox framework. The four render windows display an axial (top left), sagittal (top right) and coronal (bottom left) 2D cut as well as a 3D view of a synthetic fiber helix and the fiducials used to define its shape. In the 2D views the helix is superimposing the baseline volume of the corresponding diffusion weighted image. The sagittal render window shows a close-up view on one of the circular fiducials.
\section QmitkFiberfoxViewUserManualFiberDefinition Fiber Definition
Fiber strands are defined simply by placing markers in a 3D image volume. The fibers are then interpolated between these fiducials.
<b>Example:</b>
\li Chose an image volume to place the markers used to define the fiber pathway. If you don't have such an image available switch to the "Signal Generation" tab, define the size and spacing of the desired image and click "Generate Image". If no fiber bundle is selected, this will generate a dummy image that can be used to place the fiducials.
\li Start placing fiducials at the desired positions to define the fiber pathway. To do that, click on the button with the circle pictogram, then click at the desired position and plane in the image volume and drag your mouse while keeping the button pressed to generate a circular shape. Adjust the shape using the control points (Fig. 2). The position of control point D introduces a twist of the fibers between two successive fiducials. The actual fiber generation is triggered automatically as soon as you place the second control point.
\li In some cases the fibers are entangled in a way that can't be resolved by introducing an additional fiber twist. Fiberfox tries to avoid these situations, which arise from different normal orientations of succeeding fiducials, automatically. In rare cases this is not successful. Use the double-arrow button to flip the fiber positions of the selected fiducial in one dimension. Either the problem is resolved now or you can resolve it manually by adjusting the twist-control point.
\image html Fiberfox-Fiducial.png Fig. 2: Control points defining the actual shape of the fiducial. A specifies the fiducials position in space, B and C the two ellipse radii and D the twisting angle between two successive fiducials.
<b>Fiber Options:</b>
\li <b>Real Time Fibers</b>: If checked, each parameter adjustment (fiducial position, number of fibers, ...) will be directly applied to the selected fiber bundle. If unchecked, the fibers will only be generated if the corresponding button "Generate Fibers" is clicked.
\li <b>Advanced Options</b>: Show/hide advanced options
\li <b>#Fibers</b>: Specifies the number of fibers that will be generated for the selected bundle.
\li <b>Fiber Sampling</b>: Adjusts the number of points per cm that make up the fiber. A higher sampling rate is needed if high curvatures are modeled.
\li <b>Tension, Continuity, Bias</b>: Parameters controlling the shape of the splines interpolation the fiducials. See <a href="http://en.wikipedia.org/wiki/Kochanek%E2%80%93Bartels_spline">Wikipedia</a> for details.
<b>Fiducial Options:</b>
\li <b>Use Constant Fiducial Radius</b>: If checked, all fiducials are treated as circles with the same radius. The first fiducial of the bundle defines the radius of all other fiducials.
\li <b>Align with grid</b>: Click to shift all fiducial center points to the next voxel center.
<b>Operations:</b>
\li <b>Rotation</b>: Define the rotation of the selected fiber bundle around each axis (in degree).
\li <b>Translation</b>: Define the translation of the selected fiber bundle along each axis (in mm).
\li <b>Scaling</b>: Define a scaling factor for the selected fiber bundle in each dimension.
\li <b>Transform Selection</b>: Apply specified rotation, translation and scaling to the selected Bundle/Fiducial
\li <b>Copy Bundles</b>: Add copies of the selected fiber bundles to the datamanager.
\li <b>Join Bundles</b>: Add new bundle to the datamanager that contains all fibers from the selected bundles.
\li <b>Include Fiducials</b>: If checked, the specified transformation is also applied to the fiducials belonging to the selected fiber bundle and the fiducials are also copied.
\image html FiberfoxExamples.png Fig. 3: Examples of artificial crossing (a,b), fanning (c,d), highly curved (e,f), kissing (g,h) and twisting (i,j) fibers as well as of the corresponding tensor images generated with Fiberfox.
\section QmitkFiberfoxViewUserManualSignalGeneration Signal Generation
To generate an artificial signal from the input fibers we follow the concepts recently presented by Panagiotaki et al. in a review and taxonomy of different compartment models [2]: a flexible model combining multiple compartments is used to simulate the anisotropic diffusion inside (intra-axonal compartment) and between axons (inter-axonal compartment), isotropic diffusion outside of the axons (extra-axonal compartment 1) and the restricted diffusion in other cell types (extra-axonal compartment 2) weighted according to their respective volume fraction.
A diffusion weighted image is generated from the fibers by selecting the according fiber bundle in the datamanager and clicking "Generate Image". If some other diffusion weighted image is selected together with the fiber bundle, Fiberfox directly uses the parameters of the selected image (size, spacing, gradient directions, b-values) for the signal generation process. Additionally a binary image can be selected that defines the tissue area. Voxels outside of this mask will contain no signal, only noise.
<b>Basic Image Settings:</b>
\li <b>Image Dimensions</b>: Specifies actual image size (number of voxels in each dimension).
\li <b>Image Spacing</b>: Specifies voxel size in mm. Beware that changing the voxel size also changes the signal strength, e.g. increasing the resolution from <em>2x2x2</em> mm to <em>1x1x1</em> mm decreases the signal obtained for each voxel by a factor 8.
\li <b>Gradient Directions</b>: Number of gradients directions distributed equally over the half sphere. 10% baseline images are automatically added.
\li <b>b-Value</b>: Diffusion weighting in s/mm². If an existing diffusion weighted image is used to set the basic parameters, the b-value is defined by the gradient direction magnitudes of this image, which also enables the use of multiple b-values.
<b>Advanced Image Settings (activate checkbox "Advanced Options"):</b>
\li <b>Repetitions</b>: Specifies the number of averages used for the acquisition to reduce noise.
\li <b>Signal Scale</b>: Additional scaling factor for the signal in each voxel. The default value of 125 results in a maximum signal amplitude of 1000 for <em>2x2x2</em> mm voxels. Beware that changing this value without changing the noise variance results in a changed SNR. Adjustment of this value might be needed if the overall signal values are much too high or much too low (depends on a variety of factors like voxel size and relaxation times).
\li <b>Echo Time <em>TE</em></b>: Time between the 90° excitation pulse and the first spin echo. Increasing this time results in a stronger <em>T2</em>-relaxation effect (<a href="http://en.wikipedia.org/wiki/Relaxation_%28NMR%29">Wikipedia</a>).
\li <b>Line Readout Time</b>: Time to read one line in k-space. Increasing this time results in a stronger <em>T2*</em> effect which causes an attenuation of the higher frequencies in phase direction (here along y-axis) which again results in a blurring effect of sharp edges perpendicular to the phase direction.
\li <b><em>T<sub>inhom</sub></em> Relaxation</b>: Time constant specifying the signal decay due to magnetic field inhomogeneities (also called <em>T2'</em>). Together with the tissue specific relaxation time constant <em>T2</em> this defines the <em>T2*</em> decay constant: <em>T2*=(T2 T2')/(T2+T2')</em>
\li <b>Fiber Radius (in µm)</b>: Used to calculate the volume fractions of the used compartments (fiber, water, etc.). If set to 0 (default) the fiber radius is set automatically so that the voxel containing the most fibers is filled completely. A realistic axon radius ranges from about 5 to 20 microns. Using the automatic estimation the resulting value might very well be much larger or smaller than this range.
\li <b>Interpolation Shrink</b>: The signal generated at each position along the fibers is distributed on the surrounding voxels using an interpolation scheme shaped like an arctangent function. Large values result in a steeper interpolation scheme approximating a nearest neighbor interpolation. Very small values result in an almost linear interpolation.
-\li <b>Enforce Pure Fiber Voxels</b>: If checked, the actual volume fractions of the single compartments are ignored. A voxel will either be filled by the intra axonal compartment completely or will contain no fiber at all.
+\li <b>Simulate Signal Relaxation</b>: If checked, the relaxation induced signal decay is simulated, other wise the parameters <em>TE</em>, Line Readout Time, <em>T<sub>inhom</sub></em>, and <em>T2</em> are ignored.
+\li <b>Disable Partial Volume Effects</b>: If checked, the actual volume fractions of the single compartments are ignored. A voxel will either be filled by the intra axonal compartment completely or will contain no fiber at all.
\li <b>Output k-Space Image</b>: Some of the effects simulated in our framework are modeled in the k-space representation of the actual image. Checking this box will output this frequency representation (amplitude spectrum).
<b>Compartment Settings:</b>
The group-boxes "Intra-axonal Compartment", "Inter-axonal Compartment" and "Extra-axonal Compartments" allow the specification which model to use and the corresponding model parameters. Currently the following models are implemented:
\li <b>Stick</b>: The “stick” model describes diffusion in an idealized cylinder with zero radius. Parameter: Diffusivity <em>d</em>
\li <b>Zeppelin</b>: Cylindrically symmetric diffusion tensor. Parameters: Parallel diffusivity <em>d<sub>||</sub></em> and perpendicular diffusivity <em>d<sub>⊥</sub></em>
\li <b>Tensor</b>: Full diffusion tensor. Parameters: Parallel diffusivity <em>d<sub>||</sub></em> and perpendicular diffusivity constants <em>d<sub>⊥1</sub></em> and <em>d<sub>⊥2</sub></em>
\li <b>Ball</b>: Isotropic compartment. Parameter: Diffusivity <em>d</em>
\li <b>Astrosticks</b>: Consists of multiple stick models pointing in different directions. The single stick orientations can either be distributed equally over the sphere or are sampled randomly. The model represents signal coming from a type of glial cell called astrocytes, or populations of axons with arbitrary orientation. Parameters: randomization of the stick orientations and diffusivity of the sticks <em>d</em>.
\li <b>Dot</b>: Isotropically restricted compartment. No parameter.
For a detailed description of the single models, please refer to Panagiotaki <em>et al.</em> "Compartment models of the diffusion MR signal in brain white matter: A taxonomy and comparison."[2]. Additionally to the model parameters, each compartment has its own <em>T2</em> signal relaxation constant (in <em>ms</em>).
<b>Noise and Artifacts:</b>
-\li <b>Variance</b>: Adds Rician noise with the specified variance to the signal.
-\li <b>Gibbs Ringing</b>: Ringing artifacts occurring on edges in the image due to the frequency low-pass filtering caused by the limited size of the k-space. The higher the oversampling factor, the larger the distance from the corresponding edge in which the ringing is still visible.
+\li <b>Rician Noise</b>: Add Rician noise with the specified variance to the signal.
+\li <b>N/2 Ghosts</b>: Specify the offset between successive lines in k-space. This offset causes ghost images in distance N/2 in phase direction due to the alternating EPI readout directions.
+\li <b>Distortions</b>: Simulate distortions due to magnetic field inhomogeneities. This is achieved by adding an additional phase during the readout process. The input is a frequency map specifying the inhomogeneities.
+\li <b>Gibbs Ringing</b>: Ringing artifacts occurring on edges in the image due to the frequency low-pass filtering caused by the limited size of the k-space. The higher the oversampling factor, the larger the distance from the corresponding edge in which the ringing is still visible. Keep in mind that increasing the oversampling factor results in a quadratic increase of computation time.
\section QmitkFiberfoxViewUserManualKnownIssues Known Issues
\li If fiducials are created in one of the marginal slices of the underlying image, a position change of the fiducial can be observed upon selection/deselection. If the fiducial is created in any other slice this bug does not occur.
\li If a scaling factor is applied to the selcted fiber bundle, the corresponding fiducials are not scaled accordingly.
\li In some cases the automatic update of the selected fiber bundle is not triggered even if "Real Time Fibers" is checked, e.g. if a fiducial is deleted. If this happens on can always force an update by pressing the "Generate Fibers" button.
If any other issues or feature requests arises during the use of Fiberfox, please don't hesitate to send us an e-mail or directly report the issue in our bugtracker: http://bugs.mitk.org/
\section QmitkFiberfoxViewUserManualReferences References
[1] Peter F. Neher, Bram Stieltjes, Frederik B. Laun, Hans-Peter Meinzer, and Klaus H. Fritzsche: Fiberfox: A novel tool to generate software phantoms of complex fiber geometries. In proceedings: ISMRM 2013
[2] Panagiotaki, E., Schneider, T., Siow, B., Hall, M.G., Lythgoe, M.F., Alexander, D.C.: Compartment models of the diffusion mr signal in brain white matter: A taxonomy and comparison. Neuroimage 59 (2012) 2241–2254
*/
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/files.cmake b/Plugins/org.mitk.gui.qt.diffusionimaging/files.cmake
index 32b8b924c9..090612aff9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/files.cmake
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/files.cmake
@@ -1,169 +1,173 @@
set(SRC_CPP_FILES
QmitkODFDetailsWidget.cpp
QmitkODFRenderWidget.cpp
QmitkPartialVolumeAnalysisWidget.cpp
QmitkIVIMWidget.cpp
QmitkTbssRoiAnalysisWidget.cpp
QmitkResidualAnalysisWidget.cpp
QmitkResidualViewWidget.cpp
QmitkTensorModelParametersWidget.cpp
QmitkZeppelinModelParametersWidget.cpp
QmitkStickModelParametersWidget.cpp
QmitkDotModelParametersWidget.cpp
QmitkBallModelParametersWidget.cpp
QmitkAstrosticksModelParametersWidget.cpp
)
set(INTERNAL_CPP_FILES
mitkPluginActivator.cpp
QmitkQBallReconstructionView.cpp
QmitkPreprocessingView.cpp
QmitkDiffusionDicomImportView.cpp
QmitkDiffusionQuantificationView.cpp
QmitkTensorReconstructionView.cpp
QmitkDiffusionImagingPublicPerspective.cpp
QmitkControlVisualizationPropertiesView.cpp
QmitkODFDetailsView.cpp
QmitkGibbsTrackingView.cpp
QmitkStochasticFiberTrackingView.cpp
QmitkStreamlineTrackingView.cpp
QmitkFiberProcessingView.cpp
QmitkFiberBundleDeveloperView.cpp
QmitkPartialVolumeAnalysisView.cpp
QmitkIVIMView.cpp
QmitkTractbasedSpatialStatisticsView.cpp
QmitkTbssTableModel.cpp
QmitkTbssMetaTableModel.cpp
QmitkTbssSkeletonizationView.cpp
Connectomics/QmitkConnectomicsDataView.cpp
Connectomics/QmitkConnectomicsNetworkOperationsView.cpp
Connectomics/QmitkConnectomicsStatisticsView.cpp
Connectomics/QmitkNetworkHistogramCanvas.cpp
QmitkDwiSoftwarePhantomView.cpp
QmitkOdfMaximaExtractionView.cpp
QmitkFiberfoxView.cpp
QmitkFiberExtractionView.cpp
+ QmitkFieldmapGeneratorView.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
src/internal/QmitkODFDetailsViewControls.ui
src/internal/QmitkGibbsTrackingViewControls.ui
src/internal/QmitkStochasticFiberTrackingViewControls.ui
src/internal/QmitkStreamlineTrackingViewControls.ui
src/internal/QmitkFiberProcessingViewControls.ui
src/internal/QmitkFiberBundleDeveloperViewControls.ui
src/internal/QmitkPartialVolumeAnalysisViewControls.ui
src/internal/QmitkIVIMViewControls.ui
src/internal/QmitkTractbasedSpatialStatisticsViewControls.ui
src/internal/QmitkTbssSkeletonizationViewControls.ui
src/internal/Connectomics/QmitkConnectomicsDataViewControls.ui
src/internal/Connectomics/QmitkConnectomicsNetworkOperationsViewControls.ui
src/internal/Connectomics/QmitkConnectomicsStatisticsViewControls.ui
src/internal/QmitkDwiSoftwarePhantomViewControls.ui
src/internal/QmitkOdfMaximaExtractionViewControls.ui
src/internal/QmitkFiberfoxViewControls.ui
src/internal/QmitkFiberExtractionViewControls.ui
src/QmitkTensorModelParametersWidgetControls.ui
src/QmitkZeppelinModelParametersWidgetControls.ui
src/QmitkStickModelParametersWidgetControls.ui
src/QmitkDotModelParametersWidgetControls.ui
src/QmitkBallModelParametersWidgetControls.ui
src/QmitkAstrosticksModelParametersWidgetControls.ui
+ src/internal/QmitkFieldmapGeneratorViewControls.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
src/internal/QmitkODFDetailsView.h
src/QmitkODFRenderWidget.h
src/QmitkODFDetailsWidget.h
src/internal/QmitkGibbsTrackingView.h
src/internal/QmitkStochasticFiberTrackingView.h
src/internal/QmitkStreamlineTrackingView.h
src/internal/QmitkFiberProcessingView.h
src/internal/QmitkFiberBundleDeveloperView.h
src/internal/QmitkPartialVolumeAnalysisView.h
src/QmitkPartialVolumeAnalysisWidget.h
src/internal/QmitkIVIMView.h
src/internal/QmitkTractbasedSpatialStatisticsView.h
src/internal/QmitkTbssSkeletonizationView.h
src/QmitkTbssRoiAnalysisWidget.h
src/QmitkResidualAnalysisWidget.h
src/QmitkResidualViewWidget.h
src/internal/Connectomics/QmitkConnectomicsDataView.h
src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.h
src/internal/Connectomics/QmitkConnectomicsStatisticsView.h
src/internal/Connectomics/QmitkNetworkHistogramCanvas.h
src/internal/QmitkDwiSoftwarePhantomView.h
src/internal/QmitkOdfMaximaExtractionView.h
src/internal/QmitkFiberfoxView.h
src/internal/QmitkFiberExtractionView.h
src/QmitkTensorModelParametersWidget.h
src/QmitkZeppelinModelParametersWidget.h
src/QmitkStickModelParametersWidget.h
src/QmitkDotModelParametersWidget.h
src/QmitkBallModelParametersWidget.h
src/QmitkAstrosticksModelParametersWidget.h
+ src/internal/QmitkFieldmapGeneratorView.h
)
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
plugin.xml
resources/preprocessing.png
resources/dwiimport.png
resources/quantification.png
resources/reconodf.png
resources/recontensor.png
resources/vizControls.png
resources/OdfDetails.png
resources/GibbsTracking.png
resources/FiberBundleOperations.png
resources/PartialVolumeAnalysis_24.png
resources/IVIM_48.png
resources/stochFB.png
resources/tbss.png
resources/connectomics/QmitkConnectomicsDataViewIcon_48.png
resources/connectomics/QmitkConnectomicsNetworkOperationsViewIcon_48.png
resources/connectomics/QmitkConnectomicsStatisticsViewIcon_48.png
resources/arrow.png
resources/qball_peaks.png
resources/phantom.png
resources/tensor.png
resources/qball.png
resources/StreamlineTracking.png
resources/dwi2.png
+ resources/odf.png
resources/refresh.xpm
)
set(QRC_FILES
# uncomment the following line if you want to use Qt resources
resources/QmitkDiffusionImaging.qrc
#resources/QmitkTractbasedSpatialStatisticsView.qrc
)
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/Plugins/org.mitk.gui.qt.diffusionimaging/plugin.xml b/Plugins/org.mitk.gui.qt.diffusionimaging/plugin.xml
index 662563552d..82e1bb5613 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/plugin.xml
@@ -1,167 +1,176 @@
<?xml version="1.0" encoding="UTF-8"?>
<?BlueBerry version="0.1"?>
<plugin>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.qballreconstruction"
name="Q-Balls"
icon="resources/qball.png"
class="QmitkQBallReconstructionView" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.diffusiondicomimport"
name="DICOM Import"
class="QmitkDiffusionDicomImport"
icon="resources/dwiimport.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.diffusionpreprocessing"
name="Preprocessing"
class="QmitkPreprocessingView"
icon="resources/dwi2.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.diffusionquantification"
name="Scalar Indices"
class="QmitkDiffusionQuantificationView"
icon="resources/quantification.png"/>
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.tensorreconstruction"
name="Tensors"
icon="resources/tensor.png"
class="QmitkTensorReconstructionView" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.controlvisualizationpropertiesview"
name="Visualization"
icon="resources/vizControls.png"
class="QmitkControlVisualizationPropertiesView" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.ivim"
name="IVIM"
class="QmitkIVIMView"
icon="resources/IVIM_48.png" />
</extension>
<extension point="org.blueberry.ui.perspectives">
<perspective id="org.mitk.perspectives.publicdiffusionimaging"
name="Diffusion Imaging Public"
class="QmitkDiffusionImagingPublicPerspective"
icon="resources/reconodf.png"/>
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.odfdetails"
name="ODF Details"
class="QmitkODFDetailsView"
icon="resources/OdfDetails.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.gibbstracking"
name="Gibbs Tracking"
class="QmitkGibbsTrackingView"
icon="resources/GibbsTracking.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.stochasticfibertracking"
name="Stochastic Tracking"
class="QmitkStochasticFiberTrackingView"
icon="resources/stochFB.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.streamlinetracking"
name="Streamline Tracking"
class="QmitkStreamlineTrackingView"
icon="resources/StreamlineTracking.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.fiberprocessing"
name="Fiber Processing"
class="QmitkFiberProcessingView"
icon="resources/FiberBundleOperations.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.fiberextraction"
name="Fiber Extraction"
class="QmitkFiberExtractionView"
icon="resources/FiberBundleOperations.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.fiberbundledeveloper"
name="FiberDevTool"
class="QmitkFiberBundleDeveloperView"
icon="resources/FiberBundleOperations.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.partialvolumeanalysisview"
name="PV Analysis"
class="QmitkPartialVolumeAnalysisView"
icon="resources/PartialVolumeAnalysis_24.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.tbssskeletonization"
name="Tbss Skeletonization"
class="QmitkTbssSkeletonizationView"
icon="resources/tbss.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.tractbasedspatialstatistics"
name="Tract-based spatial statistics"
class="QmitkTractbasedSpatialStatisticsView"
icon="resources/tbss.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.connectomicsnetworkoperations"
name="Network Operations"
class="QmitkConnectomicsNetworkOperationsView"
icon="resources/connectomics/QmitkConnectomicsNetworkOperationsViewIcon_48.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.connectomicsdata"
name="Network Data"
class="QmitkConnectomicsDataView"
icon="resources/connectomics/QmitkConnectomicsDataViewIcon_48.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.connectomicsstatistics"
name="Network Statistics"
class="QmitkConnectomicsStatisticsView"
icon="resources/connectomics/QmitkConnectomicsStatisticsViewIcon_48.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.odfmaximaextraction"
name="Peak Extraction"
class="QmitkOdfMaximaExtractionView"
icon="resources/qball_peaks.png" />
</extension>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.fiberfoxview"
name="Fiberfox"
class="QmitkFiberfoxView"
icon="resources/phantom.png" />
</extension>
+ <extension point="org.blueberry.ui.views">
+ <view id="org.mitk.views.fieldmapgenerator"
+ name="Fieldmap Generator"
+ class="QmitkFieldmapGeneratorView"
+ icon="resources/odf.png" />
+ </extension>
+
+
+
</plugin>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc b/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc
index b38091991a..9caa2bf372 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc
@@ -1,37 +1,38 @@
<RCC>
<qresource prefix="/QmitkDiffusionImaging">
<file>qball.png</file>
<file>tensor.png</file>
<file>dwi.png</file>
<file>dwiimport.png</file>
<file>quantification.png</file>
<file>reconodf.png</file>
<file>recontensor.png</file>
<file>texIntONIcon.png</file>
<file>texIntOFFIcon.png</file>
<file>vizControls.png</file>
<file>Refresh_48.png</file>
<file>QBallData24.png</file>
<file>glyphsoff_C.png</file>
<file>glyphsoff_S.png</file>
<file>glyphsoff_T.png</file>
<file>glyphson_C.png</file>
<file>glyphson_S.png</file>
<file>glyphson_T.png</file>
<file>FiberBundle.png</file>
<file>FiberBundleX.png</file>
<file>connectomics/ConnectomicsNetwork.png</file>
<file>rectangle.png</file>
<file>circle.png</file>
<file>polygon.png</file>
<file>color24.gif</file>
<file>color48.gif</file>
<file>color64.gif</file>
<file>crosshair.png</file>
<file>paint2.png</file>
<file>IVIM_48.png</file>
<file>reset.png</file>
<file>MapperEfx2D.png</file>
<file>refresh.xpm</file>
+ <file>odf.png</file>
</qresource>
</RCC>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
index f9007d45d2..118e7e599c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
@@ -1,973 +1,968 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkTbssRoiAnalysisWidget.h"
#include <qlabel.h>
#include <qpen.h>
#include <qgroupbox.h>
#include <qwt_text.h>
#include <qwt_plot_grid.h>
#include <qwt_painter.h>
#include <qwt_legend.h>
#include <qwt_plot_marker.h>
#include <iostream>
#include <fstream>
#include <limits>
#include <vtkCellArray.h>
QmitkTbssRoiAnalysisWidget::QmitkTbssRoiAnalysisWidget( QWidget * parent )
: QmitkPlotWidget(parent)
{
m_PlotPicker = new QwtPlotPicker(m_Plot->canvas());
m_PlotPicker->setSelectionFlags(QwtPicker::PointSelection | QwtPicker::ClickSelection | QwtPicker::DragSelection);
m_PlotPicker->setTrackerMode(QwtPicker::ActiveOnly);
m_PlottingFiberBundle = false;
}
void QmitkTbssRoiAnalysisWidget::DoPlotFiberBundles(mitk::FiberBundleX *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg, int number)
{
mitk::Geometry3D* currentGeometry = fib->GetGeometry();
mitk::PlaneGeometry* startGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(startRoi->GetGeometry2D()) );
mitk::PlaneGeometry* endGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(endRoi->GetGeometry2D()) );
mitk::Point3D startCenter = startRoi->GetWorldControlPoint(0); //center Point of start roi
mitk::Point3D endCenter = endRoi->GetWorldControlPoint(0); //center Point of end roi
mitk::FiberBundleX::Pointer inStart = fib->ExtractFiberSubset(startRoi);
mitk::FiberBundleX::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
int num = inBoth->GetNumFibers();
TractContainerType tracts;
vtkSmartPointer<vtkPolyData> fiberPolyData = inBoth->GetFiberPolyData();
vtkCellArray* lines = fiberPolyData->GetLines();
lines->InitTraversal();
// Now find out for each fiber which ROI is encountered first. If this is the startRoi, the direction is ok
// Otherwise the plot should be in the reverse direction
for( int fiberID( 0 ); fiberID < num; fiberID++ )
{
vtkIdType numPointsInCell(0);
vtkIdType* pointsInCell(NULL);
lines->GetNextCell ( numPointsInCell, pointsInCell );
int startId = 0;
int endId = 0;
float minDistStart = std::numeric_limits<float>::max();
float minDistEnd = std::numeric_limits<float>::max();
for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
{
double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
mitk::Point3D point;
point[0] = p[0];
point[1] = p[1];
point[2] = p[2];
float distanceToStart = point.EuclideanDistanceTo(startCenter);
float distanceToEnd = point.EuclideanDistanceTo(endCenter);
if(distanceToStart < minDistStart)
{
minDistStart = distanceToStart;
startId = pointInCellID;
}
if(distanceToEnd < minDistEnd)
{
minDistEnd = distanceToEnd;
endId = pointInCellID;
}
}
/* We found the start and end points of of the part that should be plottet for
the current fiber. now we need to plot them. If the endId is smaller than the startId the plot order
must be reversed*/
TractType singleTract;
PointType point;
if(startId < endId)
{
// Calculate the intersection of the ROI with the startRoi and decide if the startId is part of the roi or must be cut of
double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
mitk::Vector3D p0;
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
mitk::Vector3D p1;
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
// Check if p and p2 are both on the same side of the plane
mitk::Vector3D normal = startGeometry2D->GetNormal();
mitk::Point3D pStart;
pStart[0] = p0[0]; pStart[1] = p0[1]; pStart[2] = p0[2];
mitk::Point3D pSecond;
pSecond[0] = p1[0]; pSecond[1] = p1[1]; pSecond[2] = p1[2];
bool startOnPositive = startGeometry2D->IsAbove(pStart);
bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
mitk::Vector3D onPlane;
onPlane[0] = startCenter[0]; onPlane[1] = startCenter[1]; onPlane[2] = startCenter[2];
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId+1 lie on the same side of the plane, so we need
need startId-1 to calculate the intersection with the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
}
double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
mitk::Vector3D newPoint = (p0-p1);
point[0] = d*newPoint[0] + p0[0];
point[1] = d*newPoint[1] + p0[1];
point[2] = d*newPoint[2] + p0[2];
singleTract.push_back(point);
if(! (secondOnPositive ^ startOnPositive) )
{
/* StartId and startId+1 lie on the same side of the plane
so startId is also part of the ROI*/
double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
point[0] = start[0]; point[1] = start[1]; point[2] = start[2];
singleTract.push_back(point);
}
for( int pointInCellID( startId+1 ); pointInCellID < endId ; pointInCellID++)
{
// push back point
double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
singleTract.push_back( point );
}
/* endId must be included if endId and endId-1 lie on the same side of the
plane defined by endRoi*/
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
mitk::Point3D pLast;
pLast[0] = p0[0]; pLast[1] = p0[1]; pLast[2] = p0[2];
mitk::Point3D pBeforeLast;
pBeforeLast[0] = p1[0]; pBeforeLast[1] = p1[1]; pBeforeLast[2] = p1[2];
normal = endGeometry2D->GetNormal();
bool lastOnPositive = endGeometry2D->IsAbove(pLast);
bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
onPlane[0] = endCenter[0];
onPlane[1] = endCenter[1];
onPlane[2] = endCenter[2];
if(! (lastOnPositive ^ secondLastOnPositive) )
{
/* endId and endId-1 lie on the same side of the plane, so we need
need endId+1 to calculate the intersection with the planar figure.
this should exist since we know that the fiber crosses the planar figure
endId is also part of the tract and can be inserted here */
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
singleTract.push_back( point );
p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
}
d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
newPoint = (p0-p1);
point[0] = d*newPoint[0] + p0[0];
point[1] = d*newPoint[1] + p0[1];
point[2] = d*newPoint[2] + p0[2];
singleTract.push_back(point);
}
else{
// Calculate the intersection of the ROI with the startRoi and decide if the startId is part of the roi or must be cut of
double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
mitk::Vector3D p0;
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
mitk::Vector3D p1;
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
// Check if p and p2 are both on the same side of the plane
mitk::Vector3D normal = startGeometry2D->GetNormal();
mitk::Point3D pStart;
pStart[0] = p0[0]; pStart[1] = p0[1]; pStart[2] = p0[2];
mitk::Point3D pSecond;
pSecond[0] = p1[0]; pSecond[1] = p1[1]; pSecond[2] = p1[2];
bool startOnPositive = startGeometry2D->IsAbove(pStart);
bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
mitk::Vector3D onPlane;
onPlane[0] = startCenter[0]; onPlane[1] = startCenter[1]; onPlane[2] = startCenter[2];
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId+1 lie on the same side of the plane, so we need
need startId-1 to calculate the intersection with the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
}
double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
mitk::Vector3D newPoint = (p0-p1);
point[0] = d*newPoint[0] + p0[0];
point[1] = d*newPoint[1] + p0[1];
point[2] = d*newPoint[2] + p0[2];
singleTract.push_back(point);
if(! (secondOnPositive ^ startOnPositive) )
{
/* StartId and startId+1 lie on the same side of the plane
so startId is also part of the ROI*/
double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
point[0] = start[0]; point[1] = start[1]; point[2] = start[2];
singleTract.push_back(point);
}
for( int pointInCellID( startId-1 ); pointInCellID > endId ; pointInCellID--)
{
// push back point
double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
singleTract.push_back( point );
}
/* endId must be included if endId and endI+1 lie on the same side of the
plane defined by endRoi*/
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
mitk::Point3D pLast;
pLast[0] = p0[0]; pLast[1] = p0[1]; pLast[2] = p0[2];
mitk::Point3D pBeforeLast;
pBeforeLast[0] = p1[0]; pBeforeLast[1] = p1[1]; pBeforeLast[2] = p1[2];
bool lastOnPositive = endGeometry2D->IsAbove(pLast);
bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
normal = endGeometry2D->GetNormal();
onPlane[0] = endCenter[0];
onPlane[1] = endCenter[1];
onPlane[2] = endCenter[2];
if(! (lastOnPositive ^ secondLastOnPositive) )
{
/* endId and endId+1 lie on the same side of the plane, so we need
need endId-1 to calculate the intersection with the planar figure.
this should exist since we know that the fiber crosses the planar figure
endId is also part of the tract and can be inserted here */
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
singleTract.push_back( point );
p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
}
d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
newPoint = (p0-p1);
point[0] = d*newPoint[0] + p0[0];
point[1] = d*newPoint[1] + p0[1];
point[2] = d*newPoint[2] + p0[2];
singleTract.push_back(point);
}
tracts.push_back(singleTract);
}
//todo: Make number of samples selectable by user
TractContainerType resampledTracts = ParameterizeTracts(tracts, number);
// Now we have the resampled tracts. Next we should use these points to read out the values
PlotFiberBundles(resampledTracts, img, avg);
m_CurrentTracts = resampledTracts;
}
void QmitkTbssRoiAnalysisWidget::PlotFiberBetweenRois(mitk::FiberBundleX *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg, int number)
{
if(fib == NULL || img == NULL || startRoi == NULL || endRoi == NULL)
return;
m_Fib = fib;
m_CurrentImage = img;
m_CurrentStartRoi = startRoi;
m_CurrentEndRoi = endRoi;
DoPlotFiberBundles(fib, img, startRoi, endRoi, avg, number);
}
void QmitkTbssRoiAnalysisWidget::ModifyPlot(int number, bool avg)
{
if(m_Fib == NULL || m_CurrentImage == NULL || m_CurrentStartRoi == NULL || m_CurrentEndRoi == NULL)
return;
DoPlotFiberBundles(m_Fib, m_CurrentImage, m_CurrentStartRoi, m_CurrentEndRoi, avg, number);
}
TractContainerType QmitkTbssRoiAnalysisWidget::ParameterizeTracts(TractContainerType tracts, int number)
{
TractContainerType resampledTracts;
for(TractContainerType::iterator it = tracts.begin(); it != tracts.end(); ++it)
{
TractType resampledTract;
TractType tract = *it;
// Calculate the total length
float totalLength = 0;
if(tract.size() < 2)
continue;
PointType p0 = tract.at(0);
for(int i = 1; i<tract.size(); i++)
{
PointType p1 = tract.at(i);
float length = p0.EuclideanDistanceTo(p1);
totalLength += length;
p0 = p1;
}
float stepSize = totalLength / number;
p0 = tract.at(0);
PointType p1 = tract.at(1);
int tractCounter = 2;
float distance = p0.EuclideanDistanceTo(p1);
float locationBetween = 0;
for(float position = 0;
position <= totalLength+0.001 && resampledTract.size() <= (number+1);
position+=stepSize)
{
/* In case we walked to far we need to find the next segment we are on and on what relative position on that
tract we are on. Small correction for rounding errors */
while(locationBetween > distance+0.001)
{
if(tractCounter == tract.size())
std::cout << "problem";
// Determine by what distance we are no on the next segment
locationBetween = locationBetween - distance;
p0 = p1;
p1 = tract.at(tractCounter);
tractCounter++;
distance = p0.EuclideanDistanceTo(p1);
}
// Direction
PointType::VectorType direction = p1-p0;
direction.Normalize();
PointType newSample = p0 + direction*locationBetween;
resampledTract.push_back(newSample);
locationBetween += stepSize;
}
resampledTracts.push_back(resampledTract);
}
return resampledTracts;
}
mitk::Point3D QmitkTbssRoiAnalysisWidget::GetPositionInWorld(int index)
{
TractContainerType tractsAtIndex;
float xSum = 0.0;
float ySum = 0.0;
float zSum = 0.0;
for(TractContainerType::iterator it = m_CurrentTracts.begin();
it!=m_CurrentTracts.end(); ++it)
{
TractType tract = *it;
PointType p = tract.at(index);
xSum += p[0];
ySum += p[1];
zSum += p[2];
}
int number = m_CurrentTracts.size();
float xPos = xSum / number;
float yPos = ySum / number;
float zPos = zSum / number;
mitk::Point3D pos;
pos[0] = xPos;
pos[1] = yPos;
pos[2] = zPos;
return pos;
}
std::vector< std::vector<double> > QmitkTbssRoiAnalysisWidget::CalculateGroupProfiles(std::string preprocessed)
{
MITK_INFO << "make profiles!";
std::vector< std::vector<double> > profiles;
//No results were preprocessed, so they must be calculated now.
if(preprocessed == "")
{
// Iterate through the 4th dim (corresponding to subjects)
// and create a profile for every subject
int size = m_Projections->GetVectorLength();
for(int s=0; s<size; s++)
{
// Iterate trough the roi
std::vector<double> profile;
RoiType::iterator it;
it = m_Roi.begin();
while(it != m_Roi.end())
{
itk::Index<3> ix = *it;
profile.push_back(m_Projections->GetPixel(ix).GetElement(s));
it++;
}
int pSize = profile.size();
profiles.push_back(profile);
}
}
else{ // Use preprocessed results
std::ifstream file(preprocessed.c_str());
if(file.is_open())
{
std::string line;
while(getline(file,line))
{
std::vector<std::string> tokens;
Tokenize(line, tokens);
std::vector<std::string>::iterator it;
it = tokens.begin();
std::vector< double > profile;
while(it != tokens.end())
{
std::string s = *it;
profile.push_back (atof( s.c_str() ) );
++it;
}
profiles.push_back(profile);
}
}
}
m_IndividualProfiles = profiles;
// Calculate the averages
// Here a check could be build in to check whether all profiles have
// the same length, but this should normally be the case if the input
// data were corrected with the TBSS Module.
std::vector< std::vector<double> > groupProfiles;
std::vector< std::pair<std::string, int> >::iterator it;
it = m_Groups.begin();
int c = 0; //the current profile number
int nprof = profiles.size();
while(it != m_Groups.end() && profiles.size() > 0)
{
std::pair<std::string, int> p = *it;
int size = p.second;
//initialize a vector of the right length with zeroes
std::vector<double> averageProfile;
for(int i=0; i<profiles.at(0).size(); i++)
{
averageProfile.push_back(0.0);
}
// Average the right number of profiles
for(int i=0; i<size; i++)
{
for(int j=0; j<averageProfile.size(); ++j)
{
averageProfile.at(j) = averageProfile.at(j) + profiles.at(c).at(j);
}
c++;
}
// Devide by the number of profiles to get group average
for(int i=0; i<averageProfile.size(); i++)
{
averageProfile.at(i) = averageProfile.at(i) / size;
}
groupProfiles.push_back(averageProfile);
++it;
}
int pSize = groupProfiles.size();
return groupProfiles;
}
void QmitkTbssRoiAnalysisWidget::DrawProfiles(std::string preprocessed)
{
this->Clear();
m_Vals.clear();
std::vector<double> v1;
std::vector <std::vector<double> > groupProfiles = CalculateGroupProfiles(preprocessed);
std::vector<double> xAxis;
for(int i=0; i<groupProfiles.at(0).size(); ++i)
{
xAxis.push_back((double)i);
}
// fill m_Vals. This might be used by the user to copy data to the clipboard
for(int i=0; i<groupProfiles.size(); i++)
{
v1.clear();
for(int j=0; j<groupProfiles.at(i).size(); j++)
{
v1.push_back(groupProfiles.at(i).at(j));
}
m_Vals.push_back(v1);
}
std::string title = m_Measure + " profiles on the ";
title.append(m_Structure);
this->SetPlotTitle( title.c_str() );
QPen pen( Qt::SolidLine );
pen.setWidth(2);
std::vector< std::pair<std::string, int> >::iterator it;
it = m_Groups.begin();
int c = 0; //the current profile number
QColor colors[4] = {Qt::green, Qt::blue, Qt::yellow, Qt::red};
while(it != m_Groups.end() && groupProfiles.size() > 0)
{
std::pair< std::string, int > group = *it;
pen.setColor(colors[c]);
int curveId = this->InsertCurve( group.first.c_str() );
this->SetCurveData( curveId, xAxis, groupProfiles.at(c) );
this->SetCurvePen( curveId, pen );
c++;
it++;
}
QwtLegend *legend = new QwtLegend;
this->SetLegend(legend, QwtPlot::RightLegend, 0.5);
std::cout << m_Measure << std::endl;
this->m_Plot->setAxisTitle(0, m_Measure.c_str());
this->m_Plot->setAxisTitle(3, "Position");
this->Replot();
}
void QmitkTbssRoiAnalysisWidget::PlotFiberBundles(TractContainerType tracts, mitk::Image *img, bool avg)
{
this->Clear();
std::vector<TractType>::iterator it = tracts.begin();
// Match points on tracts. Take the smallest tract and match all others on this one
/*
int min = std::numeric_limits<int>::max();
TractType smallestTract;
while(it != tracts.end())
{
TractType tract = *it;
if(tract.size()<min)
{
smallestTract = tract;
min = tract.size();
}
++it;
}
it = tracts.begin();
while(it != tracts.end())
{
TractType tract = *it;
if(tract == smallestTract)
{
++it;
continue;
}
// Finding correspondences between points
std::vector<int> correspondingIndices;
TractType correspondingPoints;
for(int i=0; i<smallestTract.size(); i++)
{
PointType p = smallestTract[i];
double minDist = std::numeric_limits<float>::max();
int correspondingIndex = 0;
PointType correspondingPoint;
// Search for the point on the second tract with the smallest distance
// to p and memorize it
for(int j=0; j<tract.size(); j++)
{
PointType p2 = tract[j];
double dist = fabs( p.EuclideanDistanceTo(p2) );
if(dist < minDist)
{
correspondingIndex = j;
correspondingPoint = p2;
minDist = dist;
}
}
correspondingIndices.push_back(correspondingIndex);
correspondingPoints.push_back(correspondingPoint);
}
if(smallestTract.size() != correspondingIndices.size())
{
MITK_ERROR << "smallest tract and correspondingIndices have no equal size";
continue;
}
std::cout << "corresponding points\n";
for(int i=0; i<smallestTract.size(); i++)
{
PointType p = smallestTract[i];
PointType p2 = correspondingPoints[i];
std::cout << "[" << p[0] << ", " << p[1] << ", " << p[2] << ", ["
<< p2[0] << ", " << p2[1] << ", " << p2[2] << "]\n";
}
std::cout << std::endl;
++it;
}
*/
// Get the values along the curves from a 3D images. should also contain info about the position on screen.
std::vector< std::vector <double > > profiles;
it = tracts.begin();
while(it != tracts.end())
{
std::cout << "Tract\n";
TractType tract = *it;
TractType::iterator tractIt = tract.begin();
std::vector<double> profile;
while(tractIt != tract.end())
{
PointType p = *tractIt;
std::cout << p[0] << ' ' << p[1] << ' ' << p[2] << '\n';
// Get value from image
profile.push_back( (double)img->GetPixelValueByWorldCoordinate(p) );
++tractIt;
}
profiles.push_back(profile);
std::cout << std::endl;
++it;
}
if(profiles.size() == 0)
return;
m_IndividualProfiles = profiles;
std::string title = "Fiber bundle plot";
this->SetPlotTitle( title.c_str() );
// initialize average profile
std::vector<double> averageProfile;
std::vector<double> profile = profiles.at(0); // can do this because we checked the size of profiles before
for(int i=0; i<profile.size(); ++i)
{
averageProfile.push_back(0.0);
}
std::vector< std::vector<double> >::iterator profit = profiles.begin();
int id=0;
while(profit != profiles.end())
{
std::vector<double> profile = *profit;
std::vector<double> xAxis;
for(int i=0; i<profile.size(); ++i)
{
xAxis.push_back((double)i);
averageProfile.at(i) += profile.at(i) / profiles.size();
}
int curveId = this->InsertCurve( QString::number(id).toStdString().c_str() );
this->SetCurveData( curveId, xAxis, profile );
++profit;
id++;
}
m_Average = averageProfile;
if(avg)
{
// Draw the average profile
std::vector<double> xAxis;
for(int i=0; i<averageProfile.size(); ++i)
{
xAxis.push_back((double)i);
}
int curveId = this->InsertCurve( QString::number(id).toStdString().c_str() );
this->SetCurveData( curveId, xAxis, averageProfile );
QPen pen( Qt::SolidLine );
pen.setWidth(3);
pen.setColor(Qt::red);
this->SetCurvePen( curveId, pen );
id++;
}
this->Replot();
}
-void QmitkTbssRoiAnalysisWidget::Boxplots()
-{
- this->Clear();
-}
-
void QmitkTbssRoiAnalysisWidget::drawBar(int x)
{
m_Plot->detachItems(QwtPlotItem::Rtti_PlotMarker, true);
QwtPlotMarker *mX = new QwtPlotMarker();
//mX->setLabel(QString::fromLatin1("selected point"));
mX->setLabelAlignment(Qt::AlignLeft | Qt::AlignBottom);
mX->setLabelOrientation(Qt::Vertical);
mX->setLineStyle(QwtPlotMarker::VLine);
mX->setLinePen(QPen(Qt::black, 0, Qt::SolidLine));
mX->setXValue(x);
mX->attach(m_Plot);
this->Replot();
}
QmitkTbssRoiAnalysisWidget::~QmitkTbssRoiAnalysisWidget()
{
delete m_PlotPicker;
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
index 3002f61d35..6c85b4f9d7 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
@@ -1,223 +1,217 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkTbssRoiAnalysisWidget_H_
#define QmitkTbssRoiAnalysisWidget_H_
#include "QmitkPlotWidget.h"
#include <org_mitk_gui_qt_diffusionimaging_Export.h>
-//#include "QmitkHistogram.h"
#include "QmitkExtExports.h"
-#include "mitkImage.h"
#include "mitkPlanarFigure.h"
#include "itkVectorImage.h"
#include <mitkFiberBundleX.h>
#include <mitkPlanarCircle.h>
-//#include <itkHistogram.h>
-
-//#include <vtkQtChartWidget.h>
-#include <vtkQtBarChart.h>
-#include <QStandardItemModel>
#include <qwt_plot.h>
-#include <QPainter>
#include <qwt_plot_picker.h>
typedef itk::VectorImage<float,3> VectorImageType;
-
typedef std::vector< itk::Index<3> > RoiType;
-
typedef itk::Point<float,3> PointType;
typedef std::vector< PointType> TractType;
typedef std::vector< TractType > TractContainerType;
/**
- * \brief Widget for displaying boxplots
- * framework
+ * \brief Plot widget for TBSS Data
+ * This widget can plot regions of interest on TBSS projection data.
*/
class DIFFUSIONIMAGING_EXPORT QmitkTbssRoiAnalysisWidget : public QmitkPlotWidget
{
Q_OBJECT
public:
QmitkTbssRoiAnalysisWidget( QWidget * parent);
virtual ~QmitkTbssRoiAnalysisWidget();
+
+ /* \brief Set group information */
void SetGroups(std::vector< std::pair<std::string, int> > groups)
{
m_Groups = groups;
}
+ /* \brief Draws the group averaged profiles */
void DrawProfiles(std::string preprocessed);
void PlotFiberBundles(TractContainerType tracts, mitk::Image* img, bool avg=false);
- void Boxplots();
-
+ /* \brief Sets the projections of the individual subjects */
void SetProjections(VectorImageType::Pointer projections)
{
m_Projections = projections;
}
+ /* \brief Set the region of interest*/
void SetRoi(RoiType roi)
{
m_Roi = roi;
}
+ /* \brief Set structure information to display in the plot */
void SetStructure(std::string structure)
{
m_Structure = structure;
}
+ /* \brief Set measurement type for display in the plot */
void SetMeasure(std::string measure)
{
m_Measure = measure;
}
- QwtPlot* GetPlot()
- {
- return m_Plot;
- }
-
- QwtPlotPicker* m_PlotPicker;
-
+ /* \brief Draws a bar to indicate were the user clicked in the plot */
+ void drawBar(int x);
- void drawBar(int x);
+ /* \brief Returns the values of the group averaged profiles */
std::vector <std::vector<double> > GetVals()
{
return m_Vals;
}
+
+ /* \brief Returns the values of the individual subjects profiles */
std::vector <std::vector<double> > GetIndividualProfiles()
{
return m_IndividualProfiles;
}
std::vector<double> GetAverageProfile()
{
return m_Average;
}
void SetPlottingFiber(bool b)
{
m_PlottingFiberBundle = b;
}
bool IsPlottingFiber()
{
return m_PlottingFiberBundle;
}
void PlotFiberBetweenRois(mitk::FiberBundleX *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg=-1, int number=25);
// Takes an index which is an x coordinate from the plot and finds the corresponding position in world space
mitk::Point3D GetPositionInWorld(int index);
void ModifyPlot(int number, bool avg);
+
+
+ QwtPlotPicker* m_PlotPicker;
+
protected:
mitk::FiberBundleX* m_Fib;
std::vector< std::vector<double> > m_Vals;
std::vector< std::vector<double> > m_IndividualProfiles;
std::vector< double > m_Average;
-
-
std::vector< std::vector<double> > CalculateGroupProfiles(std::string preprocessed);
void Tokenize(const std::string& str,
std::vector<std::string>& tokens,
const std::string& delimiters = " ")
{
// Skip delimiters at beginning.
std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
// Find first "non-delimiter".
std::string::size_type pos = str.find_first_of(delimiters, lastPos);
while (std::string::npos != pos || std::string::npos != lastPos)
{
// Found a token, add it to the vector.
tokens.push_back(str.substr(lastPos, pos - lastPos));
// Skip delimiters. Note the "not_of"
lastPos = str.find_first_not_of(delimiters, pos);
// Find next "non-delimiter"
pos = str.find_first_of(delimiters, lastPos);
}
}
std::vector< std::pair<std::string, int> > m_Groups;
VectorImageType::Pointer m_Projections;
RoiType m_Roi;
std::string m_Structure;
std::string m_Measure;
bool m_PlottingFiberBundle; // true when the plot results from a fiber tracking result (vtk .fib file)
// Resample a collection of tracts so that every tract contains #number equidistant samples
TractContainerType ParameterizeTracts(TractContainerType tracts, int number);
TractContainerType m_CurrentTracts;
mitk::Image* m_CurrentImage;
mitk::PlanarFigure* m_CurrentStartRoi;
mitk::PlanarFigure* m_CurrentEndRoi;
void DoPlotFiberBundles(mitk::FiberBundleX *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg=false, int number=25);
};
#endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkZeppelinModelParametersWidgetControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkZeppelinModelParametersWidgetControls.ui
index 418098a551..ceca723203 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkZeppelinModelParametersWidgetControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkZeppelinModelParametersWidgetControls.ui
@@ -1,124 +1,124 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkZeppelinModelParametersWidgetControls</class>
<widget class="QWidget" name="QmitkZeppelinModelParametersWidgetControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>410</width>
<height>116</height>
</rect>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<property name="margin">
<number>0</number>
</property>
<item row="3" column="1">
<widget class="QLabel" name="m_FaLabel">
<property name="toolTip">
<string>Fractional anisotropy of resulting tensor.</string>
</property>
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;-&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QDoubleSpinBox" name="m_D2box">
<property name="toolTip">
<string>Diffusivity along second and third eigenvector.</string>
</property>
<property name="decimals">
<number>5</number>
</property>
<property name="maximum">
<double>1.000000000000000</double>
</property>
<property name="singleStep">
<double>0.000100000000000</double>
</property>
<property name="value">
<double>0.000250000000000</double>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSpinBox" name="m_T2box">
<property name="toolTip">
<string>T2 relaxation time of this compartment (in milliseconds).</string>
</property>
<property name="maximum">
<number>10000</number>
</property>
<property name="value">
- <number>100</number>
+ <number>200</number>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QDoubleSpinBox" name="m_D1box">
<property name="toolTip">
<string>Diffusivity along largest eigenvector.</string>
</property>
<property name="decimals">
<number>5</number>
</property>
<property name="maximum">
<double>1.000000000000000</double>
</property>
<property name="singleStep">
<double>0.000100000000000</double>
</property>
<property name="value">
<double>0.001000000000000</double>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label_2">
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;d&lt;/span&gt;&lt;span style=&quot; vertical-align:sub;&quot;&gt;⟂&lt;/span&gt;:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;d&lt;/span&gt;&lt;span style=&quot; vertical-align:sub;&quot;&gt;||&lt;/span&gt;:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_5">
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;T2&lt;/span&gt; - Relaxation:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QLabel" name="label_4">
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;FA&lt;/span&gt;:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
</widget>
</item>
</layout>
</widget>
<tabstops>
<tabstop>m_T2box</tabstop>
<tabstop>m_D1box</tabstop>
<tabstop>m_D2box</tabstop>
</tabstops>
<resources/>
<connections/>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
index 9845efa0e5..d089e8f2ee 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
@@ -1,392 +1,392 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// ####### Blueberry includes #######
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// ####### Qmitk includes #######
#include "QmitkConnectomicsDataView.h"
#include "QmitkStdMultiWidget.h"
// ####### Qt includes #######
#include <QMessageBox>
// ####### ITK includes #######
#include <itkRGBAPixel.h>
// ####### MITK includes #######
#include <mitkConnectomicsConstantsManager.h>
#include "mitkConnectomicsSyntheticNetworkGenerator.h"
#include "mitkConnectomicsSimulatedAnnealingManager.h"
#include "mitkConnectomicsSimulatedAnnealingPermutationModularity.h"
#include "mitkConnectomicsSimulatedAnnealingCostFunctionModularity.h"
-#include <itkConnectomicsNetworkToConnectivityMatrixImageFilter.h>
+//#include <itkConnectomicsNetworkToConnectivityMatrixImageFilter.h>
// Includes for image casting between ITK and MITK
#include "mitkImageCast.h"
#include "mitkITKImageImport.h"
#include "mitkImageAccessByItk.h"
const std::string QmitkConnectomicsDataView::VIEW_ID = "org.mitk.views.connectomicsdata";
QmitkConnectomicsDataView::QmitkConnectomicsDataView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_ConnectomicsNetworkCreator( mitk::ConnectomicsNetworkCreator::New() )
, m_demomode( false )
, m_currentIndex( 0 )
{
}
QmitkConnectomicsDataView::~QmitkConnectomicsDataView()
{
}
void QmitkConnectomicsDataView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkConnectomicsDataViewControls;
m_Controls->setupUi( parent );
QObject::connect( m_Controls->networkifyPushButton, SIGNAL(clicked()), this, SLOT(OnNetworkifyPushButtonClicked()) );
QObject::connect( m_Controls->syntheticNetworkCreationPushButton, SIGNAL(clicked()), this, SLOT(OnSyntheticNetworkCreationPushButtonClicked()) );
QObject::connect( (QObject*)( m_Controls->syntheticNetworkComboBox ), SIGNAL(currentIndexChanged (int)), this, SLOT(OnSyntheticNetworkComboBoxCurrentIndexChanged(int)) );
}
// GUI is different for developer and demo mode
m_demomode = true;
if( m_demomode )
{
this->m_Controls->networkifyPushButton->show();
this->m_Controls->networkifyPushButton->setText( "Create Network" );
this->m_Controls->syntheticNetworkOptionsGroupBox->show();
//--------------------------- fill comboBox---------------------------
this->m_Controls->syntheticNetworkComboBox->insertItem(0,"Regular lattice");
this->m_Controls->syntheticNetworkComboBox->insertItem(1,"Heterogenic sphere");
this->m_Controls->syntheticNetworkComboBox->insertItem(2,"Random network");
}
else
{
this->m_Controls->networkifyPushButton->show();
this->m_Controls->networkifyPushButton->setText( "Networkify" );
this->m_Controls->syntheticNetworkOptionsGroupBox->show();
//--------------------------- fill comboBox---------------------------
this->m_Controls->syntheticNetworkComboBox->insertItem(0,"Regular lattice");
this->m_Controls->syntheticNetworkComboBox->insertItem(1,"Heterogenic sphere");
this->m_Controls->syntheticNetworkComboBox->insertItem(2,"Random network");
this->m_Controls->syntheticNetworkComboBox->insertItem(3,"Scale free network");
this->m_Controls->syntheticNetworkComboBox->insertItem(4,"Small world network");
}
this->WipeDisplay();
}
void QmitkConnectomicsDataView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkConnectomicsDataView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkConnectomicsDataView::WipeDisplay()
{
m_Controls->lblWarning->setVisible( true );
m_Controls->inputImageOneNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
m_Controls->inputImageOneNameLabel->setVisible( false );
m_Controls->inputImageOneLabel->setVisible( false );
m_Controls->inputImageTwoNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
m_Controls->inputImageTwoNameLabel->setVisible( false );
m_Controls->inputImageTwoLabel->setVisible( false );
}
void QmitkConnectomicsDataView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
this->WipeDisplay();
// Valid options are either
// 1 image (parcellation)
//
// 1 image (parcellation)
// 1 fiber bundle
//
// 1 network
if( nodes.size() > 2 )
{
return;
}
bool alreadyFiberBundleSelected( false ), alreadyImageSelected( false ), currentFormatUnknown( true );
// iterate all selected objects, adjust warning visibility
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
it != nodes.end();
++it )
{
mitk::DataNode::Pointer node = *it;
currentFormatUnknown = true;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
currentFormatUnknown = false;
if( alreadyImageSelected )
{
this->WipeDisplay();
return;
}
alreadyImageSelected = true;
m_Controls->lblWarning->setVisible( false );
m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
m_Controls->inputImageOneNameLabel->setVisible( true );
m_Controls->inputImageOneLabel->setVisible( true );
}
if( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
{
currentFormatUnknown = false;
// a fiber bundle has to be in conjunction with a parcellation
if( nodes.size() != 2 || alreadyFiberBundleSelected )
{
this->WipeDisplay();
return;
}
alreadyFiberBundleSelected = true;
m_Controls->lblWarning->setVisible( false );
m_Controls->inputImageTwoNameLabel->setText(node->GetName().c_str());
m_Controls->inputImageTwoNameLabel->setVisible( true );
m_Controls->inputImageTwoLabel->setVisible( true );
}
{ // network section
mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
if( node.IsNotNull() && network )
{
currentFormatUnknown = false;
if( nodes.size() != 1 )
{
// only valid option is a single network
this->WipeDisplay();
return;
}
m_Controls->lblWarning->setVisible( false );
m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
m_Controls->inputImageOneNameLabel->setVisible( true );
m_Controls->inputImageOneLabel->setVisible( true );
}
} // end network section
if ( currentFormatUnknown )
{
this->WipeDisplay();
return;
}
} // end for loop
}
void QmitkConnectomicsDataView::OnSyntheticNetworkComboBoxCurrentIndexChanged(int currentIndex)
{
m_currentIndex = currentIndex;
switch (m_currentIndex) {
case 0:
this->m_Controls->parameterOneLabel->setText( "Nodes per side" );
this->m_Controls->parameterTwoLabel->setText( "Internode distance" );
this->m_Controls->parameterOneSpinBox->setEnabled( true );
this->m_Controls->parameterOneSpinBox->setValue( 5 );
this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 999.999 );
this->m_Controls->parameterTwoDoubleSpinBox->setValue( 10.0 );
break;
case 1:
this->m_Controls->parameterOneLabel->setText( "Number of nodes" );
this->m_Controls->parameterTwoLabel->setText( "Radius" );
this->m_Controls->parameterOneSpinBox->setEnabled( true );
this->m_Controls->parameterOneSpinBox->setValue( 1000 );
this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 999.999 );
this->m_Controls->parameterTwoDoubleSpinBox->setValue( 50.0 );
break;
case 2:
this->m_Controls->parameterOneLabel->setText( "Number of nodes" );
this->m_Controls->parameterTwoLabel->setText( "Edge percentage" );
this->m_Controls->parameterOneSpinBox->setEnabled( true );
this->m_Controls->parameterOneSpinBox->setValue( 100 );
this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 1.0 );
this->m_Controls->parameterTwoDoubleSpinBox->setValue( 0.5 );
break;
case 3:
//GenerateSyntheticScaleFreeNetwork( network, 1000 );
break;
case 4:
//GenerateSyntheticSmallWorldNetwork( network, 1000 );
break;
default:
this->m_Controls->parameterOneLabel->setText( "Parameter 1" );
this->m_Controls->parameterTwoLabel->setText( "Paramater 2" );
this->m_Controls->parameterOneSpinBox->setEnabled( false );
this->m_Controls->parameterOneSpinBox->setValue( 0 );
this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( false );
this->m_Controls->parameterTwoDoubleSpinBox->setValue( 0.0 );
}
}
void QmitkConnectomicsDataView::OnSyntheticNetworkCreationPushButtonClicked()
{
// warn if trying to create a very big network
// big network is a network with > 5000 nodes (estimate)
// this might fill up the memory to the point it freezes
int numberOfNodes( 0 );
switch (m_currentIndex) {
case 0:
numberOfNodes = this->m_Controls->parameterOneSpinBox->value()
* this->m_Controls->parameterOneSpinBox->value()
* this->m_Controls->parameterOneSpinBox->value();
break;
case 1:
numberOfNodes = this->m_Controls->parameterOneSpinBox->value();
break;
case 2:
numberOfNodes = this->m_Controls->parameterOneSpinBox->value();
break;
case 3:
// not implemented yet
break;
case 4:
// not implemented yet
break;
default:
break;
}
if( numberOfNodes > 5000 )
{
QMessageBox msgBox;
msgBox.setText("Trying to generate very large network.");
msgBox.setIcon( QMessageBox::Warning );
msgBox.setInformativeText("You are trying to generate a network with more than 5000 nodes, this is very resource intensive and might lead to program instability. Proceed with network generation?");
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
msgBox.setDefaultButton(QMessageBox::No);
int ret = msgBox.exec();
switch (ret) {
case QMessageBox::Yes:
// continue
break;
case QMessageBox::No:
// stop
return;
break;
default:
// should never be reached
break;
}
}
// proceed
mitk::ConnectomicsSyntheticNetworkGenerator::Pointer generator = mitk::ConnectomicsSyntheticNetworkGenerator::New();
mitk::DataNode::Pointer networkNode = mitk::DataNode::New();
int parameterOne = this->m_Controls->parameterOneSpinBox->value();
double parameterTwo = this->m_Controls->parameterTwoDoubleSpinBox->value();
//add network to datastorage
networkNode->SetData( generator->CreateSyntheticNetwork( m_currentIndex, parameterOne, parameterTwo ) );
networkNode->SetName( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_CNF_NAME );
if( generator->WasGenerationSuccessfull() )
{
this->GetDefaultDataStorage()->Add( networkNode );
}
else
{
MITK_WARN << "Problem occured during synthetic network generation.";
}
return;
}
void QmitkConnectomicsDataView::OnNetworkifyPushButtonClicked()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
if ( nodes.empty() )
{
QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
return;
}
if (! ( nodes.size() == 2 ) )
{
QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
return;
}
mitk::DataNode* firstNode = nodes.front();
mitk::DataNode* secondNode = nodes.at(1);
if (!firstNode)
{
// Nothing selected. Inform the user and return
QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
return;
}
// here we have a valid mitk::DataNode
// a node itself is not very useful, we need its data item (the image)
mitk::BaseData* firstData = firstNode->GetData();
mitk::BaseData* secondData = secondNode->GetData();
if (firstData && secondData)
{
// test if this data item is an image or not (could also be a surface or something totally different)
mitk::Image* image = dynamic_cast<mitk::Image*>( firstData );
mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>( secondData );
// check whether order was switched
if (! (image && fiberBundle) )
{
image = dynamic_cast<mitk::Image*>( secondData );
fiberBundle = dynamic_cast<mitk::FiberBundleX*>( firstData );
}
if (image && fiberBundle)
{
m_ConnectomicsNetworkCreator->SetSegmentation( image );
m_ConnectomicsNetworkCreator->SetFiberBundle( fiberBundle );
m_ConnectomicsNetworkCreator->CalculateCenterOfMass();
m_ConnectomicsNetworkCreator->SetEndPointSearchRadius( 15 );
m_ConnectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
mitk::DataNode::Pointer networkNode = mitk::DataNode::New();
//add network to datastorage
networkNode->SetData( m_ConnectomicsNetworkCreator->GetNetwork() );
networkNode->SetName( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_CNF_NAME );
this->GetDefaultDataStorage()->Add( networkNode );
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.cpp
index cb080c53e1..f6528f5b15 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.cpp
@@ -1,488 +1,488 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// ####### Blueberry includes #######
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// ####### Qmitk includes #######
#include "QmitkConnectomicsNetworkOperationsView.h"
#include "QmitkStdMultiWidget.h"
// ####### Qt includes #######
#include <QMessageBox>
// ####### ITK includes #######
#include <itkRGBAPixel.h>
// ####### MITK includes #######
#include <mitkConnectomicsConstantsManager.h>
#include "mitkConnectomicsSimulatedAnnealingManager.h"
#include "mitkConnectomicsSimulatedAnnealingPermutationModularity.h"
#include "mitkConnectomicsSimulatedAnnealingCostFunctionModularity.h"
#include <itkConnectomicsNetworkToConnectivityMatrixImageFilter.h>
// Includes for image casting between ITK and MITK
#include "mitkImageCast.h"
#include "mitkITKImageImport.h"
#include "mitkImageAccessByItk.h"
const std::string QmitkConnectomicsNetworkOperationsView::VIEW_ID = "org.mitk.views.connectomicsnetworkoperations";
QmitkConnectomicsNetworkOperationsView::QmitkConnectomicsNetworkOperationsView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_demomode( false )
, m_currentIndex( 0 )
{
}
QmitkConnectomicsNetworkOperationsView::~QmitkConnectomicsNetworkOperationsView()
{
}
void QmitkConnectomicsNetworkOperationsView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkConnectomicsNetworkOperationsViewControls;
m_Controls->setupUi( parent );
QObject::connect( m_Controls->convertToRGBAImagePushButton, SIGNAL(clicked()), this, SLOT(OnConvertToRGBAImagePushButtonClicked()) );
QObject::connect( (QObject*)( m_Controls->modularizePushButton ), SIGNAL(clicked()), this, SLOT(OnModularizePushButtonClicked()) );
QObject::connect( (QObject*)( m_Controls->prunePushButton ), SIGNAL(clicked()), this, SLOT(OnPrunePushButtonClicked()) );
QObject::connect( (QObject*)( m_Controls->createConnectivityMatrixImagePushButton ), SIGNAL(clicked()), this, SLOT(OnCreateConnectivityMatrixImagePushButtonClicked()) );
}
// GUI is different for developer and demo mode
m_demomode = true;
if( m_demomode )
{
this->m_Controls->convertToRGBAImagePushButton->show();
this->m_Controls->modularizePushButton->hide();
this->m_Controls->pruneOptionsGroupBox->hide();
}
else
{
this->m_Controls->convertToRGBAImagePushButton->show();
this->m_Controls->modularizePushButton->show();
this->m_Controls->pruneOptionsGroupBox->show();
}
this->WipeDisplay();
}
void QmitkConnectomicsNetworkOperationsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkConnectomicsNetworkOperationsView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkConnectomicsNetworkOperationsView::WipeDisplay()
{
m_Controls->lblWarning->setVisible( true );
m_Controls->inputImageOneNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
m_Controls->inputImageOneNameLabel->setVisible( false );
m_Controls->inputImageOneLabel->setVisible( false );
}
void QmitkConnectomicsNetworkOperationsView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
this->WipeDisplay();
// Valid options are either
if( nodes.size() > 2 )
{
return;
}
bool currentFormatUnknown(true), alreadyImageSelected(false);
// iterate all selected objects, adjust warning visibility
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
it != nodes.end();
++it )
{
mitk::DataNode::Pointer node = *it;
currentFormatUnknown = true;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
currentFormatUnknown = false;
if( alreadyImageSelected )
{
this->WipeDisplay();
return;
}
alreadyImageSelected = true;
m_Controls->lblWarning->setVisible( false );
m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
m_Controls->inputImageOneNameLabel->setVisible( true );
m_Controls->inputImageOneLabel->setVisible( true );
}
if( node.IsNotNull() )
{ // network section
mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
if( network )
{
currentFormatUnknown = false;
if( nodes.size() != 1 )
{
// only valid option is a single network
this->WipeDisplay();
return;
}
m_Controls->lblWarning->setVisible( false );
m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
m_Controls->inputImageOneNameLabel->setVisible( true );
m_Controls->inputImageOneLabel->setVisible( true );
}
} // end network section
if ( currentFormatUnknown )
{
this->WipeDisplay();
return;
}
} // end for loop
}
void QmitkConnectomicsNetworkOperationsView::OnConvertToRGBAImagePushButtonClicked()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
if (nodes.empty()) return;
mitk::DataNode* node = nodes.front();
if (!node)
{
// Nothing selected. Inform the user and return
QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_ONLY_PARCELLATION_SELECTION_WARNING);
return;
}
// here we have a valid mitk::DataNode
// a node itself is not very useful, we need its data item (the image)
mitk::BaseData* data = node->GetData();
if (data)
{
// test if this data item is an image or not (could also be a surface or something totally different)
mitk::Image* image = dynamic_cast<mitk::Image*>( data );
if (image)
{
std::stringstream message;
std::string name;
message << mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_PERFORMING_IMAGE_PROCESSING_FOR_IMAGE;
if (node->GetName(name))
{
// a property called "name" was found for this DataNode
message << "'" << name << "'";
}
message << ".";
MITK_INFO << message.str();
// Convert to RGBA
AccessByItk( image, TurnIntoRGBA );
this->GetDefaultDataStorage()->GetNamedNode( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_RGBA_NAME )->GetData()->SetGeometry( node->GetData()->GetGeometry() );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
else
{
QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_ONLY_PARCELLATION_SELECTION_WARNING);
return;
}
}
else
{
QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_ONLY_PARCELLATION_SELECTION_WARNING);
return;
}
}
template < typename TPixel, unsigned int VImageDimension >
void QmitkConnectomicsNetworkOperationsView::TurnIntoRGBA( itk::Image<TPixel, VImageDimension>* inputImage)
{
typedef itk::RGBAPixel< unsigned char > RGBAPixelType;
typedef itk::Image< TPixel, VImageDimension > TemplateImageType;
typedef itk::Image< RGBAPixelType, VImageDimension > RGBAImageType;
itk::ImageRegionIterator<TemplateImageType> it_inputImage(inputImage, inputImage->GetLargestPossibleRegion());
TPixel minimumValue, maximumValue;
it_inputImage.GoToBegin();
maximumValue = minimumValue = it_inputImage.Value();
for(it_inputImage.GoToBegin(); !it_inputImage.IsAtEnd(); ++it_inputImage)
{
if ( it_inputImage.Value() < minimumValue )
{
minimumValue = it_inputImage.Value();
}
else
{
if ( it_inputImage.Value() > maximumValue )
{
maximumValue = it_inputImage.Value();
}
}
}
int range = int ( maximumValue - minimumValue ); //needs to be castable to int
int offset = int ( minimumValue );
if ( range < 0 ) //error
{
return;
}
std::vector< unsigned int > histogram;
histogram.resize( range + 1, 0 );
for(it_inputImage.GoToBegin(); !it_inputImage.IsAtEnd(); ++it_inputImage)
{
histogram[ int ( it_inputImage.Value() ) - offset ] += 1;
}
int gapCounter = 0; //this variable will be used to count the empty labels
//stores how much has to be subtracted from the image to remove gaps
std::vector< TPixel > subtractionStorage;
subtractionStorage.resize( range + 1, 0 );
for( int index = 0; index <= range; index++ )
{
if( histogram[ index ] == 0 )
{
gapCounter++; //if the label is empty, increase gapCounter
}
else
{
subtractionStorage[ index ] = TPixel ( gapCounter );
}
}
//remove gaps from label image
for(it_inputImage.GoToBegin(); !it_inputImage.IsAtEnd(); ++it_inputImage)
{
it_inputImage.Value() = it_inputImage.Value() - subtractionStorage[int ( it_inputImage.Value() ) - offset ];
}
// create colour vector
std::vector< RGBAPixelType > lookupTable;
{
RGBAPixelType backgroundColour;
for( int elementIndex = 0; elementIndex < 4; ++elementIndex )
{
backgroundColour.SetElement( elementIndex, 0 );
}
lookupTable.push_back( backgroundColour );
for(int colourNumber = 0; colourNumber < range ; ++colourNumber)
{
RGBAPixelType colour;
for( int elementIndex = 0; elementIndex < 3; ++elementIndex )
{
colour.SetElement( elementIndex, rand() % 256 );
}
colour.SetAlpha( 255 );
lookupTable.push_back( colour );
}
}
// create RGBA image
typename RGBAImageType::Pointer rgbaImage = RGBAImageType::New();
rgbaImage->SetRegions(inputImage->GetLargestPossibleRegion().GetSize());
rgbaImage->SetSpacing(inputImage->GetSpacing());
rgbaImage->SetOrigin(inputImage->GetOrigin());
rgbaImage->Allocate();
//fill with appropriate colours
itk::ImageRegionIterator<RGBAImageType> it_rgbaImage(rgbaImage, rgbaImage->GetLargestPossibleRegion());
for(it_inputImage.GoToBegin(), it_rgbaImage.GoToBegin(); !it_inputImage.IsAtEnd(); ++it_inputImage, ++it_rgbaImage)
{
it_rgbaImage.Value() = lookupTable[ int ( it_inputImage.Value() ) - offset ];
}
- mitk::Image::Pointer mitkRGBAImage = mitk::ImportItkImage( rgbaImage );
+ mitk::Image::Pointer mitkRGBAImage = mitk::ImportItkImage( rgbaImage )->Clone();
mitk::DataNode::Pointer rgbaImageNode = mitk::DataNode::New();
rgbaImageNode->SetData(mitkRGBAImage);
rgbaImageNode->SetProperty(mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_NAME, mitk::StringProperty::New(mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_RGBA_NAME));
rgbaImageNode->SetBoolProperty( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_VOLUMERENDERING, true);
this->GetDefaultDataStorage()->Add( rgbaImageNode );
}
void QmitkConnectomicsNetworkOperationsView::OnModularizePushButtonClicked()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
if ( nodes.empty() )
{
QMessageBox::information( NULL, "Modularization calculation", "Please select exactly one network.");
return;
}
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
it != nodes.end();
++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
return;
}
{
mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
if( node.IsNotNull() && network )
{
typedef mitk::ConnectomicsSimulatedAnnealingPermutationModularity::ToModuleMapType MappingType;
int depthOfModuleRecursive( 2 );
double startTemperature( 2.0 );
double stepSize( 4.0 );
mitk::ConnectomicsNetwork::Pointer connectomicsNetwork( network );
mitk::ConnectomicsSimulatedAnnealingManager::Pointer manager = mitk::ConnectomicsSimulatedAnnealingManager::New();
mitk::ConnectomicsSimulatedAnnealingPermutationModularity::Pointer permutation = mitk::ConnectomicsSimulatedAnnealingPermutationModularity::New();
mitk::ConnectomicsSimulatedAnnealingCostFunctionModularity::Pointer costFunction = mitk::ConnectomicsSimulatedAnnealingCostFunctionModularity::New();
permutation->SetCostFunction( costFunction.GetPointer() );
permutation->SetNetwork( connectomicsNetwork );
permutation->SetDepth( depthOfModuleRecursive );
permutation->SetStepSize( stepSize );
manager->SetPermutation( permutation.GetPointer() );
manager->RunSimulatedAnnealing( startTemperature, stepSize );
MappingType mapping = permutation->GetMapping();
MappingType::iterator iter = mapping.begin();
MappingType::iterator end = mapping.end();
int loop( 0 );
while( iter != end )
{
MBI_DEBUG << "Vertex " << iter->first << " belongs to module " << iter->second ;
MBI_INFO << "Vertex " << iter->first << " belongs to module " << iter->second ;
iter++;
}
MBI_DEBUG << "Overall number of modules is " << permutation->getNumberOfModules( &mapping ) ;
MBI_DEBUG << "Cost is " << costFunction->Evaluate( network, &mapping ) ;
MBI_INFO << "Overall number of modules is " << permutation->getNumberOfModules( &mapping ) ;
MBI_INFO << "Cost is " << costFunction->Evaluate( network, &mapping ) ;
return;
}
}
}
}
void QmitkConnectomicsNetworkOperationsView::OnPrunePushButtonClicked()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
if ( nodes.empty() )
{
QMessageBox::information( NULL, "Network pruning", "Please select one or more networks.");
return;
}
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
it != nodes.end();
++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
return;
}
{
mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
if( node.IsNotNull() && network )
{
// Edge pruning will also do node pruning
network->PruneEdgesBelowWeight( this->m_Controls->pruneEdgeWeightSpinBox->value() );
}
}
}
}
void QmitkConnectomicsNetworkOperationsView::OnCreateConnectivityMatrixImagePushButtonClicked()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
if ( nodes.empty() )
{
QMessageBox::information( NULL, "Connectivity Matrix Image creation", "Please select one or more networks.");
return;
}
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
it != nodes.end();
++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
return;
}
{
mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
if( node.IsNotNull() && network )
{
itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::Pointer filter = itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::New();
filter->SetInputNetwork( network );
filter->SetBinaryConnectivity(m_Controls->binaryCheckBox->isChecked());
filter->SetRescaleConnectivity(m_Controls->rescaleCheckBox->isChecked());
filter->Update();
- mitk::Image::Pointer connectivityMatrixImage = mitk::ImportItkImage( filter->GetOutput());
+ mitk::Image::Pointer connectivityMatrixImage = mitk::ImportItkImage( filter->GetOutput())->Clone();
mitk::DataNode::Pointer connectivityMatrixImageNode = mitk::DataNode::New();
connectivityMatrixImageNode->SetData ( connectivityMatrixImage );
connectivityMatrixImageNode->SetName( "Connectivity matrix" );
this->GetDefaultDataStorage()->Add(connectivityMatrixImageNode, node );
}
}
}
}
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index f91bcbecf3..6bac6f6c31 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1766 +1,1766 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkControlVisualizationPropertiesView.h"
#include "mitkNodePredicateDataType.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include "mitkResliceMethodProperty.h"
#include "mitkRenderingManager.h"
#include "mitkTbssImage.h"
#include "mitkPlanarFigure.h"
#include "mitkFiberBundleX.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkFiberBundleInteractor.h"
#include "mitkPlanarFigureInteractor.h"
#include <mitkQBallImage.h>
#include <mitkTensorImage.h>
#include <mitkDiffusionImage.h>
#include "mitkGlobalInteraction.h"
#include "mitkGeometry2D.h"
#include "mitkSegTool2D.h"
#include "berryIWorkbenchWindow.h"
#include "berryIWorkbenchPage.h"
#include "berryISelectionService.h"
#include "berryConstants.h"
#include "berryPlatformUI.h"
#include "itkRGBAPixel.h"
#include <itkTractDensityImageFilter.h>
#include "qwidgetaction.h"
#include "qcolordialog.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 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);
m_View->m_Controls->m_ImageControlsFrame->setVisible(false);
m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(false);
m_View->m_Controls->m_BundleControlsFrame->setVisible(false);
m_View->m_SelectedNode = 0;
if(m_View->m_CurrentSelection.IsNull())
return;
if(m_View->m_CurrentSelection->Size() == 1)
{
mitk::DataNodeObject::Pointer nodeObj = m_View->m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
if(nodeObj.IsNotNull())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
mitk::BaseData* nodeData = node->GetData();
if(nodeData != NULL )
{
if(dynamic_cast<mitk::PlanarFigure*>(nodeData) != 0)
{
m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(true);
m_View->m_SelectedNode = node;
float val;
node->GetFloatProperty("planarfigure.line.width", val);
m_View->m_Controls->m_PFWidth->setValue((int)(val*10.0));
QString label = "Width %1";
label = label.arg(val);
m_View->m_Controls->label_pfwidth->setText(label);
float color[3];
node->GetColor( color, NULL, "planarfigure.default.line.color");
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255.0));
styleSheet.append(")");
m_View->m_Controls->m_PFColor->setAutoFillBackground(true);
m_View->m_Controls->m_PFColor->setStyleSheet(styleSheet);
node->GetColor( color, NULL, "color");
styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255.0));
styleSheet.append(")");
m_View->PlanarFigureFocus();
}
if(dynamic_cast<mitk::FiberBundleX*>(nodeData) != 0)
{
m_View->m_Controls->m_BundleControlsFrame->setVisible(true);
m_View->m_SelectedNode = node;
if(m_View->m_CurrentPickingNode != 0 && node.GetPointer() != m_View->m_CurrentPickingNode)
{
m_View->m_Controls->m_Crosshair->setEnabled(false);
}
else
{
m_View->m_Controls->m_Crosshair->setEnabled(true);
}
float val;
node->GetFloatProperty("TubeRadius", val);
m_View->m_Controls->m_TubeRadius->setValue((int)(val * 100.0));
QString label = "Radius %1";
label = label.arg(val);
m_View->m_Controls->label_tuberadius->setText(label);
int width;
node->GetIntProperty("LineWidth", width);
m_View->m_Controls->m_LineWidth->setValue(width);
label = "Width %1";
label = label.arg(width);
m_View->m_Controls->label_linewidth->setText(label);
float range;
node->GetFloatProperty("Fiber2DSliceThickness",range);
label = "Range %1";
label = label.arg(range*0.1);
m_View->m_Controls->label_range->setText(label);
}
} // check node data != NULL
}
}
if(m_View->m_CurrentSelection->Size() > 0 && m_View->m_SelectedNode == 0)
{
m_View->m_Controls->m_ImageControlsFrame->setVisible(true);
bool foundDiffusionImage = false;
bool foundQBIVolume = false;
bool foundTensorVolume = false;
bool foundImage = false;
bool foundMultipleOdfImages = false;
bool foundRGBAImage = false;
bool foundTbssImage = 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();
mitk::BaseData* nodeData = node->GetData();
if(nodeData != NULL )
{
// only look at interesting types
if(QString("DiffusionImage").compare(nodeData->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>* >(nodeData))->GetVectorImage()->GetVectorLength();
m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
}
if(QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
{
foundTbssImage = 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::TbssImage* >(nodeData))->GetImage()->GetVectorLength();
m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
}
else if(QString("QBallImage").compare(nodeData->GetNameOfClass())==0)
{
foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
foundQBIVolume = true;
ApplySettings(node);
}
else if(QString("TensorImage").compare(nodeData->GetNameOfClass())==0)
{
foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
foundTensorVolume = true;
ApplySettings(node);
}
else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
{
foundImage = true;
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(nodeData);
if(img.IsNotNull()
- && img->GetPixelType().GetPixelTypeId() == itk::ImageIOBase::RGBA
- && img->GetPixelType().GetTypeId() == typeid(unsigned char) )
+ && img->GetPixelType().GetPixelType() == itk::ImageIOBase::RGBA
+ && img->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR )
{
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;
}
}
} // END CHECK node != NULL
}
}
}
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 || foundTbssImage;
m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
m_View->m_Controls->m_TSMenu->setVisible(foundAnyImage);
}
}
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_NodeUsedForOdfVisualization(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")),
m_CurrentSelection(0),
m_CurrentPickingNode(0),
m_GlyIsOn_S(false),
m_GlyIsOn_C(false),
m_GlyIsOn_T(false),
m_FiberBundleObserverTag(0),
m_Color(NULL)
{
currentThickSlicesMode = 1;
m_MyMenu = NULL;
}
QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
{
if(m_SlicesRotationObserverTag1 )
{
mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
if( coordinator)
coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
}
if( m_SlicesRotationObserverTag2)
{
mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
if( coordinator )
coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
}
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
}
void QmitkControlVisualizationPropertiesView::OnThickSlicesModeSelected( QAction* action )
{
currentThickSlicesMode = action->data().toInt();
switch(currentThickSlicesMode)
{
default:
case 1:
this->m_Controls->m_TSMenu->setText("MIP");
break;
case 2:
this->m_Controls->m_TSMenu->setText("SUM");
break;
case 3:
this->m_Controls->m_TSMenu->setText("WEIGH");
break;
}
mitk::DataNode* n;
n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
mitk::BaseRenderer::Pointer renderer =
this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
if(renderer.IsNotNull())
{
renderer->SendUpdateSlice();
}
renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
if(renderer.IsNotNull())
{
renderer->SendUpdateSlice();
}
renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
if(renderer.IsNotNull())
{
renderer->SendUpdateSlice();
}
renderer->GetRenderingManager()->RequestUpdateAll();
}
void QmitkControlVisualizationPropertiesView::OnTSNumChanged(int num)
{
if(num==0)
{
mitk::DataNode* n;
n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
}
else
{
mitk::DataNode* n;
n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
}
m_TSLabel->setText(QString::number(num*2+1));
mitk::BaseRenderer::Pointer renderer =
this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
if(renderer.IsNotNull())
{
renderer->SendUpdateSlice();
}
renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
if(renderer.IsNotNull())
{
renderer->SendUpdateSlice();
}
renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
if(renderer.IsNotNull())
{
renderer->SendUpdateSlice();
}
renderer->GetRenderingManager()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
}
void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
// hide warning (ODFs in rotated planes)
m_Controls->m_lblRotatedPlanesWarning->hide();
m_MyMenu = new QMenu(parent);
connect( m_MyMenu, SIGNAL( aboutToShow() ), this, SLOT(OnMenuAboutToShow()) );
// button for changing rotation mode
m_Controls->m_TSMenu->setMenu( m_MyMenu );
//m_CrosshairModeButton->setIcon( QIcon( iconCrosshairMode_xpm ) );
m_Controls->params_frame->setVisible(false);
QIcon icon5(":/QmitkDiffusionImaging/Refresh_48.png");
m_Controls->m_Reinit->setIcon(icon5);
m_Controls->m_Focus->setIcon(icon5);
QIcon iconColor(":/QmitkDiffusionImaging/color24.gif");
m_Controls->m_PFColor->setIcon(iconColor);
m_Controls->m_Color->setIcon(iconColor);
QIcon iconReset(":/QmitkDiffusionImaging/reset.png");
m_Controls->m_ResetColoring->setIcon(iconReset);
m_Controls->m_PFColor->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QIcon iconCrosshair(":/QmitkDiffusionImaging/crosshair.png");
m_Controls->m_Crosshair->setIcon(iconCrosshair);
// was is los
QIcon iconPaint(":/QmitkDiffusionImaging/paint2.png");
m_Controls->m_TDI->setIcon(iconPaint);
QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
m_Controls->m_TextureIntON->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_Controls->frame_tube->setVisible(false);
m_Controls->frame_wire->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::OnMenuAboutToShow ()
{
// THICK SLICE SUPPORT
QMenu *myMenu = m_MyMenu;
myMenu->clear();
QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu);
thickSlicesActionGroup->setExclusive(true);
mitk::BaseRenderer::Pointer renderer =
this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
int currentTSMode = 0;
{
mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(renderer->GetCurrentWorldGeometry2DNode()->GetProperty( "reslice.thickslices" ));
if( m.IsNotNull() )
currentTSMode = m->GetValueAsId();
}
const int maxTS = 30;
int currentNum = 0;
{
mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(renderer->GetCurrentWorldGeometry2DNode()->GetProperty( "reslice.thickslices.num" ));
if( m.IsNotNull() )
{
currentNum = m->GetValue();
if(currentNum < 0) currentNum = 0;
if(currentNum > maxTS) currentNum = maxTS;
}
}
if(currentTSMode==0)
currentNum=0;
QSlider *m_TSSlider = new QSlider(myMenu);
m_TSSlider->setMinimum(0);
m_TSSlider->setMaximum(maxTS-1);
m_TSSlider->setValue(currentNum);
m_TSSlider->setOrientation(Qt::Horizontal);
connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) );
QHBoxLayout* _TSLayout = new QHBoxLayout;
_TSLayout->setContentsMargins(4,4,4,4);
_TSLayout->addWidget(m_TSSlider);
_TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu));
QWidget* _TSWidget = new QWidget;
_TSWidget->setLayout(_TSLayout);
QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu);
thickSliceModeActionGroup->setExclusive(true);
QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu);
m_TSSliderAction->setDefaultWidget(_TSWidget);
myMenu->addAction(m_TSSliderAction);
QAction* mipThickSlicesAction = new QAction(myMenu);
mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
mipThickSlicesAction->setText("MIP (max. intensity proj.)");
mipThickSlicesAction->setCheckable(true);
mipThickSlicesAction->setChecked(currentThickSlicesMode==1);
mipThickSlicesAction->setData(1);
myMenu->addAction( mipThickSlicesAction );
QAction* sumThickSlicesAction = new QAction(myMenu);
sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
sumThickSlicesAction->setText("SUM (sum intensity proj.)");
sumThickSlicesAction->setCheckable(true);
sumThickSlicesAction->setChecked(currentThickSlicesMode==2);
sumThickSlicesAction->setData(2);
myMenu->addAction( sumThickSlicesAction );
QAction* weightedThickSlicesAction = new QAction(myMenu);
weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)");
weightedThickSlicesAction->setCheckable(true);
weightedThickSlicesAction->setChecked(currentThickSlicesMode==3);
weightedThickSlicesAction->setData(3);
myMenu->addAction( weightedThickSlicesAction );
connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) );
}
void QmitkControlVisualizationPropertiesView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
if (m_MultiWidget)
{
mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
if (coordinator)
{
itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
}
coordinator = m_MultiWidget->GetSlicesSwiveller();
if (coordinator)
{
itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
}
}
}
void QmitkControlVisualizationPropertiesView::SliceRotation(const itk::EventObject&)
{
// test if plane rotated
if( m_GlyIsOn_T || m_GlyIsOn_C || m_GlyIsOn_S )
{
if( this->IsPlaneRotated() )
{
// show label
m_Controls->m_lblRotatedPlanesWarning->show();
}
else
{
//hide label
m_Controls->m_lblRotatedPlanesWarning->hide();
}
}
}
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_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
connect( (QObject*)(m_Controls->m_OpacitySlider), SIGNAL(spanChanged(double,double)), this, SLOT(OpacityChanged(double,double)) );
connect((QObject*) m_Controls->m_Wire, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationWire()));
connect((QObject*) m_Controls->m_Tube, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationTube()));
connect((QObject*) m_Controls->m_Color, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationColor()));
connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
connect((QObject*) m_Controls->m_Focus, SIGNAL(clicked()), (QObject*) this, SLOT(PlanarFigureFocus()));
connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) );
connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) );
connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) ));
connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor()));
connect((QObject*) m_Controls->m_PFWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(PFWidth(int)));
connect((QObject*) m_Controls->m_PFColor, SIGNAL(clicked()), (QObject*) this, SLOT(PFColor()));
connect((QObject*) m_Controls->m_TDI, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateTdi()));
connect((QObject*) m_Controls->m_LineWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(LineWidthChanged(int)));
connect((QObject*) m_Controls->m_TubeRadius, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(TubeRadiusChanged(int)));
}
}
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;
}
}
// set diffusion image channel to b0 volume
void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
{
mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
if (dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData()))
{
mitk::DiffusionImage<short>::Pointer dimg = dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData());
// if there is no b0 image in the dataset, the GetB0Indices() returns a vector of size 0
// and hence we cannot set the Property directly to .front()
int displayChannelPropertyValue = 0;
if( dimg->GetB0Indices().size() > 0)
displayChannelPropertyValue = dimg->GetB0Indices().front();
notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue );
}
}
/* OnSelectionChanged is registered to SelectionService, therefore no need to
implement SelectionService Listener explicitly */
void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
// deactivate channel slider if no diffusion weighted image or tbss image is selected
m_Controls->m_DisplayIndex->setVisible(false);
m_Controls->label_channel->setVisible(false);
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
if (node.IsNotNull() && (dynamic_cast<mitk::TbssImage*>(nodeData) ||
dynamic_cast<mitk::DiffusionImage<short>*>(nodeData)))
{
m_Controls->m_DisplayIndex->setVisible(true);
m_Controls->label_channel->setVisible(true);
}
else if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
{
if (m_Color.IsNotNull())
m_Color->RemoveObserver(m_FiberBundleObserverTag);
itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor );
m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", NULL));
if (m_Color.IsNotNull())
m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command );
}
}
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
if( node.IsNotNull() && (dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData)) )
{
if(m_NodeUsedForOdfVisualization.IsNotNull())
{
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false);
}
m_NodeUsedForOdfVisualization = node;
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
m_Controls->m_TSMenu->setVisible(false); // deactivate mip etc. for tensor and q-ball images
break;
}
else
m_Controls->m_TSMenu->setVisible(true);
}
}
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();
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
const mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
if(QString(classname.c_str()).compare(nodeData->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);
std::vector<std::string> sets;
sets.push_back("DiffusionImage");
sets.push_back("TbssImage");
std::vector<std::string>::iterator it = sets.begin();
while(it != sets.end())
{
std::string s = *it;
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet(s);
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();
}
it++;
}
}
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()
{
m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked();
if (m_NodeUsedForOdfVisualization.IsNull())
{
MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
return;
}
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
VisibleOdfsON(0);
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
{
m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked();
if (m_NodeUsedForOdfVisualization.IsNull())
{
MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
return;
}
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
VisibleOdfsON(1);
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
{
m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked();
if (m_NodeUsedForOdfVisualization.IsNull())
{
MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
return;
}
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
VisibleOdfsON(2);
}
bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
{
// for all 2D renderwindows of m_MultiWidget check alignment
mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D() );
if (displayPlane.IsNull()) return false;
mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
if( currentImage == NULL )
{
MITK_ERROR << " Casting problems. Returning false";
return false;
}
int affectedDimension(-1);
int affectedSlice(-1);
return !(mitk::SegTool2D::DetermineAffectedImageSlice( currentImage, displayPlane, affectedDimension, affectedSlice ));
}
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();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
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::ScalingCheckbox()
{
m_Controls->m_ScalingFrame->setVisible(
m_Controls->m_ScalingCheckbox->isChecked());
if(!m_Controls->m_ScalingCheckbox->isChecked())
{
m_Controls->m_AdditionalScaling->setCurrentIndex(0);
m_Controls->m_ScalingFactor->setValue(1.0);
}
}
void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX()
{
if (m_SelectedNode)
{
bool currentMode;
m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode);
m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
{
if (m_SelectedNode)
{
float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1;
m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
{
QString label = "Range %1";
label = label.arg(value * 0.1);
m_Controls->label_range->setText(label);
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationWire()
{
if(m_SelectedNode)
{
int width = m_Controls->m_LineWidth->value();
m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(width));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(15));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(18));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(1));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(2));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(4));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationTube()
{
if(m_SelectedNode)
{
float radius = m_Controls->m_TubeRadius->value() / 100.0;
m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(radius));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(17));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(13));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(16));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
{
float color[3];
m_SelectedNode->GetColor(color);
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255.0));
styleSheet.append(")");
m_Controls->m_Color->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color[0], color[1], color[2]));
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
m_SelectedNode->Modified();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationColor()
{
if(m_SelectedNode)
{
QColor color = QColorDialog::getColor();
if (!color.isValid())
return;
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_Color->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
m_SelectedNode->Modified();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
{
if(m_SelectedNode)
{
MITK_INFO << "reset colorcoding to oBased";
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(255,255,255)";
m_Controls->m_Color->setStyleSheet(styleSheet);
// m_SelectedNode->SetProperty("color",NULL);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(1.0, 1.0, 1.0));
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED);
fib->DoColorCodingOrientationBased();
m_SelectedNode->Modified();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
{
if(m_SelectedNode)
{
mitk::PlanarFigure* _PlanarFigure = 0;
_PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
if (_PlanarFigure && _PlanarFigure->GetGeometry2D())
{
QmitkRenderWindow* selectedRenderWindow = 0;
bool PlanarFigureInitializedWindow = false;
QmitkRenderWindow* RenderWindow1 =
this->GetActiveStdMultiWidget()->GetRenderWindow1();
if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
{
selectedRenderWindow = RenderWindow1;
}
QmitkRenderWindow* RenderWindow2 =
this->GetActiveStdMultiWidget()->GetRenderWindow2();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow2->GetRenderer()))
{
selectedRenderWindow = RenderWindow2;
}
QmitkRenderWindow* RenderWindow3 =
this->GetActiveStdMultiWidget()->GetRenderWindow3();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow3->GetRenderer()))
{
selectedRenderWindow = RenderWindow3;
}
QmitkRenderWindow* RenderWindow4 =
this->GetActiveStdMultiWidget()->GetRenderWindow4();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow4->GetRenderer()))
{
selectedRenderWindow = RenderWindow4;
}
const mitk::PlaneGeometry
* _PlaneGeometry =
dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry1 =
RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane1 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry2 =
RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane2 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry3 =
RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane3 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
normal[0] = fabs(normal[0]); normal[1] = fabs(normal[1]); normal[2] = fabs(normal[2]);
normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
double ang1 = angle(normal, normal1);
double ang2 = angle(normal, normal2);
double ang3 = angle(normal, normal3);
if(ang1 < ang2 && ang1 < ang3)
{
selectedRenderWindow = RenderWindow1;
}
else
{
if(ang2 < ang3)
{
selectedRenderWindow = RenderWindow2;
}
else
{
selectedRenderWindow = RenderWindow3;
}
}
// make node visible
if (selectedRenderWindow)
{
const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
centerP, _PlaneGeometry->GetNormal());
}
}
// set interactor for new node (if not already set)
mitk::PlanarFigureInteractor::Pointer figureInteractor
= dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", m_SelectedNode);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
}
}
void QmitkControlVisualizationPropertiesView::SetInteractor()
{
typedef std::vector<mitk::DataNode*> Container;
Container _NodeSet = this->GetDataManagerSelection();
mitk::DataNode* node = 0;
mitk::FiberBundleX* bundle = 0;
mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
// finally add all nodes to the model
for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
; it++)
{
node = const_cast<mitk::DataNode*>(*it);
bundle = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
if(bundle)
{
bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
if(bundleInteractor.IsNotNull())
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
if(!m_Controls->m_Crosshair->isChecked())
{
m_Controls->m_Crosshair->setChecked(false);
this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
m_CurrentPickingNode = 0;
}
else
{
m_Controls->m_Crosshair->setChecked(true);
bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
m_CurrentPickingNode = node;
}
}
}
}
void QmitkControlVisualizationPropertiesView::PFWidth(int w)
{
double width = w/10.0;
m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QString label = "Width %1";
label = label.arg(width);
m_Controls->label_pfwidth->setText(label);
}
void QmitkControlVisualizationPropertiesView::PFColor()
{
QColor color = QColorDialog::getColor();
if (!color.isValid())
return;
m_Controls->m_PFColor->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_PFColor->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkControlVisualizationPropertiesView::GenerateTdi()
{
if(m_SelectedNode)
{
mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
if(!bundle)
return;
typedef float OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
// run generator
itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
generator->SetFiberBundle(bundle);
generator->SetOutputAbsoluteValues(true);
generator->SetUpsamplingFactor(1);
generator->Update();
// get result
OutImageType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// to datastorage
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
QString name(m_SelectedNode->GetName().c_str());
name += "_TDI";
node->SetName(name.toStdString());
node->SetVisibility(true);
GetDataStorage()->Add(node);
}
}
void QmitkControlVisualizationPropertiesView::LineWidthChanged(int w)
{
QString label = "Width %1";
label = label.arg(w);
m_Controls->label_linewidth->setText(label);
BundleRepresentationWire();
}
void QmitkControlVisualizationPropertiesView::TubeRadiusChanged(int r)
{
QString label = "Radius %1";
label = label.arg(r / 100.0);
m_Controls->label_tuberadius->setText(label);
this->BundleRepresentationTube();
}
void QmitkControlVisualizationPropertiesView::Welcome()
{
berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
GetSite()->GetWorkbenchWindow(), false);
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
index eec63e7d6c..3c1f2d8c59 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
@@ -1,800 +1,798 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "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"
#include "gdcmDirectory.h"
#include "gdcmScanner.h"
#include "gdcmSorter.h"
#include "gdcmIPPSorter.h"
#include "gdcmAttribute.h"
#include "gdcmVersion.h"
#include <QMessageBox>
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);
m_Controls->m_DicomLoadRecursiveCheckbox->setVisible(false);
m_Controls->m_OverrideOptionCheckbox->setVisible(false);
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()) );
connect( m_Controls->m_Remove, SIGNAL(clicked()), this, SLOT(Remove()) );
}
}
void QmitkDiffusionDicomImport::Remove()
{
int i = m_Controls->listWidget->currentRow();
m_Controls->listWidget->takeItem(i);
}
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);
// show file override option checkbox
m_Controls->m_OverrideOptionCheckbox->setVisible(true);
}
void QmitkDiffusionDicomImport::OutputClear()
{
m_OutputFolderName = "";
m_OutputFolderNameSet = false;
m_Controls->m_OutputLabel->setText("... optional out-folder ...");
// hide file override option checkbox - no output specified
m_Controls->m_OverrideOptionCheckbox->setVisible(false);
}
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());
}
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().Trim();
std::string str2 = at2.GetValue().Trim();
return std::lexicographical_compare(str1.begin(), str1.end(),
str2.begin(), str2.end() );
}
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;
bool imageSuccessfullySaved = true;
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
int nrFolders = m_Controls->listWidget->count();
if(!nrFolders)
{
Error(QString("No input folders were selected. ABORTING."));
return;
}
Status(QString("GDCM %1 used for DICOM parsing and sorting!").arg(gdcm::Version::GetVersion()));
PrintMemoryUsage();
QString status;
mitk::DataNode::Pointer node;
mitk::ProgressBar::GetInstance()->AddStepsToDo(2*nrFolders);
std::string folder = m_Controls->m_OutputLabel->text().toStdString();
if(berry::Platform::IsWindows())
{
folder.append("\\import.log");
}
else
{
folder.append("/import.log");
}
ofstream logfile;
if(m_OutputFolderNameSet) logfile.open(folder.c_str());
while(m_Controls->listWidget->count())
{
// RETREIVE FOLDERNAME
QListWidgetItem * item = m_Controls->listWidget->takeItem(0);
QString folderName = item->text();
if(m_OutputFolderNameSet) logfile << "Reading " << folderName.toStdString() << '\n';
// PARSING DIRECTORY
PrintMemoryUsage();
clock.Start(folderName.toAscii());
std::vector<std::string> seriesUIDs(0);
std::vector<std::vector<std::string> > seriesFilenames(0);
Status("== Initial Directory Scan ==");
if(m_OutputFolderNameSet) logfile << "== Initial Directory Scan ==\n";
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));
if(m_OutputFolderNameSet)logfile << "...found " << ntotalfiles << " different files\n";
Status("Scanning Headers");
if(m_OutputFolderNameSet) logfile << "Scanning Headers\n";
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");
if(m_OutputFolderNameSet )logfile << "ERROR: scanner failed\n";
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");
if(m_OutputFolderNameSet)logfile << "ERROR: No DICOM files found\n";
continue;
}
Status(QString(" ... successfully scanned %1 headers.").arg(nfiles));
if(m_OutputFolderNameSet) logfile << "...succesfully scanned " << nfiles << " headers\n";
Status("Sorting");
if(m_OutputFolderNameSet) logfile << "Sorting\n";
const gdcm::Scanner::ValuesType &values1 = s.GetValues(t1);
int nvalues;
if(m_Controls->m_DuplicateID->isChecked())
{
nvalues = 1;
}
else
{
nvalues = values1.size();
}
if(nvalues>1)
{
Error("Multiple sSeries tudies found. Please limit to 1 study per folder");
if(m_OutputFolderNameSet) logfile << "Multiple series found. Limit to one. If you are convinced this is an error use the merge duplicate study IDs option \n";
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.");
if(m_OutputFolderNameSet) logfile << "Folder contains images of unequal dimensions that cannot be combined in one 3d volume. ABORTING\n.";
continue;
}
const gdcm::Scanner::ValuesType &values2 = s.GetValues(t2);
int nSeries;
if(m_Controls->m_DuplicateID->isChecked())
{
nSeries = 1;
}
else
{
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");
if(m_OutputFolderNameSet) logfile << "Number of files in series not equal, Some volumes are probably incomplete. ABORTING \n";
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");
if(m_OutputFolderNameSet) logfile << "Scanner failed\n";
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) // More than one element must have this tag (Not != )
{
subsorter.SetSortFunction( SortByAcquisitionNumber );
it = values3.begin();
}
else if (values4.size() > 1)
{
nAcquis = values4.size();
subsorter.SetSortFunction( SortBySeqName );
it = values4.begin();
}
// Hotfix for Bug 14758, better fix by selecting always availible tags.
else
{
Error("Sorting tags (0x0020,0x0012) and (0x0018,0x0024) missing, ABORTING");
if(m_OutputFolderNameSet) logfile << "Sorting tags (0x0020,0x0012) and (0x0018,0x0024) missing, ABORTING\n";
continue;
}
nTotalAcquis += nAcquis;
subsorter.Sort( sub );
if(filesPerSeries % nAcquis != 0)
{
Error("Number of files per acquisition not equal, ABORTING");
if(m_OutputFolderNameSet) logfile << "Number of files per acquisition not equal, ABORTING \n";
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( true );
if( !ippsorter.Sort( ipplist ) )
{
Error(QString("Failed to sort acquisition %1, ABORTING").arg(identifier.c_str()));
if(m_OutputFolderNameSet) logfile << "Failed to sort acquisition " << identifier.c_str() << " , Aborting\n";
continue;
}
const std::vector<std::string> & list = ippsorter.GetFilenames();
seriesFilenames.push_back(list);
seriesUIDs.push_back(identifier.c_str());
}
++it2;
}
// Hot Fix for Bug 14758, checking if no file is acuired.
if (nTotalAcquis < 1) // Test if zero, if true than error because no file was selected
{
Error("Nno files in acquisitions, ABORTING");
if(m_OutputFolderNameSet) logfile << "Nno files in acquisitions, ABORTING \n";
continue;
}
-
if(nfiles % nTotalAcquis != 0)
{
Error("Number of files per acquisition differs between series, ABORTING");
if(m_OutputFolderNameSet) logfile << "Number of files per acquisition differs between series, ABORTING \n";
continue;
}
int slices = nfiles/nTotalAcquis;
Status(QString("Series is composed of %1 different 3D volumes with %2 slices.").arg(nTotalAcquis).arg(slices));
if(m_OutputFolderNameSet) logfile << "Series is composed of " << nTotalAcquis << " different 3D volumes with " << slices << " slices\n";
// READING HEADER-INFOS
PrintMemoryUsage();
Status(QString("Reading Headers %1").arg(folderName));
if(m_OutputFolderNameSet) logfile << "Reading Headers "<< folderName.toStdString() << "\n";
mitk::DicomDiffusionImageHeaderReader::Pointer headerReader;
- mitk::GroupDiffusionHeadersFilter::InputType inHeaders;
+ typedef short PixelValueType;
+ typedef mitk::DicomDiffusionImageReader< PixelValueType, 3 > VolumesReader;
+ VolumesReader::HeaderContainer inHeaders;
unsigned int size2 = seriesUIDs.size();
for ( unsigned int i = 0 ; i < size2 ; ++i )
{
// Hot Fix for Bug 14459, catching if no valid data in datafile.
try
{
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());
}
catch (mitk::Exception e)
{
Error("Could not read file header, ABORTING");
if(m_OutputFolderNameSet) logfile << e;
continue;
}
-
//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();
if(m_OutputFolderNameSet) logfile << "Loading volumes\n";
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"));
if(m_OutputFolderNameSet) logfile << "Initializing Diffusion Image\n";
typedef mitk::DiffusionImage<PixelValueType> DiffVolumesType;
DiffVolumesType::Pointer diffImage = DiffVolumesType::New();
diffImage->SetDirections(directions);
diffImage->SetVectorImage(vecImage);
diffImage->SetB_Value(maxb);
diffImage->InitializeFromVectorImage();
- diffImage->UpdateBValueList();
+ diffImage->UpdateBValueMap();
Status(QString("Diffusion Image initialized"));
if(m_OutputFolderNameSet) logfile << "Diffusion Image initialized\n";
if(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked())
{
PrintMemoryUsage();
Status(QString("Averaging gradient directions"));
logfile << "Averaging gradient directions\n";
diffImage->AverageRedundantGradients(m_Controls->m_Blur->value());
}
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);
// if the override option is not checked, we need to make sure that the current filepath
// does not point to an existing file
if( !(m_Controls->m_OverrideOptionCheckbox->isChecked()) )
{
QFile outputFile( fullpath );
// generate new filename if file exists
int file_counter = 0;
while( outputFile.exists() )
{
// copy base name
QString newdescr = descr;
file_counter++;
MITK_WARN << "The file "<< fullpath.toStdString() << " exists already.";
QString appendix = QString("_%1").arg( QString::number(file_counter) );
newdescr.append(appendix);
fullpath = QString("%1/%2.dwi")
.arg(m_OutputFolderName)
.arg(newdescr);
// set the new generated filename for next check
outputFile.setFileName( fullpath );
}
}
writer->SetFileName(fullpath.toStdString());
writer->SetInput(diffImage);
try
{
writer->Update();
}
catch (itk::ExceptionObject &ex)
{
imageSuccessfullySaved = false;
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()));
logfile << 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()).toStdString() << "\n";
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));
logfile << "Image " << descr.toStdString() << " added to datastorage\n";
continue ;
}
Status(QString("Image %1 written to disc (%1)").arg(fullpath.toStdString().c_str()));
logfile << "Image " << fullpath.toStdString() << "\n";
}
}
else
{
Status(QString("No diffusion information found (%1)").arg(folderName));
if(m_OutputFolderNameSet) logfile << "No diffusion information found "<< folderName.toStdString();
}
Status(QString("Finished processing %1 with memory:").arg(folderName));
if(m_OutputFolderNameSet) logfile << "Finished processing " << folderName.toStdString() << "\n";
PrintMemoryUsage();
clock.Stop(folderName.toAscii());
mitk::ProgressBar::GetInstance()->Progress();
int lwidget = m_Controls->listWidget->count();
std::cout << lwidget <<std::endl;
logfile << "\n";
}
logfile.close();
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();
try
{
MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
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 ;
}
if (!imageSuccessfullySaved)
QMessageBox::warning(NULL,"WARNING","One or more files could not be saved! The according files where moved to the datastorage.");
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/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberExtractionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberExtractionView.cpp
index 214cb0f0b9..75fc7e4735 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberExtractionView.cpp
@@ -1,1370 +1,1370 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkFiberExtractionView.h"
#include <QmitkStdMultiWidget.h>
// Qt
#include <QMessageBox>
// MITK
#include <mitkNodePredicateProperty.h>
#include <mitkImageCast.h>
#include <mitkPointSet.h>
#include <mitkPlanarCircle.h>
#include <mitkPlanarPolygon.h>
#include <mitkPlanarRectangle.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkGlobalInteraction.h>
#include <mitkImageAccessByItk.h>
#include <mitkDataNodeObject.h>
#include <mitkDiffusionImage.h>
#include <mitkTensorImage.h>
// ITK
#include <itkResampleImageFilter.h>
#include <itkGaussianInterpolateImageFunction.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkTractsToFiberEndingsImageFilter.h>
#include <itkTractDensityImageFilter.h>
#include <itkImageRegion.h>
#include <itkTractsToRgbaImageFilter.h>
#include <math.h>
const std::string QmitkFiberExtractionView::VIEW_ID = "org.mitk.views.fiberextraction";
const std::string id_DataManager = "org.mitk.views.datamanager";
using namespace mitk;
QmitkFiberExtractionView::QmitkFiberExtractionView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_CircleCounter(0)
, m_PolygonCounter(0)
, m_UpsamplingFactor(5)
{
}
// Destructor
QmitkFiberExtractionView::~QmitkFiberExtractionView()
{
}
void QmitkFiberExtractionView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkFiberExtractionViewControls;
m_Controls->setupUi( parent );
m_Controls->doExtractFibersButton->setDisabled(true);
m_Controls->PFCompoANDButton->setDisabled(true);
m_Controls->PFCompoORButton->setDisabled(true);
m_Controls->PFCompoNOTButton->setDisabled(true);
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
m_Controls->m_RectangleButton->setVisible(false);
connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( OnDrawCircle() ) );
connect( m_Controls->m_PolygonButton, SIGNAL( clicked() ), this, SLOT( OnDrawPolygon() ) );
connect(m_Controls->PFCompoANDButton, SIGNAL(clicked()), this, SLOT(GenerateAndComposite()) );
connect(m_Controls->PFCompoORButton, SIGNAL(clicked()), this, SLOT(GenerateOrComposite()) );
connect(m_Controls->PFCompoNOTButton, SIGNAL(clicked()), this, SLOT(GenerateNotComposite()) );
connect(m_Controls->m_JoinBundles, SIGNAL(clicked()), this, SLOT(JoinBundles()) );
connect(m_Controls->m_SubstractBundles, SIGNAL(clicked()), this, SLOT(SubstractBundles()) );
connect(m_Controls->m_GenerateRoiImage, SIGNAL(clicked()), this, SLOT(GenerateRoiImage()) );
connect(m_Controls->m_Extract3dButton, SIGNAL(clicked()), this, SLOT(ExtractPassingMask()));
connect( m_Controls->m_ExtractMask, SIGNAL(clicked()), this, SLOT(ExtractEndingInMask()) );
connect( m_Controls->doExtractFibersButton, SIGNAL(clicked()), this, SLOT(DoFiberExtraction()) );
}
}
void QmitkFiberExtractionView::ExtractEndingInMask()
{
if (m_MaskImageNode.IsNull())
return;
mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
for (int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
QString name(m_SelectedFB.at(i)->GetName().c_str());
itkUCharImageType::Pointer mask = itkUCharImageType::New();
mitk::CastToItkImage<itkUCharImageType>(mitkMask, mask);
mitk::FiberBundleX::Pointer newFib = fib->ExtractFiberSubset(mask, false);
if (newFib->GetNumFibers()<=0)
{
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
continue;
}
DataNode::Pointer newNode = DataNode::New();
newNode->SetData(newFib);
name += "_ending-in-mask";
newNode->SetName(name.toStdString());
GetDefaultDataStorage()->Add(newNode);
m_SelectedFB.at(i)->SetVisibility(false);
}
}
void QmitkFiberExtractionView::ExtractPassingMask()
{
if (m_MaskImageNode.IsNull())
return;
mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
for (int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
QString name(m_SelectedFB.at(i)->GetName().c_str());
itkUCharImageType::Pointer mask = itkUCharImageType::New();
mitk::CastToItkImage<itkUCharImageType>(mitkMask, mask);
mitk::FiberBundleX::Pointer newFib = fib->ExtractFiberSubset(mask, true);
if (newFib->GetNumFibers()<=0)
{
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
continue;
}
DataNode::Pointer newNode = DataNode::New();
newNode->SetData(newFib);
name += "_passing-mask";
newNode->SetName(name.toStdString());
GetDefaultDataStorage()->Add(newNode);
m_SelectedFB.at(i)->SetVisibility(false);
}
}
void QmitkFiberExtractionView::GenerateRoiImage(){
if (m_SelectedPF.empty())
return;
mitk::Geometry3D::Pointer geometry;
if (!m_SelectedFB.empty())
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.front()->GetData());
geometry = fib->GetGeometry();
}
else
return;
- mitk::Vector3D spacing = geometry->GetSpacing();
+ itk::Vector<double,3> spacing = geometry->GetSpacing();
spacing /= m_UpsamplingFactor;
mitk::Point3D newOrigin = geometry->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
newOrigin[0] += bounds.GetElement(0);
newOrigin[1] += bounds.GetElement(2);
newOrigin[2] += bounds.GetElement(4);
itk::Matrix<double, 3, 3> direction;
itk::ImageRegion<3> imageRegion;
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
direction[j][i] = geometry->GetMatrixColumn(i)[j]/spacing[j];
imageRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
imageRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
imageRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
m_PlanarFigureImage = itkUCharImageType::New();
m_PlanarFigureImage->SetSpacing( spacing ); // Set the image spacing
m_PlanarFigureImage->SetOrigin( newOrigin ); // Set the image origin
m_PlanarFigureImage->SetDirection( direction ); // Set the image direction
m_PlanarFigureImage->SetRegions( imageRegion );
m_PlanarFigureImage->Allocate();
m_PlanarFigureImage->FillBuffer( 0 );
Image::Pointer tmpImage = Image::New();
tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
for (int i=0; i<m_SelectedPF.size(); i++)
CompositeExtraction(m_SelectedPF.at(i), tmpImage);
DataNode::Pointer node = DataNode::New();
tmpImage = Image::New();
tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
node->SetData(tmpImage);
node->SetName("ROI Image");
this->GetDefaultDataStorage()->Add(node);
}
void QmitkFiberExtractionView::CompositeExtraction(mitk::DataNode::Pointer node, mitk::Image* image)
{
if (dynamic_cast<mitk::PlanarFigure*>(node.GetPointer()->GetData()) && !dynamic_cast<mitk::PlanarFigureComposite*>(node.GetPointer()->GetData()))
{
m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node.GetPointer()->GetData());
AccessFixedDimensionByItk_2(
image,
InternalReorientImagePlane, 3,
m_PlanarFigure->GetGeometry(), -1);
AccessFixedDimensionByItk_2(
m_InternalImage,
InternalCalculateMaskFromPlanarFigure,
3, 2, node->GetName() );
}
}
template < typename TPixel, unsigned int VImageDimension >
void QmitkFiberExtractionView::InternalReorientImagePlane( const itk::Image< TPixel, VImageDimension > *image, mitk::Geometry3D* planegeo3D, int additionalIndex )
{
MITK_DEBUG << "InternalReorientImagePlane() start";
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< float, VImageDimension > FloatImageType;
typedef itk::ResampleImageFilter<ImageType, FloatImageType, double> ResamplerType;
typename ResamplerType::Pointer resampler = ResamplerType::New();
mitk::PlaneGeometry* planegeo = dynamic_cast<mitk::PlaneGeometry*>(planegeo3D);
float upsamp = m_UpsamplingFactor;
float gausssigma = 0.5;
// Spacing
typename ResamplerType::SpacingType spacing = planegeo->GetSpacing();
spacing[0] = image->GetSpacing()[0] / upsamp;
spacing[1] = image->GetSpacing()[1] / upsamp;
spacing[2] = image->GetSpacing()[2];
resampler->SetOutputSpacing( spacing );
// Size
typename ResamplerType::SizeType size;
size[0] = planegeo->GetParametricExtentInMM(0) / spacing[0];
size[1] = planegeo->GetParametricExtentInMM(1) / spacing[1];
size[2] = 1;
resampler->SetSize( size );
// Origin
typename mitk::Point3D orig = planegeo->GetOrigin();
typename mitk::Point3D corrorig;
planegeo3D->WorldToIndex(orig,corrorig);
corrorig[0] += 0.5/upsamp;
corrorig[1] += 0.5/upsamp;
corrorig[2] += 0;
planegeo3D->IndexToWorld(corrorig,corrorig);
resampler->SetOutputOrigin(corrorig );
// Direction
typename ResamplerType::DirectionType direction;
typename mitk::AffineTransform3D::MatrixType matrix = planegeo->GetIndexToWorldTransform()->GetMatrix();
for(int c=0; c<matrix.ColumnDimensions; c++)
{
double sum = 0;
for(int r=0; r<matrix.RowDimensions; r++)
{
sum += matrix(r,c)*matrix(r,c);
}
for(int r=0; r<matrix.RowDimensions; r++)
{
direction(r,c) = matrix(r,c)/sqrt(sum);
}
}
resampler->SetOutputDirection( direction );
// Gaussian interpolation
if(gausssigma != 0)
{
double sigma[3];
for( unsigned int d = 0; d < 3; d++ )
{
sigma[d] = gausssigma * image->GetSpacing()[d];
}
double alpha = 2.0;
typedef itk::GaussianInterpolateImageFunction<ImageType, double>
GaussianInterpolatorType;
typename GaussianInterpolatorType::Pointer interpolator
= GaussianInterpolatorType::New();
interpolator->SetInputImage( image );
interpolator->SetParameters( sigma, alpha );
resampler->SetInterpolator( interpolator );
}
else
{
// typedef typename itk::BSplineInterpolateImageFunction<ImageType, double>
// InterpolatorType;
typedef typename itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
typename InterpolatorType::Pointer interpolator
= InterpolatorType::New();
interpolator->SetInputImage( image );
resampler->SetInterpolator( interpolator );
}
// Other resampling options
resampler->SetInput( image );
resampler->SetDefaultPixelValue(0);
MITK_DEBUG << "Resampling requested image plane ... ";
resampler->Update();
MITK_DEBUG << " ... done";
if(additionalIndex < 0)
{
this->m_InternalImage = mitk::Image::New();
this->m_InternalImage->InitializeByItk( resampler->GetOutput() );
this->m_InternalImage->SetVolume( resampler->GetOutput()->GetBufferPointer() );
}
}
template < typename TPixel, unsigned int VImageDimension >
void QmitkFiberExtractionView::InternalCalculateMaskFromPlanarFigure( itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string nodeName )
{
MITK_DEBUG << "InternalCalculateMaskFromPlanarFigure() start";
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::CastImageFilter< ImageType, itkUCharImageType > CastFilterType;
// Generate mask image as new image with same header as input image and
// initialize with "1".
itkUCharImageType::Pointer newMaskImage = itkUCharImageType::New();
newMaskImage->SetSpacing( image->GetSpacing() ); // Set the image spacing
newMaskImage->SetOrigin( image->GetOrigin() ); // Set the image origin
newMaskImage->SetDirection( image->GetDirection() ); // Set the image direction
newMaskImage->SetRegions( image->GetLargestPossibleRegion() );
newMaskImage->Allocate();
newMaskImage->FillBuffer( 1 );
// Generate VTK polygon from (closed) PlanarFigure polyline
// (The polyline points are shifted by -0.5 in z-direction to make sure
// that the extrusion filter, which afterwards elevates all points by +0.5
// in z-direction, creates a 3D object which is cut by the the plane z=0)
const Geometry2D *planarFigureGeometry2D = m_PlanarFigure->GetGeometry2D();
const PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
const Geometry3D *imageGeometry3D = m_InternalImage->GetGeometry( 0 );
vtkPolyData *polyline = vtkPolyData::New();
polyline->Allocate( 1, 1 );
// Determine x- and y-dimensions depending on principal axis
int i0, i1;
switch ( axis )
{
case 0:
i0 = 1;
i1 = 2;
break;
case 1:
i0 = 0;
i1 = 2;
break;
case 2:
default:
i0 = 0;
i1 = 1;
break;
}
// Create VTK polydata object of polyline contour
vtkPoints *points = vtkPoints::New();
PlanarFigure::PolyLineType::const_iterator it;
std::vector<vtkIdType> indices;
unsigned int numberOfPoints = 0;
for ( it = planarFigurePolyline.begin();
it != planarFigurePolyline.end();
++it )
{
Point3D point3D;
// Convert 2D point back to the local index coordinates of the selected
// image
Point2D point2D = it->Point;
planarFigureGeometry2D->WorldToIndex(point2D, point2D);
point2D[0] -= 0.5/m_UpsamplingFactor;
point2D[1] -= 0.5/m_UpsamplingFactor;
planarFigureGeometry2D->IndexToWorld(point2D, point2D);
planarFigureGeometry2D->Map( point2D, point3D );
// Polygons (partially) outside of the image bounds can not be processed
// further due to a bug in vtkPolyDataToImageStencil
if ( !imageGeometry3D->IsInside( point3D ) )
{
float bounds[2] = {0,0};
bounds[0] =
this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i0);
bounds[1] =
this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i1);
imageGeometry3D->WorldToIndex( point3D, point3D );
// if (point3D[i0]<0)
// point3D[i0] = 0.5;
// else if (point3D[i0]>bounds[0])
// point3D[i0] = bounds[0]-0.5;
// if (point3D[i1]<0)
// point3D[i1] = 0.5;
// else if (point3D[i1]>bounds[1])
// point3D[i1] = bounds[1]-0.5;
if (point3D[i0]<0)
point3D[i0] = 0.0;
else if (point3D[i0]>bounds[0])
point3D[i0] = bounds[0]-0.001;
if (point3D[i1]<0)
point3D[i1] = 0.0;
else if (point3D[i1]>bounds[1])
point3D[i1] = bounds[1]-0.001;
points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
numberOfPoints++;
}
else
{
imageGeometry3D->WorldToIndex( point3D, point3D );
// Add point to polyline array
points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
numberOfPoints++;
}
}
polyline->SetPoints( points );
points->Delete();
vtkIdType *ptIds = new vtkIdType[numberOfPoints];
for ( vtkIdType i = 0; i < numberOfPoints; ++i )
{
ptIds[i] = i;
}
polyline->InsertNextCell( VTK_POLY_LINE, numberOfPoints, ptIds );
// Extrude the generated contour polygon
vtkLinearExtrusionFilter *extrudeFilter = vtkLinearExtrusionFilter::New();
extrudeFilter->SetInput( polyline );
extrudeFilter->SetScaleFactor( 1 );
extrudeFilter->SetExtrusionTypeToNormalExtrusion();
extrudeFilter->SetVector( 0.0, 0.0, 1.0 );
// Make a stencil from the extruded polygon
vtkPolyDataToImageStencil *polyDataToImageStencil = vtkPolyDataToImageStencil::New();
polyDataToImageStencil->SetInput( extrudeFilter->GetOutput() );
// Export from ITK to VTK (to use a VTK filter)
typedef itk::VTKImageImport< itkUCharImageType > ImageImportType;
typedef itk::VTKImageExport< itkUCharImageType > ImageExportType;
typename ImageExportType::Pointer itkExporter = ImageExportType::New();
itkExporter->SetInput( newMaskImage );
vtkImageImport *vtkImporter = vtkImageImport::New();
this->ConnectPipelines( itkExporter, vtkImporter );
vtkImporter->Update();
// Apply the generated image stencil to the input image
vtkImageStencil *imageStencilFilter = vtkImageStencil::New();
imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
imageStencilFilter->SetStencil( polyDataToImageStencil->GetOutput() );
imageStencilFilter->ReverseStencilOff();
imageStencilFilter->SetBackgroundValue( 0 );
imageStencilFilter->Update();
// Export from VTK back to ITK
vtkImageExport *vtkExporter = vtkImageExport::New();
vtkExporter->SetInputConnection( imageStencilFilter->GetOutputPort() );
vtkExporter->Update();
typename ImageImportType::Pointer itkImporter = ImageImportType::New();
this->ConnectPipelines( vtkExporter, itkImporter );
itkImporter->Update();
// calculate cropping bounding box
m_InternalImageMask3D = itkImporter->GetOutput();
m_InternalImageMask3D->SetDirection(image->GetDirection());
itk::ImageRegionConstIterator<itkUCharImageType>
itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType>
itimage(image, image->GetLargestPossibleRegion());
itmask = itmask.Begin();
itimage = itimage.Begin();
typename ImageType::SizeType lowersize = {{9999999999,9999999999,9999999999}};
typename ImageType::SizeType uppersize = {{0,0,0}};
while( !itmask.IsAtEnd() )
{
if(itmask.Get() == 0)
{
itimage.Set(0);
}
else
{
typename ImageType::IndexType index = itimage.GetIndex();
typename ImageType::SizeType signedindex;
signedindex[0] = index[0];
signedindex[1] = index[1];
signedindex[2] = index[2];
lowersize[0] = signedindex[0] < lowersize[0] ? signedindex[0] : lowersize[0];
lowersize[1] = signedindex[1] < lowersize[1] ? signedindex[1] : lowersize[1];
lowersize[2] = signedindex[2] < lowersize[2] ? signedindex[2] : lowersize[2];
uppersize[0] = signedindex[0] > uppersize[0] ? signedindex[0] : uppersize[0];
uppersize[1] = signedindex[1] > uppersize[1] ? signedindex[1] : uppersize[1];
uppersize[2] = signedindex[2] > uppersize[2] ? signedindex[2] : uppersize[2];
}
++itmask;
++itimage;
}
typename ImageType::IndexType index;
index[0] = lowersize[0];
index[1] = lowersize[1];
index[2] = lowersize[2];
typename ImageType::SizeType size;
size[0] = uppersize[0] - lowersize[0] + 1;
size[1] = uppersize[1] - lowersize[1] + 1;
size[2] = uppersize[2] - lowersize[2] + 1;
itk::ImageRegion<3> cropRegion = itk::ImageRegion<3>(index, size);
// crop internal mask
typedef itk::RegionOfInterestImageFilter< itkUCharImageType, itkUCharImageType > ROIMaskFilterType;
typename ROIMaskFilterType::Pointer roi2 = ROIMaskFilterType::New();
roi2->SetRegionOfInterest(cropRegion);
roi2->SetInput(m_InternalImageMask3D);
roi2->Update();
m_InternalImageMask3D = roi2->GetOutput();
Image::Pointer tmpImage = Image::New();
tmpImage->InitializeByItk(m_InternalImageMask3D.GetPointer());
tmpImage->SetVolume(m_InternalImageMask3D->GetBufferPointer());
Image::Pointer tmpImage2 = Image::New();
tmpImage2->InitializeByItk(m_PlanarFigureImage.GetPointer());
const Geometry3D *pfImageGeometry3D = tmpImage2->GetGeometry( 0 );
const Geometry3D *intImageGeometry3D = tmpImage->GetGeometry( 0 );
typedef itk::ImageRegionIteratorWithIndex<itkUCharImageType> IteratorType;
IteratorType imageIterator (m_InternalImageMask3D, m_InternalImageMask3D->GetRequestedRegion());
imageIterator.GoToBegin();
while ( !imageIterator.IsAtEnd() )
{
unsigned char val = imageIterator.Value();
if (val>0)
{
itk::Index<3> index = imageIterator.GetIndex();
Point3D point;
point[0] = index[0];
point[1] = index[1];
point[2] = index[2];
intImageGeometry3D->IndexToWorld(point, point);
pfImageGeometry3D->WorldToIndex(point, point);
point[i0] += 0.5;
point[i1] += 0.5;
index[0] = point[0];
index[1] = point[1];
index[2] = point[2];
if (pfImageGeometry3D->IsIndexInside(index))
m_PlanarFigureImage->SetPixel(index, 1);
}
++imageIterator;
}
// Clean up VTK objects
polyline->Delete();
extrudeFilter->Delete();
polyDataToImageStencil->Delete();
vtkImporter->Delete();
imageStencilFilter->Delete();
//vtkExporter->Delete(); // TODO: crashes when outcommented; memory leak??
delete[] ptIds;
}
void QmitkFiberExtractionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkFiberExtractionView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
/* OnSelectionChanged is registered to SelectionService, therefore no need to
implement SelectionService Listener explicitly */
void QmitkFiberExtractionView::UpdateGui()
{
m_Controls->m_Extract3dButton->setEnabled(false);
m_Controls->m_ExtractMask->setEnabled(false);
// are fiber bundles selected?
if ( m_SelectedFB.empty() )
{
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_JoinBundles->setEnabled(false);
m_Controls->m_SubstractBundles->setEnabled(false);
m_Controls->doExtractFibersButton->setEnabled(false);
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
}
else
{
m_Controls->m_InputData->setTitle("Input Data");
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
// one bundle and one planar figure needed to extract fibers
if (!m_SelectedPF.empty())
m_Controls->doExtractFibersButton->setEnabled(true);
// more than two bundles needed to join/subtract
if (m_SelectedFB.size() > 1)
{
m_Controls->m_JoinBundles->setEnabled(true);
m_Controls->m_SubstractBundles->setEnabled(true);
}
else
{
m_Controls->m_JoinBundles->setEnabled(false);
m_Controls->m_SubstractBundles->setEnabled(false);
}
if (m_MaskImageNode.IsNotNull())
{
m_Controls->m_Extract3dButton->setEnabled(true);
m_Controls->m_ExtractMask->setEnabled(true);
}
}
// are planar figures selected?
if ( m_SelectedPF.empty() )
{
m_Controls->doExtractFibersButton->setEnabled(false);
m_Controls->PFCompoANDButton->setEnabled(false);
m_Controls->PFCompoORButton->setEnabled(false);
m_Controls->PFCompoNOTButton->setEnabled(false);
m_Controls->m_GenerateRoiImage->setEnabled(false);
}
else
{
if ( !m_SelectedFB.empty() )
m_Controls->m_GenerateRoiImage->setEnabled(true);
else
m_Controls->m_GenerateRoiImage->setEnabled(false);
if (m_SelectedPF.size() > 1)
{
m_Controls->PFCompoANDButton->setEnabled(true);
m_Controls->PFCompoORButton->setEnabled(true);
m_Controls->PFCompoNOTButton->setEnabled(false);
}
else
{
m_Controls->PFCompoANDButton->setEnabled(false);
m_Controls->PFCompoORButton->setEnabled(false);
m_Controls->PFCompoNOTButton->setEnabled(true);
}
}
}
void QmitkFiberExtractionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
//reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
m_SelectedFB.clear();
m_SelectedPF.clear();
m_SelectedSurfaces.clear();
m_SelectedImage = NULL;
m_MaskImageNode = NULL;
m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_PfLabel->setText("<font color='grey'>needed for extraction</font>");
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
{
m_Controls->m_FibLabel->setText(node->GetName().c_str());
m_SelectedFB.push_back(node);
}
else if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
{
m_Controls->m_PfLabel->setText(node->GetName().c_str());
m_SelectedPF.push_back(node);
}
else if (dynamic_cast<mitk::Image*>(node->GetData()))
{
m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
{
m_MaskImageNode = node;
m_Controls->m_PfLabel->setText(node->GetName().c_str());
}
}
else if (dynamic_cast<mitk::Surface*>(node->GetData()))
{
m_Controls->m_PfLabel->setText(node->GetName().c_str());
m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
}
}
UpdateGui();
GenerateStats();
}
void QmitkFiberExtractionView::OnDrawPolygon()
{
// bool checked = m_Controls->m_PolygonButton->isChecked();
// if(!this->AssertDrawingIsPossible(checked))
// return;
mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
figure->ClosedOn();
this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
MITK_DEBUG << "PlanarPolygon created ...";
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
mitk::DataNode* node = 0;
mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
mitk::PlanarFigure* figureP = 0;
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
; it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
figureP = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
if(figureP)
{
figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
}
}
}
void QmitkFiberExtractionView::OnDrawCircle()
{
mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
this->GetDataStorage()->Modified();
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
mitk::DataNode* node = 0;
mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
mitk::PlanarFigure* figureP = 0;
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End(); it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
figureP = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
if(figureP)
{
figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
}
}
}
void QmitkFiberExtractionView::Activated()
{
}
void QmitkFiberExtractionView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
const char *propertyKey, mitk::BaseProperty *property )
{
// initialize figure's geometry with empty geometry
mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
figure->SetGeometry2D( emptygeometry );
//set desired data to DataNode where Planarfigure is stored
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetName(name.toStdString());
newNode->SetData(figure);
newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,0.0,0.0));
newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(2.0));
newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true));
newNode->AddProperty( "selected", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(false) );
newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(3.0) );
newNode->AddProperty( "planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.helperline.width", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
newNode->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(0.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
newNode->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(2.0));
newNode->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(2.0));
// figure drawn on the topmost layer / image
newNode->SetColor(1.0,1.0,1.0);
newNode->SetOpacity(0.8);
GetDataStorage()->Add(newNode );
std::vector<mitk::DataNode*> selectedNodes = GetDataManagerSelection();
for(unsigned int i = 0; i < selectedNodes.size(); i++)
{
selectedNodes[i]->SetSelected(false);
}
newNode->SetSelected(true);
}
void QmitkFiberExtractionView::DoFiberExtraction()
{
if ( m_SelectedFB.empty() ){
QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
MITK_WARN("QmitkFiberExtractionView") << "no fibe bundle selected";
return;
}
for (int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
mitk::PlanarFigure::Pointer roi = dynamic_cast<mitk::PlanarFigure*> (m_SelectedPF.at(0)->GetData());
mitk::FiberBundleX::Pointer extFB = fib->ExtractFiberSubset(roi);
if (extFB->GetNumFibers()<=0)
{
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
continue;
}
mitk::DataNode::Pointer node;
node = mitk::DataNode::New();
node->SetData(extFB);
QString name(m_SelectedFB.at(i)->GetName().c_str());
name += "_";
name += m_SelectedPF.at(0)->GetName().c_str();
node->SetName(name.toStdString());
GetDataStorage()->Add(node);
m_SelectedFB.at(i)->SetVisibility(false);
}
}
void QmitkFiberExtractionView::GenerateAndComposite()
{
mitk::PlanarFigureComposite::Pointer PFCAnd = mitk::PlanarFigureComposite::New();
mitk::PlaneGeometry* currentGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D()));
PFCAnd->SetGeometry2D(currentGeometry2D);
PFCAnd->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin();
it != m_SelectedPF.end(); ++it )
{
mitk::DataNode::Pointer nodePF = *it;
mitk::PlanarFigure::Pointer tmpPF = dynamic_cast<mitk::PlanarFigure*>( nodePF->GetData() );
PFCAnd->addPlanarFigure( tmpPF );
PFCAnd->addDataNode( nodePF );
PFCAnd->setDisplayName("AND_COMPO");
}
AddCompositeToDatastorage(PFCAnd, NULL);
}
void QmitkFiberExtractionView::GenerateOrComposite()
{
mitk::PlanarFigureComposite::Pointer PFCOr = mitk::PlanarFigureComposite::New();
mitk::PlaneGeometry* currentGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D()));
PFCOr->SetGeometry2D(currentGeometry2D);
PFCOr->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin();
it != m_SelectedPF.end(); ++it )
{
mitk::DataNode::Pointer nodePF = *it;
mitk::PlanarFigure::Pointer tmpPF = dynamic_cast<mitk::PlanarFigure*>( nodePF->GetData() );
PFCOr->addPlanarFigure( tmpPF );
PFCOr->addDataNode( nodePF );
PFCOr->setDisplayName("OR_COMPO");
}
AddCompositeToDatastorage(PFCOr, NULL);
}
void QmitkFiberExtractionView::GenerateNotComposite()
{
mitk::PlanarFigureComposite::Pointer PFCNot = mitk::PlanarFigureComposite::New();
mitk::PlaneGeometry* currentGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D()));
PFCNot->SetGeometry2D(currentGeometry2D);
PFCNot->setOperationType(mitk::PFCOMPOSITION_NOT_OPERATION);
for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin();
it != m_SelectedPF.end(); ++it )
{
mitk::DataNode::Pointer nodePF = *it;
mitk::PlanarFigure::Pointer tmpPF = dynamic_cast<mitk::PlanarFigure*>( nodePF->GetData() );
PFCNot->addPlanarFigure( tmpPF );
PFCNot->addDataNode( nodePF );
PFCNot->setDisplayName("NOT_COMPO");
}
AddCompositeToDatastorage(PFCNot, NULL);
}
/* CLEANUP NEEDED */
void QmitkFiberExtractionView::AddCompositeToDatastorage(mitk::PlanarFigureComposite::Pointer pfcomp, mitk::DataNode::Pointer parentDataNode )
{
mitk::DataNode::Pointer newPFCNode;
newPFCNode = mitk::DataNode::New();
newPFCNode->SetName( pfcomp->getDisplayName() );
newPFCNode->SetData(pfcomp);
newPFCNode->SetVisibility(true);
switch (pfcomp->getOperationType()) {
case 0:
{
if (!parentDataNode.IsNull()) {
GetDataStorage()->Add(newPFCNode, parentDataNode);
} else {
GetDataStorage()->Add(newPFCNode);
}
//iterate through its childs
for(int i=0; i<pfcomp->getNumberOfChildren(); ++i)
{
mitk::PlanarFigure::Pointer tmpPFchild = pfcomp->getChildAt(i);
mitk::DataNode::Pointer savedPFchildNode = pfcomp->getDataNodeAt(i);
mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
if ( !pfcompcast.IsNull() )
{
// child is of type planar Figure composite
// make new node of the child, cuz later the child has to be removed of its old position in datamanager
// feed new dataNode with information of the savedDataNode, which is gonna be removed soon
mitk::DataNode::Pointer newChildPFCNode;
newChildPFCNode = mitk::DataNode::New();
newChildPFCNode->SetData(tmpPFchild);
newChildPFCNode->SetName( savedPFchildNode->GetName() );
pfcompcast->setDisplayName( savedPFchildNode->GetName() ); //name might be changed in DataManager by user
//update inside vector the dataNodePointer
pfcomp->replaceDataNodeAt(i, newChildPFCNode);
AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
// remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
// without having its parent anymore
//GetDataStorage()->Remove(savedPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
}else{
MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
}
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
}
}
else
{
// child is not of type PlanarFigureComposite, so its one of the planarFigures
// create new dataNode containing the data of the old dataNode, but position in dataManager will be
// modified cuz we re setting a (new) parent.
mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
newPFchildNode->SetName(savedPFchildNode->GetName() );
newPFchildNode->SetData(tmpPFchild);
newPFchildNode->SetVisibility(true);
// replace the dataNode in PFComp DataNodeVector
pfcomp->replaceDataNodeAt(i, newPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
}
else
{
MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
}
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode))
{
MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
}
MITK_DEBUG << "adding " << newPFchildNode->GetName() << " to " << newPFCNode->GetName();
//add new child to datamanager with its new position as child of newPFCNode parent
GetDataStorage()->Add(newPFchildNode, newPFCNode);
}
}
GetDataStorage()->Modified();
break;
}
case 1:
{
if (!parentDataNode.IsNull()) {
MITK_DEBUG << "adding " << newPFCNode->GetName() << " to " << parentDataNode->GetName() ;
GetDataStorage()->Add(newPFCNode, parentDataNode);
} else {
MITK_DEBUG << "adding " << newPFCNode->GetName();
GetDataStorage()->Add(newPFCNode);
}
for(int i=0; i<pfcomp->getNumberOfChildren(); ++i)
{
mitk::PlanarFigure::Pointer tmpPFchild = pfcomp->getChildAt(i);
mitk::DataNode::Pointer savedPFchildNode = pfcomp->getDataNodeAt(i);
mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
if ( !pfcompcast.IsNull() )
{ // child is of type planar Figure composite
// make new node of the child, cuz later the child has to be removed of its old position in datamanager
// feed new dataNode with information of the savedDataNode, which is gonna be removed soon
mitk::DataNode::Pointer newChildPFCNode;
newChildPFCNode = mitk::DataNode::New();
newChildPFCNode->SetData(tmpPFchild);
newChildPFCNode->SetName( savedPFchildNode->GetName() );
pfcompcast->setDisplayName( savedPFchildNode->GetName() ); //name might be changed in DataManager by user
//update inside vector the dataNodePointer
pfcomp->replaceDataNodeAt(i, newChildPFCNode);
AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
// remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
// without having its parent anymore
//GetDataStorage()->Remove(savedPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
}else{
MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
}
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
}
} else {
// child is not of type PlanarFigureComposite, so its one of the planarFigures
// create new dataNode containing the data of the old dataNode, but position in dataManager will be
// modified cuz we re setting a (new) parent.
mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
newPFchildNode->SetName(savedPFchildNode->GetName() );
newPFchildNode->SetData(tmpPFchild);
newPFchildNode->SetVisibility(true);
// replace the dataNode in PFComp DataNodeVector
pfcomp->replaceDataNodeAt(i, newPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
}else{
MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
}
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
}
MITK_DEBUG << "adding " << newPFchildNode->GetName() << " to " << newPFCNode->GetName();
//add new child to datamanager with its new position as child of newPFCNode parent
GetDataStorage()->Add(newPFchildNode, newPFCNode);
}
}
GetDataStorage()->Modified();
break;
}
case 2:
{
if (!parentDataNode.IsNull()) {
MITK_DEBUG << "adding " << newPFCNode->GetName() << " to " << parentDataNode->GetName() ;
GetDataStorage()->Add(newPFCNode, parentDataNode);
}
else
{
MITK_DEBUG << "adding " << newPFCNode->GetName();
GetDataStorage()->Add(newPFCNode);
}
//iterate through its childs
for(int i=0; i<pfcomp->getNumberOfChildren(); ++i)
{
mitk::PlanarFigure::Pointer tmpPFchild = pfcomp->getChildAt(i);
mitk::DataNode::Pointer savedPFchildNode = pfcomp->getDataNodeAt(i);
mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
if ( !pfcompcast.IsNull() )
{ // child is of type planar Figure composite
// makeRemoveBundle new node of the child, cuz later the child has to be removed of its old position in datamanager
// feed new dataNode with information of the savedDataNode, which is gonna be removed soon
mitk::DataNode::Pointer newChildPFCNode;
newChildPFCNode = mitk::DataNode::New();
newChildPFCNode->SetData(tmpPFchild);
newChildPFCNode->SetName( savedPFchildNode->GetName() );
pfcompcast->setDisplayName( savedPFchildNode->GetName() ); //name might be changed in DataManager by user
//update inside vector the dataNodePointer
pfcomp->replaceDataNodeAt(i, newChildPFCNode);
AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
// remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
// without having its parent anymore
//GetDataStorage()->Remove(savedPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
}else{
MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
}
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
}
} else {
// child is not of type PlanarFigureComposite, so its one of the planarFigures
// create new dataNode containing the data of the old dataNode, but position in dataManager will be
// modified cuz we re setting a (new) parent.
mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
newPFchildNode->SetName(savedPFchildNode->GetName() );
newPFchildNode->SetData(tmpPFchild);
newPFchildNode->SetVisibility(true);
// replace the dataNode in PFComp DataNodeVector
pfcomp->replaceDataNodeAt(i, newPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
}else{
MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
}
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
if ( GetDataStorage()->Exists(savedPFchildNode)) {
MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
}
MITK_DEBUG << "adding " << newPFchildNode->GetName() << " to " << newPFCNode->GetName();
//add new child to datamanager with its new position as child of newPFCNode parent
GetDataStorage()->Add(newPFchildNode, newPFCNode);
}
}
GetDataStorage()->Modified();
break;
}
default:
MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
break;
}
}
void QmitkFiberExtractionView::JoinBundles()
{
if ( m_SelectedFB.size()<2 ){
QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
MITK_WARN("QmitkFiberExtractionView") << "Select at least two fiber bundles!";
return;
}
mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
m_SelectedFB.at(0)->SetVisibility(false);
QString name("");
name += QString(m_SelectedFB.at(0)->GetName().c_str());
for (int i=1; i<m_SelectedFB.size(); i++)
{
newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
name += "+"+QString(m_SelectedFB.at(i)->GetName().c_str());
m_SelectedFB.at(i)->SetVisibility(false);
}
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
GetDataStorage()->Add(fbNode);
}
void QmitkFiberExtractionView::SubstractBundles()
{
if ( m_SelectedFB.size()<2 ){
QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
MITK_WARN("QmitkFiberExtractionView") << "Select at least two fiber bundles!";
return;
}
mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
m_SelectedFB.at(0)->SetVisibility(false);
QString name("");
name += QString(m_SelectedFB.at(0)->GetName().c_str());
for (int i=1; i<m_SelectedFB.size(); i++)
{
newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
if (newBundle.IsNull())
break;
name += "-"+QString(m_SelectedFB.at(i)->GetName().c_str());
m_SelectedFB.at(i)->SetVisibility(false);
}
if (newBundle.IsNull())
{
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers. Did you select the fiber bundles in the correct order? X-Y is not equal to Y-X!");
return;
}
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
GetDataStorage()->Add(fbNode);
}
void QmitkFiberExtractionView::GenerateStats()
{
if ( m_SelectedFB.empty() )
return;
QString stats("");
for( int i=0; i<m_SelectedFB.size(); i++ )
{
mitk::DataNode::Pointer node = m_SelectedFB[i];
if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
{
if (i>0)
stats += "\n-----------------------------\n";
stats += QString(node->GetName().c_str()) + "\n";
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
stats += "Number of fibers: "+ QString::number(fib->GetNumFibers()) + "\n";
stats += "Min. length: "+ QString::number(fib->GetMinFiberLength(),'f',1) + " mm\n";
stats += "Max. length: "+ QString::number(fib->GetMaxFiberLength(),'f',1) + " mm\n";
stats += "Mean length: "+ QString::number(fib->GetMeanFiberLength(),'f',1) + " mm\n";
stats += "Median length: "+ QString::number(fib->GetMedianFiberLength(),'f',1) + " mm\n";
stats += "Standard deviation: "+ QString::number(fib->GetLengthStDev(),'f',1) + " mm\n";
}
}
this->m_Controls->m_StatsTextEdit->setText(stats);
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
index 2bd20830af..a52818d6df 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
@@ -1,469 +1,470 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkFiberProcessingView.h"
#include <QmitkStdMultiWidget.h>
// Qt
#include <QMessageBox>
// MITK
#include <mitkNodePredicateProperty.h>
#include <mitkImageCast.h>
#include <mitkPointSet.h>
#include <mitkPlanarCircle.h>
#include <mitkPlanarPolygon.h>
#include <mitkPlanarRectangle.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkGlobalInteraction.h>
#include <mitkImageAccessByItk.h>
#include <mitkDataNodeObject.h>
#include <mitkDiffusionImage.h>
#include <mitkTensorImage.h>
// ITK
#include <itkResampleImageFilter.h>
#include <itkGaussianInterpolateImageFunction.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkTractsToFiberEndingsImageFilter.h>
#include <itkTractDensityImageFilter.h>
#include <itkImageRegion.h>
#include <itkTractsToRgbaImageFilter.h>
#include <math.h>
const std::string QmitkFiberProcessingView::VIEW_ID = "org.mitk.views.fiberprocessing";
const std::string id_DataManager = "org.mitk.views.datamanager";
using namespace mitk;
QmitkFiberProcessingView::QmitkFiberProcessingView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_UpsamplingFactor(5)
{
}
// Destructor
QmitkFiberProcessingView::~QmitkFiberProcessingView()
{
}
void QmitkFiberProcessingView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkFiberProcessingViewControls;
m_Controls->setupUi( parent );
connect( m_Controls->m_ProcessFiberBundleButton, SIGNAL(clicked()), this, SLOT(ProcessSelectedBundles()) );
connect( m_Controls->m_ResampleFibersButton, SIGNAL(clicked()), this, SLOT(ResampleSelectedBundles()) );
connect(m_Controls->m_FaColorFibersButton, SIGNAL(clicked()), this, SLOT(DoImageColorCoding()));
connect( m_Controls->m_PruneFibersButton, SIGNAL(clicked()), this, SLOT(PruneBundle()) );
connect( m_Controls->m_CurvatureThresholdButton, SIGNAL(clicked()), this, SLOT(ApplyCurvatureThreshold()) );
connect( m_Controls->m_MirrorFibersButton, SIGNAL(clicked()), this, SLOT(MirrorFibers()) );
}
}
void QmitkFiberProcessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
+
void QmitkFiberProcessingView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkFiberProcessingView::UpdateGui()
{
// are fiber bundles selected?
if ( m_SelectedFB.empty() )
{
m_Controls->m_ProcessFiberBundleButton->setEnabled(false);
m_Controls->m_ResampleFibersButton->setEnabled(false);
m_Controls->m_FaColorFibersButton->setEnabled(false);
m_Controls->m_PruneFibersButton->setEnabled(false);
m_Controls->m_CurvatureThresholdButton->setEnabled(false);
if (m_SelectedSurfaces.size()>0)
m_Controls->m_MirrorFibersButton->setEnabled(true);
else
m_Controls->m_MirrorFibersButton->setEnabled(false);
}
else
{
m_Controls->m_ProcessFiberBundleButton->setEnabled(true);
m_Controls->m_ResampleFibersButton->setEnabled(true);
m_Controls->m_PruneFibersButton->setEnabled(true);
m_Controls->m_CurvatureThresholdButton->setEnabled(true);
m_Controls->m_MirrorFibersButton->setEnabled(true);
if (m_SelectedImage.IsNotNull())
m_Controls->m_FaColorFibersButton->setEnabled(true);
}
}
void QmitkFiberProcessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
//reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
m_SelectedFB.clear();
m_SelectedSurfaces.clear();
m_SelectedImage = NULL;
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
{
m_SelectedFB.push_back(node);
}
else if (dynamic_cast<mitk::Image*>(node->GetData()))
m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
else if (dynamic_cast<mitk::Surface*>(node->GetData()))
{
m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
}
}
UpdateGui();
GenerateStats();
}
void QmitkFiberProcessingView::Activated()
{
}
void QmitkFiberProcessingView::PruneBundle()
{
int minLength = this->m_Controls->m_PruneFibersSpinBox->value();
int maxLength = this->m_Controls->m_MaxPruneFibersSpinBox->value();
for (int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
if (!fib->RemoveShortFibers(minLength))
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
else if (!fib->RemoveLongFibers(maxLength))
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
}
GenerateStats();
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberProcessingView::ApplyCurvatureThreshold()
{
int mm = this->m_Controls->m_MinCurvatureRadiusBox->value();
for (int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
if (!fib->ApplyCurvatureThreshold(mm, this->m_Controls->m_RemoveFiberDueToCurvatureCheckbox->isChecked()))
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
}
GenerateStats();
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberProcessingView::GenerateStats()
{
if ( m_SelectedFB.empty() )
return;
QString stats("");
for( int i=0; i<m_SelectedFB.size(); i++ )
{
mitk::DataNode::Pointer node = m_SelectedFB[i];
if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
{
if (i>0)
stats += "\n-----------------------------\n";
stats += QString(node->GetName().c_str()) + "\n";
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
stats += "Number of fibers: "+ QString::number(fib->GetNumFibers()) + "\n";
stats += "Min. length: "+ QString::number(fib->GetMinFiberLength(),'f',1) + " mm\n";
stats += "Max. length: "+ QString::number(fib->GetMaxFiberLength(),'f',1) + " mm\n";
stats += "Mean length: "+ QString::number(fib->GetMeanFiberLength(),'f',1) + " mm\n";
stats += "Median length: "+ QString::number(fib->GetMedianFiberLength(),'f',1) + " mm\n";
stats += "Standard deviation: "+ QString::number(fib->GetLengthStDev(),'f',1) + " mm\n";
}
}
this->m_Controls->m_StatsTextEdit->setText(stats);
}
void QmitkFiberProcessingView::ProcessSelectedBundles()
{
if ( m_SelectedFB.empty() ){
QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
MITK_WARN("QmitkFiberProcessingView") << "no fibe bundle selected";
return;
}
int generationMethod = m_Controls->m_GenerationBox->currentIndex();
for( int i=0; i<m_SelectedFB.size(); i++ )
{
mitk::DataNode::Pointer node = m_SelectedFB[i];
if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
QString name(node->GetName().c_str());
DataNode::Pointer newNode = NULL;
switch(generationMethod){
case 0:
newNode = GenerateTractDensityImage(fib, false, true);
name += "_TDI";
break;
case 1:
newNode = GenerateTractDensityImage(fib, false, false);
name += "_TDI";
break;
case 2:
newNode = GenerateTractDensityImage(fib, true, false);
name += "_envelope";
break;
case 3:
newNode = GenerateColorHeatmap(fib);
break;
case 4:
newNode = GenerateFiberEndingsImage(fib);
name += "_fiber_endings";
break;
case 5:
newNode = GenerateFiberEndingsPointSet(fib);
name += "_fiber_endings";
break;
}
if (newNode.IsNotNull())
{
newNode->SetName(name.toStdString());
GetDataStorage()->Add(newNode);
}
}
}
}
// generate pointset displaying the fiber endings
mitk::DataNode::Pointer QmitkFiberProcessingView::GenerateFiberEndingsPointSet(mitk::FiberBundleX::Pointer fib)
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
vtkSmartPointer<vtkPolyData> fiberPolyData = fib->GetFiberPolyData();
vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
vLines->InitTraversal();
int count = 0;
int numFibers = fib->GetNumFibers();
for( int i=0; i<numFibers; i++ )
{
vtkIdType numPoints(0);
vtkIdType* points(NULL);
vLines->GetNextCell ( numPoints, points );
if (numPoints>0)
{
double* point = fiberPolyData->GetPoint(points[0]);
itk::Point<float,3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
pointSet->InsertPoint(count, itkPoint);
count++;
}
if (numPoints>2)
{
double* point = fiberPolyData->GetPoint(points[numPoints-1]);
itk::Point<float,3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
pointSet->InsertPoint(count, itkPoint);
count++;
}
}
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( pointSet );
return node;
}
// generate image displaying the fiber endings
mitk::DataNode::Pointer QmitkFiberProcessingView::GenerateFiberEndingsImage(mitk::FiberBundleX::Pointer fib)
{
typedef unsigned char OutPixType;
typedef itk::Image<OutPixType,3> OutImageType;
typedef itk::TractsToFiberEndingsImageFilter< OutImageType > ImageGeneratorType;
ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
generator->SetFiberBundle(fib);
generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
if (m_SelectedImage.IsNotNull())
{
OutImageType::Pointer itkImage = OutImageType::New();
CastToItkImage(m_SelectedImage, itkImage);
generator->SetInputImage(itkImage);
generator->SetUseImageGeometry(true);
}
generator->Update();
// get output image
OutImageType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// init data node
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
return node;
}
// generate rgba heatmap from fiber bundle
mitk::DataNode::Pointer QmitkFiberProcessingView::GenerateColorHeatmap(mitk::FiberBundleX::Pointer fib)
{
typedef itk::RGBAPixel<unsigned char> OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
typedef itk::TractsToRgbaImageFilter< OutImageType > ImageGeneratorType;
ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
generator->SetFiberBundle(fib);
generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
if (m_SelectedImage.IsNotNull())
{
itk::Image<unsigned char, 3>::Pointer itkImage = itk::Image<unsigned char, 3>::New();
CastToItkImage(m_SelectedImage, itkImage);
generator->SetInputImage(itkImage);
generator->SetUseImageGeometry(true);
}
generator->Update();
// get output image
typedef itk::Image<OutPixType,3> OutType;
OutType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// init data node
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
return node;
}
// generate tract density image from fiber bundle
mitk::DataNode::Pointer QmitkFiberProcessingView::GenerateTractDensityImage(mitk::FiberBundleX::Pointer fib, bool binary, bool absolute)
{
typedef float OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
generator->SetFiberBundle(fib);
generator->SetBinaryOutput(binary);
generator->SetOutputAbsoluteValues(absolute);
generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
if (m_SelectedImage.IsNotNull())
{
OutImageType::Pointer itkImage = OutImageType::New();
CastToItkImage(m_SelectedImage, itkImage);
generator->SetInputImage(itkImage);
generator->SetUseImageGeometry(true);
}
generator->Update();
// get output image
typedef itk::Image<OutPixType,3> OutType;
OutType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// init data node
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
return node;
}
void QmitkFiberProcessingView::ResampleSelectedBundles()
{
int factor = this->m_Controls->m_ResampleFibersSpinBox->value();
for (int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
fib->DoFiberSmoothing(factor);
}
GenerateStats();
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberProcessingView::MirrorFibers()
{
unsigned int axis = this->m_Controls->m_AxisSelectionBox->currentIndex();
for (int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
fib->MirrorFibers(axis);
}
if (m_SelectedFB.size()>0)
GenerateStats();
if (m_SelectedSurfaces.size()>0)
{
for (int i=0; i<m_SelectedSurfaces.size(); i++)
{
mitk::Surface::Pointer surf = m_SelectedSurfaces.at(i);
vtkSmartPointer<vtkPolyData> poly = surf->GetVtkPolyData();
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
for (int i=0; i<poly->GetNumberOfPoints(); i++)
{
double* point = poly->GetPoint(i);
point[axis] *= -1;
vtkNewPoints->InsertNextPoint(point);
}
poly->SetPoints(vtkNewPoints);
surf->CalculateBoundingBox();
}
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberProcessingView::DoImageColorCoding()
{
if (m_SelectedImage.IsNull())
return;
for( int i=0; i<m_SelectedFB.size(); i++ )
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
fib->SetFAMap(m_SelectedImage);
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_FA_BASED);
fib->DoColorCodingFaBased();
}
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
old mode 100644
new mode 100755
index 23b8a8c7ab..ff0bd67487
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,1594 +1,1789 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//misc
#define _USE_MATH_DEFINES
#include <math.h>
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkFiberfoxView.h"
// MITK
#include <mitkImage.h>
#include <mitkDiffusionImage.h>
#include <mitkImageToItk.h>
#include <itkDwiPhantomGenerationFilter.h>
#include <mitkImageCast.h>
#include <mitkProperties.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkDataStorage.h>
#include <itkFibersFromPlanarFiguresFilter.h>
#include <itkTractsToDWIImageFilter.h>
#include <mitkTensorImage.h>
#include <mitkILinkedRenderWindowPart.h>
#include <mitkGlobalInteraction.h>
#include <mitkImageToItk.h>
#include <mitkImageCast.h>
#include <mitkImageGenerator.h>
#include <mitkNodePredicateDataType.h>
#include <mitkTensorModel.h>
#include <mitkBallModel.h>
#include <mitkStickModel.h>
#include <mitkAstroStickModel.h>
#include <mitkDotModel.h>
#include <mitkRicianNoiseModel.h>
-#include <mitkGibbsRingingArtifact.h>
-#include <mitkSignalDecay.h>
#include <itkScalableAffineTransform.h>
#include <mitkLevelWindowProperty.h>
+#include <mitkNodePredicateOr.h>
+#include <mitkNodePredicateAnd.h>
+#include <mitkNodePredicateNot.h>
+#include <itkAddArtifactsToDwiImageFilter.h>
#include <QMessageBox>
#define _USE_MATH_DEFINES
#include <math.h>
const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
QmitkFiberfoxView::QmitkFiberfoxView()
: QmitkAbstractView()
, m_Controls( 0 )
, m_SelectedImage( NULL )
{
}
// Destructor
QmitkFiberfoxView::~QmitkFiberfoxView()
{
}
void QmitkFiberfoxView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkFiberfoxViewControls;
m_Controls->setupUi( parent );
m_Controls->m_StickWidget1->setVisible(true);
m_Controls->m_StickWidget2->setVisible(false);
m_Controls->m_ZeppelinWidget1->setVisible(false);
m_Controls->m_ZeppelinWidget2->setVisible(false);
m_Controls->m_TensorWidget1->setVisible(false);
m_Controls->m_TensorWidget2->setVisible(false);
m_Controls->m_BallWidget1->setVisible(true);
m_Controls->m_BallWidget2->setVisible(false);
m_Controls->m_AstrosticksWidget1->setVisible(false);
m_Controls->m_AstrosticksWidget2->setVisible(false);
m_Controls->m_DotWidget1->setVisible(false);
m_Controls->m_DotWidget2->setVisible(false);
m_Controls->m_Comp4FractionFrame->setVisible(false);
m_Controls->m_DiffusionPropsMessage->setVisible(false);
m_Controls->m_GeometryMessage->setVisible(false);
m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
m_Controls->m_VarianceBox->setVisible(false);
- m_Controls->m_KspaceParamFrame->setVisible(false);
+ m_Controls->m_GibbsRingingFrame->setVisible(false);
+ m_Controls->m_NoiseFrame->setVisible(false);
+ m_Controls->m_GhostFrame->setVisible(false);
+ m_Controls->m_DistortionsFrame->setVisible(false);
+ m_Controls->m_EddyFrame->setVisible(false);
+
+ m_Controls->m_FrequencyMapBox->SetDataStorage(this->GetDataStorage());
+ mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
+ mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
+ mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
+ mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
+ mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
+ isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
+ mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
+ mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
+ m_Controls->m_FrequencyMapBox->SetPredicate(finalPredicate);
connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
connect((QObject*) m_Controls->m_GenerateFibersButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFibers()));
connect((QObject*) m_Controls->m_CircleButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnDrawROI()));
connect((QObject*) m_Controls->m_FlipButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnFlipButton()));
connect((QObject*) m_Controls->m_JoinBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(JoinBundles()));
connect((QObject*) m_Controls->m_VarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
connect((QObject*) m_Controls->m_DistributionBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnDistributionChanged(int)));
connect((QObject*) m_Controls->m_FiberDensityBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberDensityChanged(int)));
connect((QObject*) m_Controls->m_FiberSamplingBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberSamplingChanged(int)));
connect((QObject*) m_Controls->m_TensionBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnTensionChanged(double)));
connect((QObject*) m_Controls->m_ContinuityBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnContinuityChanged(double)));
connect((QObject*) m_Controls->m_BiasBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnBiasChanged(double)));
connect((QObject*) m_Controls->m_AddGibbsRinging, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGibbsRinging(int)));
+ connect((QObject*) m_Controls->m_AddNoise, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddNoise(int)));
+ connect((QObject*) m_Controls->m_AddGhosts, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGhosts(int)));
+ connect((QObject*) m_Controls->m_AddDistortions, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddDistortions(int)));
+ connect((QObject*) m_Controls->m_AddEddy, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddEddy(int)));
+
connect((QObject*) m_Controls->m_ConstantRadiusBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnConstantRadius(int)));
connect((QObject*) m_Controls->m_CopyBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(CopyBundles()));
connect((QObject*) m_Controls->m_TransformBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(ApplyTransform()));
connect((QObject*) m_Controls->m_AlignOnGrid, SIGNAL(clicked()), (QObject*) this, SLOT(AlignOnGrid()));
connect((QObject*) m_Controls->m_Compartment1Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp1ModelFrameVisibility(int)));
connect((QObject*) m_Controls->m_Compartment2Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp2ModelFrameVisibility(int)));
connect((QObject*) m_Controls->m_Compartment3Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp3ModelFrameVisibility(int)));
connect((QObject*) m_Controls->m_Compartment4Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp4ModelFrameVisibility(int)));
connect((QObject*) m_Controls->m_AdvancedOptionsBox, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
connect((QObject*) m_Controls->m_AdvancedOptionsBox_2, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
}
}
void QmitkFiberfoxView::ShowAdvancedOptions(int state)
{
if (state)
{
m_Controls->m_AdvancedFiberOptionsFrame->setVisible(true);
m_Controls->m_AdvancedSignalOptionsFrame->setVisible(true);
m_Controls->m_AdvancedOptionsBox->setChecked(true);
m_Controls->m_AdvancedOptionsBox_2->setChecked(true);
}
else
{
m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
m_Controls->m_AdvancedOptionsBox->setChecked(false);
m_Controls->m_AdvancedOptionsBox_2->setChecked(false);
}
}
void QmitkFiberfoxView::Comp1ModelFrameVisibility(int index)
{
m_Controls->m_StickWidget1->setVisible(false);
m_Controls->m_ZeppelinWidget1->setVisible(false);
m_Controls->m_TensorWidget1->setVisible(false);
switch (index)
{
case 0:
m_Controls->m_StickWidget1->setVisible(true);
break;
case 1:
m_Controls->m_ZeppelinWidget1->setVisible(true);
break;
case 2:
m_Controls->m_TensorWidget1->setVisible(true);
break;
}
}
void QmitkFiberfoxView::Comp2ModelFrameVisibility(int index)
{
m_Controls->m_StickWidget2->setVisible(false);
m_Controls->m_ZeppelinWidget2->setVisible(false);
m_Controls->m_TensorWidget2->setVisible(false);
switch (index)
{
case 0:
break;
case 1:
m_Controls->m_StickWidget2->setVisible(true);
break;
case 2:
m_Controls->m_ZeppelinWidget2->setVisible(true);
break;
case 3:
m_Controls->m_TensorWidget2->setVisible(true);
break;
}
}
void QmitkFiberfoxView::Comp3ModelFrameVisibility(int index)
{
m_Controls->m_BallWidget1->setVisible(false);
m_Controls->m_AstrosticksWidget1->setVisible(false);
m_Controls->m_DotWidget1->setVisible(false);
switch (index)
{
case 0:
m_Controls->m_BallWidget1->setVisible(true);
break;
case 1:
m_Controls->m_AstrosticksWidget1->setVisible(true);
break;
case 2:
m_Controls->m_DotWidget1->setVisible(true);
break;
}
}
void QmitkFiberfoxView::Comp4ModelFrameVisibility(int index)
{
m_Controls->m_BallWidget2->setVisible(false);
m_Controls->m_AstrosticksWidget2->setVisible(false);
m_Controls->m_DotWidget2->setVisible(false);
m_Controls->m_Comp4FractionFrame->setVisible(false);
switch (index)
{
case 0:
break;
case 1:
m_Controls->m_BallWidget2->setVisible(true);
m_Controls->m_Comp4FractionFrame->setVisible(true);
break;
case 2:
m_Controls->m_AstrosticksWidget2->setVisible(true);
m_Controls->m_Comp4FractionFrame->setVisible(true);
break;
case 3:
m_Controls->m_DotWidget2->setVisible(true);
m_Controls->m_Comp4FractionFrame->setVisible(true);
break;
}
}
void QmitkFiberfoxView::OnConstantRadius(int value)
{
if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
+void QmitkFiberfoxView::OnAddEddy(int value)
+{
+ if (value>0)
+ m_Controls->m_EddyFrame->setVisible(true);
+ else
+ m_Controls->m_EddyFrame->setVisible(false);
+}
+
+void QmitkFiberfoxView::OnAddDistortions(int value)
+{
+ if (value>0)
+ m_Controls->m_DistortionsFrame->setVisible(true);
+ else
+ m_Controls->m_DistortionsFrame->setVisible(false);
+}
+
+void QmitkFiberfoxView::OnAddGhosts(int value)
+{
+ if (value>0)
+ m_Controls->m_GhostFrame->setVisible(true);
+ else
+ m_Controls->m_GhostFrame->setVisible(false);
+}
+
+void QmitkFiberfoxView::OnAddNoise(int value)
+{
+ if (value>0)
+ m_Controls->m_NoiseFrame->setVisible(true);
+ else
+ m_Controls->m_NoiseFrame->setVisible(false);
+}
+
void QmitkFiberfoxView::OnAddGibbsRinging(int value)
{
if (value>0)
- m_Controls->m_KspaceParamFrame->setVisible(true);
+ m_Controls->m_GibbsRingingFrame->setVisible(true);
else
- m_Controls->m_KspaceParamFrame->setVisible(false);
+ m_Controls->m_GibbsRingingFrame->setVisible(false);
}
void QmitkFiberfoxView::OnDistributionChanged(int value)
{
if (value==1)
m_Controls->m_VarianceBox->setVisible(true);
else
m_Controls->m_VarianceBox->setVisible(false);
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnVarianceChanged(double value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnFiberDensityChanged(int value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnFiberSamplingChanged(int value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnTensionChanged(double value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnContinuityChanged(double value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnBiasChanged(double value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::AlignOnGrid()
{
for (int i=0; i<m_SelectedFiducials.size(); i++)
{
mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
{
mitk::DataNode::Pointer pFibNode = *it;
if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pFibNode->GetData()) )
{
mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
{
mitk::DataNode::Pointer pImgNode = *it2;
if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
mitk::Geometry3D::Pointer geom = img->GetGeometry();
itk::Index<3> idx;
geom->WorldToIndex(wc0, idx);
mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
mitk::Point3D world;
geom->IndexToWorld(cIdx,world);
mitk::Vector3D trans = world - wc0;
pe->GetGeometry()->Translate(trans);
break;
}
}
break;
}
}
}
for( int i=0; i<m_SelectedBundles2.size(); i++ )
{
mitk::DataNode::Pointer fibNode = m_SelectedBundles2.at(i);
mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(fibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it = sources->begin(); it != sources->end(); ++it )
{
mitk::DataNode::Pointer imgNode = *it;
if ( imgNode.IsNotNull() && dynamic_cast<mitk::Image*>(imgNode->GetData()) )
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(fibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(imgNode->GetData());
mitk::Geometry3D::Pointer geom = img->GetGeometry();
itk::Index<3> idx;
geom->WorldToIndex(wc0, idx);
mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
mitk::Point3D world;
geom->IndexToWorld(cIdx,world);
mitk::Vector3D trans = world - wc0;
pe->GetGeometry()->Translate(trans);
}
}
break;
}
}
}
for( int i=0; i<m_SelectedImages.size(); i++ )
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
{
mitk::DataNode::Pointer fibNode = *it;
if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
mitk::Geometry3D::Pointer geom = img->GetGeometry();
itk::Index<3> idx;
geom->WorldToIndex(wc0, idx);
mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
mitk::Point3D world;
geom->IndexToWorld(cIdx,world);
mitk::Vector3D trans = world - wc0;
pe->GetGeometry()->Translate(trans);
}
}
}
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnFlipButton()
{
if (m_SelectedFiducial.IsNull())
return;
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
if( it != m_DataNodeToPlanarFigureData.end() )
{
QmitkPlanarFigureData& data = it->second;
data.m_Flipped += 1;
data.m_Flipped %= 2;
}
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
{
NPoints *= 2;
GradientListType pointshell;
int numB0 = NPoints/20;
if (numB0==0)
numB0=1;
GradientType g;
g.Fill(0.0);
for (int i=0; i<numB0; i++)
pointshell.push_back(g);
if (NPoints==0)
return pointshell;
vnl_vector<double> theta; theta.set_size(NPoints);
vnl_vector<double> phi; phi.set_size(NPoints);
double C = sqrt(4*M_PI);
phi(0) = 0.0;
phi(NPoints-1) = 0.0;
for(int i=0; i<NPoints; i++)
{
theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
if( i>0 && i<NPoints-1)
{
phi(i) = (phi(i-1) + C /
sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
// % (2*DIST_POINTSHELL_PI);
}
}
for(int i=0; i<NPoints; i++)
{
g[2] = sin(theta(i));
if (g[2]<0)
continue;
g[0] = cos(theta(i)) * cos(phi(i));
g[1] = cos(theta(i)) * sin(phi(i));
pointshell.push_back(g);
}
return pointshell;
}
template<int ndirs>
std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
{
std::vector<itk::Vector<double,3> > retval;
vnl_matrix_fixed<double, 3, ndirs>* U =
itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
// Add 0 vector for B0
int numB0 = ndirs/10;
if (numB0==0)
numB0=1;
itk::Vector<double,3> v;
v.Fill(0.0);
for (int i=0; i<numB0; i++)
{
retval.push_back(v);
}
for(int i=0; i<ndirs;i++)
{
itk::Vector<double,3> v;
v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
retval.push_back(v);
}
return retval;
}
void QmitkFiberfoxView::OnAddBundle()
{
if (m_SelectedImage.IsNull())
return;
mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
mitk::FiberBundleX::Pointer bundle = mitk::FiberBundleX::New();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( bundle );
QString name = QString("Bundle_%1").arg(children->size());
node->SetName(name.toStdString());
m_SelectedBundles.push_back(node);
UpdateGui();
GetDataStorage()->Add(node, m_SelectedImage);
}
void QmitkFiberfoxView::OnDrawROI()
{
if (m_SelectedBundles.empty())
OnAddBundle();
if (m_SelectedBundles.empty())
return;
mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( figure );
QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
for( int i=0; i<nodes.size(); i++)
nodes.at(i)->SetSelected(false);
m_SelectedFiducial = node;
QString name = QString("Fiducial_%1").arg(children->size());
node->SetName(name.toStdString());
node->SetSelected(true);
GetDataStorage()->Add(node, m_SelectedBundles.at(0));
this->DisableCrosshairNavigation();
mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
UpdateGui();
}
bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
{
int li = -1;
i->GetPropertyValue("layer", li);
int lj = -1;
j->GetPropertyValue("layer", lj);
return li<lj;
}
void QmitkFiberfoxView::GenerateFibers()
{
if (m_SelectedBundles.empty())
{
if (m_SelectedFiducial.IsNull())
return;
mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
if(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()))
m_SelectedBundles.push_back(*it);
if (m_SelectedBundles.empty())
return;
}
vector< vector< mitk::PlanarEllipse::Pointer > > fiducials;
vector< vector< unsigned int > > fliplist;
for (int i=0; i<m_SelectedBundles.size(); i++)
{
mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(i));
std::vector< mitk::DataNode::Pointer > childVector;
for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
childVector.push_back(*it);
sort(childVector.begin(), childVector.end(), CompareLayer);
vector< mitk::PlanarEllipse::Pointer > fib;
vector< unsigned int > flip;
float radius = 1;
int count = 0;
for( std::vector< mitk::DataNode::Pointer >::const_iterator it = childVector.begin(); it != childVector.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
{
mitk::PlanarEllipse* ellipse = dynamic_cast<mitk::PlanarEllipse*>(node->GetData());
if (m_Controls->m_ConstantRadiusBox->isChecked())
{
ellipse->SetTreatAsCircle(true);
mitk::Point2D c = ellipse->GetControlPoint(0);
mitk::Point2D p = ellipse->GetControlPoint(1);
mitk::Vector2D v = p-c;
if (count==0)
{
radius = v.GetVnlVector().magnitude();
ellipse->SetControlPoint(1, p);
}
else
{
v.Normalize();
v *= radius;
ellipse->SetControlPoint(1, c+v);
}
}
fib.push_back(ellipse);
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(node.GetPointer());
if( it != m_DataNodeToPlanarFigureData.end() )
{
QmitkPlanarFigureData& data = it->second;
flip.push_back(data.m_Flipped);
}
else
flip.push_back(0);
}
count++;
}
if (fib.size()>1)
{
fiducials.push_back(fib);
fliplist.push_back(flip);
}
else if (fib.size()>0)
m_SelectedBundles.at(i)->SetData( mitk::FiberBundleX::New() );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
filter->SetFiducials(fiducials);
filter->SetFlipList(fliplist);
switch(m_Controls->m_DistributionBox->currentIndex()){
case 0:
filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_UNIFORM);
break;
case 1:
filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_GAUSSIAN);
filter->SetVariance(m_Controls->m_VarianceBox->value());
break;
}
filter->SetDensity(m_Controls->m_FiberDensityBox->value());
filter->SetTension(m_Controls->m_TensionBox->value());
filter->SetContinuity(m_Controls->m_ContinuityBox->value());
filter->SetBias(m_Controls->m_BiasBox->value());
filter->SetFiberSampling(m_Controls->m_FiberSamplingBox->value());
filter->Update();
vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
for (int i=0; i<fiberBundles.size(); i++)
{
m_SelectedBundles.at(i)->SetData( fiberBundles.at(i) );
if (fiberBundles.at(i)->GetNumFibers()>50000)
m_SelectedBundles.at(i)->SetVisibility(false);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberfoxView::GenerateImage()
{
itk::ImageRegion<3> imageRegion;
imageRegion.SetSize(0, m_Controls->m_SizeX->value());
imageRegion.SetSize(1, m_Controls->m_SizeY->value());
imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
mitk::Vector3D spacing;
spacing[0] = m_Controls->m_SpacingX->value();
spacing[1] = m_Controls->m_SpacingY->value();
spacing[2] = m_Controls->m_SpacingZ->value();
mitk::Point3D origin;
origin[0] = spacing[0]/2;
origin[1] = spacing[1]/2;
origin[2] = spacing[2]/2;
itk::Matrix<double, 3, 3> directionMatrix; directionMatrix.SetIdentity();
- if (m_SelectedBundles.empty())
- {
- mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
- m_Controls->m_SizeX->value(),
- m_Controls->m_SizeY->value(),
- m_Controls->m_SizeZ->value(),
- m_Controls->m_SpacingX->value(),
- m_Controls->m_SpacingY->value(),
- m_Controls->m_SpacingZ->value());
-
- mitk::Geometry3D* geom = image->GetGeometry();
- geom->SetOrigin(origin);
-
- mitk::DataNode::Pointer node = mitk::DataNode::New();
- node->SetData( image );
- node->SetName("Dummy");
- unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
- unsigned int level = window/2;
- mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
- node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
- GetDataStorage()->Add(node);
- m_SelectedImage = node;
-
- mitk::BaseData::Pointer basedata = node->GetData();
- if (basedata.IsNotNull())
- {
- mitk::RenderingManager::GetInstance()->InitializeViews(
- basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- UpdateGui();
-
- return;
- }
-
if (m_SelectedImage.IsNotNull())
{
mitk::Image* img = dynamic_cast<mitk::Image*>(m_SelectedImage->GetData());
itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
imageRegion = itkImg->GetLargestPossibleRegion();
spacing = itkImg->GetSpacing();
origin = itkImg->GetOrigin();
directionMatrix = itkImg->GetDirection();
}
DiffusionSignalModel<double>::GradientListType gradientList;
double bVal = 1000;
if (m_SelectedDWI.IsNull())
{
gradientList = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());;
bVal = m_Controls->m_BvalueBox->value();
}
else
{
mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedDWI->GetData());
imageRegion = dwi->GetVectorImage()->GetLargestPossibleRegion();
spacing = dwi->GetVectorImage()->GetSpacing();
origin = dwi->GetVectorImage()->GetOrigin();
directionMatrix = dwi->GetVectorImage()->GetDirection();
bVal = dwi->GetB_Value();
mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer dirs = dwi->GetDirections();
for (int i=0; i<dirs->Size(); i++)
{
DiffusionSignalModel<double>::GradientType g;
g[0] = dirs->at(i)[0];
g[1] = dirs->at(i)[1];
g[2] = dirs->at(i)[2];
gradientList.push_back(g);
}
}
+ if (m_SelectedBundles.empty())
+ {
+ if (m_SelectedDWI.IsNotNull()) // add artifacts to existing diffusion weighted image
+ {
+ for (int i=0; i<m_SelectedImages.size(); i++)
+ {
+
+ QString artifactModelString("");
+ mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
+
+ if (!dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedImages.at(i)->GetData()))
+ continue;
+ mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedImages.at(i)->GetData());
+
+ double noiseVariance = 0;
+ if (m_Controls->m_AddNoise->isChecked())
+ {
+ noiseVariance = m_Controls->m_NoiseLevel->value();
+ artifactModelString += "_NOISE";
+ artifactModelString += QString::number(noiseVariance);
+ }
+ mitk::RicianNoiseModel<short> noiseModel;
+ noiseModel.SetNoiseVariance(noiseVariance);
+
+ if ( this->m_Controls->m_TEbox->value() < imageRegion.GetSize(1)*m_Controls->m_LineReadoutTimeBox->value() )
+ {
+ this->m_Controls->m_TEbox->setValue( imageRegion.GetSize(1)*m_Controls->m_LineReadoutTimeBox->value() );
+ QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(this->m_Controls->m_TEbox->value())+" ms");
+ }
+ double lineReadoutTime = m_Controls->m_LineReadoutTimeBox->value();
+
+ // add N/2 ghosting
+ double kOffset = 0;
+ if (m_Controls->m_AddGhosts->isChecked())
+ {
+ artifactModelString += "_GHOST";
+ kOffset = m_Controls->m_kOffsetBox->value();
+ }
+
+
+ if ( this->m_Controls->m_TEbox->value() < imageRegion.GetSize(1)*m_Controls->m_LineReadoutTimeBox->value() )
+ {
+ this->m_Controls->m_TEbox->setValue( imageRegion.GetSize(1)*m_Controls->m_LineReadoutTimeBox->value() );
+ QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(this->m_Controls->m_TEbox->value())+" ms");
+ }
+
+ itk::AddArtifactsToDwiImageFilter< short >::Pointer filter = itk::AddArtifactsToDwiImageFilter< short >::New();
+ filter->SetInput(diffImg->GetVectorImage());
+ filter->SettLine(lineReadoutTime);
+ filter->SetkOffset(kOffset);
+ filter->SetNoiseModel(&noiseModel);
+ filter->SetGradientList(gradientList);
+ filter->SetTE(this->m_Controls->m_TEbox->value());
+
+ if (m_Controls->m_AddEddy->isChecked())
+ {
+ filter->SetSimulateEddyCurrents(true);
+ filter->SetEddyGradientStrength(m_Controls->m_EddyGradientStrength->value());
+ artifactModelString += "_EDDY";
+ }
+
+ if (m_Controls->m_AddGibbsRinging->isChecked())
+ {
+ resultNode->AddProperty("Fiberfox.kRinging-Upsampling", DoubleProperty::New(m_Controls->m_ImageUpsamplingBox->value()));
+ filter->SetUpsampling(m_Controls->m_ImageUpsamplingBox->value());
+ }
+
+ if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
+ {
+ mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
+ mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
+ ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
+ CastToItkImage< ItkDoubleImgType >(img, itkImg);
+
+ if (imageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
+ imageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
+ imageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
+ {
+ filter->SetFrequencyMap(itkImg);
+ artifactModelString += "_DISTORTED";
+ }
+ }
+
+ filter->Update();
+
+ resultNode->AddProperty("Fiberfox.Line-Offset", DoubleProperty::New(kOffset));
+ resultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
+ resultNode->AddProperty("Fiberfox.Tinhom", IntProperty::New(m_Controls->m_T2starBox->value()));
+ resultNode->AddProperty("binary", BoolProperty::New(false));
+
+ mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
+ image->SetVectorImage( filter->GetOutput() );
+ image->SetB_Value(diffImg->GetB_Value());
+ image->SetDirections(diffImg->GetDirections());
+ image->InitializeFromVectorImage();
+ resultNode->SetData( image );
+ resultNode->SetName(m_SelectedImages.at(i)->GetName()+artifactModelString.toStdString());
+ GetDataStorage()->Add(resultNode);
+ }
+ return;
+ }
+ mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
+ m_Controls->m_SizeX->value(),
+ m_Controls->m_SizeY->value(),
+ m_Controls->m_SizeZ->value(),
+ m_Controls->m_SpacingX->value(),
+ m_Controls->m_SpacingY->value(),
+ m_Controls->m_SpacingZ->value());
+
+ mitk::Geometry3D* geom = image->GetGeometry();
+ geom->SetOrigin(origin);
+
+ mitk::DataNode::Pointer node = mitk::DataNode::New();
+ node->SetData( image );
+ node->SetName("Dummy");
+ unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
+ unsigned int level = window/2;
+ mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
+ node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
+ GetDataStorage()->Add(node);
+ m_SelectedImage = node;
+
+ mitk::BaseData::Pointer basedata = node->GetData();
+ if (basedata.IsNotNull())
+ {
+ mitk::RenderingManager::GetInstance()->InitializeViews(
+ basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ }
+ UpdateGui();
+
+ return;
+ }
for (int i=0; i<m_SelectedBundles.size(); i++)
{
+ itk::TractsToDWIImageFilter::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter::New();
+
// storage for generated phantom image
mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
QString signalModelString("");
itk::TractsToDWIImageFilter::DiffusionModelList fiberModelList, nonFiberModelList;
// signal models
double comp3Weight = 1;
double comp4Weight = 0;
if (m_Controls->m_Compartment4Box->currentIndex()>0)
{
comp4Weight = m_Controls->m_Comp4FractionBox->value();
comp3Weight -= comp4Weight;
}
mitk::StickModel<double> stickModel1;
mitk::StickModel<double> stickModel2;
mitk::TensorModel<double> zeppelinModel1;
mitk::TensorModel<double> zeppelinModel2;
mitk::TensorModel<double> tensorModel1;
mitk::TensorModel<double> tensorModel2;
mitk::BallModel<double> ballModel1;
mitk::BallModel<double> ballModel2;
mitk::AstroStickModel<double> astrosticksModel1;
mitk::AstroStickModel<double> astrosticksModel2;
mitk::DotModel<double> dotModel1;
mitk::DotModel<double> dotModel2;
// compartment 1
switch (m_Controls->m_Compartment1Box->currentIndex())
{
case 0:
MITK_INFO << "Using stick model";
stickModel1.SetGradientList(gradientList);
stickModel1.SetDiffusivity(m_Controls->m_StickWidget1->GetD());
stickModel1.SetT2(m_Controls->m_StickWidget1->GetT2());
fiberModelList.push_back(&stickModel1);
signalModelString += "Stick";
resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
resultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(stickModel1.GetT2()) );
break;
case 1:
MITK_INFO << "Using zeppelin model";
zeppelinModel1.SetGradientList(gradientList);
zeppelinModel1.SetBvalue(bVal);
zeppelinModel1.SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
zeppelinModel1.SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
zeppelinModel1.SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
zeppelinModel1.SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
fiberModelList.push_back(&zeppelinModel1);
signalModelString += "Zeppelin";
resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(zeppelinModel1.GetT2()) );
break;
case 2:
MITK_INFO << "Using tensor model";
tensorModel1.SetGradientList(gradientList);
tensorModel1.SetBvalue(bVal);
tensorModel1.SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
tensorModel1.SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
tensorModel1.SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
tensorModel1.SetT2(m_Controls->m_TensorWidget1->GetT2());
fiberModelList.push_back(&tensorModel1);
signalModelString += "Tensor";
resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
resultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(zeppelinModel1.GetT2()) );
break;
}
// compartment 2
switch (m_Controls->m_Compartment2Box->currentIndex())
{
case 0:
break;
case 1:
stickModel2.SetGradientList(gradientList);
stickModel2.SetDiffusivity(m_Controls->m_StickWidget2->GetD());
stickModel2.SetT2(m_Controls->m_StickWidget2->GetT2());
fiberModelList.push_back(&stickModel2);
signalModelString += "Stick";
resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
resultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(stickModel2.GetT2()) );
break;
case 2:
zeppelinModel2.SetGradientList(gradientList);
zeppelinModel2.SetBvalue(bVal);
zeppelinModel2.SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
zeppelinModel2.SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
zeppelinModel2.SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
zeppelinModel2.SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
fiberModelList.push_back(&zeppelinModel2);
signalModelString += "Zeppelin";
resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(zeppelinModel2.GetT2()) );
break;
case 3:
tensorModel2.SetGradientList(gradientList);
tensorModel2.SetBvalue(bVal);
tensorModel2.SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
tensorModel2.SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
tensorModel2.SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
tensorModel2.SetT2(m_Controls->m_TensorWidget2->GetT2());
fiberModelList.push_back(&tensorModel2);
signalModelString += "Tensor";
resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
resultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(zeppelinModel2.GetT2()) );
break;
}
// compartment 3
switch (m_Controls->m_Compartment3Box->currentIndex())
{
case 0:
ballModel1.SetGradientList(gradientList);
ballModel1.SetBvalue(bVal);
ballModel1.SetDiffusivity(m_Controls->m_BallWidget1->GetD());
ballModel1.SetT2(m_Controls->m_BallWidget1->GetT2());
ballModel1.SetWeight(comp3Weight);
nonFiberModelList.push_back(&ballModel1);
signalModelString += "Ball";
resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(ballModel1.GetT2()) );
break;
case 1:
astrosticksModel1.SetGradientList(gradientList);
astrosticksModel1.SetBvalue(bVal);
astrosticksModel1.SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
astrosticksModel1.SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
astrosticksModel1.SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
astrosticksModel1.SetWeight(comp3Weight);
nonFiberModelList.push_back(&astrosticksModel1);
signalModelString += "Astrosticks";
resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(astrosticksModel1.GetT2()) );
resultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
break;
case 2:
dotModel1.SetGradientList(gradientList);
dotModel1.SetT2(m_Controls->m_DotWidget1->GetT2());
dotModel1.SetWeight(comp3Weight);
nonFiberModelList.push_back(&dotModel1);
signalModelString += "Dot";
resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(dotModel1.GetT2()) );
break;
}
// compartment 4
switch (m_Controls->m_Compartment4Box->currentIndex())
{
case 0:
break;
case 1:
ballModel2.SetGradientList(gradientList);
ballModel2.SetBvalue(bVal);
ballModel2.SetDiffusivity(m_Controls->m_BallWidget2->GetD());
ballModel2.SetT2(m_Controls->m_BallWidget2->GetT2());
ballModel2.SetWeight(comp4Weight);
nonFiberModelList.push_back(&ballModel2);
signalModelString += "Ball";
resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(ballModel2.GetT2()) );
break;
case 2:
astrosticksModel2.SetGradientList(gradientList);
astrosticksModel2.SetBvalue(bVal);
astrosticksModel2.SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
astrosticksModel2.SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
astrosticksModel2.SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
astrosticksModel2.SetWeight(comp4Weight);
nonFiberModelList.push_back(&astrosticksModel2);
signalModelString += "Astrosticks";
resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(astrosticksModel2.GetT2()) );
resultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
break;
case 3:
dotModel2.SetGradientList(gradientList);
dotModel2.SetT2(m_Controls->m_DotWidget2->GetT2());
dotModel2.SetWeight(comp4Weight);
nonFiberModelList.push_back(&dotModel2);
signalModelString += "Dot";
resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(dotModel2.GetT2()) );
break;
}
itk::TractsToDWIImageFilter::KspaceArtifactList artifactList;
- // noise model
- double noiseVariance = m_Controls->m_NoiseLevel->value();
+ // artifact models
+ QString artifactModelString("");
+ double noiseVariance = 0;
+ if (m_Controls->m_AddNoise->isChecked())
+ {
+ noiseVariance = m_Controls->m_NoiseLevel->value();
+ artifactModelString += "_NOISE";
+ artifactModelString += QString::number(noiseVariance);
+ resultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
+ }
mitk::RicianNoiseModel<double> noiseModel;
noiseModel.SetNoiseVariance(noiseVariance);
- // artifact models
- QString artifactModelString("");
- mitk::GibbsRingingArtifact<double> gibbsModel;
if (m_Controls->m_AddGibbsRinging->isChecked())
{
- artifactModelString += "_Gibbs-ringing";
- resultNode->AddProperty("Fiberfox.k-Space-Undersampling", IntProperty::New(m_Controls->m_KspaceUndersamplingBox->currentText().toInt()));
- gibbsModel.SetKspaceCropping((double)m_Controls->m_KspaceUndersamplingBox->currentText().toInt());
- artifactList.push_back(&gibbsModel);
+ artifactModelString += "_RINGING";
+ resultNode->AddProperty("Fiberfox.Ringing-Upsampling", DoubleProperty::New(m_Controls->m_ImageUpsamplingBox->value()));
+ tractsToDwiFilter->SetUpsampling(m_Controls->m_ImageUpsamplingBox->value());
}
if ( this->m_Controls->m_TEbox->value() < imageRegion.GetSize(1)*m_Controls->m_LineReadoutTimeBox->value() )
{
this->m_Controls->m_TEbox->setValue( imageRegion.GetSize(1)*m_Controls->m_LineReadoutTimeBox->value() );
QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(this->m_Controls->m_TEbox->value())+" ms");
}
double lineReadoutTime = m_Controls->m_LineReadoutTimeBox->value();
- // adjusting line readout time to the adapted image size needed for the FFT
- int y=2;
- while (y<imageRegion.GetSize(1))
- y *= 2;
- if (y>imageRegion.GetSize(1))
+ // adjusting line readout time to the adapted image size needed for the DFT
+ int y = imageRegion.GetSize(1);
+ if ( y%2 == 1 )
+ y += 1;
+ if ( y>imageRegion.GetSize(1) )
lineReadoutTime *= (double)imageRegion.GetSize(1)/y;
- mitk::SignalDecay<double> contrastModel;
- contrastModel.SetTinhom(this->m_Controls->m_T2starBox->value());
- contrastModel.SetTE(this->m_Controls->m_TEbox->value());
- contrastModel.SetTline(lineReadoutTime);
- artifactList.push_back(&contrastModel);
+ // add N/2 ghosting
+ double kOffset = 0;
+ if (m_Controls->m_AddGhosts->isChecked())
+ {
+ artifactModelString += "_GHOST";
+ kOffset = m_Controls->m_kOffsetBox->value();
+ resultNode->AddProperty("Fiberfox.Line-Offset", DoubleProperty::New(kOffset));
+ }
+
+ // add distortions
+ if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
+ {
+ mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
+ mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
+ ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
+ CastToItkImage< ItkDoubleImgType >(img, itkImg);
+
+ if (imageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
+ imageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
+ imageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
+ {
+ tractsToDwiFilter->SetFrequencyMap(itkImg);
+ artifactModelString += "_DISTORTED";
+ }
+ }
+
+ if (m_Controls->m_AddEddy->isChecked())
+ {
+ tractsToDwiFilter->SetSimulateEddyCurrents(true);
+ tractsToDwiFilter->SetEddyGradientStrength(m_Controls->m_EddyGradientStrength->value());
+ artifactModelString += "_EDDY";
+ }
mitk::FiberBundleX::Pointer fiberBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedBundles.at(i)->GetData());
if (fiberBundle->GetNumFibers()<=0)
continue;
- itk::TractsToDWIImageFilter::Pointer filter = itk::TractsToDWIImageFilter::New();
- filter->SetImageRegion(imageRegion);
- filter->SetSpacing(spacing);
- filter->SetOrigin(origin);
- filter->SetDirectionMatrix(directionMatrix);
- filter->SetFiberBundle(fiberBundle);
- filter->SetFiberModels(fiberModelList);
- filter->SetNonFiberModels(nonFiberModelList);
- filter->SetNoiseModel(&noiseModel);
- filter->SetKspaceArtifacts(artifactList);
- filter->SetNumberOfRepetitions(m_Controls->m_RepetitionsBox->value());
- filter->SetEnforcePureFiberVoxels(m_Controls->m_EnforcePureFiberVoxelsBox->isChecked());
- filter->SetInterpolationShrink(m_Controls->m_InterpolationShrink->value());
- filter->SetFiberRadius(m_Controls->m_FiberRadius->value());
- filter->SetSignalScale(m_Controls->m_SignalScaleBox->value());
+ if (m_Controls->m_RelaxationBox->isChecked())
+ artifactModelString += "_RELAX";
+
+ tractsToDwiFilter->SetSimulateRelaxation(m_Controls->m_RelaxationBox->isChecked());
+ tractsToDwiFilter->SetImageRegion(imageRegion);
+ tractsToDwiFilter->SetSpacing(spacing);
+ tractsToDwiFilter->SetOrigin(origin);
+ tractsToDwiFilter->SetDirectionMatrix(directionMatrix);
+ tractsToDwiFilter->SetFiberBundle(fiberBundle);
+ tractsToDwiFilter->SetFiberModels(fiberModelList);
+ tractsToDwiFilter->SetNonFiberModels(nonFiberModelList);
+ tractsToDwiFilter->SetNoiseModel(&noiseModel);
+ tractsToDwiFilter->SetKspaceArtifacts(artifactList);
+ tractsToDwiFilter->SetkOffset(kOffset);
+ tractsToDwiFilter->SettLine(m_Controls->m_LineReadoutTimeBox->value());
+ tractsToDwiFilter->SettInhom(this->m_Controls->m_T2starBox->value());
+ tractsToDwiFilter->SetTE(this->m_Controls->m_TEbox->value());
+ tractsToDwiFilter->SetNumberOfRepetitions(m_Controls->m_RepetitionsBox->value());
+ tractsToDwiFilter->SetEnforcePureFiberVoxels(m_Controls->m_EnforcePureFiberVoxelsBox->isChecked());
+ tractsToDwiFilter->SetInterpolationShrink(m_Controls->m_InterpolationShrink->value());
+ tractsToDwiFilter->SetFiberRadius(m_Controls->m_FiberRadius->value());
+ tractsToDwiFilter->SetSignalScale(m_Controls->m_SignalScaleBox->value());
+ if (m_Controls->m_InterpolationShrink->value()<1000)
+ tractsToDwiFilter->SetUseInterpolation(true);
if (m_TissueMask.IsNotNull())
{
ItkUcharImgType::Pointer mask = ItkUcharImgType::New();
mitk::CastToItkImage<ItkUcharImgType>(m_TissueMask, mask);
- filter->SetTissueMask(mask);
+ tractsToDwiFilter->SetTissueMask(mask);
}
- filter->Update();
+ tractsToDwiFilter->Update();
mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
- image->SetVectorImage( filter->GetOutput() );
+ image->SetVectorImage( tractsToDwiFilter->GetOutput() );
image->SetB_Value(bVal);
image->SetDirections(gradientList);
image->InitializeFromVectorImage();
resultNode->SetData( image );
resultNode->SetName(m_SelectedBundles.at(i)->GetName()
+"_D"+QString::number(imageRegion.GetSize(0)).toStdString()
+"-"+QString::number(imageRegion.GetSize(1)).toStdString()
+"-"+QString::number(imageRegion.GetSize(2)).toStdString()
+"_S"+QString::number(spacing[0]).toStdString()
+"-"+QString::number(spacing[1]).toStdString()
+"-"+QString::number(spacing[2]).toStdString()
+"_b"+QString::number(bVal).toStdString()
- +"_NOISE"+QString::number(noiseVariance).toStdString()
+"_"+signalModelString.toStdString()
+artifactModelString.toStdString());
GetDataStorage()->Add(resultNode, m_SelectedBundles.at(i));
resultNode->AddProperty("Fiberfox.InterpolationShrink", IntProperty::New(m_Controls->m_InterpolationShrink->value()));
resultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(m_Controls->m_SignalScaleBox->value()));
resultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(m_Controls->m_FiberRadius->value()));
resultNode->AddProperty("Fiberfox.Tinhom", IntProperty::New(m_Controls->m_T2starBox->value()));
- resultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
resultNode->AddProperty("Fiberfox.Repetitions", IntProperty::New(m_Controls->m_RepetitionsBox->value()));
resultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(bVal));
resultNode->AddProperty("Fiberfox.Model", StringProperty::New(signalModelString.toStdString()));
resultNode->AddProperty("Fiberfox.PureFiberVoxels", BoolProperty::New(m_Controls->m_EnforcePureFiberVoxelsBox->isChecked()));
resultNode->AddProperty("binary", BoolProperty::New(false));
- resultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(filter->GetLevelWindow()) );
+ resultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(tractsToDwiFilter->GetLevelWindow()) );
- if (m_Controls->m_KspaceImageBox->isChecked())
+ if (m_Controls->m_VolumeFractionsBox->isChecked())
{
- itk::Image<double, 3>::Pointer kspace = filter->GetKspaceImage();
- mitk::Image::Pointer image = mitk::Image::New();
- image->InitializeByItk(kspace.GetPointer());
- image->SetVolume(kspace->GetBufferPointer());
-
- mitk::DataNode::Pointer node = mitk::DataNode::New();
- node->SetData( image );
- node->SetName(m_SelectedBundles.at(i)->GetName()+"_k-space");
- GetDataStorage()->Add(node, m_SelectedBundles.at(i));
+ std::vector< itk::TractsToDWIImageFilter::ItkDoubleImgType::Pointer > volumeFractions = tractsToDwiFilter->GetVolumeFractions();
+ for (int k=0; k<volumeFractions.size(); k++)
+ {
+ mitk::Image::Pointer image = mitk::Image::New();
+ image->InitializeByItk(volumeFractions.at(k).GetPointer());
+ image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
+
+ mitk::DataNode::Pointer node = mitk::DataNode::New();
+ node->SetData( image );
+ node->SetName(m_SelectedBundles.at(i)->GetName()+"_CompartmentVolume-"+QString::number(k).toStdString());
+ GetDataStorage()->Add(node, m_SelectedBundles.at(i));
+ }
}
mitk::BaseData::Pointer basedata = resultNode->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void QmitkFiberfoxView::ApplyTransform()
{
vector< mitk::DataNode::Pointer > selectedBundles;
for( int i=0; i<m_SelectedImages.size(); i++ )
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
{
mitk::DataNode::Pointer fibNode = *it;
if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
selectedBundles.push_back(fibNode);
}
}
if (selectedBundles.empty())
selectedBundles = m_SelectedBundles2;
if (!selectedBundles.empty())
{
std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin();
for (it; it!=selectedBundles.end(); ++it)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
// handle child fiducials
if (m_Controls->m_IncludeFiducials->isChecked())
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
mitk::Geometry3D* geom = pe->GetGeometry();
// translate
mitk::Vector3D world;
world[0] = m_Controls->m_XtransBox->value();
world[1] = m_Controls->m_YtransBox->value();
world[2] = m_Controls->m_ZtransBox->value();
geom->Translate(world);
// calculate rotation matrix
double x = m_Controls->m_XrotBox->value()*M_PI/180;
double y = m_Controls->m_YrotBox->value()*M_PI/180;
double z = m_Controls->m_ZrotBox->value()*M_PI/180;
itk::Matrix< float, 3, 3 > rotX; rotX.SetIdentity();
rotX[1][1] = cos(x);
rotX[2][2] = rotX[1][1];
rotX[1][2] = -sin(x);
rotX[2][1] = -rotX[1][2];
itk::Matrix< float, 3, 3 > rotY; rotY.SetIdentity();
rotY[0][0] = cos(y);
rotY[2][2] = rotY[0][0];
rotY[0][2] = sin(y);
rotY[2][0] = -rotY[0][2];
itk::Matrix< float, 3, 3 > rotZ; rotZ.SetIdentity();
rotZ[0][0] = cos(z);
rotZ[1][1] = rotZ[0][0];
rotZ[0][1] = -sin(z);
rotZ[1][0] = -rotZ[0][1];
itk::Matrix< float, 3, 3 > rot = rotZ*rotY*rotX;
// transform control point coordinate into geometry translation
geom->SetOrigin(pe->GetWorldControlPoint(0));
mitk::Point2D cp; cp.Fill(0.0);
pe->SetControlPoint(0, cp);
// rotate fiducial
geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
// implicit translation
mitk::Vector3D trans;
trans[0] = geom->GetOrigin()[0]-fib->GetGeometry()->GetCenter()[0];
trans[1] = geom->GetOrigin()[1]-fib->GetGeometry()->GetCenter()[1];
trans[2] = geom->GetOrigin()[2]-fib->GetGeometry()->GetCenter()[2];
mitk::Vector3D newWc = rot*trans;
newWc = newWc-trans;
geom->Translate(newWc);
}
}
}
}
}
else
{
for (int i=0; i<m_SelectedFiducials.size(); i++)
{
mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
mitk::Geometry3D* geom = pe->GetGeometry();
// translate
mitk::Vector3D world;
world[0] = m_Controls->m_XtransBox->value();
world[1] = m_Controls->m_YtransBox->value();
world[2] = m_Controls->m_ZtransBox->value();
geom->Translate(world);
// calculate rotation matrix
double x = m_Controls->m_XrotBox->value()*M_PI/180;
double y = m_Controls->m_YrotBox->value()*M_PI/180;
double z = m_Controls->m_ZrotBox->value()*M_PI/180;
itk::Matrix< float, 3, 3 > rotX; rotX.SetIdentity();
rotX[1][1] = cos(x);
rotX[2][2] = rotX[1][1];
rotX[1][2] = -sin(x);
rotX[2][1] = -rotX[1][2];
itk::Matrix< float, 3, 3 > rotY; rotY.SetIdentity();
rotY[0][0] = cos(y);
rotY[2][2] = rotY[0][0];
rotY[0][2] = sin(y);
rotY[2][0] = -rotY[0][2];
itk::Matrix< float, 3, 3 > rotZ; rotZ.SetIdentity();
rotZ[0][0] = cos(z);
rotZ[1][1] = rotZ[0][0];
rotZ[0][1] = -sin(z);
rotZ[1][0] = -rotZ[0][1];
itk::Matrix< float, 3, 3 > rot = rotZ*rotY*rotX;
// transform control point coordinate into geometry translation
geom->SetOrigin(pe->GetWorldControlPoint(0));
mitk::Point2D cp; cp.Fill(0.0);
pe->SetControlPoint(0, cp);
// rotate fiducial
geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
}
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberfoxView::CopyBundles()
{
if ( m_SelectedBundles.size()<1 ){
QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
MITK_WARN("QmitkFiberProcessingView") << "Select at least one fiber bundle!";
return;
}
std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
for (it; it!=m_SelectedBundles.end(); ++it)
{
// find parent image
mitk::DataNode::Pointer parentNode;
mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
{
mitk::DataNode::Pointer pImgNode = *it2;
if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
{
parentNode = pImgNode;
break;
}
}
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
mitk::FiberBundleX::Pointer newBundle = fib->GetDeepCopy();
QString name((*it)->GetName().c_str());
name += "_copy";
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
if (parentNode.IsNotNull())
GetDataStorage()->Add(fbNode, parentNode);
else
GetDataStorage()->Add(fbNode);
// copy child fiducials
if (m_Controls->m_IncludeFiducials->isChecked())
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse::Pointer pe = mitk::PlanarEllipse::New();
pe->DeepCopy(dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()));
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetData(pe);
newNode->SetName(fiducialNode->GetName());
GetDataStorage()->Add(newNode, fbNode);
}
}
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberfoxView::JoinBundles()
{
if ( m_SelectedBundles.size()<2 ){
QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
return;
}
std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
QString name("");
name += QString((*it)->GetName().c_str());
++it;
for (it; it!=m_SelectedBundles.end(); ++it)
{
newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()));
name += "+"+QString((*it)->GetName().c_str());
}
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
GetDataStorage()->Add(fbNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberfoxView::UpdateGui()
{
m_Controls->m_FiberBundleLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_GeometryFrame->setEnabled(true);
m_Controls->m_GeometryMessage->setVisible(false);
m_Controls->m_DiffusionPropsMessage->setVisible(false);
m_Controls->m_FiberGenMessage->setVisible(true);
m_Controls->m_TransformBundlesButton->setEnabled(false);
m_Controls->m_CopyBundlesButton->setEnabled(false);
m_Controls->m_GenerateFibersButton->setEnabled(false);
m_Controls->m_FlipButton->setEnabled(false);
m_Controls->m_CircleButton->setEnabled(false);
m_Controls->m_BvalueBox->setEnabled(true);
m_Controls->m_NumGradientsBox->setEnabled(true);
m_Controls->m_JoinBundlesButton->setEnabled(false);
m_Controls->m_AlignOnGrid->setEnabled(false);
if (m_SelectedFiducial.IsNotNull())
{
m_Controls->m_TransformBundlesButton->setEnabled(true);
m_Controls->m_FlipButton->setEnabled(true);
m_Controls->m_AlignOnGrid->setEnabled(true);
}
if (m_SelectedImage.IsNotNull() || !m_SelectedBundles.empty())
{
m_Controls->m_TransformBundlesButton->setEnabled(true);
m_Controls->m_CircleButton->setEnabled(true);
m_Controls->m_FiberGenMessage->setVisible(false);
m_Controls->m_AlignOnGrid->setEnabled(true);
}
if (m_TissueMask.IsNotNull() || m_SelectedImage.IsNotNull())
{
m_Controls->m_GeometryMessage->setVisible(true);
m_Controls->m_GeometryFrame->setEnabled(false);
}
if (m_SelectedDWI.IsNotNull())
{
m_Controls->m_DiffusionPropsMessage->setVisible(true);
m_Controls->m_BvalueBox->setEnabled(false);
m_Controls->m_NumGradientsBox->setEnabled(false);
m_Controls->m_GeometryMessage->setVisible(true);
m_Controls->m_GeometryFrame->setEnabled(false);
}
if (!m_SelectedBundles.empty())
{
m_Controls->m_CopyBundlesButton->setEnabled(true);
m_Controls->m_GenerateFibersButton->setEnabled(true);
m_Controls->m_FiberBundleLabel->setText(m_SelectedBundles.at(0)->GetName().c_str());
if (m_SelectedBundles.size()>1)
m_Controls->m_JoinBundlesButton->setEnabled(true);
}
}
void QmitkFiberfoxView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
{
m_SelectedBundles2.clear();
m_SelectedImages.clear();
m_SelectedFiducials.clear();
m_SelectedFiducial = NULL;
m_TissueMask = NULL;
m_SelectedBundles.clear();
m_SelectedImage = NULL;
m_SelectedDWI = NULL;
m_Controls->m_TissueMaskLabel->setText("<font color='grey'>optional</font>");
// iterate all selected objects, adjust warning visibility
for( int i=0; i<nodes.size(); i++)
{
mitk::DataNode::Pointer node = nodes.at(i);
if ( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
{
m_SelectedDWI = node;
m_SelectedImage = node;
m_SelectedImages.push_back(node);
}
else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
m_SelectedImages.push_back(node);
m_SelectedImage = node;
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
{
m_TissueMask = dynamic_cast<mitk::Image*>(node->GetData());
m_Controls->m_TissueMaskLabel->setText(node->GetName().c_str());
}
}
else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
{
m_SelectedBundles2.push_back(node);
if (m_Controls->m_RealTimeFibers->isChecked())
{
m_SelectedBundles.push_back(node);
mitk::FiberBundleX::Pointer newFib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
GenerateFibers();
}
else
m_SelectedBundles.push_back(node);
}
else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
{
m_SelectedFiducials.push_back(node);
m_SelectedFiducial = node;
m_SelectedBundles.clear();
mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
{
mitk::DataNode::Pointer pNode = *it;
if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pNode->GetData()) )
m_SelectedBundles.push_back(pNode);
}
}
}
UpdateGui();
}
void QmitkFiberfoxView::EnableCrosshairNavigation()
{
MITK_DEBUG << "EnableCrosshairNavigation";
// enable the crosshair navigation
if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
{
MITK_DEBUG << "enabling linked navigation";
linkedRenderWindow->EnableLinkedNavigation(true);
// linkedRenderWindow->EnableSlicingPlanes(true);
}
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::DisableCrosshairNavigation()
{
MITK_DEBUG << "DisableCrosshairNavigation";
// disable the crosshair navigation during the drawing
if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
{
MITK_DEBUG << "disabling linked navigation";
linkedRenderWindow->EnableLinkedNavigation(false);
// linkedRenderWindow->EnableSlicingPlanes(false);
}
}
void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
{
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
if( it != m_DataNodeToPlanarFigureData.end() )
{
QmitkPlanarFigureData& data = it->second;
// remove observers
data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
m_DataNodeToPlanarFigureData.erase( it );
}
}
void QmitkFiberfoxView::NodeAdded( const mitk::DataNode* node )
{
// add observer for selection in renderwindow
mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
bool isPositionMarker (false);
node->GetBoolProperty("isContourMarker", isPositionMarker);
if( figure && !isPositionMarker )
{
MITK_DEBUG << "figure added. will add interactor if needed.";
mitk::PlanarFigureInteractor::Pointer figureInteractor
= dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", nonConstNode);
}
else
{
// just to be sure that the interactor is not added twice
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
}
MITK_DEBUG << "adding interactor to globalinteraction";
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
MITK_DEBUG << "will now add observers for planarfigure";
QmitkPlanarFigureData data;
data.m_Figure = figure;
// // add observer for event when figure has been placed
typedef itk::SimpleMemberCommand< QmitkFiberfoxView > SimpleCommandType;
// SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
// initializationCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureInitialized );
// data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
// add observer for event when figure is picked (selected)
typedef itk::MemberCommand< QmitkFiberfoxView > MemberCommandType;
MemberCommandType::Pointer selectCommand = MemberCommandType::New();
selectCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureSelected );
data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
// add observer for event when interaction with figure starts
SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
startInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::DisableCrosshairNavigation);
data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
// add observer for event when interaction with figure starts
SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
endInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::EnableCrosshairNavigation);
data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
m_DataNodeToPlanarFigureData[nonConstNode] = data;
}
}
void QmitkFiberfoxView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
{
mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPf = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
mitk::DataStorage::SetOfObjects::ConstPointer allPfs = this->GetDataStorage()->GetSubset( isPf );
for ( mitk::DataStorage::SetOfObjects::const_iterator it = allPfs->begin(); it!=allPfs->end(); ++it)
{
mitk::DataNode* node = *it;
if( node->GetData() == object )
{
node->SetSelected(true);
m_SelectedFiducial = node;
}
else
node->SetSelected(false);
}
UpdateGui();
this->RequestRenderWindowUpdate();
}
void QmitkFiberfoxView::SetFocus()
{
m_Controls->m_CircleButton->setFocus();
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
old mode 100644
new mode 100755
index 472cec2de2..159f196062
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
@@ -1,137 +1,142 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <berryISelectionListener.h>
#include <berryIStructuredSelection.h>
#include <QmitkAbstractView.h>
#include "ui_QmitkFiberfoxViewControls.h"
#include <itkVectorImage.h>
#include <itkVectorContainer.h>
#include <itkOrientationDistributionFunction.h>
#include <mitkFiberBundleX.h>
#include <mitkPlanarEllipse.h>
/*!
\brief View for fiber based diffusion software phantoms (Fiberfox).
\sa QmitkFunctionality
\ingroup Functionalities
*/
// Forward Qt class declarations
using namespace std;
class QmitkFiberfoxView : public QmitkAbstractView
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const string VIEW_ID;
QmitkFiberfoxView();
virtual ~QmitkFiberfoxView();
virtual void CreateQtPartControl(QWidget *parent);
void SetFocus();
+ typedef itk::Image<double, 3> ItkDoubleImgType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Vector<double,3> GradientType;
typedef vector<GradientType> GradientListType;
template<int ndirs> vector<itk::Vector<double,3> > MakeGradientList() ;
protected slots:
void OnDrawROI(); ///< adds new ROI, handles interactors etc.
void OnAddBundle(); ///< adds new fiber bundle to datastorage
void OnFlipButton(); ///< negate one coordinate of the fiber waypoints in the selcted planar figure. needed in case of unresolvable twists
void GenerateFibers(); ///< generate fibers from the selected ROIs
void GenerateImage(); ///< generate artificial image from the selected fiber bundle
void JoinBundles(); ///< merges selcted fiber bundles into one
void CopyBundles(); ///< add copy of the selected bundle to the datamanager
void ApplyTransform(); ///< rotate and shift selected bundles
void AlignOnGrid(); ///< shift selected fiducials to nearest voxel center
void Comp1ModelFrameVisibility(int index);///< only show parameters of selected fiber model type
void Comp2ModelFrameVisibility(int index);///< only show parameters of selected non-fiber model type
void Comp3ModelFrameVisibility(int index);///< only show parameters of selected non-fiber model type
void Comp4ModelFrameVisibility(int index);///< only show parameters of selected non-fiber model type
void ShowAdvancedOptions(int state);
/** update fibers if any parameter changes */
void OnFiberDensityChanged(int value);
void OnFiberSamplingChanged(int value);
void OnTensionChanged(double value);
void OnContinuityChanged(double value);
void OnBiasChanged(double value);
void OnVarianceChanged(double value);
void OnDistributionChanged(int value);
void OnAddGibbsRinging(int value);
+ void OnAddNoise(int value);
+ void OnAddGhosts(int value);
+ void OnAddDistortions(int value);
+ void OnAddEddy(int value);
void OnConstantRadius(int value);
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>&);
GradientListType GenerateHalfShell(int NPoints); ///< generate vectors distributed over the halfsphere
Ui::QmitkFiberfoxViewControls* m_Controls;
void UpdateGui(); ///< enable/disbale buttons etc. according to current datamanager selection
void PlanarFigureSelected( itk::Object* object, const itk::EventObject& );
void EnableCrosshairNavigation(); ///< enable crosshair navigation if planar figure interaction ends
void DisableCrosshairNavigation(); ///< disable crosshair navigation if planar figure interaction starts
void NodeAdded( const mitk::DataNode* node ); ///< add observers
void NodeRemoved(const mitk::DataNode* node); ///< remove observers
/** structure to keep track of planar figures and observers */
struct QmitkPlanarFigureData
{
QmitkPlanarFigureData()
: m_Figure(0)
, m_EndPlacementObserverTag(0)
, m_SelectObserverTag(0)
, m_StartInteractionObserverTag(0)
, m_EndInteractionObserverTag(0)
, m_Flipped(0)
{
}
mitk::PlanarFigure* m_Figure;
unsigned int m_EndPlacementObserverTag;
unsigned int m_SelectObserverTag;
unsigned int m_StartInteractionObserverTag;
unsigned int m_EndInteractionObserverTag;
unsigned int m_Flipped;
};
std::map<mitk::DataNode*, QmitkPlanarFigureData> m_DataNodeToPlanarFigureData; ///< map each planar figure uniquely to a QmitkPlanarFigureData
mitk::Image::Pointer m_TissueMask; ///< mask defining which regions of the image should contain signal and which are containing only noise
mitk::DataNode::Pointer m_SelectedFiducial; ///< selected planar ellipse
mitk::DataNode::Pointer m_SelectedImage;
mitk::DataNode::Pointer m_SelectedDWI;
vector< mitk::DataNode::Pointer > m_SelectedBundles;
vector< mitk::DataNode::Pointer > m_SelectedBundles2;
vector< mitk::DataNode::Pointer > m_SelectedFiducials;
vector< mitk::DataNode::Pointer > m_SelectedImages;
};
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui
old mode 100644
new mode 100755
index f45819d6b4..63972bd20f
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui
@@ -1,2020 +1,2204 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkFiberfoxViewControls</class>
<widget class="QWidget" name="QmitkFiberfoxViewControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>493</width>
- <height>1438</height>
+ <height>1565</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout_2">
<item row="0" column="0">
<widget class="QTabWidget" name="tabWidget">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="tab">
<attribute name="title">
<string>Fiber Definition</string>
</attribute>
<layout class="QGridLayout" name="gridLayout_8">
<item row="7" column="0">
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QLabel" name="m_FiberGenMessage">
<property name="styleSheet">
<string notr="true">color: rgb(255, 0, 0);</string>
</property>
<property name="text">
<string>Please select an image or an existing fiber bundle to draw the fiber fiducials. If you can't provide a suitable image, generate one using the &quot;Signal Generation&quot; tab.</string>
</property>
<property name="textFormat">
<enum>Qt::AutoText</enum>
</property>
<property name="alignment">
<set>Qt::AlignJustify|Qt::AlignVCenter</set>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
</widget>
</item>
<item row="5" column="0">
<widget class="QGroupBox" name="groupBox_7">
<property name="title">
<string>Fiducial Options</string>
</property>
<layout class="QGridLayout" name="gridLayout_16">
<item row="0" column="0">
<widget class="QCheckBox" name="m_ConstantRadiusBox">
<property name="toolTip">
<string>All fiducials are treated as circles with the same radius as the first fiducial. </string>
</property>
<property name="text">
<string>Use Constant Fiducial Radius</string>
</property>
<property name="checked">
<bool>false</bool>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QCommandLinkButton" name="m_AlignOnGrid">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>Align selected fiducials with voxel grid. Shifts selected fiducials to nearest voxel center.</string>
</property>
<property name="text">
<string>Align With Grid</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="6" column="0" colspan="2">
<widget class="QGroupBox" name="groupBox_4">
<property name="title">
<string>Operations</string>
</property>
<layout class="QGridLayout" name="gridLayout_11">
<item row="4" column="0">
<widget class="QCommandLinkButton" name="m_CopyBundlesButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Copy Bundles</string>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QCommandLinkButton" name="m_TransformBundlesButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Transform Selection</string>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QFrame" name="frame_4">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_12">
<property name="margin">
<number>0</number>
</property>
<item row="1" column="2">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_18">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Y</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QDoubleSpinBox" name="m_XrotBox">
<property name="toolTip">
<string>Rotation angle (in degree) around x-axis.</string>
</property>
<property name="minimum">
<double>-360.000000000000000</double>
</property>
<property name="maximum">
<double>360.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_22">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Axis:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="2">
<widget class="QDoubleSpinBox" name="m_YrotBox">
<property name="toolTip">
<string>Rotation angle (in degree) around y-axis.</string>
</property>
<property name="minimum">
<double>-360.000000000000000</double>
</property>
<property name="maximum">
<double>360.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_21">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Translation:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="3" column="3">
<widget class="QDoubleSpinBox" name="m_ZtransBox">
<property name="toolTip">
<string>Translation (in mm) in direction of the z-axis.</string>
</property>
<property name="minimum">
<double>-1000.000000000000000</double>
</property>
<property name="maximum">
<double>1000.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
</widget>
</item>
<item row="3" column="2">
<widget class="QDoubleSpinBox" name="m_YtransBox">
<property name="toolTip">
<string>Translation (in mm) in direction of the y-axis.</string>
</property>
<property name="minimum">
<double>-1000.000000000000000</double>
</property>
<property name="maximum">
<double>1000.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_17">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>X</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_20">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Rotation:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="1" column="3">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_19">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Z</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="3">
<widget class="QDoubleSpinBox" name="m_ZrotBox">
<property name="toolTip">
<string>Rotation angle (in degree) around z-axis.</string>
</property>
<property name="minimum">
<double>-360.000000000000000</double>
</property>
<property name="maximum">
<double>360.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
</widget>
</item>
<item row="3" column="1">
<widget class="QDoubleSpinBox" name="m_XtransBox">
<property name="toolTip">
<string>Translation (in mm) in direction of the x-axis.</string>
</property>
<property name="minimum">
<double>-1000.000000000000000</double>
</property>
<property name="maximum">
<double>1000.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_24">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Scaling:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="4" column="1">
<widget class="QDoubleSpinBox" name="m_XscaleBox">
<property name="toolTip">
<string>Scaling factor for selected fiber bundle along the x-axis.</string>
</property>
<property name="minimum">
<double>0.010000000000000</double>
</property>
<property name="maximum">
<double>10.000000000000000</double>
</property>
<property name="singleStep">
<double>0.010000000000000</double>
</property>
<property name="value">
<double>1.000000000000000</double>
</property>
</widget>
</item>
<item row="4" column="2">
<widget class="QDoubleSpinBox" name="m_YscaleBox">
<property name="toolTip">
<string>Scaling factor for selected fiber bundle along the y-axis.</string>
</property>
<property name="minimum">
<double>0.010000000000000</double>
</property>
<property name="maximum">
<double>10.000000000000000</double>
</property>
<property name="singleStep">
<double>0.010000000000000</double>
</property>
<property name="value">
<double>1.000000000000000</double>
</property>
</widget>
</item>
<item row="4" column="3">
<widget class="QDoubleSpinBox" name="m_ZscaleBox">
<property name="toolTip">
<string>Scaling factor for selected fiber bundle along the z-axis.</string>
</property>
<property name="minimum">
<double>0.010000000000000</double>
</property>
<property name="maximum">
<double>10.000000000000000</double>
</property>
<property name="singleStep">
<double>0.010000000000000</double>
</property>
<property name="value">
<double>1.000000000000000</double>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="5" column="0">
<widget class="QCommandLinkButton" name="m_JoinBundlesButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Join Bundles</string>
</property>
</widget>
</item>
<item row="6" column="0">
<widget class="QCheckBox" name="m_IncludeFiducials">
<property name="toolTip">
<string>If checked, the fiducials belonging to the modified bundle are also modified.</string>
</property>
<property name="text">
<string>Include Fiducials</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="4" column="0">
<widget class="QGroupBox" name="groupBox_8">
<property name="title">
<string>Fiber Options</string>
</property>
<layout class="QGridLayout" name="gridLayout_15">
<item row="2" column="0">
<widget class="QFrame" name="frame_5">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_9">
<property name="margin">
<number>0</number>
</property>
<item row="2" column="0">
<widget class="QFrame" name="m_AdvancedFiberOptionsFrame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_21">
<property name="margin">
<number>0</number>
</property>
<item row="1" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_5">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Tension:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_8">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Fiber Sampling:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QDoubleSpinBox" name="m_TensionBox">
<property name="toolTip">
<string/>
</property>
<property name="decimals">
<number>3</number>
</property>
<property name="minimum">
<double>-1.000000000000000</double>
</property>
<property name="maximum">
<double>1.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>0.000000000000000</double>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSpinBox" name="m_FiberSamplingBox">
<property name="toolTip">
<string>Fiber sampling points (per cm)</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>100</number>
</property>
<property name="singleStep">
<number>1</number>
</property>
<property name="value">
<number>10</number>
</property>
</widget>
</item>
<item row="3" column="1">
<widget class="QDoubleSpinBox" name="m_BiasBox">
<property name="decimals">
<number>3</number>
</property>
<property name="minimum">
<double>-1.000000000000000</double>
</property>
<property name="maximum">
<double>1.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>0.000000000000000</double>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_7">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Bias:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_6">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Continuity:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QDoubleSpinBox" name="m_ContinuityBox">
<property name="decimals">
<number>3</number>
</property>
<property name="minimum">
<double>-1.000000000000000</double>
</property>
<property name="maximum">
<double>1.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>0.000000000000000</double>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="0">
<widget class="QFrame" name="frame_2">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_25">
<property name="margin">
<number>0</number>
</property>
<property name="verticalSpacing">
<number>6</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_4">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>#Fibers:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSpinBox" name="m_FiberDensityBox">
<property name="toolTip">
<string>Specify number of fibers to generate for the selected bundle.</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>1000000</number>
</property>
<property name="singleStep">
<number>100</number>
</property>
<property name="value">
<number>100</number>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
<item row="3" column="0">
<widget class="QCommandLinkButton" name="m_GenerateFibersButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Generate Fibers</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QFrame" name="frame_3">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_5">
<property name="margin">
<number>0</number>
</property>
<item row="0" column="1">
<widget class="QComboBox" name="m_DistributionBox">
<property name="toolTip">
<string>Select fiber distribution inside of the fiducials.</string>
</property>
<item>
<property name="text">
<string>Uniform</string>
</property>
</item>
<item>
<property name="text">
<string>Gaussian</string>
</property>
</item>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_9">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Fiber Distribution:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QDoubleSpinBox" name="m_VarianceBox">
<property name="toolTip">
<string>Variance of the gaussian</string>
</property>
<property name="decimals">
<number>3</number>
</property>
<property name="minimum">
<double>0.001000000000000</double>
</property>
<property name="maximum">
<double>10.000000000000000</double>
</property>
<property name="singleStep">
<double>0.010000000000000</double>
</property>
<property name="value">
<double>0.100000000000000</double>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="0" column="0">
<widget class="QFrame" name="frame_8">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_22">
<property name="margin">
<number>0</number>
</property>
<item row="0" column="0">
<widget class="QCheckBox" name="m_RealTimeFibers">
<property name="toolTip">
<string>Disable to only generate fibers if &quot;Generate Fibers&quot; button is pressed.</string>
</property>
<property name="text">
<string>Real Time Fibers</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QCheckBox" name="m_AdvancedOptionsBox">
<property name="toolTip">
<string>Disable to only generate fibers if &quot;Generate Fibers&quot; button is pressed.</string>
</property>
<property name="text">
<string>Advanced Options</string>
</property>
<property name="checked">
<bool>false</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
<item row="3" column="0">
<widget class="QFrame" name="frame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_3">
<property name="margin">
<number>0</number>
</property>
<item row="0" column="0">
<widget class="QPushButton" name="m_CircleButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="maximumSize">
<size>
<width>30</width>
<height>30</height>
</size>
</property>
<property name="toolTip">
<string>Draw elliptical fiducial.</string>
</property>
<property name="text">
<string/>
</property>
<property name="icon">
<iconset resource="../../resources/QmitkDiffusionImaging.qrc">
<normaloff>:/QmitkDiffusionImaging/circle.png</normaloff>:/QmitkDiffusionImaging/circle.png</iconset>
</property>
<property name="iconSize">
<size>
<width>32</width>
<height>32</height>
</size>
</property>
<property name="checkable">
<bool>false</bool>
</property>
<property name="flat">
<bool>true</bool>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QPushButton" name="m_FlipButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="maximumSize">
<size>
<width>30</width>
<height>30</height>
</size>
</property>
<property name="toolTip">
<string>Flip fiber waypoints of selcted fiducial around one axis.</string>
</property>
<property name="text">
<string/>
</property>
<property name="icon">
<iconset resource="../../resources/QmitkDiffusionImaging.qrc">
<normaloff>:/QmitkDiffusionImaging/refresh.xpm</normaloff>:/QmitkDiffusionImaging/refresh.xpm</iconset>
</property>
<property name="iconSize">
<size>
<width>32</width>
<height>32</height>
</size>
</property>
<property name="checkable">
<bool>false</bool>
</property>
<property name="flat">
<bool>true</bool>
</property>
</widget>
</item>
<item row="0" column="2">
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_2">
<attribute name="title">
<string>Signal Generation</string>
</attribute>
<layout class="QGridLayout" name="gridLayout_4">
<item row="5" column="0">
<widget class="QGroupBox" name="m_IntraAxonalGroupBox">
<property name="title">
<string>Intra-axonal Compartment</string>
</property>
<layout class="QGridLayout" name="gridLayout_13">
<item row="0" column="0">
<widget class="QComboBox" name="m_Compartment1Box">
<property name="toolTip">
<string>Select signal model for intra-axonal compartment.</string>
</property>
<item>
<property name="text">
<string>Stick Model</string>
</property>
</item>
<item>
<property name="text">
<string>Zeppelin Model</string>
</property>
</item>
<item>
<property name="text">
<string>Tensor Model</string>
</property>
</item>
</widget>
</item>
<item row="1" column="0">
<widget class="QmitkStickModelParametersWidget" name="m_StickWidget1" native="true"/>
</item>
<item row="2" column="0">
<widget class="QmitkZeppelinModelParametersWidget" name="m_ZeppelinWidget1" native="true"/>
</item>
<item row="3" column="0">
<widget class="QmitkTensorModelParametersWidget" name="m_TensorWidget1" native="true"/>
</item>
</layout>
</widget>
</item>
<item row="0" column="0">
<widget class="QGroupBox" name="groupBox_2">
<property name="title">
<string>Data</string>
</property>
<layout class="QGridLayout" name="gridLayout_10">
<item row="0" column="0" rowspan="2" colspan="2">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_16">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Fiber Bundle:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="0" column="2" rowspan="2">
<widget class="QLabel" name="m_FiberBundleLabel">
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;mandatory&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
</widget>
</item>
<item row="3" column="0" colspan="2">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_3">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>Tissue Mask:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="3" column="2">
<widget class="QLabel" name="m_TissueMaskLabel">
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#969696;&quot;&gt;optional&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="7" column="0">
<widget class="QGroupBox" name="groupBox_6">
<property name="title">
<string>Extra-axonal Compartments</string>
</property>
<layout class="QGridLayout" name="gridLayout_14">
<item row="6" column="0">
<widget class="QComboBox" name="m_Compartment3Box">
<property name="toolTip">
<string>Select signal model for extra-axonal compartment.</string>
</property>
<item>
<property name="text">
<string>Ball Model</string>
</property>
</item>
<item>
<property name="text">
<string>Astrosticks Model</string>
</property>
</item>
<item>
<property name="text">
<string>Dot Model</string>
</property>
</item>
</widget>
</item>
<item row="8" column="0">
<widget class="QmitkAstrosticksModelParametersWidget" name="m_AstrosticksWidget1" native="true"/>
</item>
<item row="14" column="0">
<widget class="QmitkAstrosticksModelParametersWidget" name="m_AstrosticksWidget2" native="true"/>
</item>
<item row="13" column="0">
<widget class="QmitkBallModelParametersWidget" name="m_BallWidget2" native="true"/>
</item>
<item row="7" column="0">
<widget class="QmitkBallModelParametersWidget" name="m_BallWidget1" native="true"/>
</item>
<item row="12" column="0">
<widget class="QComboBox" name="m_Compartment4Box">
<property name="toolTip">
<string>Select signal model for extra-axonal compartment.</string>
</property>
<item>
<property name="text">
<string>--</string>
</property>
</item>
<item>
<property name="text">
<string>Ball Model</string>
</property>
</item>
<item>
<property name="text">
<string>Astrosticks Model</string>
</property>
</item>
<item>
<property name="text">
<string>Dot Model</string>
</property>
</item>
</widget>
</item>
<item row="11" column="0">
<widget class="Line" name="line_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item row="15" column="0">
<widget class="QmitkDotModelParametersWidget" name="m_DotWidget2" native="true"/>
</item>
<item row="16" column="0">
<widget class="QFrame" name="m_Comp4FractionFrame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_18">
<property name="margin">
<number>0</number>
</property>
<item row="0" column="1">
<widget class="QDoubleSpinBox" name="m_Comp4FractionBox">
<property name="toolTip">
<string>Weighting factor between the two extra-axonal compartments.</string>
</property>
<property name="maximum">
<double>1.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>0.300000000000000</double>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="m_NoiseLabel_3">
<property name="text">
<string>Compartment Fraction:</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="9" column="0">
<widget class="QmitkDotModelParametersWidget" name="m_DotWidget1" native="true"/>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<widget class="QCommandLinkButton" name="m_GenerateImageButton">
<property name="enabled">
<bool>true</bool>
</property>
<property name="toolTip">
<string>Start DWI generation from selected fiebr bundle. If no fiber bundle is selected, a grayscale image containing a simple gradient is generated.</string>
</property>
<property name="text">
<string>Generate Image</string>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QGroupBox" name="groupBox">
<property name="title">
<string>Image Settings</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="7" column="0">
<widget class="QFrame" name="m_AdvancedSignalOptionsFrame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_23">
<property name="margin">
<number>0</number>
</property>
<property name="horizontalSpacing">
<number>6</number>
</property>
- <item row="4" column="0">
- <widget class="QLabel" name="m_TensorsToDWIBValueLabel_12">
+ <item row="7" column="0">
+ <widget class="QCheckBox" name="m_RelaxationBox">
<property name="toolTip">
- <string/>
- </property>
- <property name="statusTip">
- <string/>
- </property>
- <property name="whatsThis">
- <string/>
- </property>
- <property name="text">
- <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:sub;&quot;&gt;inhom&lt;/span&gt; Relaxation: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+ <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;TE&lt;/span&gt;, &lt;span style=&quot; font-style:italic;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:sub;&quot;&gt;inhom&lt;/span&gt; and &lt;span style=&quot; font-style:italic;&quot;&gt;T2&lt;/span&gt; will have no effect if unchecked.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
- <property name="wordWrap">
- <bool>false</bool>
- </property>
- </widget>
- </item>
- <item row="8" column="0">
- <widget class="QCheckBox" name="m_KspaceImageBox">
<property name="text">
- <string>Output k-Space Image</string>
+ <string>Simulate Signal Relaxation</string>
</property>
<property name="checked">
- <bool>false</bool>
+ <bool>true</bool>
</property>
</widget>
</item>
- <item row="6" column="1">
- <widget class="QSpinBox" name="m_InterpolationShrink">
- <property name="toolTip">
- <string>Large values shrink (towards nearest neighbour interpolation), small values strech interpolation function (towards linear interpolation).</string>
- </property>
- <property name="minimum">
- <number>1</number>
- </property>
- <property name="maximum">
- <number>10000</number>
- </property>
- <property name="value">
- <number>10</number>
+ <item row="0" column="0">
+ <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_2">
+ <property name="text">
+ <string>Repetitions:</string>
</property>
</widget>
</item>
<item row="3" column="1">
<widget class="QDoubleSpinBox" name="m_LineReadoutTimeBox">
<property name="toolTip">
<string>T2* relaxation time (in milliseconds).</string>
</property>
<property name="maximum">
<double>100.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>1.000000000000000</double>
</property>
</widget>
</item>
- <item row="7" column="0">
- <widget class="QCheckBox" name="m_EnforcePureFiberVoxelsBox">
+ <item row="5" column="0">
+ <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_4">
+ <property name="text">
+ <string>Fiber Radius:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="5" column="1">
+ <widget class="QSpinBox" name="m_FiberRadius">
<property name="toolTip">
- <string>Treat voxel content as fiber-only if at least one fiber is present.</string>
+ <string>Fiber radius used to calculate volume fractions (in µm). Set to 0 for automatic radius estimation.</string>
</property>
- <property name="text">
- <string>Enforce Pure Fiber Voxels</string>
+ <property name="minimum">
+ <number>0</number>
</property>
- <property name="checked">
- <bool>false</bool>
+ <property name="maximum">
+ <number>1000</number>
+ </property>
+ <property name="value">
+ <number>0</number>
</property>
</widget>
</item>
- <item row="2" column="1">
- <widget class="QSpinBox" name="m_TEbox">
+ <item row="1" column="1">
+ <widget class="QSpinBox" name="m_SignalScaleBox">
<property name="toolTip">
<string>TE in milliseconds</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>10000</number>
</property>
<property name="singleStep">
<number>1</number>
</property>
<property name="value">
<number>100</number>
</property>
</widget>
</item>
- <item row="5" column="0">
- <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_4">
- <property name="text">
- <string>Fiber Radius:</string>
- </property>
- </widget>
- </item>
<item row="6" column="0">
<widget class="QLabel" name="m_TensorsToDWINumDirsLabel_3">
<property name="text">
<string>Interpolation Shrink:</string>
</property>
</widget>
</item>
- <item row="0" column="0">
- <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_2">
+ <item row="3" column="0">
+ <widget class="QLabel" name="m_TensorsToDWIBValueLabel_15">
+ <property name="toolTip">
+ <string/>
+ </property>
+ <property name="statusTip">
+ <string/>
+ </property>
+ <property name="whatsThis">
+ <string/>
+ </property>
<property name="text">
- <string>Repetitions:</string>
+ <string>Line Readout Time: </string>
+ </property>
+ <property name="wordWrap">
+ <bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel_13">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Echo Time &lt;span style=&quot; font-style:italic;&quot;&gt;TE&lt;/span&gt;: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
- <item row="3" column="0">
- <widget class="QLabel" name="m_TensorsToDWIBValueLabel_15">
+ <item row="8" column="0">
+ <widget class="QCheckBox" name="m_EnforcePureFiberVoxelsBox">
+ <property name="toolTip">
+ <string>Disable partial volume. Treat voxel content as fiber-only if at least one fiber is present.</string>
+ </property>
+ <property name="text">
+ <string>Disable Partial Volume Effects</string>
+ </property>
+ <property name="checked">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item row="9" column="0">
+ <widget class="QCheckBox" name="m_VolumeFractionsBox">
+ <property name="toolTip">
+ <string>Output one image per compartment containing the corresponding volume fractions per voxel.</string>
+ </property>
+ <property name="text">
+ <string>Output Volume Fractions</string>
+ </property>
+ <property name="checked">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item row="4" column="0">
+ <widget class="QLabel" name="m_TensorsToDWIBValueLabel_12">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
- <string>Line Readout Time: </string>
+ <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:sub;&quot;&gt;inhom&lt;/span&gt; Relaxation: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSpinBox" name="m_RepetitionsBox">
<property name="toolTip">
<string>Number of signal averages. Increase to reduce noise.</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>100</number>
</property>
<property name="singleStep">
<number>1</number>
</property>
<property name="value">
<number>1</number>
</property>
</widget>
</item>
<item row="4" column="1">
<widget class="QSpinBox" name="m_T2starBox">
<property name="toolTip">
<string>Relaxation time due to magnetic field inhomogeneities (T2', in milliseconds).</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>10000</number>
</property>
<property name="singleStep">
<number>1</number>
</property>
<property name="value">
<number>50</number>
</property>
</widget>
</item>
- <item row="5" column="1">
- <widget class="QSpinBox" name="m_FiberRadius">
+ <item row="2" column="1">
+ <widget class="QSpinBox" name="m_TEbox">
<property name="toolTip">
- <string>Fiber radius used to calculate volume fractions (in µm). Set to 0 for automatic radius estimation.</string>
+ <string>TE in milliseconds</string>
</property>
<property name="minimum">
- <number>0</number>
+ <number>1</number>
</property>
<property name="maximum">
- <number>1000</number>
+ <number>10000</number>
</property>
- <property name="value">
- <number>0</number>
+ <property name="singleStep">
+ <number>1</number>
</property>
- </widget>
- </item>
- <item row="1" column="0">
- <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_5">
- <property name="text">
- <string>Signal Scale:</string>
+ <property name="value">
+ <number>100</number>
</property>
</widget>
</item>
- <item row="1" column="1">
- <widget class="QSpinBox" name="m_SignalScaleBox">
+ <item row="6" column="1">
+ <widget class="QSpinBox" name="m_InterpolationShrink">
<property name="toolTip">
- <string>TE in milliseconds</string>
+ <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Large values shrink (towards nearest neighbour interpolation), small values strech interpolation function (towards linear interpolation). 1000 equals nearest neighbour interpolation.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
- <number>10000</number>
- </property>
- <property name="singleStep">
- <number>1</number>
+ <number>1000</number>
</property>
<property name="value">
- <number>125</number>
+ <number>1000</number>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="0">
+ <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_5">
+ <property name="text">
+ <string>Signal Scale:</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="m_GeometryMessage">
<property name="styleSheet">
<string notr="true">color: rgb(255, 0, 0);</string>
</property>
<property name="text">
<string>Using geometry of selected image!</string>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QLabel" name="m_DiffusionPropsMessage">
<property name="styleSheet">
<string notr="true">color: rgb(255, 0, 0);</string>
</property>
<property name="text">
<string>Using gradients of selected DWI!</string>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QFrame" name="m_GeometryFrame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_7">
<property name="margin">
<number>0</number>
</property>
<item row="2" column="2">
<widget class="QDoubleSpinBox" name="m_SpacingY">
<property name="decimals">
<number>3</number>
</property>
<property name="minimum">
<double>0.100000000000000</double>
</property>
<property name="maximum">
<double>50.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>2.000000000000000</double>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label_2">
<property name="text">
<string>Image Spacing:</string>
</property>
</widget>
</item>
<item row="2" column="3">
<widget class="QDoubleSpinBox" name="m_SpacingZ">
<property name="decimals">
<number>3</number>
</property>
<property name="minimum">
<double>0.100000000000000</double>
</property>
<property name="maximum">
<double>50.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>2.000000000000000</double>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QDoubleSpinBox" name="m_SpacingX">
<property name="decimals">
<number>3</number>
</property>
<property name="minimum">
<double>0.100000000000000</double>
</property>
<property name="maximum">
<double>50.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>2.000000000000000</double>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>Image Dimensions:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSpinBox" name="m_SizeX">
<property name="toolTip">
<string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>1000</number>
</property>
<property name="singleStep">
<number>1</number>
</property>
<property name="value">
<number>11</number>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QSpinBox" name="m_SizeY">
<property name="toolTip">
<string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>1000</number>
</property>
<property name="singleStep">
<number>1</number>
</property>
<property name="value">
<number>11</number>
</property>
</widget>
</item>
<item row="0" column="3">
<widget class="QSpinBox" name="m_SizeZ">
<property name="toolTip">
<string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>1000</number>
</property>
<property name="singleStep">
<number>1</number>
</property>
<property name="value">
<number>3</number>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="5" column="0">
<widget class="QFrame" name="m_TensorsToDWIFrame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_24">
<property name="margin">
<number>0</number>
</property>
<property name="spacing">
<number>6</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="m_TensorsToDWINumDirsLabel">
<property name="text">
<string>Gradient Directions:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSpinBox" name="m_NumGradientsBox">
<property name="toolTip">
<string>Number of gradient directions distributed over the half sphere.</string>
</property>
<property name="minimum">
<number>0</number>
</property>
<property name="maximum">
<number>10000</number>
</property>
<property name="singleStep">
<number>1</number>
</property>
<property name="value">
<number>30</number>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="m_TensorsToDWIBValueLabel">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
<string>b-Value:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QSpinBox" name="m_BvalueBox">
<property name="toolTip">
<string>b-value in mm/s²</string>
</property>
<property name="minimum">
<number>0</number>
</property>
<property name="maximum">
<number>10000</number>
</property>
<property name="singleStep">
<number>100</number>
</property>
<property name="value">
<number>1000</number>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="6" column="0">
<widget class="QCheckBox" name="m_AdvancedOptionsBox_2">
<property name="text">
<string>Advanced Options</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="10" column="0">
<spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item row="9" column="0">
<widget class="QGroupBox" name="groupBox_3">
<property name="title">
- <string>Noise and Artifacts</string>
+ <string>Noise and other Artifacts</string>
</property>
<layout class="QGridLayout" name="gridLayout_6">
+ <item row="3" column="0">
+ <widget class="QCheckBox" name="m_AddGhosts">
+ <property name="text">
+ <string>Add N/2 Ghosts</string>
+ </property>
+ <property name="checked">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
<item row="4" column="0">
- <widget class="QFrame" name="m_KspaceParamFrame">
+ <widget class="QFrame" name="m_GhostFrame">
<property name="enabled">
<bool>true</bool>
</property>
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
- <layout class="QFormLayout" name="formLayout_4">
+ <layout class="QFormLayout" name="formLayout_6">
<property name="horizontalSpacing">
<number>6</number>
</property>
<property name="margin">
<number>0</number>
</property>
<item row="0" column="0">
- <widget class="QLabel" name="m_TensorsToDWIBValueLabel_14">
+ <widget class="QLabel" name="m_TensorsToDWIBValueLabel_23">
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string/>
</property>
<property name="text">
- <string>k-Space Undersampling:</string>
+ <string>K-Space Line Offset:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="0" column="1">
- <widget class="QComboBox" name="m_KspaceUndersamplingBox">
+ <widget class="QDoubleSpinBox" name="m_kOffsetBox">
<property name="toolTip">
- <string>Image is upsampled using this factor, afterwards fourier transformed, cropped to the original size and then inverse fourier transformed.</string>
+ <string>A larger offset increases the inensity of the ghost image.</string>
</property>
- <property name="currentIndex">
- <number>0</number>
+ <property name="decimals">
+ <number>3</number>
+ </property>
+ <property name="maximum">
+ <double>1.000000000000000</double>
+ </property>
+ <property name="singleStep">
+ <double>0.010000000000000</double>
+ </property>
+ <property name="value">
+ <double>0.100000000000000</double>
</property>
- <item>
- <property name="text">
- <string>2</string>
- </property>
- </item>
- <item>
- <property name="text">
- <string>4</string>
- </property>
- </item>
- <item>
- <property name="text">
- <string>8</string>
- </property>
- </item>
- <item>
- <property name="text">
- <string>16</string>
- </property>
- </item>
- <item>
- <property name="text">
- <string>32</string>
- </property>
- </item>
- <item>
- <property name="text">
- <string>64</string>
- </property>
- </item>
- <item>
- <property name="text">
- <string>128</string>
- </property>
- </item>
- <item>
- <property name="text">
- <string>256</string>
- </property>
- </item>
</widget>
</item>
</layout>
</widget>
</item>
- <item row="2" column="0">
- <widget class="QFrame" name="m_T2bluringParamFrame">
+ <item row="1" column="0">
+ <widget class="QFrame" name="m_NoiseFrame">
+ <property name="frameShape">
+ <enum>QFrame::NoFrame</enum>
+ </property>
+ <property name="frameShadow">
+ <enum>QFrame::Raised</enum>
+ </property>
+ <layout class="QFormLayout" name="formLayout_5">
+ <property name="margin">
+ <number>0</number>
+ </property>
+ <item row="0" column="0">
+ <widget class="QLabel" name="m_NoiseLabel">
+ <property name="text">
+ <string>Variance:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="1">
+ <widget class="QDoubleSpinBox" name="m_NoiseLevel">
+ <property name="toolTip">
+ <string>Variance of Rician noise model.</string>
+ </property>
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ <property name="minimum">
+ <double>0.000000000000000</double>
+ </property>
+ <property name="maximum">
+ <double>100000.000000000000000</double>
+ </property>
+ <property name="singleStep">
+ <double>0.001000000000000</double>
+ </property>
+ <property name="value">
+ <double>25.000000000000000</double>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item row="9" column="0">
+ <widget class="QCheckBox" name="m_AddGibbsRinging">
+ <property name="toolTip">
+ <string>Add ringing artifacts occuring at strong edges in the image.</string>
+ </property>
+ <property name="text">
+ <string>Add Gibbs Ringing</string>
+ </property>
+ <property name="checked">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="0">
+ <widget class="QCheckBox" name="m_AddNoise">
+ <property name="text">
+ <string>Add Rician Noise</string>
+ </property>
+ <property name="checked">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item row="11" column="0">
+ <widget class="QFrame" name="m_GibbsRingingFrame">
<property name="enabled">
<bool>true</bool>
</property>
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
- <layout class="QFormLayout" name="formLayout">
- <property name="fieldGrowthPolicy">
- <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
- </property>
+ <layout class="QFormLayout" name="formLayout_4">
<property name="horizontalSpacing">
- <number>0</number>
- </property>
- <property name="verticalSpacing">
- <number>0</number>
+ <number>6</number>
</property>
<property name="margin">
<number>0</number>
</property>
+ <item row="0" column="0">
+ <widget class="QLabel" name="m_TensorsToDWIBValueLabel_14">
+ <property name="toolTip">
+ <string/>
+ </property>
+ <property name="statusTip">
+ <string/>
+ </property>
+ <property name="whatsThis">
+ <string/>
+ </property>
+ <property name="text">
+ <string>Upsampling:</string>
+ </property>
+ <property name="wordWrap">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="1">
+ <widget class="QDoubleSpinBox" name="m_ImageUpsamplingBox">
+ <property name="toolTip">
+ <string>Larger values increase the ringing range. Beware of performance issues!</string>
+ </property>
+ <property name="decimals">
+ <number>2</number>
+ </property>
+ <property name="minimum">
+ <double>1.000000000000000</double>
+ </property>
+ <property name="maximum">
+ <double>10.000000000000000</double>
+ </property>
+ <property name="singleStep">
+ <double>0.100000000000000</double>
+ </property>
+ <property name="value">
+ <double>2.000000000000000</double>
+ </property>
+ </widget>
+ </item>
</layout>
</widget>
</item>
- <item row="1" column="0">
- <widget class="QFrame" name="frame_7">
+ <item row="5" column="0">
+ <widget class="QCheckBox" name="m_AddDistortions">
+ <property name="text">
+ <string>Add Distortions</string>
+ </property>
+ <property name="checked">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item row="8" column="0">
+ <widget class="QFrame" name="m_EddyFrame">
+ <property name="enabled">
+ <bool>true</bool>
+ </property>
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
- <layout class="QFormLayout" name="formLayout_5">
+ <layout class="QFormLayout" name="formLayout_8">
+ <property name="fieldGrowthPolicy">
+ <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
+ </property>
+ <property name="horizontalSpacing">
+ <number>6</number>
+ </property>
<property name="margin">
<number>0</number>
</property>
<item row="0" column="0">
- <widget class="QLabel" name="m_NoiseLabel">
+ <widget class="QLabel" name="m_TensorsToDWIBValueLabel_26">
+ <property name="toolTip">
+ <string/>
+ </property>
+ <property name="statusTip">
+ <string/>
+ </property>
+ <property name="whatsThis">
+ <string/>
+ </property>
<property name="text">
- <string>Variance:</string>
+ <string>Gradient Strength:</string>
+ </property>
+ <property name="wordWrap">
+ <bool>false</bool>
</property>
</widget>
</item>
<item row="0" column="1">
- <widget class="QDoubleSpinBox" name="m_NoiseLevel">
+ <widget class="QDoubleSpinBox" name="m_EddyGradientStrength">
<property name="toolTip">
- <string>Variance of Rician noise model.</string>
+ <string>A larger offset increases the inensity of the ghost image.</string>
</property>
<property name="decimals">
- <number>4</number>
- </property>
- <property name="minimum">
- <double>0.000000000000000</double>
+ <number>5</number>
</property>
<property name="maximum">
- <double>100000.000000000000000</double>
+ <double>1000.000000000000000</double>
</property>
<property name="singleStep">
<double>0.001000000000000</double>
</property>
<property name="value">
- <double>25.000000000000000</double>
+ <double>0.001000000000000</double>
</property>
</widget>
</item>
</layout>
</widget>
</item>
- <item row="3" column="0">
- <widget class="QCheckBox" name="m_AddGibbsRinging">
+ <item row="6" column="0">
+ <widget class="QFrame" name="m_DistortionsFrame">
+ <property name="enabled">
+ <bool>true</bool>
+ </property>
+ <property name="frameShape">
+ <enum>QFrame::NoFrame</enum>
+ </property>
+ <property name="frameShadow">
+ <enum>QFrame::Raised</enum>
+ </property>
+ <layout class="QFormLayout" name="formLayout_7">
+ <property name="horizontalSpacing">
+ <number>6</number>
+ </property>
+ <property name="margin">
+ <number>0</number>
+ </property>
+ <item row="0" column="0">
+ <widget class="QLabel" name="m_TensorsToDWIBValueLabel_25">
+ <property name="toolTip">
+ <string/>
+ </property>
+ <property name="statusTip">
+ <string/>
+ </property>
+ <property name="whatsThis">
+ <string/>
+ </property>
+ <property name="text">
+ <string>Frequency Map:</string>
+ </property>
+ <property name="wordWrap">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="1">
+ <widget class="QmitkDataStorageComboBox" name="m_FrequencyMapBox">
+ <property name="toolTip">
+ <string>Select image specifying the frequency inhomogeneities (in Hz).</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item row="7" column="0">
+ <widget class="QCheckBox" name="m_AddEddy">
+ <property name="toolTip">
+ <string>!!!EXPERIMENTAL!!!</string>
+ </property>
<property name="text">
- <string>Add Gibbs Ringing</string>
+ <string>Add Eddy Current Effects</string>
</property>
<property name="checked">
<bool>false</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="6" column="0">
<widget class="QGroupBox" name="groupBox_5">
<property name="title">
<string>Inter-axonal Compartment</string>
</property>
<layout class="QGridLayout" name="gridLayout_17">
<item row="3" column="0">
<widget class="QmitkTensorModelParametersWidget" name="m_TensorWidget2" native="true"/>
</item>
<item row="1" column="0">
<widget class="QmitkZeppelinModelParametersWidget" name="m_ZeppelinWidget2" native="true"/>
</item>
<item row="0" column="0">
<widget class="QComboBox" name="m_Compartment2Box">
<property name="toolTip">
<string>Select signal model for intra-axonal compartment.</string>
</property>
<item>
<property name="text">
<string>--</string>
</property>
</item>
<item>
<property name="text">
<string>Stick Model</string>
</property>
</item>
<item>
<property name="text">
<string>Zeppelin Model</string>
</property>
</item>
<item>
<property name="text">
<string>Tensor Model</string>
</property>
</item>
</widget>
</item>
<item row="2" column="0">
<widget class="QmitkStickModelParametersWidget" name="m_StickWidget2" native="true"/>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<customwidgets>
+ <customwidget>
+ <class>QmitkDataStorageComboBox</class>
+ <extends>QComboBox</extends>
+ <header location="global">QmitkDataStorageComboBox.h</header>
+ </customwidget>
<customwidget>
<class>QmitkTensorModelParametersWidget</class>
<extends>QWidget</extends>
<header location="global">QmitkTensorModelParametersWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkStickModelParametersWidget</class>
<extends>QWidget</extends>
<header location="global">QmitkStickModelParametersWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkZeppelinModelParametersWidget</class>
<extends>QWidget</extends>
<header location="global">QmitkZeppelinModelParametersWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkBallModelParametersWidget</class>
<extends>QWidget</extends>
<header location="global">QmitkBallModelParametersWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkAstrosticksModelParametersWidget</class>
<extends>QWidget</extends>
<header location="global">QmitkAstrosticksModelParametersWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkDotModelParametersWidget</class>
<extends>QWidget</extends>
<header>QmitkDotModelParametersWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<tabstops>
- <tabstop>tabWidget</tabstop>
<tabstop>m_CircleButton</tabstop>
<tabstop>m_FlipButton</tabstop>
<tabstop>m_RealTimeFibers</tabstop>
- <tabstop>m_DistributionBox</tabstop>
<tabstop>m_AdvancedOptionsBox</tabstop>
+ <tabstop>m_DistributionBox</tabstop>
<tabstop>m_VarianceBox</tabstop>
<tabstop>m_FiberDensityBox</tabstop>
<tabstop>m_FiberSamplingBox</tabstop>
<tabstop>m_TensionBox</tabstop>
<tabstop>m_ContinuityBox</tabstop>
<tabstop>m_BiasBox</tabstop>
<tabstop>m_GenerateFibersButton</tabstop>
<tabstop>m_ConstantRadiusBox</tabstop>
<tabstop>m_AlignOnGrid</tabstop>
<tabstop>m_XrotBox</tabstop>
<tabstop>m_YrotBox</tabstop>
<tabstop>m_ZrotBox</tabstop>
<tabstop>m_XtransBox</tabstop>
<tabstop>m_YtransBox</tabstop>
<tabstop>m_ZtransBox</tabstop>
<tabstop>m_XscaleBox</tabstop>
<tabstop>m_YscaleBox</tabstop>
<tabstop>m_ZscaleBox</tabstop>
<tabstop>m_TransformBundlesButton</tabstop>
<tabstop>m_CopyBundlesButton</tabstop>
<tabstop>m_JoinBundlesButton</tabstop>
<tabstop>m_IncludeFiducials</tabstop>
<tabstop>m_GenerateImageButton</tabstop>
<tabstop>m_SizeX</tabstop>
<tabstop>m_SizeY</tabstop>
<tabstop>m_SizeZ</tabstop>
<tabstop>m_SpacingX</tabstop>
<tabstop>m_SpacingY</tabstop>
<tabstop>m_SpacingZ</tabstop>
<tabstop>m_NumGradientsBox</tabstop>
<tabstop>m_BvalueBox</tabstop>
<tabstop>m_AdvancedOptionsBox_2</tabstop>
<tabstop>m_RepetitionsBox</tabstop>
+ <tabstop>m_SignalScaleBox</tabstop>
<tabstop>m_TEbox</tabstop>
<tabstop>m_LineReadoutTimeBox</tabstop>
<tabstop>m_T2starBox</tabstop>
<tabstop>m_FiberRadius</tabstop>
<tabstop>m_InterpolationShrink</tabstop>
<tabstop>m_EnforcePureFiberVoxelsBox</tabstop>
- <tabstop>m_KspaceImageBox</tabstop>
<tabstop>m_Compartment1Box</tabstop>
<tabstop>m_Compartment2Box</tabstop>
<tabstop>m_Compartment3Box</tabstop>
<tabstop>m_Compartment4Box</tabstop>
<tabstop>m_Comp4FractionBox</tabstop>
+ <tabstop>m_AddNoise</tabstop>
<tabstop>m_NoiseLevel</tabstop>
+ <tabstop>m_AddGhosts</tabstop>
+ <tabstop>m_kOffsetBox</tabstop>
+ <tabstop>m_AddDistortions</tabstop>
+ <tabstop>m_FrequencyMapBox</tabstop>
<tabstop>m_AddGibbsRinging</tabstop>
- <tabstop>m_KspaceUndersamplingBox</tabstop>
+ <tabstop>tabWidget</tabstop>
</tabstops>
<resources>
<include location="../../resources/QmitkDiffusionImaging.qrc"/>
</resources>
<connections/>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp
new file mode 100644
index 0000000000..82b690a657
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp
@@ -0,0 +1,298 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+// Blueberry
+#include <berryISelectionService.h>
+#include <berryIWorkbenchWindow.h>
+
+// MITK
+#include "QmitkFieldmapGeneratorView.h"
+#include <QmitkStdMultiWidget.h>
+#include <QmitkDataStorageComboBox.h>
+#include <mitkNodePredicateDataType.h>
+#include <itkFieldmapGeneratorFilter.h>
+
+const std::string QmitkFieldmapGeneratorView::VIEW_ID = "org.mitk.views.fieldmapgenerator";
+
+QmitkFieldmapGeneratorView::QmitkFieldmapGeneratorView()
+ : QmitkFunctionality()
+ , m_Controls( 0 )
+ , m_MultiWidget( NULL )
+{
+
+}
+
+QmitkFieldmapGeneratorView::~QmitkFieldmapGeneratorView()
+{
+
+}
+
+void QmitkFieldmapGeneratorView::CreateQtPartControl( QWidget *parent )
+{
+ // build up qt view, unless already done
+ if ( !m_Controls )
+ {
+ // create GUI widgets from the Qt Designer's .ui file
+ m_Controls = new Ui::QmitkFieldmapGeneratorViewControls;
+ m_Controls->setupUi( parent );
+
+ m_Controls->m_SelectedImageBox->SetDataStorage(this->GetDataStorage());
+ mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
+ m_Controls->m_SelectedImageBox->SetPredicate(isMitkImage);
+
+ connect((QObject*) m_Controls->m_GenerateFieldmap, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFieldmap()));
+ connect((QObject*) m_Controls->m_PlaceFieldSource, SIGNAL(clicked()), (QObject*) this, SLOT(PlaceFieldSource()));
+ connect((QObject*) m_Controls->m_SourceVarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
+ connect((QObject*) m_Controls->m_SourceHeightBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnHeightChanged(double)));
+
+ }
+}
+
+void QmitkFieldmapGeneratorView::OnVarianceChanged(double value)
+{
+ if (m_SelectedSource.IsNotNull())
+ {
+ m_SelectedSource->SetProperty("pointsize", mitk::FloatProperty::New(value));
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ }
+}
+
+void QmitkFieldmapGeneratorView::OnHeightChanged(double value)
+{
+ if (m_SelectedSource.IsNotNull())
+ {
+ m_SelectedSource->SetProperty("color", mitk::ColorProperty::New(0, 0, value/100.0));
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ }
+}
+
+void QmitkFieldmapGeneratorView::PlaceFieldSource()
+{
+ if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull() || !m_MultiWidget)
+ {
+ m_Controls->m_WorldPosLabel->setText("-");
+ m_Controls->m_IndexLabel->setText("-");
+ return;
+ }
+
+ mitk::Point3D index;
+ mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData());
+ mitk::Geometry3D* geom = img->GetGeometry();
+
+ if ( geom->IsInside(m_WorldPoint) )
+ {
+ img->GetGeometry()->WorldToIndex(m_WorldPoint, index);
+ mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
+ pointSet->InsertPoint(0, m_WorldPoint);
+
+
+ mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_Controls->m_SelectedImageBox->GetSelectedNode());
+
+ mitk::DataNode::Pointer node = mitk::DataNode::New();
+ node->SetData(pointSet);
+ QString name = QString("FieldSource_%1").arg(children->size());
+ node->SetName(name.toStdString());
+ node->SetVisibility(true);
+
+ float minSpacing;
+ if(geom->GetSpacing()[0]<geom->GetSpacing()[1] && geom->GetSpacing()[0]<geom->GetSpacing()[2])
+ minSpacing = geom->GetSpacing()[0];
+ else if (geom->GetSpacing()[1] < geom->GetSpacing()[2])
+ minSpacing = geom->GetSpacing()[1];
+ else
+ minSpacing = geom->GetSpacing()[2];
+
+ node->SetProperty("pointsize", mitk::FloatProperty::New(minSpacing*5));
+ node->SetProperty("color", mitk::ColorProperty::New(0, 0, 1));
+
+ GetDataStorage()->Add(node, m_Controls->m_SelectedImageBox->GetSelectedNode());
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ }
+}
+
+void QmitkFieldmapGeneratorView::GenerateFieldmap()
+{
+ if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull())
+ return;
+
+ mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData());
+ mitk::Geometry3D* geom = img->GetGeometry();
+
+ typedef itk::Image< double, 3 > FieldMapType;
+ itk::Vector<double> spacing; ///< output image spacing
+ mitk::Point3D origin; ///< output image origin
+ itk::FieldmapGeneratorFilter< FieldMapType >::MatrixType directionMatrix; ///< output image rotation
+ itk::FieldmapGeneratorFilter< FieldMapType >::OutputImageRegionType imageRegion; ///< output image size
+
+ spacing = geom->GetSpacing();
+ origin = geom->GetOrigin();
+ imageRegion.SetSize(0, img->GetDimension(0));
+ imageRegion.SetSize(1, img->GetDimension(1));
+ imageRegion.SetSize(2, img->GetDimension(2));
+ for (int r=0; r<3; r++)
+ for (int c=0; c<3; c++)
+ directionMatrix[r][c]=geom->GetMatrixColumn(c)[r]/spacing[c];
+
+ std::vector< double > variances;
+ std::vector< double > heights;
+ std::vector< mitk::Point3D > worldPositions;
+
+ mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_Controls->m_SelectedImageBox->GetSelectedNode());
+ for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
+ if(dynamic_cast<mitk::PointSet*>((*it)->GetData()))
+ {
+ float var = 0; (*it)->GetPropertyValue("pointsize", var); variances.push_back(var);
+ float color[3]; (*it)->GetColor(color); heights.push_back(color[2]*100);
+ mitk::PointSet* ps = dynamic_cast<mitk::PointSet*>((*it)->GetData());
+ mitk::Point3D point;
+ ps->GetPointIfExists(0, &point);
+ worldPositions.push_back(point);
+ }
+
+ vnl_vector_fixed< double, 3 > gradient, offset;
+ gradient[0] = m_Controls->m_xGradientBox->value();
+ gradient[1] = m_Controls->m_yGradientBox->value();
+ gradient[2] = m_Controls->m_zGradientBox->value();
+ offset[0] = m_Controls->m_xOffsetBox->value();
+ offset[1] = m_Controls->m_yOffsetBox->value();
+ offset[2] = m_Controls->m_zOffsetBox->value();
+
+ itk::FieldmapGeneratorFilter< FieldMapType >::Pointer filter = itk::FieldmapGeneratorFilter< FieldMapType >::New();
+ filter->SetHeights(heights);
+ filter->SetVariances(variances);
+ filter->SetWorldPositions(worldPositions);
+ filter->SetSpacing(spacing);
+ filter->SetOrigin(origin);
+ filter->SetDirectionMatrix(directionMatrix);
+ filter->SetImageRegion(imageRegion);
+ filter->SetGradient(gradient);
+ filter->SetOffset(offset);
+ filter->Update();
+
+ mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
+ mitk::Image::Pointer image = mitk::Image::New();
+ image->InitializeByItk(filter->GetOutput(0));
+ image->SetVolume(filter->GetOutput(0)->GetBufferPointer());
+ resultNode->SetData( image );
+ resultNode->SetName(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetName()+"_Fieldmap");
+ GetDataStorage()->Add(resultNode);
+}
+
+void QmitkFieldmapGeneratorView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+{
+ m_MultiWidget = &stdMultiWidget;
+
+ {
+ mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
+ itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
+ command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
+ m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
+ }
+
+ {
+ mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
+ itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
+ command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
+ m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
+ }
+
+ {
+ mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
+ itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
+ command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
+ m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
+ }
+}
+
+void QmitkFieldmapGeneratorView::StdMultiWidgetNotAvailable()
+{
+
+ {
+ mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
+ slicer->RemoveObserver( m_SliceObserverTag1 );
+ }
+
+ {
+ mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
+ slicer->RemoveObserver( m_SliceObserverTag2 );
+ }
+
+ {
+ mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
+ slicer->RemoveObserver( m_SliceObserverTag3 );
+ }
+
+ m_MultiWidget = NULL;
+}
+
+void QmitkFieldmapGeneratorView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+{
+ if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNotNull())
+ m_Controls->m_SelectedImageBox->GetSelectedNode()->RemoveObserver( m_PropertyObserverTag );
+
+ m_Controls->m_InputData->setTitle("Please Select Reference Image");
+ m_SelectedSource = NULL;
+
+ // iterate selection
+ for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+ {
+ mitk::DataNode::Pointer node = *it;
+
+ if ( node.IsNotNull() && (dynamic_cast<mitk::PointSet*>(node->GetData())) )
+ {
+ m_Controls->m_SourceNameLabel->setText(node->GetName().c_str());
+ m_SelectedSource = node;
+ float variance = 0; node->GetPropertyValue("pointsize", variance);
+ m_Controls->m_SourceVarianceBox->setValue(variance);
+
+ float color[3]; node->GetColor(color);
+ m_Controls->m_SourceHeightBox->setValue(color[2]*100);
+ }
+ }
+
+ if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNotNull())
+ {
+ itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
+ command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
+ m_PropertyObserverTag = m_Controls->m_SelectedImageBox->GetSelectedNode()->AddObserver( itk::ModifiedEvent(), command );
+
+ m_Controls->m_InputData->setTitle("Reference Image");
+ }
+}
+
+void QmitkFieldmapGeneratorView::OnSliceChanged(const itk::EventObject& /*e*/)
+{
+ if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull() || !m_MultiWidget)
+ {
+ m_Controls->m_WorldPosLabel->setText("-");
+ m_Controls->m_IndexLabel->setText("-");
+ return;
+ }
+
+ m_WorldPoint = m_MultiWidget->GetCrossPosition();
+ QString posSting = QString::number(m_WorldPoint[0]); posSting += ", "; posSting += QString::number(m_WorldPoint[1]); posSting += ", "; posSting += QString::number(m_WorldPoint[2]);
+ m_Controls->m_WorldPosLabel->setText(posSting.toStdString().c_str());
+
+ mitk::Point3D index;
+ mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData());
+
+ if ( m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData()->GetGeometry()->IsInside(m_WorldPoint) )
+ {
+ img->GetGeometry()->WorldToIndex(m_WorldPoint, index);
+ posSting = QString::number(index[0]); posSting += ", "; posSting += QString::number(index[1]); posSting += ", "; posSting += QString::number(index[2]);
+ m_Controls->m_IndexLabel->setText(posSting.toStdString().c_str());
+ }
+}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.h
new file mode 100644
index 0000000000..388dc7e5bc
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.h
@@ -0,0 +1,86 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef _QMITKQmitkFieldmapGeneratorView_H_INCLUDED
+#define _QMITKQmitkFieldmapGeneratorView_H_INCLUDED
+
+#include <berryISelectionListener.h>
+#include <QmitkFunctionality.h>
+#include "ui_QmitkFieldmapGeneratorViewControls.h"
+#include <mitkPointSet.h>
+#include <itkImage.h>
+
+/*!
+ \brief View displaying details of the orientation distribution function in the voxel at the current crosshair position.
+
+ \sa QmitkFunctionality
+ \ingroup Functionalities
+*/
+
+class QmitkFieldmapGeneratorView : public QmitkFunctionality
+{
+ // this is needed for all Qt objects that should have a Qt meta-object
+ // (everything that derives from QObject and wants to have signal/slots)
+ Q_OBJECT
+
+public:
+
+ static const std::string VIEW_ID;
+
+ QmitkFieldmapGeneratorView();
+ QmitkFieldmapGeneratorView(const QmitkFieldmapGeneratorView& other)
+ {
+ Q_UNUSED(other)
+ throw std::runtime_error("Copy constructor not implemented");
+ }
+ virtual ~QmitkFieldmapGeneratorView();
+
+ virtual void CreateQtPartControl(QWidget *parent);
+
+ virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
+ virtual void StdMultiWidgetNotAvailable();
+
+ void OnSliceChanged(const itk::EventObject& e);
+
+protected slots:
+
+ void GenerateFieldmap();
+ void PlaceFieldSource();
+ void OnVarianceChanged(double value);
+ void OnHeightChanged(double value);
+
+protected:
+
+ /// \brief called by QmitkFunctionality when DataManager's selection has changed
+ virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
+
+ Ui::QmitkFieldmapGeneratorViewControls* m_Controls;
+ QmitkStdMultiWidget* m_MultiWidget;
+
+ /** observer flags */
+ int m_SliceObserverTag1;
+ int m_SliceObserverTag2;
+ int m_SliceObserverTag3;
+ int m_PropertyObserverTag;
+
+ mitk::Point3D m_WorldPoint;
+ mitk::DataNode::Pointer m_SelectedSource;
+};
+
+
+
+#endif // _QmitkFieldmapGeneratorView_H_INCLUDED
+
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorViewControls.ui
new file mode 100644
index 0000000000..f700a16e71
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorViewControls.ui
@@ -0,0 +1,299 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QmitkFieldmapGeneratorViewControls</class>
+ <widget class="QWidget" name="QmitkFieldmapGeneratorViewControls">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>348</width>
+ <height>498</height>
+ </rect>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>0</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="windowTitle">
+ <string>QmitkTemplate</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout_2">
+ <property name="spacing">
+ <number>6</number>
+ </property>
+ <property name="margin">
+ <number>9</number>
+ </property>
+ <item>
+ <widget class="QGroupBox" name="m_InputData">
+ <property name="title">
+ <string>Please Select Reference Image</string>
+ </property>
+ <layout class="QGridLayout" name="gridLayout_3">
+ <item row="0" column="0">
+ <widget class="QmitkDataStorageComboBox" name="m_SelectedImageBox"/>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <widget class="QFrame" name="frame">
+ <property name="frameShape">
+ <enum>QFrame::NoFrame</enum>
+ </property>
+ <property name="frameShadow">
+ <enum>QFrame::Raised</enum>
+ </property>
+ <layout class="QGridLayout" name="gridLayout">
+ <property name="margin">
+ <number>0</number>
+ </property>
+ <item row="0" column="0">
+ <widget class="QLabel" name="label_2">
+ <property name="text">
+ <string>World Coordinates:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="1">
+ <widget class="QLabel" name="m_WorldPosLabel">
+ <property name="text">
+ <string>-</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="0">
+ <widget class="QLabel" name="label_3">
+ <property name="text">
+ <string>Index:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="1">
+ <widget class="QLabel" name="m_IndexLabel">
+ <property name="text">
+ <string>-</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <widget class="QCommandLinkButton" name="m_PlaceFieldSource">
+ <property name="text">
+ <string>Place Field Source</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QCommandLinkButton" name="m_GenerateFieldmap">
+ <property name="text">
+ <string>Generate Fieldmap</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QGroupBox" name="groupBox_2">
+ <property name="title">
+ <string>Add Gradient</string>
+ </property>
+ <layout class="QGridLayout" name="gridLayout_4">
+ <item row="0" column="1">
+ <widget class="QLabel" name="label_10">
+ <property name="text">
+ <string>Gradient</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="0">
+ <widget class="QLabel" name="label_7">
+ <property name="text">
+ <string>x:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="3" column="0">
+ <widget class="QLabel" name="label_9">
+ <property name="text">
+ <string>z:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="3" column="1">
+ <widget class="QDoubleSpinBox" name="m_zGradientBox">
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ <property name="minimum">
+ <double>-1000.000000000000000</double>
+ </property>
+ <property name="maximum">
+ <double>1000.000000000000000</double>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="1">
+ <widget class="QDoubleSpinBox" name="m_xGradientBox">
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ <property name="minimum">
+ <double>-1000.000000000000000</double>
+ </property>
+ <property name="maximum">
+ <double>1000.000000000000000</double>
+ </property>
+ </widget>
+ </item>
+ <item row="2" column="0">
+ <widget class="QLabel" name="label_8">
+ <property name="text">
+ <string>y:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="2" column="1">
+ <widget class="QDoubleSpinBox" name="m_yGradientBox">
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ <property name="minimum">
+ <double>-1000.000000000000000</double>
+ </property>
+ <property name="maximum">
+ <double>1000.000000000000000</double>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="2">
+ <widget class="QLabel" name="label_11">
+ <property name="text">
+ <string>Offset</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="2">
+ <widget class="QDoubleSpinBox" name="m_xOffsetBox">
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ <property name="minimum">
+ <double>-1000.000000000000000</double>
+ </property>
+ <property name="maximum">
+ <double>1000.000000000000000</double>
+ </property>
+ </widget>
+ </item>
+ <item row="2" column="2">
+ <widget class="QDoubleSpinBox" name="m_yOffsetBox">
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ <property name="minimum">
+ <double>-1000.000000000000000</double>
+ </property>
+ <property name="maximum">
+ <double>1000.000000000000000</double>
+ </property>
+ </widget>
+ </item>
+ <item row="3" column="2">
+ <widget class="QDoubleSpinBox" name="m_zOffsetBox">
+ <property name="decimals">
+ <number>4</number>
+ </property>
+ <property name="minimum">
+ <double>-1000.000000000000000</double>
+ </property>
+ <property name="maximum">
+ <double>1000.000000000000000</double>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <widget class="QGroupBox" name="groupBox">
+ <property name="title">
+ <string>Edit Selected Source</string>
+ </property>
+ <layout class="QGridLayout" name="gridLayout_2">
+ <item row="0" column="0">
+ <widget class="QLabel" name="label_6">
+ <property name="text">
+ <string>Name:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="2" column="0">
+ <widget class="QLabel" name="label_5">
+ <property name="text">
+ <string>Height:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="0">
+ <widget class="QLabel" name="label_4">
+ <property name="text">
+ <string>Variance:</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="1">
+ <widget class="QLabel" name="m_SourceNameLabel">
+ <property name="text">
+ <string>-</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="1">
+ <widget class="QDoubleSpinBox" name="m_SourceVarianceBox">
+ <property name="maximum">
+ <double>999999.000000000000000</double>
+ </property>
+ </widget>
+ </item>
+ <item row="2" column="1">
+ <widget class="QDoubleSpinBox" name="m_SourceHeightBox">
+ <property name="maximum">
+ <double>999999.000000000000000</double>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <spacer name="spacer1">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeType">
+ <enum>QSizePolicy::Expanding</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>220</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <customwidgets>
+ <customwidget>
+ <class>QmitkDataStorageComboBox</class>
+ <extends>QComboBox</extends>
+ <header location="global">QmitkDataStorageComboBox.h</header>
+ </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
index 6ecdb77b95..5683c2355d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
@@ -1,815 +1,826 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkIVIMView.h"
#include "QmitkStdMultiWidget.h"
// qt
#include "qmessagebox.h"
#include "qclipboard.h"
// mitk
#include "mitkDiffusionImage.h"
#include "mitkImageCast.h"
// itk
#include "itkScalarImageToHistogramGenerator.h"
#include "itkRegionOfInterestImageFilter.h"
#include "itkImageRegionConstIteratorWithIndex.h"
// itk/mitk
#include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
#include "itkRegularizedIVIMReconstructionFilter.h"
#include "mitkImageCast.h"
const std::string QmitkIVIMView::VIEW_ID = "org.mitk.views.ivim";
QmitkIVIMView::QmitkIVIMView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
- , m_Active(false)
, m_SliceObserverTag1(0), m_SliceObserverTag2(0), m_SliceObserverTag3(0)
, m_DiffusionImageNode(NULL)
, m_MaskImageNode(NULL)
+ , m_Active(false)
{
}
QmitkIVIMView::~QmitkIVIMView()
{
// QmitkStdMultiWidget* MultiWidget = this->GetActiveStdMultiWidget(false);
// if(MultiWidget)
// {
// //unregister observers when view is destroyed
// if( MultiWidget->mitkWidget1 != NULL && m_SliceObserverTag1 != 0)
// {
// mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget1->GetSliceNavigationController();
// slicer->RemoveObserver( m_SliceObserverTag1 );
// }
// if( MultiWidget->mitkWidget2 != NULL && m_SliceObserverTag2 != 0)
// {
// mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget2->GetSliceNavigationController();
// slicer->RemoveObserver( m_SliceObserverTag2 );
// }
// if( MultiWidget->mitkWidget3!= NULL && m_SliceObserverTag3 != 0)
// {
// mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget3->GetSliceNavigationController();
// slicer->RemoveObserver( m_SliceObserverTag3 );
// }
// }
}
void QmitkIVIMView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkIVIMViewControls;
m_Controls->setupUi( parent );
connect( m_Controls->m_ButtonStart, SIGNAL(clicked()), this, SLOT(FittIVIMStart()) );
connect( m_Controls->m_ButtonAutoThres, SIGNAL(clicked()), this, SLOT(AutoThreshold()) );
connect( m_Controls->m_MethodCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(MethodCombo(int)) );
connect( m_Controls->m_DStarSlider, SIGNAL(valueChanged(int)), this, SLOT(DStarSlider(int)) );
connect( m_Controls->m_BThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(BThreshSlider(int)) );
connect( m_Controls->m_S0ThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(S0ThreshSlider(int)) );
connect( m_Controls->m_NumItSlider, SIGNAL(valueChanged(int)), this, SLOT(NumItsSlider(int)) );
connect( m_Controls->m_LambdaSlider, SIGNAL(valueChanged(int)), this, SLOT(LambdaSlider(int)) );
connect( m_Controls->m_CheckDStar, SIGNAL(clicked()), this, SLOT(Checkbox()) );
connect( m_Controls->m_CheckD, SIGNAL(clicked()), this, SLOT(Checkbox()) );
connect( m_Controls->m_Checkf, SIGNAL(clicked()), this, SLOT(Checkbox()) );
connect( m_Controls->m_ChooseMethod, SIGNAL(clicked()), this, SLOT(ChooseMethod()) );
connect( m_Controls->m_CurveClipboard, SIGNAL(clicked()), this, SLOT(ClipboardCurveButtonClicked()) );
connect( m_Controls->m_ValuesClipboard, SIGNAL(clicked()), this, SLOT(ClipboardStatisticsButtonClicked()) );
}
QString dstar = QString::number(m_Controls->m_DStarSlider->value()/1000.0);
m_Controls->m_DStarLabel->setText(dstar);
QString bthresh = QString::number(m_Controls->m_BThreshSlider->value()*5.0);
m_Controls->m_BThreshLabel->setText(bthresh);
QString s0thresh = QString::number(m_Controls->m_S0ThreshSlider->value()*0.5);
m_Controls->m_S0ThreshLabel->setText(s0thresh);
QString numits = QString::number(m_Controls->m_NumItSlider->value());
m_Controls->m_NumItsLabel->setText(numits);
QString lambda = QString::number(m_Controls->m_LambdaSlider->value()*.00001);
m_Controls->m_LambdaLabel->setText(lambda);
m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
m_Controls->m_Warning->setVisible(false);
MethodCombo(m_Controls->m_MethodCombo->currentIndex());
}
void QmitkIVIMView::Checkbox()
{
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::MethodCombo(int val)
{
switch(val)
{
case 0:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(false);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 1:
m_Controls->m_DstarFrame->setVisible(true);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(false);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 2:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(true);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 3:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(true);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 4:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(false);
m_Controls->m_NeglBframe->setVisible(false);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
}
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::DStarSlider (int val)
{
QString sval = QString::number(val/1000.0);
m_Controls->m_DStarLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::BThreshSlider (int val)
{
QString sval = QString::number(val*5.0);
m_Controls->m_BThreshLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::S0ThreshSlider (int val)
{
QString sval = QString::number(val*0.5);
m_Controls->m_S0ThreshLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::NumItsSlider (int val)
{
QString sval = QString::number(val);
m_Controls->m_NumItsLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::LambdaSlider (int val)
{
QString sval = QString::number(val*.00001);
m_Controls->m_LambdaLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
}
void QmitkIVIMView::StdMultiWidgetNotAvailable()
{
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag1 );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag2 );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag3 );
}
m_MultiWidget = NULL;
}
void QmitkIVIMView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
bool foundOneDiffusionImage = false;
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
m_MaskImageNode = NULL;
m_DiffusionImageNode = NULL;
// iterate all selected objects, adjust warning visibility
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
if( dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
{
m_DiffusionImageNode = node;
foundOneDiffusionImage = true;
m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
}
else
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
{
m_MaskImageNode = node;
m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
}
}
}
}
if (m_DiffusionImageNode.IsNotNull())
{
m_Controls->m_VisualizeResultsWidget->setVisible(true);
m_Controls->m_InputData->setTitle("Input Data");
}
else
+ {
m_Controls->m_VisualizeResultsWidget->setVisible(false);
+ m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
+ }
m_Controls->m_ButtonStart->setEnabled( foundOneDiffusionImage );
m_Controls->m_ButtonAutoThres->setEnabled( foundOneDiffusionImage );
m_Controls->m_ControlsFrame->setEnabled( foundOneDiffusionImage );
m_Controls->m_BottomControlsFrame->setEnabled( foundOneDiffusionImage );
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::AutoThreshold()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
if (nodes.empty()) return;
if (!nodes.front())
{
// Nothing selected. Inform the user and return
QMessageBox::information( NULL, "Template", "Please load and select a diffusion image before starting image processing.");
return;
}
typedef mitk::DiffusionImage<short> DiffImgType;
DiffImgType* dimg = dynamic_cast<DiffImgType*>(nodes.front()->GetData());
if (!dimg)
{
// Nothing selected. Inform the user and return
QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
return;
}
// find bzero index
int index = -1;
DiffImgType::GradientDirectionContainerType::Pointer directions = dimg->GetDirections();
for(DiffImgType::GradientDirectionContainerType::ConstIterator it = directions->Begin();
it != directions->End(); ++it)
{
index++;
DiffImgType::GradientDirectionType g = it.Value();
if(g[0] == 0 && g[1] == 0 && g[2] == 0 )
break;
}
typedef itk::VectorImage<short,3> VecImgType;
VecImgType::Pointer vecimg = dimg->GetVectorImage();
int vecLength = vecimg->GetVectorLength();
index = index > vecLength-1 ? vecLength-1 : index;
MITK_INFO << "Performing Histogram Analysis on Channel" << index;
typedef itk::Image<short,3> ImgType;
ImgType::Pointer img = ImgType::New();
mitk::CastToItkImage<ImgType>(dimg, img);
itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
- itw = itw.Begin();
+ itw.GoToBegin();
itk::ImageRegionConstIterator<VecImgType> itr (vecimg, vecimg->GetLargestPossibleRegion() );
- itr = itr.Begin();
+ itr.GoToBegin();
while(!itr.IsAtEnd())
{
itw.Set(itr.Get().GetElement(index));
++itr;
++itw;
}
typedef itk::Statistics::ScalarImageToHistogramGenerator< ImgType >
HistogramGeneratorType;
typedef HistogramGeneratorType::HistogramType HistogramType;
HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New();
histogramGenerator->SetInput( img );
histogramGenerator->SetMarginalScale( 10 ); // Defines y-margin width of histogram
histogramGenerator->SetNumberOfBins( 100 ); // CT range [-1024, +2048] --> bin size 4 values
histogramGenerator->SetHistogramMin( dimg->GetScalarValueMin() );
histogramGenerator->SetHistogramMax( dimg->GetScalarValueMax() * .5 );
histogramGenerator->Compute();
HistogramType::ConstIterator iter = histogramGenerator->GetOutput()->Begin();
float maxFreq = 0;
float maxValue = 0;
while ( iter != histogramGenerator->GetOutput()->End() )
{
if(iter.GetFrequency() > maxFreq)
{
maxFreq = iter.GetFrequency();
maxValue = iter.GetMeasurementVector()[0];
}
++iter;
}
maxValue *= 2;
int sliderPos = maxValue * 2;
m_Controls->m_S0ThreshSlider->setValue(sliderPos);
S0ThreshSlider(sliderPos);
}
void QmitkIVIMView::FittIVIMStart()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
mitk::DiffusionImage<short>* img = 0;
- for ( int i=0; i<nodes.size(); i++ )
+ for ( unsigned int i=0; i<nodes.size(); i++ )
{
img = dynamic_cast<mitk::DiffusionImage<short>*>(nodes.at(i)->GetData());
if (img)
break;
}
if (!img)
{
QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
return;
}
typedef itk::VectorImage<short,3> VecImgType;
VecImgType::Pointer vecimg = img->GetVectorImage();
OutImgType::IndexType dummy;
FittIVIM(vecimg, img->GetDirections(), img->GetB_Value(), true, dummy);
OutputToDatastorage(nodes);
}
void QmitkIVIMView::OnSliceChanged(const itk::EventObject& /*e*/)
{
if(!m_Visible)
return;
m_Controls->m_Warning->setVisible(false);
if(!m_Controls || m_DiffusionImageNode.IsNull())
return;
m_Controls->m_VisualizeResultsWidget->setVisible(false);
mitk::DiffusionImage<short>::Pointer diffusionImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_DiffusionImageNode->GetData());
mitk::Image::Pointer maskImg = NULL;
if (m_MaskImageNode.IsNotNull())
maskImg = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
if (!m_MultiWidget) return;
typedef itk::VectorImage<short,3> VecImgType;
VecImgType::Pointer vecimg = (VecImgType*)diffusionImg->GetVectorImage().GetPointer();
VecImgType::Pointer roiImage = VecImgType::New();
bool success = false;
if(maskImg.IsNull())
{
int roisize = 0;
if(m_Controls->m_MethodCombo->currentIndex() == 4)
roisize = 5;
mitk::Point3D pos = m_MultiWidget->GetCrossPosition();
VecImgType::IndexType crosspos;
diffusionImg->GetTimeSlicedGeometry()->WorldToIndex(pos, crosspos);
if (!vecimg->GetLargestPossibleRegion().IsInside(crosspos))
{
m_Controls->m_Warning->setText(QString("Crosshair position not inside of selected diffusion weighted image. Reinit needed!"));
m_Controls->m_Warning->setVisible(true);
return;
}
else
m_Controls->m_Warning->setVisible(false);
VecImgType::IndexType index;
index[0] = crosspos[0] - roisize; index[0] = index[0] < 0 ? 0 : index[0];
index[1] = crosspos[1] - roisize; index[1] = index[1] < 0 ? 0 : index[1];
index[2] = crosspos[2] - roisize; index[2] = index[2] < 0 ? 0 : index[2];
VecImgType::SizeType size;
size[0] = roisize*2+1;
size[1] = roisize*2+1;
size[2] = roisize*2+1;
VecImgType::SizeType maxSize = vecimg->GetLargestPossibleRegion().GetSize();
size[0] = index[0]+size[0] > maxSize[0] ? maxSize[0]-index[0] : size[0];
size[1] = index[1]+size[1] > maxSize[1] ? maxSize[1]-index[1] : size[1];
size[2] = index[2]+size[2] > maxSize[2] ? maxSize[2]-index[2] : size[2];
VecImgType::RegionType region;
region.SetSize( size );
region.SetIndex( index );
vecimg->SetRequestedRegion( region );
VecImgType::IndexType newstart;
newstart.Fill(0);
VecImgType::RegionType newregion;
newregion.SetSize( size );
newregion.SetIndex( newstart );
roiImage->CopyInformation( vecimg );
roiImage->SetRegions( newregion );
roiImage->SetOrigin( pos );
roiImage->Allocate();
roiImage->SetPixel(newstart, vecimg->GetPixel(index));
success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetB_Value(), false, crosspos);
}
else
{
typedef itk::Image<float,3> MaskImgType;
MaskImgType::Pointer maskItk;
CastToItkImage( maskImg, maskItk );
mitk::Point3D pos;
pos[0] = 0;
pos[1] = 0;
pos[2] = 0;
VecImgType::IndexType index;
index[0] = 0;
index[1] = 0;
index[2] = 0;
VecImgType::SizeType size;
size[0] = 1;
size[1] = 1;
size[2] = 1;
VecImgType::RegionType region;
region.SetSize( size );
region.SetIndex( index );
vecimg->SetRequestedRegion( region );
// iterators over output and input
itk::ImageRegionConstIteratorWithIndex<VecImgType>
vecit(vecimg, vecimg->GetLargestPossibleRegion());
itk::VariableLengthVector<double> avg(vecimg->GetVectorLength());
avg.Fill(0);
float numPixels = 0;
while ( ! vecit.IsAtEnd() )
{
VecImgType::PointType point;
vecimg->TransformIndexToPhysicalPoint(vecit.GetIndex(), point);
MaskImgType::IndexType index;
maskItk->TransformPhysicalPointToIndex(point, index);
if(maskItk->GetPixel(index) != 0)
{
avg += vecit.Get();
numPixels += 1.0;
}
// update iterators
++vecit;
}
avg /= numPixels;
m_Controls->m_Warning->setText(QString("Averaging ")+QString::number((int)numPixels)+QString(" voxels!"));
m_Controls->m_Warning->setVisible(true);
roiImage->CopyInformation( vecimg );
roiImage->SetRegions( region );
roiImage->SetOrigin( pos );
roiImage->Allocate();
roiImage->SetPixel(index, avg);
success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetB_Value(), false, index);
}
vecimg->SetRegions( vecimg->GetLargestPossibleRegion() );
if (success)
{
m_Controls->m_VisualizeResultsWidget->setVisible(true);
m_Controls->m_VisualizeResultsWidget->SetParameters(m_Snap);
}
}
bool QmitkIVIMView::FittIVIM(itk::VectorImage<short,3>* vecimg, DirContainerType* dirs, float bval, bool multivoxel, OutImgType::IndexType &crosspos)
{
IVIMFilterType::Pointer filter = IVIMFilterType::New();
filter->SetInput(vecimg);
filter->SetGradientDirections(dirs);
filter->SetBValue(bval);
switch(m_Controls->m_MethodCombo->currentIndex())
{
case 0:
filter->SetMethod(IVIMFilterType::IVIM_FIT_ALL);
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
break;
case 1:
filter->SetMethod(IVIMFilterType::IVIM_DSTAR_FIX);
filter->SetDStar(m_Controls->m_DStarLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
break;
case 2:
filter->SetMethod(IVIMFilterType::IVIM_D_THEN_DSTAR);
filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
break;
case 3:
filter->SetMethod(IVIMFilterType::IVIM_LINEAR_D_THEN_F);
filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
break;
case 4:
filter->SetMethod(IVIMFilterType::IVIM_REGULARIZED);
filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
filter->SetNumberIterations(m_Controls->m_NumItsLabel->text().toInt());
filter->SetLambda(m_Controls->m_LambdaLabel->text().toDouble());
filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
break;
}
if(!multivoxel)
{
filter->SetFitDStar(true);
}
filter->SetNumberOfThreads(1);
filter->SetVerbose(false);
filter->SetCrossPosition(crosspos);
try{
filter->Update();
m_Snap = filter->GetSnapshot();
m_DStarMap = filter->GetOutput(2);
m_DMap = filter->GetOutput(1);
- m_fMap = filter->GetOutput(0);
+ m_fMap = filter->GetOutput();
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
m_Controls->m_Warning->setText(QString("IVIM fit not possible: ")+ex.GetDescription());
m_Controls->m_Warning->setVisible(true);
return false;
}
return true;
}
void QmitkIVIMView::OutputToDatastorage(std::vector<mitk::DataNode*> nodes)
{
// Outputs to Datastorage
QString basename(nodes.front()->GetName().c_str());
if(m_Controls->m_CheckDStar->isChecked())
{
mitk::Image::Pointer dstarimage = mitk::Image::New();
dstarimage->InitializeByItk(m_DStarMap.GetPointer());
dstarimage->SetVolume(m_DStarMap->GetBufferPointer());
QString newname2 = basename; newname2 = newname2.append("_DStarMap_%1").arg(m_Controls->m_MethodCombo->currentText());
mitk::DataNode::Pointer node2=mitk::DataNode::New();
node2->SetData( dstarimage );
node2->SetName(newname2.toAscii());
GetDefaultDataStorage()->Add(node2);
}
if(m_Controls->m_CheckD->isChecked())
{
mitk::Image::Pointer dimage = mitk::Image::New();
dimage->InitializeByItk(m_DMap.GetPointer());
dimage->SetVolume(m_DMap->GetBufferPointer());
QString newname1 = basename; newname1 = newname1.append("_DMap_%1").arg(m_Controls->m_MethodCombo->currentText());
mitk::DataNode::Pointer node1=mitk::DataNode::New();
node1->SetData( dimage );
node1->SetName(newname1.toAscii());
GetDefaultDataStorage()->Add(node1);
}
if(m_Controls->m_Checkf->isChecked())
{
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk(m_fMap.GetPointer());
image->SetVolume(m_fMap->GetBufferPointer());
QString newname0 = basename; newname0 = newname0.append("_fMap_%1").arg(m_Controls->m_MethodCombo->currentText());
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
node->SetName(newname0.toAscii());
GetDefaultDataStorage()->Add(node);
}
m_MultiWidget->RequestUpdate();
+ // reset the data node labels, the selection in DataManager is lost after adding
+ // a new node -> we cannot directly proceed twice, the DWI ( and MASK) image have to be selected again
+ m_Controls->m_InputData->setTitle("Please Select Input Data");
+ m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
+ m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
+ m_MaskImageNode = NULL;
+ m_DiffusionImageNode = NULL;
+
}
void QmitkIVIMView::ChooseMethod()
{
m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
}
void QmitkIVIMView::ClipboardCurveButtonClicked()
{
if(true)
{
QString clipboard("Measurement Points\n");
- for ( int i=0; i<m_Snap.bvalues.size(); i++)
+ for ( unsigned int i=0; i<m_Snap.bvalues.size(); i++)
{
clipboard = clipboard.append( "%L1 \t" )
.arg( m_Snap.bvalues[i], 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
- for ( int i=0; i<m_Snap.allmeas.size(); i++)
+ for ( unsigned int i=0; i<m_Snap.allmeas.size(); i++)
{
clipboard = clipboard.append( "%L1 \t" )
.arg( m_Snap.allmeas[i], 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
clipboard = clipboard.append( "1st Linear Fit of D and f \n" );
double maxb = m_Snap.bvalues.max_value();
clipboard = clipboard.append( "%L1 \t %L2 \n %L3 \t %L4 \n" )
.arg( (float) 0, 0, 'f', 2 )
.arg( maxb, 0, 'f', 2 )
.arg(1-m_Snap.currentFunceiled, 0, 'f', 2 )
.arg((1-m_Snap.currentFunceiled)*exp(-maxb * m_Snap.currentD), 0, 'f', 2 );
int nsampling = 50;
double f = 1-m_Snap.currentFunceiled;
clipboard = clipboard.append("Final Model\n");
for(int i=0; i<nsampling; i++)
{
double x = (((1.0)*i)/(1.0*nsampling))*maxb;
clipboard = clipboard.append( "%L1 \t" )
.arg( x, 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
for(int i=0; i<nsampling; i++)
{
double x = (((1.0)*i)/(1.0*nsampling))*maxb;
double y = f*exp(- x * m_Snap.currentD) + (1-f)*exp(- x * (m_Snap.currentD+m_Snap.currentDStar));
clipboard = clipboard.append( "%L1 \t" )
.arg( y, 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
}
void QmitkIVIMView::ClipboardStatisticsButtonClicked()
{
if ( true )
{
QString clipboard( "f \t D \t D* \n" );
clipboard = clipboard.append( "%L1 \t %L2 \t %L3" )
.arg( m_Snap.currentF, 0, 'f', 10 )
.arg( m_Snap.currentD, 0, 'f', 10 )
.arg( m_Snap.currentDStar, 0, 'f', 10 ) ;
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
}
void QmitkIVIMView::Activated()
{
m_Active = true;
}
void QmitkIVIMView::Deactivated()
{
m_Active = false;
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
index 2f26f69ef9..26bba0a2fd 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
@@ -1,751 +1,768 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//misc
#define _USE_MATH_DEFINES
#include <math.h>
#include <QFileDialog>
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkOdfMaximaExtractionView.h"
// MITK
#include <mitkImageCast.h>
#include <mitkFiberBundleX.h>
#include <mitkImage.h>
#include <mitkDiffusionImage.h>
#include <mitkImageToItk.h>
#include <mitkTensorImage.h>
// ITK
#include <itkVectorImage.h>
#include <itkOdfMaximaExtractionFilter.h>
#include <itkFiniteDiffOdfMaximaExtractionFilter.h>
#include <itkMrtrixPeakImageConverter.h>
#include <itkFslPeakImageConverter.h>
#include <itkShCoefficientImageImporter.h>
#include <itkDiffusionTensorPrincipalDirectionImageFilter.h>
const std::string QmitkOdfMaximaExtractionView::VIEW_ID = "org.mitk.views.odfmaximaextractionview";
using namespace mitk;
QmitkOdfMaximaExtractionView::QmitkOdfMaximaExtractionView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
{
}
// Destructor
QmitkOdfMaximaExtractionView::~QmitkOdfMaximaExtractionView()
{
}
void QmitkOdfMaximaExtractionView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkOdfMaximaExtractionViewControls;
m_Controls->setupUi( parent );
connect((QObject*) m_Controls->m_StartTensor, SIGNAL(clicked()), (QObject*) this, SLOT(StartTensor()));
connect((QObject*) m_Controls->m_StartFiniteDiff, SIGNAL(clicked()), (QObject*) this, SLOT(StartFiniteDiff()));
connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
connect((QObject*) m_Controls->m_ImportPeaks, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertPeaks()));
connect((QObject*) m_Controls->m_ImportShCoeffs, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertShCoeffs()));
}
}
void QmitkOdfMaximaExtractionView::UpdateGui()
{
m_Controls->m_GenerateImageButton->setEnabled(false);
m_Controls->m_StartFiniteDiff->setEnabled(false);
m_Controls->m_StartTensor->setEnabled(false);
m_Controls->m_CoeffImageFrame->setEnabled(false);
if (!m_ImageNodes.empty() || !m_TensorImageNodes.empty())
{
m_Controls->m_InputData->setTitle("Input Data");
if (!m_TensorImageNodes.empty())
{
m_Controls->m_DwiFibLabel->setText(m_TensorImageNodes.front()->GetName().c_str());
m_Controls->m_StartTensor->setEnabled(true);
}
else
{
m_Controls->m_DwiFibLabel->setText(m_ImageNodes.front()->GetName().c_str());
m_Controls->m_StartFiniteDiff->setEnabled(true);
m_Controls->m_GenerateImageButton->setEnabled(true);
m_Controls->m_CoeffImageFrame->setEnabled(true);
m_Controls->m_ShOrderBox->setEnabled(true);
m_Controls->m_MaxNumPeaksBox->setEnabled(true);
m_Controls->m_PeakThresholdBox->setEnabled(true);
m_Controls->m_AbsoluteThresholdBox->setEnabled(true);
}
}
else
m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
if (m_ImageNodes.empty())
{
m_Controls->m_ImportPeaks->setEnabled(false);
m_Controls->m_ImportShCoeffs->setEnabled(false);
}
else
{
m_Controls->m_ImportPeaks->setEnabled(true);
m_Controls->m_ImportShCoeffs->setEnabled(true);
}
if (!m_BinaryImageNodes.empty())
{
m_Controls->m_MaskLabel->setText(m_BinaryImageNodes.front()->GetName().c_str());
}
else
{
m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
}
}
template<int shOrder>
void QmitkOdfMaximaExtractionView::TemplatedConvertShCoeffs(mitk::Image* mitkImg)
{
typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
typename FilterType::Pointer filter = FilterType::New();
switch (m_Controls->m_ToolkitBox->currentIndex())
{
case 0:
filter->SetToolkit(FilterType::FSL);
break;
case 1:
filter->SetToolkit(FilterType::MRTRIX);
break;
default:
filter->SetToolkit(FilterType::FSL);
}
filter->SetInputImage(caster->GetOutput());
filter->GenerateData();
typename FilterType::QballImageType::Pointer itkQbi = filter->GetQballImage();
typename FilterType::CoefficientImageType::Pointer itkCi = filter->GetCoefficientImage();
{
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkCi.GetPointer() );
img->SetVolume( itkCi->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
node->SetName("_ShCoefficientImage");
+ node->SetVisibility(false);
GetDataStorage()->Add(node);
}
{
mitk::QBallImage::Pointer img = mitk::QBallImage::New();
img->InitializeByItk( itkQbi.GetPointer() );
img->SetVolume( itkQbi->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
node->SetName("_QballImage");
GetDataStorage()->Add(node);
}
}
void QmitkOdfMaximaExtractionView::ConvertShCoeffs()
{
if (m_ImageNodes.empty())
return;
mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
if (mitkImg->GetDimension()!=4)
{
MITK_INFO << "wrong image type (need 4 dimensions)";
return;
}
int nrCoeffs = mitkImg->GetLargestPossibleRegion().GetSize()[3];
// solve bx² + cx + d = 0 = shOrder² + 2*shOrder + 2-2*neededCoeffs;
int c=3, d=2-2*nrCoeffs;
double D = c*c-4*d;
int shOrder;
if (D>0)
{
shOrder = (-c+sqrt(D))/2.0;
if (shOrder<0)
shOrder = (-c-sqrt(D))/2.0;
}
else if (D==0)
shOrder = -c/2.0;
MITK_INFO << "using SH-order " << shOrder;
switch (shOrder)
{
case 4:
TemplatedConvertShCoeffs<4>(mitkImg);
break;
case 6:
TemplatedConvertShCoeffs<6>(mitkImg);
break;
case 8:
TemplatedConvertShCoeffs<8>(mitkImg);
break;
case 10:
TemplatedConvertShCoeffs<10>(mitkImg);
break;
case 12:
TemplatedConvertShCoeffs<12>(mitkImg);
break;
default:
MITK_INFO << "SH-order " << shOrder << " not supported";
}
}
void QmitkOdfMaximaExtractionView::ConvertPeaks()
{
if (m_ImageNodes.empty())
return;
switch (m_Controls->m_ToolkitBox->currentIndex())
{
case 0:
{
typedef itk::Image< float, 4 > ItkImageType;
typedef itk::FslPeakImageConverter< float > FilterType;
FilterType::Pointer filter = FilterType::New();
FilterType::InputType::Pointer inputVec = FilterType::InputType::New();
mitk::Geometry3D::Pointer geom;
for (int i=0; i<m_ImageNodes.size(); i++)
{
mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(i)->GetData());
geom = mitkImg->GetGeometry();
typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
inputVec->InsertElement(inputVec->Size(), itkImg);
}
filter->SetInputImages(inputVec);
filter->GenerateData();
mitk::Vector3D outImageSpacing = geom->GetSpacing();
float maxSpacing = 1;
if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
maxSpacing = outImageSpacing[0];
else if (outImageSpacing[1] > outImageSpacing[2])
maxSpacing = outImageSpacing[1];
else
maxSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
// directions->SetGeometry(geom);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
node->SetName("_VectorField");
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(i)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
+ node->SetVisibility(false);
GetDataStorage()->Add(node);
}
break;
}
case 1:
{
typedef itk::Image< float, 4 > ItkImageType;
typedef itk::MrtrixPeakImageConverter< float > FilterType;
FilterType::Pointer filter = FilterType::New();
// cast to itk
mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
mitk::Geometry3D::Pointer geom = mitkImg->GetGeometry();
typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
filter->SetInputImage(itkImg);
filter->GenerateData();
mitk::Vector3D outImageSpacing = geom->GetSpacing();
float maxSpacing = 1;
if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
maxSpacing = outImageSpacing[0];
else if (outImageSpacing[1] > outImageSpacing[2])
maxSpacing = outImageSpacing[1];
else
maxSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
//directions->SetGeometry(geom);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
+ {
+ ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
+ mitk::Image::Pointer image2 = mitk::Image::New();
+ image2->InitializeByItk( numDirImage.GetPointer() );
+ image2->SetVolume( numDirImage->GetBufferPointer() );
+ DataNode::Pointer node2 = DataNode::New();
+ node2->SetData(image2);
+ QString name(m_ImageNodes.at(0)->GetName().c_str());
+ name += "_NumDirections";
+ node2->SetName(name.toStdString().c_str());
+ GetDataStorage()->Add(node2);
+ }
+
typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
+ node->SetVisibility(false);
GetDataStorage()->Add(node);
}
break;
}
}
}
void QmitkOdfMaximaExtractionView::GenerateImage()
{
if (!m_ImageNodes.empty())
GenerateDataFromDwi();
}
void QmitkOdfMaximaExtractionView::StartTensor()
{
if (m_TensorImageNodes.empty())
return;
typedef itk::DiffusionTensorPrincipalDirectionImageFilter< float, float > MaximaExtractionFilterType;
MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
mitk::Geometry3D::Pointer geometry;
try{
TensorImage::Pointer img = dynamic_cast<TensorImage*>(m_TensorImageNodes.at(0)->GetData());
ItkTensorImage::Pointer itkImage = ItkTensorImage::New();
CastToItkImage<ItkTensorImage>(img, itkImage);
filter->SetInput(itkImage);
geometry = img->GetGeometry();
}
catch(itk::ExceptionObject &e)
{
MITK_INFO << "wrong image type: " << e.what();
throw e;
}
if (!m_BinaryImageNodes.empty())
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
CastToItkImage<ItkUcharImgType>(mitkMaskImg, itkMaskImage);
filter->SetMaskImage(itkMaskImage);
}
if (m_Controls->m_NormalizationBox->currentIndex()==0)
filter->SetNormalizeVectors(false);
filter->Update();
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
MaximaExtractionFilterType::OutputImageType::Pointer itkImg = filter->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_TensorImageNodes.at(0)->GetName().c_str());
name += "_PrincipalDirection";
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
DataNode::Pointer node2 = DataNode::New();
node2->SetData(image2);
QString name(m_TensorImageNodes.at(0)->GetName().c_str());
name += "_NumDirections";
node2->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node2);
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
// directions->SetGeometry(geometry);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_TensorImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
template<int shOrder>
void QmitkOdfMaximaExtractionView::StartMaximaExtraction()
{
typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
switch (m_Controls->m_ToolkitBox->currentIndex())
{
case 0:
filter->SetToolkit(MaximaExtractionFilterType::FSL);
break;
case 1:
filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
break;
default:
filter->SetToolkit(MaximaExtractionFilterType::FSL);
}
mitk::Geometry3D::Pointer geometry;
try{
Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
typedef ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
typename CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
filter->SetInput(caster->GetOutput());
geometry = img->GetGeometry();
}
catch(itk::ExceptionObject &e)
{
MITK_INFO << "wrong image type: " << e.what();
throw;
}
filter->SetAngularThreshold(cos((float)m_Controls->m_AngularThreshold->value()*M_PI/180));
filter->SetClusteringThreshold(cos((float)m_Controls->m_ClusteringAngleBox->value()*M_PI/180));
filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
filter->SetAbsolutePeakThreshold(m_Controls->m_AbsoluteThresholdBox->value());
if (!m_BinaryImageNodes.empty())
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
CastToItkImage<ItkUcharImgType>(mitkMaskImg, itkMaskImage);
filter->SetMaskImage(itkMaskImage);
}
switch (m_Controls->m_NormalizationBox->currentIndex())
{
case 0:
filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
break;
case 1:
filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
break;
case 2:
filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
break;
}
filter->Update();
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
typedef typename MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
typename ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
typename MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
+ node->SetVisibility(false);
GetDataStorage()->Add(node);
}
}
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
DataNode::Pointer node2 = DataNode::New();
node2->SetData(image2);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_NumDirections";
node2->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node2);
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
// directions->SetGeometry(geometry);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
void QmitkOdfMaximaExtractionView::StartFiniteDiff()
{
if (m_ImageNodes.empty())
return;
switch (m_Controls->m_ShOrderBox->currentIndex())
{
case 0:
StartMaximaExtraction<2>();
break;
case 1:
StartMaximaExtraction<4>();
break;
case 2:
StartMaximaExtraction<6>();
break;
case 3:
StartMaximaExtraction<8>();
break;
case 4:
StartMaximaExtraction<10>();
break;
case 5:
StartMaximaExtraction<12>();
break;
}
}
void QmitkOdfMaximaExtractionView::GenerateDataFromDwi()
{
typedef itk::OdfMaximaExtractionFilter< float > MaximaExtractionFilterType;
MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
mitk::Geometry3D::Pointer geometry;
if (!m_ImageNodes.empty())
{
try{
Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
typedef ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
filter->SetShCoeffImage(caster->GetOutput());
geometry = img->GetGeometry();
}
catch(itk::ExceptionObject &e)
{
MITK_INFO << "wrong image type: " << e.what();
return;
}
}
else
return;
filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
if (!m_BinaryImageNodes.empty())
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
CastToItkImage<ItkUcharImgType>(mitkMaskImg, itkMaskImage);
filter->SetMaskImage(itkMaskImage);
}
switch (m_Controls->m_NormalizationBox->currentIndex())
{
case 0:
filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
break;
case 1:
filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
break;
case 2:
filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
break;
}
filter->GenerateData();
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
typedef MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
}
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(image2);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_NumDirections";
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
// directions->SetGeometry(geometry);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
void QmitkOdfMaximaExtractionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkOdfMaximaExtractionView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkOdfMaximaExtractionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
m_BinaryImageNodes.clear();
m_ImageNodes.clear();
m_TensorImageNodes.clear();
// iterate all selected objects, adjust warning visibility
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if ( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
{
m_TensorImageNodes.push_back(node);
}
else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
m_BinaryImageNodes.push_back(node);
else
m_ImageNodes.push_back(node);
}
}
UpdateGui();
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
index 0287b21615..6a20c6cd88 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
@@ -1,2148 +1,2148 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkPartialVolumeAnalysisView.h"
#include <limits>
#include <qlabel.h>
#include <qspinbox.h>
#include <qpushbutton.h>
#include <qcheckbox.h>
#include <qgroupbox.h>
#include <qradiobutton.h>
#include <qlineedit.h>
#include <qclipboard.h>
#include <qfiledialog.h>
#include <berryIEditorPart.h>
#include <berryIWorkbenchPage.h>
#include <berryPlatform.h>
#include "QmitkStdMultiWidget.h"
#include "QmitkStdMultiWidgetEditor.h"
#include "QmitkSliderNavigatorWidget.h"
#include <QMessageBox>
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateOr.h"
#include "mitkImageTimeSelector.h"
#include "mitkProperties.h"
#include "mitkProgressBar.h"
#include "mitkImageCast.h"
#include "mitkImageToItk.h"
#include "mitkITKImageImport.h"
#include "mitkDataNodeObject.h"
#include "mitkNodePredicateData.h"
#include "mitkPlanarFigureInteractor.h"
#include "mitkGlobalInteraction.h"
#include "mitkTensorImage.h"
#include "mitkPlanarCircle.h"
#include "mitkPlanarRectangle.h"
#include "mitkPlanarPolygon.h"
#include "mitkPartialVolumeAnalysisClusteringCalculator.h"
#include "mitkDiffusionImage.h"
#include <itkVectorImage.h>
#include "itkTensorDerivedMeasurementsFilter.h"
#include "itkDiffusionTensor3D.h"
#include "itkCartesianToPolarVectorImageFilter.h"
#include "itkPolarToCartesianVectorImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkMaskImageFilter.h"
#include "itkCastImageFilter.h"
#include "itkImageMomentsCalculator.h"
#include <itkResampleImageFilter.h>
#include <itkGaussianInterpolateImageFunction.h>
#include <itkNearestNeighborInterpolateImageFunction.h>
#include <vnl/vnl_vector.h>
#define _USE_MATH_DEFINES
#include <math.h>
#define PVA_PI M_PI
const std::string QmitkPartialVolumeAnalysisView::VIEW_ID =
"org.mitk.views.partialvolumeanalysisview";
class QmitkRequestStatisticsUpdateEvent : public QEvent
{
public:
enum Type
{
StatisticsUpdateRequest = QEvent::MaxUser - 1025
};
QmitkRequestStatisticsUpdateEvent()
: QEvent( (QEvent::Type) StatisticsUpdateRequest ) {};
};
typedef itk::Image<short, 3> ImageType;
typedef itk::Image<float, 3> FloatImageType;
typedef itk::Image<itk::Vector<float,3>, 3> VectorImageType;
inline bool my_isnan(float x)
{
volatile float d = x;
if(d!=d)
return true;
if(d==d)
return false;
return d != d;
}
QmitkPartialVolumeAnalysisView::QmitkPartialVolumeAnalysisView(QObject * /*parent*/, const char * /*name*/)
: //QmitkFunctionality(),
m_Controls( NULL ),
m_TimeStepperAdapter( NULL ),
m_MeasurementInfoRenderer(0),
m_MeasurementInfoAnnotation(0),
m_SelectedImageNodes( ),
m_SelectedImage( NULL ),
m_SelectedMaskNode( NULL ),
m_SelectedImageMask( NULL ),
m_SelectedPlanarFigureNodes(0),
m_SelectedPlanarFigure( NULL ),
m_IsTensorImage(false),
m_FAImage(0),
m_RDImage(0),
m_ADImage(0),
m_MDImage(0),
m_CAImage(0),
// m_DirectionImage(0),
m_DirectionComp1Image(0),
m_DirectionComp2Image(0),
m_AngularErrorImage(0),
m_SelectedRenderWindow(NULL),
m_LastRenderWindow(NULL),
m_ImageObserverTag( -1 ),
m_ImageMaskObserverTag( -1 ),
m_PlanarFigureObserverTag( -1 ),
m_CurrentStatisticsValid( false ),
m_StatisticsUpdatePending( false ),
m_GaussianSigmaChangedSliding(false),
m_NumberBinsSliding(false),
m_UpsamplingChangedSliding(false),
m_ClusteringResult(NULL),
m_EllipseCounter(0),
m_RectangleCounter(0),
m_PolygonCounter(0),
m_CurrentFigureNodeInitialized(false),
m_QuantifyClass(2),
m_IconTexOFF(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntOFFIcon.png")),
m_IconTexON(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntONIcon.png")),
m_TexIsOn(true),
m_Visible(false)
{
}
QmitkPartialVolumeAnalysisView::~QmitkPartialVolumeAnalysisView()
{
if ( m_SelectedImage.IsNotNull() )
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
if ( m_SelectedImageMask.IsNotNull() )
m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
if ( m_SelectedPlanarFigure.IsNotNull() )
{
m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
}
this->GetDataStorage()->AddNodeEvent -= mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage );
m_SelectedPlanarFigureNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
m_SelectedPlanarFigureNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
m_SelectedPlanarFigureNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
m_SelectedImageNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
m_SelectedImageNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
m_SelectedImageNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
}
void QmitkPartialVolumeAnalysisView::CreateQtPartControl(QWidget *parent)
{
if (m_Controls == NULL)
{
m_Controls = new Ui::QmitkPartialVolumeAnalysisViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
}
SetHistogramVisibility();
m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
m_Controls->m_SimilarAnglesFrame->setVisible(false);
m_Controls->m_SimilarAnglesLabel->setVisible(false);
vtkTextProperty *textProp = vtkTextProperty::New();
textProp->SetColor(1.0, 1.0, 1.0);
m_MeasurementInfoAnnotation = vtkCornerAnnotation::New();
m_MeasurementInfoAnnotation->SetMaximumFontSize(12);
m_MeasurementInfoAnnotation->SetTextProperty(textProp);
m_MeasurementInfoRenderer = vtkRenderer::New();
m_MeasurementInfoRenderer->AddActor(m_MeasurementInfoAnnotation);
m_SelectedPlanarFigureNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
m_SelectedPlanarFigureNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
m_SelectedPlanarFigureNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
m_SelectedPlanarFigureNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
m_SelectedImageNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
m_SelectedImageNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
m_SelectedImageNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
m_SelectedImageNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
this->GetDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage ) );
Select(NULL,true,true);
SetAdvancedVisibility();
}
void QmitkPartialVolumeAnalysisView::SetHistogramVisibility()
{
m_Controls->m_HistogramWidget->setVisible(m_Controls->m_DisplayHistogramCheckbox->isChecked());
}
void QmitkPartialVolumeAnalysisView::SetAdvancedVisibility()
{
m_Controls->frame_7->setVisible(m_Controls->m_AdvancedCheckbox->isChecked());
}
void QmitkPartialVolumeAnalysisView::CreateConnections()
{
if ( m_Controls )
{
connect( m_Controls->m_DisplayHistogramCheckbox, SIGNAL( clicked() )
, this, SLOT( SetHistogramVisibility() ) );
connect( m_Controls->m_AdvancedCheckbox, SIGNAL( clicked() )
, this, SLOT( SetAdvancedVisibility() ) );
connect( m_Controls->m_NumberBinsSlider, SIGNAL( sliderReleased () ),
this, SLOT( NumberBinsReleasedSlider( ) ) );
connect( m_Controls->m_UpsamplingSlider, SIGNAL( sliderReleased( ) ),
this, SLOT( UpsamplingReleasedSlider( ) ) );
connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( sliderReleased( ) ),
this, SLOT( GaussianSigmaReleasedSlider( ) ) );
connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( sliderReleased( ) ),
this, SLOT( SimilarAnglesReleasedSlider( ) ) );
connect( m_Controls->m_NumberBinsSlider, SIGNAL( valueChanged (int) ),
this, SLOT( NumberBinsChangedSlider( int ) ) );
connect( m_Controls->m_UpsamplingSlider, SIGNAL( valueChanged( int ) ),
this, SLOT( UpsamplingChangedSlider( int ) ) );
connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( valueChanged( int ) ),
this, SLOT( GaussianSigmaChangedSlider( int ) ) );
connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( valueChanged( int ) ),
this, SLOT( SimilarAnglesChangedSlider(int) ) );
connect( m_Controls->m_OpacitySlider, SIGNAL( valueChanged( int ) ),
this, SLOT( OpacityChangedSlider(int) ) );
connect( (QObject*)(m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ToClipBoard()));
connect( m_Controls->m_CircleButton, SIGNAL( clicked() )
, this, SLOT( ActionDrawEllipseTriggered() ) );
connect( m_Controls->m_RectangleButton, SIGNAL( clicked() )
, this, SLOT( ActionDrawRectangleTriggered() ) );
connect( m_Controls->m_PolygonButton, SIGNAL( clicked() )
, this, SLOT( ActionDrawPolygonTriggered() ) );
connect( m_Controls->m_GreenRadio, SIGNAL( clicked(bool) )
, this, SLOT( GreenRadio(bool) ) );
connect( m_Controls->m_PartialVolumeRadio, SIGNAL( clicked(bool) )
, this, SLOT( PartialVolumeRadio(bool) ) );
connect( m_Controls->m_BlueRadio, SIGNAL( clicked(bool) )
, this, SLOT( BlueRadio(bool) ) );
connect( m_Controls->m_AllRadio, SIGNAL( clicked(bool) )
, this, SLOT( AllRadio(bool) ) );
connect( m_Controls->m_EstimateCircle, SIGNAL( clicked() )
, this, SLOT( EstimateCircle() ) );
connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
connect( m_Controls->m_ExportClusteringResultsButton, SIGNAL(clicked()), this, SLOT(ExportClusteringResults()));
}
}
void QmitkPartialVolumeAnalysisView::ExportClusteringResults()
{
if (m_ClusteringResult.IsNull() || m_SelectedImage.IsNull())
return;
mitk::Geometry3D* geometry = m_SelectedImage->GetGeometry();
itk::Image< short, 3>::Pointer referenceImage = itk::Image< short, 3>::New();
- mitk::Vector3D newSpacing = geometry->GetSpacing();
+ itk::Vector<double,3> newSpacing = geometry->GetSpacing();
mitk::Point3D newOrigin = geometry->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
newOrigin[0] += bounds.GetElement(0);
newOrigin[1] += bounds.GetElement(2);
newOrigin[2] += bounds.GetElement(4);
itk::Matrix<double, 3, 3> newDirection;
itk::ImageRegion<3> imageRegion;
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
newDirection[j][i] = geometry->GetMatrixColumn(i)[j]/newSpacing[j];
imageRegion.SetSize(0, geometry->GetExtent(0));
imageRegion.SetSize(1, geometry->GetExtent(1));
imageRegion.SetSize(2, geometry->GetExtent(2));
// apply new image parameters
referenceImage->SetSpacing( newSpacing );
referenceImage->SetOrigin( newOrigin );
referenceImage->SetDirection( newDirection );
referenceImage->SetRegions( imageRegion );
referenceImage->Allocate();
typedef itk::Image< float, 3 > OutType;
mitk::Image::Pointer mitkInImage = dynamic_cast<mitk::Image*>(m_ClusteringResult->GetData());
typedef itk::Image< itk::RGBAPixel<unsigned char>, 3 > ItkRgbaImageType;
typedef mitk::ImageToItk< ItkRgbaImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkInImage);
caster->Update();
ItkRgbaImageType::Pointer itkInImage = caster->GetOutput();
typedef itk::ExtractChannelFromRgbaImageFilter< itk::Image< short, 3>, OutType > ExtractionFilterType;
ExtractionFilterType::Pointer filter = ExtractionFilterType::New();
filter->SetInput(itkInImage);
filter->SetChannel(ExtractionFilterType::ALPHA);
filter->SetReferenceImage(referenceImage);
filter->Update();
OutType::Pointer outImg = filter->GetOutput();
mitk::Image::Pointer img = mitk::Image::New(); img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// init data node
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
node->SetName("Clustering Result");
GetDataStorage()->Add(node);
}
void QmitkPartialVolumeAnalysisView::EstimateCircle()
{
typedef itk::Image<unsigned char, 3> SegImageType;
SegImageType::Pointer mask_itk = SegImageType::New();
typedef mitk::ImageToItk<SegImageType> CastType;
CastType::Pointer caster = CastType::New();
caster->SetInput(m_SelectedImageMask);
caster->Update();
typedef itk::ImageMomentsCalculator< SegImageType > MomentsType;
MomentsType::Pointer momentsCalc = MomentsType::New();
momentsCalc->SetImage(caster->GetOutput());
momentsCalc->Compute();
MomentsType::VectorType cog = momentsCalc->GetCenterOfGravity();
MomentsType::MatrixType axes = momentsCalc->GetPrincipalAxes();
MomentsType::VectorType moments = momentsCalc->GetPrincipalMoments();
// moments-coord conversion
// third coordinate min oder max?
// max-min = extent
MomentsType::AffineTransformPointer trafo = momentsCalc->GetPhysicalAxesToPrincipalAxesTransform();
itk::ImageRegionIterator<SegImageType>
itimage(caster->GetOutput(), caster->GetOutput()->GetLargestPossibleRegion());
itimage = itimage.Begin();
double max = -9999999999.0;
double min = 9999999999.0;
while( !itimage.IsAtEnd() )
{
if(itimage.Get())
{
ImageType::IndexType index = itimage.GetIndex();
itk::Point<float,3> point;
caster->GetOutput()->TransformIndexToPhysicalPoint(index,point);
itk::Point<float,3> newPoint;
newPoint = trafo->TransformPoint(point);
if(newPoint[2]<min)
min = newPoint[2];
if(newPoint[2]>max)
max = newPoint[2];
}
++itimage;
}
double extent = max - min;
MITK_DEBUG << "EXTENT = " << extent;
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
double factor = 1000.0;
mitk::FillVector3D(origin, cog[0]-factor*axes[1][0]-factor*axes[2][0],
cog[1]-factor*axes[1][1]-factor*axes[2][1],
cog[2]-factor*axes[1][2]-factor*axes[2][2]);
// mitk::FillVector3D(normal, axis[0][0],axis[0][1],axis[0][2]);
mitk::FillVector3D(bottom, 2*factor*axes[1][0], 2*factor*axes[1][1], 2*factor*axes[1][2]);
mitk::FillVector3D(right, 2*factor*axes[2][0], 2*factor*axes[2][1], 2*factor*axes[2][2]);
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector());
planegeometry->SetOrigin(origin);
double len1 = sqrt(axes[1][0]*axes[1][0] + axes[1][1]*axes[1][1] + axes[1][2]*axes[1][2]);
double len2 = sqrt(axes[2][0]*axes[2][0] + axes[2][1]*axes[2][1] + axes[2][2]*axes[2][2]);
mitk::Point2D point1;
point1[0] = factor*len1;
point1[1] = factor*len2;
mitk::Point2D point2;
point2[0] = factor*len1+extent*.5;
point2[1] = factor*len2;
mitk::PlanarCircle::Pointer circle = mitk::PlanarCircle::New();
circle->SetGeometry2D(planegeometry);
circle->PlaceFigure( point1 );
circle->SetControlPoint(0,point1);
circle->SetControlPoint(1,point2);
//circle->SetCurrentControlPoint( point2 );
mitk::PlanarFigure::PolyLineType polyline = circle->GetPolyLine( 0 );
MITK_DEBUG << "SIZE of planar figure polyline: " << polyline.size();
AddFigureToDataStorage(circle, "Circle");
}
bool QmitkPartialVolumeAnalysisView::AssertDrawingIsPossible(bool checked)
{
if (m_SelectedImageNodes->GetNode().IsNull())
{
checked = false;
this->HandleException("Please select an image!", dynamic_cast<QWidget *>(this->parent()), true);
return false;
}
//this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(false);
return checked;
}
void QmitkPartialVolumeAnalysisView::ActionDrawEllipseTriggered()
{
bool checked = m_Controls->m_CircleButton->isChecked();
if(!this->AssertDrawingIsPossible(checked))
return;
mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
// using PV_ prefix for planar figures from this view
// to distinguish them from that ones created throught the measurement view
this->AddFigureToDataStorage(figure, QString("PV_Circle%1").arg(++m_EllipseCounter));
MITK_DEBUG << "PlanarCircle created ...";
}
void QmitkPartialVolumeAnalysisView::ActionDrawRectangleTriggered()
{
bool checked = m_Controls->m_RectangleButton->isChecked();
if(!this->AssertDrawingIsPossible(checked))
return;
mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
// using PV_ prefix for planar figures from this view
// to distinguish them from that ones created throught the measurement view
this->AddFigureToDataStorage(figure, QString("PV_Rectangle%1").arg(++m_RectangleCounter));
MITK_DEBUG << "PlanarRectangle created ...";
}
void QmitkPartialVolumeAnalysisView::ActionDrawPolygonTriggered()
{
bool checked = m_Controls->m_PolygonButton->isChecked();
if(!this->AssertDrawingIsPossible(checked))
return;
mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
figure->ClosedOn();
// using PV_ prefix for planar figures from this view
// to distinguish them from that ones created throught the measurement view
this->AddFigureToDataStorage(figure, QString("PV_Polygon%1").arg(++m_PolygonCounter));
MITK_DEBUG << "PlanarPolygon created ...";
}
void QmitkPartialVolumeAnalysisView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
const char *propertyKey, mitk::BaseProperty *property )
{
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetName(name.toStdString());
newNode->SetData(figure);
// Add custom property, if available
if ( (propertyKey != NULL) && (property != NULL) )
{
newNode->AddProperty( propertyKey, property );
}
// figure drawn on the topmost layer / image
this->GetDataStorage()->Add(newNode, m_SelectedImageNodes->GetNode() );
QList<mitk::DataNode::Pointer> selectedNodes = this->GetDataManagerSelection();
for(unsigned int i = 0; i < selectedNodes.size(); i++)
{
selectedNodes[i]->SetSelected(false);
}
std::vector<mitk::DataNode *> selectedPFNodes = m_SelectedPlanarFigureNodes->GetNodes();
for(unsigned int i = 0; i < selectedPFNodes.size(); i++)
{
selectedPFNodes[i]->SetSelected(false);
}
newNode->SetSelected(true);
Select(newNode);
}
void QmitkPartialVolumeAnalysisView::PlanarFigureInitialized()
{
if(m_SelectedPlanarFigureNodes->GetNode().IsNull())
return;
m_CurrentFigureNodeInitialized = true;
this->Select(m_SelectedPlanarFigureNodes->GetNode());
m_Controls->m_CircleButton->setChecked(false);
m_Controls->m_RectangleButton->setChecked(false);
m_Controls->m_PolygonButton->setChecked(false);
//this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(true);
this->RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::PlanarFigureFocus(mitk::DataNode* node)
{
mitk::PlanarFigure* _PlanarFigure = 0;
_PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
if (_PlanarFigure)
{
FindRenderWindow(node);
const mitk::PlaneGeometry
* _PlaneGeometry =
dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
// make node visible
if (m_SelectedRenderWindow)
{
mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
m_SelectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
centerP, _PlaneGeometry->GetNormal());
m_SelectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
centerP);
}
}
}
void QmitkPartialVolumeAnalysisView::FindRenderWindow(mitk::DataNode* node)
{
if (node && dynamic_cast<mitk::PlanarFigure*> (node->GetData()))
{
m_SelectedRenderWindow = 0;
bool PlanarFigureInitializedWindow = false;
foreach(QmitkRenderWindow * window, this->GetRenderWindowPart()->GetQmitkRenderWindows().values())
{
if (!m_SelectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, window->GetRenderer()))
{
m_SelectedRenderWindow = window;
}
}
}
}
void QmitkPartialVolumeAnalysisView::OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes)
{
m_Controls->m_InputData->setTitle("Please Select Input Data");
if (!m_Visible)
return;
if ( nodes.empty() )
{
if (m_ClusteringResult.IsNotNull())
{
this->GetDataStorage()->Remove(m_ClusteringResult);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
Select(NULL, true, true);
}
for (int i=0; i<nodes.size(); i++)
Select(nodes.at(i));
}
void QmitkPartialVolumeAnalysisView::Select( mitk::DataNode::Pointer node, bool clearMaskOnFirstArgNULL, bool clearImageOnFirstArgNULL )
{
// Clear any unreferenced images
this->RemoveOrphanImages();
bool somethingChanged = false;
if(node.IsNull())
{
somethingChanged = true;
if(clearMaskOnFirstArgNULL)
{
if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
{
m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
m_ImageMaskObserverTag = -1;
}
if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
{
m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
m_PlanarFigureObserverTag = -1;
}
if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
{
m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
m_InitializedObserverTag = -1;
}
m_SelectedPlanarFigure = NULL;
m_SelectedPlanarFigureNodes->RemoveAllNodes();
m_CurrentFigureNodeInitialized = false;
m_SelectedRenderWindow = 0;
m_SelectedMaskNode = NULL;
m_SelectedImageMask = NULL;
}
if(clearImageOnFirstArgNULL)
{
if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
{
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
m_ImageObserverTag = -1;
}
m_SelectedImageNodes->RemoveAllNodes();
m_SelectedImage = NULL;
m_IsTensorImage = false;
m_FAImage = NULL;
m_RDImage = NULL;
m_ADImage = NULL;
m_MDImage = NULL;
m_CAImage = NULL;
m_DirectionComp1Image = NULL;
m_DirectionComp2Image = NULL;
m_AngularErrorImage = NULL;
m_Controls->m_SimilarAnglesFrame->setVisible(false);
m_Controls->m_SimilarAnglesLabel->setVisible(false);
}
}
else
{
typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
ITKCommandType::Pointer changeListener;
changeListener = ITKCommandType::New();
changeListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate );
// Get selected element
mitk::TensorImage *selectedTensorImage = dynamic_cast< mitk::TensorImage * >( node->GetData() );
mitk::Image *selectedImage = dynamic_cast< mitk::Image * >( node->GetData() );
mitk::PlanarFigure *selectedPlanar = dynamic_cast< mitk::PlanarFigure * >( node->GetData() );
bool isMask = false;
bool isImage = false;
bool isPlanar = false;
bool isTensorImage = false;
if (selectedTensorImage != NULL)
{
isTensorImage = true;
}
else if(selectedImage != NULL)
{
node->GetPropertyValue("binary", isMask);
isImage = !isMask;
}
else if ( (selectedPlanar != NULL) )
{
isPlanar = true;
}
// image
if(isImage && selectedImage->GetDimension()==3)
{
if(selectedImage != m_SelectedImage.GetPointer())
{
somethingChanged = true;
if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
{
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
m_ImageObserverTag = -1;
}
*m_SelectedImageNodes = node;
m_SelectedImage = selectedImage;
m_IsTensorImage = false;
m_FAImage = NULL;
m_RDImage = NULL;
m_ADImage = NULL;
m_MDImage = NULL;
m_CAImage = NULL;
m_DirectionComp1Image = NULL;
m_DirectionComp2Image = NULL;
m_AngularErrorImage = NULL;
// Add change listeners to selected objects
m_ImageObserverTag = m_SelectedImage->AddObserver(
itk::ModifiedEvent(), changeListener );
m_Controls->m_SimilarAnglesFrame->setVisible(false);
m_Controls->m_SimilarAnglesLabel->setVisible(false);
m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
}
}
//planar
if(isPlanar)
{
if(selectedPlanar != m_SelectedPlanarFigure.GetPointer())
{
MITK_DEBUG << "Planar selection changed";
somethingChanged = true;
// Possibly previous change listeners
if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
{
m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
m_PlanarFigureObserverTag = -1;
}
if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
{
m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
m_InitializedObserverTag = -1;
}
m_SelectedPlanarFigure = selectedPlanar;
*m_SelectedPlanarFigureNodes = node;
m_CurrentFigureNodeInitialized = selectedPlanar->IsPlaced();
m_SelectedMaskNode = NULL;
m_SelectedImageMask = NULL;
m_PlanarFigureObserverTag = m_SelectedPlanarFigure->AddObserver(
mitk::EndInteractionPlanarFigureEvent(), changeListener );
if(!m_CurrentFigureNodeInitialized)
{
typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
ITKCommandType::Pointer initializationCommand;
initializationCommand = ITKCommandType::New();
// set the callback function of the member command
initializationCommand->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::PlanarFigureInitialized );
// add an observer
m_InitializedObserverTag = selectedPlanar->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
}
m_Controls->m_SelectedMaskLabel->setText( m_SelectedPlanarFigureNodes->GetNode()->GetName().c_str() );
PlanarFigureFocus(node);
}
}
//mask
this->m_Controls->m_EstimateCircle->setEnabled(isMask && selectedImage->GetDimension()==3);
if(isMask && selectedImage->GetDimension()==3)
{
if(selectedImage != m_SelectedImage.GetPointer())
{
somethingChanged = true;
if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
{
m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
m_ImageMaskObserverTag = -1;
}
m_SelectedMaskNode = node;
m_SelectedImageMask = selectedImage;
m_SelectedPlanarFigure = NULL;
m_SelectedPlanarFigureNodes->RemoveAllNodes();
m_ImageMaskObserverTag = m_SelectedImageMask->AddObserver(
itk::ModifiedEvent(), changeListener );
m_Controls->m_SelectedMaskLabel->setText( m_SelectedMaskNode->GetName().c_str() );
}
}
//tensor image
if(isTensorImage && selectedTensorImage->GetDimension()==3)
{
if(selectedImage != m_SelectedImage.GetPointer())
{
somethingChanged = true;
if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
{
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
m_ImageObserverTag = -1;
}
*m_SelectedImageNodes = node;
m_SelectedImage = selectedImage;
m_IsTensorImage = true;
ExtractTensorImages(selectedImage);
// Add change listeners to selected objects
m_ImageObserverTag = m_SelectedImage->AddObserver(
itk::ModifiedEvent(), changeListener );
m_Controls->m_SimilarAnglesFrame->setVisible(true);
m_Controls->m_SimilarAnglesLabel->setVisible(true);
m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
}
}
}
if(somethingChanged)
{
this->SetMeasurementInfoToRenderWindow("");
if(m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull() )
{
m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_ResampleOptionsFrame->setEnabled(false);
m_Controls->m_HistogramWidget->setEnabled(false);
m_Controls->m_ClassSelector->setEnabled(false);
m_Controls->m_DisplayHistogramCheckbox->setEnabled(false);
m_Controls->m_AdvancedCheckbox->setEnabled(false);
m_Controls->frame_7->setEnabled(false);
}
else
{
m_Controls->m_ResampleOptionsFrame->setEnabled(true);
m_Controls->m_HistogramWidget->setEnabled(true);
m_Controls->m_ClassSelector->setEnabled(true);
m_Controls->m_DisplayHistogramCheckbox->setEnabled(true);
m_Controls->m_AdvancedCheckbox->setEnabled(true);
m_Controls->frame_7->setEnabled(true);
}
// Clear statistics / histogram GUI if nothing is selected
if ( m_SelectedImage.IsNull() )
{
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
m_Controls->m_OpacityFrame->setEnabled(false);
m_Controls->m_SelectedImageLabel->setText("<font color='red'>mandatory</font>");
}
else
{
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
m_Controls->m_OpacityFrame->setEnabled(true);
}
if( !m_Visible || m_SelectedImage.IsNull()
|| (m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull()) )
{
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_HistogramWidget->ClearItemModel();
m_CurrentStatisticsValid = false;
}
else
{
m_Controls->m_InputData->setTitle("Input Data");
this->RequestStatisticsUpdate();
}
}
}
void QmitkPartialVolumeAnalysisView::ShowClusteringResults()
{
typedef itk::Image<unsigned char, 3> MaskImageType;
mitk::Image::Pointer mask = 0;
MaskImageType::Pointer itkmask = 0;
if(m_IsTensorImage && m_Controls->m_SimilarAnglesSlider->value() != 0)
{
typedef itk::Image<float, 3> AngularErrorImageType;
typedef mitk::ImageToItk<AngularErrorImageType> CastType;
CastType::Pointer caster = CastType::New();
caster->SetInput(m_AngularErrorImage);
caster->Update();
typedef itk::BinaryThresholdImageFilter< AngularErrorImageType, MaskImageType > ThreshType;
ThreshType::Pointer thresh = ThreshType::New();
thresh->SetUpperThreshold((90-m_Controls->m_SimilarAnglesSlider->value())*(PVA_PI/180.0));
thresh->SetInsideValue(1.0);
thresh->SetInput(caster->GetOutput());
thresh->Update();
itkmask = thresh->GetOutput();
mask = mitk::Image::New();
mask->InitializeByItk(itkmask.GetPointer());
mask->SetVolume(itkmask->GetBufferPointer());
// GetDefaultDataStorage()->Remove(m_newnode);
// m_newnode = mitk::DataNode::New();
// m_newnode->SetData(mask);
// m_newnode->SetName("masking node");
// m_newnode->SetIntProperty( "layer", 1002 );
// GetDefaultDataStorage()->Add(m_newnode, m_SelectedImageNodes->GetNode());
}
mitk::Image::Pointer clusteredImage;
ClusteringType::Pointer clusterer = ClusteringType::New();
if(m_QuantifyClass==3)
{
if(m_IsTensorImage)
{
double *green_fa, *green_rd, *green_ad, *green_md;
//double *greengray_fa, *greengray_rd, *greengray_ad, *greengray_md;
double *gray_fa, *gray_rd, *gray_ad, *gray_md;
//double *redgray_fa, *redgray_rd, *redgray_ad, *redgray_md;
double *red_fa, *red_rd, *red_ad, *red_md;
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
mitk::Image::ConstPointer imgToCluster = tmpImg;
red_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
green_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
gray_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
mitk::Image::ConstPointer imgToCluster3 = tmpImg;
red_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
green_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
gray_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
mitk::Image::ConstPointer imgToCluster4 = tmpImg;
red_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
green_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
gray_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
mitk::Image::ConstPointer imgToCluster5 = tmpImg;
red_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
green_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
gray_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
// clipboard
QString clipboardText("FA\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
clipboardText = clipboardText
.arg(red_fa[0]).arg(red_fa[1])
.arg(gray_fa[0]).arg(gray_fa[1])
.arg(green_fa[0]).arg(green_fa[1]);
QString clipboardText3("RD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
clipboardText3 = clipboardText3
.arg(red_rd[0]).arg(red_rd[1])
.arg(gray_rd[0]).arg(gray_rd[1])
.arg(green_rd[0]).arg(green_rd[1]);
QString clipboardText4("AD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
clipboardText4 = clipboardText4
.arg(red_ad[0]).arg(red_ad[1])
.arg(gray_ad[0]).arg(gray_ad[1])
.arg(green_ad[0]).arg(green_ad[1]);
QString clipboardText5("MD\t%1\t%2\t\t%3\t%4\t\t%5\t%6");
clipboardText5 = clipboardText5
.arg(red_md[0]).arg(red_md[1])
.arg(gray_md[0]).arg(gray_md[1])
.arg(green_md[0]).arg(green_md[1]);
QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
// now paint infos also on renderwindow
QString plainInfoText("%1 %2 %3 \n");
plainInfoText = plainInfoText
.arg("Red ", 20)
.arg("Gray ", 20)
.arg("Green", 20);
QString plainInfoText0("FA:%1 ± %2%3 ± %4%5 ± %6\n");
plainInfoText0 = plainInfoText0
.arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(gray_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(gray_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(green_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(green_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText3("RDx10³:%1 ± %2%3 ± %4%5 ± %6\n");
plainInfoText3 = plainInfoText3
.arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * gray_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * green_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText4("ADx10³:%1 ± %2%3 ± %4%5 ± %6\n");
plainInfoText4 = plainInfoText4
.arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * gray_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * green_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText5("MDx10³:%1 ± %2%3 ± %4%5 ± %6");
plainInfoText5 = plainInfoText5
.arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * gray_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * green_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
}
else
{
double* green;
double* gray;
double* red;
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
mitk::Image::ConstPointer imgToCluster = tmpImg;
red = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r);
green = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g);
gray = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b);
// clipboard
QString clipboardText("%1\t%2\t\t%3\t%4\t\t%5\t%6");
clipboardText = clipboardText.arg(red[0]).arg(red[1])
.arg(gray[0]).arg(gray[1])
.arg(green[0]).arg(green[1]);
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
// now paint infos also on renderwindow
QString plainInfoText("Red: %1 ± %2\nGray: %3 ± %4\nGreen: %5 ± %6");
plainInfoText = plainInfoText.arg(red[0]).arg(red[1])
.arg(gray[0]).arg(gray[1])
.arg(green[0]).arg(green[1]);
this->SetMeasurementInfoToRenderWindow(plainInfoText);
}
clusteredImage = m_CurrentRGBClusteringResults->rgb;
}
else
{
if(m_IsTensorImage)
{
double *red_fa, *red_rd, *red_ad, *red_md;
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
mitk::Image::ConstPointer imgToCluster = tmpImg;
red_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
mitk::Image::ConstPointer imgToCluster3 = tmpImg;
red_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentPerformClusteringResults->clusteredImage, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
mitk::Image::ConstPointer imgToCluster4 = tmpImg;
red_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentPerformClusteringResults->clusteredImage, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
mitk::Image::ConstPointer imgToCluster5 = tmpImg;
red_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentPerformClusteringResults->clusteredImage, mask);
// clipboard
QString clipboardText("FA\t%1\t%2\t");
clipboardText = clipboardText
.arg(red_fa[0]).arg(red_fa[1]);
QString clipboardText3("RD\t%1\t%2\t");
clipboardText3 = clipboardText3
.arg(red_rd[0]).arg(red_rd[1]);
QString clipboardText4("AD\t%1\t%2\t");
clipboardText4 = clipboardText4
.arg(red_ad[0]).arg(red_ad[1]);
QString clipboardText5("MD\t%1\t%2\t");
clipboardText5 = clipboardText5
.arg(red_md[0]).arg(red_md[1]);
QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
// now paint infos also on renderwindow
QString plainInfoText("%1 \n");
plainInfoText = plainInfoText
.arg("Red ", 20);
QString plainInfoText0("FA:%1 ± %2\n");
plainInfoText0 = plainInfoText0
.arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText3("RDx10³:%1 ± %2\n");
plainInfoText3 = plainInfoText3
.arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText4("ADx10³:%1 ± %2\n");
plainInfoText4 = plainInfoText4
.arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText5("MDx10³:%1 ± %2");
plainInfoText5 = plainInfoText5
.arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
}
else
{
double* quant;
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
mitk::Image::ConstPointer imgToCluster = tmpImg;
quant = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage);
// clipboard
QString clipboardText("%1\t%2");
clipboardText = clipboardText.arg(quant[0]).arg(quant[1]);
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
// now paint infos also on renderwindow
QString plainInfoText("Measurement: %1 ± %2");
plainInfoText = plainInfoText.arg(quant[0]).arg(quant[1]);
this->SetMeasurementInfoToRenderWindow(plainInfoText);
}
clusteredImage = m_CurrentPerformClusteringResults->displayImage;
}
if(mask.IsNotNull())
{
typedef itk::Image<itk::RGBAPixel<unsigned char>,3> RGBImageType;
typedef mitk::ImageToItk<RGBImageType> ClusterCasterType;
ClusterCasterType::Pointer clCaster = ClusterCasterType::New();
clCaster->SetInput(clusteredImage);
clCaster->Update();
clCaster->GetOutput();
typedef itk::MaskImageFilter< RGBImageType, MaskImageType, RGBImageType > MaskType;
MaskType::Pointer masker = MaskType::New();
masker->SetInput1(clCaster->GetOutput());
masker->SetInput2(itkmask);
masker->Update();
clusteredImage = mitk::Image::New();
clusteredImage->InitializeByItk(masker->GetOutput());
clusteredImage->SetVolume(masker->GetOutput()->GetBufferPointer());
}
if(m_ClusteringResult.IsNotNull())
{
this->GetDataStorage()->Remove(m_ClusteringResult);
}
m_ClusteringResult = mitk::DataNode::New();
m_ClusteringResult->SetBoolProperty("helper object", true);
m_ClusteringResult->SetIntProperty( "layer", 1000 );
m_ClusteringResult->SetBoolProperty("texture interpolation", m_TexIsOn);
m_ClusteringResult->SetData(clusteredImage);
m_ClusteringResult->SetName("Clusterprobs");
this->GetDataStorage()->Add(m_ClusteringResult, m_SelectedImageNodes->GetNode());
if(m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
{
m_SelectedPlanarFigureNodes->GetNode()->SetIntProperty( "layer", 1001 );
}
this->RequestRenderWindowUpdate();
}
void QmitkPartialVolumeAnalysisView::UpdateStatistics()
{
if(!m_CurrentFigureNodeInitialized && m_SelectedPlanarFigure.IsNotNull())
{
MITK_DEBUG << "Selected planar figure not initialized. No stats calculation performed.";
return;
}
// Remove any cached images that are no longer referenced elsewhere
this->RemoveOrphanImages();
QmitkStdMultiWidget *multiWidget = 0;
QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
if(multiWidgetEdit){
multiWidget = multiWidgetEdit->GetStdMultiWidget();
}
if ( multiWidget == NULL )
{
return;
}
if ( m_SelectedImage.IsNotNull() )
{
// Check if a the selected image is a multi-channel image. If yes, statistics
// cannot be calculated currently.
if ( !m_IsTensorImage && m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
{
QMessageBox::information( NULL, "Warning", "Non-tensor multi-component images not supported.");
m_Controls->m_HistogramWidget->ClearItemModel();
m_CurrentStatisticsValid = false;
return;
}
// Retrieve HistogramStatisticsCalculator from has map (or create a new one
// for this image if non-existant)
PartialVolumeAnalysisMapType::iterator it =
m_PartialVolumeAnalysisMap.find( m_SelectedImage );
if ( it != m_PartialVolumeAnalysisMap.end() )
{
m_CurrentStatisticsCalculator = it->second;
}
else
{
m_CurrentStatisticsCalculator = mitk::PartialVolumeAnalysisHistogramCalculator::New();
m_CurrentStatisticsCalculator->SetPlanarFigureThickness(m_Controls->m_PlanarFiguresThickness->value());
if(m_IsTensorImage)
{
m_CurrentStatisticsCalculator->SetImage( m_CAImage );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_FAImage );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp1Image );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp2Image );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_RDImage );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_ADImage );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_MDImage );
}
else
{
m_CurrentStatisticsCalculator->SetImage( m_SelectedImage );
}
m_PartialVolumeAnalysisMap[m_SelectedImage] = m_CurrentStatisticsCalculator;
MITK_DEBUG << "Creating StatisticsCalculator";
}
std::string maskName;
std::string maskType;
unsigned int maskDimension;
if ( m_SelectedImageMask.IsNotNull() )
{
mitk::PixelType pixelType = m_SelectedImageMask->GetPixelType();
- MITK_DEBUG << pixelType.GetItkTypeAsString();
+ MITK_DEBUG << pixelType.GetPixelTypeAsString();
if(pixelType.GetBitsPerComponent() == 16)
{
//convert from short to uchar
typedef itk::Image<short, 3> ShortImageType;
typedef itk::Image<unsigned char, 3> CharImageType;
CharImageType::Pointer charImage;
ShortImageType::Pointer shortImage;
mitk::CastToItkImage(m_SelectedImageMask, shortImage);
typedef itk::CastImageFilter<ShortImageType, CharImageType> ImageCasterType;
ImageCasterType::Pointer caster = ImageCasterType::New();
caster->SetInput( shortImage );
caster->Update();
charImage = caster->GetOutput();
mitk::CastToMitkImage(charImage, m_SelectedImageMask);
}
m_CurrentStatisticsCalculator->SetImageMask( m_SelectedImageMask );
m_CurrentStatisticsCalculator->SetMaskingModeToImage();
maskName = m_SelectedMaskNode->GetName();
maskType = m_SelectedImageMask->GetNameOfClass();
maskDimension = 3;
std::stringstream maskLabel;
maskLabel << maskName;
if ( maskDimension > 0 )
{
maskLabel << " [" << maskDimension << "D " << maskType << "]";
}
m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
}
else if ( m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
{
m_CurrentStatisticsCalculator->SetPlanarFigure( m_SelectedPlanarFigure );
m_CurrentStatisticsCalculator->SetMaskingModeToPlanarFigure();
maskName = m_SelectedPlanarFigureNodes->GetNode()->GetName();
maskType = m_SelectedPlanarFigure->GetNameOfClass();
maskDimension = 2;
}
else
{
m_CurrentStatisticsCalculator->SetMaskingModeToNone();
maskName = "-";
maskType = "";
maskDimension = 0;
}
bool statisticsChanged = false;
bool statisticsCalculationSuccessful = false;
// Initialize progress bar
mitk::ProgressBar::GetInstance()->AddStepsToDo( 100 );
// Install listener for progress events and initialize progress bar
typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
ITKCommandType::Pointer progressListener;
progressListener = ITKCommandType::New();
progressListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::UpdateProgressBar );
unsigned long progressObserverTag = m_CurrentStatisticsCalculator
->AddObserver( itk::ProgressEvent(), progressListener );
ClusteringType::ParamsType *cparams = 0;
ClusteringType::ClusterResultType *cresult = 0;
ClusteringType::HistType *chist = 0;
try
{
m_CurrentStatisticsCalculator->SetNumberOfBins(m_Controls->m_NumberBins->text().toInt());
m_CurrentStatisticsCalculator->SetUpsamplingFactor(m_Controls->m_Upsampling->text().toDouble());
m_CurrentStatisticsCalculator->SetGaussianSigma(m_Controls->m_GaussianSigma->text().toDouble());
// Compute statistics
statisticsChanged =
m_CurrentStatisticsCalculator->ComputeStatistics( );
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
mitk::Image::ConstPointer imgToCluster = tmpImg;
if(imgToCluster.IsNotNull())
{
// perform clustering
const HistogramType *histogram = m_CurrentStatisticsCalculator->GetHistogram( );
if(histogram != NULL)
{
ClusteringType::Pointer clusterer = ClusteringType::New();
clusterer->SetStepsNumIntegration(200);
clusterer->SetMaxIt(1000);
mitk::Image::Pointer pFiberImg;
if(m_QuantifyClass==3)
{
if(m_Controls->m_Quantiles->isChecked())
{
m_CurrentRGBClusteringResults = clusterer->PerformRGBQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
}
else
{
m_CurrentRGBClusteringResults = clusterer->PerformRGBClustering(imgToCluster, histogram);
}
pFiberImg = m_CurrentRGBClusteringResults->rgbChannels->r;
cparams = m_CurrentRGBClusteringResults->params;
cresult = m_CurrentRGBClusteringResults->result;
chist = m_CurrentRGBClusteringResults->hist;
}
else
{
if(m_Controls->m_Quantiles->isChecked())
{
m_CurrentPerformClusteringResults =
clusterer->PerformQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
}
else
{
m_CurrentPerformClusteringResults =
clusterer->PerformClustering(imgToCluster, histogram, m_QuantifyClass);
}
pFiberImg = m_CurrentPerformClusteringResults->clusteredImage;
cparams = m_CurrentPerformClusteringResults->params;
cresult = m_CurrentPerformClusteringResults->result;
chist = m_CurrentPerformClusteringResults->hist;
}
if(m_IsTensorImage)
{
m_AngularErrorImage = clusterer->CaculateAngularErrorImage(
m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1),
m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2),
pFiberImg);
// GetDefaultDataStorage()->Remove(m_newnode2);
// m_newnode2 = mitk::DataNode::New();
// m_newnode2->SetData(m_AngularErrorImage);
// m_newnode2->SetName(("AngularError"));
// m_newnode2->SetIntProperty( "layer", 1003 );
// GetDefaultDataStorage()->Add(m_newnode2, m_SelectedImageNodes->GetNode());
// newnode = mitk::DataNode::New();
// newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1));
// newnode->SetName(("Comp1"));
// GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
// newnode = mitk::DataNode::New();
// newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2));
// newnode->SetName(("Comp2"));
// GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
}
ShowClusteringResults();
}
}
statisticsCalculationSuccessful = true;
}
catch ( const std::runtime_error &e )
{
QMessageBox::information( NULL, "Warning", e.what());
}
catch ( const std::exception &e )
{
MITK_ERROR << "Caught exception: " << e.what();
QMessageBox::information( NULL, "Warning", e.what());
}
m_CurrentStatisticsCalculator->RemoveObserver( progressObserverTag );
// Make sure that progress bar closes
mitk::ProgressBar::GetInstance()->Progress( 100 );
if ( statisticsCalculationSuccessful )
{
if ( statisticsChanged )
{
// Do not show any error messages
m_CurrentStatisticsValid = true;
}
// m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
m_Controls->m_HistogramWidget->SetParameters(
cparams, cresult, chist );
// m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
}
else
{
m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
// Clear statistics and histogram
m_Controls->m_HistogramWidget->ClearItemModel();
m_CurrentStatisticsValid = false;
// If a (non-closed) PlanarFigure is selected, display a line profile widget
if ( m_SelectedPlanarFigure.IsNotNull() )
{
// TODO: enable line profile widget
//m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 1 );
//m_Controls->m_LineProfileWidget->SetImage( m_SelectedImage );
//m_Controls->m_LineProfileWidget->SetPlanarFigure( m_SelectedPlanarFigure );
//m_Controls->m_LineProfileWidget->UpdateItemModelFromPath();
}
}
}
}
void QmitkPartialVolumeAnalysisView::SetMeasurementInfoToRenderWindow(const QString& text)
{
FindRenderWindow(m_SelectedPlanarFigureNodes->GetNode());
if(m_LastRenderWindow != m_SelectedRenderWindow)
{
if(m_LastRenderWindow)
{
QObject::disconnect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
, this, SLOT( OnRenderWindowDelete(QObject*) ) );
}
m_LastRenderWindow = m_SelectedRenderWindow;
if(m_LastRenderWindow)
{
QObject::connect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
, this, SLOT( OnRenderWindowDelete(QObject*) ) );
}
}
if(m_LastRenderWindow && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
{
if (!text.isEmpty())
{
m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->InsertForegroundRenderer(
m_MeasurementInfoRenderer, true);
}
else
{
if (mitk::VtkLayerController::GetInstance(
m_LastRenderWindow->GetRenderWindow()) ->IsRendererInserted(
m_MeasurementInfoRenderer))
mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->RemoveRenderer(
m_MeasurementInfoRenderer);
}
}
else
{
QmitkStdMultiWidget *multiWidget = 0;
QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
if(multiWidgetEdit){
multiWidget = multiWidgetEdit->GetStdMultiWidget();
}
if ( multiWidget == NULL )
{
return;
}
if (!text.isEmpty())
{
m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(
m_MeasurementInfoRenderer, true);
}
else
{
if (mitk::VtkLayerController::GetInstance(
multiWidget->GetRenderWindow1()->GetRenderWindow()) ->IsRendererInserted(
m_MeasurementInfoRenderer))
mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer(
m_MeasurementInfoRenderer);
}
}
}
void QmitkPartialVolumeAnalysisView::UpdateProgressBar()
{
mitk::ProgressBar::GetInstance()->Progress();
}
void QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate()
{
if ( !m_StatisticsUpdatePending )
{
QApplication::postEvent( this, new QmitkRequestStatisticsUpdateEvent );
m_StatisticsUpdatePending = true;
}
}
void QmitkPartialVolumeAnalysisView::RemoveOrphanImages()
{
PartialVolumeAnalysisMapType::iterator it = m_PartialVolumeAnalysisMap.begin();
while ( it != m_PartialVolumeAnalysisMap.end() )
{
mitk::Image *image = it->first;
mitk::PartialVolumeAnalysisHistogramCalculator *calculator = it->second;
++it;
mitk::NodePredicateData::Pointer hasImage = mitk::NodePredicateData::New( image );
if ( this->GetDataStorage()->GetNode( hasImage ) == NULL )
{
if ( m_SelectedImage == image )
{
m_SelectedImage = NULL;
m_SelectedImageNodes->RemoveAllNodes();
}
if ( m_CurrentStatisticsCalculator == calculator )
{
m_CurrentStatisticsCalculator = NULL;
}
m_PartialVolumeAnalysisMap.erase( image );
it = m_PartialVolumeAnalysisMap.begin();
}
}
}
void QmitkPartialVolumeAnalysisView::ExtractTensorImages(
mitk::Image::Pointer tensorimage)
{
typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
typedef mitk::ImageToItk<TensorImageType> CastType;
CastType::Pointer caster = CastType::New();
caster->SetInput(tensorimage);
caster->Update();
TensorImageType::Pointer image = caster->GetOutput();
typedef itk::TensorDerivedMeasurementsFilter<float> MeasurementsType;
MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::FA);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer fa = measurementsCalculator->GetOutput();
m_FAImage = mitk::Image::New();
m_FAImage->InitializeByItk(fa.GetPointer());
m_FAImage->SetVolume(fa->GetBufferPointer());
// mitk::DataNode::Pointer node = mitk::DataNode::New();
// node->SetData(m_FAImage);
// GetDefaultDataStorage()->Add(node);
measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::CA);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer ca = measurementsCalculator->GetOutput();
m_CAImage = mitk::Image::New();
m_CAImage->InitializeByItk(ca.GetPointer());
m_CAImage->SetVolume(ca->GetBufferPointer());
// node = mitk::DataNode::New();
// node->SetData(m_CAImage);
// GetDefaultDataStorage()->Add(node);
measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::RD);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer rd = measurementsCalculator->GetOutput();
m_RDImage = mitk::Image::New();
m_RDImage->InitializeByItk(rd.GetPointer());
m_RDImage->SetVolume(rd->GetBufferPointer());
// node = mitk::DataNode::New();
// node->SetData(m_CAImage);
// GetDefaultDataStorage()->Add(node);
measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::AD);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer ad = measurementsCalculator->GetOutput();
m_ADImage = mitk::Image::New();
m_ADImage->InitializeByItk(ad.GetPointer());
m_ADImage->SetVolume(ad->GetBufferPointer());
// node = mitk::DataNode::New();
// node->SetData(m_CAImage);
// GetDefaultDataStorage()->Add(node);
measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::RA);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer md = measurementsCalculator->GetOutput();
m_MDImage = mitk::Image::New();
m_MDImage->InitializeByItk(md.GetPointer());
m_MDImage->SetVolume(md->GetBufferPointer());
// node = mitk::DataNode::New();
// node->SetData(m_CAImage);
// GetDefaultDataStorage()->Add(node);
typedef DirectionsFilterType::OutputImageType DirImageType;
DirectionsFilterType::Pointer dirFilter = DirectionsFilterType::New();
dirFilter->SetInput(image );
dirFilter->Update();
itk::ImageRegionIterator<DirImageType>
itd(dirFilter->GetOutput(), dirFilter->GetOutput()->GetLargestPossibleRegion());
itd = itd.Begin();
while( !itd.IsAtEnd() )
{
DirImageType::PixelType direction = itd.Get();
direction[0] = fabs(direction[0]);
direction[1] = fabs(direction[1]);
direction[2] = fabs(direction[2]);
itd.Set(direction);
++itd;
}
typedef itk::CartesianToPolarVectorImageFilter<
DirImageType, DirImageType, true> C2PFilterType;
C2PFilterType::Pointer cpFilter = C2PFilterType::New();
cpFilter->SetInput(dirFilter->GetOutput());
cpFilter->Update();
DirImageType::Pointer dir = cpFilter->GetOutput();
typedef itk::Image<float, 3> CompImageType;
CompImageType::Pointer comp1 = CompImageType::New();
comp1->SetSpacing( dir->GetSpacing() ); // Set the image spacing
comp1->SetOrigin( dir->GetOrigin() ); // Set the image origin
comp1->SetDirection( dir->GetDirection() ); // Set the image direction
comp1->SetRegions( dir->GetLargestPossibleRegion() );
comp1->Allocate();
CompImageType::Pointer comp2 = CompImageType::New();
comp2->SetSpacing( dir->GetSpacing() ); // Set the image spacing
comp2->SetOrigin( dir->GetOrigin() ); // Set the image origin
comp2->SetDirection( dir->GetDirection() ); // Set the image direction
comp2->SetRegions( dir->GetLargestPossibleRegion() );
comp2->Allocate();
itk::ImageRegionConstIterator<DirImageType>
it(dir, dir->GetLargestPossibleRegion());
itk::ImageRegionIterator<CompImageType>
it1(comp1, comp1->GetLargestPossibleRegion());
itk::ImageRegionIterator<CompImageType>
it2(comp2, comp2->GetLargestPossibleRegion());
it = it.Begin();
it1 = it1.Begin();
it2 = it2.Begin();
while( !it.IsAtEnd() )
{
it1.Set(it.Get()[1]);
it2.Set(it.Get()[2]);
++it;
++it1;
++it2;
}
m_DirectionComp1Image = mitk::Image::New();
m_DirectionComp1Image->InitializeByItk(comp1.GetPointer());
m_DirectionComp1Image->SetVolume(comp1->GetBufferPointer());
m_DirectionComp2Image = mitk::Image::New();
m_DirectionComp2Image->InitializeByItk(comp2.GetPointer());
m_DirectionComp2Image->SetVolume(comp2->GetBufferPointer());
}
void QmitkPartialVolumeAnalysisView::OnRenderWindowDelete(QObject * obj)
{
if(obj == m_LastRenderWindow)
m_LastRenderWindow = 0;
if(obj == m_SelectedRenderWindow)
m_SelectedRenderWindow = 0;
}
bool QmitkPartialVolumeAnalysisView::event( QEvent *event )
{
if ( event->type() == (QEvent::Type) QmitkRequestStatisticsUpdateEvent::StatisticsUpdateRequest )
{
// Update statistics
m_StatisticsUpdatePending = false;
this->UpdateStatistics();
return true;
}
return false;
}
bool QmitkPartialVolumeAnalysisView::IsExclusiveFunctionality() const
{
return true;
}
void QmitkPartialVolumeAnalysisView::Activated()
{
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
mitk::DataNode* node = 0;
mitk::PlanarFigure* figure = 0;
mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
// finally add all nodes to the model
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
; it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
if(figure)
{
figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
}
}
}
void QmitkPartialVolumeAnalysisView::Deactivated()
{
}
void QmitkPartialVolumeAnalysisView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer reference)
{
this->SetMeasurementInfoToRenderWindow("");
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
mitk::DataNode* node = 0;
mitk::PlanarFigure* figure = 0;
mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
// finally add all nodes to the model
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
; it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
if(figure)
{
figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
if(figureInteractor)
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
}
}
}
void QmitkPartialVolumeAnalysisView::Hidden()
{
if (m_ClusteringResult.IsNotNull())
{
this->GetDataStorage()->Remove(m_ClusteringResult);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
Select(NULL, true, true);
m_Visible = false;
}
void QmitkPartialVolumeAnalysisView::Visible()
{
m_Visible = true;
berry::IWorkbenchPart::Pointer bla;
if (!this->GetCurrentSelection().empty())
{
this->OnSelectionChanged(bla, this->GetCurrentSelection());
}
else
{
this->OnSelectionChanged(bla, this->GetDataManagerSelection());
}
}
void QmitkPartialVolumeAnalysisView::SetFocus()
{
}
void QmitkPartialVolumeAnalysisView::GreenRadio(bool checked)
{
if(checked)
{
m_Controls->m_PartialVolumeRadio->setChecked(false);
m_Controls->m_BlueRadio->setChecked(false);
m_Controls->m_AllRadio->setChecked(false);
m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
}
m_QuantifyClass = 0;
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::PartialVolumeRadio(bool checked)
{
if(checked)
{
m_Controls->m_GreenRadio->setChecked(false);
m_Controls->m_BlueRadio->setChecked(false);
m_Controls->m_AllRadio->setChecked(false);
m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
}
m_QuantifyClass = 1;
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::BlueRadio(bool checked)
{
if(checked)
{
m_Controls->m_PartialVolumeRadio->setChecked(false);
m_Controls->m_GreenRadio->setChecked(false);
m_Controls->m_AllRadio->setChecked(false);
m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
}
m_QuantifyClass = 2;
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::AllRadio(bool checked)
{
if(checked)
{
m_Controls->m_BlueRadio->setChecked(false);
m_Controls->m_PartialVolumeRadio->setChecked(false);
m_Controls->m_GreenRadio->setChecked(false);
m_Controls->m_ExportClusteringResultsButton->setEnabled(false);
}
m_QuantifyClass = 3;
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::NumberBinsChangedSlider(int v )
{
m_Controls->m_NumberBins->setText(QString("%1").arg(m_Controls->m_NumberBinsSlider->value()*5.0));
}
void QmitkPartialVolumeAnalysisView::UpsamplingChangedSlider( int v)
{
m_Controls->m_Upsampling->setText(QString("%1").arg(m_Controls->m_UpsamplingSlider->value()/10.0));
}
void QmitkPartialVolumeAnalysisView::GaussianSigmaChangedSlider(int v )
{
m_Controls->m_GaussianSigma->setText(QString("%1").arg(m_Controls->m_GaussianSigmaSlider->value()/100.0));
}
void QmitkPartialVolumeAnalysisView::SimilarAnglesChangedSlider(int v )
{
m_Controls->m_SimilarAngles->setText(QString("%1°").arg(90-m_Controls->m_SimilarAnglesSlider->value()));
ShowClusteringResults();
}
void QmitkPartialVolumeAnalysisView::OpacityChangedSlider(int v )
{
if(m_SelectedImageNodes->GetNode().IsNotNull())
{
float opacImag = 1.0f-(v-5)/5.0f;
opacImag = opacImag < 0 ? 0 : opacImag;
m_SelectedImageNodes->GetNode()->SetFloatProperty("opacity", opacImag);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
if(m_ClusteringResult.IsNotNull())
{
float opacClust = v/5.0f;
opacClust = opacClust > 1 ? 1 : opacClust;
m_ClusteringResult->SetFloatProperty("opacity", opacClust);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkPartialVolumeAnalysisView::NumberBinsReleasedSlider( )
{
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::UpsamplingReleasedSlider( )
{
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::GaussianSigmaReleasedSlider( )
{
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::SimilarAnglesReleasedSlider( )
{
}
void QmitkPartialVolumeAnalysisView::ToClipBoard()
{
std::vector<std::vector<double>* > vals = m_Controls->m_HistogramWidget->m_Vals;
QString clipboardText;
for (std::vector<std::vector<double>* >::iterator it = vals.begin(); it
!= vals.end(); ++it)
{
for (std::vector<double>::iterator it2 = (**it).begin(); it2 != (**it).end(); ++it2)
{
clipboardText.append(QString("%1 \t").arg(*it2));
}
clipboardText.append(QString("\n"));
}
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
}
void QmitkPartialVolumeAnalysisView::PropertyChanged(const mitk::DataNode* /*node*/, const mitk::BaseProperty* /*prop*/)
{
}
void QmitkPartialVolumeAnalysisView::NodeChanged(const mitk::DataNode* /*node*/)
{
}
void QmitkPartialVolumeAnalysisView::NodeRemoved(const mitk::DataNode* node)
{
if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
this->GetDataStorage()->Remove(m_ClusteringResult);
if( node == m_SelectedPlanarFigureNodes->GetNode().GetPointer()
|| node == m_SelectedMaskNode.GetPointer() )
{
this->Select(NULL,true,false);
SetMeasurementInfoToRenderWindow("");
}
if( node == m_SelectedImageNodes->GetNode().GetPointer() )
{
this->Select(NULL,false,true);
SetMeasurementInfoToRenderWindow("");
}
}
void QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage(const mitk::DataNode* node)
{
if(!m_Visible)
return;
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(nonConstNode->GetData());
if(figure)
{
// set interactor for new node (if not already set)
mitk::PlanarFigureInteractor::Pointer figureInteractor
= dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", nonConstNode);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
// remove uninitialized old planars
if( m_SelectedPlanarFigureNodes->GetNode().IsNotNull() && m_CurrentFigureNodeInitialized == false )
{
mitk::Interactor::Pointer oldInteractor = m_SelectedPlanarFigureNodes->GetNode()->GetInteractor();
if(oldInteractor.IsNotNull())
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(oldInteractor);
this->GetDataStorage()->Remove(m_SelectedPlanarFigureNodes->GetNode());
}
}
}
void QmitkPartialVolumeAnalysisView::TextIntON()
{
if(m_ClusteringResult.IsNotNull())
{
if(m_TexIsOn)
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
}
else
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
}
m_ClusteringResult->SetBoolProperty("texture interpolation", !m_TexIsOn);
m_TexIsOn = !m_TexIsOn;
this->RequestRenderWindowUpdate();
}
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
index 87054f15a6..08071d0d28 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
@@ -1,595 +1,731 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//#define MBILOG_ENABLE_DEBUG
#include "QmitkPreprocessingView.h"
#include "mitkDiffusionImagingConfigure.h"
// qt includes
#include <QMessageBox>
// itk includes
#include "itkTimeProbe.h"
#include "itkB0ImageExtractionImageFilter.h"
#include "itkB0ImageExtractionToSeparateImageFilter.h"
#include "itkBrainMaskExtractionImageFilter.h"
#include "itkCastImageFilter.h"
#include "itkVectorContainer.h"
#include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
#include <itkMergeDiffusionImagesFilter.h>
+#include <itkMultiShellAdcAverageReconstructionImageFilter.h>
+#include <itkDwiGradientLengthCorrectionFilter.h>
// mitk includes
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkProgressBar.h"
#include "mitkStatusBar.h"
#include "mitkNodePredicateDataType.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 <mitkPointSet.h>
+#include <itkAdcImageFilter.h>
#include <QTableWidgetItem>
#include <QTableWidget>
const std::string QmitkPreprocessingView::VIEW_ID =
"org.mitk.views.preprocessing";
#define DI_INFO MITK_INFO("DiffusionImaging")
typedef float TTensorPixelType;
QmitkPreprocessingView::QmitkPreprocessingView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL),
m_DiffusionImage(NULL)
{
}
QmitkPreprocessingView::QmitkPreprocessingView(const QmitkPreprocessingView& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkPreprocessingView::~QmitkPreprocessingView()
{
}
void QmitkPreprocessingView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkPreprocessingViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
m_Controls->m_MeasurementFrameTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
m_Controls->m_MeasurementFrameTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
}
}
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_ModifyMeasurementFrame), SIGNAL(clicked()), this, SLOT(DoApplyMesurementFrame()) );
connect( (QObject*)(m_Controls->m_ReduceGradientsButton), SIGNAL(clicked()), this, SLOT(DoReduceGradientDirections()) );
connect( (QObject*)(m_Controls->m_ShowGradientsButton), SIGNAL(clicked()), this, SLOT(DoShowGradientDirections()) );
connect( (QObject*)(m_Controls->m_MirrorGradientToHalfSphereButton), SIGNAL(clicked()), this, SLOT(DoHalfSphereGradientDirections()) );
connect( (QObject*)(m_Controls->m_MergeDwisButton), SIGNAL(clicked()), this, SLOT(MergeDwis()) );
+ connect( (QObject*)(m_Controls->m_AdcAverage), SIGNAL(clicked()), this, SLOT(DoAdcAverage()) );
+ connect( (QObject*)(m_Controls->m_B_ValueMap_Rounder_SpinBox), SIGNAL(valueChanged(int)), this, SLOT(UpdateDwiBValueMapRounder(int)));
+ connect( (QObject*)(m_Controls->m_CreateLengthCorrectedDwi), SIGNAL(clicked()), this, SLOT(DoLengthCorrection()) );
+ connect( (QObject*)(m_Controls->m_CalcAdcButton), SIGNAL(clicked()), this, SLOT(DoAdcCalculation()) );
+ }
+}
+
+void QmitkPreprocessingView::DoLengthCorrection()
+{
+ if (m_DiffusionImage.IsNull())
+ return;
+
+ typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
+ typedef itk::DwiGradientLengthCorrectionFilter FilterType;
+
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetRoundingValue( m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
+ filter->SetReferenceBValue(m_DiffusionImage->GetB_Value());
+ filter->SetReferenceGradientDirectionContainer(m_DiffusionImage->GetDirections());
+ filter->Update();
+
+ DiffusionImageType::Pointer image = DiffusionImageType::New();
+ image->SetVectorImage( m_DiffusionImage->GetVectorImage());
+ image->SetB_Value( filter->GetNewBValue() );
+ image->SetDirections( filter->GetOutputGradientDirectionContainer());
+ image->InitializeFromVectorImage();
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
+
+ imageNode->SetName((name+"_rounded").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode);
+}
+
+void QmitkPreprocessingView::UpdateDwiBValueMapRounder(int i)
+{
+ if (m_DiffusionImage.IsNull())
+ return;
+ m_DiffusionImage->UpdateBValueMap();
+ UpdateBValueTableWidget(i);
+}
+
+void QmitkPreprocessingView::DoAdcAverage()
+{
+ typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
+ typedef itk::MultiShellAdcAverageReconstructionImageFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
+ typedef DiffusionImageType::BValueMap BValueMap;
+
+ for (int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+ {
+ DiffusionImageType::Pointer inImage = dynamic_cast< DiffusionImageType* >(m_SelectedDiffusionNodes.at(i)->GetData());
+ BValueMap originalShellMap = inImage->GetB_ValueMap();
+
+ GradientDirectionContainerType::Pointer gradientContainer = inImage->GetDirections();
+
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetInput(inImage->GetVectorImage());
+ filter->SetOriginalGradientDirections(gradientContainer);
+ filter->SetOriginalBValueMap(originalShellMap);
+ filter->SetB_Value(inImage->GetB_Value());
+ filter->Update();
+ DiffusionImageType::Pointer outImage = DiffusionImageType::New();
+ outImage->SetVectorImage( filter->GetOutput() );
+ outImage->SetB_Value( filter->GetTargetB_Value() );
+ //image->SetOriginalDirections( filter->GetTargetGradientDirections() );
+ outImage->SetDirections( filter->GetTargetGradientDirections() );
+ //image->SetMeasurementFrame( m_DiffusionImage->GetMeasurementFrame() );
+ outImage->InitializeFromVectorImage();
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( outImage );
+ QString name = m_SelectedDiffusionNodes.at(i)->GetName().c_str();
+
+ imageNode->SetName((name+"_averaged").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode);
}
}
-void QmitkPreprocessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkPreprocessingView::DoAdcCalculation()
{
- bool foundDwiVolume = false;
- m_DiffusionImage = NULL;
- m_SelectedDiffusionNodes.clear();
+ if (m_DiffusionImage.IsNull())
+ return;
- // iterate selection
- for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+ typedef mitk::DiffusionImage< DiffusionPixelType > DiffusionImageType;
+ typedef itk::AdcImageFilter< DiffusionPixelType, double > FilterType;
+
+
+ for (int i=0; i<m_SelectedDiffusionNodes.size(); i++)
{
- mitk::DataNode::Pointer node = *it;
+ DiffusionImageType::Pointer inImage = dynamic_cast< DiffusionImageType* >(m_SelectedDiffusionNodes.at(i)->GetData());
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetInput(inImage->GetVectorImage());
+ filter->SetGradientDirections(inImage->GetDirections());
+ filter->SetB_value(inImage->GetB_Value());
+ filter->Update();
- if( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
- {
- foundDwiVolume = true;
- m_DiffusionImage = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(node->GetData());
- m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
- m_SelectedDiffusionNodes.push_back(node);
- }
+ mitk::Image::Pointer image = mitk::Image::New();
+ image->InitializeByItk( filter->GetOutput() );
+ image->SetVolume( filter->GetOutput()->GetBufferPointer() );
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedDiffusionNodes.at(i)->GetName().c_str();
+
+ imageNode->SetName((name+"_ADC").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode);
}
+}
- m_Controls->m_ButtonAverageGradients->setEnabled(foundDwiVolume);
- m_Controls->m_ButtonExtractB0->setEnabled(foundDwiVolume);
- m_Controls->m_CheckExtractAll->setEnabled(foundDwiVolume);
- m_Controls->m_ModifyMeasurementFrame->setEnabled(foundDwiVolume);
- m_Controls->m_MeasurementFrameTable->setEnabled(foundDwiVolume);
- m_Controls->m_ReduceGradientsButton->setEnabled(foundDwiVolume);
- m_Controls->m_ShowGradientsButton->setEnabled(foundDwiVolume);
- m_Controls->m_MirrorGradientToHalfSphereButton->setEnabled(foundDwiVolume);
- m_Controls->m_MergeDwisButton->setEnabled(foundDwiVolume);
+void QmitkPreprocessingView::UpdateBValueTableWidget(int i)
+{
foreach(QCheckBox * box, m_ReduceGradientCheckboxes)
{
m_Controls->m_ReductionFrame->layout()->removeWidget(box);
delete box;
}
foreach(QSpinBox * box, m_ReduceGradientSpinboxes)
{
m_Controls->m_ReductionFrame->layout()->removeWidget(box);
delete box;
}
m_ReduceGradientCheckboxes.clear();
m_ReduceGradientSpinboxes.clear();
- if (foundDwiVolume)
+ if (m_DiffusionImage.IsNull())
{
- m_Controls->m_InputData->setTitle("Input Data");
- vnl_matrix_fixed< double, 3, 3 > mf = m_DiffusionImage->GetMeasurementFrame();
- for (int r=0; r<3; r++)
- for (int c=0; c<3; c++)
- {
- QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
- delete item;
- item = new QTableWidgetItem();
- item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
- item->setText(QString::number(mf.get(r,c)));
- m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
- }
+ m_Controls->m_B_ValueMap_TableWidget->clear();
+ m_Controls->m_B_ValueMap_TableWidget->setRowCount(1);
+ QStringList headerList;
+ headerList << "b-Value" << "Number of gradients";
+ m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
+ m_Controls->m_B_ValueMap_TableWidget->setItem(0,0,new QTableWidgetItem("-"));
+ m_Controls->m_B_ValueMap_TableWidget->setItem(0,1,new QTableWidgetItem("-"));
+ }else{
typedef mitk::DiffusionImage<short*>::BValueMap BValueMap;
typedef mitk::DiffusionImage<short*>::BValueMap::iterator BValueMapIterator;
- BValueMap bValMap = m_DiffusionImage->GetB_ValueMap();
- BValueMapIterator it = bValMap.begin();
- m_Controls->m_BvalueTable->clear();
- m_Controls->m_BvalueTable->setRowCount(bValMap.size() );
+ BValueMapIterator it;
+
+ BValueMap roundedBValueMap;
+ GradientDirectionContainerType::ConstIterator gdcit;
+ for( gdcit = m_DiffusionImage->GetDirections()->Begin(); gdcit != m_DiffusionImage->GetDirections()->End(); ++gdcit)
+ {
+ float currentBvalue = std::floor(m_DiffusionImage->GetB_Value(gdcit.Index()));
+ double rounded = int((currentBvalue + 0.5 * i)/i)*i;
+ roundedBValueMap[rounded].push_back(gdcit.Index());
+ }
+
+ m_Controls->m_B_ValueMap_TableWidget->clear();
+ m_Controls->m_B_ValueMap_TableWidget->setRowCount(roundedBValueMap.size() );
QStringList headerList;
headerList << "b-Value" << "Number of gradients";
- m_Controls->m_BvalueTable->setHorizontalHeaderLabels(headerList);
+ m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
QCheckBox* checkBox;
QSpinBox* spinBox;
int i = 0 ;
- for(;it != bValMap.end(); it++)
+ for(it = roundedBValueMap.begin() ;it != roundedBValueMap.end(); it++)
{
- m_Controls->m_BvalueTable->setItem(i,0,new QTableWidgetItem(QString::number(it->first)));
- m_Controls->m_BvalueTable->setItem(i,1,new QTableWidgetItem(QString::number(it->second.size())));
+ m_Controls->m_B_ValueMap_TableWidget->setItem(i,0,new QTableWidgetItem(QString::number(it->first)));
+ m_Controls->m_B_ValueMap_TableWidget->setItem(i,1,new QTableWidgetItem(QString::number(it->second.size())));
// Reduce Gradients GUI adaption
- if(it->first != 0 && bValMap.size() > 1){
+ if(it->first != 0 && roundedBValueMap.size() > 1){
checkBox = new QCheckBox(QString::number(it->first) + " with " + QString::number(it->second.size()) + " directions");
checkBox->setEnabled(true);
checkBox->setChecked(true);
checkBox->setCheckable(true);
m_ReduceGradientCheckboxes.push_back(checkBox);
m_Controls->m_ReductionFrame->layout()->addWidget(checkBox);
spinBox = new QSpinBox();
spinBox->setValue(std::ceil((float)it->second.size()/2));
spinBox->setMaximum(it->second.size());
spinBox->setMinimum(0);
m_ReduceGradientSpinboxes.push_back(spinBox);
m_Controls->m_ReductionFrame->layout()->addWidget(spinBox);
}
i++;
}
}
+
+}
+
+void QmitkPreprocessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+{
+ bool foundDwiVolume = false;
+ m_DiffusionImage = NULL;
+ m_SelectedDiffusionNodes.clear();
+
+ // iterate selection
+ for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+ {
+ mitk::DataNode::Pointer node = *it;
+
+ if( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
+ {
+ foundDwiVolume = true;
+ m_DiffusionImage = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(node->GetData());
+ m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
+ m_SelectedDiffusionNodes.push_back(node);
+ }
+ }
+
+ m_Controls->m_ButtonAverageGradients->setEnabled(foundDwiVolume);
+ m_Controls->m_ButtonExtractB0->setEnabled(foundDwiVolume);
+ m_Controls->m_CheckExtractAll->setEnabled(foundDwiVolume);
+ m_Controls->m_ModifyMeasurementFrame->setEnabled(foundDwiVolume);
+ m_Controls->m_MeasurementFrameTable->setEnabled(foundDwiVolume);
+ m_Controls->m_ReduceGradientsButton->setEnabled(foundDwiVolume);
+ m_Controls->m_ShowGradientsButton->setEnabled(foundDwiVolume);
+ m_Controls->m_MirrorGradientToHalfSphereButton->setEnabled(foundDwiVolume);
+ m_Controls->m_MergeDwisButton->setEnabled(foundDwiVolume);
+ m_Controls->m_B_ValueMap_Rounder_SpinBox->setEnabled(foundDwiVolume);
+ m_Controls->m_AdcAverage->setEnabled(foundDwiVolume);
+ m_Controls->m_CreateLengthCorrectedDwi->setEnabled(foundDwiVolume);
+ if(foundDwiVolume)m_Controls->m_B_ValueMap_Rounder_SpinBox->setValue(10);
+ m_Controls->m_CalcAdcButton->setEnabled(foundDwiVolume);
+
+ UpdateBValueTableWidget(m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
+
+ if (foundDwiVolume)
+ {
+ m_Controls->m_InputData->setTitle("Input Data");
+ vnl_matrix_fixed< double, 3, 3 > mf = m_DiffusionImage->GetMeasurementFrame();
+ for (int r=0; r<3; r++)
+ for (int c=0; c<3; c++)
+ {
+ QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
+ delete item;
+ item = new QTableWidgetItem();
+ item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
+ item->setText(QString::number(mf.get(r,c)));
+ m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
+ }
+ }
else
{
for (int r=0; r<3; r++)
for (int c=0; c<3; c++)
{
QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
delete item;
item = new QTableWidgetItem();
m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
}
- m_Controls->m_BvalueTable->clear();
- m_Controls->m_BvalueTable->setRowCount(1);
- QStringList headerList;
- headerList << "b-Value" << "Number of gradients";
- m_Controls->m_BvalueTable->setHorizontalHeaderLabels(headerList);
- m_Controls->m_BvalueTable->setItem(0,0,new QTableWidgetItem("-"));
- m_Controls->m_BvalueTable->setItem(0,1,new QTableWidgetItem("-"));
+
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_InputData->setTitle("Please Select Input Data");
}
}
void QmitkPreprocessingView::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkPreprocessingView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
void QmitkPreprocessingView::DoHalfSphereGradientDirections()
{
GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
for (int j=0; j<gradientContainer->Size(); j++)
if (gradientContainer->at(j)[0]<0)
gradientContainer->at(j) = -gradientContainer->at(j);
m_DiffusionImage->SetDirections(gradientContainer);
}
void QmitkPreprocessingView::DoApplyMesurementFrame()
{
if (m_DiffusionImage.IsNull())
return;
vnl_matrix_fixed< double, 3, 3 > mf;
for (int r=0; r<3; r++)
for (int c=0; c<3; c++)
{
QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
if (!item)
return;
mf[r][c] = item->text().toDouble();
}
m_DiffusionImage->SetMeasurementFrame(mf);
}
void QmitkPreprocessingView::DoShowGradientDirections()
{
if (m_DiffusionImage.IsNull())
return;
int maxIndex = 0;
int maxSize = m_DiffusionImage->GetDimension(0);
if (maxSize<m_DiffusionImage->GetDimension(1))
{
maxSize = m_DiffusionImage->GetDimension(1);
maxIndex = 1;
}
if (maxSize<m_DiffusionImage->GetDimension(2))
{
maxSize = m_DiffusionImage->GetDimension(2);
maxIndex = 2;
}
mitk::Point3D origin = m_DiffusionImage->GetGeometry()->GetOrigin();
mitk::PointSet::Pointer originSet = mitk::PointSet::New();
typedef mitk::DiffusionImage<short*>::BValueMap BValueMap;
typedef mitk::DiffusionImage<short*>::BValueMap::iterator BValueMapIterator;
BValueMap bValMap = m_DiffusionImage->GetB_ValueMap();
GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
mitk::Geometry3D::Pointer geometry = m_DiffusionImage->GetGeometry();
int shellCount = 1;
for(BValueMapIterator it = bValMap.begin(); it!=bValMap.end(); ++it)
{
mitk::PointSet::Pointer pointset = mitk::PointSet::New();
for (int j=0; j<it->second.size(); j++)
{
mitk::Point3D ip;
vnl_vector_fixed< double, 3 > v = gradientContainer->at(it->second[j]);
if (v.magnitude()>mitk::eps)
{
ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_DiffusionImage->GetDimension(0)/2;
ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_DiffusionImage->GetDimension(1)/2;
ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_DiffusionImage->GetDimension(2)/2;
pointset->InsertPoint(j, ip);
}
else if (originSet->IsEmpty())
{
ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_DiffusionImage->GetDimension(0)/2;
ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_DiffusionImage->GetDimension(1)/2;
ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_DiffusionImage->GetDimension(2)/2;
originSet->InsertPoint(j, ip);
}
}
if (it->first<mitk::eps)
continue;
// add shell to datastorage
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(pointset);
QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
name += "_Shell_";
name += QString::number(it->first);
node->SetName(name.toStdString().c_str());
node->SetProperty("pointsize", mitk::FloatProperty::New((float)maxSize/50));
int b0 = shellCount%2;
int b1 = 0;
int b2 = 0;
if (shellCount>4)
b2 = 1;
if (shellCount%4 >= 2)
b1 = 1;
node->SetProperty("color", mitk::ColorProperty::New(b2, b1, b0));
GetDefaultDataStorage()->Add(node, m_SelectedDiffusionNodes.front());
shellCount++;
}
// add origin to datastorage
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(originSet);
QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
name += "_Origin";
node->SetName(name.toStdString().c_str());
node->SetProperty("pointsize", mitk::FloatProperty::New((float)maxSize/50));
node->SetProperty("color", mitk::ColorProperty::New(1,1,1));
GetDefaultDataStorage()->Add(node, m_SelectedDiffusionNodes.front());
}
void QmitkPreprocessingView::DoReduceGradientDirections()
{
if (m_DiffusionImage.IsNull())
return;
typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
typedef DiffusionImageType::BValueMap BValueMap;
// GetShellSelection from GUI
BValueMap shellSlectionMap;
BValueMap originalShellMap = m_DiffusionImage->GetB_ValueMap();
std::vector<int> newNumGradientDirections;
int shellCounter = 0;
foreach(QCheckBox * box , m_ReduceGradientCheckboxes)
{
if(box->isChecked())
{
double BValue = (box->text().split(' ')).at(0).toDouble();
shellSlectionMap[BValue] = originalShellMap[BValue];
newNumGradientDirections.push_back(m_ReduceGradientSpinboxes.at(shellCounter)->value());
}
shellCounter++;
}
if (newNumGradientDirections.empty())
return;
GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
FilterType::Pointer filter = FilterType::New();
filter->SetInput(m_DiffusionImage->GetVectorImage());
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetNumGradientDirections(newNumGradientDirections);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetShellSelectionBValueMap(shellSlectionMap);
filter->Update();
DiffusionImageType::Pointer image = DiffusionImageType::New();
image->SetVectorImage( filter->GetOutput() );
image->SetB_Value(m_DiffusionImage->GetB_Value());
image->SetDirections(filter->GetGradientDirections());
image->SetMeasurementFrame(m_DiffusionImage->GetMeasurementFrame());
image->InitializeFromVectorImage();
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
imageNode->SetData( image );
QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
foreach(QSpinBox* box, m_ReduceGradientSpinboxes)
{
name += "_";
name += QString::number(box->value());
}
imageNode->SetName(name.toStdString().c_str());
GetDefaultDataStorage()->Add(imageNode);
}
void QmitkPreprocessingView::MergeDwis()
{
typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
typedef DiffusionImageType::GradientDirectionContainerType GradientContainerType;
if (m_SelectedDiffusionNodes.size()<2)
return;
typedef itk::VectorImage<DiffusionPixelType,3> DwiImageType;
typedef DwiImageType::PixelType DwiPixelType;
typedef DwiImageType::RegionType DwiRegionType;
typedef std::vector< DwiImageType::Pointer > DwiImageContainerType;
typedef std::vector< GradientContainerType::Pointer > GradientListContainerType;
DwiImageContainerType imageContainer;
GradientListContainerType gradientListContainer;
std::vector< double > bValueContainer;
QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
for (int i=0; i<m_SelectedDiffusionNodes.size(); i++)
{
DiffusionImageType::Pointer dwi = dynamic_cast< mitk::DiffusionImage<DiffusionPixelType>* >( m_SelectedDiffusionNodes.at(i)->GetData() );
if ( dwi.IsNotNull() )
{
imageContainer.push_back(dwi->GetVectorImage());
gradientListContainer.push_back(dwi->GetDirections());
bValueContainer.push_back(dwi->GetB_Value());
if (i>0)
{
name += "+";
name += m_SelectedDiffusionNodes.at(i)->GetName().c_str();
}
}
}
typedef itk::MergeDiffusionImagesFilter<short> FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetImageVolumes(imageContainer);
filter->SetGradientLists(gradientListContainer);
filter->SetBValues(bValueContainer);
filter->Update();
vnl_matrix_fixed< double, 3, 3 > mf; mf.set_identity();
DiffusionImageType::Pointer image = DiffusionImageType::New();
image->SetVectorImage( filter->GetOutput() );
image->SetB_Value(filter->GetB_Value());
image->SetDirections(filter->GetOutputGradients());
image->SetMeasurementFrame(mf);
image->InitializeFromVectorImage();
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
imageNode->SetData( image );
imageNode->SetName(name.toStdString().c_str());
GetDefaultDataStorage()->Add(imageNode);
}
void QmitkPreprocessingView::ExtractB0()
{
typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
typedef DiffusionImageType::GradientDirectionContainerType GradientContainerType;
int nrFiles = m_SelectedDiffusionNodes.size();
if (!nrFiles) return;
// call the extraction withou averaging if the check-box is checked
if( this->m_Controls->m_CheckExtractAll->isChecked() )
{
DoExtractBOWithoutAveraging();
return;
}
mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.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::DoExtractBOWithoutAveraging()
{
// typedefs
typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
typedef DiffusionImageType::GradientDirectionContainerType GradientContainerType;
typedef itk::B0ImageExtractionToSeparateImageFilter< short, short> FilterType;
// check number of selected objects, return if empty
int nrFiles = m_SelectedDiffusionNodes.size();
if (!nrFiles)
return;
mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
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
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->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( mitkImage );
node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0_ALL"));
GetDefaultDataStorage()->Add(node);
++itemiter;
}
}
void QmitkPreprocessingView::AverageGradients()
{
int nrFiles = m_SelectedDiffusionNodes.size();
if (!nrFiles) return;
mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.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;
}
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
index 7fa2503fce..5bfeb97b89 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
@@ -1,109 +1,115 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _QMITKPREPROCESSINGVIEW_H_INCLUDED
#define _QMITKPREPROCESSINGVIEW_H_INCLUDED
#include <QmitkFunctionality.h>
#include <string>
#include "ui_QmitkPreprocessingViewControls.h"
#include "mitkDiffusionImage.h"
typedef short DiffusionPixelType;
struct PrpSelListener;
/*!
* \ingroup org_mitk_gui_qt_preprocessing_internal
*
* \brief QmitkPreprocessingView
*
* Document your class here.
*
* \sa 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;
typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
typedef itk::VectorContainer< unsigned int, GradientDirectionType > GradientDirectionContainerType;
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 ExtractB0();
void MergeDwis();
void DoApplyMesurementFrame();
void DoReduceGradientDirections();
void DoShowGradientDirections();
void DoHalfSphereGradientDirections();
+ void DoAdcAverage();
+ void UpdateDwiBValueMapRounder(int i);
+ void DoLengthCorrection();
+ void DoAdcCalculation();
protected:
/** Called by ExtractB0 if check-box activated, extracts all b0 images without averaging */
void DoExtractBOWithoutAveraging();
+ void UpdateBValueTableWidget(int i);
+
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
Ui::QmitkPreprocessingViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
mitk::DiffusionImage<DiffusionPixelType>::Pointer m_DiffusionImage;
std::vector< mitk::DataNode::Pointer > m_SelectedDiffusionNodes;
QList<QCheckBox*> m_ReduceGradientCheckboxes;
QList<QSpinBox*> m_ReduceGradientSpinboxes;
};
#endif // _QMITKPREPROCESSINGVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui
index ee3586448e..24d5138edd 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui
@@ -1,567 +1,634 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkPreprocessingViewControls</class>
<widget class="QWidget" name="QmitkPreprocessingViewControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>892</width>
- <height>1080</height>
+ <height>1290</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="acceptDrops">
<bool>false</bool>
</property>
<property name="windowTitle">
<string>QmitkPreprocessingViewControls</string>
</property>
<property name="autoFillBackground">
<bool>true</bool>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QGroupBox" name="m_InputData">
<property name="title">
<string>Please Select Input Data</string>
</property>
<layout class="QGridLayout" name="gridLayout_2">
<item row="0" column="0">
<widget class="QLabel" name="label_5">
<property name="toolTip">
<string/>
</property>
<property name="text">
<string>Raw DWI:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLabel" name="m_DiffusionImageLabel">
<property name="text">
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;mandatory&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_5">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Info</string>
</property>
<layout class="QGridLayout" name="gridLayout_3">
+ <item row="1" column="0">
+ <widget class="Line" name="line_4">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ </widget>
+ </item>
+ <item row="5" column="0">
+ <widget class="QCommandLinkButton" name="m_ShowGradientsButton">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="toolTip">
+ <string>Generate pointset displaying the gradient vectors (applied measurement frame).</string>
+ </property>
+ <property name="statusTip">
+ <string/>
+ </property>
+ <property name="whatsThis">
+ <string notr="true"/>
+ </property>
+ <property name="text">
+ <string>Show gradients</string>
+ </property>
+ </widget>
+ </item>
+ <item row="4" column="0">
+ <widget class="Line" name="line_3">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ </widget>
+ </item>
+ <item row="7" column="0">
+ <widget class="QCommandLinkButton" name="m_AdcAverage">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="toolTip">
+ <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Create a new Diffusion Weighted Image (DWI) using an ADC average over all q-shells.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+ </property>
+ <property name="text">
+ <string>ADC average (multi-shell)</string>
+ </property>
+ </widget>
+ </item>
<item row="0" column="0">
- <widget class="QTableWidget" name="m_BvalueTable">
+ <widget class="QTableWidget" name="m_B_ValueMap_TableWidget">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="verticalScrollBarPolicy">
<enum>Qt::ScrollBarAsNeeded</enum>
</property>
<property name="horizontalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOff</enum>
</property>
<attribute name="horizontalHeaderCascadingSectionResizes">
<bool>true</bool>
</attribute>
<attribute name="horizontalHeaderDefaultSectionSize">
<number>100</number>
</attribute>
<attribute name="horizontalHeaderStretchLastSection">
<bool>true</bool>
</attribute>
<attribute name="verticalHeaderVisible">
<bool>false</bool>
</attribute>
<attribute name="verticalHeaderCascadingSectionResizes">
<bool>true</bool>
</attribute>
<column>
<property name="text">
<string>b-Value</string>
</property>
</column>
<column>
<property name="text">
<string>Number of gradients</string>
</property>
</column>
</widget>
</item>
- <item row="0" column="1">
- <spacer name="horizontalSpacer_2">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
+ <item row="3" column="0">
+ <widget class="QCommandLinkButton" name="m_CreateLengthCorrectedDwi">
+ <property name="enabled">
+ <bool>false</bool>
</property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
+ <property name="text">
+ <string>Round b-value</string>
</property>
- </spacer>
+ </widget>
</item>
- <item row="1" column="0">
- <widget class="QCommandLinkButton" name="m_ShowGradientsButton">
+ <item row="2" column="0">
+ <widget class="QSpinBox" name="m_B_ValueMap_Rounder_SpinBox">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
- <string>Generate pointset displaying the gradient vectors (applied measurement frame).</string>
+ <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Round b-values to nearest multiple of this value (click &amp;quot;Round b-value&amp;quot; to create new image with these values).&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
- <property name="statusTip">
- <string/>
+ <property name="correctionMode">
+ <enum>QAbstractSpinBox::CorrectToNearestValue</enum>
</property>
- <property name="whatsThis">
- <string notr="true"/>
+ <property name="minimum">
+ <number>1</number>
</property>
- <property name="text">
- <string>Show gradients</string>
+ <property name="maximum">
+ <number>10000</number>
+ </property>
+ <property name="singleStep">
+ <number>10</number>
+ </property>
+ </widget>
+ </item>
+ <item row="6" column="0">
+ <widget class="Line" name="line_5">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_2">
<property name="title">
<string>Non diffusion weighted image</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<widget class="QLabel" name="label_3">
<property name="minimumSize">
<size>
<width>0</width>
<height>30</height>
</size>
</property>
<property name="text">
<string>Average and extract all images that were acquired without diffusion weighting.</string>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QCommandLinkButton" name="m_ButtonExtractB0">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>If multiple baseline acquisitions are present, the default behaviour is to output an averaged image.</string>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string notr="true"/>
</property>
<property name="text">
<string>Extract B0</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="m_CheckExtractAll">
<property name="toolTip">
<string>Create a 3D+t data set containing all b0 images as timesteps</string>
</property>
<property name="text">
<string>Extract all B0 images without averaging</string>
</property>
</widget>
</item>
+ <item>
+ <widget class="QCommandLinkButton" name="m_CalcAdcButton">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="toolTip">
+ <string>If multiple baseline acquisitions are present, the default behaviour is to output an averaged image.</string>
+ </property>
+ <property name="statusTip">
+ <string/>
+ </property>
+ <property name="whatsThis">
+ <string notr="true"/>
+ </property>
+ <property name="text">
+ <string>Calculate ADC map</string>
+ </property>
+ </widget>
+ </item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_ReduceSizeLayout">
<property name="title">
<string>Modify DWI</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_4">
<item>
<widget class="QFrame" name="frame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QFormLayout" name="formLayout_2">
- <property name="leftMargin">
- <number>0</number>
- </property>
- <property name="topMargin">
- <number>0</number>
- </property>
- <property name="rightMargin">
- <number>0</number>
- </property>
- <property name="bottomMargin">
+ <property name="margin">
<number>0</number>
</property>
<item row="0" column="1">
<widget class="QDoubleSpinBox" name="m_Blur">
<property name="toolTip">
<string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
</property>
<property name="statusTip">
<string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
</property>
<property name="whatsThis">
<string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
</property>
<property name="decimals">
<number>6</number>
</property>
<property name="maximum">
<double>2.000000000000000</double>
</property>
<property name="singleStep">
<double>0.000100000000000</double>
</property>
<property name="value">
<double>0.001000000000000</double>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label">
<property name="toolTip">
<string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
</property>
<property name="statusTip">
<string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
</property>
<property name="whatsThis">
<string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
</property>
<property name="text">
<string>Merge radius</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QCommandLinkButton" name="m_ButtonAverageGradients">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>Multiple acquistions of one gradient direction can be averaged. Due to rounding errors, similar gradients often differ in the last decimal positions. The Merge radius allows to average them by taking all directions within a certain radius into account.</string>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string notr="true"/>
</property>
<property name="text">
<string>Average redundant gradients</string>
</property>
</widget>
</item>
<item>
<widget class="Line" name="line_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item>
<widget class="QFrame" name="m_ReductionFrame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_4">
- <property name="leftMargin">
- <number>0</number>
- </property>
- <property name="topMargin">
- <number>0</number>
- </property>
- <property name="rightMargin">
- <number>0</number>
- </property>
- <property name="bottomMargin">
+ <property name="margin">
<number>0</number>
</property>
<property name="spacing">
<number>9</number>
</property>
<item row="0" column="1">
<widget class="QLabel" name="label_6">
<property name="text">
<string/>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_4">
<property name="text">
<string>Specify desired number of gradients per shell:</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
+ <item>
+ <spacer name="horizontalSpacer_3">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
<item>
<widget class="QCommandLinkButton" name="m_ReduceGradientsButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>Retain only the specified number of gradient directions and according image volumes. The retained directions are spread equally over the half sphere using an iterative energy repulsion strategy.</string>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string notr="true"/>
</property>
<property name="text">
<string>Reduce number of gradients</string>
</property>
</widget>
</item>
<item>
<widget class="Line" name="line">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item>
<widget class="QCommandLinkButton" name="m_MirrorGradientToHalfSphereButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>Sometimes the gradient directions are not located on one half sphere.</string>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string notr="true"/>
</property>
<property name="text">
<string>Mirror gradients to half sphere</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_7">
<property name="title">
<string>Merge selected images</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_6">
<item>
<widget class="QCommandLinkButton" name="m_MergeDwisButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string>Merges selected DWIs of same dimension. If several b-values are present, the resulting image will contain multiple b-shells.</string>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string notr="true"/>
</property>
<property name="text">
<string>Merge selected DWIs</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_4">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Measurment frame</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="1">
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QTableWidget" name="m_MeasurementFrameTable">
<property name="enabled">
<bool>false</bool>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="cursor" stdset="0">
<cursorShape>IBeamCursor</cursorShape>
</property>
<property name="autoFillBackground">
<bool>true</bool>
</property>
<property name="verticalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOff</enum>
</property>
<property name="horizontalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOff</enum>
</property>
<property name="showGrid">
<bool>true</bool>
</property>
<property name="cornerButtonEnabled">
<bool>false</bool>
</property>
<attribute name="horizontalHeaderVisible">
<bool>false</bool>
</attribute>
<attribute name="horizontalHeaderCascadingSectionResizes">
<bool>true</bool>
</attribute>
<attribute name="horizontalHeaderHighlightSections">
<bool>true</bool>
</attribute>
<attribute name="horizontalHeaderMinimumSectionSize">
<number>0</number>
</attribute>
<attribute name="verticalHeaderVisible">
<bool>false</bool>
</attribute>
<attribute name="verticalHeaderCascadingSectionResizes">
<bool>true</bool>
</attribute>
<attribute name="verticalHeaderHighlightSections">
<bool>true</bool>
</attribute>
<row>
<property name="text">
<string>New Row</string>
</property>
</row>
<row>
<property name="text">
<string>New Row</string>
</property>
</row>
<row>
<property name="text">
<string>New Row</string>
</property>
</row>
<column>
<property name="text">
<string>New Column</string>
</property>
</column>
<column>
<property name="text">
<string>New Column</string>
</property>
</column>
<column>
<property name="text">
<string>New Column</string>
</property>
</column>
</widget>
</item>
<item row="1" column="0">
<widget class="QCommandLinkButton" name="m_ModifyMeasurementFrame">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string notr="true"/>
</property>
<property name="text">
<string>Apply new measurement frame</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<resources/>
<connections/>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
index 961a581783..1576d6c260 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
@@ -1,1061 +1,1062 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//#define MBILOG_ENABLE_DEBUG
#include "QmitkQBallReconstructionView.h"
#include "mitkDiffusionImagingConfigure.h"
// qt includes
#include <QMessageBox>
// itk includes
#include "itkTimeProbe.h"
// mitk includes
#include "mitkProgressBar.h"
#include "mitkStatusBar.h"
#include "mitkNodePredicateDataType.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "itkDiffusionQballReconstructionImageFilter.h"
#include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
#include "itkDiffusionMultiShellQballReconstructionImageFilter.h"
#include "itkVectorContainer.h"
#include "mitkQBallImage.h"
#include "mitkProperties.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include "mitkLookupTable.h"
#include "mitkLookupTableProperty.h"
#include "mitkTransferFunction.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include "berryIStructuredSelection.h"
#include "berryIWorkbenchWindow.h"
#include "berryISelectionService.h"
#include <boost/version.hpp>
const std::string QmitkQBallReconstructionView::VIEW_ID = "org.mitk.views.qballreconstruction";
typedef float TTensorPixelType;
const int QmitkQBallReconstructionView::nrconvkernels = 252;
struct QbrShellSelection
{
QmitkQBallReconstructionView* m_View;
mitk::DataNode * m_Node;
std::string m_NodeName;
std::vector<QCheckBox *> m_CheckBoxes;
QLabel * m_Label;
mitk::DiffusionImage<DiffusionPixelType> * m_Image;
typedef mitk::DiffusionImage<DiffusionPixelType>::BValueMap BValueMap;
QbrShellSelection(QmitkQBallReconstructionView* view, mitk::DataNode * node)
: m_View(view),
m_Node(node),
m_NodeName(node->GetName())
{
m_Image = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType> * > (node->GetData());
if(!m_Image){MITK_INFO << "QmitkQBallReconstructionView::QbrShellSelection : fail to initialize DiffusionImage "; return;}
GenerateCheckboxes();
}
void GenerateCheckboxes()
{
BValueMap origMap = m_Image->GetB_ValueMap();
BValueMap::iterator itStart = origMap.begin();
itStart++;
BValueMap::iterator itEnd = origMap.end();
m_Label = new QLabel(m_NodeName.c_str());
m_Label->setVisible(true);
m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(m_Label);
for(BValueMap::iterator it = itStart ; it!= itEnd; it++)
{
QCheckBox * box = new QCheckBox(QString::number(it->first));
m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(box);
box->setChecked(true);
box->setCheckable(true);
// box->setVisible(true);
m_CheckBoxes.push_back(box);
}
}
void SetVisible(bool vis)
{
foreach(QCheckBox * box, m_CheckBoxes)
{
box->setVisible(vis);
}
}
BValueMap GetBValueSelctionMap()
{
BValueMap inputMap = m_Image->GetB_ValueMap();
BValueMap outputMap;
double val = 0;
if(inputMap.find(0) == inputMap.end()){
MITK_INFO << "QbrShellSelection: return empty BValueMap from GUI Selection";
return outputMap;
}else{
outputMap[val] = inputMap[val];
MITK_INFO << val;
}
foreach(QCheckBox * box, m_CheckBoxes)
{
if(box->isChecked()){
val = box->text().toDouble();
outputMap[val] = inputMap[val];
MITK_INFO << val;
}
}
return outputMap;
}
~QbrShellSelection()
{
m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget(m_Label);
delete m_Label;
for(std::vector<QCheckBox *>::iterator it = m_CheckBoxes.begin() ; it!= m_CheckBoxes.end(); it++)
{
m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget((*it));
delete (*it);
}
m_CheckBoxes.clear();
}
};
using namespace berry;
struct QbrSelListener : ISelectionListener
{
berryObjectMacro(QbrSelListener);
QbrSelListener(QmitkQBallReconstructionView* view)
{
m_View = view;
}
void DoSelectionChanged(ISelection::ConstPointer selection)
{
// save current selection in member variable
m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
// do something with the selected items
if(m_View->m_CurrentSelection)
{
bool foundDwiVolume = false;
m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_View->m_Controls->m_InputData->setTitle("Please Select Input Data");
QString selected_images = "";
mitk::DataStorage::SetOfObjects::Pointer set =
mitk::DataStorage::SetOfObjects::New();
int at = 0;
// iterate selection
for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
i != m_View->m_CurrentSelection->End(); ++i)
{
// extract datatree node
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
mitk::DiffusionImage<DiffusionPixelType>* diffusionImage;
// only look at interesting types
if(diffusionImage = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType> * >(node->GetData()))
{
foundDwiVolume = true;
selected_images += QString(node->GetName().c_str());
if(i + 1 != m_View->m_CurrentSelection->End())
selected_images += "\n";
set->InsertElement(at++, node);
}
}
}
m_View->GenerateShellSelectionUI(set);
m_View->m_Controls->m_DiffusionImageLabel->setText(selected_images);
m_View->m_Controls->m_ButtonStandard->setEnabled(foundDwiVolume);
if (foundDwiVolume)
m_View->m_Controls->m_InputData->setTitle("Input Data");
else
m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
}
}
void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
{
// check, if selection comes from datamanager
if (part)
{
QString partname(part->GetPartName().c_str());
if(partname.compare("Datamanager")==0)
{
// apply selection
DoSelectionChanged(selection);
}
}
}
QmitkQBallReconstructionView* m_View;
};
// --------------- QmitkQBallReconstructionView----------------- //
QmitkQBallReconstructionView::QmitkQBallReconstructionView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL)
{
}
QmitkQBallReconstructionView::QmitkQBallReconstructionView(const QmitkQBallReconstructionView& other)
{
Q_UNUSED(other);
throw std::runtime_error("Copy constructor not implemented");
}
QmitkQBallReconstructionView::~QmitkQBallReconstructionView()
{
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
}
void QmitkQBallReconstructionView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkQBallReconstructionViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
QStringList items;
items << "2" << "4" << "6" << "8" << "10" << "12";
m_Controls->m_QBallReconstructionMaxLLevelComboBox->addItems(items);
m_Controls->m_QBallReconstructionMaxLLevelComboBox->setCurrentIndex(1);
MethodChoosen(m_Controls->m_QBallReconstructionMethodComboBox->currentIndex());
#ifndef DIFFUSION_IMAGING_EXTENDED
m_Controls->m_QBallReconstructionMethodComboBox->removeItem(3);
#endif
AdvancedCheckboxClicked();
}
m_SelListener = berry::ISelectionListener::Pointer(new QbrSelListener(this));
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
}
void QmitkQBallReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkQBallReconstructionView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkQBallReconstructionView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_ButtonStandard), SIGNAL(clicked()), this, SLOT(ReconstructStandard()) );
connect( (QObject*)(m_Controls->m_AdvancedCheckbox), SIGNAL(clicked()), this, SLOT(AdvancedCheckboxClicked()) );
connect( (QObject*)(m_Controls->m_QBallReconstructionMethodComboBox), SIGNAL(currentIndexChanged(int)), this, SLOT(MethodChoosen(int)) );
}
}
void QmitkQBallReconstructionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
}
void QmitkQBallReconstructionView::Activated()
{
QmitkFunctionality::Activated();
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
}
void QmitkQBallReconstructionView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
void QmitkQBallReconstructionView::ReconstructStandard()
{
int index = m_Controls->m_QBallReconstructionMethodComboBox->currentIndex();
#ifndef DIFFUSION_IMAGING_EXTENDED
if(index>=3)
{
index = index + 1;
}
#endif
switch(index)
{
case 0:
{
// Numerical
Reconstruct(0,0);
break;
}
case 1:
{
// Standard
Reconstruct(1,0);
break;
}
case 2:
{
// Solid Angle
Reconstruct(1,6);
break;
}
case 3:
{
// Constrained Solid Angle
Reconstruct(1,7);
break;
}
case 4:
{
// ADC
Reconstruct(1,4);
break;
}
case 5:
{
// Raw Signal
Reconstruct(1,5);
break;
}
case 6:
{
// Q-Ball reconstruction
Reconstruct(2,0);
break;
}
}
}
void QmitkQBallReconstructionView::MethodChoosen(int method)
{
#ifndef DIFFUSION_IMAGING_EXTENDED
if(method>=3)
{
method = method + 1;
}
#endif
m_Controls->m_QBallSelectionBox->setHidden(true);
m_Controls->m_OutputCoeffsImage->setHidden(true);
if (method==0)
m_Controls->m_ShFrame->setVisible(false);
else
m_Controls->m_ShFrame->setVisible(true);
switch(method)
{
case 0:
m_Controls->m_Description->setText("Numerical recon. (Tuch 2004)");
break;
case 1:
m_Controls->m_Description->setText("Spherical harmonics recon. (Descoteaux 2007)");
m_Controls->m_OutputCoeffsImage->setHidden(false);
break;
case 2:
m_Controls->m_Description->setText("SH recon. with solid angle consideration (Aganj 2009)");
m_Controls->m_OutputCoeffsImage->setHidden(false);
break;
case 3:
m_Controls->m_Description->setText("SH solid angle with non-neg. constraint (Goh 2009)");
break;
case 4:
m_Controls->m_Description->setText("SH recon. of the plain ADC-profiles");
break;
case 5:
m_Controls->m_Description->setText("SH recon. of the raw diffusion signal");
break;
case 6:
m_Controls->m_Description->setText("SH recon. of the multi shell diffusion signal (Aganj 2010)");
m_Controls->m_QBallSelectionBox->setHidden(false);
m_Controls->m_OutputCoeffsImage->setHidden(false);
break;
}
}
void QmitkQBallReconstructionView::AdvancedCheckboxClicked()
{
bool check = m_Controls->m_AdvancedCheckbox->isChecked();
m_Controls->m_QBallReconstructionMaxLLevelTextLabel_2->setVisible(check);
m_Controls->m_QBallReconstructionMaxLLevelComboBox->setVisible(check);
m_Controls->m_QBallReconstructionLambdaTextLabel_2->setVisible(check);
m_Controls->m_QBallReconstructionLambdaLineEdit->setVisible(check);
m_Controls->m_QBallReconstructionThresholdLabel_2->setVisible(check);
m_Controls->m_QBallReconstructionThreasholdEdit->setVisible(check);
m_Controls->label_2->setVisible(check);
m_Controls->frame_2->setVisible(check);
}
void QmitkQBallReconstructionView::Reconstruct(int method, int normalization)
{
if (m_CurrentSelection)
{
mitk::DataStorage::SetOfObjects::Pointer set =
mitk::DataStorage::SetOfObjects::New();
int at = 0;
for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
i != m_CurrentSelection->End();
++i)
{
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
{
set->InsertElement(at++, node);
}
}
}
if(method == 0)
{
NumericalQBallReconstruction(set, normalization);
}
else
{
#if BOOST_VERSION / 100000 > 0
#if BOOST_VERSION / 100 % 1000 > 34
if(method == 1)
{
AnalyticalQBallReconstruction(set, normalization);
}
if(method == 2)
{
MultiQBallReconstruction(set);
}
#else
std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
#endif
#else
std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
#endif
}
}
}
void QmitkQBallReconstructionView::NumericalQBallReconstruction
(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization)
{
try
{
itk::TimeProbe clock;
int nrFiles = inImages->size();
if (!nrFiles) return;
QString status;
mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
std::vector<mitk::DataNode::Pointer> nodes;
while ( itemiter != itemiterend ) // for all items
{
mitk::DiffusionImage<DiffusionPixelType>* vols =
static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
(*itemiter)->GetData());
std::string nodename;
(*itemiter)->GetStringProperty("name", nodename);
++itemiter;
// QBALL RECONSTRUCTION
clock.Start();
MITK_INFO << "QBall reconstruction ";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
"QBall reconstruction for %s", nodename.c_str()).toAscii());
typedef itk::DiffusionQballReconstructionImageFilter
<DiffusionPixelType, DiffusionPixelType, TTensorPixelType, QBALL_ODFSIZE>
QballReconstructionImageFilterType;
QballReconstructionImageFilterType::Pointer filter =
QballReconstructionImageFilterType::New();
filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
filter->SetBValue(vols->GetB_Value());
filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
switch(normalization)
{
case 0:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
break;
}
case 1:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO_B_VALUE);
break;
}
case 2:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO);
break;
}
case 3:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_NONE);
break;
}
default:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
}
}
filter->Update();
clock.Stop();
MITK_DEBUG << "took " << clock.GetMeanTime() << "s." ;
// ODFs TO DATATREE
mitk::QBallImage::Pointer image = mitk::QBallImage::New();
image->InitializeByItk( filter->GetOutput() );
//image->SetImportVolume( filter->GetOutput()->GetBufferPointer(), 0, 0, mitk::Image::ImportMemoryManagementType::ManageMemory );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
QString newname;
newname = newname.append(nodename.c_str());
newname = newname.append("_QN%1").arg(normalization);
SetDefaultNodeProperties(node, newname.toStdString());
nodes.push_back(node);
mitk::ProgressBar::GetInstance()->Progress();
}
std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
GetDefaultDataStorage()->Add(*nodeIt);
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toAscii());
m_MultiWidget->RequestUpdate();
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
return ;
}
}
void QmitkQBallReconstructionView::AnalyticalQBallReconstruction(
mitk::DataStorage::SetOfObjects::Pointer inImages,
int normalization)
{
try
{
itk::TimeProbe clock;
int nrFiles = inImages->size();
if (!nrFiles) return;
std::vector<float> lambdas;
float minLambda = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
lambdas.push_back(minLambda);
int nLambdas = lambdas.size();
QString status;
mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
std::vector<mitk::DataNode::Pointer>* nodes
= new std::vector<mitk::DataNode::Pointer>();
while ( itemiter != itemiterend ) // for all items
{
mitk::DiffusionImage<DiffusionPixelType>* vols =
static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
(*itemiter)->GetData());
std::string nodename;
(*itemiter)->GetStringProperty("name",nodename);
itemiter++;
// QBALL RECONSTRUCTION
clock.Start();
MITK_INFO << "QBall reconstruction ";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
"QBall reconstruction for %s", nodename.c_str()).toAscii());
for(int i=0; i<nLambdas; i++)
{
float currentLambda = lambdas[i];
switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
{
case 0:
{
TemplatedAnalyticalQBallReconstruction<2>(vols, currentLambda, nodename, nodes, normalization);
break;
}
case 1:
{
TemplatedAnalyticalQBallReconstruction<4>(vols, currentLambda, nodename, nodes, normalization);
break;
}
case 2:
{
TemplatedAnalyticalQBallReconstruction<6>(vols, currentLambda, nodename, nodes, normalization);
break;
}
case 3:
{
TemplatedAnalyticalQBallReconstruction<8>(vols, currentLambda, nodename, nodes, normalization);
break;
}
case 4:
{
TemplatedAnalyticalQBallReconstruction<10>(vols, currentLambda, nodename, nodes, normalization);
break;
}
case 5:
{
TemplatedAnalyticalQBallReconstruction<12>(vols, currentLambda, nodename, nodes, normalization);
break;
}
}
clock.Stop();
MITK_DEBUG << "took " << clock.GetMeanTime() << "s." ;
mitk::ProgressBar::GetInstance()->Progress();
}
}
std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
for(nodeIt = nodes->begin(); nodeIt != nodes->end(); ++nodeIt)
GetDefaultDataStorage()->Add(*nodeIt);
m_MultiWidget->RequestUpdate();
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toAscii());
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex;
QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
return;
}
}
template<int L>
void QmitkQBallReconstructionView::TemplatedAnalyticalQBallReconstruction(
mitk::DiffusionImage<DiffusionPixelType>* vols, float lambda,
std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes,
int normalization)
{
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter
<DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
filter->SetBValue(vols->GetB_Value());
filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
filter->SetLambda(lambda);
switch(normalization)
{
case 0:
{
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
break;
}
case 1:
{
filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO_B_VALUE);
break;
}
case 2:
{
filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO);
break;
}
case 3:
{
filter->SetNormalizationMethod(FilterType::QBAR_NONE);
break;
}
case 4:
{
filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
break;
}
case 5:
{
filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
break;
}
case 6:
{
filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
break;
}
case 7:
{
filter->SetNormalizationMethod(FilterType::QBAR_NONNEG_SOLID_ANGLE);
break;
}
default:
{
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
}
}
filter->Update();
// ODFs TO DATATREE
mitk::QBallImage::Pointer image = mitk::QBallImage::New();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
QString newname;
newname = newname.append(nodename.c_str());
newname = newname.append("_QA%1").arg(normalization);
SetDefaultNodeProperties(node, newname.toStdString());
nodes->push_back(node);
if(m_Controls->m_OutputCoeffsImage->isChecked())
{
mitk::Image::Pointer coeffsImage = mitk::Image::New();
coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
coeffsNode->SetData( coeffsImage );
coeffsNode->SetProperty( "name", mitk::StringProperty::New(
QString(nodename.c_str()).append("_coeffs").toStdString()) );
+ coeffsNode->SetVisibility(false);
nodes->push_back(coeffsNode);
}
}
void QmitkQBallReconstructionView::MultiQBallReconstruction(
mitk::DataStorage::SetOfObjects::Pointer inImages)
{
try
{
itk::TimeProbe clock;
int nrFiles = inImages->size();
if (!nrFiles) return;
std::vector<float> lambdas;
float minLambda = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
lambdas.push_back(minLambda);
int nLambdas = lambdas.size();
QString status;
mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
std::vector<mitk::DataNode::Pointer>* nodes
= new std::vector<mitk::DataNode::Pointer>();
while ( itemiter != itemiterend ) // for all items
{
mitk::DiffusionImage<DiffusionPixelType>* vols =
static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
(*itemiter)->GetData());
const mitk::DataNode * nodePointer = (*itemiter).GetPointer();
std::string nodename;
(*itemiter)->GetStringProperty("name",nodename);
itemiter++;
// QBALL RECONSTRUCTION
clock.Start();
MITK_INFO << "QBall reconstruction ";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
"QBall reconstruction for %s", nodename.c_str()).toAscii());
for(int i=0; i<nLambdas; i++)
{
float currentLambda = lambdas[i];
switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
{
case 0:
{
TemplatedMultiQBallReconstruction<2>(vols, currentLambda, nodePointer, nodes);
break;
}
case 1:
{
TemplatedMultiQBallReconstruction<4>(vols, currentLambda, nodePointer, nodes);
break;
}
case 2:
{
TemplatedMultiQBallReconstruction<6>(vols, currentLambda, nodePointer, nodes);
break;
}
case 3:
{
TemplatedMultiQBallReconstruction<8>(vols, currentLambda, nodePointer, nodes);
break;
}
case 4:
{
TemplatedMultiQBallReconstruction<10>(vols, currentLambda, nodePointer, nodes);
break;
}
case 5:
{
TemplatedMultiQBallReconstruction<12>(vols, currentLambda, nodePointer, nodes);
break;
}
}
clock.Stop();
MITK_DEBUG << "took " << clock.GetMeanTime() << "s." ;
mitk::ProgressBar::GetInstance()->Progress();
}
}
std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
for(nodeIt = nodes->begin(); nodeIt != nodes->end(); ++nodeIt)
GetDefaultDataStorage()->Add(*nodeIt);
m_MultiWidget->RequestUpdate();
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toAscii());
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
return ;
}
}
template<int L>
void QmitkQBallReconstructionView::TemplatedMultiQBallReconstruction(
mitk::DiffusionImage<DiffusionPixelType>* vols, float lambda,
const mitk::DataNode * dataNodePointer, std::vector<mitk::DataNode::Pointer>* nodes)
{
typedef itk::DiffusionMultiShellQballReconstructionImageFilter
<DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
typename FilterType::Pointer filter = FilterType::New();
std::string nodename;
dataNodePointer->GetStringProperty("name",nodename);
filter->SetBValueMap(m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap());
filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage(), vols->GetB_Value() );
filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
filter->SetLambda(lambda);
filter->Update();
// ODFs TO DATATREE
mitk::QBallImage::Pointer image = mitk::QBallImage::New();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
QString newname;
newname = newname.append(nodename.c_str());
newname = newname.append("_QAMultiShell");
SetDefaultNodeProperties(node, newname.toStdString());
nodes->push_back(node);
if(m_Controls->m_OutputCoeffsImage->isChecked())
{
mitk::Image::Pointer coeffsImage = mitk::Image::New();
coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
coeffsNode->SetData( coeffsImage );
coeffsNode->SetProperty( "name", mitk::StringProperty::New(
QString(nodename.c_str()).append("_coeffs").toStdString()) );
nodes->push_back(coeffsNode);
}
}
void QmitkQBallReconstructionView::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
{
node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
node->SetProperty ("layer", mitk::IntProperty::New(100));
node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
//node->SetProperty( "opacity", mitk::FloatProperty::New(1.0f) );
node->SetProperty( "name", mitk::StringProperty::New(name) );
}
//node->SetProperty( "volumerendering", mitk::BoolProperty::New( false ) );
//node->SetProperty( "use color", mitk::BoolProperty::New( true ) );
//node->SetProperty( "texture interpolation", mitk::BoolProperty::New( true ) );
//node->SetProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
//node->SetProperty( "layer", mitk::IntProperty::New(0));
//node->SetProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
//node->SetOpacity(1.0f);
//node->SetColor(1.0,1.0,1.0);
//node->SetVisibility(true);
//node->SetProperty( "IsQBallVolume", mitk::BoolProperty::New( true ) );
//mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
//mitk::LevelWindow levelwindow;
//// levelwindow.SetAuto( image );
//levWinProp->SetLevelWindow( levelwindow );
//node->GetPropertyList()->SetPropertx( "levelwindow", levWinProp );
//// add a default rainbow lookup table for color mapping
//if(!node->GetProperty("LookupTable"))
//{
// mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
// vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
// vtkLut->SetHueRange(0.6667, 0.0);
// vtkLut->SetTableRange(0.0, 20.0);
// vtkLut->Build();
// mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
// mitkLutProp->SetLookupTable(mitkLut);
// node->SetProperty( "LookupTable", mitkLutProp );
//}
//if(!node->GetProperty("binary"))
// node->SetProperty( "binary", mitk::BoolProperty::New( false ) );
//// add a default transfer function
//mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
//node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
//// set foldername as string property
//mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
//node->SetProperty( "name", nameProp );
void QmitkQBallReconstructionView::GenerateShellSelectionUI(mitk::DataStorage::SetOfObjects::Pointer set)
{
std::map<const mitk::DataNode * , QbrShellSelection * > tempMap;
const mitk::DataStorage::SetOfObjects::iterator setEnd( set->end() );
mitk::DataStorage::SetOfObjects::iterator NodeIt( set->begin() );
while(NodeIt != setEnd)
{
if(m_ShellSelectorMap.find( (*NodeIt).GetPointer() ) != m_ShellSelectorMap.end())
{
tempMap[(*NodeIt).GetPointer()] = m_ShellSelectorMap[(*NodeIt).GetPointer()];
m_ShellSelectorMap.erase((*NodeIt).GetPointer());
}else
{
tempMap[(*NodeIt).GetPointer()] = new QbrShellSelection(this, (*NodeIt) );
tempMap[(*NodeIt).GetPointer()]->SetVisible(true);
}
NodeIt++;
}
for(std::map<const mitk::DataNode * , QbrShellSelection * >::iterator it = m_ShellSelectorMap.begin(); it != m_ShellSelectorMap.end();it ++)
{
delete it->second;
}
m_ShellSelectorMap.clear();
m_ShellSelectorMap = tempMap;
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionViewControls.ui
index a8afb2c9a2..b803eb8448 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionViewControls.ui
@@ -1,349 +1,326 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkQBallReconstructionViewControls</class>
<widget class="QWidget" name="QmitkQBallReconstructionViewControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>372</width>
<height>844</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="acceptDrops">
<bool>true</bool>
</property>
<property name="windowTitle">
<string>QmitkQBallReconstructionViewControls</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<widget class="QGroupBox" name="m_InputData">
<property name="title">
<string>Please Select Input Data</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QLabel" name="label">
<property name="toolTip">
<string>Input for Q-Ball reconstruction.</string>
</property>
<property name="text">
<string>Raw DWI:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLabel" name="m_DiffusionImageLabel">
<property name="toolTip">
<string>Input for Q-Ball reconstruction.</string>
</property>
<property name="text">
<string>&lt;font color='red'&gt;mandatory&lt;/font&gt;</string>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_3">
<property name="title">
<string>Parameters</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QCheckBox" name="m_AdvancedCheckbox">
<property name="text">
<string>Advanced Settings</string>
</property>
</widget>
</item>
<item>
<widget class="QFrame" name="frame_2">
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_5">
<item row="0" column="0">
<widget class="QFrame" name="frame_3">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_4">
- <property name="leftMargin">
- <number>0</number>
- </property>
- <property name="topMargin">
- <number>0</number>
- </property>
- <property name="rightMargin">
- <number>0</number>
- </property>
- <property name="bottomMargin">
+ <property name="margin">
<number>0</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="m_QBallReconstructionThresholdLabel_2">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string>B0 Threshold</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="0" column="1">
- <widget class="QSpinBox" name="m_QBallReconstructionThreasholdEdit"/>
+ <widget class="QSpinBox" name="m_QBallReconstructionThreasholdEdit">
+ <property name="maximum">
+ <number>10000</number>
+ </property>
+ </widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="0">
<widget class="QFrame" name="m_ShFrame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_3">
- <property name="leftMargin">
- <number>0</number>
- </property>
- <property name="topMargin">
- <number>0</number>
- </property>
- <property name="rightMargin">
- <number>0</number>
- </property>
- <property name="bottomMargin">
+ <property name="margin">
<number>0</number>
</property>
<item row="0" column="0">
<widget class="QFrame" name="frame">
<property name="frameShape">
<enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_2">
- <property name="leftMargin">
- <number>0</number>
- </property>
- <property name="topMargin">
- <number>0</number>
- </property>
- <property name="rightMargin">
- <number>0</number>
- </property>
- <property name="bottomMargin">
+ <property name="margin">
<number>0</number>
</property>
<item row="3" column="0">
<widget class="QLabel" name="m_QBallReconstructionLambdaTextLabel_2">
<property name="enabled">
<bool>true</bool>
</property>
<property name="toolTip">
<string>Regularization Parameter</string>
</property>
<property name="text">
<string>Lambda:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="m_QBallReconstructionMaxLLevelTextLabel_2">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string>Maximum l-Level:</string>
</property>
<property name="wordWrap">
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QComboBox" name="m_QBallReconstructionMaxLLevelComboBox">
<property name="enabled">
<bool>true</bool>
</property>
<property name="currentIndex">
<number>-1</number>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_2">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string>Spherical Harmonics:</string>
</property>
</widget>
</item>
<item row="3" column="1">
<widget class="QDoubleSpinBox" name="m_QBallReconstructionLambdaLineEdit">
<property name="decimals">
<number>3</number>
</property>
<property name="maximum">
<double>1.000000000000000</double>
</property>
<property name="singleStep">
<double>0.001000000000000</double>
</property>
<property name="value">
<double>0.006000000000000</double>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="0">
<widget class="QCheckBox" name="m_OutputCoeffsImage">
<property name="text">
<string>Output SH-Coefficient Image</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QComboBox" name="m_QBallReconstructionMethodComboBox">
<property name="currentIndex">
<number>2</number>
</property>
<item>
<property name="text">
<string>Numerical</string>
</property>
</item>
<item>
<property name="text">
<string>Standard</string>
</property>
</item>
<item>
<property name="text">
<string>Solid Angle</string>
</property>
</item>
<item>
<property name="text">
<string>Constraint Solid Angle</string>
</property>
</item>
<item>
<property name="text">
<string>ADC-Profile only</string>
</property>
</item>
<item>
<property name="text">
<string>Raw Signal only</string>
</property>
</item>
<item>
<property name="text">
<string>Multi-Shell</string>
</property>
</item>
</widget>
</item>
<item>
<widget class="QLabel" name="m_Description">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QCommandLinkButton" name="m_ButtonStandard">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string/>
</property>
<property name="statusTip">
<string/>
</property>
<property name="whatsThis">
<string notr="true"/>
</property>
<property name="text">
<string>Start Reconstruction</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_QBallSelectionBox">
<property name="enabled">
<bool>true</bool>
</property>
<property name="layoutDirection">
<enum>Qt::LeftToRight</enum>
</property>
<property name="autoFillBackground">
<bool>false</bool>
</property>
<property name="title">
<string>Multi-Shell Reconstruction</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2"/>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>0</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<resources/>
<connections/>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
index 5c1838d2e6..65e522a80e 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
@@ -1,288 +1,289 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
#include <berryIStructuredSelection.h>
// Qmitk
#include "QmitkStochasticFiberTrackingView.h"
#include "QmitkStdMultiWidget.h"
// Qt
#include <QMessageBox>
// MITK
#include <mitkImageToItk.h>
#include <mitkFiberBundleX.h>
// VTK
#include <vtkPolyData.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkSmartPointer.h>
#include <vtkPolyLine.h>
#include <vtkCellData.h>
const std::string QmitkStochasticFiberTrackingView::VIEW_ID = "org.mitk.views.stochasticfibertracking";
const std::string id_DataManager = "org.mitk.views.datamanager";
using namespace berry;
QmitkStochasticFiberTrackingView::QmitkStochasticFiberTrackingView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
- , m_DiffusionImage( NULL )
, m_SeedRoi( NULL )
+ , m_DiffusionImage( NULL )
{
}
// Destructor
QmitkStochasticFiberTrackingView::~QmitkStochasticFiberTrackingView()
{
}
void QmitkStochasticFiberTrackingView::CreateQtPartControl( QWidget *parent )
{
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkStochasticFiberTrackingViewControls;
m_Controls->setupUi( parent );
connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
connect( m_Controls->m_SeedsPerVoxelSlider, SIGNAL(valueChanged(int)), this, SLOT(OnSeedsPerVoxelChanged(int)) );
connect( m_Controls->m_MaxCacheSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxCacheSizeChanged(int)) );
connect( m_Controls->m_MaxTractLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxTractLengthChanged(int)) );
}
}
void QmitkStochasticFiberTrackingView::OnSeedsPerVoxelChanged(int value)
{
m_Controls->m_SeedsPerVoxelLabel->setText(QString("Seeds per Voxel: ")+QString::number(value));
}
void QmitkStochasticFiberTrackingView::OnMaxTractLengthChanged(int value)
{
m_Controls->m_MaxTractLengthLabel->setText(QString("Max. Tract Length: ")+QString::number(value));
}
void QmitkStochasticFiberTrackingView::OnMaxCacheSizeChanged(int value)
{
m_Controls->m_MaxCacheSizeLabel->setText(QString("Max. Cache Size: ")+QString::number(value)+"GB");
}
void QmitkStochasticFiberTrackingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkStochasticFiberTrackingView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkStochasticFiberTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
m_DiffusionImageNode = NULL;
m_DiffusionImage = NULL;
m_SeedRoi = NULL;
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_RoiImageLabel->setText("<font color='red'>mandatory</font>");
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
if( dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
{
m_DiffusionImageNode = node;
m_DiffusionImage = dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData());
m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
}
else
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
{
m_SeedRoi = dynamic_cast<mitk::Image*>(node->GetData());
m_Controls->m_RoiImageLabel->setText(node->GetName().c_str());
}
}
}
}
if(m_DiffusionImage.IsNotNull() && m_SeedRoi.IsNotNull())
{
m_Controls->m_InputData->setTitle("Input Data");
m_Controls->commandLinkButton->setEnabled(true);
}
else
{
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->commandLinkButton->setEnabled(false);
}
}
void QmitkStochasticFiberTrackingView::DoFiberTracking()
{
typedef itk::VectorImage< short int, 3 > DWIVectorImageType;
typedef itk::Image< float, 3 > FloatImageType;
typedef itk::Image< unsigned int, 3 > CImageType;
typedef itk::StochasticTractographyFilter< DWIVectorImageType, FloatImageType, CImageType > TrackingFilterType;
typedef itk::DTITubeSpatialObject<3> DTITubeType;
typedef itk::DTITubeSpatialObjectPoint<3> DTITubePointType;
typedef itk::SceneSpatialObject<3> SceneSpatialObjectType;
/* get Gradients/Direction of dwi */
itk::VectorContainer< unsigned int, vnl_vector_fixed<double,3> >::Pointer Pdir = m_DiffusionImage->GetDirections();
/* bValueContainer, Container includes b-values according to corresponding gradient-direction*/
TrackingFilterType::bValueContainerType::Pointer vecCont = TrackingFilterType::bValueContainerType::New();
/* for each gradient set b-Value; for 0-gradient set b-value eq. 0 */
for ( int i=0; i<(int)Pdir->size(); ++i)
{
vnl_vector_fixed<double,3> valsGrad = Pdir->at(i);
if (valsGrad.get(0) == 0 && valsGrad.get(1) == 0 && valsGrad.get(2) == 0)
{ //set 0-Gradient to bValue 0
vecCont->InsertElement(i,0);
}else{
vecCont->InsertElement(i,m_DiffusionImage->GetB_Value());
}
}
/* define measurement frame (identity-matrix 3x3) */
TrackingFilterType::MeasurementFrameType measurement_frame = m_DiffusionImage->GetMeasurementFrame();
/* generate white matterImage (dummy?)*/
FloatImageType::Pointer wmImage = FloatImageType::New();
wmImage->SetSpacing( m_DiffusionImage->GetVectorImage()->GetSpacing() );
wmImage->SetOrigin( m_DiffusionImage->GetVectorImage()->GetOrigin() );
wmImage->SetDirection( m_DiffusionImage->GetVectorImage()->GetDirection() );
wmImage->SetLargestPossibleRegion( m_DiffusionImage->GetVectorImage()->GetLargestPossibleRegion() );
wmImage->SetBufferedRegion( wmImage->GetLargestPossibleRegion() );
wmImage->SetRequestedRegion( wmImage->GetLargestPossibleRegion() );
wmImage->Allocate();
itk::ImageRegionIterator<FloatImageType> ot(wmImage, wmImage->GetLargestPossibleRegion() );
while (!ot.IsAtEnd())
{
ot.Set(1);
++ot;
}
/* init TractographyFilter */
TrackingFilterType::Pointer trackingFilter = TrackingFilterType::New();
- trackingFilter->SetInput(m_DiffusionImage->GetVectorImage().GetPointer());
+ trackingFilter->SetPrimaryInput(m_DiffusionImage->GetVectorImage().GetPointer());
trackingFilter->SetbValues(vecCont);
trackingFilter->SetGradients(Pdir);
trackingFilter->SetMeasurementFrame(measurement_frame);
- trackingFilter->SetWhiteMatterProbabilityImageInput(wmImage);
+ trackingFilter->SetWhiteMatterProbabilityImage(wmImage);
trackingFilter->SetTotalTracts(m_Controls->m_SeedsPerVoxelSlider->value());
trackingFilter->SetMaxLikelihoodCacheSize(m_Controls->m_MaxCacheSizeSlider->value()*1000);
trackingFilter->SetMaxTractLength(m_Controls->m_MaxTractLengthSlider->value());
//itk::Image< char, 3 >
mitk::ImageToItk< itk::Image< unsigned char, 3 > >::Pointer binaryImageToItk1 = mitk::ImageToItk< itk::Image< unsigned char, 3 > >::New();
binaryImageToItk1->SetInput( m_SeedRoi );
binaryImageToItk1->Update();
vtkSmartPointer<vtkPoints> vPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vCellArray = vtkSmartPointer<vtkCellArray>::New();
itk::ImageRegionConstIterator< BinaryImageType > it(binaryImageToItk1->GetOutput(), binaryImageToItk1->GetOutput()->GetRequestedRegion());
- it.Begin();
+ it.GoToBegin();
mitk::Geometry3D* geom = m_DiffusionImage->GetGeometry();
while(!it.IsAtEnd())
{
itk::ImageConstIterator<BinaryImageType>::PixelType tmpPxValue = it.Get();
if(tmpPxValue != 0){
mitk::Point3D point;
itk::ImageRegionConstIterator< BinaryImageType >::IndexType seedIdx = it.GetIndex();
trackingFilter->SetSeedIndex(seedIdx);
trackingFilter->Update();
+
/* get results from Filter */
/* write each single tract into member container */
TrackingFilterType::TractContainerType::Pointer container_tmp = trackingFilter->GetOutputTractContainer();
TrackingFilterType::TractContainerType::Iterator elIt = container_tmp->Begin();
TrackingFilterType::TractContainerType::Iterator end = container_tmp->End();
bool addTract = true;
while( elIt != end ){
TrackingFilterType::TractContainerType::Element tract = elIt.Value();
TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::ConstPointer vertexlist = tract->GetVertexList();
vtkSmartPointer<vtkPolyLine> vPolyLine = vtkSmartPointer<vtkPolyLine>::New();
for( int j=0; j<(int)vertexlist->Size(); j++)
{
TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::Element vertex = vertexlist->GetElement(j);
mitk::Point3D index;
index[0] = (float)vertex[0];
index[1] = (float)vertex[1];
index[2] = (float)vertex[2];
if (geom->IsIndexInside(index))
{
geom->IndexToWorld(index, point);
vtkIdType id = vPoints->InsertNextPoint(point.GetDataPointer());
vPolyLine->GetPointIds()->InsertNextId(id);
}
else
{
addTract = false;
break;
}
}
if (addTract)
vCellArray->InsertNextCell(vPolyLine);
++elIt;
}
}
++it;
}
vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
fiberPolyData->SetPoints(vPoints);
fiberPolyData->SetLines(vCellArray);
mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberPolyData);
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(fib);
QString name("FiberBundle_");
name += m_DiffusionImageNode->GetName().c_str();
name += "_Probabilistic";
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
GetDataStorage()->Add(fbNode, m_DiffusionImageNode);
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssMetaTableModel.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssMetaTableModel.h
index b13712592e..739891fd75 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssMetaTableModel.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssMetaTableModel.h
@@ -1,54 +1,54 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkTbssMetaTableModel_h
#define QmitkTbssMetaTableModel_h
#include <QAbstractTableModel>
#include <QPair>
#include <QList>
#include <QObject>
#include <QString>
class QmitkTbssMetaTableModel : public QAbstractTableModel
{
- //Q_OBJECT
+ // TableModel to model pairs of group description and group number
public:
QmitkTbssMetaTableModel(QObject *parent=0);
QmitkTbssMetaTableModel(QList< QPair<QString, QString> > listofPairs, QObject *parent=0);
int rowCount(const QModelIndex &parent) const;
int columnCount(const QModelIndex &parent) const;
QVariant data(const QModelIndex &index, int role) const;
QVariant headerData(int section, Qt::Orientation orientation, int role) const;
Qt::ItemFlags flags(const QModelIndex &index) const;
bool setData(const QModelIndex &index, const QVariant &value, int role=Qt::EditRole);
bool insertRows(int position, int rows, const QModelIndex &index=QModelIndex());
bool removeRows(int position, int rows, const QModelIndex &index=QModelIndex());
QList< QPair<QString, QString> > getList();
private:
QList< QPair<QString, QString> > listOfPairs;
};
#endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
index 0469eac1ac..755023f702 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
@@ -1,520 +1,435 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-// Blueberry
-#include <berryIWorkbenchWindow.h>
-#include <berryIWorkbenchPage.h>
-#include <berryISelectionService.h>
-#include <berryConstants.h>
-#include <berryPlatformUI.h>
-
// Qmitk
#include "QmitkTbssSkeletonizationView.h"
-#include <QmitkStdMultiWidget.h>
-#include <mitkDataNodeObject.h>
-#include <itkCastImageFilter.h>
#include <itkSkeletonizationFilter.h>
#include <itkProjectionFilter.h>
#include <itkDistanceMapFilter.h>
#include <itkBinaryThresholdImageFilter.h>
#include <itkImageFileReader.h>
// Qt
#include <QInputDialog>
#include <QMessageBox>
//vtk
#include <vtkLinearTransform.h>
#include <vtkMatrix4x4.h>
// Boost
#include <boost/lexical_cast.hpp>
const std::string QmitkTbssSkeletonizationView::VIEW_ID = "org.mitk.views.tbssskeletonization";
using namespace berry;
-struct TbssSkeletonizationSelListener : ISelectionListener
+QmitkTbssSkeletonizationView::QmitkTbssSkeletonizationView()
+: QmitkFunctionality()
+, m_Controls( 0 )
+, m_MultiWidget( NULL )
{
- berryObjectMacro(TbssSkeletonizationSelListener)
+}
- TbssSkeletonizationSelListener(QmitkTbssSkeletonizationView* view)
- {
- m_View = view;
- }
+QmitkTbssSkeletonizationView::~QmitkTbssSkeletonizationView()
+{
+}
+
+void QmitkTbssSkeletonizationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
+{
+ //datamanager selection changed
+ if (!this->IsActivated())
+ return;
+ bool found3dImage = false;
+ bool found4dImage = false;
- void DoSelectionChanged(ISelection::ConstPointer selection)
+ // iterate selection
+ for ( int i=0; i<nodes.size(); i++ )
{
- // 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 found3dImage = false;
- bool found4dImage = false;
+ // only look at interesting types from valid nodes
+ mitk::BaseData* nodeData = nodes[i]->GetData();
- // iterate selection
- for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
- i != m_View->m_CurrentSelection->End(); ++i)
+ if(nodeData)
+ {
+ if(QString("Image").compare(nodeData->GetNameOfClass())==0)
{
-
- // extract datatree node
- if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
+ mitk::Image* img = static_cast<mitk::Image*>(nodeData);
+ if(img->GetDimension() == 3)
{
- mitk::DataNode::Pointer node = nodeObj->GetDataNode();
-
- // only look at interesting types
- // from valid nodes
- mitk::BaseData* nodeData = node->GetData();
-
- if(nodeData)
- {
- if(QString("Image").compare(nodeData->GetNameOfClass())==0)
- {
- mitk::Image* img = static_cast<mitk::Image*>(nodeData);
- if(img->GetDimension() == 3)
- {
- found3dImage = true;
- }
- else if(img->GetDimension() == 4)
- {
- found4dImage = true;
- }
- }
- }
+ found3dImage = true;
+ }
+ else if(img->GetDimension() == 4)
+ {
+ found4dImage = true;
}
-
}
-
- m_View->m_Controls->m_Skeletonize->setEnabled(found3dImage);
- m_View->m_Controls->m_Project->setEnabled(found3dImage && found4dImage);
- m_View->m_Controls->m_OutputMask->setEnabled(found3dImage && found4dImage);
- m_View->m_Controls->m_OutputDistanceMap->setEnabled(found3dImage && found4dImage);
}
- }
-
- 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);
- }
- }
}
- QmitkTbssSkeletonizationView* m_View;
-};
-
-
-QmitkTbssSkeletonizationView::QmitkTbssSkeletonizationView()
-: QmitkFunctionality()
-, m_Controls( 0 )
-, m_MultiWidget( NULL )
-{
+ this->m_Controls->m_Skeletonize->setEnabled(found3dImage);
+ this->m_Controls->m_Project->setEnabled(found3dImage && found4dImage);
+ this->m_Controls->m_OutputMask->setEnabled(found3dImage && found4dImage);
+ this->m_Controls->m_OutputDistanceMap->setEnabled(found3dImage && found4dImage);
}
-QmitkTbssSkeletonizationView::~QmitkTbssSkeletonizationView()
-{
-}
-
-void QmitkTbssSkeletonizationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
-{
- //datamanager selection changed
- if (!this->IsActivated())
- return;
-}
-
void QmitkTbssSkeletonizationView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkTbssSkeletonizationViewControls;
m_Controls->setupUi( parent );
this->CreateConnections();
}
- m_SelListener = berry::ISelectionListener::Pointer(new TbssSkeletonizationSelListener(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<TbssSkeletonizationSelListener>()->DoSelectionChanged(sel);
-
- m_IsInitialized = false;
-
-
-
}
void QmitkTbssSkeletonizationView::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<TbssSkeletonizationSelListener>()->DoSelectionChanged(sel);
}
void QmitkTbssSkeletonizationView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
void QmitkTbssSkeletonizationView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_Skeletonize), SIGNAL(clicked()), this, SLOT(Skeletonize() ));
connect( (QObject*)(m_Controls->m_Project), SIGNAL(clicked()), this, SLOT(Project() ));
}
}
void QmitkTbssSkeletonizationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkTbssSkeletonizationView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkTbssSkeletonizationView::Skeletonize()
{
typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
- if (m_CurrentSelection)
- {
- mitk::DataStorage::SetOfObjects::Pointer set =
- mitk::DataStorage::SetOfObjects::New();
+ std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
- mitk::Image::Pointer meanImage = mitk::Image::New();
- 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();
+ mitk::Image::Pointer meanImage = mitk::Image::New();
+ std::string name = "";
- // process only on valid nodes
- mitk::BaseData* nodeData = node->GetData();
+ for ( int i=0; i<nodes.size(); i++ )
+ {
+ // process only on valid nodes
+ mitk::BaseData* nodeData = nodes[i]->GetData();
- if(nodeData)
+ if(nodeData)
+ {
+ if(QString("Image").compare(nodeData->GetNameOfClass())==0)
+ {
+ mitk::Image* img = static_cast<mitk::Image*>(nodeData);
+ if(img->GetDimension() == 3)
{
- if(QString("Image").compare(nodeData->GetNameOfClass())==0)
- {
- mitk::Image* img = static_cast<mitk::Image*>(nodeData);
- if(img->GetDimension() == 3)
- {
- meanImage = img;
- }
- }
+ meanImage = img;
+ name = nodes[i]->GetName();
}
}
}
+ }
- // Calculate skeleton
- FloatImageType::Pointer itkImg = FloatImageType::New();
- mitk::CastToItkImage(meanImage, itkImg);
- skeletonizer->SetInput(itkImg);
- skeletonizer->Update();
+ // Calculate skeleton
+ FloatImageType::Pointer itkImg = FloatImageType::New();
+ mitk::CastToItkImage(meanImage, itkImg);
+ skeletonizer->SetInput(itkImg);
+ skeletonizer->Update();
+
+
+ FloatImageType::Pointer output = skeletonizer->GetOutput();
+ mitk::Image::Pointer mitkOutput = mitk::Image::New();
+ mitk::CastToMitkImage(output, mitkOutput);
+ name += "_skeleton";
+ AddToDataStorage(mitkOutput, name);
- FloatImageType::Pointer output = skeletonizer->GetOutput();
- mitk::Image::Pointer mitkOutput = mitk::Image::New();
- mitk::CastToMitkImage(output, mitkOutput);
- AddToDataStorage(mitkOutput, "all_FA_skeletonised");
- }
}
void QmitkTbssSkeletonizationView::Project()
{
+
typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
typedef itk::ProjectionFilter ProjectionFilterType;
typedef itk::DistanceMapFilter<FloatImageType, FloatImageType> DistanceMapFilterType;
SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
- if (m_CurrentSelection)
- {
- mitk::DataStorage::SetOfObjects::Pointer set =
- mitk::DataStorage::SetOfObjects::New();
- mitk::Image::Pointer meanImage = mitk::Image::New();
- mitk::Image::Pointer subjects = mitk::Image::New();
+ std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
- 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();
- // process only on valid nodes
- mitk::BaseData* nodeData = node->GetData();
+ mitk::Image::Pointer meanImage = mitk::Image::New();
+ mitk::Image::Pointer subjects = mitk::Image::New();
+
+ for ( int i=0; i<nodes.size(); i++ )
+ {
+ // process only on valid nodes
+ mitk::BaseData* nodeData = nodes[i]->GetData();
- if(nodeData)
+ if(nodeData)
+ {
+ if(QString("Image").compare(nodeData->GetNameOfClass())==0)
+ {
+ mitk::Image* img = static_cast<mitk::Image*>(nodeData);
+ if(img->GetDimension() == 3)
{
- if(QString("Image").compare(nodeData->GetNameOfClass())==0)
- {
- mitk::Image* img = static_cast<mitk::Image*>(nodeData);
- if(img->GetDimension() == 3)
- {
- meanImage = img;
- }
- else if(img->GetDimension() == 4)
- {
- subjects = img;
- }
- }
+ meanImage = img;
+ }
+ else if(img->GetDimension() == 4)
+ {
+ subjects = img;
}
-
}
}
- Float4DImageType::Pointer allFA = ConvertToItk(subjects);
+ }
+ Float4DImageType::Pointer allFA = ConvertToItk(subjects);
- // Calculate skeleton
- FloatImageType::Pointer itkImg = FloatImageType::New();
- mitk::CastToItkImage(meanImage, itkImg);
- skeletonizer->SetInput(itkImg);
- skeletonizer->Update();
+ // Calculate skeleton
+ FloatImageType::Pointer itkImg = FloatImageType::New();
+ mitk::CastToItkImage(meanImage, itkImg);
+ skeletonizer->SetInput(itkImg);
+ skeletonizer->Update();
- FloatImageType::Pointer output = skeletonizer->GetOutput();
- mitk::Image::Pointer mitkOutput = mitk::Image::New();
- mitk::CastToMitkImage(output, mitkOutput);
- AddToDataStorage(mitkOutput, "mean_FA_skeletonised");
+ FloatImageType::Pointer output = skeletonizer->GetOutput();
+ mitk::Image::Pointer mitkOutput = mitk::Image::New();
+ mitk::CastToMitkImage(output, mitkOutput);
+ AddToDataStorage(mitkOutput, "mean_FA_skeletonised");
- // Retrieve direction image needed later by the projection filter
- DirectionImageType::Pointer directionImg = skeletonizer->GetVectorImage();
+ // Retrieve direction image needed later by the projection filter
+ DirectionImageType::Pointer directionImg = skeletonizer->GetVectorImage();
- // Calculate distance image
- DistanceMapFilterType::Pointer distanceMapFilter = DistanceMapFilterType::New();
- distanceMapFilter->SetInput(output);
- distanceMapFilter->Update();
- FloatImageType::Pointer distanceMap = distanceMapFilter->GetOutput();
+ // Calculate distance image
+ DistanceMapFilterType::Pointer distanceMapFilter = DistanceMapFilterType::New();
+ distanceMapFilter->SetInput(output);
+ distanceMapFilter->Update();
+ FloatImageType::Pointer distanceMap = distanceMapFilter->GetOutput();
- if(m_Controls->m_OutputDistanceMap->isChecked())
- {
- mitk::Image::Pointer mitkDistance = mitk::Image::New();
- mitk::CastToMitkImage(distanceMap, mitkDistance);
- AddToDataStorage(mitkDistance, "distance map");
- }
+ if(m_Controls->m_OutputDistanceMap->isChecked())
+ {
+ mitk::Image::Pointer mitkDistance = mitk::Image::New();
+ mitk::CastToMitkImage(distanceMap, mitkDistance);
+ AddToDataStorage(mitkDistance, "distance map");
+ }
- // Do projection
+ // Do projection
- // Ask a threshold to create a skeleton mask
- double threshold = -1.0;
- while(threshold == -1.0)
- {
- threshold = QInputDialog::getDouble(m_Controls->m_Skeletonize, tr("Specify the FA threshold"),
- tr("Threshold:"), QLineEdit::Normal,
- 0.2);
+ // Ask a threshold to create a skeleton mask
+ double threshold = -1.0;
+ while(threshold == -1.0)
+ {
+ threshold = QInputDialog::getDouble(m_Controls->m_Skeletonize, tr("Specify the FA threshold"),
+ tr("Threshold:"), QLineEdit::Normal,
+ 0.2);
- if(threshold < 0.0 || threshold > 1.0)
- {
- QMessageBox msgBox;
- msgBox.setText("Please choose a value between 0 and 1");
- msgBox.exec();
- threshold = -1.0;
- }
+ if(threshold < 0.0 || threshold > 1.0)
+ {
+ QMessageBox msgBox;
+ msgBox.setText("Please choose a value between 0 and 1");
+ msgBox.exec();
+ threshold = -1.0;
}
+ }
- typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> ThresholdFilterType;
- ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New();
- thresholder->SetInput(output);
- thresholder->SetLowerThreshold(threshold);
- thresholder->SetUpperThreshold(std::numeric_limits<float>::max());
- thresholder->SetOutsideValue(0);
- thresholder->SetInsideValue(1);
- thresholder->Update();
+ typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> ThresholdFilterType;
+ ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New();
+ thresholder->SetInput(output);
+ thresholder->SetLowerThreshold(threshold);
+ thresholder->SetUpperThreshold(std::numeric_limits<float>::max());
+ thresholder->SetOutsideValue(0);
+ thresholder->SetInsideValue(1);
+ thresholder->Update();
- CharImageType::Pointer thresholdedImg = thresholder->GetOutput();
+ CharImageType::Pointer thresholdedImg = thresholder->GetOutput();
- if(m_Controls->m_OutputMask->isChecked())
- {
- mitk::Image::Pointer mitkThresholded = mitk::Image::New();
- mitk::CastToMitkImage(thresholdedImg, mitkThresholded);
- std::string maskName = "skeleton_mask_at_" + boost::lexical_cast<std::string>(threshold);
- AddToDataStorage(mitkThresholded, maskName);
- }
+ if(m_Controls->m_OutputMask->isChecked())
+ {
+ mitk::Image::Pointer mitkThresholded = mitk::Image::New();
+ mitk::CastToMitkImage(thresholdedImg, mitkThresholded);
+ std::string maskName = "skeleton_mask_at_" + boost::lexical_cast<std::string>(threshold);
+ AddToDataStorage(mitkThresholded, maskName);
+ }
- typedef itk::ImageFileReader< CharImageType > CharReaderType;
- CharReaderType::Pointer reader = CharReaderType::New();
- reader->SetFileName("/local/testing/LowerCingulum_1mm.nii.gz");
- reader->Update();
- CharImageType::Pointer cingulum = reader->GetOutput();
+ typedef itk::ImageFileReader< CharImageType > CharReaderType;
+ CharReaderType::Pointer reader = CharReaderType::New();
+ reader->SetFileName("/local/testing/LowerCingulum_1mm.nii.gz");
+ reader->Update();
+ CharImageType::Pointer cingulum = reader->GetOutput();
- ProjectionFilterType::Pointer projectionFilter = ProjectionFilterType::New();
- projectionFilter->SetDistanceMap(distanceMap);
- projectionFilter->SetDirections(directionImg);
- projectionFilter->SetAllFA(allFA);
- projectionFilter->SetTube(cingulum);
- projectionFilter->SetSkeleton(thresholdedImg);
- projectionFilter->Project();
+ ProjectionFilterType::Pointer projectionFilter = ProjectionFilterType::New();
+ projectionFilter->SetDistanceMap(distanceMap);
+ projectionFilter->SetDirections(directionImg);
+ projectionFilter->SetAllFA(allFA);
+ projectionFilter->SetTube(cingulum);
+ projectionFilter->SetSkeleton(thresholdedImg);
+ projectionFilter->Project();
- Float4DImageType::Pointer projected = projectionFilter->GetProjections();
+ Float4DImageType::Pointer projected = projectionFilter->GetProjections();
+
+ mitk::Image::Pointer mitkProjections = mitk::Image::New();
+ mitk::CastToMitkImage(projected, mitkProjections);
+
+ AddToDataStorage(mitkProjections, "all_FA_projected");
- mitk::Image::Pointer mitkProjections = mitk::Image::New();
- mitk::CastToMitkImage(projected, mitkProjections);
- AddToDataStorage(mitkProjections, "all_FA_projected");
- }
}
void QmitkTbssSkeletonizationView::AddToDataStorage(mitk::Image* img, std::string name)
{
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetProperty( "name", mitk::StringProperty::New(name) );
result->SetData( img );
// add new image to data storage and set as active to ease further processing
GetDefaultDataStorage()->Add( result );
}
Float4DImageType::Pointer QmitkTbssSkeletonizationView::ConvertToItk(mitk::Image::Pointer image)
{
Float4DImageType::Pointer output = Float4DImageType::New();
mitk::Geometry3D* geo = image->GetGeometry();
mitk::Vector3D mitkSpacing = geo->GetSpacing();
mitk::Point3D mitkOrigin = geo->GetOrigin();
Float4DImageType::SpacingType spacing;
spacing[0] = mitkSpacing[0];
spacing[1] = mitkSpacing[1];
spacing[2] = mitkSpacing[2];
spacing[3] = 1.0; // todo: check if spacing has length 4
Float4DImageType::PointType origin;
origin[0] = mitkOrigin[0];
origin[1] = mitkOrigin[1];
origin[2] = mitkOrigin[2];
origin[3] = 0;
Float4DImageType::SizeType size;
size[0] = image->GetDimension(0);
size[1] = image->GetDimension(1);
size[2] = image->GetDimension(2);
size[3] = image->GetDimension(3);
Float4DImageType::DirectionType dir;
vtkLinearTransform* lin = geo->GetVtkTransform();
vtkMatrix4x4 *m = lin->GetMatrix();
dir.Fill(0.0);
for(int x=0; x<3; x++)
{
for(int y=0; y<3; y++)
{
dir[x][y] = m->GetElement(x,y);
}
}
dir[3][3] = 1;
output->SetSpacing(spacing);
output->SetOrigin(origin);
output->SetRegions(size);
output->SetDirection(dir);
output->Allocate();
if(image->GetDimension() == 4)
{
int timesteps = image->GetDimension(3);
// iterate through the subjects and copy data to output
for(int t=0; t<timesteps; t++)
{
for(int x=0; x<image->GetDimension(0); x++)
{
for(int y=0; y<image->GetDimension(1); y++)
{
for(int z=0; z<image->GetDimension(2); z++)
{
itk::Index<4> ix4;
ix4[0] = x;
ix4[1] = y;
ix4[2] = z;
ix4[3] = t;
mitk::Index3D ix;
ix[0] = x;
ix[1] = y;
ix[2] = z;
output->SetPixel(ix4, image->GetPixelValueByIndex(ix, t));
}
}
}
}
}
return output;
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h
index 42d4763751..683c7bdd1b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h
@@ -1,122 +1,95 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkTbssSkeletonizationView_h
#define QmitkTbssSkeletonizationView_h
-// Blueberry
-#include <berryISelectionListener.h>
-#include <berryIPartListener.h>
-#include <berryIStructuredSelection.h>
-
-// itk
-#include "itkImage.h"
-#include "itkVectorImage.h"
#include <QmitkFunctionality.h>
-
#include "ui_QmitkTbssSkeletonizationViewControls.h"
typedef itk::Image<float, 3> FloatImageType;
typedef itk::Image<char, 3> CharImageType;
typedef itk::Image<float, 4> Float4DImageType;
typedef itk::CovariantVector<int,3> VectorType;
typedef itk::Image<VectorType, 3> DirectionImageType;
-struct TbssSkeletonizationSelListener;
-
-
/*!
- \brief QmitkTbssSkeletonizationView
-
- \warning This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
-
- \sa QmitkFunctionalitymitkTbssWorkspaceManager
- \ingroup Functionalities
+ * \brief Implementation of the core functionality of TBSS.
+ * This plugin provides the core functionality of TBSS (see Smith et al., 2009. http://dx.doi.org/10.1016/j.neuroimage.2006.02.024)
+ * It can skeletonize a mean FA image and calculate the projection of all individual subjects to this skeleton.
*/
+
class QmitkTbssSkeletonizationView : public QmitkFunctionality
{
-
- friend struct TbssSkeletonizationSelListener;
-
-
-
- // this is needed for all Qt objesetupUicts that should have a Qt meta-object
- // (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkTbssSkeletonizationView();
virtual ~QmitkTbssSkeletonizationView();
virtual void CreateQtPartControl(QWidget *parent);
- /// \brief Creation of the connections of main and control widget
+ //Creation of the connections of main and control widget
virtual void CreateConnections();
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
/// \brief Called when the functionality is activated
virtual void Activated();
virtual void Deactivated();
protected slots:
+ /* \brief Perform skeletonization only */
void Skeletonize();
+
+ // Perform skeletonization and Projection of subject data to the skeleton
void Project();
protected:
- /// \brief called by QmitkFunctionality when DataManager's selection has changed
+ //brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
- void InitPointsets();
-
- void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
-
- berry::ISelectionListener::Pointer m_SelListener;
- berry::IStructuredSelection::ConstPointer m_CurrentSelection;
-
- bool m_IsInitialized;
-
Ui::QmitkTbssSkeletonizationViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
void AddToDataStorage(mitk::Image* img, std::string name);
Float4DImageType::Pointer ConvertToItk(mitk::Image::Pointer image);
};
#endif // _QMITKTbssSkeletonizationVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationViewControls.ui
index 55f6829fa8..3a238d4d04 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationViewControls.ui
@@ -1,71 +1,74 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkTbssSkeletonizationViewControls</class>
<widget class="QWidget" name="QmitkTbssSkeletonizationViewControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>431</width>
<height>811</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="windowTitle">
<string>QmitkTemplate</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_9">
<item>
<widget class="QPushButton" name="m_Skeletonize">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Skeletonize</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_Project">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
<property name="text">
<string>Skeletonize and Project</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="m_OutputMask">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Output binary mask</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="m_OutputDistanceMap">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Output distance map</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<resources/>
<connections/>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
index b471a69636..db6de5555f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
@@ -1,2133 +1,1132 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-// Blueberry
-#include "berryIWorkbenchWindow.h"
-#include "berryIWorkbenchPage.h"
-#include "berryISelectionService.h"
-#include "berryConstants.h"
-#include "berryPlatformUI.h"
-
// Qmitk
#include "QmitkTractbasedSpatialStatisticsView.h"
#include "QmitkStdMultiWidget.h"
#include "mitkDataNodeObject.h"
#include <itkCastImageFilter.h>
// Qt
#include <QMessageBox>
-#include <qfiledialog.h>
-#include <QDirIterator>
#include <QInputDialog>
-#include <QDir>
-#include <QStringList>
-#include <QMessageBox>
-#include <QSortFilterProxyModel>
#include <QClipboard>
-#include <itkNiftiImageIO.h>
-#include <itkImageFileReader.h>
-
-#include <iostream>
-#include <fstream>
-#include <limits>
-
-#include <itkMultiplyImageFilter.h>
#include <mitkTractAnalyzer.h>
#include <mitkTbssImporter.h>
-#include <mitkProgressBar.h>
#include <mitkPlanarCircle.h>
#include <mitkPlanarFigureInteractor.h>
-#include <mitkVectorImageMapper2D.h>
-#include "vtkFloatArray.h"
-#include "vtkLinearTransform.h"
#include "vtkPoints.h"
-#include "mitkSurface.h"
-#include <vtkGlyph3D.h>
-#include "vtkArrowSource.h"
-#include "vtkUnstructuredGrid.h"
-#include "vtkPointData.h"
#include <vtkCellArray.h>
#include <vtkPolyLine.h>
-#include <boost/graph/graph_traits.hpp>
-#include <boost/graph/adjacency_list.hpp>
-#include <boost/graph/dijkstra_shortest_paths.hpp>
-
-#include <QMessageBox>
-
-#include "mitkITKImageImport.h"
-// #include "mitkImageMapperGL2D.h"
-#include "mitkVolumeDataVtkMapper3D.h"
-#include "mitkImageAccessByItk.h"
-#include "mitkTensorImage.h"
-
-#include "itkDiffusionTensor3D.h"
-
-
-#define SEARCHSIGMA 10 /* length in linear voxel dimens
- {
- // create new ones
- m_PointSetNode = mitk::PointSet::New();ions */
-#define MAXSEARCHLENGTH (3*SEARCHSIGMA)
const std::string QmitkTractbasedSpatialStatisticsView::VIEW_ID = "org.mitk.views.tractbasedspatialstatistics";
using namespace berry;
-struct TbssSelListener : ISelectionListener
-{
-
- berryObjectMacro(TbssSelListener)
-
- TbssSelListener(QmitkTractbasedSpatialStatisticsView* 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 foundTbssRoi = false;
- bool foundTbss = false;
- bool found3dImage = false;
- bool found4dImage = false;
- bool foundFiberBundle = false;
- bool foundStartRoi = false;
- bool foundEndRoi = false;
-
- mitk::TbssRoiImage* roiImage;
- mitk::TbssImage* image;
- mitk::Image* img;
- mitk::FiberBundleX* fib;
- mitk::PlanarFigure* start;
- mitk::PlanarFigure* end;
-
- m_View->m_CurrentStartRoi = NULL;
- m_View->m_CurrentEndRoi = NULL;
-
-
- // 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
- // check for valid data
- mitk::BaseData* nodeData = node->GetData();
- if( nodeData )
- {
- if(QString("TbssRoiImage").compare(nodeData->GetNameOfClass())==0)
- {
- foundTbssRoi = true;
- roiImage = static_cast<mitk::TbssRoiImage*>(nodeData);
- }
- else if (QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
- {
- foundTbss = true;
- image = static_cast<mitk::TbssImage*>(nodeData);
- }
- else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
- {
- img = static_cast<mitk::Image*>(nodeData);
- if(img->GetDimension() == 3)
- {
- found3dImage = true;
- }
- else if(img->GetDimension() == 4)
- {
- found4dImage = true;
- }
- }
-
- else if (QString("FiberBundleX").compare(nodeData->GetNameOfClass())==0)
- {
- foundFiberBundle = true;
- fib = static_cast<mitk::FiberBundleX*>(nodeData);
- m_View->m_CurrentFiberNode = node;
- }
-
-
- std::string name = nodeData->GetNameOfClass();
- if(QString("PlanarCircle").compare(nodeData->GetNameOfClass())==0)
- {
- if(!foundStartRoi)
- {
- start = dynamic_cast<mitk::PlanarFigure*>(nodeData);
- m_View->m_CurrentStartRoi = node;
- foundStartRoi = true;
- }
- else
- {
- end = dynamic_cast<mitk::PlanarFigure*>(nodeData);
- m_View->m_CurrentEndRoi = node;
- foundEndRoi = true;
- }
- }
- } // end CHECK nodeData != NULL
-
- }
-
- }
-
- m_View->m_Controls->m_CreateRoi->setEnabled(found3dImage);
- m_View->m_Controls->m_ImportFsl->setEnabled(found4dImage);
-
-
-
- if(foundTbss && foundTbssRoi)
- {
- m_View->Plot(image, roiImage);
- }
-
- if(found3dImage && foundFiberBundle && foundStartRoi && foundEndRoi)
- {
- m_View->PlotFiberBundle(fib, img, start, end);
-
- }
- else if(found3dImage == true && foundFiberBundle)
- {
- m_View->PlotFiberBundle(fib, img);
- }
-
- if(found3dImage)
- {
- m_View->InitPointsets();
- }
-
- m_View->m_Controls->m_Cut->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi);
- m_View->m_Controls->m_SegmentLabel->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
- m_View->m_Controls->m_Segments->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
- m_View->m_Controls->m_Average->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
-
-
- }
- }
-
-
- 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);
- }
- }
- }
-
- QmitkTractbasedSpatialStatisticsView* m_View;
-};
-
-
QmitkTractbasedSpatialStatisticsView::QmitkTractbasedSpatialStatisticsView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
{
}
QmitkTractbasedSpatialStatisticsView::~QmitkTractbasedSpatialStatisticsView()
{
}
void QmitkTractbasedSpatialStatisticsView::PerformChange()
{
m_Controls->m_RoiPlotWidget->ModifyPlot(m_Controls->m_Segments->value(), m_Controls->m_Average->isChecked());
}
void QmitkTractbasedSpatialStatisticsView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
{
//datamanager selection changed
if (!this->IsActivated())
return;
-
+/*
// Get DataManagerSelection
if (!this->GetDataManagerSelection().empty())
{
mitk::DataNode::Pointer sourceImageNode = this->GetDataManagerSelection().front();
mitk::Image::Pointer sourceImage = dynamic_cast<mitk::Image*>(sourceImageNode->GetData());
if (!sourceImage)
{
m_Controls->m_TbssImageLabel->setText(
QString( sourceImageNode->GetName().c_str() ) + " is no image"
);
return;
}
// set Text
m_Controls->m_TbssImageLabel->setText(
QString( sourceImageNode->GetName().c_str() ) + " (" +
QString::number(sourceImage->GetDimension()) + "D)"
);
}
else
{
m_Controls->m_TbssImageLabel->setText("Please select an image");
}
+*/
+
+ // Check which datatypes are selected in the datamanager and enable/disable widgets accordingly
+
+ bool foundTbssRoi = false;
+ bool foundTbss = false;
+ bool found3dImage = false;
+ bool found4dImage = false;
+ bool foundFiberBundle = false;
+ bool foundStartRoi = false;
+ bool foundEndRoi = false;
+
+ mitk::TbssRoiImage* roiImage;
+ mitk::TbssImage* image;
+ mitk::Image* img;
+ mitk::FiberBundleX* fib;
+ mitk::PlanarFigure* start;
+ mitk::PlanarFigure* end;
+
+ m_CurrentStartRoi = NULL;
+ m_CurrentEndRoi = NULL;
+
+
+
+ for ( int i=0; i<nodes.size(); i++ )
+ {
+
+ // only look at interesting types
+ // check for valid data
+ mitk::BaseData* nodeData = nodes[i]->GetData();
+ if( nodeData )
+ {
+ if(QString("TbssRoiImage").compare(nodeData->GetNameOfClass())==0)
+ {
+ foundTbssRoi = true;
+ roiImage = static_cast<mitk::TbssRoiImage*>(nodeData);
+ }
+ else if (QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
+ {
+ foundTbss = true;
+ image = static_cast<mitk::TbssImage*>(nodeData);
+ }
+ else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
+ {
+ img = static_cast<mitk::Image*>(nodeData);
+ if(img->GetDimension() == 3)
+ {
+ found3dImage = true;
+ }
+ else if(img->GetDimension() == 4)
+ {
+ found4dImage = true;
+ }
+ }
+
+ else if (QString("FiberBundleX").compare(nodeData->GetNameOfClass())==0)
+ {
+ foundFiberBundle = true;
+ fib = static_cast<mitk::FiberBundleX*>(nodeData);
+ this->m_CurrentFiberNode = nodes[i];
+ }
+
+
+ if(QString("PlanarCircle").compare(nodeData->GetNameOfClass())==0)
+ {
+ if(!foundStartRoi)
+ {
+ start = dynamic_cast<mitk::PlanarFigure*>(nodeData);
+ this->m_CurrentStartRoi = nodes[i];
+ foundStartRoi = true;
+ }
+ else
+ {
+ end = dynamic_cast<mitk::PlanarFigure*>(nodeData);
+ this->m_CurrentEndRoi = nodes[i];
+ foundEndRoi = true;
+ }
+ }
+ }
+ }
+
+
+ this->m_Controls->m_CreateRoi->setEnabled(found3dImage);
+ this->m_Controls->m_ImportFsl->setEnabled(found4dImage);
+
+
+
+ if(foundTbss && foundTbssRoi)
+ {
+ this->Plot(image, roiImage);
+ }
+
+ if(found3dImage && foundFiberBundle && foundStartRoi && foundEndRoi)
+ {
+ this->PlotFiberBundle(fib, img, start, end);
+ }
+
+ else if(found3dImage == true && foundFiberBundle)
+ {
+ this->PlotFiberBundle(fib, img);
+ }
+
+ if(found3dImage)
+ {
+ this->InitPointsets();
+ }
+
+ this->m_Controls->m_Cut->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi);
+ this->m_Controls->m_SegmentLabel->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
+ this->m_Controls->m_Segments->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
+ this->m_Controls->m_Average->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
}
void QmitkTractbasedSpatialStatisticsView::InitPointsets()
{
// Check if PointSetStart exsits, if not create it.
m_P1 = this->GetDefaultDataStorage()->GetNamedNode("PointSetNode");
if (m_PointSetNode)
{
//m_PointSetNode = dynamic_cast<mitk::PointSet*>(m_P1->GetData());
return;
}
if ((!m_P1) || (!m_PointSetNode))
{
// create new ones
m_PointSetNode = mitk::PointSet::New();
m_P1 = mitk::DataNode::New();
m_P1->SetData( m_PointSetNode );
m_P1->SetProperty( "name", mitk::StringProperty::New( "PointSet" ) );
m_P1->SetProperty( "opacity", mitk::FloatProperty::New( 1 ) );
m_P1->SetProperty( "helper object", mitk::BoolProperty::New(true) ); // CHANGE if wanted
m_P1->SetProperty( "pointsize", mitk::FloatProperty::New( 0.1 ) );
m_P1->SetColor( 1.0, 0.0, 0.0 );
this->GetDefaultDataStorage()->Add(m_P1);
m_Controls->m_PointWidget->SetPointSetNode(m_P1);
m_Controls->m_PointWidget->SetMultiWidget(GetActiveStdMultiWidget());
}
}
void QmitkTractbasedSpatialStatisticsView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkTractbasedSpatialStatisticsViewControls;
m_Controls->setupUi( parent );
this->CreateConnections();
}
- m_SelListener = berry::ISelectionListener::Pointer(new TbssSelListener(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<TbssSelListener>()->DoSelectionChanged(sel);
-
- m_IsInitialized = false;
-
-
// Table for the FSL TBSS import
m_GroupModel = new QmitkTbssTableModel();
m_Controls->m_GroupInfo->setModel(m_GroupModel);
}
void QmitkTractbasedSpatialStatisticsView::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<TbssSelListener>()->DoSelectionChanged(sel);
}
void QmitkTractbasedSpatialStatisticsView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
void QmitkTractbasedSpatialStatisticsView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_CreateRoi), SIGNAL(clicked()), this, SLOT(CreateRoi()) );
connect( (QObject*)(m_Controls->m_ImportFsl), SIGNAL(clicked()), this, SLOT(TbssImport()) );
connect( (QObject*)(m_Controls->m_AddGroup), SIGNAL(clicked()), this, SLOT(AddGroup()) );
connect( (QObject*)(m_Controls->m_RemoveGroup), SIGNAL(clicked()), this, SLOT(RemoveGroup()) );
connect( (QObject*)(m_Controls->m_Clipboard), SIGNAL(clicked()), this, SLOT(CopyToClipboard()) );
connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(selected(const QwtDoublePoint&)), SLOT(Clicked(const QwtDoublePoint&) ) );
connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(moved(const QwtDoublePoint&)), SLOT(Clicked(const QwtDoublePoint&) ) );
connect( (QObject*)(m_Controls->m_Cut), SIGNAL(clicked()), this, SLOT(Cut()) );
connect( (QObject*)(m_Controls->m_Average), SIGNAL(stateChanged(int)), this, SLOT(PerformChange()) );
connect( (QObject*)(m_Controls->m_Segments), SIGNAL(valueChanged(int)), this, SLOT(PerformChange()) );
}
}
void QmitkTractbasedSpatialStatisticsView::CopyToClipboard()
{
if(m_Controls->m_RoiPlotWidget->IsPlottingFiber())
{
// Working with fiber bundles
std::vector <std::vector<double> > profiles = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
-
-
QString clipboardText;
for (std::vector<std::vector<double> >::iterator it = profiles.begin(); it
!= profiles.end(); ++it)
{
for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
(*it).end(); ++it2)
{
clipboardText.append(QString("%1 \t").arg(*it2));
}
clipboardText.append(QString("\n"));
}
if(m_Controls->m_Average->isChecked())
{
std::vector<double> averages = m_Controls->m_RoiPlotWidget->GetAverageProfile();
clipboardText.append(QString("\nAverage\n"));
for (std::vector<double>::iterator it2 = averages.begin(); it2 !=
averages.end(); ++it2)
{
clipboardText.append(QString("%1 \t").arg(*it2));
}
}
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
}
else{
// Working with TBSS Data
if(m_Controls->m_Average->isChecked())
{
std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetVals();
QString clipboardText;
for (std::vector<std::vector<double> >::iterator it = vals.begin(); it
!= vals.end(); ++it)
{
for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
(*it).end(); ++it2)
{
clipboardText.append(QString("%1 \t").arg(*it2));
double d = *it2;
std::cout << d <<std::endl;
}
clipboardText.append(QString("\n"));
}
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
}
else
{
std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
QString clipboardText;
for (std::vector<std::vector<double> >::iterator it = vals.begin(); it
!= vals.end(); ++it)
{
for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
(*it).end(); ++it2)
{
clipboardText.append(QString("%1 \t").arg(*it2));
double d = *it2;
std::cout << d <<std::endl;
}
clipboardText.append(QString("\n"));
}
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
}
}
}
void QmitkTractbasedSpatialStatisticsView::RemoveGroup()
{
QTableView *temp = static_cast<QTableView*>(m_Controls->m_GroupInfo);
- // QSortFilterProxyModel *proxy = static_cast<QSortFilterProxyModel*>(temp->model());
+
QItemSelectionModel *selectionModel = temp->selectionModel();
QModelIndexList indices = selectionModel->selectedRows();
QModelIndex index;
foreach(index, indices)
{
int row = index.row();
m_GroupModel->removeRows(row, 1, QModelIndex());
}
}
-std::string QmitkTractbasedSpatialStatisticsView::ReadFile(std::string whatfile)
-{
- std::string s = "Select a" + whatfile;
- QFileDialog* w = new QFileDialog(this->m_Controls->m_ImportFsl, QString(s.c_str()) );
- w->setFileMode(QFileDialog::ExistingFiles);
- w->setDirectory("/home");
- if(whatfile == "gradient image")
- {
- w->setNameFilter("Tbss gradient images (*.tgi)");
- }
-
- // RETRIEVE SELECTION
- if ( w->exec() != QDialog::Accepted )
- {
- return "";
- MITK_INFO << "Failed to load";
- }
-
- QStringList filenames = w->selectedFiles();
- if (filenames.size() > 0)
- {
- std::string retval = filenames.at(0).toStdString();
- return retval;
- }
- return "";
-}
void QmitkTractbasedSpatialStatisticsView::AddGroup()
{
QString group("Group");
int number = 0;
QPair<QString, int> pair(group, number);
QList< QPair<QString, int> >list = m_GroupModel->getList();
if(!list.contains(pair))
{
m_GroupModel->insertRows(0, 1, QModelIndex());
QModelIndex index = m_GroupModel->index(0, 0, QModelIndex());
m_GroupModel->setData(index, group, Qt::EditRole);
index = m_GroupModel->index(0, 1, QModelIndex());
m_GroupModel->setData(index, number, Qt::EditRole);
}
- else
- {
- //QMessageBox::information(this, "Duplicate name");
- }
-
-
}
void QmitkTractbasedSpatialStatisticsView::TbssImport()
{
// Read groups from the interface
mitk::TbssImporter::Pointer importer = mitk::TbssImporter::New();
QList< QPair<QString, int> >list = m_GroupModel->getList();
+
if(list.size() == 0)
{
QMessageBox msgBox;
msgBox.setText("No study group information has been set yet.");
msgBox.exec();
return;
}
std::vector < std::pair<std::string, int> > groups;
for(int i=0; i<list.size(); i++)
{
QPair<QString, int> pair = list.at(i);
std::string s = pair.first.toStdString();
int n = pair.second;
std::pair<std::string, int> p;
p.first = s;
p.second = n;
groups.push_back(p);
}
importer->SetGroupInfo(groups);
std::string minfo = m_Controls->m_MeasurementInfo->text().toStdString();
importer->SetMeasurementInfo(minfo);
std::string name = "";
- for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
- i != m_CurrentSelection->End(); ++i)
+
+ std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+
+ for ( int i=0; i<nodes.size(); i++ )
{
- // extract datatree node
- if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
+ if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
{
- mitk::DataNode::Pointer node = nodeObj->GetDataNode();
-
- if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
+ mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
+ if(img->GetDimension() == 4)
{
- mitk::Image* img = static_cast<mitk::Image*>(node->GetData());
- if(img->GetDimension() == 4)
- {
- importer->SetImportVolume(img);
- name = node->GetName();
- }
+ importer->SetImportVolume(img);
+ name = nodes[i]->GetName();
}
}
}
+
mitk::TbssImage::Pointer tbssImage;
tbssImage = importer->Import();
name += "_tbss";
AddTbssToDataStorage(tbssImage, name);
}
void QmitkTractbasedSpatialStatisticsView::AddTbssToDataStorage(mitk::Image* image, std::string name)
{
mitk::LevelWindow levelwindow;
levelwindow.SetAuto( image );
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
levWinProp->SetLevelWindow( levelwindow );
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetProperty( "name", mitk::StringProperty::New(name) );
result->SetData( image );
result->SetProperty( "levelwindow", levWinProp );
// add new image to data storage and set as active to ease further processing
GetDefaultDataStorage()->Add( result );
// show the results
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
+
void QmitkTractbasedSpatialStatisticsView::Clicked(const QwtDoublePoint& pos)
{
int index = (int)pos.x();
if(m_Roi.size() > 0 && m_CurrentGeometry != NULL && !m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
{
index = std::min( (int)m_Roi.size()-1, std::max(0, index) );
itk::Index<3> ix = m_Roi.at(index);
mitk::Vector3D i;
i[0] = ix[0];
i[1] = ix[1];
i[2] = ix[2];
mitk::Vector3D w;
m_CurrentGeometry->IndexToWorld(i, w);
mitk::Point3D origin = m_CurrentGeometry->GetOrigin();
mitk::Point3D p;
p[0] = w[0] + origin[0];
p[1] = w[1] + origin[1];
p[2] = w[2] + origin[2];
m_MultiWidget->MoveCrossToPosition(p);
m_Controls->m_RoiPlotWidget->drawBar(index);
}
else if(m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
{
mitk::Point3D point = m_Controls->m_RoiPlotWidget->GetPositionInWorld(index);
m_MultiWidget->MoveCrossToPosition(point);
- /*
- mitk::BaseData* fibData = m_CurrentFiberNode->GetData();
- mitk::FiberBundleX* fib = static_cast<mitk::FiberBundleX*>(fibData);
-
- mitk::BaseData* startData = m_CurrentStartRoi->GetData();
- mitk::PlanarFigure* startRoi = static_cast<mitk::PlanarFigure*>(startData);
-
- mitk::BaseData* endData = m_CurrentEndRoi->GetData();
- mitk::PlanarFigure* endRoi = static_cast<mitk::PlanarFigure*>(endData);
-
- mitk::Point3D startCenter = startRoi->GetWorldControlPoint(0); //center Point of start roi
- mitk::Point3D endCenter = endRoi->GetWorldControlPoint(0); //center Point of end roi
-
-
- mitk::FiberBundleX::Pointer inStart = fib->ExtractFiberSubset(startRoi);
- mitk::FiberBundleX::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
-
- // check wich fiber is selected. if they are all shown take the first one from the bundle
- int selectedFiber = std::max(m_Controls->m_FiberSelector->currentIndex()-1, 0);
- int num = inBoth->GetNumFibers();
-
- if(num < selectedFiber)
- return;
-
- std::vector<long> ids;
- ids.push_back(selectedFiber);
-
- vtkSmartPointer<vtkPolyData> singlefib = inBoth->GeneratePolyDataByIds(ids);
- vtkCellArray* lines = singlefib->GetLines();
- lines->InitTraversal();
-
-
-
-
- // Select fiber by selectedFiber
- vtkIdType numPointsInCell(0);
- vtkIdType* pointsInCell(NULL);
- lines->GetCell(selectedFiber, numPointsInCell, pointsInCell);
-
-
- int startId = 0;
- int endId = 0;
-
- float minDistStart = std::numeric_limits<float>::max();
- float minDistEnd = std::numeric_limits<float>::max();
-
-
- for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
- {
-
-
- double *p = singlefib->GetPoint( pointsInCell[ pointInCellID ] );
-
-
- mitk::Point3D point;
- point[0] = p[0];
- point[1] = p[1];
- point[2] = p[2];
-
- float distanceToStart = point.EuclideanDistanceTo(startCenter);
- float distanceToEnd = point.EuclideanDistanceTo(endCenter);
-
- if(distanceToStart < minDistStart)
- {
- minDistStart = distanceToStart;
- startId = pointInCellID;
- }
-
- if(distanceToEnd < minDistEnd)
- {
- minDistEnd = distanceToEnd;
- endId = pointInCellID;
- }
-
- }
-
-
- if(startId < endId)
- {
- index = startId + index;
- }
- else
- {
- index = startId- index;
- }
-
-
- // In case the possible range of indices exceeds the range of fiber oints
- index = std::min( (int)numPointsInCell-1, std::max(0, index) );
-
- double *p = singlefib->GetPoint( pointsInCell[ index ] );
- PointType point;
- point[0] = p[0];
- point[1] = p[1];
- point[2] = p[2];
-
-
-*/
}
}
void QmitkTractbasedSpatialStatisticsView::Cut()
{
mitk::BaseData* fibData = m_CurrentFiberNode->GetData();
mitk::FiberBundleX* fib = static_cast<mitk::FiberBundleX*>(fibData);
mitk::BaseData* startData = m_CurrentStartRoi->GetData();
mitk::PlanarFigure* startRoi = static_cast<mitk::PlanarFigure*>(startData);
mitk::PlaneGeometry* startGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(startRoi->GetGeometry2D()) );
mitk::BaseData* endData = m_CurrentEndRoi->GetData();
mitk::PlanarFigure* endRoi = static_cast<mitk::PlanarFigure*>(endData);
mitk::PlaneGeometry* endGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(endRoi->GetGeometry2D()) );
mitk::Point3D startCenter = startRoi->GetWorldControlPoint(0); //center Point of start roi
mitk::Point3D endCenter = endRoi->GetWorldControlPoint(0); //center Point of end roi
mitk::FiberBundleX::Pointer inStart = fib->ExtractFiberSubset(startRoi);
mitk::FiberBundleX::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
int num = inBoth->GetNumFibers();
vtkSmartPointer<vtkPolyData> fiberPolyData = inBoth->GetFiberPolyData();
vtkCellArray* lines = fiberPolyData->GetLines();
lines->InitTraversal();
// initialize new vtk polydata
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
int pointIndex=0;
// find start and endpoint
for( int fiberID( 0 ); fiberID < num; fiberID++ )
{
vtkIdType numPointsInCell(0);
vtkIdType* pointsInCell(NULL);
lines->GetNextCell ( numPointsInCell, pointsInCell );
int startId = 0;
int endId = 0;
float minDistStart = std::numeric_limits<float>::max();
float minDistEnd = std::numeric_limits<float>::max();
vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();
int lineIndex=0;
for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
{
double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
mitk::Point3D point;
point[0] = p[0];
point[1] = p[1];
point[2] = p[2];
float distanceToStart = point.EuclideanDistanceTo(startCenter);
float distanceToEnd = point.EuclideanDistanceTo(endCenter);
if(distanceToStart < minDistStart)
{
minDistStart = distanceToStart;
startId = pointInCellID;
}
if(distanceToEnd < minDistEnd)
{
minDistEnd = distanceToEnd;
endId = pointInCellID;
}
}
/* We found the start and end points of of the part that should be plottet for
the current fiber. now we need to plot them. If the endId is smaller than the startId the plot order
must be reversed*/
if(startId < endId)
{
double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
mitk::Vector3D p0;
p0[0] = p[0];
p0[1] = p[1];
p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
mitk::Vector3D p1;
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
// Check if p and p2 are both on the same side of the plane
mitk::Vector3D normal = startGeometry2D->GetNormal();
mitk::Point3D pStart;
pStart[0] = p0[0];
pStart[1] = p0[1];
pStart[2] = p0[2];
bool startOnPositive = startGeometry2D->IsAbove(pStart);
mitk::Point3D pSecond;
pSecond[0] = p1[0];
pSecond[1] = p1[1];
pSecond[2] = p1[2];
bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
// Calculate intersection with the plane
mitk::Vector3D onPlane;
onPlane[0] = startCenter[0];
onPlane[1] = startCenter[1];
onPlane[2] = startCenter[2];
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId+1 lie on the same side of the plane, so we need
need startId-1 to calculate the intersection with the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
}
double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
mitk::Vector3D newPoint = (p0-p1);
newPoint[0] = d*newPoint[0] + p0[0];
newPoint[1] = d*newPoint[1] + p0[1];
newPoint[2] = d*newPoint[2] + p0[2];
double insertPoint[3];
insertPoint[0] = newPoint[0];
insertPoint[1] = newPoint[1];
insertPoint[2] = newPoint[2];
// First insert the intersection with the start roi
points->InsertNextPoint(insertPoint);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
if(! (secondOnPositive ^ startOnPositive) )
{
/* StartId and startId+1 lie on the same side of the plane
so startId is also part of the ROI*/
double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
points->InsertNextPoint(start);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
// Insert the rest up and to including endId-1
for( int pointInCellID( startId+1 ); pointInCellID < endId ; pointInCellID++)
{
// create new polyline for new polydata
double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
points->InsertNextPoint(p);
// add point to line
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
/* endId must be included if endId and endId-1 lie on the same side of the
plane defined by endRoi*/
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
mitk::Point3D pLast;
pLast[0] = p0[0]; pLast[1] = p0[1]; pLast[2] = p0[2];
mitk::Point3D pBeforeLast;
pBeforeLast[0] = p1[0]; pBeforeLast[1] = p1[1]; pBeforeLast[2] = p1[2];
bool lastOnPositive = endGeometry2D->IsAbove(pLast);
bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
normal = endGeometry2D->GetNormal();
onPlane[0] = endCenter[0];
onPlane[1] = endCenter[1];
onPlane[2] = endCenter[2];
if(! (lastOnPositive ^ secondLastOnPositive) )
{
/* endId and endId-1 lie on the same side of the plane, so we need
need endId+1 to calculate the intersection with the planar figure.
this should exist since we know that the fiber crosses the planar figure
endId is part of the roi so can also be included here*/
p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
points->InsertNextPoint(end);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
newPoint = (p0-p1);
newPoint[0] = d*newPoint[0] + p0[0];
newPoint[1] = d*newPoint[1] + p0[1];
newPoint[2] = d*newPoint[2] + p0[2];
insertPoint[0] = newPoint[0];
insertPoint[1] = newPoint[1];
insertPoint[2] = newPoint[2];
//Insert the Last Point (intersection with the end roi)
points->InsertNextPoint(insertPoint);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
// Need to reverse walking order
else{
double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
mitk::Vector3D p0;
p0[0] = p[0];
p0[1] = p[1];
p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
mitk::Vector3D p1;
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
// Check if p and p2 are both on the same side of the plane
mitk::Vector3D normal = startGeometry2D->GetNormal();
mitk::Point3D pStart;
pStart[0] = p0[0];
pStart[1] = p0[1];
pStart[2] = p0[2];
bool startOnPositive = startGeometry2D->IsAbove(pStart);
mitk::Point3D pSecond;
pSecond[0] = p1[0];
pSecond[1] = p1[1];
pSecond[2] = p1[2];
bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
// Calculate intersection with the plane
mitk::Vector3D onPlane;
onPlane[0] = startCenter[0];
onPlane[1] = startCenter[1];
onPlane[2] = startCenter[2];
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId-1 lie on the same side of the plane, so we need
need startId+1 to calculate the intersection with the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
}
double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
mitk::Vector3D newPoint = (p0-p1);
newPoint[0] = d*newPoint[0] + p0[0];
newPoint[1] = d*newPoint[1] + p0[1];
newPoint[2] = d*newPoint[2] + p0[2];
double insertPoint[3];
insertPoint[0] = newPoint[0];
insertPoint[1] = newPoint[1];
insertPoint[2] = newPoint[2];
// First insert the intersection with the start roi
points->InsertNextPoint(insertPoint);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId-1 lie on the same side of the plane
so endId is also part of the ROI*/
double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
points->InsertNextPoint(start);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
// Insert the rest up and to including endId-1
for( int pointInCellID( startId-1 ); pointInCellID > endId ; pointInCellID--)
{
// create new polyline for new polydata
double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
points->InsertNextPoint(p);
// add point to line
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
/* startId must be included if startId and startId+ lie on the same side of the
plane defined by endRoi*/
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
p0[0] = p[0];
p0[1] = p[1];
p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
mitk::Point3D pLast;
pLast[0] = p0[0];
pLast[1] = p0[1];
pLast[2] = p0[2];
bool lastOnPositive = endGeometry2D->IsAbove(pLast);
mitk::Point3D pBeforeLast;
pBeforeLast[0] = p1[0];
pBeforeLast[1] = p1[1];
pBeforeLast[2] = p1[2];
bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
onPlane[0] = endCenter[0];
onPlane[1] = endCenter[1];
onPlane[2] = endCenter[2];
if(! (lastOnPositive ^ secondLastOnPositive) )
{
/* endId and endId+1 lie on the same side of the plane, so we need
need endId-1 to calculate the intersection with the planar figure.
this should exist since we know that the fiber crosses the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
/* endId and endId+1 lie on the same side of the plane
so startId is also part of the ROI*/
double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
points->InsertNextPoint(end);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
newPoint = (p0-p1);
newPoint[0] = d*newPoint[0] + p0[0];
newPoint[1] = d*newPoint[1] + p0[1];
newPoint[2] = d*newPoint[2] + p0[2];
insertPoint[0] = newPoint[0];
insertPoint[1] = newPoint[1];
insertPoint[2] = newPoint[2];
//Insert the Last Point (intersection with the end roi)
points->InsertNextPoint(insertPoint);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
// add polyline to vtk cell array
cells->InsertNextCell(polyLine);
}
// Add the points to the dataset
polyData->SetPoints(points);
// Add the lines to the dataset
polyData->SetLines(cells);
mitk::FiberBundleX::Pointer cutBundle = mitk::FiberBundleX::New(polyData);
mitk::DataNode::Pointer cutNode = mitk::DataNode::New();
cutNode->SetData(cutBundle);
std::string name = "fiberCut";
cutNode->SetName(name);
GetDataStorage()->Add(cutNode);
}
void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
-void QmitkTractbasedSpatialStatisticsView::AdjustPlotMeasure(const QString & text)
-{
- berry::ISelection::ConstPointer sel(
- this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
- m_CurrentSelection = sel.Cast<const IStructuredSelection>();
- m_SelListener.Cast<TbssSelListener>()->DoSelectionChanged(sel);
-}
-
-void QmitkTractbasedSpatialStatisticsView::Clustering()
-{
-/*
-
-
- // Create a mask using the distance map
- typedef itk::ImageFileReader< VectorImageType > DirectionReader;
- DirectionReader::Pointer directionReader = DirectionReader::New();
- directionReader->SetFileName(m_TbssWorkspaceManager.GetInputDir().toStdString() + "/tbss/" + m_TbssWorkspaceManager.GetGradient().toStdString());
- directionReader->Update();
- VectorImageType::Pointer directions = directionReader->GetOutput();
-
- FloatReaderType::Pointer distMapReader = FloatReaderType::New();
- distMapReader->SetFileName(m_TbssWorkspaceManager.GetInputDir().toStdString() + "/stats/" + m_TbssWorkspaceManager.GetDistanceMap().toStdString());
- distMapReader->Update();
- FloatImageType::Pointer distanceMap = distMapReader->GetOutput();
-
-
- std::string line;
- std::string path = "/mnt/E130-Projekte/NeuroDiffusion/BRAM DTI/TBSS/rois/cc.txt";
- std::ifstream file(path.c_str());
- std::vector< itk::Index< 3 > > roi;
-
- if(file.is_open())
- {
-
- while(getline(file,line))
- {
-
- std::vector<std::string> tokens;
- Tokenize(line, tokens);
-
- itk::Index<3> ix;
- ix[0] = atoi(tokens[0].c_str());
- ix[1] = atoi(tokens[1].c_str());
- ix[2] = atoi(tokens[2].c_str());
- roi.push_back(ix);
- }
- }
-
- if(roi.size() == 0)
- {
- return;
- }
-
-
-
- // Some code from the projection algorithm of tbss to create a mask
-
-
- std::vector< std::vector< itk::Index< 3 > > > rois;
-
- for(int j=0; j<roi.size(); j++)
- {
-
-
-
- std::vector< itk::Index<3> > indices;
-
- FloatImageType::SizeType size = distanceMap->GetLargestPossibleRegion().GetSize();
-
- bool roiDone = false;
-
- while(!roiDone && j<roi.size())
- {
- if(j != 0 && j%5==0)
- {
- roiDone = true;
- }
-
- itk::Index<3> ix = roi[j];
- int x=ix[0];
- int y=ix[1];
- int z=ix[2];
- VectorImageType::PixelType dir = directions->GetPixel(ix);
-
- indices.push_back(ix);
-
-
- for(int iters=0;iters<2;iters++)
- {
- float distance=0;
-
- for(int d=1;d<MAXSEARCHLENGTH;d++)
- {
- int D=d;
- if (iters==1) D=-d;
-
- int dx = x+dir[0]*D, dy = y+dir[1]*D, dz = z+dir[2]*D;
- ix[0] = dx;
- ix[1] = dy;
- ix[2] = dz;
-
- if(dx<0 || dy<0 || dz<0
- || dx>=size[0] && dy<=size[1] && dz<=size[2])
- {
- d=MAXSEARCHLENGTH;
- }
- else if(distanceMap->GetPixel(ix)>=distance)
- {
- distance = distanceMap->GetPixel(ix);
- indices.push_back(ix);
- }
- else{
- d=MAXSEARCHLENGTH;
- }
-
- }
-
- }
- j++;
- }
-
-
- // Create a mask from indices
- UCharImageType::Pointer maskItk = UCharImageType::New();
- maskItk->SetRegions(distanceMap->GetRequestedRegion());
- maskItk->SetDirection(distanceMap->GetDirection());
- maskItk->SetSpacing(distanceMap->GetSpacing());
- maskItk->SetOrigin(distanceMap->GetOrigin());
- maskItk->Allocate();
-
-
-
-
-
-
-
- // For every point on the roi create a mask and feed it to the partial voluming algorithm
-
-
- //maskItk->FillBuffer(0);
-
-
-
- // Create a bounding box from current ROI
- int xMin = numeric_limits<int>::max();
- int yMin = numeric_limits<int>::max();
- int zMin = numeric_limits<int>::max();
- int xMax = numeric_limits<int>::min();
- int yMax = numeric_limits<int>::min();
- int zMax = numeriUCharImageType::Pointer newMask = UCharImageType::New();c_limits<int>::min();
-
-
- for(int i=0; i<indices.size(); i++)
- {
- itk::Index<3> ix = indices[i];
-
- if(ix[0] < xMin)
- xMin=ix[0];
-
- if(ix[1] < yMin)
- yMin=ix[1];
-
- if(ix[2] < zMin)
- zMin=ix[2];
-
- if(ix[0] > xMax)
- xMax=ix[0];
-
- if(ix[1] > yMax)
- yMax=ix[1];
-
- if(ix[2] > zMax)
- zMax=ix[2];
- }
-
- FloatImageType::PointType origin = distanceMap->GetOrigin();
- CharImageType::PointType originMask;
- originMask[0] = origin[0] + xMin;
- originMask[1] = origin[1] + -yMin;
- originMask[2] = origin[2] + zMin;
-
- CharImageType::RegionType region;
- CharImageType::RegionType::SizeType s;
- s[0] = xMax-xMin + 1;
- s[1] = yMax-yMin + 1;
- s[2] = zMax-zMin + 1;
- region.SetSize(s);
-
-
- UCharImageType::Pointer newMask = UCharImageType::New();
- newMask->SetSpacing( distanceMap->GetSpacing() ); // Set the image spacing
- newMask->SetOrigin( originMask ); // Set the image origin
- newMask->SetDirection( distanceMap->GetDirection() ); // Set the image direction
- newMask->SetRegions( region );
- newMask->Allocate();
- newMask->FillBuffer(0);
-
-
-
- for(int i=0; i<indices.size(); i++)
- {
- //convert the index to the new pixel index
- itk::Index<3> ix = indices[i];
-
- itk::Point< double, 3 > point;
- itk::Index< 3 > index;
-
- distanceMap->TransformIndexToPhysicalPoint (ix, point);
-
-
-
- newMask->TransformPhysicalPointToIndex(point, index);
-
-
-
- newMask->SetPixel(index, 1);
- }
-
-
-
-*/
-
-
-
-/*
-
-
-
- UCharImageType::Pointer newMask = UCharImageType::New();
- UCharReaderType::Pointer cReader = UCharReaderType::New();
- cReader->SetFileName("/mnt/E130-Projekte/NeuroDiffusion/BRAM DTI/ClusteringFornix/fornix_central_maxFA_path_Dilated_by_3.nrrd");
- cReader->Update();
- newMask = cReader->GetOutput();
-
-
- // mitk::DataNode::Pointer maskNode = readNode("itk image/mnt/E130-Projekte/NeuroDiffusion/BRAM DTI/TBSS/clusterMasks/area2.nii");
- // mitk::Image::Pointer mask = dynamic_cast<mitk::Image*>(maskNode->GetData());
- mitk::Image::Pointer mask;
- mitk::CastToMitkImage(newMask, mask);
-
- typedef mitk::PartialVolumeAnalysisHistogramCalculator HistorgramCalculator;
- typedef mitk::PartialVolumeAnalysisClusteringCalculator ClusteringType;
- typedef HistorgramCalculator::HistogramType HistogramType;
-
- HistorgramCalculator::Pointer histogramCalculator = HistorgramCalculator::New();
-
-
-
-
-
- // Make list of subjects
-
- std::vector<std::string> paths;
- paths.push_back("/mnt/E130-Projekte/NeuroDiffusion/BRAM DTI/TBSS/FA/SORTEDBYCONDITION/FA/subset");
- // paths.push_back("/mnt/E130-Projekte/NeuroDiffusion/BRAM DTI/TBSS/FA/SORTEDBYCONDITION/AXD/");
-
- for(int j=0; j<paths.size(); j++)
- {
- QDir currentDir = QDir(QString(paths.at(j).c_str()));
- currentDir.setFilter( QDir::Files );
- QStringList entries = currentDir.entryList();
-
- std::vector<double> values;
-
- for(int i=0; i<entries.size(); i++)
- {
-
-
-
- std::string file = paths.at(j) + entries.at(i).toStdString();
- mitk::DataNode::Pointer node = readNode(file);
- mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
-
-
- histogramCalculator->SetImage(image);
- histogramCalculator->SetImageMask( mask );
- histogramCalculator->SetMaskingModeToImage();
- histogramCalculator->SetNumberOfBins(25);
- histogramCalculator->SetUpsamplingFactor(5);
- histogramCalculator->SetGaussianSigma(0.0);
- histogramCalculator->SetForceUpdate(true);
-
- bool statisticsChanged = histogramCalculator->ComputeStatistics( );
-
-
- ClusteringType::ParamsType *cparams = 0;
- ClusteringType::ClusterResultType *cresult = 0;
- ClusteringType::HistType *chist = 0;
- ClusteringType::HelperStructPerformClusteringRetval *currentPerformClusteringResults;
-
- try{
-
-
- mitk::Image* tmpImg = histogramCalculator->GetInternalImage();
- mitk::Image::ConstPointer imgToCluster = tmpImg;
-
- if(imgToCluster.IsNotNull())
- {
-
- // perform clustering
- const HistogramType *histogram = histogramCalculator->GetHistogram( );
- ClusteringType::Pointer clusterer = ClusteringType::New();
- clusterer->SetStepsNumIntegration(200);
- clusterer->SetMaxIt(1000);
-
- mitk::Image::Pointer pFiberImg;
-
- currentPerformClusteringResults =
- clusterer->PerformClustering(imgToCluster, histogram, 2);
-
- pFiberImg = currentPerformClusteringResults->clusteredImage;
- cparams = currentPerformClusteringResults->params;
- cresult = currentPerformClusteringResults->result;
- chist = currentPerformClusteringResults->hist;
-
-
- // m_Controls->m_HistogramWidget->SetParameters(
- // cparams, cresult, chist );
-
-
-
- std::vector<double> *xVals = chist->GetXVals();
-
- std::vector<double> *fiberVals = new std::vector<double>(cresult->GetFiberVals());
-
-
-
- double fiberFA = 0.0;
- double weights = 0.0;
-
- // std::cout << "x, y, fiber, nonFiber, mixed, combi" << std::endl;
- for(int k=0; k<xVals->size(); ++k)
- {
-
- fiberFA += xVals->at(k) * fiberVals->at(k);
- weights += fiberVals->at(k);
-
-
- }
-
- fiberFA = fiberFA / weights;
- std::cout << "FA: " << fiberFA << std::endl;
- values.push_back(fiberFA);
-
- }
-
-
- }
-
- catch ( const std::runtime_error &e )
- {
- std::cout << "noooooooooooooooooooooooooooooooo!";
- }
-
- //MITK_INFO << "number of voxels: " << indices.size();
- }
-
- std::vector<double>::iterator it = values.begin();
- while(it!=values.end())
- {
- std::cout << *it << std::endl;
- ++it;
- }
-
- }*/
-}
-
void QmitkTractbasedSpatialStatisticsView::CreateRoi()
{
-
- // It is important to load the MeanFASkeletonMask image in MITK to make sure that point selection and
- // pathfinding is done on the same image
- //string filename = m_TbssWorkspaceManager.GetInputDir().toStdString() + "/stats/" + m_TbssWorkspaceManager.GetMeanFASkeletonMask().toStdString();
-
- // Implement a way to obtain skeleton and skeletonFA without sml workspace
-
+ bool ok;
double threshold = QInputDialog::getDouble(m_Controls->m_CreateRoi, tr("Set an FA threshold"),
- tr("Threshold:"), QLineEdit::Normal,
- 0.2);
+ tr("Threshold:"), 0.2, 0.0, 1.0, 2, &ok);
+ if(!ok)
+ return;
mitk::Image::Pointer image;
- for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
- i != m_CurrentSelection->End(); ++i)
+ std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+
+ for ( int i=0; i<nodes.size(); i++ )
{
- // extract datatree node
- if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
+ if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
{
- mitk::DataNode::Pointer node = nodeObj->GetDataNode();
-
- if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
- {
- mitk::Image* img = static_cast<mitk::Image*>(node->GetData());
+ mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
if(img->GetDimension() == 3)
{
image = img;
}
- }
}
}
-
-
if(image.IsNull())
{
return;
}
mitk::TractAnalyzer analyzer;
analyzer.SetInputImage(image);
analyzer.SetThreshold(threshold);
+ // Set Pointset to analyzer
+ analyzer.SetPointSet(m_PointSetNode);
+ // Run Analyzer
+ analyzer.MakeRoi();
- int n = 0;
- if(m_PointSetNode.IsNotNull())
- {
- n = m_PointSetNode->GetSize();
- if(n==0)
- {
- QMessageBox msgBox;
- msgBox.setText("No points have been set yet.");
- msgBox.exec();
- }
- }
- else{
- QMessageBox msgBox;
- msgBox.setText("No points have been set yet.");
- msgBox.exec();
- }
-
- std::string pathDescription = "";
- std::vector< itk::Index<3> > totalPath;
-
- if(n>0)
- {
- for(int i=0; i<n-1; ++i)
- {
- mitk::Point3D p = m_PointSetNode->GetPoint(i);
- mitk::Point3D p2 = m_PointSetNode->GetPoint(i+1);
-
-
- itk::Index<3> StartPoint; mitk::ProgressBar::GetInstance()->Progress();
-
- itk::Index<3> EndPoint;
- image->GetGeometry()->WorldToIndex(p,StartPoint);
- image->GetGeometry()->WorldToIndex(p2,EndPoint);
- MITK_INFO << "create roi";
-
-
- analyzer.BuildGraph(StartPoint, EndPoint);
- std::vector< itk::Index<3> > path = analyzer.GetPath();
-
+ // Obtain tbss roi image from analyzer
+ mitk::TbssRoiImage::Pointer tbssRoi = analyzer.GetRoiImage();
- for(std::vector< itk::Index<3> >::iterator it = path.begin();
- it != path.end(); it++)
- {
- itk::Index<3> ix = *it;
-
- if (!(ix==EndPoint))
- { mitk::ProgressBar::GetInstance()->Progress();
+ tbssRoi->SetStructure(m_Controls->m_Structure->text().toStdString());
- totalPath.push_back(ix);
- std::stringstream ss;
- ss << ix[0] << " " << ix[1] << " " << ix[2] << "\n";
- pathDescription += ss.str();
- }
- else
- {
- // Only when dealing with the last segment the last point should be added. This one will not occur
- // as the first point of the next roi segment.
- if(i == (n-2))
- {
- totalPath.push_back(EndPoint);
- std::stringstream ss;
- ss << EndPoint[0] << " " << EndPoint[1] << " " << EndPoint[2] << "\n";
- pathDescription += ss.str();
- }
+ // get path description and set to interface
+ std::string pathDescription = analyzer.GetPathDescription();
+ m_Controls->m_PathTextEdit->setPlainText(QString(pathDescription.c_str()));
- }
- }
+ // Add roi image to datastorage
+ AddTbssToDataStorage(tbssRoi, m_Controls->m_RoiName->text().toStdString());
- }
- m_Controls->m_PathTextEdit->setPlainText(QString(pathDescription.c_str()));
-
-
- FloatImageType::Pointer itkImg = FloatImageType::New();
- mitk::CastToItkImage(image, itkImg);
-
- CharImageType::Pointer roiImg = CharImageType::New();
- roiImg->SetRegions(itkImg->GetLargestPossibleRegion().GetSize());
- roiImg->SetOrigin(itkImg->GetOrigin());
- roiImg->SetSpacing(itkImg->GetSpacing());
- roiImg->SetDirection(itkImg->GetDirection());
- roiImg->Allocate();
- roiImg->FillBuffer(0);
-
-
- std::vector< itk::Index<3> > roi;
-
- std::vector< itk::Index<3> >::iterator it;
- for(it = totalPath.begin();
- it != totalPath.end();
- it++)
- {
- itk::Index<3> ix = *it;
- roiImg->SetPixel(ix, 1);
- roi.push_back(ix);
- }
-
-
- mitk::TbssRoiImage::Pointer tbssRoi = mitk::TbssRoiImage::New();
-
- tbssRoi->SetRoi(roi);
- tbssRoi->SetImage(roiImg);
- tbssRoi->SetStructure(m_Controls->m_Structure->text().toStdString());
- tbssRoi->InitializeFromImage();
-
- AddTbssToDataStorage(tbssRoi, m_Controls->m_RoiName->text().toStdString());
-
-
- }
}
void QmitkTractbasedSpatialStatisticsView:: PlotFiberBundle(mitk::FiberBundleX *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi)
{
bool avg = m_Controls->m_Average->isChecked();
int segments = m_Controls->m_Segments->value();
m_Controls->m_RoiPlotWidget->PlotFiberBetweenRois(fib, img, startRoi ,endRoi, avg, segments);
m_Controls->m_RoiPlotWidget->SetPlottingFiber(true);
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkTractbasedSpatialStatisticsView::Plot(mitk::TbssImage* image, mitk::TbssRoiImage* roiImage)
{
if(m_Controls->m_TabWidget->currentWidget() == m_Controls->m_MeasureTAB)
{
std::vector< itk::Index<3> > roi = roiImage->GetRoi();
m_Roi = roi;
m_CurrentGeometry = image->GetGeometry();
std::string resultfile = "";
std::string structure = roiImage->GetStructure();
m_Controls->m_RoiPlotWidget->SetGroups(image->GetGroupInfo());
m_Controls->m_RoiPlotWidget->SetProjections(image->GetImage());
m_Controls->m_RoiPlotWidget->SetRoi(roi);
m_Controls->m_RoiPlotWidget->SetStructure(structure);
m_Controls->m_RoiPlotWidget->SetMeasure( image->GetMeasurementInfo() );
m_Controls->m_RoiPlotWidget->DrawProfiles(resultfile);
}
m_Controls->m_RoiPlotWidget->SetPlottingFiber(false);
}
-
-
-
-
-void QmitkTractbasedSpatialStatisticsView::Masking()
-{
- //QString filename = m_Controls->m_WorkingDirectory->text();
- QString filename = "E:/Experiments/tbss";
- QString faFiles = filename + "/AxD";
- QString maskFiles = filename + "/bin_masks";
-
-
- QDirIterator faDirIt(faFiles, QDir::Files | QDir::NoSymLinks, QDirIterator::Subdirectories);
- QDirIterator maskDirIt(maskFiles, QDir::Files | QDir::NoSymLinks, QDirIterator::Subdirectories);
-
- std::vector<std::string> faFilenames;
- std::vector<std::string> maskFilenames;
- std::vector<std::string> outputFilenames;
-
- while(faDirIt.hasNext() && maskDirIt.hasNext())
- {
- faDirIt.next();
- maskDirIt.next();
- if((faDirIt.fileInfo().completeSuffix() == "nii"
- || faDirIt.fileInfo().completeSuffix() == "mhd"
- || faDirIt.fileInfo().completeSuffix() == "nii.gz")
- && (maskDirIt.fileInfo().completeSuffix() == "nii"
- || maskDirIt.fileInfo().completeSuffix() == "mhd"
- || maskDirIt.fileInfo().completeSuffix() == "nii.gz"))
- {
- faFilenames.push_back(faDirIt.filePath().toStdString());
- outputFilenames.push_back(faDirIt.fileName().toStdString());
- maskFilenames.push_back(maskDirIt.filePath().toStdString());
- }
- }
-
- std::vector<std::string>::iterator faIt = faFilenames.begin();
- std::vector<std::string>::iterator maskIt = maskFilenames.begin();
- std::vector<std::string>::iterator outputIt = outputFilenames.begin();
-
- // Now multiply all FA images with their corresponding masks
-
- QString outputDir = filename;
- while(faIt != faFilenames.end() && maskIt != maskFilenames.end() && outputIt != outputFilenames.end())
- {
- std::cout << "Mask " << *faIt << " with " << *maskIt << std::endl;
-
- typedef itk::MultiplyImageFilter<FloatImageType, CharImageType, FloatImageType> MultiplicationFilterType;
-
- FloatReaderType::Pointer floatReader = FloatReaderType::New();
- CharReaderType::Pointer charReader = CharReaderType::New();
-
- floatReader->SetFileName(*faIt);
- //floatReader->Update();
- //FloatImageType::Pointer faImage = floatReader->GetOutput();
-
- charReader->SetFileName(*maskIt);
- //charReader->Update();
- // CharImageType::Pointer maskImage = charReader->GetOutput();
-
- MultiplicationFilterType::Pointer multiplicationFilter = MultiplicationFilterType::New();
- multiplicationFilter->SetInput1(floatReader->GetOutput());
- multiplicationFilter->SetInput2(charReader->GetOutput());
- multiplicationFilter->Update();
-
- //FloatImageType::Pointer maskedImage = FloatImageType::New();
- //maskedImage = MultiplicationFilter->GetOutput();
-
- FloatWriterType::Pointer floatWriter = FloatWriterType::New();
- std::string s = faFiles.toStdString().append("/"+*outputIt);
- floatWriter->SetFileName(s.c_str());
- floatWriter->SetInput(multiplicationFilter->GetOutput());
- floatWriter->Update();
-
- ++faIt;
- ++maskIt;
- ++outputIt;
- }
-}
-
-
-VectorImageType::Pointer QmitkTractbasedSpatialStatisticsView::ConvertToVectorImage(mitk::Image::Pointer mitkImage)
-{
- VectorImageType::Pointer vecImg = VectorImageType::New();
-
- mitk::Geometry3D* geo = mitkImage->GetGeometry();
- mitk::Vector3D spacing = geo->GetSpacing();
- mitk::Point3D origin = geo->GetOrigin();
-
- VectorImageType::SpacingType vecSpacing;
- vecSpacing[0] = spacing[0];
- vecSpacing[1] = spacing[1];
- vecSpacing[2] = spacing[2];
-
- VectorImageType::PointType vecOrigin;
- vecOrigin[0] = origin[0];
- vecOrigin[1] = origin[1];
- vecOrigin[2] = origin[2];
-
- VectorImageType::SizeType size;
- size[0] = mitkImage->GetDimension(0);
- size[1] = mitkImage->GetDimension(1);
- size[2] = mitkImage->GetDimension(2);
-
-
- vecImg->SetSpacing(vecSpacing);
- vecImg->SetOrigin(vecOrigin);
- vecImg->SetRegions(size);
- vecImg->SetVectorLength(mitkImage->GetDimension(3));
- vecImg->Allocate();
-
-
- for(int x=0; x<size[0]; x++)
- {
- for(int y=0; y<size[1]; y++)
- {
- for(int z=0; z<size[2]; z++)
- {
- mitk::Index3D ix;
- ix[0] = x;
- ix[1] = y;
- ix[2] = z;
-
-
- itk::VariableLengthVector<float> pixel = vecImg->GetPixel(ix);
-
- for (int t=0; t<pixel.Size(); t++)
- {
- float f = mitkImage->GetPixelValueByIndex(ix, t);
- pixel.SetElement(t, f);
- }
- vecImg->SetPixel(ix, pixel);
- }
- }
- }
-
- return vecImg;
-
-}
-
-
-/*
-void QmitkTractbasedSpatialStatisticsView::InitializeGridByVectorImage()
-{
- // Read vector image from file
- typedef itk::ImageFileReader< FloatVectorImageType > VectorReaderType;
- VectorReaderType::Pointer vectorReader = VectorReaderType::New();
- vectorReader->SetFileName("E:\\tbss\\testing\\Gradient.mhd");
- vectorReader->Update();
- FloatVectorImageType::Pointer directions = vectorReader->GetOutput();
-
-
- // Read roi from file.
- CharReaderType::Pointer roiReader = CharReaderType::New();
- roiReader->SetFileName("E:\\tbss\\testing\\debugging skeletonization\\segment2.mhd");
- roiReader->Update();
- CharImageType::Pointer roi = roiReader->GetOutput();
-
- DoInitializeGridByVectorImage(directions, roi, std::string("directions"));
-
-
-}
-
-
-
-
-void QmitkTractbasedSpatialStatisticsView::DoInitializeGridByVectorImage(FloatVectorImageType::Pointer vectorpic, CharImageType::Pointer roi, std::string name)
-{
- //vtkStructuredGrid* grid = vtkStructuredGrid::New();
- itk::Matrix<double,3,3> itkdirection = vectorpic->GetDirection();
- itk::Matrix<double,3,3> itkinversedirection = itk::Matrix<double,3,3>(itkdirection.GetInverse());
- std::vector<VectorType> GridPoints;
- vtkPoints *points = vtkPoints::New();
- mitk::Geometry3D::Pointer geom = mitk::Geometry3D::New();
- vtkLinearTransform *vtktransform;
- vtkLinearTransform *inverse;
- mitk::Image::Pointer geomget = mitk::Image::New();
- geomget->InitializeByItk(vectorpic.GetPointer());
- geom = geomget->GetGeometry();
- vtktransform = geom->GetVtkTransform();
- inverse = vtktransform->GetLinearInverse();
- vtkFloatArray * directions = vtkFloatArray::New();
- directions->SetName("Vectors");
- directions->SetNumberOfComponents(3);
-
- // Iterator for the vector image
- itk::ImageRegionIterator<FloatVectorImageType> it_input(vectorpic, vectorpic->GetLargestPossibleRegion());
- FloatVectorType nullvector;
- nullvector.Fill(0);
- double lengthsum = 0;
- int id = 0;
-
- // Iterator for the roi
- itk::ImageRegionIterator<CharImageType> roiIt(roi, roi->GetLargestPossibleRegion());
- roiIt.GoToBegin();
-
- for(it_input.GoToBegin(); !( it_input.IsAtEnd() || roiIt.IsAtEnd() ); ++it_input)
- {
- //VectorType val = it_input.Value();
- if(it_input.Value() != nullvector && roiIt.Get() != 0)
- {
- //itk::Point<double,3> point;
- mitk::Point3D mitkpoint, mitkworldpoint;
- mitk::Point3D mitkendpoint, mitkworldendpoint;
- mitk::Vector3D mitkvector, mitktransvector;
- itk::Point<float,3> direction = it_input.Value().GetDataPointer();
- //itk::Index<3> in_input = it_input.GetIndex();
- //itk::ContinuousIndex<int,3> cindirection;
- FloatVectorType transvec = it_input.Value();
- mitkvector[0] = transvec[0];
- mitkvector[1] = transvec[1];
- mitkvector[2] = transvec[2];
- //mitkvector[2] = 0.0;
-
-
- mitkpoint[0] = it_input.GetIndex()[0];
- mitkpoint[1] = it_input.GetIndex()[1];
- mitkpoint[2] = it_input.GetIndex()[2];
-
- mitkendpoint[0] = mitkpoint[0] + mitkvector[0];
- mitkendpoint[1] = mitkpoint[1] + mitkvector[1];
- mitkendpoint[2] = mitkpoint[2] + mitkvector[2];
-
- //mitkpoint.setXYZ((ScalarType)point[0],(ScalarType)point[1],(ScalarType)point[2]);
- geom->IndexToWorld(mitkpoint, mitkworldpoint);
- geom->IndexToWorld(mitkendpoint, mitkworldendpoint);
- mitktransvector[0] = mitkworldendpoint[0] - mitkworldpoint[0];
- mitktransvector[1] = mitkworldendpoint[1] - mitkworldpoint[1];
- mitktransvector[2] = mitkworldendpoint[2] - mitkworldpoint[2];
-
- lengthsum += mitktransvector.GetNorm();
-
- directions->InsertTuple3(id,mitktransvector[0],mitktransvector[1],mitktransvector[2]);
-
- points->InsertPoint(id,mitkworldpoint[0],mitkworldpoint[1],mitkworldpoint[2]);
- id++;
- //for (unsigned short loop = 0; (loop < 20) && (!it_input.IsAtEnd()); loop++)
- //{
- // ++it_input;
- //}
- if(it_input.IsAtEnd())
- {
- break;
- }
- }
- ++roiIt;
- }
- double meanlength = lengthsum / id;
- vtkGlyph3D* glyph = vtkGlyph3D::New();
- vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::New();
- ugrid->SetPoints(points);
- ugrid->GetPointData()->SetVectors(directions);
- glyph->SetInput(ugrid);
- glyph->SetScaleModeToScaleByVector();
- glyph->SetScaleFactor(0.5);
- glyph->SetColorModeToColorByScalar();
- //glyph->ClampingOn();
- vtkArrowSource* arrow = vtkArrowSource::New();
- if(meanlength > 5) {arrow->SetTipLength(0);arrow->SetTipRadius(0);}
-
- arrow->SetShaftRadius(0.03/meanlength);
- //arrow->SetTipRadius(0.05/meanlength);
-
- glyph->SetSource(arrow->GetOutput());
- glyph->Update();
-
- mitk::Surface::Pointer glyph_surface = mitk::Surface::New();
-
- glyph_surface->SetVtkPolyData(glyph->GetOutput());
- glyph_surface->UpdateOutputInformation();
-
- mitk::DataNode::Pointer gridNode = mitk::DataNode::New();
- gridNode->SetProperty( "name", mitk::StringProperty::New(name.c_str()) );
- //m_GridNode->SetProperty( "color" , m_GridColor);
- gridNode->SetProperty( "visible", mitk::BoolProperty::New(true) );
- gridNode->SetProperty( "segmentation", mitk::BoolProperty::New(true) );
- gridNode->SetProperty( "ID-Tag", mitk::StringProperty::New("grid") );
- gridNode->SetProperty( "shader", mitk::StringProperty::New("mitkShaderLightning") );
- gridNode->SetData( glyph_surface );
- GetDefaultDataStorage()->Add(gridNode);
-
-
-}
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
index 65f0ca1fbc..0f3a45cfff 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
@@ -1,265 +1,170 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkTractbasedSpatialStatisticsView_h
#define QmitkTractbasedSpatialStatisticsView_h
-#include <berryISelectionListener.h>
-#include <berryIPartListener.h>
-#include <berryIStructuredSelection.h>
-
-
#include <QmitkFunctionality.h>
#include "ui_QmitkTractbasedSpatialStatisticsViewControls.h"
#include <QListWidgetItem>
-#include <mitkDiffusionImage.h>
-#include <string>
-
#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>
#include <mitkDataNodeFactory.h>
#include <itkDiffusionTensor3D.h>
#include <mitkTbssImage.h>
#include <mitkTbssRoiImage.h>
#include "QmitkTbssTableModel.h"
#include "QmitkTbssMetaTableModel.h"
#include <mitkFiberBundleX.h>
+// Image types
typedef short DiffusionPixelType;
typedef itk::Image<char, 3> CharImageType;
typedef itk::Image<unsigned char, 3> UCharImageType;
typedef itk::Image<float, 4> Float4DImageType;
typedef itk::Image<float, 3> FloatImageType;
-typedef itk::Vector<int, 3> IntVectorType;
-//typedef itk::VectorImage<int, 3> DirectionImageType;
typedef itk::VectorImage<float, 3> VectorImageType;
-
+// Readers/Writers
typedef itk::ImageFileReader< CharImageType > CharReaderType;
typedef itk::ImageFileReader< UCharImageType > UCharReaderType;
typedef itk::ImageFileWriter< CharImageType > CharWriterType;
typedef itk::ImageFileReader< FloatImageType > FloatReaderType;
typedef itk::ImageFileWriter< FloatImageType > FloatWriterType;
typedef itk::ImageFileReader< Float4DImageType > Float4DReaderType;
typedef itk::ImageFileWriter< Float4DImageType > Float4DWriterType;
-struct TbssSelListener;
-
-
/*!
- \brief QmitkTractbasedSpatialStatisticsView
-
- \warning This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
-
- \sa QmitkFunctionalitymitkTbssWorkspaceManager
- \ingroup Functionalities
+ * \brief This plugin provides an extension for Tract-based spatial statistics (see Smith et al., 2009. http://dx.doi.org/10.1016/j.neuroimage.2006.02.024)
+ * TBSS enables analyzing the brain by a pipeline of registration, skeletonization, and projection that results in a white matter skeleton
+ * for all subjects that are analyzed statistically. This plugin provides functionality to select single tracts and analyze them seperately.
*/
+
class QmitkTractbasedSpatialStatisticsView : public QmitkFunctionality
{
-
- friend struct TbssSelListener;
-
-
-
- // this is needed for all Qt objesetupUicts that should have a Qt meta-object
- // (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkTractbasedSpatialStatisticsView();
virtual ~QmitkTractbasedSpatialStatisticsView();
virtual void CreateQtPartControl(QWidget *parent);
/// \brief Creation of the connections of main and control widget
virtual void CreateConnections();
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
/// \brief Called when the functionality is activated
virtual void Activated();
virtual void Deactivated();
protected slots:
-
- //void OutputValues();
-
-
-
- // void InitializeGridByVectorImage();
-
- void Masking();
-
-
-
+ // Creates Roi
void CreateRoi();
-
- void Clustering();
-
- void AdjustPlotMeasure(const QString & text);
-
void Clicked(const QwtDoublePoint& pos);
+ // Import of FSL TBSS data
void TbssImport();
-
+ // Add a group as metadata. This metadata is required by the plotting functionality
void AddGroup();
+
+ // Remove a group
void RemoveGroup();
+ // Copies the values displayed in the plot widget to clipboard, i.e. exports the data
void CopyToClipboard();
+ // Method to cut away parts of fiber bundles that should not be plotted.
void Cut();
+ // Adjust plot widget
void PerformChange();
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
+ // Creates a plot using a 4D image containing the projections of all subjects and a region of interest
void Plot(mitk::TbssImage*, mitk::TbssRoiImage*);
- void PlotFiberBundle(mitk::FiberBundleX* fib, mitk::Image* img, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
- void InitPointsets();
-
- void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
+ void PlotFiberBundle(mitk::FiberBundleX* fib, mitk::Image* img, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
- berry::ISelectionListener::Pointer m_SelListener;
- berry::IStructuredSelection::ConstPointer m_CurrentSelection;
- bool m_IsInitialized;
+ // Create a point set. This point set defines the points through which a region of interest should go
+ void InitPointsets();
+ // Pointset and DataNode to contain the PointSet used in ROI creation
mitk::PointSet::Pointer m_PointSetNode;
mitk::DataNode::Pointer m_P1;
+ // GUI widgets
Ui::QmitkTractbasedSpatialStatisticsViewControls* m_Controls;
+ /* A pointer to the QmitkStdMultiWidget. Used for interaction with the plot widget
+ (clicking in the plot widget makes the image cross jump to the corresponding location
+ on the skeleton).*/
QmitkStdMultiWidget* m_MultiWidget;
-
- std::vector<CharImageType::IndexType> SortPoints(CharImageType::Pointer roi, CharImageType::IndexType currentPoint);
-
- bool PointVisited(std::vector<CharImageType::IndexType> points, CharImageType::IndexType point);
-
- // Modifies the current point by reference and returns true if no more points need to be visited
- CharImageType::IndexType FindNextPoint(std::vector<CharImageType::IndexType> pointsVisited,
- CharImageType::IndexType currentPoint, CharImageType::Pointer roi, bool &ready);
-
-
-
-
- //void DoInitializeGridByVectorImage(FloatVectorImageType::Pointer vectorpic, CharImageType::Pointer roi ,std::string name);
-
-
-
- // Tokenizer needed for the roi files
- void Tokenize(const std::string& str,
- std::vector<std::string>& tokens,
- const std::string& delimiters = " ")
- {
- // Skip delimiters at beginning.
- std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
- // Find first "non-delimiter".
- std::string::size_type pos = str.find_first_of(delimiters, lastPos);
-
- while (std::string::npos != pos || std::string::npos != lastPos)
- {
- // Found a token, add it to the vector.
- tokens.push_back(str.substr(lastPos, pos - lastPos));
- // Skip delimiters. Note the "not_of"
- lastPos = str.find_first_not_of(delimiters, pos);
- // Find next "non-delimiter"
- pos = str.find_first_of(delimiters, lastPos);
- }
- }
-
- mitk::DataNode::Pointer readNode(std::string f)
- {
- mitk::DataNode::Pointer node;
- mitk::DataNodeFactory::Pointer nodeReader = mitk::DataNodeFactory::New();
- try
- {
- nodeReader->SetFileName(f);
- nodeReader->Update();
- node = nodeReader->GetOutput();
- }
- catch(...) {
- MITK_ERROR << "Could not read file";
- return NULL;
- }
-
- return node;
- }
-
- /*template < typename TPixel, unsigned int VImageDimension >
- void ToITK4D( itk::Image<TPixel, VImageDimension>* inputImage, Float4DImageType::Pointer& outputImage );*/
-
-
- std::string ReadFile(std::string whatfile);
-
+ // Used to save the region of interest in a vector of itk::index.
std::vector< itk::Index<3> > m_Roi;
mitk::FiberBundleX* m_Fib;
- std::string m_CurrentStructure;
-
mitk::Geometry3D* m_CurrentGeometry;
+ // A table model for saving group information in a name,number pair.
QmitkTbssTableModel* m_GroupModel;
-
-
+ // Convenience function for adding a new image to the datastorage and giving it a name.
void AddTbssToDataStorage(mitk::Image* image, std::string name);
- mitk::TbssImage::Pointer m_CurrentTbssMetaImage;
-
- VectorImageType::Pointer ConvertToVectorImage(mitk::Image::Pointer mitkImg);
-
-
mitk::DataNode::Pointer m_CurrentFiberNode; // needed for the index property when interacting with the plot widget
- mitk::DataNode::Pointer m_CurrentStartRoi; // needed when a plot should only show values between a start end end roi
- mitk::DataNode::Pointer m_CurrentEndRoi; // idem dito
-
+ // needed when a plot should only show values between a start end end roi
+ mitk::DataNode::Pointer m_CurrentStartRoi;
+ mitk::DataNode::Pointer m_CurrentEndRoi;
};
#endif // _QMITKTRACTBASEDSPATIALSTATISTICSVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.cpp
index 0198ad45d3..2fbf11dd7c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.cpp
@@ -1,83 +1,85 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "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"
#include "src/internal/QmitkODFDetailsView.h"
#include "src/internal/QmitkGibbsTrackingView.h"
#include "src/internal/QmitkStochasticFiberTrackingView.h"
#include "src/internal/QmitkFiberProcessingView.h"
#include "src/internal/QmitkFiberBundleDeveloperView.h"
#include "src/internal/QmitkPartialVolumeAnalysisView.h"
#include "src/internal/QmitkIVIMView.h"
#include "src/internal/QmitkTractbasedSpatialStatisticsView.h"
#include "src/internal/QmitkTbssSkeletonizationView.h"
#include "src/internal/QmitkStreamlineTrackingView.h"
#include "src/internal/Connectomics/QmitkConnectomicsDataView.h"
#include "src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.h"
#include "src/internal/Connectomics/QmitkConnectomicsStatisticsView.h"
#include "src/internal/QmitkOdfMaximaExtractionView.h"
#include "src/internal/QmitkFiberfoxView.h"
#include "src/internal/QmitkFiberExtractionView.h"
+#include "src/internal/QmitkFieldmapGeneratorView.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)
BERRY_REGISTER_EXTENSION_CLASS(QmitkODFDetailsView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkGibbsTrackingView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkStochasticFiberTrackingView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkFiberProcessingView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkFiberBundleDeveloperView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkPartialVolumeAnalysisView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkIVIMView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkTractbasedSpatialStatisticsView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkTbssSkeletonizationView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkConnectomicsDataView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkConnectomicsNetworkOperationsView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkConnectomicsStatisticsView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkStreamlineTrackingView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkOdfMaximaExtractionView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkFiberfoxView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkFiberExtractionView, context)
+ BERRY_REGISTER_EXTENSION_CLASS(QmitkFieldmapGeneratorView, context)
}
void PluginActivator::stop(ctkPluginContext* context)
{
Q_UNUSED(context)
}
}
Q_EXPORT_PLUGIN2(org_mitk_gui_qt_diffusionimaging, mitk::PluginActivator)
diff --git a/Plugins/org.mitk.gui.qt.diffusionimagingapp/documentation/MitkDiffusionImagingAppQtHelpCollectionProject.qhcp b/Plugins/org.mitk.gui.qt.diffusionimagingapp/documentation/MitkDiffusionImagingAppQtHelpCollectionProject.qhcp
index a9a39d92fe..ebd648576d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimagingapp/documentation/MitkDiffusionImagingAppQtHelpCollectionProject.qhcp
+++ b/Plugins/org.mitk.gui.qt.diffusionimagingapp/documentation/MitkDiffusionImagingAppQtHelpCollectionProject.qhcp
@@ -1,22 +1,22 @@
<?xml version="1.0" encoding="utf-8" ?>
<QHelpCollectionProject version="1.0">
<assistant>
<title>MITK Diffusion Help</title>
- <applicationIcon>assistant-logo.png</applicationIcon>
+ <applicationIcon>assistant-logo.png</applicationIcon>
<startPage>qthelp://org.mitk.gui.qt.diffusionimagingapp/bundle/index.html</startPage>
- <applicationIcon>assistant-icon.png</applicationIcon>
+ <applicationIcon>assistant-icon.png</applicationIcon>
<enableFilterFunctionality>false</enableFilterFunctionality>
<enableDocumentationManager>false</enableDocumentationManager>
<enableAddressBar visible="false">true</enableAddressBar>
<cacheDirectory>MitkDIApp</cacheDirectory>
<aboutMenuText>
<text>About MITK Diffusion Help</text>
</aboutMenuText>
- <aboutDialog>
- <icon>about-logo.png</icon>
- </aboutDialog>
+ <aboutDialog>
+ <icon>about-logo.png</icon>
+ </aboutDialog>
</assistant>
<docFiles>
-
+
</docFiles>
</QHelpCollectionProject>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/Perspectives/QmitkDIAppSyntheticDataGenerationPerspective.cpp b/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/Perspectives/QmitkDIAppSyntheticDataGenerationPerspective.cpp
index 67e3e08eac..653aa0b8c7 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/Perspectives/QmitkDIAppSyntheticDataGenerationPerspective.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/Perspectives/QmitkDIAppSyntheticDataGenerationPerspective.cpp
@@ -1,56 +1,64 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkDIAppSyntheticDataGenerationPerspective.h"
#include "berryIViewLayout.h"
void QmitkDIAppSyntheticDataGenerationPerspective::CreateInitialLayout(berry::IPageLayout::Pointer layout)
{
/////////////////////////////////////////////////////
// all di-app perspectives should have the following:
/////////////////////////////////////////////////////
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, .15f, "org.mitk.views.datamanager");
berry::IFolderLayout::Pointer left =
layout->CreateFolder("org.mbi.diffusionimaginginternal.leftcontrols",
berry::IPageLayout::BOTTOM, 0.1f, "org.mitk.views.controlvisualizationpropertiesview");
layout->AddStandaloneViewPlaceholder("org.mitk.views.imagenavigator",
berry::IPageLayout::BOTTOM, .4f, "org.mbi.diffusionimaginginternal.leftcontrols", false);
/////////////////////////////////////////////
// here goes the perspective specific stuff
/////////////////////////////////////////////
left->AddView("org.mitk.views.fiberfoxview");
berry::IViewLayout::Pointer lo = layout->GetViewLayout("org.mitk.views.fiberfoxview");
lo->SetCloseable(false);
left->AddView("org.mitk.views.fiberprocessing");
lo = layout->GetViewLayout("org.mitk.views.fiberprocessing");
lo->SetCloseable(false);
+ left->AddView("org.mitk.views.fiberextraction");
+ lo = layout->GetViewLayout("org.mitk.views.fiberextraction");
+ lo->SetCloseable(false);
+
+ left->AddView("org.mitk.views.fieldmapgenerator");
+ lo = layout->GetViewLayout("org.mitk.views.fieldmapgenerator");
+ lo->SetCloseable(false);
+
left->AddView("org.mitk.views.segmentation");
lo = layout->GetViewLayout("org.mitk.views.segmentation");
lo->SetCloseable(false);
}
diff --git a/Plugins/org.mitk.gui.qt.dtiatlasapp/documentation/MitkDTIAtlasAppQtHelpCollectionProject.qhcp b/Plugins/org.mitk.gui.qt.dtiatlasapp/documentation/MitkDTIAtlasAppQtHelpCollectionProject.qhcp
index fa48318c3b..121bb95921 100644
--- a/Plugins/org.mitk.gui.qt.dtiatlasapp/documentation/MitkDTIAtlasAppQtHelpCollectionProject.qhcp
+++ b/Plugins/org.mitk.gui.qt.dtiatlasapp/documentation/MitkDTIAtlasAppQtHelpCollectionProject.qhcp
@@ -1,22 +1,22 @@
<?xml version="1.0" encoding="utf-8" ?>
<QHelpCollectionProject version="1.0">
<assistant>
<title>MITK 3M3 Help</title>
- <applicationIcon>assistant-logo.png</applicationIcon>
+ <applicationIcon>assistant-logo.png</applicationIcon>
<startPage>qthelp://org.mitk.gui.qt.dtiatlasapp/bundle/index.html</startPage>
- <applicationIcon>assistant-icon.png</applicationIcon>
+ <applicationIcon>assistant-icon.png</applicationIcon>
<enableFilterFunctionality>false</enableFilterFunctionality>
<enableDocumentationManager>false</enableDocumentationManager>
<enableAddressBar visible="false">true</enableAddressBar>
<cacheDirectory>Mitk3M3</cacheDirectory>
<aboutMenuText>
<text>About MITK 3M3 Help</text>
</aboutMenuText>
- <aboutDialog>
- <icon>about-logo.png</icon>
- </aboutDialog>
+ <aboutDialog>
+ <icon>about-logo.png</icon>
+ </aboutDialog>
</assistant>
<docFiles>
-
+
</docFiles>
</QHelpCollectionProject>
diff --git a/Plugins/org.mitk.gui.qt.examples/CMakeLists.txt b/Plugins/org.mitk.gui.qt.examples/CMakeLists.txt
index 4c7d54d49d..4bc67387dc 100644
--- a/Plugins/org.mitk.gui.qt.examples/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.examples/CMakeLists.txt
@@ -1,7 +1,7 @@
project(org_mitk_gui_qt_examples)
MACRO_CREATE_MITK_CTK_PLUGIN(
- EXPORT_DIRECTIVE EXAMPLES_EXPORT
- EXPORTED_INCLUDE_SUFFIXES src
- MODULE_DEPENDENCIES QmitkExt
+ EXPORT_DIRECTIVE EXAMPLES_EXPORT
+ EXPORTED_INCLUDE_SUFFIXES src
+ MODULE_DEPENDENCIES QmitkExt
)
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.examples/files.cmake b/Plugins/org.mitk.gui.qt.examples/files.cmake
index 18a5f2d363..a8c57e39b9 100644
--- a/Plugins/org.mitk.gui.qt.examples/files.cmake
+++ b/Plugins/org.mitk.gui.qt.examples/files.cmake
@@ -1,60 +1,67 @@
set(SRC_CPP_FILES
)
set(INTERNAL_CPP_FILES
mitkPluginActivator.cpp
colourimageprocessing/QmitkColourImageProcessingView.cpp
colourimageprocessing/mitkColourImageProcessor.cpp
isosurface/QmitkIsoSurface.cpp
simpleexample/QmitkSimpleExampleView.cpp
simplemeasurement/QmitkSimpleMeasurement.cpp
viewinitialization/QmitkViewInitializationView.cpp
volumetry/QmitkVolumetryView.cpp
+ surfaceutilities/QmitkSurfaceUtilities.cpp
+ surfaceutilities/mitkSurfaceModifier.cpp
+ surfaceutilities/mitkSurfaceToPointSetFilter.cpp
+ surfaceutilities/mitkTargetPointsCalculator.cpp
)
set(UI_FILES
src/internal/colourimageprocessing/QmitkColourImageProcessingViewControls.ui
src/internal/isosurface/QmitkIsoSurfaceControls.ui
src/internal/simpleexample/QmitkSimpleExampleViewControls.ui
src/internal/simplemeasurement/QmitkSimpleMeasurementControls.ui
src/internal/viewinitialization/QmitkViewInitializationViewControls.ui
src/internal/volumetry/QmitkVolumetryViewControls.ui
+ src/internal/surfaceutilities/QmitkSurfaceUtilitiesControls.ui
)
set(MOC_H_FILES
src/internal/mitkPluginActivator.h
src/internal/colourimageprocessing/QmitkColourImageProcessingView.h
src/internal/isosurface/QmitkIsoSurface.h
src/internal/simpleexample/QmitkSimpleExampleView.h
src/internal/simplemeasurement/QmitkSimpleMeasurement.h
src/internal/viewinitialization/QmitkViewInitializationView.h
src/internal/volumetry/QmitkVolumetryView.h
+ src/internal/surfaceutilities/QmitkSurfaceUtilities.h
)
set(CACHED_RESOURCE_FILES
plugin.xml
resources/ColorImageProcessing.png
resources/isoSurface.xpm
resources/SimpleExample.png
resources/SimpleMeasurement.png
resources/viewInitializationIcon.xpm
resources/volumetryIcon.xpm
+ resources/surfaceUtilities.xpm
)
set(QRC_FILES
resources/QmitkColourImageProcessingView.qrc
resources/isosurface.qrc
resources/QmitkVolumetryView.qrc
)
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/Plugins/org.mitk.gui.qt.examples/plugin.xml b/Plugins/org.mitk.gui.qt.examples/plugin.xml
index 2518a132ec..5e898c6628 100644
--- a/Plugins/org.mitk.gui.qt.examples/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.examples/plugin.xml
@@ -1,57 +1,64 @@
<?xml version="1.0" encoding="UTF-8"?>
<?BlueBerry version="0.1"?>
<plugin>
-
+
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.colourimageprocessing"
name="Colour Image Processing"
- class="QmitkColourImageProcessingView"
+ class="QmitkColourImageProcessingView"
icon="resources/ColorImageProcessing.png" />
</extension>
-
+
<extension point="org.blueberry.ui.views">
<category
id="org.mitk.views.general"
name="MITK General"/>
<view
id="org.mitk.views.isosurface"
name="IsoSurface"
category="org.mitk.views.general"
icon="resources/isoSurface.xpm"
class="QmitkIsoSurface" />
</extension>
-
+
<extension point="org.blueberry.ui.views">
- <category
- id="org.mitk.views.general"
- name="MITK General"/>
- <view
- id="org.mitk.views.simplemeasurement"
- name="SimpleMeasurement"
- category="org.mitk.views.general"
+ <category
+ id="org.mitk.views.general"
+ name="MITK General"/>
+ <view
+ id="org.mitk.views.simplemeasurement"
+ name="SimpleMeasurement"
+ category="org.mitk.views.general"
icon="resources/SimpleMeasurement.png"
class="QmitkSimpleMeasurement" />
</extension>
-
+
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.simpleexample"
name="Simple Example"
class="QmitkSimpleExampleView"
icon="resources/SimpleExample.png" />
</extension>
-
+
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.viewinitialization"
name="ViewInitialization"
- class="QmitkViewInitializationView"
+ class="QmitkViewInitializationView"
icon="resources/viewInitializationIcon.xpm"/>
</extension>
-
+
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.volumetry"
name="Volumetry"
- class="QmitkVolumetryView"
+ class="QmitkVolumetryView"
icon="resources/volumetryIcon.xpm" />
</extension>
+ <extension point="org.blueberry.ui.views">
+ <view id="org.mitk.views.qmitksurfaceutilies"
+ name="Surface Utility"
+ class="QmitkSurfaceUtilities"
+ icon="resources/surfaceUtilities.xpm" />
+ </extension>
+
</plugin>
diff --git a/Plugins/org.mitk.gui.qt.examples/resources/surfaceUtilities.xpm b/Plugins/org.mitk.gui.qt.examples/resources/surfaceUtilities.xpm
new file mode 100644
index 0000000000..b43aea934e
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/resources/surfaceUtilities.xpm
@@ -0,0 +1,3837 @@
+/* XPM */
+static char * surfaceUtilities_xpm[] = {
+"200 168 3666 2",
+" c None",
+". c #58789E",
+"+ c #627D9E",
+"@ c #456E9F",
+"# c #4775AD",
+"$ c #4D7099",
+"% c #7089A8",
+"& c #466FA2",
+"* c #4E80BC",
+"= c #4F81BD",
+"- c #4979B2",
+"; c #466891",
+"> c #738DAB",
+", c #436B9C",
+"' c #4F81BE",
+") c #456FA1",
+"! c #4877AF",
+"~ c #4C6E97",
+"{ c #456EA0",
+"] c #466991",
+"^ c #6E88A7",
+"/ c #4E7FBC",
+"( c #4978B1",
+"_ c #4F719A",
+": c #647FA0",
+"< c #4670A2",
+"[ c #4A6C95",
+"} c #446D9E",
+"| c #486A93",
+"1 c #6A84A4",
+"2 c #436C9C",
+"3 c #4D7FBC",
+"4 c #4977B0",
+"5 c #50729B",
+"6 c #6882A3",
+"7 c #4978B0",
+"8 c #446C9D",
+"9 c #6681A1",
+"0 c #4D7FBB",
+"a c #6E87A7",
+"b c #476991",
+"c c #416897",
+"d c #4C7CB7",
+"e c #4C7DB8",
+"f c #4D7EB9",
+"g c #4E7FBA",
+"h c #4776AD",
+"i c #4B6D95",
+"j c #507198",
+"k c #4E719C",
+"l c #50749F",
+"m c #50749E",
+"n c #466C99",
+"o c #4F82BF",
+"p c #416A9D",
+"q c #50739D",
+"r c #4D6F98",
+"s c #5082BF",
+"t c #3D6596",
+"u c #496C95",
+"v c #6784A6",
+"w c #607DA1",
+"x c #53739A",
+"y c #3A608E",
+"z c #6380A3",
+"A c #53749D",
+"B c #4170A6",
+"C c #56779F",
+"D c #4774A9",
+"E c #4B6E97",
+"F c #4979B3",
+"G c #4B7BB6",
+"H c #55779E",
+"I c #4672A8",
+"J c #4E80BD",
+"K c #446D9F",
+"L c #627FA1",
+"M c #52739C",
+"N c #4A7AB4",
+"O c #4F82BE",
+"P c #3F689A",
+"Q c #627FA2",
+"R c #52739B",
+"S c #4575AE",
+"T c #5081BE",
+"U c #4C6E96",
+"V c #456994",
+"W c #476B95",
+"X c #56769D",
+"Y c #59789D",
+"Z c #486B94",
+"` c #4F80BC",
+" . c #4E7FBB",
+".. c #436C9D",
+"+. c #637FA1",
+"@. c #3A618F",
+"#. c #3E6696",
+"$. c #3E6695",
+"%. c #3E6595",
+"&. c #3D6594",
+"*. c #416795",
+"=. c #426896",
+"-. c #416794",
+";. c #3D6290",
+">. c #3F638F",
+",. c #3D618D",
+"'. c #527298",
+"). c #54759D",
+"!. c #4878B2",
+"~. c #496B95",
+"{. c #4E81BC",
+"]. c #3B6290",
+"^. c #3F6797",
+"/. c #406898",
+"(. c #406797",
+"_. c #3B6291",
+":. c #395E8D",
+"<. c #436691",
+"[. c #54749A",
+"}. c #50719A",
+"|. c #4675AE",
+"1. c #4D7EBA",
+"2. c #446FA2",
+"3. c #4F76A5",
+"4. c #4E76A5",
+"5. c #4770A2",
+"6. c #4D7FBA",
+"7. c #4571A7",
+"8. c #4C74A3",
+"9. c #4870A1",
+"0. c #4A79B1",
+"a. c #466FA0",
+"b. c #3C6494",
+"c. c #456995",
+"d. c #486A95",
+"e. c #4A6B93",
+"f. c #4B7BB5",
+"g. c #416A9C",
+"h. c #406897",
+"i. c #3F6696",
+"j. c #3E6391",
+"k. c #456791",
+"l. c #5C7A9F",
+"m. c #55769E",
+"n. c #4777B0",
+"o. c #3A6191",
+"p. c #436792",
+"q. c #517199",
+"r. c #4E7099",
+"s. c #4676AF",
+"t. c #4F81BC",
+"u. c #3C6392",
+"v. c #436894",
+"w. c #476892",
+"x. c #4F7199",
+"y. c #4F80BD",
+"z. c #6380A2",
+"A. c #3F6695",
+"B. c #3B608E",
+"C. c #56759A",
+"D. c #55769D",
+"E. c #436B9D",
+"F. c #3F6593",
+"G. c #4A6B94",
+"H. c #3E6797",
+"I. c #3D618E",
+"J. c #92908A",
+"K. c #828079",
+"L. c #817E77",
+"M. c #7D7A72",
+"N. c #7C7972",
+"O. c #7C7971",
+"P. c #7C7970",
+"Q. c #7A7770",
+"R. c #79766F",
+"S. c #79766E",
+"T. c #78746D",
+"U. c #76746D",
+"V. c #5D6A78",
+"W. c #436D9F",
+"X. c #4876AF",
+"Y. c #466893",
+"Z. c #3E6491",
+"`. c #476B97",
+" + c #406693",
+".+ c #436996",
+"++ c #3D6494",
+"@+ c #3D6493",
+"#+ c #3D628F",
+"$+ c #A8A7A3",
+"%+ c #8E8C85",
+"&+ c #88857E",
+"*+ c #89867E",
+"=+ c #807D76",
+"-+ c #817F77",
+";+ c #838078",
+">+ c #827F78",
+",+ c #838079",
+"'+ c #827F77",
+")+ c #807E76",
+"!+ c #7F7C75",
+"~+ c #7F7D75",
+"{+ c #7E7B74",
+"]+ c #7D7B73",
+"^+ c #636E79",
+"/+ c #3C679B",
+"(+ c #4A6C97",
+"_+ c #56769C",
+":+ c #4B6D97",
+"<+ c #436692",
+"[+ c #385F8E",
+"}+ c #6682A4",
+"|+ c #BFBEBA",
+"1+ c #AEADA8",
+"2+ c #83817A",
+"3+ c #807D75",
+"4+ c #848179",
+"5+ c #86837B",
+"6+ c #84817A",
+"7+ c #85827B",
+"8+ c #7E7C74",
+"9+ c #7E7A72",
+"0+ c #66707A",
+"a+ c #3F6A9D",
+"b+ c #4E80BB",
+"c+ c #4A79B3",
+"d+ c #436590",
+"e+ c #5B799F",
+"f+ c #527299",
+"g+ c #3E618D",
+"h+ c #3E6594",
+"i+ c #3F6798",
+"j+ c #A7A5A0",
+"k+ c #8F8D86",
+"l+ c #908D86",
+"m+ c #817E76",
+"n+ c #827F79",
+"o+ c #88857D",
+"p+ c #87847B",
+"q+ c #85827A",
+"r+ c #87847C",
+"s+ c #7D7A73",
+"t+ c #7C7871",
+"u+ c #5F6B79",
+"v+ c #426C9F",
+"w+ c #4876AE",
+"x+ c #57769B",
+"y+ c #446691",
+"z+ c #426692",
+"A+ c #426795",
+"B+ c #406899",
+"C+ c #3C6290",
+"D+ c #8D8B84",
+"E+ c #87847D",
+"F+ c #7B7871",
+"G+ c #7A7870",
+"H+ c #7A7670",
+"I+ c #616C77",
+"J+ c #3C679C",
+"K+ c #496C96",
+"L+ c #52739A",
+"M+ c #3F6490",
+"N+ c #3A6190",
+"O+ c #9E9B97",
+"P+ c #8A8680",
+"Q+ c #837F77",
+"R+ c #86847C",
+"S+ c #86837C",
+"T+ c #79776F",
+"U+ c #78766E",
+"V+ c #79756D",
+"W+ c #616B75",
+"X+ c #416C9E",
+"Y+ c #4A79B2",
+"Z+ c #42648F",
+"`+ c #436591",
+" @ c #3E6492",
+".@ c #446792",
+"+@ c #95938D",
+"@@ c #8E8B85",
+"#@ c #7F7C74",
+"$@ c #7C7A72",
+"%@ c #7D7972",
+"&@ c #5F6C7A",
+"*@ c #406B9E",
+"=@ c #4778B2",
+"-@ c #4777B1",
+";@ c #4776B0",
+">@ c #4877B0",
+",@ c #4C7CB6",
+"'@ c #4A6B95",
+")@ c #3F6592",
+"!@ c #496B94",
+"~@ c #A09E9A",
+"{@ c #84827B",
+"]@ c #828078",
+"^@ c #7E7B75",
+"/@ c #817D77",
+"(@ c #69737D",
+"_@ c #3B669B",
+":@ c #4B7CB7",
+"<@ c #42648C",
+"[@ c #56697E",
+"}@ c #54677C",
+"|@ c #53667C",
+"1@ c #52657C",
+"2@ c #53677C",
+"3@ c #54677D",
+"4@ c #55687E",
+"5@ c #54687E",
+"6@ c #5E7289",
+"7@ c #617EA1",
+"8@ c #466C9A",
+"9@ c #4D7EB8",
+"0@ c #3E6799",
+"a@ c #4F729A",
+"b@ c #4D709A",
+"c@ c #4673A9",
+"d@ c #4A6C96",
+"e@ c #395F8D",
+"f@ c #406593",
+"g@ c #8B8882",
+"h@ c #7E7B73",
+"i@ c #838077",
+"j@ c #848078",
+"k@ c #67727D",
+"l@ c #436DA0",
+"m@ c #4A7BB6",
+"n@ c #4E6887",
+"o@ c #807B70",
+"p@ c #7B786F",
+"q@ c #79756C",
+"r@ c #76726A",
+"s@ c #757168",
+"t@ c #736F67",
+"u@ c #726E66",
+"v@ c #726D66",
+"w@ c #827E78",
+"x@ c #96938D",
+"y@ c #5E7999",
+"z@ c #3F6595",
+"A@ c #3D6595",
+"B@ c #57779E",
+"C@ c #84827A",
+"D@ c #838179",
+"E@ c #63707E",
+"F@ c #3E699D",
+"G@ c #4E6987",
+"H@ c #817C73",
+"I@ c #78756E",
+"J@ c #77756D",
+"K@ c #76736C",
+"L@ c #74716B",
+"M@ c #726F68",
+"N@ c #52667E",
+"O@ c #4C7EB9",
+"P@ c #496B96",
+"Q@ c #4F6F97",
+"R@ c #3B618F",
+"S@ c #89867F",
+"T@ c #84807A",
+"U@ c #837F78",
+"V@ c #87857D",
+"W@ c #7D7B72",
+"X@ c #837F79",
+"Y@ c #6A747F",
+"Z@ c #3C689C",
+"`@ c #4F6A89",
+" # c #868178",
+".# c #827F76",
+"+# c #566A82",
+"@# c #4C7DB9",
+"## c #4A7AB3",
+"$# c #3F638E",
+"%# c #3C6493",
+"&# c #55749B",
+"*# c #93918D",
+"=# c #8A877F",
+"-# c #848079",
+";# c #65717E",
+"># c #436EA0",
+",# c #516C8A",
+"'# c #8E897F",
+")# c #8B8880",
+"!# c #8A887F",
+"~# c #89867D",
+"{# c #8B887F",
+"]# c #5A6E86",
+"^# c #436690",
+"/# c #3E6593",
+"(# c #3F6898",
+"_# c #3C608D",
+":# c #8A8981",
+"<# c #8A8780",
+"[# c #89857D",
+"}# c #697582",
+"|# c #8D887E",
+"1# c #8B8780",
+"2# c #8C8981",
+"3# c #8D8A82",
+"4# c #8E8B83",
+"5# c #908C84",
+"6# c #8F8B83",
+"7# c #8D8B83",
+"8# c #5C7188",
+"9# c #4C6C95",
+"0# c #908E88",
+"a# c #8C8980",
+"b# c #8B8881",
+"c# c #86827C",
+"d# c #8C8881",
+"e# c #8A867E",
+"f# c #6D7882",
+"g# c #396397",
+"h# c #516B89",
+"i# c #918E85",
+"j# c #949189",
+"k# c #98948C",
+"l# c #939189",
+"m# c #5D7289",
+"n# c #426C9E",
+"o# c #456793",
+"p# c #39608E",
+"q# c #3E6493",
+"r# c #507097",
+"s# c #8B8983",
+"t# c #86847D",
+"u# c #8C8982",
+"v# c #8A8880",
+"w# c #86837D",
+"x# c #88857C",
+"y# c #88847D",
+"z# c #667483",
+"A# c #566C85",
+"B# c #8C887E",
+"C# c #85837B",
+"D# c #908D85",
+"E# c #53729A",
+"F# c #3F6796",
+"G# c #537299",
+"H# c #898781",
+"I# c #898780",
+"J# c #8A867F",
+"K# c #8D8982",
+"L# c #7E7F7D",
+"M# c #8B877F",
+"N# c #8F8C84",
+"O# c #4D6D96",
+"P# c #3B5F8A",
+"Q# c #8E8C87",
+"R# c #8D8A83",
+"S# c #8C8983",
+"T# c #8E8B82",
+"U# c #8E8B84",
+"V# c #908C85",
+"W# c #918E86",
+"X# c #928F87",
+"Y# c #8C8A82",
+"Z# c #88847E",
+"`# c #40638F",
+" $ c #375B88",
+".$ c #94928D",
+"+$ c #87857E",
+"@$ c #928E86",
+"#$ c #918E87",
+"$$ c #8F8C85",
+"%$ c #908D84",
+"&$ c #939088",
+"*$ c #85837D",
+"=$ c #6F7881",
+"-$ c #707880",
+";$ c #727A80",
+">$ c #737B82",
+",$ c #737A81",
+"'$ c #516987",
+")$ c #3C6495",
+"!$ c #3F6491",
+"~$ c #8B8982",
+"{$ c #918D85",
+"]$ c #938F87",
+"^$ c #4A6686",
+"/$ c #3F689B",
+"($ c #4976AB",
+"_$ c #4875AA",
+":$ c #4876AC",
+"<$ c #4979B1",
+"[$ c #4C78AC",
+"}$ c #4F7AAF",
+"|$ c #4E7AAE",
+"1$ c #476B96",
+"2$ c #5A799E",
+"3$ c #87847E",
+"4$ c #95928A",
+"5$ c #96938B",
+"6$ c #94928A",
+"7$ c #8D8981",
+"8$ c #8B8980",
+"9$ c #8A8781",
+"0$ c #87837C",
+"a$ c #8C877F",
+"b$ c #4A688A",
+"c$ c #416999",
+"d$ c #446893",
+"e$ c #8B8981",
+"f$ c #8C8882",
+"g$ c #8E8A84",
+"h$ c #8E8C84",
+"i$ c #959189",
+"j$ c #96928A",
+"k$ c #96938A",
+"l$ c #97948C",
+"m$ c #939089",
+"n$ c #928E87",
+"o$ c #938F88",
+"p$ c #8C8880",
+"q$ c #84847F",
+"r$ c #4C688A",
+"s$ c #4776AF",
+"t$ c #677380",
+"u$ c #4A6C94",
+"v$ c #928F86",
+"w$ c #969289",
+"x$ c #969389",
+"y$ c #95928B",
+"z$ c #98958D",
+"A$ c #99958D",
+"B$ c #949088",
+"C$ c #928F88",
+"D$ c #86847E",
+"E$ c #496789",
+"F$ c #416898",
+"G$ c #656E76",
+"H$ c #77746D",
+"I$ c #77756E",
+"J$ c #7D7A74",
+"K$ c #96948E",
+"L$ c #375C89",
+"M$ c #888680",
+"N$ c #82807A",
+"O$ c #88867F",
+"P$ c #88857F",
+"Q$ c #949089",
+"R$ c #95918A",
+"S$ c #98958B",
+"T$ c #8A8881",
+"U$ c #4A6789",
+"V$ c #5F6C78",
+"W$ c #75736C",
+"X$ c #727069",
+"Y$ c #83807B",
+"Z$ c #385D8B",
+"`$ c #8A8882",
+" % c #807E77",
+".% c #83807A",
+"+% c #84817B",
+"@% c #85827C",
+"#% c #908D87",
+"$% c #97948B",
+"%% c #98958C",
+"&% c #8F8D85",
+"*% c #817F78",
+"=% c #797976",
+"-% c #486587",
+";% c #4776AE",
+">% c #416899",
+",% c #636E78",
+"'% c #7C786E",
+")% c #79756F",
+"!% c #75726B",
+"~% c #737069",
+"{% c #6F6D66",
+"]% c #7E7C75",
+"^% c #7C7A74",
+"/% c #486D9A",
+"(% c #416B9E",
+"_% c #365B87",
+":% c #8D8C87",
+"<% c #84827C",
+"[% c #84837C",
+"}% c #918F87",
+"|% c #97938B",
+"1% c #99968E",
+"2% c #9A968E",
+"3% c #99978E",
+"4% c #97958D",
+"5% c #89877F",
+"6% c #807D74",
+"7% c #7F7D76",
+"8% c #476588",
+"9% c #666F79",
+"0% c #75726C",
+"a% c #716E67",
+"b% c #6E6C65",
+"c% c #6D6B64",
+"d% c #6D6B65",
+"e% c #6B6963",
+"f% c #6C6A63",
+"g% c #706E68",
+"h% c #72706A",
+"i% c #78776E",
+"j% c #8F8E89",
+"k% c #4775AB",
+"l% c #4876AD",
+"m% c #365A85",
+"n% c #83817B",
+"o% c #807E79",
+"p% c #807E78",
+"q% c #7F7E78",
+"r% c #817E79",
+"s% c #87857F",
+"t% c #898680",
+"u% c #99968D",
+"v% c #9B978F",
+"w% c #9A978F",
+"x% c #9C988F",
+"y% c #9B9890",
+"z% c #95938B",
+"A% c #94918A",
+"B% c #817F79",
+"C% c #4A6689",
+"D% c #626F7C",
+"E% c #74726B",
+"F% c #74716A",
+"G% c #73716A",
+"H% c #76736D",
+"I% c #77746C",
+"J% c #9C9B95",
+"K% c #355984",
+"L% c #888682",
+"M% c #7D7B75",
+"N% c #82807B",
+"O% c #7F7D77",
+"P% c #7E7C77",
+"Q% c #7F7D78",
+"R% c #8C8A83",
+"S% c #9F9B93",
+"T% c #9E9B92",
+"U% c #9C9991",
+"V% c #9F9C93",
+"W% c #85837C",
+"X% c #7F7F7B",
+"Y% c #49678A",
+"Z% c #5082BE",
+"`% c #6A747D",
+" & c #858177",
+".& c #7F7B74",
+"+& c #7B7971",
+"@& c #8C8984",
+"#& c #4C6C94",
+"$& c #777571",
+"%& c #7C7A76",
+"&& c #7D7B76",
+"*& c #807F79",
+"=& c #7E7C76",
+"-& c #817F7A",
+";& c #A19E95",
+">& c #A29F96",
+",& c #9E9A91",
+"'& c #9A978E",
+")& c #99968F",
+"!& c #98968E",
+"~& c #828179",
+"{& c #48668A",
+"]& c #68737E",
+"^& c #7D7B74",
+"/& c #7F7C76",
+"(& c #8F8C83",
+"_& c #939087",
+":& c #8E8A82",
+"<& c #999791",
+"[& c #506F95",
+"}& c #4572A6",
+"|& c #355884",
+"1& c #83817E",
+"2& c #7C7A75",
+"3& c #7D7A75",
+"4& c #7D7B77",
+"5& c #7E7B77",
+"6& c #9F9C94",
+"7& c #A29E96",
+"8& c #A39F96",
+"9& c #A3A097",
+"0& c #9D9991",
+"a& c #9B9990",
+"b& c #9C9990",
+"c& c #97948D",
+"d& c #96938C",
+"e& c #817E78",
+"f& c #807F7A",
+"g& c #9B988F",
+"h& c #9A958D",
+"i& c #98948B",
+"j& c #8E8A83",
+"k& c #8E8C86",
+"l& c #466E9F",
+"m& c #45668E",
+"n& c #7D7C77",
+"o& c #7C7B76",
+"p& c #7B7A76",
+"q& c #7B7A77",
+"r& c #84817C",
+"s& c #95918B",
+"t& c #9D9A92",
+"u& c #A09C94",
+"v& c #9E9B93",
+"w& c #9C9890",
+"x& c #858279",
+"y& c #7D7D79",
+"z& c #486588",
+"A& c #6B747E",
+"B& c #858078",
+"C& c #9D9A91",
+"D& c #9F9B92",
+"E& c #9D9990",
+"F& c #9B988E",
+"G& c #939188",
+"H& c #476D9B",
+"I& c #4A78B1",
+"J& c #4E6D93",
+"K& c #91918D",
+"L& c #7C7C78",
+"M& c #7D7A76",
+"N& c #7C7B77",
+"O& c #7B7B77",
+"P& c #7B7977",
+"Q& c #7D7B78",
+"R& c #9B9891",
+"S& c #99978F",
+"T& c #908E86",
+"U& c #807D78",
+"V& c #817D78",
+"W& c #88867E",
+"X& c #8D8A81",
+"Y& c #476589",
+"Z& c #66717E",
+"`& c #838178",
+" * c #949188",
+".* c #9A968D",
+"+* c #9D9A90",
+"@* c #9E9C93",
+"#* c #A09C93",
+"$* c #A9A59B",
+"%* c #A9A59C",
+"&* c #A09D94",
+"** c #A29E95",
+"=* c #7A7871",
+"-* c #918F8A",
+";* c #979590",
+">* c #4470A5",
+",* c #807F7D",
+"'* c #7A7976",
+")* c #7A7975",
+"!* c #7B7975",
+"~* c #7B7A75",
+"{* c #7B7976",
+"]* c #7C7A77",
+"^* c #93918A",
+"/* c #9A9790",
+"(* c #9B9790",
+"_* c #98958E",
+":* c #807D77",
+"<* c #7F7E77",
+"[* c #7E7B76",
+"}* c #89857E",
+"|* c #7E7E7A",
+"1* c #4A678A",
+"2* c #4878B1",
+"3* c #63707C",
+"4* c #868177",
+"5* c #959289",
+"6* c #A5A298",
+"7* c #A8A59B",
+"8* c #A6A399",
+"9* c #A9A49B",
+"0* c #ACA89E",
+"a* c #AEAAA0",
+"b* c #ABA89E",
+"c* c #ABA79E",
+"d* c #AAA69D",
+"e* c #AAA59C",
+"f* c #939187",
+"g* c #87857C",
+"h* c #7C7973",
+"i* c #928F89",
+"j* c #8D8B85",
+"k* c #8F8D87",
+"l* c #928F8A",
+"m* c #8F8C87",
+"n* c #8E8B86",
+"o* c #8F8D88",
+"p* c #94938D",
+"q* c #5083C0",
+"r* c #3C6393",
+"s* c #858481",
+"t* c #7A7876",
+"u* c #787674",
+"v* c #787774",
+"w* c #777774",
+"x* c #767572",
+"y* c #777674",
+"z* c #777673",
+"A* c #797875",
+"B* c #7A7977",
+"C* c #827F7A",
+"D* c #96948C",
+"E* c #7F7E76",
+"F* c #86837A",
+"G* c #82817C",
+"H* c #6C757E",
+"I* c #858178",
+"J* c #A7A39A",
+"K* c #ABA79D",
+"L* c #AFABA1",
+"M* c #ADA99F",
+"N* c #ACA89F",
+"O* c #ADAAA0",
+"P* c #A8A49A",
+"Q* c #4A6B92",
+"R* c #4772A7",
+"S* c #4B7CB6",
+"T* c #7D7C79",
+"U* c #767471",
+"V* c #757471",
+"W* c #747370",
+"X* c #747371",
+"Y* c #757472",
+"Z* c #757573",
+"`* c #787775",
+" = c #84827D",
+".= c #918F88",
+"+= c #72797F",
+"@= c #86827A",
+"#= c #99958C",
+"$= c #A19D94",
+"%= c #A5A198",
+"&= c #ADAA9F",
+"*= c #B1ADA3",
+"== c #B2AEA3",
+"-= c #B0ACA2",
+";= c #B4AFA5",
+">= c #B4B0A5",
+",= c #86847B",
+"'= c #7B7870",
+")= c #908E89",
+"!= c #486B96",
+"~= c #426DA2",
+"{= c #73726F",
+"]= c #71716F",
+"^= c #71706E",
+"/= c #6E6E6D",
+"(= c #6C6B6A",
+"_= c #6C6C6B",
+":= c #72716F",
+"<= c #7B7B76",
+"[= c #807E7A",
+"}= c #87837A",
+"|= c #86827B",
+"1= c #98968C",
+"2= c #AAA79D",
+"3= c #B1ADA2",
+"4= c #B2ADA4",
+"5= c #A4A197",
+"6= c #85817B",
+"7= c #8C8B84",
+"8= c #4A7BB5",
+"9= c #4B709C",
+"0= c #838281",
+"a= c #716F6E",
+"b= c #70706E",
+"c= c #706F6D",
+"d= c #6D6D6A",
+"e= c #6D6D6B",
+"f= c #696968",
+"g= c #6A6969",
+"h= c #6B6B6A",
+"i= c #71706F",
+"j= c #7C7975",
+"k= c #85827D",
+"l= c #888580",
+"m= c #B3AFA5",
+"n= c #A5A197",
+"o= c #9D9B91",
+"p= c #938F85",
+"q= c #8D8B82",
+"r= c #827D75",
+"s= c #6D7D91",
+"t= c #4976AC",
+"u= c #848382",
+"v= c #6F6E6D",
+"w= c #6E6D6B",
+"x= c #6C6C6A",
+"y= c #6D6C6A",
+"z= c #6B6A69",
+"A= c #6A6968",
+"B= c #696867",
+"C= c #6D6C6B",
+"D= c #6F6F6E",
+"E= c #6F6F6D",
+"F= c #727170",
+"G= c #797876",
+"H= c #7B7A78",
+"I= c #7C7B78",
+"J= c #7C7B75",
+"K= c #81807A",
+"L= c #948F88",
+"M= c #A7A49A",
+"N= c #AFABA2",
+"O= c #AEAAA1",
+"P= c #AFACA2",
+"Q= c #AEABA1",
+"R= c #A4A097",
+"S= c #8A877E",
+"T= c #788085",
+"U= c #5F7389",
+"V= c #9B978E",
+"W= c #908C83",
+"X= c #918D84",
+"Y= c #85847F",
+"Z= c #42648D",
+"`= c #416EA4",
+" - c #7F7F7D",
+".- c #6E6D6C",
+"+- c #6A6A68",
+"@- c #727270",
+"#- c #767674",
+"$- c #7B7B78",
+"%- c #7F7D79",
+"&- c #86857F",
+"*- c #85847D",
+"=- c #7C7974",
+"-- c #7B7973",
+";- c #7C7A73",
+">- c #9A978D",
+",- c #A8A49B",
+"'- c #B0ACA1",
+")- c #A6A299",
+"!- c #A19E94",
+"~- c #A3A096",
+"{- c #928D83",
+"]- c #747D85",
+"^- c #60768F",
+"/- c #A09D93",
+"(- c #A09B91",
+"_- c #A6A093",
+":- c #898C8B",
+"<- c #657587",
+"[- c #4E6E95",
+"}- c #416FA7",
+"|- c #426A99",
+"1- c #818181",
+"2- c #666564",
+"3- c #686866",
+"4- c #686867",
+"5- c #6E6D6D",
+"6- c #86837E",
+"7- c #7B7873",
+"8- c #817D76",
+"9- c #AAA79E",
+"0- c #ACA89D",
+"a- c #ABA89D",
+"b- c #A6A298",
+"c- c #7A8085",
+"d- c #426895",
+"e- c #657A92",
+"f- c #A6A39A",
+"g- c #A7A399",
+"h- c #A39F95",
+"i- c #A39E94",
+"j- c #A6A196",
+"k- c #878E94",
+"l- c #4E6A8B",
+"m- c #416DA2",
+"n- c #617FA2",
+"o- c #7C7C7C",
+"p- c #636362",
+"q- c #626261",
+"r- c #616160",
+"s- c #5F5F5E",
+"t- c #61605F",
+"u- c #646362",
+"v- c #636261",
+"w- c #646463",
+"x- c #676665",
+"y- c #6A6A69",
+"z- c #6D6C6C",
+"A- c #706F6E",
+"B- c #747372",
+"C- c #777775",
+"D- c #797774",
+"E- c #7A7775",
+"F- c #7A7974",
+"G- c #7B7974",
+"H- c #7A7872",
+"I- c #797771",
+"J- c #797772",
+"K- c #787670",
+"L- c #8E8C83",
+"M- c #959188",
+"N- c #B2AFA4",
+"O- c #B8B3A9",
+"P- c #B8B4A9",
+"Q- c #B2AEA4",
+"R- c #ADA9A0",
+"S- c #AEA9A0",
+"T- c #ACA79D",
+"U- c #9E9990",
+"V- c #7F8281",
+"W- c #436793",
+"X- c #5D738B",
+"Y- c #A09C92",
+"Z- c #9E9C95",
+"`- c #959693",
+" ; c #878D91",
+".; c #677C94",
+"+; c #416694",
+"@; c #3B699F",
+"#; c #5083BF",
+"$; c #4977AE",
+"%; c #787878",
+"&; c #616161",
+"*; c #626161",
+"=; c #616261",
+"-; c #636363",
+";; c #666665",
+">; c #686967",
+",; c #6D6D6C",
+"'; c #6F706E",
+"); c #747472",
+"!; c #797874",
+"~; c #7A7875",
+"{; c #7F7C77",
+"]; c #7A7873",
+"^; c #787671",
+"/; c #77766F",
+"(; c #77756F",
+"_; c #797671",
+":; c #797570",
+"<; c #7A7771",
+"[; c #7B7972",
+"}; c #807C76",
+"|; c #8F8B84",
+"1; c #B3AFA4",
+"2; c #B5B1A6",
+"3; c #B6B2A7",
+"4; c #B8B4AA",
+"5; c #BEB9AE",
+"6; c #BCB9AD",
+"7; c #BBB7AC",
+"8; c #BBB6AC",
+"9; c #BAB6AB",
+"0; c #B4B0A6",
+"a; c #ACA99F",
+"b; c #ABA69D",
+"c; c #A9A69C",
+"d; c #A4A198",
+"e; c #9E9B91",
+"f; c #8C887F",
+"g; c #7C8080",
+"h; c #43658E",
+"i; c #4A7BB7",
+"j; c #5D728A",
+"k; c #928E83",
+"l; c #959086",
+"m; c #8A8B8B",
+"n; c #76818A",
+"o; c #617489",
+"p; c #547090",
+"q; c #4B719D",
+"r; c #4371A8",
+"s; c #4777B2",
+"t; c #4574AC",
+"u; c #4C6788",
+"v; c #858683",
+"w; c #6A6A6A",
+"x; c #5B5B5B",
+"y; c #5B5C5C",
+"z; c #5D5D5D",
+"A; c #5E5E5D",
+"B; c #5A5A5A",
+"C; c #605F5F",
+"D; c #606060",
+"E; c #626262",
+"F; c #676766",
+"G; c #686767",
+"H; c #696868",
+"I; c #72706F",
+"J; c #767472",
+"K; c #7E7D77",
+"L; c #77746F",
+"M; c #75736E",
+"N; c #76746E",
+"O; c #7B7872",
+"P; c #A19C94",
+"Q; c #AAA69C",
+"R; c #BDB8AE",
+"S; c #C3BEB3",
+"T; c #BCB8AD",
+"U; c #B9B5AB",
+"V; c #BEBAAE",
+"W; c #BDB9AE",
+"X; c #B5B1A7",
+"Y; c #A8A39A",
+"Z; c #96948A",
+"`; c #848583",
+" > c #45658B",
+".> c #496688",
+"+> c #3A5F8B",
+"@> c #4572A7",
+"#> c #4674AD",
+"$> c #747373",
+"%> c #585858",
+"&> c #595959",
+"*> c #5C5C5C",
+"=> c #626160",
+"-> c #5E5E5E",
+";> c #60605F",
+">> c #666666",
+",> c #656665",
+"'> c #676666",
+")> c #72716E",
+"!> c #7C7976",
+"~> c #797670",
+"{> c #787571",
+"]> c #777671",
+"^> c #76746F",
+"/> c #75726D",
+"(> c #74726D",
+"_> c #74726C",
+":> c #73716C",
+"<> c #75736D",
+"[> c #78756F",
+"}> c #797770",
+"|> c #918D86",
+"1> c #9F9C92",
+"2> c #BFBBB0",
+"3> c #C3BFB3",
+"4> c #BBB7AD",
+"5> c #B7B2A9",
+"6> c #B7B3A8",
+"7> c #9C9891",
+"8> c #8E8E89",
+"9> c #4F6C8D",
+"0> c #4979B4",
+"a> c #4B7DB8",
+"b> c #4472A9",
+"c> c #546C88",
+"d> c #7E7D76",
+"e> c #94938E",
+"f> c #797879",
+"g> c #585859",
+"h> c #575757",
+"i> c #535354",
+"j> c #515152",
+"k> c #525253",
+"l> c #545555",
+"m> c #555555",
+"n> c #5F5F5F",
+"o> c #5C5C5D",
+"p> c #59595A",
+"q> c #666664",
+"r> c #6E6E6C",
+"s> c #6F6E6C",
+"t> c #73716B",
+"u> c #716F6A",
+"v> c #7E7A75",
+"w> c #A4A298",
+"x> c #A39E96",
+"y> c #9E9A92",
+"z> c #B2ADA3",
+"A> c #B9B5AA",
+"B> c #B5B0A6",
+"C> c #A5A299",
+"D> c #A29E94",
+"E> c #9D9A94",
+"F> c #4E81BD",
+"G> c #3A669A",
+"H> c #687889",
+"I> c #989691",
+"J> c #4D4D4F",
+"K> c #525353",
+"L> c #505152",
+"M> c #4F4F50",
+"N> c #505051",
+"O> c #4F5051",
+"P> c #4E4F50",
+"Q> c #4C4D4E",
+"R> c #595A5A",
+"S> c #5B5A5A",
+"T> c #747471",
+"U> c #767573",
+"V> c #787672",
+"W> c #777570",
+"X> c #787570",
+"Y> c #767470",
+"Z> c #72706B",
+"`> c #706E69",
+" , c #6F6D68",
+"., c #85817A",
+"+, c #908E85",
+"@, c #ACA9A0",
+"#, c #ACA99E",
+"$, c #B9B4AA",
+"%, c #B6B1A7",
+"&, c #BAB7AB",
+"*, c #B7B3A9",
+"=, c #B1ACA2",
+"-, c #A09E96",
+";, c #58718E",
+">, c #426690",
+",, c #8D9295",
+"', c #96928B",
+"), c #989792",
+"!, c #4C4C4E",
+"~, c #4E4F4F",
+"{, c #575758",
+"], c #5D5C5C",
+"^, c #5A5B5B",
+"/, c #4B4B4D",
+"(, c #494B4C",
+"_, c #4A4B4C",
+":, c #4C4C4D",
+"<, c #545455",
+"[, c #565656",
+"}, c #555656",
+"|, c #555556",
+"1, c #737370",
+"2, c #7D7A78",
+"3, c #7B7A74",
+"4, c #797773",
+"5, c #777672",
+"6, c #76756F",
+"7, c #ADA99E",
+"8, c #ADA89E",
+"9, c #C2BDB3",
+"0, c #D0CCC0",
+"a, c #D7D3C7",
+"b, c #D5D1C4",
+"c, c #CBC6BB",
+"d, c #C5C2B5",
+"e, c #C2BEB3",
+"f, c #BAB6AC",
+"g, c #B2AEA5",
+"h, c #B6B2A8",
+"i, c #C2BDB2",
+"j, c #697D94",
+"k, c #4372AA",
+"l, c #667D98",
+"m, c #9C9D9A",
+"n, c #A19E96",
+"o, c #9A968F",
+"p, c #5A5A5C",
+"q, c #494A4B",
+"r, c #4D4E4F",
+"s, c #515252",
+"t, c #5F605F",
+"u, c #4D4E4E",
+"v, c #4A4A4C",
+"w, c #4D4D4E",
+"x, c #4E4E50",
+"y, c #5D5D5C",
+"z, c #656563",
+"A, c #70706F",
+"B, c #7D7C78",
+"C, c #7A7874",
+"D, c #6E6C67",
+"E, c #6D6B66",
+"F, c #716F69",
+"G, c #A4A096",
+"H, c #A5A098",
+"I, c #97938A",
+"J, c #A29D95",
+"K, c #BEBAAF",
+"L, c #BEB9AF",
+"M, c #BDB9AF",
+"N, c #C4C0B4",
+"O, c #CDC8BC",
+"P, c #D5CFC3",
+"Q, c #D0CBBF",
+"R, c #CBC7BB",
+"S, c #CCC7BC",
+"T, c #D1CDC0",
+"U, c #CEC9BD",
+"V, c #CDC8BD",
+"W, c #C8C4B9",
+"X, c #BCB7AD",
+"Y, c #B1ACA0",
+"Z, c #657B94",
+"`, c #4371A7",
+" ' c #3F6BA3",
+".' c #4E6F96",
+"+' c #A6ACAE",
+"@' c #C4C0B6",
+"#' c #A09D95",
+"$' c #A19D95",
+"%' c #898782",
+"&' c #575858",
+"*' c #49494A",
+"=' c #4E4E4F",
+"-' c #515153",
+";' c #4B4C4E",
+">' c #494A4A",
+",' c #48494B",
+"'' c #484849",
+")' c #48484A",
+"!' c #656464",
+"~' c #7C7C79",
+"{' c #787772",
+"]' c #74736E",
+"^' c #716F6B",
+"/' c #6F6D69",
+"(' c #6B6965",
+"_' c #6C6B66",
+":' c #6C6A65",
+"<' c #AAA79C",
+"[' c #ACA79E",
+"}' c #C0BCB1",
+"|' c #B0ADA3",
+"1' c #BAB6AA",
+"2' c #C1BDB2",
+"3' c #C5C0B5",
+"4' c #C6C2B6",
+"5' c #C6C2B7",
+"6' c #C7C3B8",
+"7' c #C5C1B6",
+"8' c #C7C3B6",
+"9' c #CCC8BC",
+"0' c #D6D1C5",
+"a' c #DDD8CB",
+"b' c #E1DBCE",
+"c' c #E3DED1",
+"d' c #EAE4D6",
+"e' c #E6E1D3",
+"f' c #EDE8DA",
+"g' c #E2DDD0",
+"h' c #C8C4B8",
+"i' c #D1CDC1",
+"j' c #C0BCB2",
+"k' c #738396",
+"l' c #436FA5",
+"m' c #4877AE",
+"n' c #436791",
+"o' c #8A98A5",
+"p' c #CCC6BA",
+"q' c #BFBAB0",
+"r' c #91908B",
+"s' c #747576",
+"t' c #444546",
+"u' c #474749",
+"v' c #4A4B4D",
+"w' c #494A4C",
+"x' c #47484B",
+"y' c #464749",
+"z' c #48494A",
+"A' c #474849",
+"B' c #47484A",
+"C' c #4F5050",
+"D' c #565657",
+"E' c #656565",
+"F' c #737372",
+"G' c #767570",
+"H' c #74726E",
+"I' c #74736F",
+"J' c #6D6B67",
+"K' c #6B6A65",
+"L' c #686762",
+"M' c #6A6863",
+"N' c #6B6964",
+"O' c #7E7D75",
+"P' c #A7A39B",
+"Q' c #B8B3A8",
+"R' c #BAB5AB",
+"S' c #B6B3A7",
+"T' c #CAC6BA",
+"U' c #D1CCC0",
+"V' c #D2CDC1",
+"W' c #D4CFC3",
+"X' c #E3DDD0",
+"Y' c #E8E3D6",
+"Z' c #ECE6D8",
+"`' c #EDE7D9",
+" ) c #F3EEE0",
+".) c #F7F1E2",
+"+) c #F2EDDF",
+"@) c #EAE4D7",
+"#) c #C9C4B9",
+"$) c #DAD6C9",
+"%) c #E0DBCE",
+"&) c #B6B4AC",
+"*) c #537091",
+"=) c #4879B4",
+"-) c #406DA4",
+";) c #59789C",
+">) c #8391A0",
+",) c #BEBCB4",
+"') c #C8C2B6",
+")) c #C1BDB3",
+"!) c #C1BEB3",
+"~) c #B1ADA4",
+"{) c #A39F97",
+"]) c #A4A199",
+"^) c #49494B",
+"/) c #464648",
+"() c #454648",
+"_) c #464649",
+":) c #484A4C",
+"<) c #454547",
+"[) c #444547",
+"}) c #454647",
+"|) c #4A4A4B",
+"1) c #5C5D5C",
+"2) c #656564",
+"3) c #737371",
+"4) c #787773",
+"5) c #75736F",
+"6) c #75746E",
+"7) c #74726F",
+"8) c #72706C",
+"9) c #6A6864",
+"0) c #696762",
+"a) c #666460",
+"b) c #686662",
+"c) c #B5B2A7",
+"d) c #BEBBAF",
+"e) c #AEABA0",
+"f) c #99978D",
+"g) c #C9C5B9",
+"h) c #D6D1C4",
+"i) c #D3CEC2",
+"j) c #DAD4C7",
+"k) c #DCD8CA",
+"l) c #E1DCCF",
+"m) c #E5DFD2",
+"n) c #E8E2D5",
+"o) c #EBE6D8",
+"p) c #F1ECDE",
+"q) c #F9F3E4",
+"r) c #FEFCED",
+"s) c #FCF7E9",
+"t) c #EFEADD",
+"u) c #E9E4D5",
+"v) c #EAE6D8",
+"w) c #CDC9BE",
+"x) c #D7D2C6",
+"y) c #E1DDCF",
+"z) c #C6C1B6",
+"A) c #C3BEB4",
+"B) c #AEACA6",
+"C) c #4D6B90",
+"D) c #4573AB",
+"E) c #366093",
+"F) c #5B7596",
+"G) c #91979B",
+"H) c #B2B0AA",
+"I) c #BEBAB0",
+"J) c #C1BCB2",
+"K) c #C3BFB4",
+"L) c #C4C0B5",
+"M) c #A29F97",
+"N) c #85847E",
+"O) c #83817D",
+"P) c #555657",
+"Q) c #434445",
+"R) c #4B4B4C",
+"S) c #434447",
+"T) c #434545",
+"U) c #484949",
+"V) c #6C6B6B",
+"W) c #767574",
+"X) c #7C7B79",
+"Y) c #787673",
+"Z) c #757470",
+"`) c #73726D",
+" ! c #696863",
+".! c #656460",
+"+! c #64625E",
+"@! c #676661",
+"#! c #827E79",
+"$! c #C1BDB1",
+"%! c #CDC9BD",
+"&! c #D8D3C6",
+"*! c #E6E1D4",
+"=! c #E7E2D4",
+"-! c #E8E3D5",
+";! c #E9E4D6",
+">! c #EAE5D7",
+",! c #F0EBDD",
+"'! c #F9F3E5",
+")! c #FDF9EB",
+"!! c #FFFFF2",
+"~! c #FFFFF3",
+"{! c #EAE4D8",
+"]! c #E7E2D5",
+"^! c #E5E0D3",
+"/! c #D9D4C7",
+"(! c #DDD7CB",
+"_! c #CCC7BD",
+":! c #547091",
+"<! c #4B7CB8",
+"[! c #4971A0",
+"}! c #496990",
+"|! c #6C7F92",
+"1! c #A0A09A",
+"2! c #B5AFA3",
+"3! c #BBB8AD",
+"4! c #B4B0A7",
+"5! c #B5B2A8",
+"6! c #C5C0B6",
+"7! c #A3A098",
+"8! c #929089",
+"9! c #86847F",
+"0! c #757576",
+"a! c #434345",
+"b! c #4D4C4E",
+"c! c #444446",
+"d! c #434346",
+"e! c #646464",
+"f! c #757473",
+"g! c #787876",
+"h! c #777572",
+"i! c #757370",
+"j! c #73726E",
+"k! c #6C6B67",
+"l! c #6B6A66",
+"m! c #62615E",
+"n! c #615F5C",
+"o! c #A8A59C",
+"p! c #BCB8AE",
+"q! c #B7B4A9",
+"r! c #A8A59A",
+"s! c #D5D0C3",
+"t! c #D9D4C8",
+"u! c #DBD6C9",
+"v! c #DAD5C8",
+"w! c #E4DFD1",
+"x! c #ECE7D9",
+"y! c #F5EEE0",
+"z! c #FEFBED",
+"A! c #F2EEE0",
+"B! c #EAE5D8",
+"C! c #E0DACE",
+"D! c #DCD7CB",
+"E! c #EFE9DB",
+"F! c #AAA79F",
+"G! c #A7A39C",
+"H! c #B7B4AC",
+"I! c #667E98",
+"J! c #416FA6",
+"K! c #4677B2",
+"L! c #3F6EA7",
+"M! c #3B689E",
+"N! c #51759F",
+"O! c #6E86A1",
+"P! c #8C98A4",
+"Q! c #A7ABAC",
+"R! c #C0BDB2",
+"S! c #BDB7AB",
+"T! c #AAA69E",
+"U! c #C9C4B8",
+"V! c #B1AEA4",
+"W! c #A9A59D",
+"X! c #97958E",
+"Y! c #A3A3A0",
+"Z! c #8C8C8C",
+"`! c #424344",
+" ~ c #444646",
+".~ c #464748",
+"+~ c #444445",
+"@~ c #424346",
+"#~ c #434446",
+"$~ c #4D4F50",
+"%~ c #545556",
+"&~ c #777675",
+"*~ c #7A7A77",
+"=~ c #706E6A",
+"-~ c #6B6966",
+";~ c #686663",
+">~ c #605F5C",
+",~ c #605E5B",
+"'~ c #696763",
+")~ c #BDBAAF",
+"!~ c #C0BBB0",
+"~~ c #BFBAAF",
+"{~ c #C5C1B5",
+"]~ c #DFDACD",
+"^~ c #DCD7CA",
+"/~ c #E6E0D3",
+"(~ c #EFE9DC",
+"_~ c #FBF6E7",
+":~ c #FFFEF0",
+"<~ c #FAF5E7",
+"[~ c #F8F4E6",
+"}~ c #FEFBEC",
+"|~ c #F1EBDD",
+"1~ c #D8D4C7",
+"2~ c #EEE8DB",
+"3~ c #CBC7BC",
+"4~ c #A4A19A",
+"5~ c #B2AFA5",
+"6~ c #C0BBB1",
+"7~ c #C5C0B4",
+"8~ c #6E839A",
+"9~ c #3D69A0",
+"0~ c #416CA1",
+"a~ c #345D90",
+"b~ c #446891",
+"c~ c #6E86A2",
+"d~ c #9EA9B5",
+"e~ c #C7C7C0",
+"f~ c #CAC7BE",
+"g~ c #C5C2B8",
+"h~ c #C4BFB4",
+"i~ c #B7B3AA",
+"j~ c #A6A29A",
+"k~ c #BFBBB1",
+"l~ c #B6B3A9",
+"m~ c #424445",
+"n~ c #424446",
+"o~ c #434244",
+"p~ c #414245",
+"q~ c #414244",
+"r~ c #414243",
+"s~ c #424345",
+"t~ c #434344",
+"u~ c #797877",
+"v~ c #73716F",
+"w~ c #72716D",
+"x~ c #71706C",
+"y~ c #676662",
+"z~ c #666561",
+"A~ c #63615E",
+"B~ c #5D5D59",
+"C~ c #61605D",
+"D~ c #73716D",
+"E~ c #B3B0A6",
+"F~ c #B1ACA3",
+"G~ c #B5B1A8",
+"H~ c #C1BCB1",
+"I~ c #DDD7CA",
+"J~ c #F5EFE1",
+"K~ c #FFFFF1",
+"L~ c #FEFFF1",
+"M~ c #FEFDF0",
+"N~ c #F4EEE0",
+"O~ c #F6F1E3",
+"P~ c #D1CCC1",
+"Q~ c #D8D3C7",
+"R~ c #DEDACD",
+"S~ c #ACA8A0",
+"T~ c #C0BDB3",
+"U~ c #CAC3B7",
+"V~ c #7D8FA2",
+"W~ c #4471A5",
+"X~ c #738AA5",
+"Y~ c #E7E5D9",
+"Z~ c #FFF6E5",
+"`~ c #F3ECDC",
+" { c #EEE8D9",
+".{ c #E9E3D6",
+"+{ c #B7B4AA",
+"@{ c #A9A69E",
+"#{ c #A7A59C",
+"${ c #C2BEB2",
+"%{ c #B0ADA4",
+"&{ c #ABA89F",
+"*{ c #82817D",
+"={ c #48494C",
+"-{ c #454548",
+";{ c #424244",
+">{ c #414345",
+",{ c #414143",
+"'{ c #404144",
+"){ c #474748",
+"!{ c #5D5E5E",
+"~{ c #676767",
+"{{ c #737270",
+"]{ c #72726E",
+"^{ c #73716E",
+"/{ c #676562",
+"({ c #656360",
+"_{ c #5F5D5B",
+":{ c #63625F",
+"<{ c #6C6B68",
+"[{ c #A4A098",
+"}{ c #B4B1A5",
+"|{ c #ABA69C",
+"1{ c #C7C3B7",
+"2{ c #DED9CC",
+"3{ c #E4DFD2",
+"4{ c #F4EFE0",
+"5{ c #FDF9EA",
+"6{ c #FFFDEE",
+"7{ c #FCF9EB",
+"8{ c #D0CBC0",
+"9{ c #99A7B4",
+"0{ c #39659A",
+"a{ c #8397AD",
+"b{ c #F4EFE1",
+"c{ c #E4DED2",
+"d{ c #E9E4D7",
+"e{ c #DDD8CC",
+"f{ c #A7A49D",
+"g{ c #AEABA2",
+"h{ c #A7A49C",
+"i{ c #A19E97",
+"j{ c #C3BFB5",
+"k{ c #CEC9BE",
+"l{ c #737475",
+"m{ c #47474A",
+"n{ c #48484C",
+"o{ c #404244",
+"p{ c #404142",
+"q{ c #404143",
+"r{ c #404042",
+"s{ c #636262",
+"t{ c #6C6C6C",
+"u{ c #777773",
+"v{ c #72706D",
+"w{ c #706F6B",
+"x{ c #6D6C68",
+"y{ c #696864",
+"z{ c #646360",
+"A{ c #5F5E5C",
+"B{ c #656361",
+"C{ c #6E6C69",
+"D{ c #B0ADA2",
+"E{ c #FEFDEE",
+"F{ c #FEFEF0",
+"G{ c #FFFBEC",
+"H{ c #FFFEF1",
+"I{ c #FAF6E8",
+"J{ c #EEE8DC",
+"K{ c #BEBBB0",
+"L{ c #B9B5AC",
+"M{ c #EEE7D9",
+"N{ c #9DA6AE",
+"O{ c #3A6598",
+"P{ c #7C90A7",
+"Q{ c #F0ECDF",
+"R{ c #D9D5C9",
+"S{ c #D5D1C6",
+"T{ c #A5A29B",
+"U{ c #B1AEA5",
+"V{ c #9E9B94",
+"W{ c #A5A199",
+"X{ c #AEAAA2",
+"Y{ c #A7A49B",
+"Z{ c #E2DED0",
+"`{ c #D5D1C5",
+" ] c #C8C3B7",
+".] c #A7A59B",
+"+] c #48484B",
+"@] c #494A4D",
+"#] c #49494C",
+"$] c #3F4042",
+"%] c #686868",
+"&] c #737170",
+"*] c #716F6C",
+"=] c #6C6A67",
+"-] c #696865",
+";] c #686764",
+">] c #5E5D5B",
+",] c #60605D",
+"'] c #6F6D6A",
+")] c #9D9A93",
+"!] c #B8B4AB",
+"~] c #B9B4A9",
+"{] c #AEAA9F",
+"]] c #F6EFE1",
+"^] c #FDFAEB",
+"/] c #FEFDEF",
+"(] c #FFFCED",
+"_] c #FFFCEE",
+":] c #FEFCEE",
+"<] c #EFEADC",
+"[] c #E3DED0",
+"}] c #E4DFD3",
+"|] c #B9B6AB",
+"1] c #BDB8AD",
+"2] c #C9C5BA",
+"3] c #D6D0C3",
+"4] c #A9B1B8",
+"5] c #476F9F",
+"6] c #4A7AB5",
+"7] c #778BA3",
+"8] c #D8D3C8",
+"9] c #C8C3B9",
+"0] c #D5D0C5",
+"a] c #C3C0B6",
+"b] c #ABA79F",
+"c] c #C2BEB5",
+"d] c #AFABA3",
+"e] c #A6A39B",
+"f] c #CFCBBE",
+"g] c #DCD6CA",
+"h] c #F0EADD",
+"i] c #8C8A84",
+"j] c #87847F",
+"k] c #6A6966",
+"l] c #4A4B4E",
+"m] c #46474A",
+"n] c #414144",
+"o] c #3F3F41",
+"p] c #3E3F41",
+"q] c #3F4143",
+"r] c #6F6E6B",
+"s] c #6C6A68",
+"t] c #666563",
+"u] c #656462",
+"v] c #7A7972",
+"w] c #AFACA1",
+"x] c #A29F95",
+"y] c #D0CCBF",
+"z] c #F4EEDF",
+"A] c #F6F0E2",
+"B] c #EFEBDD",
+"C] c #FEFBEB",
+"D] c #FCF9EA",
+"E] c #EEE9DB",
+"F] c #D6D1C6",
+"G] c #BEC2C4",
+"H] c #667C96",
+"I] c #D3CEC3",
+"J] c #CFCBC0",
+"K] c #B2AEA6",
+"L] c #BEBBB1",
+"M] c #DAD5C9",
+"N] c #98958F",
+"O] c #96948D",
+"P] c #918D87",
+"Q] c #8D8B86",
+"R] c #8B8985",
+"S] c #5A5A5B",
+"T] c #4A4C4E",
+"U] c #444548",
+"V] c #3E4042",
+"W] c #3E3E40",
+"X] c #3F4043",
+"Y] c #3F4041",
+"Z] c #706F6C",
+"`] c #6E6D6A",
+" ^ c #6B6A67",
+".^ c #676663",
+"+^ c #5E5E5C",
+"@^ c #5E5D5C",
+"#^ c #686765",
+"$^ c #B0ACA3",
+"%^ c #B4B1A6",
+"&^ c #ECE7D8",
+"*^ c #FEF9EB",
+"=^ c #F8F3E4",
+"-^ c #FFFEEF",
+";^ c #FDFBEC",
+">^ c #CBC7BA",
+",^ c #C7C2B7",
+"'^ c #CECABE",
+")^ c #BABBB9",
+"!^ c #8190A0",
+"~^ c #D6D2C6",
+"{^ c #BFBBB2",
+"]^ c #C8C5B9",
+"^^ c #A5A29A",
+"/^ c #E2DDD1",
+"(^ c #D4D0C4",
+"_^ c #E8E3D7",
+":^ c #B6B2A9",
+"<^ c #8B8883",
+"[^ c #8B8A85",
+"}^ c #888783",
+"|^ c #4B4C4F",
+"1^ c #45464A",
+"2^ c #454649",
+"3^ c #424245",
+"4^ c #3D3E40",
+"5^ c #3E3F40",
+"6^ c #505151",
+"7^ c #6B6A6A",
+"8^ c #71706D",
+"9^ c #6D6C69",
+"0^ c #696866",
+"a^ c #676664",
+"b^ c #60605E",
+"c^ c #5C5C5B",
+"d^ c #85817C",
+"e^ c #B1AEA3",
+"f^ c #B6B3A8",
+"g^ c #CCC7BB",
+"h^ c #D5D0C4",
+"i^ c #D8D4C8",
+"j^ c #ECE6D9",
+"k^ c #FFFDEF",
+"l^ c #FCF8E9",
+"m^ c #D2CCBE",
+"n^ c #CFCABF",
+"o^ c #E1DCD0",
+"p^ c #C6C1B7",
+"q^ c #ADAAA1",
+"r^ c #97948E",
+"s^ c #8C8A86",
+"t^ c #8A8884",
+"u^ c #868581",
+"v^ c #767678",
+"w^ c #3D3D40",
+"x^ c #3C3D3F",
+"y^ c #6B6A68",
+"z^ c #8D8A84",
+"A^ c #A8A49C",
+"B^ c #B7B2A7",
+"C^ c #F9F4E6",
+"D^ c #A5A297",
+"E^ c #C2BEB4",
+"F^ c #BCB8AF",
+"G^ c #D3CFC3",
+"H^ c #CAC5BA",
+"I^ c #D2CEC2",
+"J^ c #B0ACA4",
+"K^ c #8D8A85",
+"L^ c #8B8A84",
+"M^ c #858480",
+"N^ c #7F7D7B",
+"O^ c #6C6D6E",
+"P^ c #4A4B4F",
+"Q^ c #4A4A4E",
+"R^ c #4A4A4D",
+"S^ c #47494B",
+"T^ c #3B3C3E",
+"U^ c #3A3B3D",
+"V^ c #3D3D3F",
+"W^ c #545454",
+"X^ c #616060",
+"Y^ c #6B6B69",
+"Z^ c #6E6E6B",
+"`^ c #6B6B68",
+" / c #5F5E5D",
+"./ c #75746F",
+"+/ c #A49F98",
+"@/ c #B5B0A7",
+"#/ c #CFCBBF",
+"$/ c #76746C",
+"%/ c #C4BFB5",
+"&/ c #DBD6CA",
+"*/ c #A09D96",
+"=/ c #9F9C95",
+"-/ c #878682",
+";/ c #84827F",
+">/ c #484A4D",
+",/ c #4A4C4F",
+"'/ c #3C3D40",
+")/ c #393A3D",
+"!/ c #38393C",
+"~/ c #393A3B",
+"{/ c #3C3C3E",
+"]/ c #6C6B69",
+"^/ c #5C5B5A",
+"// c #DBD5C9",
+"(/ c #D3CEC1",
+"_/ c #C8C3B8",
+":/ c #D0CBBE",
+"</ c #CFCABE",
+"[/ c #CBC6BA",
+"}/ c #716F68",
+"|/ c #6B6962",
+"1/ c #66645E",
+"2/ c #D7D2C5",
+"3/ c #C6C2B8",
+"4/ c #D1CCC2",
+"5/ c #94918B",
+"6/ c #8C8A85",
+"7/ c #8F8C86",
+"8/ c #848380",
+"9/ c #807F7C",
+"0/ c #90908F",
+"a/ c #46474B",
+"b/ c #47474B",
+"c/ c #47484C",
+"d/ c #3D3E41",
+"e/ c #393A3C",
+"f/ c #38383A",
+"g/ c #37383A",
+"h/ c #38393B",
+"i/ c #454546",
+"j/ c #4F4F51",
+"k/ c #696967",
+"l/ c #6A6A67",
+"m/ c #5B5A58",
+"n/ c #787572",
+"o/ c #9F9D95",
+"p/ c #9A9890",
+"q/ c #EBE5D8",
+"r/ c #D4D0C3",
+"s/ c #B4B1A7",
+"t/ c #C2BFB4",
+"u/ c #D3CFC2",
+"v/ c #B0ABA2",
+"w/ c #64625C",
+"x/ c #6C6A64",
+"y/ c #ABA8A0",
+"z/ c #898783",
+"A/ c #898784",
+"B/ c #6B6968",
+"C/ c #4F5052",
+"D/ c #454749",
+"E/ c #3E3F42",
+"F/ c #39393B",
+"G/ c #36373A",
+"H/ c #37383B",
+"I/ c #363739",
+"J/ c #3B3B3D",
+"K/ c #3C3D3E",
+"L/ c #464647",
+"M/ c #6A6967",
+"N/ c #5C5C5A",
+"O/ c #5B5B59",
+"P/ c #656461",
+"Q/ c #97938D",
+"R/ c #B3AFA6",
+"S/ c #DED9CB",
+"T/ c #A19D96",
+"U/ c #716E69",
+"V/ c #67655F",
+"W/ c #625F5A",
+"X/ c #6A6862",
+"Y/ c #B5B3A9",
+"Z/ c #A9A69D",
+"`/ c #83827F",
+" ( c #7F7E7B",
+".( c #575759",
+"+( c #3A3A3D",
+"@( c #3F4044",
+"#( c #3A3B3E",
+"$( c #38383B",
+"%( c #343537",
+"&( c #333436",
+"*( c #333336",
+"=( c #343436",
+"-( c #424144",
+";( c #474848",
+">( c #5B5B5A",
+",( c #5F5E5E",
+"'( c #686766",
+")( c #595857",
+"!( c #6D6D69",
+"~( c #71716D",
+"{( c #837F7A",
+"]( c #E5E0D2",
+"^( c #F2ECDE",
+"/( c #E7E1D4",
+"(( c #ADA9A1",
+"_( c #EDE8DB",
+":( c #F3EDDF",
+"<( c #D4CFC2",
+"[( c #78766F",
+"}( c #696761",
+"|( c #5E5C57",
+"1( c #65635E",
+"2( c #CCC7BA",
+"3( c #9C9A91",
+"4( c #878581",
+"5( c #8A8983",
+"6( c #8B8984",
+"7( c #7E7D7A",
+"8( c #6D6D6F",
+"9( c #3C3E40",
+"0( c #353638",
+"a( c #323335",
+"b( c #313233",
+"c( c #303134",
+"d( c #414142",
+"e( c #575756",
+"f( c #5D5C5D",
+"g( c #565554",
+"h( c #5A5957",
+"i( c #666462",
+"j( c #EBE5D7",
+"k( c #F1EDDE",
+"l( c #FAF4E6",
+"m( c #EBE6D9",
+"n( c #FEF9EA",
+"o( c #BBB6AB",
+"p( c #6E6C66",
+"q( c #615F5A",
+"r( c #5B5955",
+"s( c #696661",
+"t( c #E1DCCE",
+"u( c #8C8B85",
+"v( c #93908A",
+"w( c #8A8885",
+"x( c #3B3C3F",
+"y( c #3B3C3D",
+"z( c #37383C",
+"A( c #353639",
+"B( c #313235",
+"C( c #3E3E41",
+"D( c #4D4D4D",
+"E( c #5C5B5B",
+"F( c #676765",
+"G( c #686865",
+"H( c #6C6C69",
+"I( c #636260",
+"J( c #545351",
+"K( c #5C5B59",
+"L( c #97938C",
+"M( c #FDF8E9",
+"N( c #F8F3E5",
+"O( c #F6F0E1",
+"P( c #D7D2C7",
+"Q( c #F5EFE2",
+"R( c #DAD4C8",
+"S( c #605E59",
+"T( c #5E5C58",
+"U( c #686661",
+"V( c #DED9CD",
+"W( c #E2DDCF",
+"X( c #98968F",
+"Y( c #99958E",
+"Z( c #94928B",
+"`( c #7F7E7A",
+" _ c #7E7C7A",
+"._ c #868582",
+"+_ c #767673",
+"@_ c #5D5D5F",
+"#_ c #343538",
+"$_ c #323336",
+"%_ c #323235",
+"&_ c #2F2F32",
+"*_ c #2B2C2E",
+"=_ c #5C5D5F",
+"-_ c #3A3A3C",
+";_ c #5E5D5A",
+">_ c #6F6E6A",
+",_ c #E3DFD2",
+"'_ c #F6F2E3",
+")_ c #FEFDF2",
+"!_ c #FAF6E9",
+"~_ c #EDE7DA",
+"{_ c #BCB9AF",
+"]_ c #B9B6AC",
+"^_ c #FFFEF2",
+"/_ c #F8F2E4",
+"(_ c #6F6D67",
+"__ c #676560",
+":_ c #62605C",
+"<_ c #63615C",
+"[_ c #726F6B",
+"}_ c #949289",
+"|_ c #F9F4E5",
+"1_ c #FCF9EF",
+"2_ c #AFACA3",
+"3_ c #A29D96",
+"4_ c #9D9992",
+"5_ c #7A7979",
+"6_ c #69696A",
+"7_ c #303033",
+"8_ c #2F3032",
+"9_ c #2E2F32",
+"0_ c #2E2F31",
+"a_ c #2C2D30",
+"b_ c #2C2D2F",
+"c_ c #333437",
+"d_ c #525255",
+"e_ c #3D3E3F",
+"f_ c #434444",
+"g_ c #4C4D4D",
+"h_ c #636361",
+"i_ c #5D5C59",
+"j_ c #565553",
+"k_ c #6A6865",
+"l_ c #FEFCEF",
+"m_ c #FFFFF7",
+"n_ c #FEFDF4",
+"o_ c #FCF7E8",
+"p_ c #BEB9B0",
+"q_ c #BDB9B0",
+"r_ c #C5C1B7",
+"s_ c #FFFEF4",
+"t_ c #FFFFF6",
+"u_ c #FFFBED",
+"v_ c #827E77",
+"w_ c #77746E",
+"x_ c #686660",
+"y_ c #66645F",
+"z_ c #FBF6E8",
+"A_ c #FFFEF3",
+"B_ c #FFFFF9",
+"C_ c #F9F6EA",
+"D_ c #8A8782",
+"E_ c #858380",
+"F_ c #817F7C",
+"G_ c #82807C",
+"H_ c #5A5959",
+"I_ c #5E5F60",
+"J_ c #3F4040",
+"K_ c #605F5E",
+"L_ c #646361",
+"M_ c #585755",
+"N_ c #A5A19A",
+"O_ c #FDFAEC",
+"P_ c #FEFAED",
+"Q_ c #D0CCC1",
+"R_ c #B0AEA4",
+"S_ c #D8D2C7",
+"T_ c #E3DDD2",
+"U_ c #FBF7E8",
+"V_ c #FFFEF5",
+"W_ c #FBF7E9",
+"X_ c #6F6C67",
+"Y_ c #76736E",
+"Z_ c #D2CDC2",
+"`_ c #F4F0E1",
+" : c #888480",
+".: c #908D88",
+"+: c #82807D",
+"@: c #717272",
+"#: c #4B4B4B",
+"$: c #535353",
+"%: c #62615F",
+"&: c #636360",
+"*: c #676563",
+"=: c #61605E",
+"-: c #575654",
+";: c #585855",
+">: c #63625E",
+",: c #FFFDF0",
+"': c #FCF8EA",
+"): c #FFFDF1",
+"!: c #FDF7E9",
+"~: c #BAB6AD",
+"{: c #FEFFF3",
+"]: c #7A7772",
+"^: c #CECABF",
+"/: c #E6E1D5",
+"(: c #FFFFF4",
+"_: c #FEFEF7",
+":: c #FFFFF5",
+"<: c #FBF8EB",
+"[: c #918E88",
+"}: c #82817E",
+"|: c #707071",
+"1: c #505050",
+"2: c #575656",
+"3: c #595958",
+"4: c #626360",
+"5: c #636160",
+"6: c #585754",
+"7: c #595855",
+"8: c #6F6E69",
+"9: c #98948D",
+"0: c #908E87",
+"a: c #B8B3AA",
+"b: c #B4B2A8",
+"c: c #D6D2C5",
+"d: c #FFFFF0",
+"e: c #F9F5E6",
+"f: c #E5E1D4",
+"g: c #C9C4BA",
+"h: c #A8A49D",
+"i: c #A4A29A",
+"j: c #D1CDC2",
+"k: c #FAF6E7",
+"l: c #6E6C68",
+"m: c #ECE8DB",
+"n: c #FEFEF4",
+"o: c #FFFFF8",
+"p: c #F5F0E3",
+"q: c #F6F0E3",
+"r: c #CAC6BC",
+"s: c #83827D",
+"t: c #797872",
+"u: c #737373",
+"v: c #515151",
+"w: c #545353",
+"x: c #5D5C5B",
+"y: c #5A5958",
+"z: c #555452",
+"A: c #5C5B57",
+"B: c #6C6A66",
+"C: c #74716D",
+"D: c #807C77",
+"E: c #FEFEF1",
+"F: c #A2A097",
+"G: c #DEDACE",
+"H: c #F9F5E7",
+"I: c #706F6A",
+"J: c #D9D5CA",
+"K: c #FDFAED",
+"L: c #FBF9EE",
+"M: c #F6F1E4",
+"N: c #E2DED2",
+"O: c #D2CDC3",
+"P: c #9F9D96",
+"Q: c #9A9891",
+"R: c #93918B",
+"S: c #84827E",
+"T: c #5F6060",
+"U: c #545453",
+"V: c #515150",
+"W: c #585857",
+"X: c #5D5C5A",
+"Y: c #5B5A59",
+"Z: c #535351",
+"`: c #545350",
+" < c #6D6C67",
+".< c #6E6D68",
+"+< c #B7B2A8",
+"@< c #E4E0D3",
+"#< c #F1EBDE",
+"$< c #F5F0E2",
+"%< c #726F6A",
+"&< c #9F9B94",
+"*< c #CCC8BD",
+"=< c #DED9CE",
+"-< c #E9E4D8",
+";< c #F0EBDF",
+">< c #E7E3D8",
+",< c #F6F0E4",
+"'< c #D8D4CA",
+")< c #E3DFD4",
+"!< c #D6D1C7",
+"~< c #BBB7AE",
+"{< c #85837F",
+"]< c #8A8985",
+"^< c #83827E",
+"/< c #3E3E3F",
+"(< c #494949",
+"_< c #525251",
+":< c #525151",
+"<< c #5A5A59",
+"[< c #4F4D4C",
+"}< c #555451",
+"|< c #605F5B",
+"1< c #686763",
+"2< c #6E6D69",
+"3< c #CAC6BB",
+"4< c #F7F3E6",
+"5< c #D2CEC1",
+"6< c #CFCBC1",
+"7< c #E6E2D6",
+"8< c #EAE6DB",
+"9< c #DFDCD1",
+"0< c #D3CFC5",
+"a< c #C7C4BB",
+"b< c #E5E1D6",
+"c< c #B5B2A9",
+"d< c #85837E",
+"e< c #7B7A79",
+"f< c #84837F",
+"g< c #656463",
+"h< c #7C7C7D",
+"i< c #555554",
+"j< c #565653",
+"k< c #4D4D4B",
+"l< c #535250",
+"m< c #64635F",
+"n< c #6F6E68",
+"o< c #C9C5B8",
+"p< c #FEFBEE",
+"q< c #A6A49B",
+"r< c #D6D0C5",
+"s< c #E0DACD",
+"t< c #72716C",
+"u< c #B3AFA7",
+"v< c #C9C6BC",
+"w< c #C8C4BB",
+"x< c #E2DED4",
+"y< c #E0DCD2",
+"z< c #C2C0B7",
+"A< c #BDBAB2",
+"B< c #D4D0C5",
+"C< c #757371",
+"D< c #82827E",
+"E< c #797873",
+"F< c #7E7D79",
+"G< c #7A7A78",
+"H< c #636464",
+"I< c #8B8B8C",
+"J< c #3E3F3F",
+"K< c #434343",
+"L< c #535352",
+"M< c #555553",
+"N< c #51504E",
+"O< c #4A4A48",
+"P< c #585654",
+"Q< c #73706B",
+"R< c #929088",
+"S< c #F5F0E1",
+"T< c #FAF7E8",
+"U< c #CBC8BC",
+"V< c #B6B2AB",
+"W< c #AAA8A1",
+"X< c #B8B5AD",
+"Y< c #C7C4BC",
+"Z< c #CCC9C1",
+"`< c #D4D1C8",
+" [ c #DBD8CF",
+".[ c #DFDAD1",
+"+[ c #D4D0C7",
+"@[ c #C3BFB7",
+"#[ c #E0DBD1",
+"$[ c #60615F",
+"%[ c #515251",
+"&[ c #585757",
+"*[ c #535251",
+"=[ c #4C4B4A",
+"-[ c #484746",
+";[ c #5C5B58",
+">[ c #BCB8AC",
+",[ c #B3AEA5",
+"'[ c #FEFAEB",
+")[ c #C8C5BC",
+"![ c #BBB8B0",
+"~[ c #CDCAC2",
+"{[ c #DDD9CF",
+"][ c #D2CEC5",
+"^[ c #C9C7BE",
+"/[ c #DBD7CE",
+"([ c #C3C0B8",
+"_[ c #E1DDD1",
+":[ c #9C9A93",
+"<[ c #6D6B68",
+"[[ c #5B5B5C",
+"}[ c #464646",
+"|[ c #535252",
+"1[ c #565655",
+"2[ c #4F4F4E",
+"3[ c #494846",
+"4[ c #484846",
+"5[ c #5B5A57",
+"6[ c #CAC6B9",
+"7[ c #FAF5E5",
+"8[ c #EEE9DC",
+"9[ c #B3B0A8",
+"0[ c #CECAC1",
+"a[ c #C6C3B9",
+"b[ c #C5C1B9",
+"c[ c #C6C3BB",
+"d[ c #D1CDC5",
+"e[ c #DAD7CD",
+"f[ c #D9D5CC",
+"g[ c #C6C4BC",
+"h[ c #B1AFA7",
+"i[ c #686968",
+"j[ c #6A6964",
+"k[ c #454545",
+"l[ c #545553",
+"m[ c #4C4C4B",
+"n[ c #444443",
+"o[ c #494947",
+"p[ c #64635E",
+"q[ c #B3B0A5",
+"r[ c #D5CFC4",
+"s[ c #F3EEDF",
+"t[ c #FFFCEC",
+"u[ c #FDFBEF",
+"v[ c #B4B1A9",
+"w[ c #C9C5BC",
+"x[ c #C5C2BA",
+"y[ c #C8C5BD",
+"z[ c #B6B4AD",
+"A[ c #C5C2BB",
+"B[ c #C3C0B9",
+"C[ c #C1BFB7",
+"D[ c #C5C3BC",
+"E[ c #6A6867",
+"F[ c #696966",
+"G[ c #686966",
+"H[ c #797776",
+"I[ c #525252",
+"J[ c #3A3B3B",
+"K[ c #4E4D4D",
+"L[ c #525150",
+"M[ c #4A4948",
+"N[ c #424240",
+"O[ c #4B4B49",
+"P[ c #676561",
+"Q[ c #F9F6E9",
+"R[ c #E1DBCF",
+"S[ c #A5A29C",
+"T[ c #B3B0A9",
+"U[ c #BFBCB5",
+"V[ c #C0BDB6",
+"W[ c #B5B2AC",
+"X[ c #B0AEA9",
+"Y[ c #CAC7C0",
+"Z[ c #94928E",
+"`[ c #6D6D6E",
+" } c #3D3D3D",
+".} c #4A4A4A",
+"+} c #50504F",
+"@} c #454443",
+"#} c #434241",
+"$} c #5D5C58",
+"%} c #6D6A65",
+"&} c #DDD8CA",
+"*} c #E4DED1",
+"=} c #F7F1E3",
+"-} c #82817B",
+";} c #83817C",
+">} c #8A8883",
+",} c #989690",
+"'} c #9E9B96",
+")} c #A4A29D",
+"!} c #B1AEA9",
+"~} c #BCBAB3",
+"{} c #BFBDB6",
+"]} c #B9B7B1",
+"^} c #B1AFAB",
+"/} c #BCB9B3",
+"(} c #B7B6B0",
+"_} c #B8B6AF",
+":} c #B9B6B0",
+"<} c #716F6D",
+"[} c #5F5F60",
+"}} c #373838",
+"|} c #4F4F4F",
+"1} c #4E4E4D",
+"2} c #403F3E",
+"3} c #444342",
+"4} c #4C4B49",
+"5} c #61615D",
+"6} c #DDD9CC",
+"7} c #FDF7E8",
+"8} c #F8F2E3",
+"9} c #97948F",
+"0} c #A09E99",
+"a} c #9F9D98",
+"b} c #A3A09B",
+"c} c #AAA8A2",
+"d} c #AEACA7",
+"e} c #B1AFAA",
+"f} c #B3B1AC",
+"g} c #ADACA7",
+"h} c #B2B0AB",
+"i} c #AAA9A4",
+"j} c #C5C3BB",
+"k} c #898884",
+"l} c #7F7E79",
+"m} c #4D4C4D",
+"n} c #464645",
+"o} c #4E4E4E",
+"p} c #4A4A49",
+"q} c #3E3D3C",
+"r} c #444442",
+"s} c #52514F",
+"t} c #5B5A56",
+"u} c #62615C",
+"v} c #D9D3C7",
+"w} c #DFDACE",
+"x} c #EDE9DC",
+"y} c #908F89",
+"z} c #9B9995",
+"A} c #A3A19C",
+"B} c #A19F99",
+"C} c #ADABA6",
+"D} c #ACA9A4",
+"E} c #737271",
+"F} c #707171",
+"G} c #515052",
+"H} c #444545",
+"I} c #4D4D4C",
+"J} c #474746",
+"K} c #3F3F3E",
+"L} c #494946",
+"M} c #53524F",
+"N} c #E2DCCF",
+"O} c #ECE7DA",
+"P} c #F8F5E6",
+"Q} c #FEFDF3",
+"R} c #F3EFE1",
+"S} c #E0DBCF",
+"T} c #F9F7EC",
+"U} c #EEEBDD",
+"V} c #817F7B",
+"W} c #8D8B87",
+"X} c #989692",
+"Y} c #9A9894",
+"Z} c #999893",
+"`} c #9A9893",
+" | c #A9A8A4",
+".| c #A8A6A2",
+"+| c #A1A09C",
+"@| c #A4A39E",
+"#| c #707172",
+"$| c #4C4C4C",
+"%| c #434342",
+"&| c #3C3C3B",
+"*| c #474744",
+"=| c #7B7A73",
+"-| c #FBF5E7",
+";| c #FAF4E7",
+">| c #F4EEE1",
+",| c #F6F4E8",
+"'| c #CEC9BF",
+")| c #9E9C94",
+"!| c #F3F0E4",
+"~| c #FFFEF6",
+"{| c #FAF8ED",
+"]| c #72726F",
+"^| c #92918D",
+"/| c #92918E",
+"(| c #93918E",
+"_| c #979693",
+":| c #A4A29E",
+"<| c #9D9C98",
+"[| c #999795",
+"}| c #9A9997",
+"|| c #4B4A4A",
+"1| c #3E3E3D",
+"2| c #4B4A47",
+"3| c #5B5855",
+"4| c #DED8CC",
+"5| c #FDF8EA",
+"6| c #F3EDE0",
+"7| c #EBE5D9",
+"8| c #F5F1E3",
+"9| c #71716E",
+"0| c #7D7D7B",
+"a| c #8C8B88",
+"b| c #91908D",
+"c| c #918F8C",
+"d| c #949390",
+"e| c #999896",
+"f| c #989794",
+"g| c #A09F9B",
+"h| c #9F9E9B",
+"i| c #979593",
+"j| c #696767",
+"k| c #3B3B3B",
+"l| c #4B4B4A",
+"m| c #3B3B3A",
+"n| c #504E4C",
+"o| c #615F5B",
+"p| c #E5E1D3",
+"q| c #DFDBCE",
+"r| c #FBF5E6",
+"s| c #D2CEC3",
+"t| c #C7C3B9",
+"u| c #DFDACC",
+"v| c #878683",
+"w| c #8F8E8B",
+"x| c #8E8D8B",
+"y| c #8E8E8C",
+"z| c #91908E",
+"A| c #9C9B98",
+"B| c #93928F",
+"C| c #878784",
+"D| c #6E6E6F",
+"E| c #484847",
+"F| c #3D3C3B",
+"G| c #575652",
+"H| c #FFFEF8",
+"I| c #FBF6E9",
+"J| c #FCF7EA",
+"K| c #F3EEE1",
+"L| c #939290",
+"M| c #92918F",
+"N| c #969593",
+"O| c #999895",
+"P| c #8C8B8A",
+"Q| c #9A9996",
+"R| c #767676",
+"S| c #424241",
+"T| c #3D3D3C",
+"U| c #40403E",
+"V| c #FEFAEC",
+"W| c #FEFEEF",
+"X| c #FEFEF2",
+"Y| c #E4DFD4",
+"Z| c #F1EBDF",
+"`| c #E5E0D5",
+" 1 c #BAB7AD",
+".1 c #CDC8BE",
+"+1 c #C6C3B8",
+"@1 c #B8B5AB",
+"#1 c #B4AFA7",
+"$1 c #81807E",
+"%1 c #92928F",
+"&1 c #908F8D",
+"*1 c #8F8F8D",
+"=1 c #898886",
+"-1 c #8F8E8D",
+";1 c #7A7A7B",
+">1 c #383837",
+",1 c #3A3A39",
+"'1 c #424140",
+")1 c #575552",
+"!1 c #D4CFC4",
+"~1 c #E7E2D6",
+"{1 c #FEFEEE",
+"]1 c #FEFFF4",
+"^1 c #FFFFEF",
+"/1 c #FDFCF1",
+"(1 c #FAF7E9",
+"_1 c #E8E4D9",
+":1 c #ECE7DC",
+"<1 c #DEDAD0",
+"[1 c #E0DCD0",
+"}1 c #B9B6AD",
+"|1 c #CAC5BB",
+"11 c #9C9992",
+"21 c #81807B",
+"31 c #70706D",
+"41 c #7E7D7B",
+"51 c #888886",
+"61 c #8D8C8A",
+"71 c #8A8988",
+"81 c #888786",
+"91 c #868583",
+"01 c #313131",
+"a1 c #3A3939",
+"b1 c #4A4947",
+"c1 c #61605C",
+"d1 c #B6B1A8",
+"e1 c #D1CBC0",
+"f1 c #F2EDE0",
+"g1 c #EFEADE",
+"h1 c #F4EEE3",
+"i1 c #E9E5DA",
+"j1 c #E6E1D6",
+"k1 c #DDD9CE",
+"l1 c #C4C1B7",
+"m1 c #7E7D7C",
+"n1 c #878684",
+"o1 c #8B8A88",
+"p1 c #8B8B89",
+"q1 c #8B8A89",
+"r1 c #868584",
+"s1 c #888887",
+"t1 c #2E2E2E",
+"u1 c #7C7B74",
+"v1 c #E2DCD0",
+"w1 c #F2ECDF",
+"x1 c #F8F4E8",
+"y1 c #F1ECDF",
+"z1 c #E2DED3",
+"A1 c #EAE4D9",
+"B1 c #CECAC0",
+"C1 c #C6C3BA",
+"D1 c #DDD9CD",
+"E1 c #C1BEB4",
+"F1 c #FAF5E6",
+"G1 c #B0AEA6",
+"H1 c #A19E99",
+"I1 c #908F8A",
+"J1 c #777573",
+"K1 c #747271",
+"L1 c #727271",
+"M1 c #7E7E7C",
+"N1 c #8C8C8A",
+"O1 c #888787",
+"P1 c #838282",
+"Q1 c #444341",
+"R1 c #65635F",
+"S1 c #F8F2E5",
+"T1 c #FFFAED",
+"U1 c #E9E4D9",
+"V1 c #DBD7CC",
+"W1 c #EDE8DD",
+"X1 c #D1CDC3",
+"Y1 c #E3DED2",
+"Z1 c #D9D5C8",
+"`1 c #FEFEF3",
+" 2 c #D8D4C9",
+".2 c #9C9994",
+"+2 c #868684",
+"@2 c #8D8C8B",
+"#2 c #8A8A89",
+"$2 c #858584",
+"%2 c #868685",
+"&2 c #4D4C4A",
+"*2 c #71706B",
+"=2 c #FAF7EA",
+"-2 c #F7F2E5",
+";2 c #E2DDD2",
+">2 c #CCC8BF",
+",2 c #E1DDD2",
+"'2 c #DBD7CB",
+")2 c #DCD8CC",
+"!2 c #FDFCEE",
+"~2 c #FFFDF2",
+"{2 c #F3EFE3",
+"]2 c #D9D5CB",
+"^2 c #B4B1A8",
+"/2 c #9F9C96",
+"(2 c #81807C",
+"_2 c #7F7E7D",
+":2 c #8A8A88",
+"<2 c #898887",
+"[2 c #7C7B7B",
+"}2 c #7E7E7F",
+"|2 c #696766",
+"12 c #444647",
+"22 c #6B6B6D",
+"32 c #61615F",
+"42 c #5A5955",
+"52 c #C7C2B8",
+"62 c #E1DDD0",
+"72 c #FEFCF0",
+"82 c #FFFEF7",
+"92 c #F8F4E7",
+"02 c #E9E5D8",
+"a2 c #D4D0C6",
+"b2 c #BCB9B0",
+"c2 c #DAD5CA",
+"d2 c #E3DED3",
+"e2 c #EEE9DE",
+"f2 c #DFDBCF",
+"g2 c #E0DBD0",
+"h2 c #E2DED1",
+"i2 c #F7F2E4",
+"j2 c #C2BFB5",
+"k2 c #B1AEA7",
+"l2 c #9A9892",
+"m2 c #878580",
+"n2 c #8C8B87",
+"o2 c #7C7C7A",
+"p2 c #878786",
+"q2 c #848483",
+"r2 c #7F7F80",
+"s2 c #797878",
+"t2 c #838383",
+"u2 c #62615D",
+"v2 c #D3CFC4",
+"w2 c #FFFAEB",
+"x2 c #E7E3D7",
+"y2 c #DFDACF",
+"z2 c #A7A49E",
+"A2 c #DBD7CD",
+"B2 c #E0DCD1",
+"C2 c #D8D3CA",
+"D2 c #DFDBD0",
+"E2 c #F3EDE1",
+"F2 c #DDD8CD",
+"G2 c #F0EBDE",
+"H2 c #C1BEB6",
+"I2 c #9B9993",
+"J2 c #979692",
+"K2 c #908E8B",
+"L2 c #838280",
+"M2 c #878785",
+"N2 c #7D7C7C",
+"O2 c #808080",
+"P2 c #7B7B7B",
+"Q2 c #565758",
+"R2 c #A7A7A6",
+"S2 c #52504D",
+"T2 c #EAE5D9",
+"U2 c #A9A69F",
+"V2 c #DAD6CB",
+"W2 c #ECE7DB",
+"X2 c #E8E4D7",
+"Y2 c #E5E0D4",
+"Z2 c #BAB7AE",
+"`2 c #DCD8CB",
+" 3 c #CDC9BF",
+".3 c #F4EFE2",
+"+3 c #F6F2E5",
+"@3 c #D7D3C9",
+"#3 c #ABA9A1",
+"$3 c #918E89",
+"%3 c #92908B",
+"&3 c #9E9C97",
+"*3 c #A19F9A",
+"=3 c #9E9C98",
+"-3 c #908F8C",
+";3 c #80807F",
+">3 c #7F7F7E",
+",3 c #727272",
+"'3 c #777879",
+")3 c #3A3B3C",
+"!3 c #898681",
+"~3 c #AEABA3",
+"{3 c #BBB8AE",
+"]3 c #F8F3E6",
+"^3 c #F6F2E4",
+"/3 c #ADAAA2",
+"(3 c #D8D3C9",
+"_3 c #C3BEB6",
+":3 c #DEDACF",
+"<3 c #CBC7BF",
+"[3 c #E7E4D7",
+"}3 c #F7F1E5",
+"|3 c #B6B3AA",
+"13 c #CBC8BD",
+"23 c #F3EFE2",
+"33 c #EEE9DD",
+"43 c #C4C0B7",
+"53 c #A8A69E",
+"63 c #9B9892",
+"73 c #9C9993",
+"83 c #9F9D97",
+"93 c #A5A39D",
+"03 c #A9A7A2",
+"a3 c #A2A09C",
+"b3 c #949391",
+"c3 c #898988",
+"d3 c #7E7E7E",
+"e3 c #767778",
+"f3 c #666767",
+"g3 c #5B5C5A",
+"h3 c #353537",
+"i3 c #555557",
+"j3 c #696764",
+"k3 c #EDE8DC",
+"l3 c #FDF7EA",
+"m3 c #FEFEF5",
+"n3 c #FBF7EA",
+"o3 c #E8E2D6",
+"p3 c #E9E3D7",
+"q3 c #C1BDB4",
+"r3 c #BBB9B0",
+"s3 c #A09D97",
+"t3 c #B7B5AD",
+"u3 c #E1DCD1",
+"v3 c #B7B4AD",
+"w3 c #E4DFD5",
+"x3 c #E4E0D4",
+"y3 c #F1ECE0",
+"z3 c #F0ECE0",
+"A3 c #CAC6BE",
+"B3 c #C9C5BB",
+"C3 c #A8A59E",
+"D3 c #F7F3E5",
+"E3 c #FBF8EA",
+"F3 c #E6E2D4",
+"G3 c #BDB9B1",
+"H3 c #B0ADA6",
+"I3 c #ABA9A4",
+"J3 c #A6A4A0",
+"K3 c #9F9E9A",
+"L3 c #9A9995",
+"M3 c #828282",
+"N3 c #7B7B7A",
+"O3 c #818180",
+"P3 c #787777",
+"Q3 c #6D6E71",
+"R3 c #626263",
+"S3 c #707072",
+"T3 c #B2AFA6",
+"U3 c #CBC6BC",
+"V3 c #EEEADD",
+"W3 c #FCF8EB",
+"X3 c #FEFCF1",
+"Y3 c #F7F4E8",
+"Z3 c #D9D4C9",
+"`3 c #A6A29B",
+" 4 c #B5B2AA",
+".4 c #DAD5CB",
+"+4 c #ACA9A2",
+"@4 c #C2BFB7",
+"#4 c #E7E2D8",
+"$4 c #EBE6DB",
+"%4 c #DCD9CF",
+"&4 c #A5A39C",
+"*4 c #DBD6CC",
+"=4 c #CFCCC1",
+"-4 c #C5C1B8",
+";4 c #D3CEC4",
+">4 c #F4EFE3",
+",4 c #DAD6CA",
+"'4 c #B8B4AC",
+")4 c #BBB9B1",
+"!4 c #C0BEB6",
+"~4 c #B8B6B0",
+"{4 c #ABAAA5",
+"]4 c #A2A19C",
+"^4 c #90908E",
+"/4 c #878685",
+"(4 c #787776",
+"_4 c #787979",
+":4 c #66676A",
+"<4 c #636466",
+"[4 c #7E7C78",
+"}4 c #D5D1C7",
+"|4 c #DCD7CC",
+"14 c #DFDAD0",
+"24 c #ECE8DC",
+"34 c #FFFAEC",
+"44 c #FCF6E9",
+"54 c #F9F4E7",
+"64 c #C8C5BB",
+"74 c #C7C2BA",
+"84 c #ACAAA3",
+"94 c #D6D2C7",
+"04 c #A3A099",
+"a4 c #A8A69F",
+"b4 c #E1DDD3",
+"c4 c #DCD7CE",
+"d4 c #E4E1D5",
+"e4 c #C4C1B8",
+"f4 c #A7A49F",
+"g4 c #CFCBC2",
+"h4 c #9B9992",
+"i4 c #A7A59D",
+"j4 c #B1AEA6",
+"k4 c #BEBBB2",
+"l4 c #ADAAA3",
+"m4 c #CBC8BF",
+"n4 c #E6E2D8",
+"o4 c #E3DFD5",
+"p4 c #EFEBDF",
+"q4 c #F2EDE1",
+"r4 c #FFFBEE",
+"s4 c #FEF8EB",
+"t4 c #CCC9BE",
+"u4 c #BCB9B1",
+"v4 c #C4C1B9",
+"w4 c #C1BEB8",
+"x4 c #B4B2AD",
+"y4 c #AFADA8",
+"z4 c #A19F9C",
+"A4 c #979694",
+"B4 c #959492",
+"C4 c #7C7B7A",
+"D4 c #727273",
+"E4 c #6B6C6D",
+"F4 c #5B5C5E",
+"G4 c #555659",
+"H4 c #5E5D5D",
+"I4 c #606160",
+"J4 c #6A6B6D",
+"K4 c #646462",
+"L4 c #7A7A74",
+"M4 c #A8A59D",
+"N4 c #D0CCC2",
+"O4 c #DDD8CE",
+"P4 c #E8E4D8",
+"Q4 c #EBE6DA",
+"R4 c #F3EEE2",
+"S4 c #FDF8EB",
+"T4 c #9C9A94",
+"U4 c #989590",
+"V4 c #E4E0D5",
+"W4 c #BCB8B1",
+"X4 c #ABA8A2",
+"Y4 c #CCC8BE",
+"Z4 c #CBC8BE",
+"`4 c #9D9B94",
+" 5 c #918E8A",
+".5 c #A4A29C",
+"+5 c #E6E1D7",
+"@5 c #E7E3D9",
+"#5 c #E9E5D9",
+"$5 c #F9F4E8",
+"%5 c #BAB7B1",
+"&5 c #A9A7A3",
+"*5 c #ACAAA5",
+"=5 c #A3A19E",
+"-5 c #696A6D",
+";5 c #505153",
+">5 c #505155",
+",5 c #95938C",
+"'5 c #A29F98",
+")5 c #B6B3AB",
+"!5 c #C7C5BC",
+"~5 c #C6C2B9",
+"{5 c #DCD8CE",
+"]5 c #E1DED2",
+"^5 c #F7F2E6",
+"/5 c #F8F3E7",
+"(5 c #E5E1D5",
+"_5 c #B8B5AC",
+":5 c #D3D0C5",
+"<5 c #A19E98",
+"[5 c #BEBAB3",
+"}5 c #DBD8CD",
+"|5 c #D8D5CB",
+"15 c #C5C2B9",
+"25 c #D7D4CA",
+"35 c #ACA9A3",
+"45 c #BAB7AF",
+"55 c #C9C6BD",
+"65 c #B5B2AB",
+"75 c #C9C5BD",
+"85 c #81807D",
+"95 c #908E8A",
+"05 c #DFDBD2",
+"a5 c #E0DBD2",
+"b5 c #E3DED4",
+"c5 c #F4F0E3",
+"d5 c #BFBDB7",
+"e5 c #ABA9A5",
+"f5 c #7B7A7A",
+"g5 c #717170",
+"h5 c #79797A",
+"i5 c #6A6B6E",
+"j5 c #575657",
+"k5 c #3F3F42",
+"l5 c #5D5E5F",
+"m5 c #A6A39C",
+"n5 c #ACA9A1",
+"o5 c #C2BFB6",
+"p5 c #CAC6BD",
+"q5 c #B9B6AE",
+"r5 c #C4C0B8",
+"s5 c #D1CDC4",
+"t5 c #D6D2C8",
+"u5 c #D8D4CB",
+"v5 c #D9D4CA",
+"w5 c #9A9791",
+"x5 c #999690",
+"y5 c #DAD6CC",
+"z5 c #A5A29D",
+"A5 c #C0BDB5",
+"B5 c #C8C4BC",
+"C5 c #D0CDC3",
+"D5 c #E6E2D7",
+"E5 c #CFCCC3",
+"F5 c #D3D0C6",
+"G5 c #B7B3AC",
+"H5 c #8D8C88",
+"I5 c #A7A59E",
+"J5 c #D6D2C9",
+"K5 c #989791",
+"L5 c #D5D1C9",
+"M5 c #9D9A95",
+"N5 c #D0CDC4",
+"O5 c #8C8B86",
+"P5 c #DFDCD2",
+"Q5 c #CDC9C1",
+"R5 c #D2CFC7",
+"S5 c #D7D3CA",
+"T5 c #D7D2C9",
+"U5 c #D4D1C6",
+"V5 c #C9C6BE",
+"W5 c #B3B1AB",
+"X5 c #B4B2AC",
+"Y5 c #747473",
+"Z5 c #656566",
+"`5 c #6B6C6F",
+" 6 c #616061",
+".6 c #56575A",
+"+6 c #515255",
+"@6 c #4B4C4D",
+"#6 c #5D5E60",
+"$6 c #4F4E4C",
+"%6 c #827F7B",
+"&6 c #888681",
+"*6 c #95928C",
+"=6 c #CFCCC2",
+"-6 c #CDCAC1",
+";6 c #D1CEC4",
+">6 c #EDE9DE",
+",6 c #E0DDD2",
+"'6 c #EAE6DA",
+")6 c #D5D2C7",
+"!6 c #A6A49D",
+"~6 c #D5D1C8",
+"{6 c #B2AFA8",
+"]6 c #A2A09A",
+"^6 c #D7D2CA",
+"/6 c #DFDBD1",
+"(6 c #DCD8CF",
+"_6 c #ADAAA4",
+":6 c #D2CFC6",
+"<6 c #C7C3BB",
+"[6 c #D7D4CB",
+"}6 c #A8A6A0",
+"|6 c #8B8A86",
+"16 c #827F7D",
+"26 c #D2CDC5",
+"36 c #ABA9A2",
+"46 c #CECBC2",
+"56 c #95938E",
+"66 c #CFCCC4",
+"76 c #C8C4BD",
+"86 c #B5B3AD",
+"96 c #BAB8B2",
+"06 c #CAC7BF",
+"a6 c #C4C0B9",
+"b6 c #C3C1BA",
+"c6 c #C0BEB7",
+"d6 c #B9B6B1",
+"e6 c #B6B4AE",
+"f6 c #92908E",
+"g6 c #848381",
+"h6 c #828180",
+"i6 c #6D6D6D",
+"j6 c #68696C",
+"k6 c #606163",
+"l6 c #626364",
+"m6 c #A9A6A0",
+"n6 c #BBB7AF",
+"o6 c #EAE5DB",
+"p6 c #9F9C97",
+"q6 c #DAD6CD",
+"r6 c #A29F9A",
+"s6 c #9E9B95",
+"t6 c #DCD7CD",
+"u6 c #DEDAD1",
+"v6 c #BEBAB4",
+"w6 c #B1AEA8",
+"x6 c #BBB8B2",
+"y6 c #B7B4AE",
+"z6 c #C6C2BB",
+"A6 c #B5B3AC",
+"B6 c #7E7C79",
+"C6 c #999894",
+"D6 c #B7B5AF",
+"E6 c #C3BFB9",
+"F6 c #C6C3BC",
+"G6 c #BEBCB5",
+"H6 c #B4B2AE",
+"I6 c #C2BFB9",
+"J6 c #828281",
+"K6 c #606161",
+"L6 c #595A5C",
+"M6 c #55565B",
+"N6 c #525354",
+"O6 c #5D5D5E",
+"P6 c #7C7C77",
+"Q6 c #A3A09A",
+"R6 c #B9B6AF",
+"S6 c #D1CEC5",
+"T6 c #D4D0C8",
+"U6 c #CBC7BE",
+"V6 c #D3CFC6",
+"W6 c #D0CCC4",
+"X6 c #8A8984",
+"Y6 c #AFADA6",
+"Z6 c #7F7D7A",
+"`6 c #DAD5CD",
+" 7 c #A6A39D",
+".7 c #888782",
+"+7 c #D5D2C9",
+"@7 c #B2B0A8",
+"#7 c #A6A49E",
+"$7 c #C7C5BE",
+"%7 c #93918C",
+"&7 c #D0CDC5",
+"*7 c #D2CEC6",
+"=7 c #84837E",
+"-7 c #9C9A97",
+";7 c #A5A39F",
+">7 c #A8A6A1",
+",7 c #C5C2BC",
+"'7 c #BEBBB5",
+")7 c #BAB8B3",
+"!7 c #BAB7B2",
+"~7 c #C2C0BA",
+"{7 c #787879",
+"]7 c #5A5B5E",
+"^7 c #55575A",
+"/7 c #4E4F52",
+"(7 c #47494A",
+"_7 c #404043",
+":7 c #7F8081",
+"<7 c #7E7D78",
+"[7 c #A09E98",
+"}7 c #DDD8CF",
+"|7 c #878582",
+"17 c #9A9792",
+"27 c #B4B1AA",
+"37 c #C5C1BA",
+"47 c #D1CDC6",
+"57 c #ACAAA4",
+"67 c #BAB7B0",
+"77 c #C1BEB7",
+"87 c #A9A7A0",
+"97 c #C4C2BA",
+"07 c #9F9E98",
+"a7 c #9D9B96",
+"b7 c #93928E",
+"c7 c #969591",
+"d7 c #9B9A97",
+"e7 c #8D8C89",
+"f7 c #A3A19D",
+"g7 c #BAB8B1",
+"h7 c #BBB9B3",
+"i7 c #B7B5B0",
+"j7 c #B2B1AB",
+"k7 c #969490",
+"l7 c #858582",
+"m7 c #646363",
+"n7 c #69696B",
+"o7 c #656568",
+"p7 c #545457",
+"q7 c #545559",
+"r7 c #4E4E4C",
+"s7 c #9B9994",
+"t7 c #9E9C96",
+"u7 c #A4A19C",
+"v7 c #B1AFA9",
+"w7 c #CEC9C0",
+"x7 c #DAD5CC",
+"y7 c #96948F",
+"z7 c #AAA8A3",
+"A7 c #918F8B",
+"B7 c #CFCDC4",
+"C7 c #9F9E99",
+"D7 c #AFADA7",
+"E7 c #B8B4AE",
+"F7 c #B2AFA9",
+"G7 c #96938F",
+"H7 c #D3D0C7",
+"I7 c #92908C",
+"J7 c #A3A29F",
+"K7 c #A4A39F",
+"L7 c #8A8986",
+"M7 c #9F9D9A",
+"N7 c #969592",
+"O7 c #989693",
+"P7 c #A09E9B",
+"Q7 c #9A9A97",
+"R7 c #91908F",
+"S7 c #848481",
+"T7 c #82817F",
+"U7 c #706F70",
+"V7 c #5F5F61",
+"W7 c #656669",
+"X7 c #4E5052",
+"Y7 c #525355",
+"Z7 c #545352",
+"`7 c #7B7875",
+" 8 c #7A7A76",
+".8 c #868480",
+"+8 c #9C9A95",
+"@8 c #ABA9A3",
+"#8 c #B3B1AA",
+"$8 c #BFBCB4",
+"%8 c #D9D6CD",
+"&8 c #CDCAC3",
+"*8 c #BEBBB4",
+"=8 c #888884",
+"-8 c #CCC9C2",
+";8 c #83837F",
+">8 c #C3C1B9",
+",8 c #BFBDB5",
+"'8 c #C3BFB8",
+")8 c #95938F",
+"!8 c #8E8E8A",
+"~8 c #A3A29E",
+"{8 c #8C8C89",
+"]8 c #81817F",
+"^8 c #818080",
+"/8 c #848484",
+"(8 c #7D7D7D",
+"_8 c #5F5F5D",
+":8 c #5D5F62",
+"<8 c #535457",
+"[8 c #5B5C5D",
+"}8 c #878681",
+"|8 c #9B9893",
+"18 c #9D9B95",
+"28 c #AAA7A1",
+"38 c #B0AEA7",
+"48 c #A9A7A1",
+"58 c #CAC6BF",
+"68 c #D1CEC6",
+"78 c #9A9993",
+"88 c #94938F",
+"98 c #CBC8C0",
+"08 c #B2AFAA",
+"a8 c #C7C4BD",
+"b8 c #B2B0A9",
+"c8 c #CCC8C1",
+"d8 c #C9C6BF",
+"e8 c #C8C5BE",
+"f8 c #8E8D89",
+"g8 c #B3B2AC",
+"h8 c #9C9B97",
+"i8 c #8B8A87",
+"j8 c #8A8987",
+"k8 c #81807F",
+"l8 c #747475",
+"m8 c #757677",
+"n8 c #78797B",
+"o8 c #797A7C",
+"p8 c #78797A",
+"q8 c #7A7B7C",
+"r8 c #797A7B",
+"s8 c #6C6C6E",
+"t8 c #5C5D61",
+"u8 c #595859",
+"v8 c #93908C",
+"w8 c #A7A59F",
+"x8 c #B7B3AD",
+"y8 c #BFBCB6",
+"z8 c #9D9B97",
+"A8 c #C7C3BC",
+"B8 c #959490",
+"C8 c #A6A49F",
+"D8 c #A9A6A2",
+"E8 c #92908D",
+"F8 c #8E8C8A",
+"G8 c #959491",
+"H8 c #7A7A7A",
+"I8 c #757676",
+"J8 c #737374",
+"K8 c #737476",
+"L8 c #747577",
+"M8 c #767779",
+"N8 c #77787A",
+"O8 c #78787B",
+"P8 c #616263",
+"Q8 c #5B5C5F",
+"R8 c #515155",
+"S8 c #4C4D50",
+"T8 c #797977",
+"U8 c #999793",
+"V8 c #ADABA5",
+"W8 c #8F8E8A",
+"X8 c #B4B1AC",
+"Y8 c #AEABA5",
+"Z8 c #A2A09D",
+"`8 c #9E9D99",
+" 9 c #B7B4AF",
+".9 c #A1A09D",
+"+9 c #848482",
+"@9 c #6B6B6B",
+"#9 c #727374",
+"$9 c #757577",
+"%9 c #717174",
+"&9 c #68696D",
+"*9 c #6B6C70",
+"=9 c #6D6E72",
+"-9 c #707175",
+";9 c #717275",
+">9 c #6F7073",
+",9 c #67696D",
+"'9 c #5B5D5F",
+")9 c #525254",
+"!9 c #4F5053",
+"~9 c #515256",
+"{9 c #4E4F51",
+"]9 c #5F6062",
+"^9 c #8F8D8A",
+"/9 c #969390",
+"(9 c #9B9A95",
+"_9 c #ACAAA6",
+":9 c #A7A5A1",
+"<9 c #888784",
+"[9 c #817F7D",
+"}9 c #898986",
+"|9 c #9F9D99",
+"19 c #A2A19D",
+"29 c #7F7E7C",
+"39 c #727172",
+"49 c #6C6C6D",
+"59 c #717274",
+"69 c #676869",
+"79 c #6A6C6E",
+"89 c #666769",
+"99 c #626468",
+"09 c #5E6064",
+"a9 c #5C5E62",
+"b9 c #5B5D62",
+"c9 c #5D5F63",
+"d9 c #595B5F",
+"e9 c #55565A",
+"f9 c #4C4D4F",
+"g9 c #47494C",
+"h9 c #565759",
+"i9 c #666667",
+"j9 c #898885",
+"k9 c #8B8986",
+"l9 c #9E9C99",
+"m9 c #AEACA8",
+"n9 c #7B7B79",
+"o9 c #A3A29D",
+"p9 c #8F8E8C",
+"q9 c #858482",
+"r9 c #7E7D7E",
+"s9 c #6F6F71",
+"t9 c #6B6B6C",
+"u9 c #737375",
+"v9 c #5E5E5F",
+"w9 c #5F6063",
+"x9 c #616266",
+"y9 c #5D5E62",
+"z9 c #606165",
+"A9 c #64656A",
+"B9 c #616367",
+"C9 c #5B5C61",
+"D9 c #595A5E",
+"E9 c #57595D",
+"F9 c #585A5E",
+"G9 c #56585C",
+"H9 c #4E5053",
+"I9 c #3B3B3E",
+"J9 c #666768",
+"K9 c #7D7C7A",
+"L9 c #7D7D7A",
+"M9 c #A19F9B",
+"N9 c #7E7E7D",
+"O9 c #7D7D7C",
+"P9 c #727474",
+"Q9 c #6E6E70",
+"R9 c #707174",
+"S9 c #6A6A6B",
+"T9 c #67676A",
+"U9 c #5E5D5E",
+"V9 c #68696B",
+"W9 c #616265",
+"X9 c #616162",
+"Y9 c #5F6163",
+"Z9 c #5A5B5D",
+"`9 c #626467",
+" 0 c #5B5B5D",
+".0 c #58595C",
+"+0 c #606266",
+"@0 c #5C5D62",
+"#0 c #525357",
+"$0 c #4E5054",
+"%0 c #646567",
+"&0 c #858483",
+"*0 c #898987",
+"=0 c #848383",
+"-0 c #7F7F7F",
+";0 c #5F5E5F",
+">0 c #5F6061",
+",0 c #58585A",
+"'0 c #5A5B5F",
+")0 c #58595B",
+"!0 c #535456",
+"~0 c #57585C",
+"{0 c #57585A",
+"]0 c #595B5D",
+"^0 c #545558",
+"/0 c #57595C",
+"(0 c #535458",
+"_0 c #46484B",
+":0 c #595A5B",
+"<0 c #666566",
+"[0 c #7A7978",
+"}0 c #808180",
+"|0 c #858484",
+"10 c #686665",
+"20 c #868585",
+"30 c #6E6E6E",
+"40 c #757678",
+"50 c #78787A",
+"60 c #717173",
+"70 c #6C6D6F",
+"80 c #5D5E61",
+"90 c #545658",
+"00 c #535558",
+"a0 c #4E4E51",
+"b0 c #4B4C50",
+"c0 c #515254",
+"d0 c #5E5F5F",
+"e0 c #666565",
+"f0 c #6C6B6C",
+"g0 c #787877",
+"h0 c #8C8B89",
+"i0 c #727171",
+"j0 c #6D6D70",
+"k0 c #707073",
+"l0 c #626365",
+"m0 c #636468",
+"n0 c #5C5C5F",
+"o0 c #636467",
+"p0 c #535355",
+"q0 c #525356",
+"r0 c #505255",
+"s0 c #515154",
+"t0 c #505053",
+"u0 c #4E4F53",
+"v0 c #838486",
+"w0 c #5B5A5B",
+"x0 c #5A5B5A",
+"y0 c #6E6D6E",
+"z0 c #717070",
+"A0 c #777776",
+"B0 c #6D6E70",
+"C0 c #646569",
+"D0 c #4D4E51",
+"E0 c #4C4E51",
+"F0 c #4E4E52",
+"G0 c #4D4E52",
+"H0 c #3C3E41",
+"I0 c #6E6F70",
+"J0 c #696969",
+"K0 c #696A6A",
+"L0 c #777778",
+"M0 c #79797B",
+"N0 c #7D7E7F",
+"O0 c #7B7A7C",
+"P0 c #646364",
+"Q0 c #626366",
+"R0 c #4C4D51",
+"S0 c #4F5054",
+"T0 c #494B4E",
+"U0 c #424243",
+"V0 c #535454",
+"W0 c #616364",
+"X0 c #646466",
+"Y0 c #646465",
+"Z0 c #626466",
+"`0 c #606064",
+" a c #5E5E61",
+".a c #606063",
+"+a c #707173",
+"@a c #737477",
+"#a c #67686A",
+"$a c #616264",
+"%a c #646568",
+"&a c #58595D",
+"*a c #545458",
+"=a c #444649",
+"-a c #3D3D41",
+";a c #5C5C5E",
+">a c #676769",
+",a c #6E6F72",
+"'a c #5C5D5D",
+")a c #494B4D",
+"!a c #434547",
+"~a c #414346",
+"{a c #545557",
+"]a c #5B5C60",
+"^a c #626367",
+"/a c #606164",
+"(a c #6E7073",
+"_a c #606062",
+":a c #5F6162",
+"<a c #5B5B5E",
+"[a c #5E5E60",
+"}a c #4D4E50",
+"|a c #57585D",
+"1a c #5A5C60",
+"2a c #5B5D61",
+"3a c #5A5C5F",
+"4a c #585A5D",
+"5a c #636469",
+"6a c #5E5F63",
+"7a c #37393B",
+"8a c #444447",
+"9a c #545659",
+"0a c #56575B",
+"aa c #4C4E50",
+"ba c #3C3C3F",
+"ca c #505256",
+"da c #5B5C62",
+"ea c #5D5E63",
+"fa c #58595E",
+"ga c #505156",
+"ha c #4F5155",
+"ia c #444448",
+"ja c #535659",
+"ka c #55575B",
+"la c #4D4D51",
+"ma c #414246",
+"na c #3F3F43",
+"oa c #3D3F41",
+"pa c #353738",
+"qa c #353538",
+"ra c #5A5B5C",
+"sa c #4F5154",
+"ta c #545459",
+"ua c #525458",
+"va c #535459",
+"wa c #4D5052",
+"xa c #494A4E",
+"ya c #39393C",
+"za c #363639",
+"Aa c #343437",
+"Ba c #2F3133",
+"Ca c #656667",
+"Da c #6B6C6E",
+"Ea c #424447",
+"Fa c #303234",
+"Ga c #575859",
+"Ha c #7B7B7D",
+"Ia c #5E5F61",
+"Ja c #555658",
+"Ka c #8D8E8F",
+"La c #37373A",
+"Ma c #747476",
+" . ",
+" + @ # $ ",
+" % & * = - ; ",
+" > , * * * ' - $ ",
+" + ) * = = = * = ! ~ ",
+" { * = * = = = = = - ] ",
+" ^ , / = = = = = = = * ' ( _ ",
+" : < * = * = = = = = = = * = ! [ ",
+" } * * = = = = = = = = = = * = - | ",
+" 1 2 3 = = = = = = = = = = = = = * ' 4 5 ",
+" 6 < * = * = = = = = = = = = = = = = * = 7 | ",
+" 8 * * = = = = = = = = = = = = = = = = * ' - [ ",
+" 9 8 0 = = = = = = = = = = = = = = = = = = = * = ! _ ",
+" a < * = * = = = = = = = = = = = = = = = = = = = * = 7 b ",
+" c d e e e e f * = = = = = = = = = = = = = g e e e e f h i ",
+" j k l m m m m n f = = = = = = = = = = = = o p q m m m m l r ",
+" [ e = = = = = = = = = = = = s t ",
+" u e = = = = = = = = = = = = s t ",
+" v u e = = = = = = = = = = = = s t w ",
+" ~ x u e = = = = = = = = = = = = s t y z ",
+" A B C u e = = = = = = = = = = = = s t D { ",
+" E F G H u e = = = = = = = = = = = = s t I J K L ",
+" M N = N H u e = = = = = = = = = = = = s t I O s P Q ",
+" R S ' = N H u e = = = = = = = = = = = = s t I O * T { U V W X Y Z ",
+" E N ' ` = N H u e = = = = = = = = = = = = s t I O ` = ...+. @.#.#.$.%.%.&.*.=.-.;.>.,.'. ",
+" ).!.= * = = N ). ~.e = = = = = = = = = = = = s t I O = ` {.s P Q ].^././././.(././././././.%._.:.<.[. ",
+" }.|.O * = = = 1.2.3.4.4.4.4.4.4.4.4.4.4.4.5.6.= = = = = = = = = = = = O 7.8.4.4.4.4.4.4.4.4.4.4.4.9.0.= = = ` * = a. ].^././././././././././.^./././.^.b._.c.d.e. ",
+" r f.= ` = = = * = * * * * * * * * * * * * * * = = = = = = = = = = = = = * = * * * * * * * * * * * * * = * = = = ` = * g.+. ].^./././././././././././././.h./././.^.i.i.j.k.l. ",
+" m.n.= * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ` * s g. ].^./././././././././././././././././././././.^.o.p.q. ",
+" r.s.O t.= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ` * * a.Q ].^././././././././././././././././././././.^././.^.u.v.w. ",
+" x.f.= ` * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ` = y.P z. ].^././././././././././././././././././././././.^././.^.A.B.C. ",
+" D.|.= * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ` * s E. ].^./././././././././././././././././././././././././.^././._.u ",
+" r n.O ` = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ` {. .@ z. ].^./././././././././././././././././././././././././././.^./.#.F.G. ",
+" m.N = = * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ` = T H. ].^./././././.^././././././././././././././././././././././.^./.^.%.I. ",
+" J.K.L.M.N.O.O.P.Q.R.S.T.U.V.W.* = * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * = X.Y. I.@.Z.`.v. +.+++@+&.%.#.^./././.^./././././././././././././././.^./.#.#+ ",
+" $+%+&+*+=+-+;+>+,+>+>+'+)+!+~+{+]+M.M.^+/+* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * ' 4 (+ _+:+E <+[+_.++/././.^./././././././././././././.^./.^.].}+ ",
+" |+1+2+3+'+;+,+4+5+6+4+;+7+4+,+;+>+3+=+8+{+N.9+0+a+b+= * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = c+d+ e+f+g+B.h+/.^.^././.(././././././././././.i+/.[+Q ",
+" j+k+l+4+m+,+;+n+;+4+5+o+p+q+7+r+5+6+;+>+>+3+!+s+N.N.t+u+v+* = * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * = w+Y. x+y+z+A+b.^././.^./././././././././.^.B+C+ ",
+" D+>+6+q+6+,+,+n+n+;+6+E+r+5+r+*+o+5+,+;+3+{+s+s+M.F+G+H+S.I+J+* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * ' ( K+ L+M+N+^./.^./././././././././.^.^.;. ",
+" O+P+s+Q+;+n+>+>+,+,+,+>+,+7+R+q+6+S+r+6+>+3+!+{+{+s+N.F+Q.T+R.U+V+W+X+b+= * = = = * = = = = = = = = = = = = = = = = = = = = = = = = = = = = * = = = = = = = = = = = = = = = * = = = = = = Y+Z+ v `+ @^.^./.^././././././././.#..@ ",
+" +@@@,+!+'+,+n+,+;+,+,+,+,+,+,+n+'+L.>+>+=+#@{+s+$@s+s+]+s+$@s+s+s+s+]+N.%@&@*@* = = = = = * F =@=@=@=@=@=@=@=@=@-@;@>@- * = = = = = = = = = = = = = ,@! >@>@>@>@>@>@>@>@>@>@>@! 1.= = = = * = w+d. '@)@&././././././././.^./.++!@ ",
+" ~@E+{@]@>+n+n+;+,+,+,+,+,+,+,+,+,+,+>+'+^@{+s+N.N.N.N.s+{+#@~+/@-+=+{+$@{+L.'+Q+(@_@* * = = = :@<@[@}@|@|@1@2@3@4@5@6@7@8@v.9@= = = = = = = = = = = = s 0@a@b@b@b@b@b@b@b@b@b@b@b@~ c@' = = * ' Y+d. d@e@^./.^./././././.^./.f@ ",
+" g@h@>+q+S+S+q+,+,+,+>+n+,+,+,+,+,+,+;+n+i@;+;+>+>+>+>+;+;+;+;+;+;+,+>+>+4+r+4+,+n+j@k@l@* = * = m@n@o@p@q@r@s@t@u@v@u@u@w@x@y@e = = = = = = = = = = = = s t I O = = = ( Z+ >.z@^./.^././././.^.A@B@ ",
+" &+,+>+C@,+,+,+7+E+&+o+S+D@;+>+>+,+,+,+;+,+;+i@>+'+'+-+m+m+'+'+;+,+,+,+n+K.,+S+o+5+6+>+n+;+E@F@` = = m@G@H@]+h@]+s+N.Q.I@J@K@L@M@N@O@= = = = = = = = = = = = s t I O * = ! P@ Q@Z.#./.^./././././.R@ ",
+" S@D@T@7+q+S+o+o+7+,+U@4+5+E+V@5+6+;+>+n+,+,+;+'+>+=+{+s+$@s+s+s+W@8+;+n+;+,+X@>+,+,+4+n+>+,+;+;+Y@Z@* = m@`@ #,+>+>+>+>+.#'+>+'+L.=++#@#= = = = = = = = = = = = s t I O ' ##Y. $#%./.^././././.%#&# ",
+" *#R+6+S+S+r+*+*+&+*+=#=#o+5+q+4+C@r+&+E+7+-#]@n+;+>+L.~+!+L.>+;+;+,+,+>+m+;+n+,+,+,+,+X@n+,+,+,+>+]@j@;#>#* m@,#'#)#!#*+~#E+E+E+*+{#=#S@]#e = = = = = = = = = = = = s t I O 7 d+ ^#/#(#^././.^.B+_# ",
+" :#,+7+r+o+&+*+S@S@S@=#<#<#S@*+*+*+o+S+6+7+S+R+C@,+>+n+]@,+6+q+7+7+7+S+o+=#&+6+,+,+,+,+,+,+,+,+n+>+;+4+7+[#}#Z@m@,#|#1#2#3#4#2#)#2#4#5#6#7#8#e = = = = = = = = = = = = s t c@( (+ 9#_.B+^./././.R@ ",
+" 0#L.S+E+o+*+S@=#<#a#2#3#3#3#b#<#b#S@*+o+*+*+*+7+6+7+c#C@;+>+>+7+S@)#b#d#2#=#o+S+6+4+n+,+,+,+,+,+n+;+6+r+*+=#=#e#f#g#h#'#)#1#*+*+*+S@4#i#j#k#l#m#e = = = = = = = = = = = = s t n#o# e+p#/.^././.q#r# ",
+" s#>+t#o+&+S@S@<#a#b#2#2#u#3#)#=#<#)#b#2#2#b#)#)#v#S@w#r+E+x#o+y#r+S+r+r+r+r+S+q+6+,+,+,+,+,+;+;+;+,+6+r+*+S@o+r+o+e#z#A#B#r+C#6+4+6+r+2#D#i#5#D#m#e = = = = = = = = = = = = s t k. E#u./.^./.F#G# ",
+" H#I#{@S+E+J#S@=#2#2#3#3#3#K#3#u#)#)#b#2#u#3#4#4#4#4#3#u#u#2#)#2#3#2#2#2#)#b#b#2#b#b#=#=#*+*+&+o+r+p+5+S+*+*+E+7+7+r+J#*+E+L#q+6+,+q+r+&+M#d#)#3#4#N#8#e = = = = = = = = = = = = s t O#h+/.^.^.P# ",
+" Q#6+t#V@S@<#b#b#a#b#3#R#u#3#4#3#R#S#R#4#T#U#V#D#W#W#D#4#U#U#4#4#D#W#W#X#D#N#7#Y#)#S@o+r+r+o+&+=#=#)#)#)#)#=#&+5+4+,+7+S+q+4+4+;+,+6+Z#1#M#*+*+)#2#2#u#8#e = = = = = = = = = = = = s t `#F#/.^. $ ",
+" .$2++$&+S@b#2#b#2#3#3#R#3#R#4#4#4#4#4#N#N#l+W#@$X#X##$W#$$N#N#N#U#%$W#X#&$&$X#X#@$W#D#4#2#<#*+r+7+6+,+4+4+4+7+q+,+;+>+'+-+;+;+>+,+q+E+*+*$=$-$;$>$>$,$>$'$e = = = = = = = = = = = = s )$ !$^.^. $ ",
+" ~$S+&+S@<#<#b#u#2#3#R#4#U#U#N#D#D#D#l+D#{$W#]$&$j#j#j#j#X#D#N#$$U#N#$$W#X#&$X#W#X#X#W#N#N#4#Y#b#{#*+S@E+C#4+,+,+;+;+,+6+5+5+6+4+;+4+5+*+[#o+^$/$($_$_$_$_$:$b+= = = = = = = = = = = = = <$[$}$|$|$|$}$1$ 2$++^. $ ",
+" t#3$<#b#b#b#<#b#2#Y#4#U#U#D#D#$$W#W#X#X#&$j#4$4$5$4$4$6$j#X#D#N#U#%$$$i#W#W#X#&$&$X#X#W#N#U#R#7$8$9$=#S@S@=#)#)#=#*+*+S@)#)#1#r+6+,+q+0$r+S+o+a$b$<$= = = = = = = = = = = = = = = = = = * = = = = = ' c$ d$^. $ ",
+" s#7+S@<#<#b#e$b#f$u#3#g$4#h$D#l+W#W#&$j#i$4$4$j$k$l$k#l$4$m$W#N#N#N#D#W#W#X#n$o$j#j#X#W#W#N#4#S#2#)#)#=#=#)#)#b#p$d#)#1#S@*+E+S+q+4+4+6+5+5+q+0$*+q$r$s$s * = = = = = = = = = = = = = = = = = = = * 0 h.t$ u$$. $ ",
+" H#t#S@<#I#S@I#<#b#u#3#R#7#7#h$l+v$X#&$&$4$4$w$x$y$k$z$A$l$i$X#l+D#D#D#X#X#X#B$B$C$B$j#X#W#W#$$4#3#)#v#)#)#)#2#u#3#b#1#<#1#=#o+7+4+,+;+,+;+>+6+6+6+4+p+D$E$|.= t.= = = = = = = = = = = = = = = = = * o F$G$H$I$J$K$ y L$ ",
+" M$N$w#O$<#v#<#I#P$S@<#u#U#D#$$N#l+#$#$B$Q$&$j#R$w$y$k$S$A$l$B$X#X#X#X#&$&$j#R$j#R$4$j#Q$X#X#W#$$4#Y#b#S@S@T$b#b#)#=#=#<#&+r+r+o+w#q+K.X@>+;+'+#@L.'+m+m+>+q+U$Y+= * t.= = = = = = = = = = = = = = = J (.V$p@R.I@W$X$Y$ [.Z$L$ ",
+" `$ %.%+%@%w#+$I#S@&+&+&+b#U#l+D#D#l+#%#$#$C$j#Q$j#4$5$$%%%A$l$4$&$&$B$j#5$4$y$5$5$j$4$k$j#&$W#&%N#3#u#b#S@&+=#b#)#<#S@*+o+S+S+7+4+,+]@*%>+>+>+n+;+=+3+'+m+~+{+=%-%;%s * = = = = = = = = = = = = = * * >%,%'%)%I$H$K@!%~%{%]%^% /%(%_% ",
+" :%n+<%[%+%N$.%.%<%+$O$&+P$<#b#U#l+X#X#l+W#l+l+}%j#j#4$|%1%2%3%A$l$k#k#k#l$4%k#z$l$l$5$5$4$4$o$W#$$R#T$<#<#5%E+&+S@S@&+E+E+S+7+6+6+D@,+>+*%>+,+,+4+7+r+R+>+;+;+'+6%7%8%s$= t.= = = = = = = = = = = * s h.9%F+T+T+T.W$0%X$M@a%b%c%d%c%e%e%f%c%{%g%h%!%I@I@T+Q.R.i%K@7%2+j% k%l%m% ",
+" Y$N$@%<%n%Y$o%p%q%r%{@s%I#t%<#u#U#l+W#l+D#N#U#N#X#j#l$u%v%w%u%2%x%y%A$A$z$5$z%4$l$|%4$A%R$4$&$W#U#u#<#w#S++$E+E+S+E+S+7+7+7+6+,+4+,+,+D@6+w#&+S@S@=#)#)#*+S+6+q+q+;+B%C%Y+' * t.= = = = = = = = = * /.D%H@s+N.F+Q.R.H$K@E%F%G%G%F%L@K@H%I$R.F+]+!+L.>+>+>+'+4+]@>+m+3+N.I%N$H#J% /%O@,@K% ",
+" L%M%o%N%<%n%B%o%O%P%P%Q%@%O$O$O$P$t%b#R%R#N#U#4#U#l+j#l$y%S%T%U%U%V%V%y%1%A$z$z$z$z$z$z$k#l$j#X#D#4#b#S@w#2+2+{@W%{@+%+%+%.%2+6+,+,+,+6+C#r+w#&+=#)#2#1#=#)#)#o+0$5+7+q+X%Y%|.Z%* = = = = = = = * J c$`% &L.!+.&M.N.+&F+Q.Q.Q.Q.Q.Q.G+N.h@!+'+D@S+o+5+*+K#u#2#=#)#<#*+o+E+S+,+L.=+{@@& #&s$' b+K% ",
+" $&%&&&P%q%n+*&B%O%O%=&Q%-&W%O$9$O$D$*$3$+$s%T$R#U#&%Q$l$w%S%;&V%V%>&;&,&'&)&1%z$1%1%!&u%l$4$X#$$4#3#<#E++%~&,+2+.%.%K..%2+K.U@>+2+6+6+S+E+o+*+)#3#4#3#3#3#2#=#*+*+o+r+6+5+5+{&>@= t.= = = = = * s /.]&,+'+-+!+{+{+~+!+#@^&{+!+/&8+!+-+q+r+S@)#(&i#X#X#i#(&{$B$_&W#&%:&3#p$S@&+E+7+6+>+h@<& [&}&' = * |& ",
+" 1&2&&&3&2&2&&&&&4&O%5&&&O%p%B%@%3$O$P$*$<%n%+%*$T$R%$$C$5$v%6&7&8&9&7&V%0&y%a&b&y%c&d&z$k#4$}%$$U#R#<#&+@%n+*%K.n+e&>+B%*%>+>+*%>+.%+%7+E+*+<#)#)#b#2#3#3#2#d#)#)#=#*+S+q+q+5+f&U$- O * = = = = 0 F$E@ #>+n+;+,+K.K.;+>+L.=+L.>+;+7+*+K#(&D#_&i$i$4$j$k#2%b&g&'&h&i&_&X#X#D#j&2#=#&+E+R+6+]%Q.k& l&= * = f m& ",
+" 4&&&n&o&%&%&p&q&p&%&%&%&4&P%o%N$Y$*$t#D$*$r&N$N$+%I#l+m$s&w%t&T%u&7&7&v&t&t&w&b&v%5$C$j#4$m$D#4#u#v#P$w#+%r% %e&e&e&e&e&*%r%e&*%>+2+6+c#&+S@<#)#b#b#2#2#)#8$d#=#*+r+5+6+4+,+6+x&y&z&|.O t.= * ' c$A&B&;+;+;+;+>+,+6+7+6+,+,+5+E+o+o+=#3#%$X#j$u%b&C&T%D&E&F&1%2%'&;&8&C&G&&$_&4#2#b#=#E+E+7+,+7%>+D$ H&O@= = = I&J& ",
+" K&L&M&&&4&=&N&N&q&q&N&O&N&P&q&2&Q&P%Q%-&n%n%*$*$+%n%r&Y#d&z$y$1%t&w&R&T%0&)&1%S&z$l$l$j#T&C$W#D+b#O$&+t#{@K.L.U&q%/&/&7%V&e&B%e&*%n+D@2+t#W&<#<#=#1#u#X&2#)#<#J#&+E+S+6+4+4+4+;+K.,+'+Y&<$= = O F$Z&`&4+q+5+7+7+7+q+4+r+*+*+o+o+<#4# *k#.*v%b&+*@*#*8&$*%*9&D&+*g&2%&$u%&***|%v$j#D#2#=#)#&+o+S+,+K.!+=*-*;* i.= = * * O >* ",
+" ,*'*)*!*p&~*p&p&{*q&p&%&]*]*p&!*p&%&2&&&P%p%r%K.n%@%3$O$D+^*)&/*1%!&1%(*w%_*l$l$5$l#C$C$l+$$%+R#S@W%n%+%K.p%:* %<*7%[*/&<*U& %e&n+~&6+7+S+E+*+S@=#)#=#=#=#=#=#=#)#<#)#!#}*o+o+y#q+4+4+|*1*2** c$3*4*4+r+*+)#2#2#3#2#M#*+*+=#b#4#D#5*1%C&D&**6*7*%*8*9*0*a*0*b*c*d*e*6*g&|%$%g&.*f*&$W#T#)#=#&+g*S+6+>+L.8+N.h*L.t%i*k&j*k&k*l*M$J$W%i*k*m*k&n*o*p* 8 * = * = ` q*r* ",
+" s*t*u*v*w*x*y*u*z*A*B*q&p&p&p&%&{*p&p&2&%&&&P%p%C*n%*$D$S#D*l$5$)&2%y$A%A%y$5$d&A%C$$$U#$$u#T$<#&+W%N$p%*%:*7%7%:*:*]%/&E* %U&:*L..%2++%@%S+E+&+&+*+S@o+*+=#=#S@o+5+q+F*S+o+*+=#E+q+,+5+G*{&)$H*I*;+6+o+=#=#1#2#N#$$N#h$N#W#j#$%g&D&8&J*c*0*K*b*L*a*M*M*a*N*O*a*M*M*N*K*P*&*'&5$i$X#v$i#(&)#*+*+S+S+7+>+m+!+/&~+{+$@s+$@#@!+3+!+!+L.'+>+m+!+s+s+s+{+L.@@ Q*R*0 = * = = = S*Q@ ",
+" T*A*z*x*U*V*W*W*X*X*Y*Z*y*`*A*!*N&O&]*o&2&~*2&&&Q%N$n%N$ =U#_*c&.=j#1%d&C$$$#$&$X#$$R#b#u#b#O$w#+%{@K. %/&/&=&=&^@^@/&:*:*7%:*e&V& %.%2+2+{@C#S+S+E+~#=#&+p+S+E+S@=#3$7+,+;+4+6+6+4+,+7+5+7++=@=5+r+r+*+e$5#&$j#j#4$|%k##=1%g&T%$=%=%*&=L**===-=-=;=>=-=M*b*K*a*M*0*b*$*%=#*w&g&2%%%&${$@$N#p$<#<#r+E+S+T@K. %!+=+=+!+~+!+'+4+q+o+,=7+V@e#o+r+6+-#>+-+h@'=J$)= !=X.' * = = = = ' ~= ",
+" `*y*x*V*X*V*X*{=]=^=/=(=_=:=y*=%P&N&p&p&<=~*%&2&2&Q%-&B%[=Y$*$S#R%H#T$R%D+D+U#l+&%R#b#<#S@+$t#w#2+p%p%:*O%/&M%]%^@^&]%=&O%/&7% %:*e&*%n+,+,+6+7+7+S+5+7+R+o+*+o+7+4+7+5+6+X@>+>+;+;+4+7+5+q+}=|=5+5+o+*+=#X&i$g&b&.*1=2%g&w&C&V%**6*2=M*-=-=-=3=3=-=*=4=L*K*d*0*0*7*5=#*b&g&v%#=5$k$$%&$%$i#{$4#2#)#=#&+o+S+6=6+>+L.L.-+>+>+,+r+=#2#3#j&4#T#3#2#{#o+5+q+4+'+{+{@k*7= Q@..8=' * = = = = * O@9= ",
+"0=^=:=^=a=b=^=^=c=d=e=_=f=g=h=i=y*'*'*N&N&]*~*j=2&&&O%Y$<%k=*$D$3$O$M$l=S@S@s%t%9$9$I#<#t%+$W%n%n+N$:*O%O%=&=&^@J$M%M%=&^@=&=&/&:*:*:* % %*%,+K.6+6+q+q+7+6+4+q+q+C@2+;+>+L.-+>+;+>+n+;+,+C@q+4+T@q+q+7+5+o+J#!#X#E&T%x%A$$%l$A$w&$=8*0*a*L**=>=m=m=*=&=&=a*d*d*0*2=n=o=x%E&E&D&&*E&i&k$|%j$D#W#D#4#2#2#2#*+o+o+o+C#7+6+7+q+S+=#v#%$p=W#]$i$ *&$B$_&_&X#q==#M#*+4+'+'+r=s=h+0.* = * = = = = = = t= ",
+"u=v=/=w=e=x=y=x=y=z=A=B=z=C=D=E=F=y*G='*H=I=N&<=J=4&P%K=D$s%P$P$&+3$3$D$s%O$M$D$*$<%@%D$3$*$2+*%B%p%=&=&^@J$^%^%J$J$M%J$M%^@{+M%]%]%^@/&=+:**%*%>+,+K.;+,+>+>+>+L.=+=+L.=+!+7%e&'+,+n+>+4+>+,+4+x&6+q+6+q+7+r+y#o+3#@$v$X#L=5$2%T%9&M=0*N=-=L*O=P=*=*=Q=b*M*K*%*%*J*R=8&8&&*C&A$k#2%u%k$j#k$|%i#X#D#D#3#3#3#<#&+*+5%V@&+*+S=<#2#{$T=U=A%5*$%u%u%z$A$v%E&V=4$%$W=X=Y=-$Z=`== = t.= = = = = * = .z+ ",
+" -w=.-C=y=z=+-A=A=B=A=A=A=_=/=i=@-X*#-G=q&I=$-]*p&%&%&N&%-n%*$3$s%&-<%n%<%D$3$*-<%n%N$C*.%N$B%<*:* %/&M%3&=-----------^%J$J$J$=&M%J$;-J$]%:*/& %*%*%>+L.w@L. %L.=+!+!+!+!+{+~+L.'+n+;+;+C@r+S+q+q+7+r+S+5+r+r+o+r+r+o+=#4#&$l$>-D&8&,-0*'-m=m=*=a*M*N*0*0*c*7*M=%*)-**!-~-8&**;&V%0&0&b&x%$%|% *v$X#D#W#4#3#N#2#*+S@)#S@S@)#3#{-]-%.^-y%E&/-$=V%#*/-,&x%g&(-_-:-<-[-}-@#O = * = = = = = = = ' |- ",
+"1-2-3-B=+-z=A=A=z=A=3-4-f=_=C=C=5-@-Z*G=G=q&]*q&'*)*)*)*!*p&4&%-n%6-N%o%-&r&w#+%.%N$N$n+B%e&p%[*&&=&^@^%=-=-^%^%=---7-----7-----h*;-J$h*^&!+=&~+L.L.L.L.L.8-=+8-L.!+=+)+=+!+ %'+>+,+4+7+r+J#=#*+)#<#)#)#p$=#=#*+=#E+*+:&D#5*F&$=%=%=J*a*-===*=O=b*0*9-0-a-2=$*8*J*J*b-6*&*E&D&8&>&D&y%A$|%$%5*V=l$v$ *D#D#N#2#N#3#=#=#)#<#b#4#c-d-@#e-f-g-%=%=8&;&7&h-i-j-k-l-=.0.0 = = = = = = = = = = t.= m-n- ",
+"o-p-q-r-s-t-u-v-w-x-3-y-h=h=C=_=_=z-A-B-C-G=B*'*A*D-D-E-F-!*%&%&4&Q%o%O%P%U&-&n%N$B%p%*&O%=&=&=&^%J$^%=-G-H-H-7-7-7-I-I-J-H-H-K-K-H---N.;-J${+]%!+7%=+ % %L.=+m+L.=+)+>+;+]@D@C@7+S+*+2#L-5#W=@$j#M-@$D#N#N#3#4#4#@$D#{$ *5$2%&*d**=N-m=O-P-Q-Q=a*R-S-M*c*T-b*c*d*J*J*,-8*6*8&$=C&x%U-#*V%T%x%j#$%$%_& *{$D#D#3#4#3#)#=#<#p$V-W-6.@#X-v%&*D&U-Y-Z-`- ;.;+;@;:@#;= t.= = = = = = = = = * = $;'. ",
+"%;&;*;=;&;r-*;p--;*;q-p-;;>;y-h=_=_=(=,;';);`*G=v*v*v*!;~;~;!*p&o&4&&&&&&&M&&&{;o%p%O%p%e&=&2&2&=-G-];7---H-J-H-7-H-H-^;/;(;_;:;K-I-<;=*[;;-^@{+7%};7%=+=+=+ %L.'+>+U@U@;+6+E+)#K#|;D#@$B$ *5*i$j$j$x%0&5* *1%v$v$&$B$ *u%#*R=$*0*1;2;3;4;5;6;7;8;9;O-0;L*M*a;0*M*b;7*K*2=c;7*d;8&R=5=R=!-e;#*&*,&|%i$k#B$X#v$X#D#4#4#2#f;g;h;i;= @#j;k;l;m;n;o;p;q;r;s;0 o = * = = = = = = = = = = * s t;u;v; ",
+"w;x;y;z;A;z;B;x;x;z;C;D;E;E;q-w-F;y-y-G;H;4-_=E=I;X*J;y*!;!;!;!*p&n&4&M&2&J=2&p&M%O%M%^@K;O%M%--G---J-I-J-H-H-J-H-I-I-K-L;M;M;K-N;(;K-<;O;J$^&{+7%:*<*8-=+L.*%B%>+,+7+R+r+r+*+)#N#_&j$j$$%z$E&u&D&g&B$D&g-A$5*P;j$_&g&u%n$C&Q;M*a*Q-R;S;T;U;V;W;9;4;O-X;0;1;N-*=*=*=L*a*N*0-0*Y;g-$*)-&*x%2%Z;5*g&5=0&5$C&|%i$j#j#]$D#N#`; >f = = f >.>+>^.@>,@* * * = = * = = = = = = = = = = = * = #>E$R+,+3& ",
+"$>%>&>*>A;=>E;*;q-D;s-->;>q-&;->A;->p->>,>'>;;;;A=C=c=)>X*x*D-A*!*%&%&&&~*p&!>!>!*~*^%G-G-2&^%G-];];I-^;~>{>I-I-^;]>^>/>(>_>:><>N;(;[>}>O;^&J$/&=+ %L.*%>+]@,+4+C#c#S+o+2#N#|>&$$%x%T%1>$=9&,-Q;K*Q;h-i$V%$*g&4$$='&j$R=R=|%E&c;M*a*1;2>3>4>5>3;X;>=Q-*=*=X;O-6>X;X;0;m=a*N*M*0*0*c*,-8&**R=d;**g&V%9*#*D&T%7>A$u%A$i&8>9>0>= * = * ( a>q*s O = * = = = = = = = = = = = = = = * = = b>c><#S@t#.%d>e> ",
+"f>g>B;h>i>j>k>i>l>l>i>m>x;->A;n>o>B;p>x;->D;-;-;q>z=r>s>s>c=W*z*A*'*]*o&~*j=2&%&2&=-~*G-2&G-G-7-H-H-^;K-^;$&K-I-K-^>(>:>t>u>u>t>N;(;K-}>N.v>]%7%*%*%>+K.,+6+C#r+R+o+)#j&D#&$5$.*T%8&%=w>7*b*0*M*M*M*0*d;4$#*K*#*4$x>y>5*n=M=k#A$c;M*M*-=4;8;2;a*N*a*a*M*a*z>2;6>6>6>A>A>B>*=N=M*0*a*c*P*%*0*a*L*%*b-0*$*$=C>**;&t&D>E>r$-@= * = = = = = F>` = = = = = = = = = = = = = = = = * = 6.G>H>C$4#u#<#S+K./&I> ",
+" J>K>L>M>N>N>N>N>O>P>Q>P>i>m>h>R>S>&>g>h>&>B;z;n>E;B=C=v=^=F=T>U>A*'*]*%&j=~*=-^%j=!*~;];F-];V>^;J-K-^;W>X>^;Y>M;^>:>u>Z>`>g% ,<>L;~>O;;-]%7% %K.,+,+7+.,<%5+&+1#2#R#+,_&$%g&&*R=7*K*c*M*O*@,@,a;0*M*a;%=i$**K*1>_&#*D&n$8&M=%%F&P*g-)-2=M*0*Q;P*J*d*#,L*1;P-9;U;$,A>6>6>A>O-m=*=Q-%,&,W;5;7;W;T;O=-=*,-=K*a*N*=,-,;,0.= * = = = = = = = = = = = = = = = = = = = = = = * = = ,@>,,,D&A%',N#g$T$W%K.J$), ",
+" L>!,~,O>{,],A;z;^,m>P>/,(,_,:,N><,[,},|,<,|,h>B;*>&;'>r>1,Y*U>y*`*'*q&2,I=%&~*!*3,!*G-D-4,4,^;5,^;W>6,Y>W>W>^>M;u>u>`> ,g%g%u>_>(;<;J$J$7%:**%,+2+{@7+S+E+O$=#b#T#@$k#w&#*8&J*K*a*'-L*L*a*O*&=R-7,a;8,M*;&j##*,-V%4$w&T%i$D&%=k#%%b&2%u%b&V%8&%=)-P*K*L*2;9;T;W;T;T;9;4;4;P-*,O-P-U;9,0,a,b,c,d,e,f,g,*,h,h,R-i,j,k,= * = = = = = = = = = = = = = = = = = = = = = * = O i;2.l,m,8&n,_*l$o,T&R#<#E+,+N$ ",
+" p,q,r,M>s,h>B;x;A;t,&>u,v,q,q,q,_,w,x,x,N>i>s,<,&>y,&;z,z=A,Y*A*'*q&q&Q&B,B,N&!*F-C,G-4,4,4,^;$&W>Y>Y>^>W>^>:>:>u>D, ,E,E,D,F,_>}>h*M%/&]%e&n+,++%S+E+&+b#3#D#X#5*u%T%$=R=P*M**=0;X;h,%,-=M*a*R-8,M*a;M*0*G,j#%%H,R=l$5*x%5*w$V=$%j$u%u%I,$%'&J,J*2=M*M*g,7;5;T;T;K,2>K,L,T;M,N,O,P,Q,R,S,T,U,O,V,W,X,O=W;i,Y,Z,`,= = = = = = = = = = = = = = = = = = = = = = = * = = '.'+'@'X;#'&*$'y$v&/*D+R%P$O$ %%' ",
+" &'*'!,M>j>='x,x,='M>-';'q,>',''')')')'*'v,J>K><,[,g>->&;!'H;_=@-`*q&q&T*~'I=B,4&p&!*G-4,{'V>W>Y>Y>]'M;^>M;M;^'/'D,('_':':'E,h%N;[;=&^@:*e&*%,++%7+E+<#2#U#D#j#2%#*)-<'['=,h,X;*=*=m=8;}'U;-=M*O*0*b*,-8*7*d*M=A$&$b&,&5$X#j$ *X#&$i$i$%%.*g&D&/-**P*|'*,1'7;2'3'4'4'5'6'7'8'9'0'a'b'c'd'e'f'g'S,h'i'@'m=}'j'k'l's * = = = = = = = = = = = = = = = = = = * = = * 0 m'n'o'p'S;2'q'd;#'9&y%)&U%#$R#9$s%O$H-r' ",
+" s't'u')')'*'q,v'v'w'x'y'z')'''A'u'u'u'B'z'z'_,='C'L>D'->E;E'F;y-v=F'A*I=T*Q&N&N&N&p&)*!;{']>G'Y>^>H'I'M;M;M;^'J'K'L'M'M'N'D,u>X>h*O'/&:*K..%6+7+E+S@3#$$W#j#'&D>P'N*m=Q'R'8;7;R'4;3;0;W;2'A>P=M*0*7***b&A$E&>&5=E&j$5$j$v$W#@$]$_&j#5*k$'&$=8*6*!-7&K*S'3'h'7'T'U'T,0,V'W'a,a'X'Y'Z'`' ).)+)@)#)6'$)%)4;5'&)*)!.O * = = = = = = = = = = = = = = = = = = ' s =)-);)>),)')))!)j'2>~)n,{)])/*1%A%U#%+I#M$p%2& ",
+" q,t'A'^)/)()_)x':)v,u'()<)[)})<)[)<)})u'z'z'^)|)v,:,<,1)2)f=z=,;A,3)y*H=T*I=I=N&p&{*~;4)]>Y>5)6)7)M;H'8)(>u>('9)0)a)b)9) ,(>K-h*=&O%:*K..%7+S+S@b#U#X#k$2%D&d;d*L*c)9;7;X,7;X,V;5;$,>=X,d)6>e)0*7*~-$=V%A$ *|%%%%%k#f)A$B$W#n$_&j#i$4$5*|%g&n=g-Q;a*-=*,g)h)i)i)j)k)l)g'm)n)o)p)q)r)s)t)u)v)c,w)x)y)z)A)K,B)C)t;O J = = = = = = = = = = = = = = = O o D)E)F)G)H)A>I)J)}'K)L)M,f,d*9&M)&*d&z%l+k+k&P$N)M%O) ",
+" P)Q)[)q,Q>v'w'^)R)Q>z'<)t'})<)S)t'T)Q)Q)[)/)u'U)z'*'|)O>%>-;V)D=@-B-W)y*B*X)I=o&{*~;4)Y)5,Z)Z)I'5)H'`)^'/' ,N' !.!+!@!:'Z>L;I-H-^&O%O%#!2+W%&+<#R#v$5$'&C&!-d;Q;|'3;P-9;7;W;K,2>}'$!4;X;8;9;Q-0*J*%=M=c;M=#*'&A$k#|%i$k$l$$%i$_&&$4$g&,&C&u%u%5=*=T;K)2'3'%!&!a'l)*!=!-!;!>!,!'!)!!!~!{!]!^!/!(!V'_!e,K,U;O={):!# = = * = = = = = * = = = = 6.<!7 [!}!|!1!2!a*3!0;4!5!6'O,6!P=X,4;])7!v&z$d&8!%+@@`$s%n%9! ",
+" 0!a!<)<)v,!,b!!,:,R)v,A'[)c!c!c!c!c!d!d!a!a!t'/)A')'z'|)Q>k>z;e!z-f!W)y*g!B*H=N&p&A*v*z*h!Z)i!5)I'H'j!8)k!l!9)b)m!n!0) ,:>^;];7---M%:*n++%S++$<#D#5$v%0&/-~-o!*=P-f,f,p!K,K,5;2>2>2'}'q!2;6>0;M*)-%=,-r!%=#*V=#=v%b&b&'&z$k$ * *u%.*j#k#R=,-%=%=z>K)Q,s!W't!u!v!(!l)w!^!]!x!y!z!~!)!~!A!B!C!D!E!c,!)U;F!M)G!g,H!I!J!s = = = = = O q*0 K!L!M!N!O!P!Q!R!S!C>T!d;5!K,U;~)U!S,K)b*~)p!V!W!U%X!d&m$#%D+g@s%6-%&Y!",
+" Z!`! ~[)}).~B'B'B','y'_)<)c!+~@~Q)a!Q)#~Q)#~Q)Q)#~()A'q,$~N>%~&;*>2)3)&~g!g!g!*~q&'*A*h!x*Z)I'I'(>H'8)=~-~(';~.!>~,~'~^'N;^;];--^%^%^@n+{@E+O$~$l+'&$'>&d;%*-=X;f,)~2>e,K)2'!~~~~~5;K,R;2;N-N-P=K*,-P*d;D&x%E&v%j$j$|%k$i&E&T%A$X#v%8&'&_&**K*%*8&a*h,7;5;{~i)]~%)a'^~%)/~(~_~:~~!<~[~}~|~1~$)2~3~p!d;4~5~f,p!6~7~8~9~= * = = .0~a~b~c~d~e~f~g~h~j'i~j~#'O=d;V!L,k~}'K)2'j'U;Q=4!l~h,6&5$d&A%i*$$T$O$k=%-q&",
+" /)<)/)A'y'B'B'B'B'y'()[)t'#~m~n~o~p~q~r~r~q~s~t~s~#~}))'Q>:,l>e!E;E;_=B-y*G=u~G=A*z*x*U*W*{=v~H'w~x~/'l!y~z~A~B~C~('D~W>^;^;J-H-=-M%O%6+E+<#l+',,&5=J*K*-=E~P-4>~~i,S;h~e,6~K,W;R;R'R'6>F~M*M*b*K*,-%=~-~-)-P*R=S%C&g&%%j#5$C&v&j#j$8&D&j#$=c;$'V%0*-=G~H~Q,t!^~I~l)e'x!J~)!K~L~M~N~O~O~P~Q~R~3~h~C>S~X,K,))e,T~U~V~W~* = * e X~Y~Z~`~ {.{5'k~+{@{n,#{P=T!#'N=4>I)L)e,K)))${}'g,%{~)&{l$m$y$A%.=g@9$*$4&*{",
+" D'/)[)y')'B')'={={B'/)-{t's~#~#~;{>{`!,{'{r~r~`!s~a!Q)#~t'){^)L>!{~{w;/={{&~G=A*4)v*x*Z)5)j!]{j!^{x~/'-~/{({>~_{:{<{I'^>^;J-_;I-];M%=&B%t#~$j#0&;&[{,-*=4;X,p!M,q'S;i,!~K,R;W;A>}{N--=L*M*|{%*,-%*%*%=R=,-Q;P*5=#*b&T%~-8&C&j$z$~-U%j$5=7&|%~-J*w&R=&=-=p!1{P~u!2{]~3{4{5{z!6{K~K~7{x!J~l)&!S;0'8{o!%*k~}'j'))K)K)^~9{0{` = e a{b{c{d{e{f'I)f{[{9-g{h{i{j~g{@,h{j{a'K)7'T'k{9'm=*=a*N=w%C$^*6$R$U#t%*$4&Y)",
+" l{<)u'()m{m{B'={^)n{x'()-{[)s~#~s~q~;{o{,{p{q{r{q{;{s~Q)<)u'*'v,M>D'x;s{t{@-#-#-Z*u{X*{{j!)>v{^{v{w{x{y{y~z{A{C~B{C{I'Y>W>J-^;J-];^%p%B%+%R#',y>8&,-o!O=4;T;I)}'K,2>e,H~M,T;f,$,X;D{a*c*a-c;,-,-,-Q;%*d*J*R=$=C&g&2%5* *0&)-J*1%w&J*T%%%J*;&1%)-8&&*Q;M*a*Q-3;K,i';!E!b{E{:~F{G{H{I{;!p)J{-!K{{~%!h,d;L{L)J)W;${z)x)M{N{O{b+e P{Q{R{S{g'w)T{@,U{o!V{W{~)X{M)Y{I)a,Z{W,`{v!Q, ]f,4!.]R-w%m$m$m$y$.=T$k=2&v{",
+" ;'y'A'u'B'+]@]@]#]={B'()[)#~#~s~s~s~q~q{p{$]$]$]r{q{;{t'.~)'^):,o>4-f=%]y-A,U>U>B-{{{=&])>]{)>w~*]=]-];]z{>],];]']i!Z)Y>^;J-H-7-G-O%.%@%b#',)])-O*N=S~N=$,~~H~W;A>!]8;7;9;~]6>X;m=-={]M*a*M*K*Q;,-P*%*P*$=E&,&$=%=5=e;k$|%%=%=u%~-d*,&$=,-$'R=%=&*%=6*M**=3;T;h'c''!]]^]6{/](]_]:]<]b'[]}]S,5'|]f,*=O=1]*,g,g)2]k~^!3]4]5]6]7]8]9]0]a]b]c]%{n,W{g{d]e]])~)K)2{x)f]5'g]h]W,A)))W;[{7!y%)&y$8!8!8!i]j]K;k]",
+" -'[)y'B','={@]l]v'={B'm]()S)#~d!s~s~p~n]q{$]o]p]$]p{q]r{r{;{A'*'''C'D;f=w;V)/={{Y*{{:=:=:={={=w~r]s]-]t]u]>]>]-]w{Z)U*U*W>^;v]M%M%=&K.S@u#m$0&d;R-~)Q=O*5~U;p!T;f,A>A>9;4;4;*,0;m=E~m=*=w]a*M*c*%*J*%*c;)-8*M=Q;b*0*0*,-b&$%)->&#*Q;$*g-$*6*c;c;x]6*w>d*9;3'R,y]/!z]A]B]C]^]D]:~G{r)E]/!F]i'S,h,O*h,3;0*d*Y{i,L)f,k{S,3{G]r*H]k{I]j'~)J]K]#'L]N=])e]g,p!q'6'd'i)6'6'M]+)2]))k~4>P'1%c&N]l$O]P]i]Q]R] =;~",
+" S]-{m]B'={={v'l]T]l]={m]y'[)()U]d!#~q~r~q{$]p]V]W]W]p]q{X]Y]p{){:,_,w,*>e!f=_=(=E=:=)>)>)>:=)>Z]`] ^k].^t]+^@^#^)>V*Y>Z)G'$&_;M%B%n+N$t#R%#$w%9&%*P=~)R-R-g,X;h,*,*,h,4!m=h,0;m=m=3;G~0;Q--=$^-=-=-=O=N*Q;c*N*M*M*8,a;a*M*$=#*J*J*$*0*a*0*,-9--=a*M*c*7*%^1{U,8{i)3{@)2{&^*^=^-^:]r);^^!V'8{>^~~%*>&$*=,&*g&,-f,,^7'X;'^c')^!^~^{^3~M,k~%{j']^^^Q-M,k~j'7'6!w)/^i'K)(^_^c,2':^7!#'t&R&U%x@0#j*i]<^[^}^t]",
+" [)()B'={w'l]|^l]T]l]x'1^2^U][)S)s~3^p~q~q{p]4^W]W]p]5^p]Y]Y]p{<)v,w,6^x;2)h=(=7^.-:=F=:=:=8^Z]9^ ^0^-]a^b^c^v-^={=I'i!Y>$&4,G-{;d^P$g@D+l#w%#'%=c*~)*=b]d*9-a*e^m=*=N=N=F~Q-Q-0;h,h,X;X;Q-z>m=0;2;>=D{a;R-a*a*a*a*L*Q-f^L*J*Q;0*c*0*N=3;m=m===N=*=5;R'O=-=2'g^U,h^g't!i^j^=^k^K~k^l^f'i)z)X,g,b-k# *4$5$X#|>g&h,L,6*c*W;2{m^L)L)n^N=0,w)7'j'p!}'))j{L)e,e,5'o^g'p^5'w)8]N=M)d*q^n,_*r^.=j*R]R]s^t^u^a^",
+" v^()2^,'={@]l];'|^|^@]B'm]2^[)S)#~s~q~'{q{$]p]w^x^x^w^4^W]W]$]p{a!*'P>j>|,p-(=z=A=w={{^=&]c=y=<{ ^ ^k]y^w-S>B;3-Z]^{I'Z)$&J-!*=&N$s%z^#$8!1%u&;&P'N*L*R-A^C>)-d*a*-=O=Q=Q=L**=X;4;$,$,*,X;B^h,X;X;X;1;L*e)L*L*-=Q-3=0;!~W;Q=d**=>=-=*=~)S;1{1{~~M**,g)z)h,M*4;S;5'U'h^i)`{l)C^G{O~-!h^S;*=D^y>b&G&&+;+]@6+|=5+R#d;R=l$u&I)T'}'2'E^F^G^3{H^))))L)E^j'9,K)2'!)I^o^%!5'5'7'J^%{f-#'Y{t&_*k&K^Q]Q]L^M^N^{{",
+" O^>{()x'={P^Q^R^@]={S^m]2^()[)S)S)@~s~'{$]p]x^T^U^U^T^x^x^V^5^p{a!*'M>s,W^X^y-h=Y^^=:=b=Z^`^y^y^ ^<{w=(=;>&> /0^*]^{./$&J-~*=&B%W%b#A%w%1%U%M)d;P'f-Y{j~+/>&9&,-M*-=L**=|'2;9;W;X,4;h,h,A>7;4;*,6>P-U;T;f,~]K,h'6'@/3;K,7;Q=N=X,i,M,@,J)%!%!9'8;m=O,#/9'K)9;K)9'Q,U'U'U'U'2{,!^!x)k{T;g-l$4#=#*+6+^&I@K@$/}>;-C@5*D#&$v&E~g,k~M,2'Q,f'n^))L)2'e,2'}'2>i,L)%/S,&/j'2]M,@,*/j~q^=/@&9!1&M^-/u^}^;/'*B*",
+" -'@~m]x'={>/={l],/@]x'_)()U][)S)@~@~q~$]$]p]'/T^)/!/~/U^{/x^W]p{;{A'N>k>|,&;4-+-r>b=Z^y=]/A= ^y^9^c=c=x-@^^/t]`]D~5)$&4,2&P%r%+%3$~$y$U%U%t&n,7!7!n,$'7&>&;&{)J*N**=0;P-9;X,I)W;|]4;7;W;W;W;T;4>W;4'I^//W'c,k{^~(/3>_/_/K,*,W;g)!)L*}'S,#)7'2'!)1~h)i':/%!%!</[/[/V,9'#)h~ ]8{'^h~%^{)4$3#E+L.h@[;}>K@}/|/1/_>k$2#K.7+i#7$@$g&S-{~2/V,A)L)g)R,P-4;K{k~j'e,L)3/W,4/j~h{q^T{5/6/K^Q]n*7/j*8/`*9/c=0/",
+" u'q~()()a/b/x'c/={x'2^U]U]S)#~S)@~q~'{$]d/'/x^U^e/f/g/h/U^{/V^p{`!i/j/W^&>p-k/.-s>w=]/y^l/y^y=s>c=Z]0^A{m/t]-~v{Z)n/];&&U&N$s%R#D+$$z%y>t&6&o/p/0&6&#'#'#'$=7!o!g{*,f,9;4>f,f,7;T;2>}'2>2'K){~U,u!c{q/d{i)H^0,r/#/U,_/s/}'H^R,L,c;W;S;t/H^#/)~d'f'b,V'T,u/O,8;v/6>W;*,==a*$^D{%*T%X#8$y#F*-+{+}>H%g%1/w/x/$$f,*,l$o+q+L.=*I$'=)+&$*,2]O,'^H^A>X;4!f,M,W;))3>L)2>g,y/V%)&x@#'^*Q#i]z/A/t^X)`*B/ ",
+" C/q~S)2^D/2^U]2^2^U]@~'{'{'{X]'{'{q{X]X]E/'/U^F/G/H/G/I/h/J/K/,{`!L/j>%>y,q>.-w=y=A=M/M/y^s>c=E=w=M/N/O/P/ ^8^Y>{'];&&O%B%3$U#Q/1%d&g&S%R&t&C&d&_*y>y>v&#'**W{c*R/A>U;6>R/0;X;P-T;2>2'K) ]U,S/-!x!x!E]j^u!0'h^U'</5'R/2'S,6'T;T/X;e,E^c,n)k~D!}~v)0'i)t!/!L,d;%%1>g-R=0&.*w%v$b#r+2+L.J$}>H$U/V/W/X/_>+%b&,^0'X,~-&$X#D#E+L.L.>+^@8&,^2]|]7;5;X;+{5!X;f,p!M,Y/])#'Z/M)J.i]`/9/B*X*@- (T*E=,; ",
+" .(+('{p~S)S)@~@~n~p~@(E/E/X]X]X]E/d/'/#(U^!/$(H/G/%(&(*(=(F/K/-(`!;(|,>(,(4-w=(=B='(A=<{`]8^c=y=x-)(m/z{!(~(Z){'];=&B%{(w#9$@@d&V%V%#'t&c&_*U%w%l$1%U%v&$'%=o!L*X;h,g,L**=X;R'W;K)5'_/8{x)l)](e'q/^('!/(3{w!'^7'e,k~E^%/6~f,M)((I)e,P~_(I]I]:(*^E]h)'^<(O,U;n=$%&$j$W#e$r+,+L.=+{+F+[(L@}(|(1(`>H-7+N#d;2(w!&!N,*=T%3(j#b#3$&+&+:*n$2'0;|]9;~)U;+{h,Z/s/Z/n,Z/Y{r^4(L%5(j*6(4(7(r>b=b=A=A, ",
+" 8(9(E/q{X]@(Y]E/X]'{'{d/U^#(T^#(#(#(U^)/)/H/I/0(%(&(a(b(c(F/{/d(`!>'e(f(X^B=]/0^x-0^y^y=c=`]<{P/g(h(i(C{w~Y>V>];=&N$<%P$S#A%c&C&#'v&v&y%C$m$z$w%z$c&y%;&C>,-d*-=0;|'R-Q-4;7;M,K)T'w)F]]~g';!j(k('!l(3{*!m(_/L)A)I)k~M,g,i{7&0;9,A)x) )x)d{;![~n(3{h~o(5;T;-=;& *)#o+5+;+=+{++&R.L@p(q(r(s(t>H-,+R#w%v/#/t(g'a'9'8;d;0&&$u#9$<#3$7%7+b*5>U;R-q^g,X;V{R-])7!6&Q]u(v(U%A%0#6/Q]w(G=y-M/F;o- ",
+" x'4^)/x^E/p]4^T^#(x(x(y(z(I/A(I/G/G/H/A(0(0(%(B(c(%(e/C(t~e/d(t~D(E(s-r-;;F(q>a^G(H(`]9^x{I(J(K(/{C{j!Y>V>];K;N$D$<#R#m$U%>&7!>&u&6&d&U#R%7/m$L(y%u&d;J*Z/R-~)$^a*~)*,7;W;}'H^h^u!g'^!f'M(G{6{N(/~l)R{6'))I)p!m=^^M)O=L{I)}'A)h^O(P(^(O~5{Q(@)R(S;>=a;%=V=W#=#5+;+=+{+F+[(L@0)S(T(U(Z><;6+7#z$M=e,V(q/W(%)W'O,p!7&t&y$R#e$<#2+^%+%**L*M=W!f-Z/v&^^X(d&N]Y(U%Z(s#`(v*U> _._+_A=2-2) ",
+" @_x(#_g/g/g/H/g/g/G/A(A(A(0(&($_%_c(&_*_T^C/C/=_ M>-_Y]''W^->;>r-u-2-u]a^ ^<{<{ ^m!J(;_;]>_7)Z)$&];P%@%t%R%k+',U%{)C>j~%=>&0&l#@@%+P]m$y$R&>&f-Z/c*L*m=V!~)m=*,p!}'#)h^u!,_o)'_H{)_!_<~~_D!T'6!{_~)W{W{d]]_M,2>}'K)K)3~<]2/^!^_k^/_<]=!T,P-b-y%j#N#*+4+3+s+Q.0%(___:_<_M'[_X>/&+$}_d*c,c'|_k^1_B]U'7'2'2_3_M)z%D+g@+$p%W><#**&*y>4_R&w%U%y%_*X(j*O)'*X*b=y=Y^h=f!h=0^*;5_ ",
+" 6_q{&(c(7_8_c(8_9_0_a_b_%_c_g/d_@_ <)e_f_g_%>z;s-;>h_u]F(;] ^=].^i_j_C~k_w{j!5)$&J-[*@%u#l+4$c&S%[{j~j~C>M)y%4$l+%+#$y$o,t&t&d;c*['&{V!*,h,0;|'8;L)6'0,&!m)J~l_m_n_C^o_R~,^t!p_{)d;|'4>q_K,k~U;N=r_5'E^`{/^,!s_t_u_'!m(3/0*D&&$u#o+q+v_!+[;w_g%e%x_y_:'`><>];N$<#a&7'@)z_(]A_B_C_P~p^e,f,J*9&U%#$D_M$*${;`>|%b&j#m$)&)&w%A%6/E_F_ (G_Y=1&Z*z=k/.-x-F;H_ ",
+" I_ i/J_:,W^x;y,c^K_z,2-L_t]l!z{M_M_m!k_^'D~]'$&];2&B%R#5$w%v&$'d;N_W{M)6&y%8!$$$$&$4$z%1%V%[{c*O*R-v/*,f,f,*,4;e,L)2]h^-!O_t_m_H{P_o_//6'Q_R_$^7;2>q'M,i~F!M)d]S_G~R/T_+)U_V_B_W_j^I^P=g&]$R#S@6+ %]%h*<;W$X_x/M'D,(>Y_I-=&.%~$C>Z_`_6{F{~!t_O_o^6!}'j'5!$'/*8!i]`$ :.%G-I-4$m$7/^*5/A%v(7/j*k&k*i*.:k&+:x=B=B=x-t-@: ",
+" ;(#:$:%>&>c^@^%:L_I(&:*:=:-:;:>:=]8)8)D~W>=-&&B%9$5$0&;&e],-)-9&C&z$4$m$X##$C$j#A%d&6&d*g,h,g,$^s/f,f,f,4>I)K)c,x)x!,:!!':):)_!:l)7'L)2>K,2>I)5!o!{)@{U{~)@'~:2]J~b{/]{:t_W_&/l~t&#$<#S+2+e&/&^&H-[(t>(_(_`>t>]:7-M%N$O$l$Q=^:/:7{(:_:::<:_^8{j{}'p!Z/d&8!%+R%t% =C*:>W%&%#$D+C$[:0#6/6(@&%'Y=F_}:1&E=B=v-2)D; ",
+" |:t~1:[,2:3:y,^/I(4:5:%:i_6:7:P//'8:Z>(>X>M%n+{@9$j#v%9&'-V!W!&*9:0:$$$$T&X#j#y$5$w%>&Q=*,f,f,a:4;f,+{b:*,T;p^0,c:B!d:~!z_e:7{A]f:g:K)I)q_f^h:#'h{U{N=])i:j:(^I]N(k:F{!!6{|~H^7*j#T$E+B%O%=&--H-K-<>t>l: ,(>^>H-O%.%t#~$v&{_I]S{m:n:o:M~p:q:r:g:k~J^7>7/#%k*n*s#l=s:C,t:S@7#g@R%R#@&R]t^G_{{r>x=r>w*z=3-p-B;u: ",
+" *'>'v:w:$:x:y:+^I(I(A{;:z:A:'~B:J'C:M;I-D:+%3$T$W#2%R=-=*=$*y>m$u#<#b#D+l+4$2%U%V%J**=4;X,W;M,p!p!8;4;*,i~L)#/0'E]!!!!E:e:p)x!x!h'k~5!A^i{o!E~N=d;F:X{T;%!G:<] )H:!!:~z_c'R'T%l+W&.% %=&J$O;X>^>(>`>I:Z>^>X>7-P%n%g@U%N=j{I]J:]!K:L:M:[~N:(^O:P:Q:F:y$R:i*%+K^`$S:o%8)2+9$I#P$u#P$6(Q]t^G=(=k/A=x='(2)y,T: ",
+" i>+~:,U:V:W:X:H_=:I(Y:Z:`:X:.^ <.<Z>W>]: %{@E+S@N#4$b&&*#*2%i$l+2#S@S@Y#X#l$y>5=7*N=+<7;K,e,%/T;+{f,4>W;W;j'c,&/b{t_{:!!:]@<x)#<U'*,n,o!R/i~f,j~^^U;K,K)S,3{r)$<<]':':|~h^v/%%7#3$N$[*=---]:K-M;:>u>%<^>^;O;M%o%Y$I#&<4>*<(^=<-<;<><,<'<)<!<])_*~<((<^Y= ( (}:L%{<S:`)--Z#+$<%t%*$9!]<L%^<I;A=f=2-k/*>*> ",
+" /<(<_<_<:< /<<c^C~h([<}<|<1<.<2<`>N;H-:*7++%6+S@4#@$X#D#4#3#2#<#S@<#2#&$v%$=j~N*2;2>2'K)3<S,q'V!Q-9;}'z)_/3~]~4<t_::!!C]c'~^@)G^4>j~Q=U;p!f,^^h{K,5'O,5</!+)^]N~f'=!2{#)'-u%R%E+*%M%];W>W>M;(>:>(>M;^;--2&&&B%O$#$M)I)J]6<7<8<9<7<0<a<b<h{c<4!T/I=:=.-y=C=.-X*`/d<C,w{,+W%n+@%D$%&}:e<f<u*f='(g<p-[,h< ",
+" <,Q)#:_<_<i<A{Y:y:j<k<l<m<y~B:n<Z>_>H-=&L.K.7+E+)#3#3#3#!#&+E+o+&+<#R#&$.*T%R=M*W;H^T'z)o<h'p!0;|'s/9,V,V,g^t!:(z!r)p<:]]!h^G^6'f,5~q<Q-4;N_Y{U;3<#/0,r<g]s</_/_>!X'&!L)Q=U%N#@%p%M%H-W>M;M;t<:>M;K-H-M%p%p%o%w#5$@{u<v<w<'<x<y<y<z<)<A<c]B<Q]C<Y^A=A=A=A=A=y^I;D<n&8)<>.%e&B%*$E<F<y*G<^=k/2-w-$:H< ",
+" I<J<K<D(L<_<>(x:M<N<O<P<m<a)(' ,Q<_>I-^&:*>+7+S+E+r+S+S+E+&+S+5+S+=#4#R<$%y>)-3=W;,^,^A)}'W;h,m=0;h,M,5'W,h'V'=!f'>!f'<~S<0'3<5~E~4;&{%=g,7!L{3~k{S,h'a,(~g'T<_~f'/(s<U<~)v&&$P$:*^%J-^>H'(>:>`)^>^;--=&N$<%<%g@*/V<W<X<Y<Z<`< [Y<.[+[@[#[o*y=A=M/k/B=k/B=B=k/A=F= (j!-~K-7%/&n+G-v*U>.-x=B=$[&>{, ",
+" <,''d(%[L<&[Y:*[=[-[;[m!a)9)D,Q<_><;h*/&L.,+7+S+E+7+6+4+q+S+*+=#)#3#D#B$2%b-L*m=0;3;*,X;V!|'-=|'m=h,>[e,_/V'%).{l)h)/!c'I]4',[7!N*N=%*N*N*q'5'e,%/3<0'.{=!'[6{_]7{p)h^h,$'W#3$U&G-^;Y>(>(>t<D~W>7-M%{;N$D$z^d&U{)[X<![Y<~[{[][^[/[([_[:[y^H;B=A=A=A=f=A=k/f=B=z=G=I'<[J'J$3&e&];r]^=+-2)u-->m> ",
+" [[+~}[){|[1[&[2[3[4[5[m<a)@!:'u>Y_<;h*/&K.6+5+5+r+S@*+o+5+7+r+=#2#N#W#4$'&#*6*Q;Q;Q;a*-=-=L*R-a*|'0;U;H~6'Q,t![]b'6[T;7;9;0;f^u&$'W{-=P=c*e,2>V!5'Q,5<x)l)7[G{(::]8[[/-=&*X#w#Q%G-^;^>(>D~8)(>W>2&O%C*<%9$6$=/9[0[a[b[c[d[e[([f[g[ [h[Z]B=B=A=A=A=f=A=f=i[>;3-A=.-'*9^j[^;=&=&J-l/x=;;g<z;e( ",
+" /<t~k[:<l[U:m[n[o[6:p[m<b)'~u>N;<;h*e&,+C@r+&+o+r+o+=#)#)#)#2#K#N#v$|%'&b&,&8&J*%*['N*N=Q-O*a**=*,f,)~h~T'</u/v!(/2>q[R-9&M*>&U%;&Q;6>,-T;f,E~,^</i'r[v!s[t[E:u[c'U;9&U%#$*$P%];X>^>(>:>D~^>J-2&P%p%*$7/R&T{v[w[x[c[c[y[z[A[B[C[D[U>f=E[A=A=A=A=A=f=>;k/F[G[B=A=H[>_l!8)B%-&V>0^f=q-X^I[o- ",
+" o>J[d(K[i<L[M[N[O[z:|<+!P[M't>(;O;=&>+7+E+o+o+<#)#=#*+*+M#2#4#{$B$j$'&,&$=>&{)%=r!M*O*M*-=R-b**=U;W;i,5'H^w)Q,P~M]u!%!3;v&t&$'t&;&9&0;Y{m=N=p!>^</k{x)=!x!}~l_Q[R[M,M)l#u#W%=&J-]>^>H'H'./V>G-Q%Q%4&-&k&:[S[T[U[x[A[V[W[X[Y[H)Y[Z['(4-A=A=A=A=A=k/f=>;F[k/k/B=H;b=W*`]l!G_d<C,k_u-=>W:`[ ",
+" #: }.}|[+}@}#}=[`:$}+!m<%}C:X>^&*%6+t#S@{#)#)#d#2#3#3#3#3#4#|>5*V=E&E&#*n=)-9&)-0*Q-m=3=L*D{U;K)]^g^U,U'i)&!&}%)*}n)Z_%*v%w%U%u&{)P=Z/V!d*h,,^7'6'x) )<]*^=}x!%)6!Z/l$I#B%&&];V>Y>Z)Y>5,];~*P%N$-};}>},}'})}!}~}{}]}^}/}(}_}:}s>4-%]A=f=A=A=f=A=>;k/k/k/k/>;B=x=T><}`]G-4(p&k]t-*>[} ",
+" h<}}.}|}1}2}3}4}l<5[5}__8:/>-- %.%w#&+<#2#u#R#4#N#N#N#N#i#]$ *$%'&T%>&)-)-R=~-g-M*Q-P-A>8;2>U!i)W'b,S_t!6}]~%)](x! )l)h,u&w%)&y%n,Q=W!2;O*g,i~U;R,i)%)_(7}8}E]/(^:Q=)&~$K.&&];4)5,5,4)!;j=!*P%N$s%.:9}0}a}b}c}d}e}f}g}h}i}j}k}B=3->;f=A=A=A=M/f=G[F[k/k/k/G[B=A={{)>Z]D-l}q&M/A;m} ",
+" W^n}o}p}q}r}M[s}t}u}9)F,K-/&e&7+&+)#u#7#N#D#D#D#W#X#X#j#A$C&#*D&D&~-2=*=0;m=Q-Q-1;7;N,T'i'`{1~v}M]e{w}g']!q/x}O~d:m())J*y%U%y%v&*=P'$^O*N=0;:^R,U's!*}K:p<:]M:U'$^C&z^n%=&G-4,4)4)'*N&Q&]*2&P%6-y}z}A}B}A}C}^}f}e}d}X[e}D}c=4-F[k/f=A=A=M/f=G[k/k/k/k/k/G[B=A=E}w=z*z*x* (t-w,F} ",
+" G}H}I}J}K}r}L}M}$}___'_>H-:**%S+<#3#4#D#D#W##$X#&$i$l$v%**%*b*$*$*Q=Q-B>M,g^s!U'6'S;g^2/D!N}c'c';!,!d{n)O}P}V_Q}R}S}0]N=U%#'S%@*R-b*o!*=O*N=J)V,0,8{h^T}m_t_U}e,j~g&&$P$p%2&C,C,C,O&Q&N&)*D-~;V}W}X}Y}Z}`}~@ |X[j+.|+|@|._k/G[k/F[f=A=f=f=k/F[k/k/k/B=k/k/3-k/c=f=y*Y*T>W*[,#| ",
+" d($|%|&|3}*|`:u}:'`>W>=|p%.%S+=#3#W#X#X#X#X#o$4$u%C&R=2=V!h,A>i,3<U,3<6' ]5<]~c'b'l)-!E]<]<]:(-|;|2~m(>|Q}m_,|o^^!'|P'Z/O=)|{)W{g{9&g,4;V!3'k{c,5''^!|~|{|&/U;**5$W#u#<%P%!*C,]*B,q&A*x*]|{='*E_^|/|(|/|_|:|.|<|+|[|}|B-3-k/k/F[i[f=M/>;F[k/k/k/k/k/B=B=G[B=x=3-c=s>:=x-~{ ",
+" K<||K}1|3}2|3|0)D,(>H-M%p%{@+$I#3#7/C$j#j#i$l$u%$'$*O=m=T;L)0,4|u!&/4|R[](g'c'e'j(E!N~A]J~=}o_G{5|+),!':t_u[6|7|I]3/p!U;h{#'P=^^9-T!f-*,p!K)7'1{%!W'](8|>!9'g,>&o,6$$$&+r%%&I=]*)*x*9|c=r>w=:=0|a|b|c|c|d|e|f|g|h|i|d|Y^3-k/k/F[i[k/f=>;F[k/B=k/k/B=j|B=G[k/B=h_h=Y^y-c^ ",
+" k|l|m|1|3}n|o|B::>^>--O%e&+%P$2#U#D#m$5$z$1%C&>&%*L*4!5;R,/!p|^(Z'%)S/q|#<o_r||_'!O(r|l^5|r)^_H{:]U_':P_p<H:W_/:*<s|]_t|T!%*|]~)M)q^%*0;h,J)2]</V'W'u|w!]~c,0;W{w&5$A%C$U#B%]*A*x*{=c=w=_=y=A-B*v|w|c|x|y|z|d|A|B|f|C|F(3-k/k/F[k/i[>;F[k/B=k/B=B=j|B=B=0^>;3-g<w-E;;>D| ",
+" *>E|F|2}#}G|L'/'^>I-^%{;N$@%P$u#N##$j#l$w%y>{)Y{d*L*3;,^l):('!M(n(z__~:(f'n(G{(](]'['[^_::::H|^_d:!!(:':I|J|K|p:t|q_5'S{T!Z/~:7;P'e]4!4;$^${</0,V'r/x)g'l)V'W;d*$')&m$d&_*T$4&v*X*^=c=y=y=y=c=Y*9/a|B|B|L|M|N|O|P|Q|y*F(k/k/k/k/k/f=k/B=k/k/B=j|B=B=B=B='(f=p-;>2);>c^ ",
+" R|S|T|U|L}o|K':>I-h*=&e&.%W%S@z^l+C$5$z$v%>&c;M*R-|'2>x)#<M(V|(]H{~!d:E{O~r|(]-^W|K~k^X|m_o:B_A_L~t_t_,:W_Y|Z|`| 1.1+1@1~:#1g{R/6~Y{:^4>~<z)n^U'i)a'&!/!g'/!n^6~@,n,d&_*U%8!;}A*V*^=r>C=x=y=w=D=W)$1x|%1L|&1M|*1=1-1(=3-k/k/k/k/k/k/F[k/B=B=j|B=B=B=B=B=j|3-C;r-*>E(;1 ",
+" >1,1'1)1P[l:^>J-^%V&B%+%D$S@D+X#y$1%w%y%#'o!N*P=7;!1~1(~o_(]{1(:t_]1K~M~M(6{^1!!H{~!H{t_o:B_]1H{/1(1K:/:_1:1<1[1M,}1H^|1])Z/L)a,K,N=U;H^U,Q,V'W'w!`'w!-!*}*!}]w)T!!&11)|O]s#21)*V*31Z^y=r>A-A-B-415161M|z|y|7181914-3-k/k/k/k/F[F[B=B=j|j|B=B=B=B=B='(E[s-y,W:%>>> ",
+" 01a1b1c1B::>W>;-M%{;.%w#P$<#u##$5$v%v&$=9&J*9-d1e1o)E]j^f1)!:~~!t_t_A_L~H{E:!!K~~!~!(:A_::m_(:':g1h1i1j1;<k1x}l1l~`{5'k~i~M,E^*</^e,f,Q,5<5<5<u!*!A]<]:(J~l(_~x!I)7!])=/^*i]S:A*W*8^w=w=c=)>F=f!m1n1o1p1p1q1r1s10|'(B=k/B=k/k/B=k/B=j|B=B=B=B=B=B=B=B=p-H_W:m>A' ",
+" t1&|r(@!8:^>^;u1U&r%B%S+I#b#R%U#m$1%;&)-,-R-~)}'v1t)j^j^w1;^K~A_(:m_t_^_!!K~^_!!!!(:m_(:F{:~~!x1y1;<z1g1{[A1B1C1D1@'E1a,t/r_6!#)]!e{c,^~h^#/V,d{S<F1U_o_(]6{:~O_S}~<G1H1I1t^S:]*J1K1)>s>^=F=^=L1M1=1N1O1s181P1q1&~'(B=B=k/B=k/k/B=j|B=B=B=B=B=B=B='('(>(I[='R) ",
+" |}Q1R1B:(>W>];G-=&N$7+3$t%b#U#U#l+l$$'Z/b]-=I)e13{B!>!m(S1:~!!::::o:o:::~!::d:!!K~!!::t_T1^]s)O_O_p)p:U1m:V1a[W1X1r:Y10,J]&/7',^R[j^I^t)Z1_/</Z'(]5|`1M~::::t_(:!_ 2([c}.2K$k*O)]*!;x*W*f!Z*E}X*0|+2@2q171#2$2%2A-'(j|j|B=k/B=B=j|j|B=B=B=B=B=B='(B=,(|):,t'0! ",
+" ->&2b)*2(;7-3&2&[*B%@%P$9$S#g$$$$$.=7>o!V!5!L)x)l)]!d{O}=2t_K~::B_o:o:o:t_o:::H{K~K~E:(:*^l(q:s)*^J|<~-2;2>2~1,2N:Y1&/'2)28]`{%!t!#<x)f'V(Q,&/3{;^u_)_!2~|::t_]1~2{2]2^2f{/2N]m*9!(2`( (9/X)v*W)_2u=:2P|:2<2[2}2t{|2B=B=j|B=k/j|B=B=B=B=B=B=3-B=B=,(12r~<)22 ",
+" 32429)M;^;=-O%*%U&p%2+3$9$D+%+8!z$y$m$U%m=52n^I]t!62Y'p)72::K~!!82o:o:o:o:o:m_~!:~6{(]p<R}-|,!E]9202-2a2b2/:c2d2e2f2o)g28]w}Y1V'x) )0]*!h2P(d{a,i2z_K|I|::(:(:s_!!/]:1j2k2l2i*J.6/m2{<s^n28/T*o2u=p2P|q1q2r2s2t2z-B=B=B=j|B=B=j|B=B=B=B=4-|2j|0^x;`!{/v' ",
+" <{u2I:W>J-^%M%B%@%{@+%*$s%H#g@U#c&y%A%C$9-w)v2I]F]V(Y'>|H{K~:~:~(:o:m_o:m_o:o:A_p<w2z_O~ )f18[d{ 2x2y2z2A2B2C2;<D2>|E2F2Y'V(/^_^0'p)h^j:]!&/3~W'-2_(G2_](:s_~!(:!!!!Q[V1H2I20#o*)=Q#6/Z[J2K28/L2M2#2p1%2N2O2P2h<%]B=4-B=j|B=B=B=B=B=B=4-|24-3-&>Y]F/Q2 ",
+" R2S2y{5)^;];2&&&Q%K=<%s%P$P$P$M$b##%/*_*y$i{j'n^I]i^;2~1M:u__]:]6{H{m_t_m_::_:m_:~r);|O~E]c2T2_^b2B<;2U2>2~1V2g1y<W2-2M:X2%)Y2l)p)x)0]Z2(^`2q_ 3o^W2.3b{O_(:s_~!~!s_~!H{+3@3#3N]$30#%3;*&3*3=3d|-3q171p2;3>3O2,3'3~{3-j|B=B=B=B=B=B=4-B=4-3-w-N>)3,{O^ ",
+" m!,~=~W>];G-^%&&B%n%w#s%9$9$!3t%H#D+z$v&U%[{~3{3*<D!N:/:G2]3)!_]_]H{V_o:o:V_m_M~}~^3>|Y'L]X1d2/3t|(3f{_3:3<3W2N:[3q:}3f1V2B!s|Q_M:|3U{(^r:L{!1I]13K|G2236{H{::~!~!(:`1~!l_334353=/6373839303a3Q|b3c3%2%2o-d3o-t{e3f3F;B=4-B=B=B=4-0^j|4-'(g3u'h3i3 ",
+" 7:j37)V>];G-&&4&:*+%P$S#U#C$C$U#~$R%L(7!@{F!&{R/j{S{S}}]W2k3.3u_l3l_]1::H|m3A_n3o3y1p3/3q3Y2U2r3_[s3t3u3v3<1w3x3y3><z3A3x<B3u<Y1b2)|I]3/C3(^'2}1o^y1T2D3-2^_A_~!!!(:~!(:F{E3F3G3y/f{/3H3I3J3K3L3/|p1O1M3N3O3P3>>Q3R32-4-B=3-j|B=B=G;F(*;w,V^J_S3 ",
+" L_i_=~G'4,G-2&&&P%P%O%p%{@I#l+4%j#z^R%c&P'T3R/J^@1U3B<k1=<]!~1V3]3M:W3H{F{X3}~Y3B1Z3Y2`3 4.4+4+4:3U2U2g2/3@4#4A2$4%4i1a<)[+[&4*4G3Z-s|c]`3_!=4-4;4F]7<_^0[W1>4P_/]H{H{!!H{k^u_C^,4'4d])4!4~4{4]4Q|61^4/4$2(4_4|:;>:4<4K_q>3-B=B=B=3-E;$:r~x^L> ",
+" a^m!j!^;C,2&2&&&=&P%p%Q%[4%-S:z^@@g@f$A%9&@,~3/3i~6<}4V2|414G:24;<y1]334n344546474`|842_|4T{~394U204]2a4&4b4]2><c4d4}4e4,2f4y[g4h4+[C1i4v2b2H!Y2j4k4W2l4m4n4o4p4q4+34<)!z!r4V|s4_(t4u4v4w4x4y4z4A4x|B4C4M3A,D4E4s-F4G4-'H4q>x-!'I41[+~p]4^J4 ",
+" K49^Y)C,L4%&M%&&P%Q%N$r& =;};}D$M$t%i]d&i{h{M4@{j4w[w[N4O414'<;2P4Q4R4S4I|I|0<64Y1}1~:94~3U2V1C3T4V2j4U4V1<1x<b<y<V4)4`|W4H3%4X4Y4Z4`4(3'4 5@3u4j%A2H!.5+5b4+5o4@5n4#5P4q4s)$5J|Q{J:Y<%5&5*5=5h|z|p1%2f!$2y-<4-5D;%>;5>5x,k>M>''r~x^W]E/ ",
+" ;[{=A*p&!*2&2&&&&&P%C**$s%s%s%P$H#9$S#,5'5h{f{U2)5!5r3~5{5]5,2,2z1u3x}^5/5V1-4(5_5{_:5<5C3a,f{R]+[[5%3a2}5|5#5{5><1525f~35}545C155R]@[@47(657585A<v495a2%405a505x<V4b<;2b5-2q4c5$4%4d5h}a3e5L3z4,*P1f5g5h5E;-;i5[[y,j5;'()q{k5Y]U^,'l5 ",
+" B-:{U*A*N&I=p&%&&&P%=&O%r&3$s%P$O$S#0:k&5/i{m5f{n5o5p5q5r5s5t5u5:3y2)2$4p4U1>27<-4j{v5w5x5y5z5T*A5B5R]w[C5A<D5e[b<E5F5V2T[:3G565{5H5I5J5M^K5L5R]M5N5O5u425L5P5Q5d[R5+[S5T5U59</[V5Y<W5X5J3z4g|:2x|A-P1Y5Z5`5 6o>.6+6@6v,u'a!r{p]g/#6 ",
+" $6]/y*{*Q&L&N&q&<=4&Q%4&[4%6k=s%&6s#k*%+*6/2e]M4((q3=6b2-6][-6<30[;6s5)<>6,6'6C1u4x3l26/)6X<)*!6~6u({6t5]6^6/6a5(6f~b4_6:6<6Z[[6}6|6u5s3162636Y=46A}5666!}768696B[06<3^[a6/}b6c6e}d6:|e6f6A|n1g6h6C=M3i6->j6k6&>i>B'@~3^3^$]5^Q)l6 ",
+" 0|N<s>A*I=B,n&]*q&]*o&N&n&o&4&Q%V}9!>}k+k*0#63^^f{m6n6a<![+[e[<3A355Q5>2J505o6r5p6q6r6B,<6x[)*s6t6M5/2{5S[o5u6:6x<v6q6w6w6s5u^65,){*x6_}z*y6z6'*A6@4B6e6B)C6I3B|.|D6E6x[F6G6e6H6d}I6w6B)D}$1O|#-J6(4~{#|K6E(L6M6N6I[~,u,''r{4^O6 ",
+" f=;:)>{*T*X)P6]*]*{*{*4&n&N&%&4&%--&d<n*k*Q#*6V{Q6m565R6v[S6T6m4U6g4V6Q5W625m4X6C[![v*Y6N5Z6]<`6 7.7+7@7#7P5,)L5%5)[v4:%$7%7e>V6-/K5&7`(r'*7=78596+:8/X[8/-7d|J2;7>7d}D6I6,7'7)7!7~7K2I3F_u=b|(={7`[->]7^7|,[,/7(7s~p~_7{/r{:7 ",
+" 4-X:V*q&T*~'Q&q&%&j=)*!*%&Q&B,%-<7%-G*m2i]Q#)=;*M5[7U2l4 4`<N5N4Q_}4b4N5J5}7H1a4}4|717f[-*q&1545J127B[M^x[![37W6H)47955767 (7787q&9707c=C}a7y=b7<|y=c7d7I=h|e7;7@|*3f7*5g7h7i7f}j7k7l7O|/=u=N3m7n7o7*>h>p7q7%~='[)q~p]4^.( ",
+" r7u]v*I=T*T*]*q&'*'*%&p&%&n&B,4&[4l}*{d<&6Q#56:[M5s7t7u7v7d[X1w7;6+[b4J5x7([y7J5B}}^@3z7c=57>2I=A7B7z/C7A[D7R5E7`<F7G7H7I7a7w4'*b7X[X*H=J7`*A-=5s*{{K7L2L7K3-3M7N7(|O7K3P7d7Q7/|R7E}S7T7'(%;U7r-V7W7O6c^P)X7()3^$]U^Y7 ",
+" Z70^`*I=I=T*I='*v*v*v*`7)* 84&N&N&F<G*O).86(.$s7+8<&M5f4@8#8$8v<f~H7V4%8&8c|H2*8q&!4([^==8-8A7A*76Y6;8A[W5>8U[,846.8'8A6w**5k7c=:|)8k/!8-7C=9/~8E}9/A|X*{8n1,*M3]8h6^8/8P1O2r2(8h<,;(8u:z,|:22_8O6:8<8/,u's~'{Y]4^[8 ",
+" g(e=W)I=X)X)'*A*y*x*W*Y*5,z*!;%&4&N&F<`(G_}8R:|8`},}18283848G177x[58+[68}678V5F_8898[=c=08y6E=*3a8F_b8c8X[d8z7e8f8u^g8v*85&5x*q&+|`*r>h8i80^C|j8k/_2k8h=h<l8m8e3D4{7'3n8o8p8q8'3r8i6l8s8s-V7t8{,u8j/[)s~s~q{q{,' ",
+" S>{{y*y*B*B*y*+_x*V*W*W*V*x*V*x*D-'*p&N&]*`(R])8.$v8K$B}W<48w8x8G696B[y8A/e}z84)96&3x=-/A8`/u*:}B8._F6)}'7B)C8D8c=E8/|(=F8G8A=g6N7Y^F=c3g5F(H80!2-u:I8'>m8J8D4K88(L8M8N8O8'3n8v^N86_P8Q8N6|,R8S8w'u'()#~T^r~S3 ",
+" E;x:);T8G=Z*B-);X*W*W*V*X*{=I'{{{=V*v*'*!*'*]*85L%]<O5r'U80}b}*3V8X[g}X[Y}e7y4N&W8X8H[z-Y8@8(=s*Z8W*/|`8I> 9-/M7L29|.9T7y=d|$1y^L7+9q>(=q8@9w-#9l8w-D=$9e!%9#9D|K8&9*9=9-9;9>9=9i5,9'9)9!9~9{9Q>()d!q~p]W]]9 ",
+" >>n>F=(4`*);]=E=b=^=i={={{:=)>{=W*x*v*A*A*'*G=B*H=41}:v|^9/9e>(9*5_9:9g|<9z703X*J3h8M/[9X8 (y^=1}9:=|9B|19O79/O|Y*29A|F=@-&1:=A=N239g<4-'349p-D|0!m76_59D;697989,99909a9b9b9t8c909d9e9C/f9l]g9S),{T^()h9 ",
+" i9y,/=Y5y*);A-w=+-A=z=(=w=:={{{=I'C<x*Y*U>y*q&7(H=G=H=T*}:j9k9)8I3d}19l9W8m9(2 (d}413-i8d|x=y^J6n929z4&1o9}:8/p9e=q9=14-A-r9G;;;l{s9q-2-m8i6r-t9u9&;v9w9]7=_x9y9z9A9B9c9C9D9E9F9E9G9H9@]S)'{$]I9G/J9 ",
+" E'y,B=g5E});@-c=x=4-2)2)u-2)B=]/Y^]/v=^=W*Y*'*41K9F<K9L9 (`/._K2<|g|M9[|w|f|w=<9_|z=y-M2h6B=z=r141j8L|x|N|@-N9O9F;P9Q9D;>>R9E;s{S9T9U9=;V9W9y;X9Y9h9{,Z9`9 0.009+0+0@0E9#0$0|^m]2^U]$]'/C(V^[)%0 ",
+" T:H_H;e!A=x=e=.-w=(=M/x-x-z,s{p-2-'(A=(=C=r>D=L1B-Z*C-`*G=*~K991b|*1L|&0q1&0Y^j80='(_=*0o2F(e=s1n9P11-=0-0E'`[i5;0>0:4&;n>:4%0z;l5x9 0>(,0'0)0g>!0~0{0p>]0^0+6/0(0/7S8P^_0S)@~p~d/H/#_@]:0 ",
+" <0D'D;7^e!!'-;p-w-2)3-k/x-w-2)q>2-F;B=A=f=g=_=_=,;A-]=@-g5L1B-[0}0|0N1M1<2G<x=*0u~10v=20E};;e=h<3040506070v9v9i5l6],V9<4*>l580Q2{,{090;5{,{0G9Y7},.600a0;'l]b0|^,/,/l]@]2^@~X]T^*(c0l{ ",
+" M>[[d0w-->],&>[,m>l>3:n>K4z,w-p-e0F;f=7^_=t{f0h=f05-30D=A,F'g0^881h0[0=0Y5v=c3i0F(h=r849g<w-J4j0#9k0l0m0n0[8o080p>L6'0%~p0q0r0s0k>t0^7%~L>u0~9|^,'@]l]l],'B'={={2^n~$]'/U^x^c!v0 ",
+" ){D'&;->z;x;w0*>x0m>N>j/$:&>->n>->&;-;4-e=,;_=@9,;303030y0z0A0d3%2+2$>t2g5/=O2G;2)2)B069;>;>2259%0C0=_{0'0!0!9(0H9D0/7E0F0j/!9#0a0!,G0l]y'@]@]m]x'@]={x'U]s~s~p~X]H0h/s~;'I0 ",
+" @6q,w,N>k>3:],1)D;q-z;<,O>O>i>[[y;y; 0->>>@97^J0K0@9t9,;30i0L0M0N0O0i6n8S9P0J4k6X^D;k6Q0[[C;[}c9G4q7~9G0R0m]={|^|^|^|^S8S0|^={={2^x'>/2^x'T0={U]()U]s~p~q~q{X]4^h/0(F4 ",
+" -0U0*'q,z'|)C'k>V0%>->x;N6O>L>h>v9v9y;.(l5W0X0Y0X0Z0`0 a.a:4+a@aN840f3`5#a->$a%af(;>w0&a*aO>x,|^|^l]T0={m]2^>/@]c/m]=aS)S)2^1^m]U]x'-{[)U]s~p~p~q{q{$]-aT^E/s~B'V9 ",
+" r,})A'u'})<))';'/,J>+6-'P>P>O>,0I_;aQ2p,k6l0Z0`9x9:8D9&ac9W7Q3@aR9#a>a,ad0'at890i>%>i>)ay'={x'y'x'U]!aS)@~~ap~'{X]'{p~@~@~p~q{'{$]E/E/E/p]'/~/I/I/x^;'{0 ",
+" F}e_s~})/)<)()B'@]v')a!,r,J>f9C/,0Z9{a.6]aa9z9^aQ0/aw9]9$ao0-5(a-9i5_a:4:a&>s,T0T]l]r,x,J>m]U]()`!'{p~'{'{p~q{X]d/4^'/x(x(#(#(T^'/x^+(H/B(p]<a[a ",
+" P)`!a!c!-{()y'x','w'v,v'@]l]}au0<8.6|a1a]a2ac9y93a4a&aD9:8995aB96a]0D9^7{9C'j/;','()#~s~q~q~'{p~@~q~q{$]E/d/'/'/'/x(T^U^7aG/I/'/()#~{a ",
+" l{W]a!a!8a()2^y'm{z'w'@]Q^l]S8/7>59a'02a]a]a2a@0]aG9^70a9ae9|aE9~0E9(0aa)a@]S^<)s~p~p~q~'{_7p]p]4^4^d/'/x(T^#(#()/!/$_q~L6F422 ",
+" u9bas~#~()D/u'B'x'@]@]@]v'S8/7caM6D92a]ada2a2aeaC9fa0a(0cagahaca(0q0@]ia[)s~'{q{q{X]w^bax(T^'/x^)/!/e/)/$(H/d/Y7#6 ",
+" l{)'o]#~2^y'B'x'={w'@]@])a|^S0ja0ae9G9F9E9ka(0>5la,/T0={iamap~naE/oap]X]$]p]x^#(+(e/h/paqa$(x^q~={{0h9 ",
+" raT^E/@~@~#~U]m]x'={@]|^E0sataq7ua#0vaq7~9wa/7S8xaS)p~'{X]d/'/x(U^e/yayazaAaBaU^{9CaDa ",
+" h9X]'{X]X]'{'{p~S)U]1^xaE0$0r0~9u0E0R0R0@]EaX]E/p]4^#(e/g/G/G/e/h/FaGa#aHa ",
+" IaS8+]h/U^'/'/p]E/X]'{S)2^U]S)S)#~p~$]p]4^U^ya%($_s~v''{Ja ",
+" Ka$aB'y'G/La$(H/H/)/#()/!/!/g/I/0(B(@6+]Ma:7 "};
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/colourimageprocessing/mitkColourImageProcessor.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/colourimageprocessing/mitkColourImageProcessor.cpp
index 9d2e7aeacc..a7bd01b10c 100644
--- a/Plugins/org.mitk.gui.qt.examples/src/internal/colourimageprocessing/mitkColourImageProcessor.cpp
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/colourimageprocessing/mitkColourImageProcessor.cpp
@@ -1,979 +1,979 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkColourImageProcessor.h"
#include <mitkImage.h>
#include <itkImage.h>
#include <mitkImageCast.h>
namespace mitk
{
mitkColourImageProcessor::mitkColourImageProcessor()
{
}
mitkColourImageProcessor::~mitkColourImageProcessor()
{
}
template <class T> class ScalarToRGBAConverter
{
const T *dataPtr;
unsigned char *tmpPtr;
int sizeX;
int sizeY;
int sizeZ;
int sizeXY;
int sizeXm1;
int sizeYm1;
int sizeZm1;
mitk::TransferFunction::Pointer tf;
public:
ScalarToRGBAConverter( const T *_dataPtr,unsigned char *_tmpPtr,int _sizeX,int _sizeY,int _sizeZ,mitk::TransferFunction::Pointer _tf )
{
dataPtr=_dataPtr;
tmpPtr=_tmpPtr;
sizeX=_sizeX;
sizeY=_sizeY;
sizeZ=_sizeZ;
sizeXY=sizeX*sizeY;
sizeXm1=sizeX-1;
sizeYm1=sizeY-1;
sizeZm1=sizeZ-1;
tf=_tf;
}
inline float sample(int x,int y,int z)
{
return float(dataPtr[ x + y * sizeX + z * sizeXY ]);
}
inline int clamp(int x)
{
if(x<0) x=0; else if(x>255) x=255;
return x;
}
inline void write(int x,int y,int z,float grayValue,float gx,float gy,float gz)
{
/*
gx /= aspect[0];
gy /= aspect[1];
gz /= aspect[2];
*/
// Compute the gradient magnitude
float t = sqrtf( gx*gx + gy*gy + gz*gz );
int doff = x + y * sizeX + z * sizeXY;
vtkPiecewiseFunction* opacityTransferFunction = tf->GetScalarOpacityFunction();
vtkPiecewiseFunction* gradientTransferFunction = tf->GetGradientOpacityFunction();
vtkColorTransferFunction* colorTransferFunction = tf->GetColorTransferFunction();
double rgb[3];
colorTransferFunction->GetColor( double(grayValue), rgb);
double opacity= opacityTransferFunction->GetValue( double(grayValue) );
opacity *= gradientTransferFunction->GetValue( double(0.5f*t) );
tmpPtr[doff*4+0] = int( rgb[0]*255 + 0.5 );
tmpPtr[doff*4+1] = int( rgb[1]*255 + 0.5 );
tmpPtr[doff*4+2] = int( rgb[2]*255 + 0.5 );
tmpPtr[doff*4+3] = int( opacity*255 + 0.5 );
}
inline void compute(int x,int y,int z)
{
float grayValue = sample(x,y,z);
float gx,gy,gz;
gx = sample(x+1,y,z) - sample(x-1,y,z);
gy = sample(x,y+1,z) - sample(x,y-1,z);
gz = sample(x,y,z+1) - sample(x,y,z-1);
write( x, y, z, grayValue, gx, gy, gz );
}
inline void computeClamp(int x,int y,int z)
{
float grayValue = sample(x,y,z);
float gx,gy,gz;
if(x==0) gx = 2.0f * ( sample(x+1,y,z) - grayValue );
else if(x==sizeXm1) gx = 2.0f * ( grayValue - sample(x-1,y,z) );
else gx = sample(x+1,y,z) - sample(x-1,y,z);
if(y==0) gy = 2.0f * ( sample(x,y+1,z) - grayValue );
else if(y==sizeYm1) gy = 2.0f * ( grayValue - sample(x,y-1,z) );
else gy = sample(x,y+1,z) - sample(x,y-1,z);
if(z==0) gz = 2.0f * ( sample(x,y,z+1) - grayValue );
else if(z==sizeZm1) gz = 2.0f * ( grayValue - sample(x,y,z-1) );
else gz = sample(x,y,z+1) - sample(x,y,z-1);
write( x, y, z, grayValue, gx, gy, gz );
}
inline void compute1D(int y,int z)
{
int x;
x=0;
computeClamp(x,y,z);
x++;
while(x<sizeX-1)
{
compute(x,y,z);
x++;
}
if(x<sizeX)
{
computeClamp(x,y,z);
x++;
}
}
inline void computeClamp1D(int y,int z)
{
int x;
x=0;
while(x<sizeX)
{
computeClamp(x,y,z);
x++;
}
}
inline void computeClamp2D(int z)
{
int y;
y=0;
while(y<sizeY)
{
computeClamp1D(y,z);
y++;
}
}
inline void compute2D(int z)
{
int y;
y=0;
computeClamp1D(y,z);
y++;
while(y<sizeY-1)
{
compute1D(y,z);
y++;
}
if(y<sizeY)
{
computeClamp1D(y,z);
y++;
}
}
inline void fillSlices()
{
int z;
for(z=0;z<sizeZ;z++)
{
if(z==0 || z==sizeZ-1)
computeClamp2D(z);
else
compute2D(z);
}
}
};
template<class TType> mitk::Image::Pointer mitkColourImageProcessor::ScalarToRGBA( itk::Image<TType, 3>* input , mitk::TransferFunction::Pointer tf)
{
const TType *inputData=input->GetBufferPointer();
typename itk::Image<TType, 3>::SizeType ioSize = input->GetLargestPossibleRegion().GetSize();
MITK_INFO << "size input image: " << ioSize[0] << ", " << ioSize[1] << ", " << ioSize[2];
MITK_INFO << "size voxel: " << ioSize[0] * ioSize[1] * ioSize[2];
int voxel = ioSize[0] * ioSize[1] * ioSize[2];
unsigned char* RGBABuffer = new unsigned char[4*voxel];
// Convert volume
{
ScalarToRGBAConverter<TType> strc(inputData,RGBABuffer,ioSize[0],ioSize[1],ioSize[2],tf);
strc.fillSlices();
}
// Create MITK Image out of the raw data
{
mitk::Image::Pointer image = mitk::Image::New();
unsigned int dimensions[ 3 ];
dimensions[ 0 ] = ioSize[0];
dimensions[ 1 ] = ioSize[1];
dimensions[ 2 ] = ioSize[2];
mitk::PixelType pixelType( MakePixelType<RGBAImage>() );
image->Initialize( pixelType, 3, dimensions );
image->SetImportChannel( RGBABuffer, 0, Image::ManageMemory );
return image;
}
}
mitk::Image::Pointer mitkColourImageProcessor::convertToRGBAImage( mitk::Image::Pointer mitkInput , mitk::TransferFunction::Pointer tf )
{
MITK_INFO << "convertToRGBAImage" ;
mitk::Image::Pointer mitkResult= mitk::Image::New();
- if (mitkInput->GetPixelType().GetTypeId() == typeid(unsigned char))
+ if (mitkInput->GetPixelType().GetComponentType() == itk::ImageIOBase::CHAR)
{
//cast to itkImage
itk::Image< unsigned char, 3 >::Pointer itkInput;
mitk::CastToItkImage(mitkInput,itkInput);
mitkResult = ScalarToRGBA<unsigned char>(itkInput, tf);
}
- else if (mitkInput->GetPixelType().GetTypeId() == typeid(short))
+ else if (mitkInput->GetPixelType().GetComponentType() == itk::ImageIOBase::SHORT)
{
//cast to itkImage
itk::Image< short, 3 >::Pointer itkInput;
mitk::CastToItkImage(mitkInput,itkInput);
mitkResult = ScalarToRGBA<short>(itkInput, tf);
}
else
{
MITK_ERROR << "unsupported pixel type";
return NULL;
}
mitkResult->SetSpacing( mitkInput->GetGeometry()->GetSpacing() );
return mitkResult;
}
template <class T,class B>
class ScalarBinaryToRGBAConverter
{
const T *dataPtr;
const B *data2Ptr;
unsigned char *tmpPtr;
int sizeX;
int sizeY;
int sizeZ;
int sizeXY;
int sizeXm1;
int sizeYm1;
int sizeZm1;
mitk::TransferFunction::Pointer tf;
public:
ScalarBinaryToRGBAConverter( const T *_dataPtr,const B *_data2Ptr,unsigned char *_tmpPtr,int _sizeX,int _sizeY,int _sizeZ,mitk::TransferFunction::Pointer _tf )
{
dataPtr=_dataPtr;
data2Ptr=_data2Ptr;
tmpPtr=_tmpPtr;
sizeX=_sizeX;
sizeY=_sizeY;
sizeZ=_sizeZ;
sizeXY=sizeX*sizeY;
sizeXm1=sizeX-1;
sizeYm1=sizeY-1;
sizeZm1=sizeZ-1;
tf=_tf;
}
inline float sample(int x,int y,int z)
{
return float(dataPtr[ x + y * sizeX + z * sizeXY ]);
}
inline bool sampleBinary(int x,int y,int z)
{
return data2Ptr[ x + y * sizeX + z * sizeXY ];
}
inline int clamp(int x)
{
if(x<0) x=0; else if(x>255) x=255;
return x;
}
inline void write(int x,int y,int z,float grayValue,float gx,float gy,float gz)
{
if(sampleBinary(x,y,z))
{
/*
gx /= aspect[0];
gy /= aspect[1];
gz /= aspect[2];
*/
// Compute the gradient magnitude
float t = sqrtf( gx*gx + gy*gy + gz*gz );
int doff = x + y * sizeX + z * sizeXY;
vtkPiecewiseFunction* opacityTransferFunction = tf->GetScalarOpacityFunction();
vtkPiecewiseFunction* gradientTransferFunction = tf->GetGradientOpacityFunction();
vtkColorTransferFunction* colorTransferFunction = tf->GetColorTransferFunction();
double rgb[3];
colorTransferFunction->GetColor( double(grayValue), rgb);
double opacity= opacityTransferFunction->GetValue( double(grayValue) );
opacity *= gradientTransferFunction->GetValue( double(0.5f*t) );
tmpPtr[doff*4+0] = int( rgb[0]*255 + 0.5 );
tmpPtr[doff*4+1] = int( rgb[1]*255 + 0.5 );
tmpPtr[doff*4+2] = int( rgb[2]*255 + 0.5 );
tmpPtr[doff*4+3] = int( opacity*255 + 0.5 );
}
else
{
int doff = x + y * sizeX + z * sizeXY;
tmpPtr[doff*4+0] = 0;
tmpPtr[doff*4+1] = 0;
tmpPtr[doff*4+2] = 0;
tmpPtr[doff*4+3] = 0;
}
}
inline void compute(int x,int y,int z)
{
float grayValue = sample(x,y,z);
float gx,gy,gz;
gx = sample(x+1,y,z) - sample(x-1,y,z);
gy = sample(x,y+1,z) - sample(x,y-1,z);
gz = sample(x,y,z+1) - sample(x,y,z-1);
write( x, y, z, grayValue, gx, gy, gz );
}
inline void computeClamp(int x,int y,int z)
{
float grayValue = sample(x,y,z);
float gx,gy,gz;
if(x==0) gx = 2.0f * ( sample(x+1,y,z) - grayValue );
else if(x==sizeXm1) gx = 2.0f * ( grayValue - sample(x-1,y,z) );
else gx = sample(x+1,y,z) - sample(x-1,y,z);
if(y==0) gy = 2.0f * ( sample(x,y+1,z) - grayValue );
else if(y==sizeYm1) gy = 2.0f * ( grayValue - sample(x,y-1,z) );
else gy = sample(x,y+1,z) - sample(x,y-1,z);
if(z==0) gz = 2.0f * ( sample(x,y,z+1) - grayValue );
else if(z==sizeZm1) gz = 2.0f * ( grayValue - sample(x,y,z-1) );
else gz = sample(x,y,z+1) - sample(x,y,z-1);
write( x, y, z, grayValue, gx, gy, gz );
}
inline void compute1D(int y,int z)
{
int x;
x=0;
computeClamp(x,y,z);
x++;
while(x<sizeX-1)
{
compute(x,y,z);
x++;
}
if(x<sizeX)
{
computeClamp(x,y,z);
x++;
}
}
inline void computeClamp1D(int y,int z)
{
int x;
x=0;
while(x<sizeX)
{
computeClamp(x,y,z);
x++;
}
}
inline void computeClamp2D(int z)
{
int y;
y=0;
while(y<sizeY)
{
computeClamp1D(y,z);
y++;
}
}
inline void compute2D(int z)
{
int y;
y=0;
computeClamp1D(y,z);
y++;
while(y<sizeY-1)
{
compute1D(y,z);
y++;
}
if(y<sizeY)
{
computeClamp1D(y,z);
y++;
}
}
inline void fillSlices()
{
int z;
for(z=0;z<sizeZ;z++)
{
if(z==0 || z==sizeZ-1)
computeClamp2D(z);
else
compute2D(z);
}
}
};
template<class TType,class BType>
mitk::Image::Pointer mitkColourImageProcessor::ScalarAndBinaryToRGBA(itk::Image<TType, 3>* input ,itk::Image<BType, 3>* input2 , mitk::TransferFunction::Pointer tf)
{
const TType *inputData=input->GetBufferPointer();
const BType *input2Data=input2->GetBufferPointer();
typename itk::Image<TType, 3>::SizeType ioSize = input->GetLargestPossibleRegion().GetSize();
MITK_INFO << "size input image: " << ioSize[0] << ", " << ioSize[1] << ", " << ioSize[2];
MITK_INFO << "size voxel: " << ioSize[0] * ioSize[1] * ioSize[2];
int voxel= ioSize[0] * ioSize[1] * ioSize[2];
unsigned char* RGBABuffer = new unsigned char[4*voxel];
//for(int i=0;i<voxel;i++)
// Convert volume
{
ScalarBinaryToRGBAConverter<TType,BType> strc(inputData,input2Data,RGBABuffer,ioSize[0],ioSize[1],ioSize[2],tf);
strc.fillSlices();
}
// Create MITK Image out of the raw data
{
mitk::Image::Pointer image = mitk::Image::New();
unsigned int dimensions[ 3 ];
dimensions[ 0 ] = ioSize[0];
dimensions[ 1 ] = ioSize[1];
dimensions[ 2 ] = ioSize[2];
mitk::PixelType pixelType( MakePixelType<RGBAImage>() );
image->Initialize( pixelType, 3, dimensions );
image->SetImportChannel( RGBABuffer, 0, Image::ManageMemory );
return image;
}
}
mitk::Image::Pointer mitkColourImageProcessor::convertWithBinaryToRGBAImage( mitk::Image::Pointer input1 ,mitk::Image::Pointer input2 , mitk::TransferFunction::Pointer tf )
{
MITK_INFO << "convertWithBinaryToRGBAImage" ;
itk::Image< short, 3 >::Pointer inputCT;
itk::Image< unsigned char, 3 >::Pointer inputBinary;
- if (input1->GetPixelType().GetTypeId() == typeid(unsigned char) && input2->GetPixelType().GetTypeId() == typeid(short))
+ if (input1->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR && input2->GetPixelType().GetComponentType() == itk::ImageIOBase::SHORT)
{
mitk::CastToItkImage(input1,inputBinary);
mitk::CastToItkImage(input2,inputCT);
}
- else if (input1->GetPixelType().GetTypeId() == typeid(short) && input2->GetPixelType().GetTypeId() == typeid(unsigned char))
+ else if (input1->GetPixelType().GetComponentType() == itk::ImageIOBase::SHORT && input2->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR)
{
mitk::CastToItkImage(input1,inputCT);
mitk::CastToItkImage(input2,inputBinary);
}
else
{
MITK_ERROR << "unsupported pixel type";
return 0;
}
return ScalarAndBinaryToRGBA<short,unsigned char>(inputCT,inputBinary, tf);
}
//////////////////////////////////////////
template <class T,class B>
class ScalarBinaryColorToRGBAConverter
{
const T *dataPtr;
const B *data2Ptr;
unsigned char *tmpPtr;
int sizeX;
int sizeY;
int sizeZ;
int sizeXY;
int sizeXm1;
int sizeYm1;
int sizeZm1;
mitk::TransferFunction::Pointer tf;
int *color;
public:
ScalarBinaryColorToRGBAConverter( const T *_dataPtr,const B *_data2Ptr,unsigned char *_tmpPtr,int _sizeX,int _sizeY,int _sizeZ,mitk::TransferFunction::Pointer _tf ,int *_color)
{
dataPtr=_dataPtr;
data2Ptr=_data2Ptr;
tmpPtr=_tmpPtr;
sizeX=_sizeX;
sizeY=_sizeY;
sizeZ=_sizeZ;
sizeXY=sizeX*sizeY;
sizeXm1=sizeX-1;
sizeYm1=sizeY-1;
sizeZm1=sizeZ-1;
tf=_tf;
color = _color;
}
inline float sample(int x,int y,int z)
{
return float(dataPtr[ x + y * sizeX + z * sizeXY ]);
}
inline bool sampleBinary(int x,int y,int z)
{
return data2Ptr[ x + y * sizeX + z * sizeXY ];
}
inline int clamp(int x)
{
if(x<0) x=0; else if(x>255) x=255;
return x;
}
inline void write(int x,int y,int z,float grayValue,float gx,float gy,float gz)
{
if(sampleBinary(x,y,z))
{
/*
gx /= aspect[0];
gy /= aspect[1];
gz /= aspect[2];
*/
// Compute the gradient magnitude
float t = sqrtf( gx*gx + gy*gy + gz*gz );
int doff = x + y * sizeX + z * sizeXY;
vtkPiecewiseFunction* opacityTransferFunction = tf->GetScalarOpacityFunction();
vtkPiecewiseFunction* gradientTransferFunction = tf->GetGradientOpacityFunction();
vtkColorTransferFunction* colorTransferFunction = tf->GetColorTransferFunction();
double rgb[3];
colorTransferFunction->GetColor( double(grayValue), rgb);
double opacity= opacityTransferFunction->GetValue( double(grayValue) );
opacity *= gradientTransferFunction->GetValue( double(0.5f*t) );
tmpPtr[doff*4+0] = int( rgb[0]*255 + 0.5 );
tmpPtr[doff*4+1] = int( rgb[1]*255 + 0.5 );
tmpPtr[doff*4+2] = int( rgb[2]*255 + 0.5 );
tmpPtr[doff*4+3] = int( opacity*255 + 0.5 );
tmpPtr[doff*4+0] = color[0];
tmpPtr[doff*4+1] = color[1];
tmpPtr[doff*4+2] = color[2];
}
else
{
int doff = x + y * sizeX + z * sizeXY;
tmpPtr[doff*4+0] = 0;
tmpPtr[doff*4+1] = 0;
tmpPtr[doff*4+2] = 0;
tmpPtr[doff*4+3] = 0;
}
}
inline void compute(int x,int y,int z)
{
float grayValue = sample(x,y,z);
float gx,gy,gz;
gx = sample(x+1,y,z) - sample(x-1,y,z);
gy = sample(x,y+1,z) - sample(x,y-1,z);
gz = sample(x,y,z+1) - sample(x,y,z-1);
write( x, y, z, grayValue, gx, gy, gz );
}
inline void computeClamp(int x,int y,int z)
{
float grayValue = sample(x,y,z);
float gx,gy,gz;
if(x==0) gx = 2.0f * ( sample(x+1,y,z) - grayValue );
else if(x==sizeXm1) gx = 2.0f * ( grayValue - sample(x-1,y,z) );
else gx = sample(x+1,y,z) - sample(x-1,y,z);
if(y==0) gy = 2.0f * ( sample(x,y+1,z) - grayValue );
else if(y==sizeYm1) gy = 2.0f * ( grayValue - sample(x,y-1,z) );
else gy = sample(x,y+1,z) - sample(x,y-1,z);
if(z==0) gz = 2.0f * ( sample(x,y,z+1) - grayValue );
else if(z==sizeZm1) gz = 2.0f * ( grayValue - sample(x,y,z-1) );
else gz = sample(x,y,z+1) - sample(x,y,z-1);
write( x, y, z, grayValue, gx, gy, gz );
}
inline void compute1D(int y,int z)
{
int x;
x=0;
computeClamp(x,y,z);
x++;
while(x<sizeX-1)
{
compute(x,y,z);
x++;
}
if(x<sizeX)
{
computeClamp(x,y,z);
x++;
}
}
inline void computeClamp1D(int y,int z)
{
int x;
x=0;
while(x<sizeX)
{
computeClamp(x,y,z);
x++;
}
}
inline void computeClamp2D(int z)
{
int y;
y=0;
while(y<sizeY)
{
computeClamp1D(y,z);
y++;
}
}
inline void compute2D(int z)
{
int y;
y=0;
computeClamp1D(y,z);
y++;
while(y<sizeY-1)
{
compute1D(y,z);
y++;
}
if(y<sizeY)
{
computeClamp1D(y,z);
y++;
}
}
inline void fillSlices()
{
int z;
for(z=0;z<sizeZ;z++)
{
if(z==0 || z==sizeZ-1)
computeClamp2D(z);
else
compute2D(z);
}
}
};
template<class TType,class BType>
mitk::Image::Pointer mitkColourImageProcessor::ScalarAndBinaryAndColorToRGBA(itk::Image<TType, 3>* input ,itk::Image<BType, 3>* input2 , mitk::TransferFunction::Pointer tf, int * color)
{
const TType *inputData=input->GetBufferPointer();
const BType *input2Data=input2->GetBufferPointer();
typename itk::Image<TType, 3>::SizeType ioSize = input->GetLargestPossibleRegion().GetSize();
MITK_INFO << "size input image: " << ioSize[0] << ", " << ioSize[1] << ", " << ioSize[2];
MITK_INFO << "size voxel: " << ioSize[0] * ioSize[1] * ioSize[2];
int voxel= ioSize[0] * ioSize[1] * ioSize[2];
unsigned char* RGBABuffer = new unsigned char[4*voxel];
//for(int i=0;i<voxel;i++)
// Convert volume
{
ScalarBinaryColorToRGBAConverter<TType,BType> strc(inputData,input2Data,RGBABuffer,ioSize[0],ioSize[1],ioSize[2],tf,color);
strc.fillSlices();
}
// Create MITK Image out of the raw data
{
mitk::Image::Pointer image = mitk::Image::New();
unsigned int dimensions[ 3 ];
dimensions[ 0 ] = ioSize[0];
dimensions[ 1 ] = ioSize[1];
dimensions[ 2 ] = ioSize[2];
mitk::PixelType pixelType( MakePixelType<RGBAImage>() );
image->Initialize( pixelType, 3, dimensions );
image->SetImportChannel( RGBABuffer, 0, Image::ManageMemory );
return image;
}
}
mitk::Image::Pointer mitkColourImageProcessor::convertWithBinaryAndColorToRGBAImage( mitk::Image::Pointer input1 ,mitk::Image::Pointer input2 , mitk::TransferFunction::Pointer tf , int * color)
{
MITK_INFO << "convertWithBinaryToRGBAImage" ;
itk::Image< short, 3 >::Pointer inputCT;
itk::Image< unsigned char, 3 >::Pointer inputBinary;
- if (input1->GetPixelType().GetTypeId() == typeid(unsigned char) && input2->GetPixelType().GetTypeId() == typeid(short))
+ if (input1->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR && input2->GetPixelType().GetComponentType() == itk::ImageIOBase::SHORT)
{
mitk::CastToItkImage(input1,inputBinary);
mitk::CastToItkImage(input2,inputCT);
}
- else if (input1->GetPixelType().GetTypeId() == typeid(short) && input2->GetPixelType().GetTypeId() == typeid(unsigned char))
+ else if (input1->GetPixelType().GetComponentType() == itk::ImageIOBase::SHORT && input2->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR)
{
mitk::CastToItkImage(input1,inputCT);
mitk::CastToItkImage(input2,inputBinary);
}
else
{
MITK_ERROR << "unsupported pixel type";
return 0;
}
return ScalarAndBinaryAndColorToRGBA<short,unsigned char>(inputCT,inputBinary, tf,color);
}
static inline int clamp(int x)
{
if(x<0) x=0; else if(x>255) x=255;
return x;
}
mitk::Image::Pointer mitkColourImageProcessor::CombineRGBAImage( unsigned char* input ,unsigned char* input2, int sizeX,int sizeY,int sizeZ )
{
int voxel= sizeX*sizeY*sizeZ;
unsigned char* RGBABuffer = new unsigned char[4*voxel];
// Convert volume
{
for( int r=0;r<voxel;r++)
{
int rgbaInput1[4];
int rgbaInput2[4];
rgbaInput1[0]=input[r*4+0];
rgbaInput1[1]=input[r*4+1];
rgbaInput1[2]=input[r*4+2];
rgbaInput1[3]=input[r*4+3];
rgbaInput2[0]=input2[r*4+0];
rgbaInput2[1]=input2[r*4+1];
rgbaInput2[2]=input2[r*4+2];
rgbaInput2[3]=input2[r*4+3];
int result[4];
/*
float fac1 = rgbaInput1[3]/255.0f;
float fac2 = rgbaInput2[3]/255.0f;
float sum = fac1+fac2;
float cor = 1.0f;
if(sum > 1.0f)
cor = 1.0f/sum;
fac1 *= cor;
fac2 *= cor;
result[0]= clamp(int(fac1 * rgbaInput1[0] + fac2 * rgbaInput2[0] + 0.5f));
result[1]= clamp(int(fac1 * rgbaInput1[1] + fac2 * rgbaInput2[1] + 0.5f));
result[2]= clamp(int(fac1 * rgbaInput1[2] + fac2 * rgbaInput2[2] + 0.5f));
result[3]= clamp(int(fac1 * rgbaInput1[3] + fac2 * rgbaInput2[3] + 0.5f));
*/
if( rgbaInput1[3] )
{
result[0]= rgbaInput1[0];
result[1]= rgbaInput1[1];
result[2]= rgbaInput1[2];
result[3]= rgbaInput1[3];
}
else
{
result[0]= rgbaInput2[0];
result[1]= rgbaInput2[1];
result[2]= rgbaInput2[2];
result[3]= rgbaInput2[3];
}
RGBABuffer[r*4+0]= result[0];
RGBABuffer[r*4+1]= result[1];
RGBABuffer[r*4+2]= result[2];
RGBABuffer[r*4+3]= result[3];
}
}
// Create MITK Image out of the raw data
{
mitk::Image::Pointer image = mitk::Image::New();
unsigned int dimensions[ 3 ];
dimensions[ 0 ] = sizeX;
dimensions[ 1 ] = sizeY;
dimensions[ 2 ] = sizeZ;
mitk::PixelType pixelType( MakePixelType<RGBAImage>() );
image->Initialize( pixelType, 3, dimensions );
image->SetImportChannel( RGBABuffer, 0, Image::ManageMemory );
return image;
}
}
mitk::Image::Pointer mitkColourImageProcessor::combineRGBAImage( mitk::Image::Pointer input1 , mitk::Image::Pointer input2)
{
RGBAImage::Pointer itk1,itk2;
unsigned char *data1=(unsigned char *)input1->GetData();
unsigned char *data2=(unsigned char *)input2->GetData();
unsigned int *dim = input1->GetDimensions();
return CombineRGBAImage(data1,data2,dim[0],dim[1],dim[2]);
}
}//end namespace mitk
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/mitkPluginActivator.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/mitkPluginActivator.cpp
index 4357e93330..7c4b40697a 100644
--- a/Plugins/org.mitk.gui.qt.examples/src/internal/mitkPluginActivator.cpp
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/mitkPluginActivator.cpp
@@ -1,48 +1,50 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPluginActivator.h"
#include <QtPlugin>
#include "src/internal/colourimageprocessing/QmitkColourImageProcessingView.h"
#include "src/internal/isosurface/QmitkIsoSurface.h"
#include "src/internal/simpleexample/QmitkSimpleExampleView.h"
#include "src/internal/simplemeasurement/QmitkSimpleMeasurement.h"
#include "src/internal/viewinitialization/QmitkViewInitializationView.h"
#include "src/internal/volumetry/QmitkVolumetryView.h"
+#include "src/internal/surfaceutilities/QmitkSurfaceUtilities.h"
namespace mitk {
void PluginActivator::start(ctkPluginContext* context)
{
BERRY_REGISTER_EXTENSION_CLASS(QmitkColourImageProcessingView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkIsoSurface, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkSimpleExampleView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkSimpleMeasurement, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkViewInitializationView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkVolumetryView, context)
+ BERRY_REGISTER_EXTENSION_CLASS(QmitkSurfaceUtilities, context)
}
void PluginActivator::stop(ctkPluginContext* context)
{
Q_UNUSED(context)
}
}
Q_EXPORT_PLUGIN2(org_mitk_gui_qt_examples, mitk::PluginActivator)
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/QmitkSurfaceUtilities.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/QmitkSurfaceUtilities.cpp
new file mode 100644
index 0000000000..21482dce53
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/QmitkSurfaceUtilities.cpp
@@ -0,0 +1,319 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "QmitkSurfaceUtilities.h"
+
+// Blueberry
+#include <berryISelectionService.h>
+#include <berryIWorkbenchWindow.h>
+
+// MITK
+#include <mitkNodePredicateDataType.h>
+#include <mitkSurface.h>
+#include <mitkDataNode.h>
+
+#include "mitkSurfaceModifier.h"
+#include "mitkTargetPointsCalculator.h"
+
+
+
+
+const std::string QmitkSurfaceUtilities::VIEW_ID = "org.mitk.views.qmitksurfaceutilies";
+
+QmitkSurfaceUtilities::QmitkSurfaceUtilities()
+ : QmitkAbstractView()
+{
+
+}
+
+QmitkSurfaceUtilities::~QmitkSurfaceUtilities()
+{
+
+}
+
+void QmitkSurfaceUtilities::CreateQtPartControl( QWidget *parent )
+{
+ // build up qt view
+ // create GUI widgets from the Qt Designer's .ui file
+ m_Controls = Ui::QmitkSurfaceUtilitiesControls();
+ m_Controls.setupUi( parent );
+
+ connect( m_Controls.m_moveToOrigin, SIGNAL(clicked()), this, SLOT(OnMoveToOriginClicked()) );
+ connect( m_Controls.m_applyTransform, SIGNAL(clicked()), this, SLOT(OnApplyTransformClicked()) );
+ connect( m_Controls.m_computeMatrix, SIGNAL(clicked()), this, SLOT(OnEulerToMatrixClicked()) );
+ connect( m_Controls.m_ComputeCoG, SIGNAL(clicked()), this, SLOT(OnComputeCoG()) );
+ connect( (QObject*)(m_Controls.m_generateTargetPoints), SIGNAL(clicked()), this, SLOT(OnGenerateTargetPoints()) );
+ connect( m_Controls.m_Perturbe, SIGNAL(clicked()), this, SLOT(OnPerturbeSurface()));
+ connect( m_Controls.m_addOutliers, SIGNAL(clicked()), this, SLOT(OnAddOutliers()));
+
+ m_Controls.m_applySurfaceBox->SetDataStorage(this->GetDataStorage());
+ m_Controls.m_applySurfaceBox->SetAutoSelectNewItems(true);
+ m_Controls.m_applySurfaceBox->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
+}
+
+void QmitkSurfaceUtilities::SetFocus()
+{
+
+}
+
+void QmitkSurfaceUtilities::OnPerturbeSurface()
+ {
+ //########## check if everything is ready... ##################
+ mitk::DataNode* node = m_Controls.m_applySurfaceBox->GetSelectedNode();
+ if (!node)
+ {
+ // Nothing selected. Inform the user and return
+ MITK_WARN << "ERROR: Please select a surface before!";
+ return;
+ }
+ //#############################################################
+
+ mitk::SurfaceModifier::Pointer myModifier = mitk::SurfaceModifier::New();
+ myModifier->PerturbeSurface(dynamic_cast<mitk::Surface*>(m_Controls.m_applySurfaceBox->GetSelectedNode()->GetData()),
+ m_Controls.m_varianceX->value(),
+ m_Controls.m_varianceY->value(),
+ m_Controls.m_varianceZ->value());
+ }
+
+void QmitkSurfaceUtilities::OnAddOutliers()
+ {
+ //########## check if everything is ready... ##################
+ mitk::DataNode* node = m_Controls.m_applySurfaceBox->GetSelectedNode();
+ if (!node)
+ {
+ // Nothing selected. Inform the user and return
+ MITK_WARN << "ERROR: Please select a surface before!";
+ return;
+ }
+ //#############################################################
+
+ double outlierChance = (double)m_Controls.m_outlierChance->value() / 100.0;
+ mitk::SurfaceModifier::Pointer myModifier = mitk::SurfaceModifier::New();
+ myModifier->AddOutlierToSurface(dynamic_cast<mitk::Surface*>(m_Controls.m_applySurfaceBox->GetSelectedNode()->GetData()),
+ m_Controls.m_outlierVarianceX->value(),
+ m_Controls.m_outlierVarianceY->value(),
+ m_Controls.m_outlierVarianceZ->value(),
+ outlierChance);
+ }
+
+void QmitkSurfaceUtilities::OnGenerateTargetPoints()
+ {
+ //########## check if everything is ready... ##################
+ mitk::DataNode* node = m_Controls.m_applySurfaceBox->GetSelectedNode();
+ if (!node)
+ {
+ // Nothing selected. Inform the user and return
+ MITK_WARN << "ERROR: Please select a surface before!";
+ return;
+ }
+ //#############################################################
+
+ mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(node->GetData());
+
+ mitk::TargetPointsCalculator::Pointer myTargetPointsCalculator = mitk::TargetPointsCalculator::New();
+ myTargetPointsCalculator->SetInterPointDistance(m_Controls.m_InterPointDistance->value());
+ myTargetPointsCalculator->SetInput(surface);
+ MITK_INFO << "Calculating Target Points (this may take a while) ..." << std::endl;
+ myTargetPointsCalculator->DoCalculate();
+ mitk::PointSet::Pointer targetPoints = myTargetPointsCalculator->GetOutput();
+ MITK_INFO << " ... done." << std::endl;
+
+ mitk::DataNode::Pointer targetPointsImageNode = mitk::DataNode::New();
+ targetPointsImageNode->SetName("Target Points");
+ targetPointsImageNode->SetData(targetPoints);
+ this->GetDataStorage()->Add(targetPointsImageNode);
+ }
+
+void QmitkSurfaceUtilities::OnApplyTransformClicked()
+{
+ //get surface from UI
+ mitk::Surface::Pointer surface;
+ if (m_Controls.m_applySurfaceBox->GetSelectedNode().IsNull())
+ {
+ MITK_WARN << "No valid surface selected!";
+ return;
+ }
+ surface = dynamic_cast<mitk::Surface*>(m_Controls.m_applySurfaceBox->GetSelectedNode()->GetData());
+
+ itk::Matrix<double,3,3> TransformationR;
+ itk::Vector<double,3> TransformationT;
+ TransformationR = ReadInFromGUI_RotationMatrix();
+ TransformationT = ReadInFromGUI_TranslationVector();
+
+ //check if rotation matrix is empty
+ if (this->ReadInFromGUI_RotationMatrix().GetVnlMatrix().is_zero())
+ {
+ MITK_WARN << "Error, rotation matrix is zero!";
+ return;
+ }
+
+ //transform surface
+ itk::Matrix<double,3,3> actualTransformationR;
+ itk::Vector<double,3> actualTransformationT;
+ mitk::SurfaceModifier::Pointer myModifier = mitk::SurfaceModifier::New();
+ myModifier->TransformSurfaceCoGCoordinates(surface,TransformationR,TransformationT,actualTransformationR,actualTransformationT);
+
+ //update view
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+}
+
+void QmitkSurfaceUtilities::OnEulerToMatrixClicked()
+{
+ //read angles from GUI:
+ double alpha = m_Controls.m_eulerangle0->text().toDouble();
+ double beta = m_Controls.m_eulerangle1->text().toDouble();
+ double gamma = m_Controls.m_eulerangle2->text().toDouble();
+
+ //convert angles to matrix:
+ itk::Matrix<double,3,3> matrix = ConvertEulerAnglesToRotationMatrix(alpha,beta,gamma);
+
+ //write matrix to GUI
+ this->WriteToGUI_RotationMatrix(matrix);
+}
+
+void QmitkSurfaceUtilities::OnMoveToOriginClicked()
+{
+ //get surface from UI
+ mitk::Surface::Pointer surface;
+ if (m_Controls.m_applySurfaceBox->GetSelectedNode().IsNull())
+ {
+ MITK_WARN << "No surface selected!";
+ return;
+ }
+ surface = dynamic_cast<mitk::Surface*>(m_Controls.m_applySurfaceBox->GetSelectedNode()->GetData());
+
+ //move surface to center
+ mitk::SurfaceModifier::Pointer myModifier = mitk::SurfaceModifier::New();
+ itk::Matrix<double,3,3> TransformToCenterR;
+ itk::Vector<double,3> TransformToCenterT;
+ myModifier->MoveSurfaceToCenter(surface,TransformToCenterR,TransformToCenterT);
+
+ //update view
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+}
+
+void QmitkSurfaceUtilities::OnComputeCoG()
+{
+ //check if input is valid
+ if (this->m_Controls.m_applySurfaceBox->GetSelectedNode().IsNull())
+ {
+ MITK_WARN << "Error, no surface selected.";
+ return;
+ }
+
+ //get selected surface and name of surface
+ mitk::Surface::Pointer selectedSurface = dynamic_cast<mitk::Surface*>(this->m_Controls.m_applySurfaceBox->GetSelectedNode()->GetData());
+ std::string nameOfSelectedSurface = this->m_Controls.m_applySurfaceBox->GetSelectedNode()->GetName();
+
+ //calculate target point
+ mitk::TargetPointsCalculator::Pointer myTargetPointsCalculator = mitk::TargetPointsCalculator::New();
+ myTargetPointsCalculator->SetTargetPointCalculationMethod(mitk::TargetPointsCalculator::OneTargetPointInCenterOfGravity);
+ myTargetPointsCalculator->SetInput(selectedSurface);
+ myTargetPointsCalculator->DoCalculate();
+ mitk::PointSet::Pointer targetPoints = myTargetPointsCalculator->GetOutput();
+
+ //create a new data node with targets
+ mitk::DataNode::Pointer newNode = mitk::DataNode::New();
+ newNode->SetName(nameOfSelectedSurface + "_CenterOfGravity");
+ newNode->SetData(targetPoints);
+
+ //add the new node to the data storage
+ this->GetDataStorage()->Add(newNode);
+ this->GetDataStorage()->Modified();
+}
+
+itk::Matrix<double,3,3> QmitkSurfaceUtilities::ReadInFromGUI_RotationMatrix()
+{
+ itk::Matrix<double,3,3> transR;
+ transR[0][0] = m_Controls.m_rotmat00->text().toDouble();
+ transR[1][0] = m_Controls.m_rotmat10->text().toDouble();
+ transR[2][0] = m_Controls.m_rotmat20->text().toDouble();
+ transR[0][1] = m_Controls.m_rotmat01->text().toDouble();
+ transR[1][1] = m_Controls.m_rotmat11->text().toDouble();
+ transR[2][1] = m_Controls.m_rotmat21->text().toDouble();
+ transR[0][2] = m_Controls.m_rotmat02->text().toDouble();
+ transR[1][2] = m_Controls.m_rotmat12->text().toDouble();
+ transR[2][2] = m_Controls.m_rotmat22->text().toDouble();
+ return transR;
+}
+
+itk::Vector<double,3> QmitkSurfaceUtilities::ReadInFromGUI_TranslationVector()
+{
+ itk::Vector<double,3> transT;
+ transT[0] = m_Controls.m_tvec0->text().toDouble();
+ transT[1] = m_Controls.m_tvec1->text().toDouble();
+ transT[2] = m_Controls.m_tvec2->text().toDouble();
+ return transT;
+}
+
+void QmitkSurfaceUtilities::WriteToGUI_RotationMatrix(itk::Matrix<double,3,3> r)
+{
+ m_Controls.m_rotmat00->setText(QString::number(r[0][0]));
+ m_Controls.m_rotmat01->setText(QString::number(r[0][1]));
+ m_Controls.m_rotmat02->setText(QString::number(r[0][2]));
+ m_Controls.m_rotmat10->setText(QString::number(r[1][0]));
+ m_Controls.m_rotmat11->setText(QString::number(r[1][1]));
+ m_Controls.m_rotmat12->setText(QString::number(r[1][2]));
+ m_Controls.m_rotmat20->setText(QString::number(r[2][0]));
+ m_Controls.m_rotmat21->setText(QString::number(r[2][1]));
+ m_Controls.m_rotmat22->setText(QString::number(r[2][2]));
+}
+
+void QmitkSurfaceUtilities::WriteToGUI_TranslationVector(itk::Vector<double,3> t)
+{
+ m_Controls.m_tvec0->setText(QString::number(t[0]));
+ m_Controls.m_tvec1->setText(QString::number(t[1]));
+ m_Controls.m_tvec2->setText(QString::number(t[2]));
+}
+
+itk::Matrix<double,3,3> QmitkSurfaceUtilities::ConvertEulerAnglesToRotationMatrix(double alpha, double beta, double gamma)
+{
+ double PI = 3.141592653589793;
+ alpha = alpha * PI / 180;
+ beta = beta * PI / 180;
+ gamma = gamma * PI / 180;
+
+ //convert angles to matrix:
+ itk::Matrix<double,3,3> matrix;
+
+ /* x-Konvention (Z, X, Z)
+ matrix[0][0] = cos(alpha) * cos(gamma) - sin(alpha) * cos(beta) * sin(gamma);
+ matrix[0][1] = -cos(alpha) * sin(gamma)- sin(alpha) * cos(beta) * cos(gamma);
+ matrix[0][2] = sin(alpha) * sin(beta);
+
+ matrix[1][0] = sin(alpha) * cos(gamma) + cos(alpha) * cos(beta) * sin(gamma);
+ matrix[1][1] = cos(alpha) * cos(beta) * cos(gamma) - sin(alpha) * sin(gamma);
+ matrix[1][2] = -cos(alpha) * sin(beta);
+
+ matrix[2][0] = sin(beta) * sin(gamma);
+ matrix[2][1] = sin(beta) * cos(gamma);
+ matrix[2][2] = cos(beta); */
+
+ //Luftfahrtnorm (DIN 9300) (Yaw-Pitch-Roll, Z, Y, X)
+ matrix[0][0] = cos(beta) * cos(alpha);
+ matrix[0][1] = cos(beta) * sin(alpha);
+ matrix[0][2] = -sin(beta);
+
+ matrix[1][0] = sin(gamma) * sin(beta) * cos(alpha) - cos(gamma) * sin(alpha) ;
+ matrix[1][1] = sin(gamma) * sin(beta) * sin(alpha) + cos(gamma) * cos(alpha);
+ matrix[1][2] = sin(gamma) * cos(beta);
+
+ matrix[2][0] = cos(gamma) * sin(beta) * cos(alpha) + sin(gamma) * sin(alpha);
+ matrix[2][1] = cos(gamma) * sin(beta) * sin(alpha) - sin(gamma) * cos(alpha);
+ matrix[2][2] = cos(gamma) * cos(beta);
+
+ return matrix;
+}
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/QmitkSurfaceUtilities.h b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/QmitkSurfaceUtilities.h
new file mode 100644
index 0000000000..c4fde6530a
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/QmitkSurfaceUtilities.h
@@ -0,0 +1,73 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#if !defined(QMITK_SurfaceUtilities_H__INCLUDED)
+#define QMITK_SurfaceUtilities_H__INCLUDED
+
+#include <berryISelectionListener.h>
+
+#include <QmitkAbstractView.h>
+
+#include "ui_QmitkSurfaceUtilitiesControls.h"
+
+/*!
+ \brief TODO
+ */
+class QmitkSurfaceUtilities : public QmitkAbstractView
+{
+ // this is needed for all Qt objects that should have a Qt meta-object
+ // (everything that derives from QObject and wants to have signal/slots)
+ Q_OBJECT
+
+ public:
+
+ static const std::string VIEW_ID;
+
+ QmitkSurfaceUtilities();
+ ~QmitkSurfaceUtilities();
+
+ virtual void CreateQtPartControl(QWidget *parent);
+
+ void SetFocus();
+
+ protected slots:
+
+ void OnEulerToMatrixClicked();
+ void OnMoveToOriginClicked();
+ void OnApplyTransformClicked();
+ void OnComputeCoG();
+ void OnGenerateTargetPoints();
+ void OnPerturbeSurface();
+ void OnAddOutliers();
+
+
+ protected:
+
+
+ //methods to read in / write from / to GUI
+ itk::Matrix<double,3,3> ReadInFromGUI_RotationMatrix();
+ itk::Vector<double,3> ReadInFromGUI_TranslationVector();
+ void WriteToGUI_RotationMatrix(itk::Matrix<double,3,3> r);
+ void WriteToGUI_TranslationVector(itk::Vector<double,3> t);
+
+ /** @brief Converts euler angles (in degrees!) to a rotation matrix. */
+ itk::Matrix<double,3,3> ConvertEulerAnglesToRotationMatrix(double alpha, double beta, double gamma);
+
+
+ Ui::QmitkSurfaceUtilitiesControls m_Controls;
+
+};
+#endif // !defined(QMITK_ISOSURFACE_H__INCLUDED)
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/QmitkSurfaceUtilitiesControls.ui b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/QmitkSurfaceUtilitiesControls.ui
new file mode 100644
index 0000000000..5558e0830a
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/QmitkSurfaceUtilitiesControls.ui
@@ -0,0 +1,1074 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QmitkSurfaceUtilitiesControls</class>
+ <widget class="QWidget" name="QmitkSurfaceUtilitiesControls">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>440</width>
+ <height>801</height>
+ </rect>
+ </property>
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>200</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="windowTitle">
+ <string>IsoSurface</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout">
+ <item>
+ <widget class="QLabel" name="label_22">
+ <property name="text">
+ <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
+&lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
+p, li { white-space: pre-wrap; }
+&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;&quot;&gt;
+&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:8pt; font-weight:600; text-decoration: underline;&quot;&gt;Surface:&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_14">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QmitkDataStorageComboBox" name="m_applySurfaceBox">
+ <property name="minimumSize">
+ <size>
+ <width>200</width>
+ <height>0</height>
+ </size>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <widget class="Line" name="line">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QToolBox" name="toolBox">
+ <property name="currentIndex">
+ <number>0</number>
+ </property>
+ <widget class="QWidget" name="page">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>418</width>
+ <height>295</height>
+ </rect>
+ </property>
+ <attribute name="label">
+ <string>Move/Rotate</string>
+ </attribute>
+ <layout class="QVBoxLayout" name="verticalLayout_2">
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_16">
+ <item>
+ <layout class="QVBoxLayout" name="verticalLayout_13">
+ <item>
+ <widget class="QLabel" name="label_18">
+ <property name="text">
+ <string>Rotation Matrix</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <layout class="QGridLayout" name="gridLayout_2">
+ <item row="0" column="0">
+ <widget class="QLineEdit" name="m_rotmat00">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>1.0</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="1">
+ <widget class="QLineEdit" name="m_rotmat01">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="2">
+ <widget class="QLineEdit" name="m_rotmat02">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="0">
+ <widget class="QLineEdit" name="m_rotmat10">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="1">
+ <widget class="QLineEdit" name="m_rotmat11">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>1.0</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="2">
+ <widget class="QLineEdit" name="m_rotmat12">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item row="2" column="0">
+ <widget class="QLineEdit" name="m_rotmat20">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item row="2" column="1">
+ <widget class="QLineEdit" name="m_rotmat21">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item row="2" column="2">
+ <widget class="QLineEdit" name="m_rotmat22">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>1.0</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <widget class="Line" name="line_2">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <layout class="QVBoxLayout" name="verticalLayout_15">
+ <item>
+ <widget class="QLabel" name="label_19">
+ <property name="text">
+ <string>T. Vector</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <layout class="QVBoxLayout" name="verticalLayout_14">
+ <item>
+ <widget class="QLineEdit" name="m_tvec0">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLineEdit" name="m_tvec1">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLineEdit" name="m_tvec2">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_12">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <widget class="Line" name="line_3">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLabel" name="label_20">
+ <property name="text">
+ <string>Euler Angles [°] =&gt; Rotation Matrix</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_17">
+ <item>
+ <widget class="QLabel" name="label_23">
+ <property name="text">
+ <string>alpha:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLineEdit" name="m_eulerangle0">
+ <property name="minimumSize">
+ <size>
+ <width>30</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLabel" name="label_24">
+ <property name="text">
+ <string>beta:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLineEdit" name="m_eulerangle1">
+ <property name="minimumSize">
+ <size>
+ <width>30</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLabel" name="label_25">
+ <property name="text">
+ <string>gamma:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLineEdit" name="m_eulerangle2">
+ <property name="minimumSize">
+ <size>
+ <width>30</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>30</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>0.0</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_13">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_computeMatrix">
+ <property name="minimumSize">
+ <size>
+ <width>100</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>100</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Compute Matrix</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <widget class="Line" name="line_4">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_20">
+ <item>
+ <spacer name="horizontalSpacer_16">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_applyTransform">
+ <property name="minimumSize">
+ <size>
+ <width>150</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>150</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Apply Transform</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_3">
+ <item>
+ <spacer name="horizontalSpacer_2">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_moveToOrigin">
+ <property name="minimumSize">
+ <size>
+ <width>150</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Move to Origin</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <spacer name="verticalSpacer_4">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>40</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ <widget class="QWidget" name="page_2">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>418</width>
+ <height>325</height>
+ </rect>
+ </property>
+ <attribute name="label">
+ <string>Perturbe</string>
+ </attribute>
+ <layout class="QVBoxLayout" name="verticalLayout_3">
+ <item>
+ <widget class="QGroupBox" name="groupBox_10">
+ <property name="title">
+ <string>Gaussian Noise</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout_8">
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_15">
+ <item>
+ <widget class="QLabel" name="label_8">
+ <property name="text">
+ <string>Variance X:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_15">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_varianceX">
+ <property name="value">
+ <number>1</number>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_18">
+ <item>
+ <widget class="QLabel" name="label_9">
+ <property name="text">
+ <string>Variance Y:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_17">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_varianceY">
+ <property name="value">
+ <number>1</number>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_19">
+ <item>
+ <widget class="QLabel" name="label_10">
+ <property name="text">
+ <string>Variance Z:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_18">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_varianceZ">
+ <property name="value">
+ <number>1</number>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_14">
+ <item>
+ <spacer name="horizontalSpacer_7">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_Perturbe">
+ <property name="text">
+ <string>Perturbe</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <widget class="Line" name="line_5">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_21">
+ <item>
+ <widget class="QLabel" name="label_11">
+ <property name="text">
+ <string>Outlier chance (%):</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_19">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_outlierChance">
+ <property name="value">
+ <number>5</number>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_22">
+ <item>
+ <widget class="QLabel" name="label_12">
+ <property name="text">
+ <string>Outlier variance:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_20">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QLabel" name="label_15">
+ <property name="text">
+ <string>X:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_outlierVarianceX"/>
+ </item>
+ <item>
+ <widget class="QLabel" name="label_14">
+ <property name="text">
+ <string>Y:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_outlierVarianceY"/>
+ </item>
+ <item>
+ <widget class="QLabel" name="label_13">
+ <property name="text">
+ <string>Z:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_outlierVarianceZ">
+ <property name="maximum">
+ <number>999</number>
+ </property>
+ <property name="value">
+ <number>20</number>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_23">
+ <item>
+ <spacer name="horizontalSpacer_21">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_addOutliers">
+ <property name="text">
+ <string>Add Outliers</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <spacer name="verticalSpacer_5">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>40</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ <widget class="QWidget" name="page_3">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>418</width>
+ <height>311</height>
+ </rect>
+ </property>
+ <attribute name="label">
+ <string>Compute Center of Grafity</string>
+ </attribute>
+ <layout class="QVBoxLayout" name="verticalLayout_4">
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <item>
+ <spacer name="horizontalSpacer">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_ComputeCoG">
+ <property name="text">
+ <string>Compute CoG</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <spacer name="verticalSpacer_2">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>252</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ <widget class="QWidget" name="page_4">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>418</width>
+ <height>311</height>
+ </rect>
+ </property>
+ <attribute name="label">
+ <string>Fill Surface With Points</string>
+ </attribute>
+ <layout class="QVBoxLayout" name="verticalLayout_5">
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_29">
+ <item>
+ <spacer name="horizontalSpacer_23">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QLabel" name="label_21">
+ <property name="minimumSize">
+ <size>
+ <width>195</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>195</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Distance between two points (mm):</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_InterPointDistance">
+ <property name="minimumSize">
+ <size>
+ <width>50</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>50</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="minimum">
+ <number>1</number>
+ </property>
+ <property name="maximum">
+ <number>999</number>
+ </property>
+ <property name="value">
+ <number>50</number>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_27">
+ <item>
+ <spacer name="horizontalSpacer_8">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_generateTargetPoints">
+ <property name="minimumSize">
+ <size>
+ <width>160</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>160</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Generate Points</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <spacer name="verticalSpacer_3">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>221</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ </widget>
+ </item>
+ <item>
+ <spacer name="verticalSpacer">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>38</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <customwidgets>
+ <customwidget>
+ <class>QmitkDataStorageComboBox</class>
+ <extends>QComboBox</extends>
+ <header location="global">QmitkDataStorageComboBox.h</header>
+ </customwidget>
+ </customwidgets>
+ <includes>
+ <include location="local">QmitkDataStorageComboBox.h</include>
+ </includes>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceModifier.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceModifier.cpp
new file mode 100644
index 0000000000..37a6ce4934
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceModifier.cpp
@@ -0,0 +1,230 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//mitk headers
+#include "mitkSurfaceModifier.h"
+#include "mitkSurfaceToPointSetFilter.h"
+
+//vtk headers
+#include <vtkSmartPointer.h>
+#include <vtkPoints.h>
+#include <vtkPolyData.h>
+#include <vtkMath.h>
+
+mitk::SurfaceModifier::SurfaceModifier()
+ {
+ m_myRandomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
+ }
+
+mitk::SurfaceModifier::~SurfaceModifier()
+ {
+ }
+
+mitk::Point3D mitk::SurfaceModifier::PerturbePointAlongAxis(mitk::Point3D point, mitk::Vector3D axis, double variance)
+ {
+ if (m_myRandomGenerator.IsNull()) m_myRandomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
+ mitk::Point3D returnValue;
+
+ //normalize axis
+ mitk::Vector3D normalizedAxis = axis;
+ normalizedAxis.Normalize();
+
+ //create noise
+ double noise = m_myRandomGenerator->GetNormalVariate(0.0, variance);
+
+ //std::cout <<point<<std::endl;
+ //add noise to point along axis
+ returnValue[0] = point[0] + axis[0] * noise;
+ returnValue[1] = point[1] + axis[1] * noise;
+ returnValue[2] = point[2] + axis[2] * noise;
+ //std::cout<<returnValue;
+
+ return returnValue;
+ }
+
+mitk::Point3D mitk::SurfaceModifier::PerturbePoint(mitk::Point3D point, double varianceX, double varianceY, double varianceZ, double maxNoiseVectorLenght)
+ {
+ if (m_myRandomGenerator.IsNull()) m_myRandomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
+ mitk::Point3D returnValue;
+ returnValue[0] = point[0] + m_myRandomGenerator->GetNormalVariate(0.0, varianceX);
+ returnValue[1] = point[1] + m_myRandomGenerator->GetNormalVariate(0.0, varianceY);
+ returnValue[2] = point[2] + m_myRandomGenerator->GetNormalVariate(0.0, varianceZ);
+ return returnValue;
+ }
+
+bool mitk::SurfaceModifier::TransformSurface(mitk::Surface::Pointer surface, itk::Matrix<double,3,3> TransformationR, itk::Vector<double,3> TransformationT)
+ {
+ //apply transformation
+ vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+ points->ShallowCopy(surface->GetVtkPolyData()->GetPoints());
+
+ for(unsigned int i = 0; i < points->GetNumberOfPoints(); i++)
+ {
+ double p[3];
+ points->GetPoint(i, p);
+ mitk::Point3D point;
+ point[0] = p[0];
+ point[1] = p[1];
+ point[2] = p[2];
+ point = TransformPoint(point,TransformationR,TransformationT);
+ p[0] = point[0];
+ p[1] = point[1];
+ p[2] = point[2];
+ points->SetPoint(i, p);
+ }
+ surface->GetVtkPolyData()->SetPoints(points);
+
+ return true;
+ }
+
+bool mitk::SurfaceModifier::TransformSurfaceCoGCoordinates(mitk::Surface::Pointer surface, itk::Matrix<double,3,3> TransformationR, itk::Vector<double,3> TransformationT, itk::Matrix<double,3,3> &OverallTransformationR, itk::Vector<double,3> &OverallTransformationT)
+ {
+ //initialize return values
+ OverallTransformationR.SetIdentity();
+ OverallTransformationT.Fill(0);
+
+ //move surface to center of gravity and store transformation
+ itk::Matrix<double,3,3> TransformRToCenter;
+ itk::Vector<double,3> TransformTToCenter;
+ MoveSurfaceToCenter(surface,TransformRToCenter,TransformTToCenter);
+
+ OverallTransformationR = TransformRToCenter;
+ OverallTransformationT = TransformTToCenter;
+
+ //apply transformation
+ TransformSurface(surface,TransformationR,TransformationT);
+
+ OverallTransformationR = TransformationR * OverallTransformationR;
+ OverallTransformationT = (TransformationR * OverallTransformationT) + TransformationT;
+
+ //move surface back to original position (build inverse transformation andy apply it)
+ TransformRToCenter = TransformRToCenter.GetInverse();
+ TransformTToCenter = (TransformRToCenter * TransformTToCenter) * -1.;
+ TransformSurface(surface,TransformRToCenter,TransformTToCenter);
+
+ OverallTransformationR = TransformRToCenter * OverallTransformationR;
+ OverallTransformationT = (TransformRToCenter * OverallTransformationT) + TransformTToCenter;
+
+ return true;
+ }
+
+mitk::Point3D mitk::SurfaceModifier::TransformPoint(mitk::Point3D point, itk::Matrix<double,3,3> TransformationR, itk::Vector<double,3> TransformationT)
+ {
+ mitk::Point3D returnValue = TransformationR * point + TransformationT;
+ return returnValue;
+ }
+
+bool mitk::SurfaceModifier::AddOutlierToSurface(mitk::Surface::Pointer surface, double varianceX, double varianceY, double varianceZ, double outlierChance)
+ {
+ vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+ points->ShallowCopy(surface->GetVtkPolyData()->GetPoints());
+ for(unsigned int i = 0; i < points->GetNumberOfPoints(); i++)
+ {
+ double p[3];
+ points->GetPoint(i, p);
+ mitk::Point3D point;
+ point[0] = p[0];
+ point[1] = p[1];
+ point[2] = p[2];
+ if((outlierChance-vtkMath::Random(0,1))>0) point = PerturbePoint(point,varianceX,varianceY,varianceZ);
+ p[0] = point[0];
+ p[1] = point[1];
+ p[2] = point[2];
+ points->SetPoint(i, p);
+ }
+ surface->GetVtkPolyData()->SetPoints(points);
+ return true;
+ }
+
+
+bool mitk::SurfaceModifier::PerturbeSurface(mitk::Surface::Pointer surface, double varianceX, double varianceY, double varianceZ, double maxNoiseVectorLenght)
+ {
+ vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+ points->ShallowCopy(surface->GetVtkPolyData()->GetPoints());
+ for(unsigned int i = 0; i < points->GetNumberOfPoints(); i++)
+ {
+ double p[3];
+ points->GetPoint(i, p);
+ mitk::Point3D point;
+ point[0] = p[0];
+ point[1] = p[1];
+ point[2] = p[2];
+ point = PerturbePoint(point,varianceX,varianceY,varianceZ,maxNoiseVectorLenght);
+ p[0] = point[0];
+ p[1] = point[1];
+ p[2] = point[2];
+ points->SetPoint(i, p);
+ }
+ surface->GetVtkPolyData()->SetPoints(points);
+
+ return true;
+ }
+
+bool mitk::SurfaceModifier::MoveSurfaceToCenter(mitk::Surface::Pointer surface)
+ {
+ itk::Matrix<double,3,3> dummyR;
+ itk::Vector<double,3> dummyT;
+ return MoveSurfaceToCenter(surface,dummyR,dummyT);
+ }
+
+bool mitk::SurfaceModifier::MoveSurfaceToCenter(mitk::Surface::Pointer surface, itk::Matrix<double,3,3> &TransformR, itk::Vector<double,3> &TransformT)
+ {
+ //get center of cravity
+ mitk::Point3D CoG = GetCenterOfGravity(surface);
+
+ //initialize transforms
+ TransformR.SetIdentity();
+ TransformT.Fill(0);
+ TransformT[0] = -CoG[0];
+ TransformT[1] = -CoG[1];
+ TransformT[2] = -CoG[2];
+
+ //apply transform
+ return TransformSurface(surface,TransformR,TransformT);
+ }
+
+mitk::Point3D mitk::SurfaceModifier::GetCenterOfGravity(mitk::Surface::Pointer surface)
+ {
+ //convert surface to point set
+ mitk::SurfaceToPointSetFilter::Pointer myConverter = mitk::SurfaceToPointSetFilter::New();
+ myConverter->SetInput(surface);
+ myConverter->Update();
+ mitk::PointSet::Pointer pointSet = myConverter->GetOutput();
+
+ //calculate center of gravity
+ mitk::Point3D cog;
+ cog.Fill(0);
+ for (int i=0; i<pointSet->GetSize(); i++)
+ {
+ cog[0] += pointSet->GetPoint(i)[0];
+ cog[1] += pointSet->GetPoint(i)[1];
+ cog[2] += pointSet->GetPoint(i)[2];
+ }
+ cog[0] /= pointSet->GetSize();
+ cog[1] /= pointSet->GetSize();
+ cog[2] /= pointSet->GetSize();
+
+ return cog;
+ }
+
+mitk::Surface::Pointer mitk::SurfaceModifier::DeepCopy(mitk::Surface::Pointer originalSurface)
+ {
+ mitk::Surface::Pointer clonedSurface = mitk::Surface::New();
+ vtkSmartPointer<vtkPolyData> clonedPolyData = vtkPolyData::New();
+ clonedPolyData->DeepCopy(originalSurface->GetVtkPolyData());
+ clonedSurface->SetVtkPolyData(clonedPolyData);
+ return clonedSurface;
+ }
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceModifier.h b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceModifier.h
new file mode 100644
index 0000000000..601a3060ee
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceModifier.h
@@ -0,0 +1,99 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef MITKSurfaceModifier_H_HEADER_INCLUDED_
+#define MITKSurfaceModifier_H_HEADER_INCLUDED_
+
+//mitk headers
+#include <mitkCommon.h>
+#include <mitkPointSet.h>
+#include <mitkSurface.h>
+
+//itk headers
+#include <itkObject.h>
+#include <itkObjectFactory.h>
+#include <itkMersenneTwisterRandomVariateGenerator.h>
+
+class vtkPolyDataNormals;
+
+namespace mitk {
+ /** Documentation
+ * @brief This class offer some methods to modify a surface.
+ */
+
+class SurfaceModifier : public itk::Object
+ {
+ public:
+ mitkClassMacro(SurfaceModifier, itk::Object);
+ itkNewMacro(Self);
+
+ /** @brief Adds gaussian noise to a surface (means to all vertexes).
+ * @param maxNoiseVectorLenght Limits the length of the noise vector of each vertex. Value -1 disables the limit. Default value is also -1.
+ */
+ bool PerturbeSurface(mitk::Surface::Pointer surface, double varianceX, double varianceY, double varianceZ, double maxNoiseVectorLenght = -1);
+
+ /** @brief Adds gaussian noise to a part of the vertexes of the surface.
+ @param outlierChance The chance to perturbe a vertex. Consequently this is also approximately the percentage of vertexes that will be perturbed.
+ */
+ bool AddOutlierToSurface(mitk::Surface::Pointer surface, double varianceX, double varianceY, double varianceZ, double outlierChance);
+
+ /** @brief Transforms a surface with a given transform. This method transforms the vertexes which means manipulating the vtkPolyData.
+ * In some cases this is needed, for example if you want to use the transformed polydata later on.
+ */
+ bool TransformSurface(mitk::Surface::Pointer surface, itk::Matrix<double,3,3> TransformationR, itk::Vector<double,3> TransformationT);
+
+ /** @brief Transforms a surface with a given transform (uses the center of gravity of the surface as origin). This method transforms the vertexes which means manipulating the vtkPolyData.
+ * In some cases this is needed, for example if you want to use the transformed polydata later on.
+ * @param OverallTransformationR Returns the overall transformation in world coordinates. (rotation)
+ * @param OverallTransformationT Returns the overall transformation in world coordinates. (translation)
+ */
+ bool TransformSurfaceCoGCoordinates(mitk::Surface::Pointer surface, itk::Matrix<double,3,3> TransformationR, itk::Vector<double,3> TransformationT, itk::Matrix<double,3,3> &OverallTransformationR, itk::Vector<double,3> &OverallTransformationT);
+
+ /** @brief Moves the surface (respectively its center of gravity) to the center of the coordinate system. */
+ bool MoveSurfaceToCenter(mitk::Surface::Pointer surface);
+
+ /** @brief Moves the surface (respectively its center of gravity) to the center of the coordinate system.
+ @param TransformR (return value) returns the rotation of the transform which was applied to the surface to move it to the origin.
+ @param TransformT (return value) returns the translation of the transform which was applied to the surface to move it to the origin.
+ */
+ bool MoveSurfaceToCenter(mitk::Surface::Pointer surface, itk::Matrix<double,3,3> &TransformR, itk::Vector<double,3> &TransformT);
+
+ /** @brief Creates a deep copy (clone) of the given surface and returns it */
+ mitk::Surface::Pointer DeepCopy(mitk::Surface::Pointer surface);
+
+
+ protected:
+ SurfaceModifier();
+ ~SurfaceModifier();
+
+ /**
+ * @param maxNoiseVectorLenght Limits the length of the noise vector. Value -1 disables the limit. Default value is also -1.
+ */
+ mitk::Point3D PerturbePoint(mitk::Point3D point, double varianceX, double varianceY, double varianceZ, double maxNoiseVectorLenght = -1);
+
+ /** @brief perturbes a point along the given axis */
+ mitk::Point3D PerturbePointAlongAxis(mitk::Point3D point, mitk::Vector3D axis, double variance);
+
+ mitk::Point3D TransformPoint(mitk::Point3D point, itk::Matrix<double,3,3> TransformationR, itk::Vector<double,3> TransformationT);
+
+ mitk::Point3D GetCenterOfGravity(mitk::Surface::Pointer surface);
+
+ itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_myRandomGenerator;
+
+ };
+
+} // namespace mitk
+#endif /* MITKSurfaceModifier_H_HEADER_INCLUDED_ */
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceToPointSetFilter.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceToPointSetFilter.cpp
new file mode 100644
index 0000000000..f73b48c661
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceToPointSetFilter.cpp
@@ -0,0 +1,86 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkSurfaceToPointSetFilter.h"
+
+//mitk headers
+#include "mitkPointSet.h"
+
+//itk headers
+#include "itkMatrix.h"
+#include "itkVector.h"
+
+//vtk headers
+#include <vtkPolyData.h>
+#include <vtkCleanPolyData.h>
+
+mitk::SurfaceToPointSetFilter::SurfaceToPointSetFilter()
+ {
+ this->SetNumberOfOutputs(1);
+ }
+
+mitk::SurfaceToPointSetFilter::~SurfaceToPointSetFilter()
+ {
+
+ }
+
+void mitk::SurfaceToPointSetFilter::GenerateData()
+ {
+ if (m_InputSurface.IsNull())
+ {
+ this->SetNthOutput(0,NULL);
+ m_ErrorMessage = "Error in SurfaceToPointSetFilter: Input is not set correctly.";
+ return;
+ }
+ mitk::PointSet::Pointer result = mitk::PointSet::New();
+
+ vtkPolyData* points = this->m_InputSurface->GetVtkPolyData();
+ vtkCleanPolyData *cleaner = vtkCleanPolyData::New();
+ cleaner->PieceInvariantOff();
+ cleaner->ConvertLinesToPointsOff();
+ cleaner->ConvertPolysToLinesOff();
+ cleaner->ConvertStripsToPolysOff();
+ cleaner->PointMergingOn();
+ cleaner->SetInput(points);
+ cleaner->Update();
+
+ vtkPolyData* mergedPoints = cleaner->GetOutput();
+
+ //generate filter output
+ for (int i=0; i<mergedPoints->GetNumberOfPoints(); i++)
+ {
+ mitk::Point3D currentPoint;
+ currentPoint[0] = mergedPoints->GetPoint(i)[0];
+ currentPoint[1] = mergedPoints->GetPoint(i)[1];
+ currentPoint[2] = mergedPoints->GetPoint(i)[2];
+ result->InsertPoint(i,currentPoint);
+ }
+ this->SetNthOutput(0,result);
+ //-------------------------
+
+ cleaner->Delete();
+ }
+
+void mitk::SurfaceToPointSetFilter::SetInput(mitk::Surface::Pointer InputSurface)
+ {
+ m_InputSurface = InputSurface;
+ this->Modified();
+ }
+
+std::string mitk::SurfaceToPointSetFilter::GetErrorMessage()
+ {
+ return this->m_ErrorMessage;
+ }
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceToPointSetFilter.h b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceToPointSetFilter.h
new file mode 100644
index 0000000000..1d9a9fa209
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkSurfaceToPointSetFilter.h
@@ -0,0 +1,58 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef MITKSURFACETOPOINTSETFILTER_H_HEADER_INCLUDED_
+#define MITKSURFACETOPOINTSETFILTER_H_HEADER_INCLUDED_
+
+//mitk headers
+#include <mitkPointSetSource.h>
+#include "mitkSurface.h"
+
+namespace mitk {
+
+
+ /** Documentation
+ * @brief This filter converts the input surface into a point set. The output point set contains every point exactly one time
+ * (no dublicated points like in the stl-format).
+ */
+
+ class SurfaceToPointSetFilter : public mitk::PointSetSource
+ {
+ public:
+
+ mitkClassMacro(SurfaceToPointSetFilter,mitk::PointSetSource);
+ itkNewMacro(Self);
+
+ void SetInput(mitk::Surface::Pointer m_InputSurface);
+
+
+ std::string GetErrorMessage();
+
+ protected:
+ SurfaceToPointSetFilter();
+ ~SurfaceToPointSetFilter();
+
+ /** @brief method generating the output of this filter. Called in the updated process of the pipeline. */
+ virtual void GenerateData();
+
+ //############### members ########################
+ mitk::Surface::Pointer m_InputSurface;
+ std::string m_ErrorMessage;
+
+ };
+
+} // namespace mitk
+#endif /* MITKSURFACETODISTANCEIMAGEFILTER_H_HEADER_INCLUDED_ */
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkTargetPointsCalculator.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkTargetPointsCalculator.cpp
new file mode 100644
index 0000000000..0e3761178a
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkTargetPointsCalculator.cpp
@@ -0,0 +1,270 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+//mitk headers
+#include "mitkTargetPointsCalculator.h"
+#include <mitkSurfaceToImageFilter.h>
+#include <mitkImageCast.h>
+#include "mitkSurfaceToPointSetFilter.h"
+
+//itk headers
+#include <itkImage.h>
+#include <itkImageRegionIterator.h>
+
+#define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
+typedef itk::Image<unsigned char, 3> ImageType;
+typedef itk::ImageRegionIterator<ImageType> IteratorType;
+
+mitk::TargetPointsCalculator::TargetPointsCalculator()
+ {
+ //set default values
+ m_InterPointDistance = 20;
+ m_ErrorMessage = "";
+ m_Method = mitk::TargetPointsCalculator::EvenlyDistributedTargetPoints;
+ }
+
+mitk::TargetPointsCalculator::~TargetPointsCalculator()
+ {
+ }
+
+void mitk::TargetPointsCalculator::SetInput(mitk::Surface::Pointer input)
+ {
+ m_Input = input;
+ }
+
+bool mitk::TargetPointsCalculator::DoCalculate()
+ {
+ if (m_Input.IsNull())
+ {
+ m_ErrorMessage = "Error in TargetPointsCalculator: please set input first!";
+ return false;
+ }
+
+ if (m_Method == mitk::TargetPointsCalculator::EvenlyDistributedTargetPoints)
+ {
+ mitk::Image::Pointer binaryImage = this->CreateBinaryImage(m_Input);
+ this->m_Output = this->CreateTargetPoints(binaryImage);
+ }
+ else if (m_Method == mitk::TargetPointsCalculator::OneTargetPointInCenterOfGravity)
+ {
+ this->m_Output = this->CreateTargetPointInCOG(m_Input);
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+void mitk::TargetPointsCalculator::SetTargetPointCalculationMethod(TargetPointCalculationMethod method)
+ {
+ m_Method = method;
+ }
+
+mitk::PointSet::Pointer mitk::TargetPointsCalculator::GetOutput()
+ {
+ return m_Output;
+ }
+
+std::string mitk::TargetPointsCalculator::GetErrorMessage()
+ {
+ return m_ErrorMessage;
+ }
+
+mitk::Image::Pointer mitk::TargetPointsCalculator::CreateBinaryImage(mitk::Surface::Pointer input)
+ {
+ //################################################################################
+ //###################### create binary image out of stl ##########################
+ //################################################################################
+
+ typedef unsigned char PixelType;
+
+ // get bounding box of current surface
+ const mitk::BoundingBox* boundingBox = this->m_Input->GetGeometry()->GetBoundingBox();
+ mitk::BoundingBox::PointType minimum = boundingBox->GetMinimum();
+ mitk::BoundingBox::PointType maximum = boundingBox->GetMaximum();
+
+ // calculate image parameters
+ float spacingFactor = 1;
+ unsigned int dim[3];
+ dim[0] = ROUND(spacingFactor*(abs(maximum[0]-minimum[0])));
+ dim[1] = ROUND(spacingFactor*(abs(maximum[1]-minimum[1])));
+ dim[2] = ROUND(spacingFactor*(abs(maximum[2]-minimum[2])));
+
+ float* origin = new float[3];
+ origin[0] = minimum[0];
+ origin[1] = minimum[1];
+ origin[2] = minimum[2];
+ itk::Size<3> size = {dim[0],dim[1],dim[2]};
+
+ // create white itk image
+ ImageType::Pointer image = ImageType::New();
+ ImageType::IndexType start;
+ start[0] = 0;
+ start[1] = 0;
+ start[2] = 0;
+ ImageType::SizeType imageSize;
+ imageSize[0] = maximum[0]-minimum[0]+20;
+ imageSize[1] = maximum[1]-minimum[1]+20;
+ imageSize[2] = maximum[2]-minimum[2]+20;
+ ImageType::RegionType region;
+ region.SetSize(imageSize);
+ region.SetIndex(start);
+ image->SetRegions(region);
+ image->Allocate();
+
+ // set all pixel values to 1
+ PixelType pixel = 1;
+ IteratorType iterator( image, image->GetRequestedRegion());
+ iterator.GoToBegin();
+ while (!iterator.IsAtEnd())
+ {
+ iterator.Set(pixel);
+ ++iterator;
+ }
+
+ // convert to mitk image
+ mitk::Image::Pointer mitkImage;
+ mitk::CastToMitkImage(image,mitkImage);
+ mitk::Point3D orig;
+ orig[0] = minimum[0]-10;
+ orig[1] = minimum[1]-10;
+ orig[2] = minimum[2]-10;
+ mitkImage->SetOrigin(orig);
+ mitkImage->UpdateOutputInformation();
+
+ mitk::SurfaceToImageFilter::Pointer surfaceToImage = mitk::SurfaceToImageFilter::New();
+ surfaceToImage->SetImage(mitkImage);
+ surfaceToImage->SetInput(m_Input);
+ surfaceToImage->MakeOutputBinaryOn();
+ surfaceToImage->Update();
+
+ return surfaceToImage->GetOutput();
+ }
+
+mitk::PointSet::Pointer mitk::TargetPointsCalculator::CreateTargetPoints(mitk::Image::Pointer binaryImage)
+ {
+ //Bounding-Box besimmten:
+
+ ImageType::Pointer itkImage = ImageType::New();
+ mitk::CastToItkImage(binaryImage, itkImage);
+
+ itk::Index<3> begin = {{0,0,0}};
+ itk::Index<3> end = {{binaryImage->GetDimension(0),binaryImage->GetDimension(1),binaryImage->GetDimension(2)}};
+
+ mitk::Point3D beginWorld;
+ mitk::Point3D endWorld;
+
+ itkImage->TransformIndexToPhysicalPoint(begin, beginWorld);
+ itkImage->TransformIndexToPhysicalPoint(end, endWorld);
+ //ende Bounding Box bestimmen
+
+ //Pointset initialisieren
+ mitk::PointSet::Pointer returnValue = mitk::PointSet::New();
+ int m = 0; //Laufvariable für Pointset-ID
+
+ //Abstand der Punkte initialisieren (in mm)
+ int abstand = m_InterPointDistance;
+
+ //#########################################################
+ //############## BERECHNUNG DER PUNKTE ####################
+ //#########################################################
+
+ //Gatter aufbauen:
+ mitk::Point3D p;
+ for(int i=RoundUpToGatter(beginWorld.GetElement(0),abstand); i<endWorld.GetElement(0); i=i+abstand)
+ {
+ for (int j=RoundUpToGatter(beginWorld.GetElement(1),abstand); j<endWorld.GetElement(1); j=j+abstand)
+ {
+ for (int k=RoundUpToGatter(beginWorld.GetElement(2),abstand); k<endWorld.GetElement(2); k=k+abstand)
+ {
+ mitk::FillVector3D<mitk::Point3D>(p, i,j,k);
+
+ //if it is inside the main structure
+ if (this->isInside(itkImage,p) ) { returnValue->SetPoint(m, p); m++; }
+
+ }
+ }
+ }
+
+ return returnValue;
+
+ }
+
+int mitk::TargetPointsCalculator::RoundUpToGatter(int i, int gatter)
+ {
+ int centimeters = RoundUpToCentimeters(i);
+ int mod = centimeters % gatter;
+ int returnValue = centimeters+(gatter-mod);
+ return returnValue;
+ }
+
+int mitk::TargetPointsCalculator::RoundUpToCentimeters(int i)
+ {
+ int returnValue = (i+9.999) / 10;
+ returnValue = returnValue * 10;
+ return returnValue;
+ }
+
+bool mitk::TargetPointsCalculator::isInside(ImageType::Pointer currentImageAsitkImage, mitk::Point3D p)
+ {
+ itk::Index<3> contInd;
+
+ if (currentImageAsitkImage->TransformPhysicalPointToIndex(p, contInd))
+ {
+ unsigned short pixel = currentImageAsitkImage->GetPixel(contInd);
+ if (pixel==1)
+ {return true;}
+ else return false;
+ }
+ else
+ return false;
+ }
+
+void mitk::TargetPointsCalculator::SetInterPointDistance(int d)
+ {
+ this->m_InterPointDistance = d;
+ }
+
+mitk::PointSet::Pointer mitk::TargetPointsCalculator::CreateTargetPointInCOG(mitk::Surface::Pointer surface)
+ {
+ mitk::PointSet::Pointer returnValue = mitk::PointSet::New();
+
+ //convert surface to point set
+ mitk::SurfaceToPointSetFilter::Pointer mySurfaceToPointSetFilter = mitk::SurfaceToPointSetFilter::New();
+ mySurfaceToPointSetFilter->SetInput(surface);
+ mySurfaceToPointSetFilter->Update();
+ mitk::PointSet::Pointer ptSet = mySurfaceToPointSetFilter->GetOutput();
+
+ //calculate CoG
+ mitk::Point3D CoG;
+ CoG.Fill(0);
+ for (int i=0; i<ptSet->GetSize(); i++)
+ {
+ CoG[0] += ptSet->GetPoint(i)[0];
+ CoG[1] += ptSet->GetPoint(i)[1];
+ CoG[2] += ptSet->GetPoint(i)[2];
+ }
+ CoG[0] /= ptSet->GetSize();
+ CoG[1] /= ptSet->GetSize();
+ CoG[2] /= ptSet->GetSize();
+
+ //update return value
+ returnValue->InsertPoint(0,CoG);
+
+ return returnValue;
+ }
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkTargetPointsCalculator.h b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkTargetPointsCalculator.h
new file mode 100644
index 0000000000..a7d863de95
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/surfaceutilities/mitkTargetPointsCalculator.h
@@ -0,0 +1,105 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef MITKTARGETPOINTSCALCULATOR_H_HEADER_INCLUDED_
+#define MITKTARGETPOINTSCALCULATOR_H_HEADER_INCLUDED_
+
+//mitk headers
+#include "mitkCommon.h"
+#include "mitkSurface.h"
+#include "mitkPointSet.h"
+#include "mitkImage.h"
+
+//itk headers
+#include "itkObject.h"
+#include <itkObjectFactory.h>
+
+namespace mitk
+ {
+ /**
+ * @brief This class offers methods to automatically calculate target points inside a (closed) surface.
+ */
+ class TargetPointsCalculator : public itk::Object
+ {
+ public:
+ mitkClassMacro(TargetPointsCalculator, itk::Object);
+ itkNewMacro(Self);
+
+ /** @brief identifier for target point calculation method */
+ enum TargetPointCalculationMethod
+ {
+ EvenlyDistributedTargetPoints,
+ OneTargetPointInCenterOfGravity
+ };
+
+ /** @brief Sets the method for the target point calculation. Default value is EvenlyDistributedTargetPoints. */
+ void SetTargetPointCalculationMethod(TargetPointCalculationMethod method);
+
+ /** @brief Sets the inter point distance (in mm), which is a parameter for the evenly distributed target points.
+ * This parameter is only used if the method is set to EvenlyDistributedTargetPoints. Default value is 20.
+ */
+ void SetInterPointDistance(int d);
+
+ /** @brief Sets the input surface. This parameter must be set before calculation is started. */
+ void SetInput(mitk::Surface::Pointer input);
+
+ /** @brief Calculates the target points.
+ * @return Returns true if calculation was successful. False if not, you can get an error message in this case.
+ */
+ bool DoCalculate();
+
+ /** @return Returns the calculated target points. Returns null if no target points are calculated yet. */
+ mitk::PointSet::Pointer GetOutput();
+
+ /** @return Returns the last error message. Returns an empty string if there was no error yet. */
+ std::string GetErrorMessage();
+
+
+ protected:
+ TargetPointsCalculator();
+ ~TargetPointsCalculator();
+
+ typedef itk::Image<unsigned char, 3> ImageType;
+
+ int m_InterPointDistance;
+
+ mitk::PointSet::Pointer m_Output;
+
+ mitk::Surface::Pointer m_Input;
+
+ std::string m_ErrorMessage;
+
+ TargetPointCalculationMethod m_Method;
+
+ mitk::Image::Pointer CreateBinaryImage(mitk::Surface::Pointer input);
+
+ mitk::PointSet::Pointer CreateTargetPoints(mitk::Image::Pointer binaryImage);
+
+ bool isInside(ImageType::Pointer currentImageAsitkImage, mitk::Point3D p);
+
+ int RoundUpToGatter(int i, int gatter);
+
+ int RoundUpToCentimeters(int i);
+
+ mitk::PointSet::Pointer CreateTargetPointInCOG(mitk::Surface::Pointer surface);
+
+ };
+
+
+
+ }
+
+#endif
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/volumetry/QmitkVolumetryView.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/volumetry/QmitkVolumetryView.cpp
index 998220e2aa..a400e947f0 100644
--- a/Plugins/org.mitk.gui.qt.examples/src/internal/volumetry/QmitkVolumetryView.cpp
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/volumetry/QmitkVolumetryView.cpp
@@ -1,423 +1,417 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkVolumetryView.h"
#include "mitkNodePredicateDataType.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include <QMessageBox>
#include "itkImage.h"
#include <limits>
#include "mitkDataNode.h"
#include "mitkRenderingManager.h"
#include "mitkVolumeCalculator.h"
#include <qdir.h>
#include <qfiledialog.h>
#include <QTextStream>
const std::string QmitkVolumetryView::VIEW_ID = "org.mitk.views.volumetry";
QmitkVolumetryView::QmitkVolumetryView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL)
{
//m_DataStorage = this->GetDefaultDataStorage();
}
QmitkVolumetryView::~QmitkVolumetryView()
{
}
void QmitkVolumetryView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkVolumetryViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
// define data type for combobox
m_Controls->m_ImageSelector->SetDataStorage( this->GetDefaultDataStorage() );
m_Controls->m_ImageSelector->SetPredicate( mitk::NodePredicateDataType::New("Image") );
}
}
void QmitkVolumetryView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkVolumetryView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkVolumetryView::CreateConnections()
{
if ( m_Controls )
{
connect( m_Controls->m_ImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnImageSelected(const mitk::DataNode*)) );
//connect( (QObject*)(m_Controls->m_Button), SIGNAL(clicked()), this, SLOT(DoSomething()) );
connect( (QObject*)(m_Controls->m_ThresholdSlider), SIGNAL(valueChanged(int)), this, SLOT(OnThresholdSliderChanged(int)) );
//connect( (QObject*)(m_Controls->m_ThresholdLineEdit), SIGNAL(valueChanged(int)), this, SLOT(OnThresholdLineEdit(int)) );
//connect( (QObject*)(m_Controls->m_TextEdit), SIGNAL(valueChanged(int)), this, SLOT(OnTextEditChanged(int)) );
connect( (QObject*)(m_Controls->m_CalcButton), SIGNAL(clicked()), this, SLOT(OnCalculateVolume()) );
connect( (QObject*)(m_Controls->m_TimeSeriesButton), SIGNAL(clicked()), this, SLOT(OnTimeSeriesButtonClicked()) );
connect( (QObject*)(m_Controls->m_SaveCsvButton), SIGNAL(clicked()), this, SLOT(OnSaveCsvButtonClicked()) );
}
}
void QmitkVolumetryView::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkVolumetryView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
void QmitkVolumetryView::OnImageSelected(const mitk::DataNode* item)
{
// nothing selected (NULL selection)
if( item == NULL || item->GetData() == NULL )
return;
- if( item->GetData()->GetSource().IsNull() )
- {
- m_SelectedDataNode = 0;
- return;
- }
-
m_SelectedDataNode = const_cast<mitk::DataNode*>(item);
std::cout << "Selected mitk::Image at address " << m_SelectedDataNode->GetData() << std::endl;
if(item == m_OverlayNode.GetPointer())
return;
if (m_OverlayNode)
{
this->GetDefaultDataStorage()->Remove(m_OverlayNode);
// remove it from the tree
//mitk::DataTreeIteratorClone overlayIt = mitk::DataTreeHelper::FindIteratorToNode(m_DataTreeIteratorClone->GetTree(),m_OverlayNode);
//if (overlayIt.IsNotNull()) { overlayIt->Remove(); }
m_OverlayNode = NULL;
}
this->CreateOverlayChild();
//std::string name;
//if (node->GetName(name))
//{
// // m_TreeNodeNameLabel->setText( name.c_str() );
//}
m_Controls->m_CalcButton->setEnabled(false);
m_Controls->m_TimeSeriesButton->setEnabled(false);
m_Controls->m_SaveCsvButton->setEnabled(false);
m_Controls->m_TextEdit->clear();
if (m_SelectedDataNode.IsNotNull() )
{
mitk::Image* image = dynamic_cast<mitk::Image*>(m_SelectedDataNode->GetData());
image->Update();
if (image && image->IsInitialized())
{
if (image->GetDimension() == 4)
{
m_Controls->m_TimeSeriesButton->setEnabled(true);
}
else
{
m_Controls->m_CalcButton->setEnabled(true);
}
int minVal = (int)image->GetScalarValue2ndMin();
int maxVal = (int)image->GetScalarValueMaxNoRecompute();
if (minVal == maxVal)
--minVal;
m_Controls->m_ThresholdSlider->setMinimum(minVal);
m_Controls->m_ThresholdSlider->setMaximum(maxVal);
m_Controls->m_ThresholdSlider->setEnabled(true);
this->UpdateSlider();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
//void QmitkVolumetryView::DoSomething()
//{
// mitk::DataNode* node = m_Controls->m_ImageSelector->GetSelectedNode();
// if (!node)
// {
// // Nothing selected. Inform the user and return
// QMessageBox::information( NULL, "Template functionality", "Please load and select an image before starting some action.");
// return;
// }
//
// // here we have a valid mitk::DataNode
//
// // a node itself is not very useful, we need its data item (the image)
// mitk::BaseData* data = node->GetData();
// if (data)
// {
// // test if this data item is really an image or not (could also be a surface or something totally different)
// mitk::Image* image = dynamic_cast<mitk::Image*>( data );
// if (image)
// {
// std::string name("(no name)");
// node->GetName(name);
//
// QMessageBox::information( NULL, "Image processing",
// QString( "Doing something to '%1'" ).arg(name.c_str()) );
//
// // at this point anything can be done using the mitk::Image image.
// }
// }
//}
//void QmitkVolumetryView::SetDataNode(const mitk::DataNode* node)
//{
// if(node == m_OverlayNode.GetPointer())
// return;
// m_SelectedDataNode = node; // is the non-const m_SelectedDataNode needed anyway?
// if (m_OverlayNode)
// {
// // remove it from the tree
// mitk::DataTreeIteratorClone overlayIt = mitk::DataTreeHelper::FindIteratorToNode(m_DataTreeIteratorClone->GetTree(),m_OverlayNode);
// if (overlayIt.IsNotNull()) { overlayIt->Remove(); }
// m_OverlayNode = NULL;
// }
// CreateOverlayChild();
// std::string name;
// if (node->GetName(name))
// {
// // m_TreeNodeNameLabel->setText( name.c_str() );
// }
// m_CalcButton->setEnabled(false);
// m_TimeSeriesButton->setEnabled(false);
// m_SaveCsvButton->setEnabled(false);
// m_TextEdit->clear();
//
// if (m_SelectedDataNode)
// {
// mitk::Image* image = dynamic_cast<mitk::Image*>(m_SelectedDataNode->GetData());
// image->Update();
// if (image && image->IsInitialized())
// {
// if (image->GetDimension() == 4)
// {
// m_TimeSeriesButton->setEnabled(true);
// }
// else
// {
// m_CalcButton->setEnabled(true);
// }
// int minVal = (int)image->GetScalarValue2ndMin();
// int maxVal = (int)image->GetScalarValueMaxNoRecompute();
// if (minVal == maxVal)
// --minVal;
// m_ThresholdSlider->setMinValue(minVal);
// m_ThresholdSlider->setMaxValue(maxVal);
// m_ThresholdSlider->setEnabled(true);
// UpdateSlider();
// mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// }
// }
//}
void QmitkVolumetryView::OnCalculateVolume()
{
if (m_SelectedDataNode.IsNotNull() )
{
mitk::Image* image = dynamic_cast<mitk::Image*>(m_SelectedDataNode->GetData());
if (image)
{
std::cout << "Dimension:" << image->GetDimension() << std::endl;
std::cout << "Dimension[3]:" << image->GetDimension(3) << std::endl;
mitk::VolumeCalculator::Pointer volCalc = mitk::VolumeCalculator::New();
volCalc->SetImage(image);
volCalc->SetThreshold(m_Controls->m_ThresholdSlider->value());
volCalc->ComputeVolume();
std::stringstream vs;
vs << volCalc->GetVolume() << " ml";
m_Controls->m_Result->setText(vs.str().c_str() );
}
}
}
void QmitkVolumetryView::OnTimeSeriesButtonClicked()
{
if (m_SelectedDataNode.IsNotNull() )
{
mitk::Image* image = dynamic_cast<mitk::Image*>(m_SelectedDataNode->GetData());
if (image)
{
mitk::VolumeCalculator::Pointer volCalc = mitk::VolumeCalculator::New();
volCalc->SetImage(image);
volCalc->SetThreshold(m_Controls->m_ThresholdSlider->value());
volCalc->ComputeVolume();
std::vector<float> volumes = volCalc->GetVolumes();
std::stringstream vs;
int timeStep = 0;
for (std::vector<float>::iterator it = volumes.begin(); it != volumes.end(); it++)
{
vs << timeStep++ << "\t" << *it << std::endl;
}
m_Controls->m_TextEdit->setText(vs.str().c_str());
m_Controls->m_TextEdit->setTabStopWidth(20);
m_Controls->m_SaveCsvButton->setEnabled(true);
}
}
}
const mitk::DataNode* QmitkVolumetryView::GetImageNode()
{
return m_SelectedDataNode;
}
void QmitkVolumetryView::UpdateSlider()
{
if (m_SelectedDataNode.IsNotNull() && dynamic_cast<mitk::Image*>(m_SelectedDataNode->GetData()))
{
int intSliderValue = (int)m_Controls->m_ThresholdSlider->value();
QString stringSliderValue;
stringSliderValue.setNum(intSliderValue);
m_Controls->m_ThresholdLineEdit->setText(stringSliderValue);
}
}
void QmitkVolumetryView::UpdateSliderLabel()
{
int sliderValue = atoi(m_Controls->m_ThresholdLineEdit->text().toLatin1());
m_Controls->m_ThresholdSlider->setValue(sliderValue);
this->UpdateSlider();
}
void QmitkVolumetryView::OnThresholdSliderChanged( int value)
{
if (m_OverlayNode)
{
m_OverlayNode->SetLevelWindow(mitk::LevelWindow(value,1));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->UpdateSlider();
}
}
void QmitkVolumetryView::CreateOverlayChild()
{
if (m_SelectedDataNode.IsNotNull())
{
m_OverlayNode = mitk::DataNode::New();
mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New("volume threshold overlay image" );
m_OverlayNode->SetProperty( "reslice interpolation", m_SelectedDataNode->GetProperty("reslice interpolation") );
m_OverlayNode->SetProperty( "name", nameProp );
m_OverlayNode->SetData(m_SelectedDataNode->GetData());
m_OverlayNode->SetColor(0.0,1.0,0.0);
m_OverlayNode->SetOpacity(.25);
int layer = 0;
m_SelectedDataNode->GetIntProperty("layer", layer);
m_OverlayNode->SetIntProperty("layer", layer+1);
m_OverlayNode->SetLevelWindow(mitk::LevelWindow(m_Controls->m_ThresholdSlider->value(),1));
this->GetDefaultDataStorage()->Add(m_OverlayNode);
//// hack!!!
//mitk::DataTreeIteratorClone iteratorClone = m_DataTreeIteratorClone;
//while ( !iteratorClone->IsAtEnd() )
//{
// mitk::DataNode::Pointer node = iteratorClone->Get();
// if ( node == m_SelectedDataNode )
// {
// iteratorClone->Add(m_OverlayNode);
// break;
// }
// ++iteratorClone;
//}
}
}
mitk::DataNode* QmitkVolumetryView::GetOverlayNode()
{
return m_OverlayNode;
}
mitk::Image* QmitkVolumetryView::GetImage()
{
return dynamic_cast<mitk::Image*>(m_SelectedDataNode->GetData());
}
void QmitkVolumetryView::OnSaveCsvButtonClicked()
{
static QString lastSavePath = QDir::homePath();
QString s = QFileDialog::getSaveFileName( this->m_Parent, "Save as..", lastSavePath, "CSV Files (*.csv)");
/*"Save file dialog"
"Choose a filename to save under" );*/
if (! s.isEmpty())
{
lastSavePath = s;
QFile saveFile(s);
if ( saveFile.open(QIODevice::WriteOnly))
{
QTextStream stream( &saveFile );
stream << m_Controls->m_TextEdit->toPlainText().replace('\t',';');
saveFile.close();
}
else
{
// QMessageBox::critical(NULL,"Save Error!",QString("Saving of CSV failed! Couldn't open output file \"") + saveFile + QString("\""),QMessageBox:Ok,QMessageBox::NoButton);
//QMessageBox::critical(NULL,"Save Error!","Saving of CSV failed! Couldn't open output file \"" + saveFile.name() +"\"",QMessageBox::Ok,QMessageBox::NoButton);
}
}
}
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
index 045e1e6027..d086227608 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
@@ -1,1042 +1,1042 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkIGTTrackingLabView.h"
#include "QmitkStdMultiWidget.h"
#include <QmitkNDIConfigurationWidget.h>
#include <QmitkFiducialRegistrationWidget.h>
#include <QmitkUpdateTimerWidget.h>
#include <QmitkToolSelectionWidget.h>
#include <QmitkToolTrackingStatusWidget.h>
#include <mitkCone.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <vtkConeSource.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkAppendPolyData.h>
// Qt
#include <QMessageBox>
#include <QIcon>
const std::string QmitkIGTTrackingLabView::VIEW_ID = "org.mitk.views.igttrackinglab";
QmitkIGTTrackingLabView::QmitkIGTTrackingLabView()
: QmitkFunctionality()
,m_Source(NULL)
,m_FiducialRegistrationFilter(NULL)
,m_PermanentRegistrationFilter(NULL)
,m_Visualizer(NULL)
,m_VirtualView(NULL)
,m_PSRecordingPointSet(NULL)
,m_RegistrationTrackingFiducialsName("Tracking Fiducials")
,m_RegistrationImageFiducialsName("Image Fiducials")
,m_PointSetRecordingDataNodeName("Recorded Points")
,m_PointSetRecording(false)
,m_ImageFiducialsDataNode(NULL)
,m_TrackerFiducialsDataNode(NULL)
,m_PermanentRegistrationSourcePoints(NULL)
{
//[-1;0;0] for WOLF_6D bronchoscope
m_DirectionOfProjectionVector[0]=0;
m_DirectionOfProjectionVector[1]=0;
m_DirectionOfProjectionVector[2]=-1;}
QmitkIGTTrackingLabView::~QmitkIGTTrackingLabView()
{
}
void QmitkIGTTrackingLabView::CreateQtPartControl( QWidget *parent )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi( parent );
m_ToolBox = new QToolBox(parent);
m_Controls.m_VBoxLayout->addWidget(m_ToolBox);
this->CreateBundleWidgets( parent );
this->CreateConnections();
}
void QmitkIGTTrackingLabView::CreateBundleWidgets( QWidget* parent )
{
// configuration widget
m_NDIConfigWidget = new QmitkNDIConfigurationWidget(parent);
m_NDIConfigWidget->SetToolTypes(QStringList () << "Instrument" << "Fiducial" << "Skinmarker" << "Unknown" );
m_ToolBox->addItem(m_NDIConfigWidget, "Configuration");
// registration widget
m_RegistrationWidget = new QmitkFiducialRegistrationWidget(parent);
m_RegistrationWidget->HideStaticRegistrationRadioButton(true);
m_RegistrationWidget->HideContinousRegistrationRadioButton(true);
m_RegistrationWidget->HideUseICPRegistrationCheckbox(true);
m_ToolBox->addItem(m_RegistrationWidget, "Initial Registration");
// permanent registration widget
m_PermanentRegistrationToolSelectionWidget = new QmitkToolSelectionWidget(parent);
m_PermanentRegistrationToolSelectionWidget->SetCheckboxtText("Use this tool for permanent registration");
m_ToolBox->addItem(m_PermanentRegistrationToolSelectionWidget, "Permanent Registration");
// pointset recording
m_ToolBox->addItem(this->CreatePointSetRecordingWidget(parent), "PointSet Recording");
// virtual view
m_VirtualViewToolSelectionWidget = new QmitkToolSelectionWidget(parent);
m_VirtualViewToolSelectionWidget->SetCheckboxtText("Enable Virtual Camera");
m_ToolBox->addItem(m_VirtualViewToolSelectionWidget, "Virtual Camera");
// tracking status
m_ToolStatusWidget = new QmitkToolTrackingStatusWidget( parent );
m_Controls.m_VBoxLayout->addWidget(m_ToolStatusWidget);
// update timer
m_RenderingTimerWidget = new QmitkUpdateTimerWidget( parent );
m_RenderingTimerWidget->SetPurposeLabelText(QString("Navigation"));
m_RenderingTimerWidget->SetTimerInterval( 50 ); // set rendering timer at 20Hz (updating every 50msec)
m_Controls.m_VBoxLayout->addWidget(m_RenderingTimerWidget);
}
void QmitkIGTTrackingLabView::CreateConnections()
{
connect( m_ToolBox, SIGNAL(currentChanged(int)), this, SLOT(OnToolBoxCurrentChanged(int)) );
//connect( m_NDIConfigWidget, SIGNAL(Connected()), m_RenderingTimerWidget, SLOT(EnableWidget()) );
connect( m_NDIConfigWidget, SIGNAL(Disconnected()), this, SLOT(OnTrackerDisconnected()) );
connect( m_NDIConfigWidget, SIGNAL(Connected()), this, SLOT(OnSetupNavigation()) );
connect( m_NDIConfigWidget, SIGNAL(SignalToolNameChanged(int, QString)), this, SLOT(OnChangeToolName(int, QString)) );
connect( m_NDIConfigWidget, SIGNAL(SignalLoadTool(int, mitk::DataNode::Pointer)), this, SLOT(OnToolLoaded(int, mitk::DataNode::Pointer)) );
connect( m_NDIConfigWidget, SIGNAL(ToolsAdded(QStringList)), this, SLOT(OnToolsAdded(QStringList)) );
connect( m_NDIConfigWidget, SIGNAL(RepresentationChanged( int ,mitk::Surface::Pointer )), this, SLOT(ChangeToolRepresentation( int, mitk::Surface::Pointer )));
connect( m_RegistrationWidget, SIGNAL(AddedTrackingFiducial()), this, SLOT(OnAddRegistrationTrackingFiducial()) );
connect( m_RegistrationWidget, SIGNAL(PerformFiducialRegistration()), this, SLOT(OnRegisterFiducials()) );
connect( m_RenderingTimerWidget, SIGNAL(Started()), this, SLOT(OnStartNavigation()) );
connect( m_RenderingTimerWidget, SIGNAL(Stopped()), this, SLOT(OnStopNavigation()) );
connect( m_VirtualViewToolSelectionWidget, SIGNAL(SignalUseTool(int, bool)), this, SLOT(OnVirtualCamera(int, bool)));
connect( m_PermanentRegistrationToolSelectionWidget, SIGNAL(SignalUseTool(int, bool)), this, SLOT(OnPermanentRegistration(int, bool)) );
}
void QmitkIGTTrackingLabView::OnAddRegistrationTrackingFiducial()
{
mitk::DataStorage* ds = this->GetDefaultDataStorage(); // check if DataStorage available
if(ds == NULL)
throw std::invalid_argument("DataStorage is not available");
if (m_FiducialRegistrationFilter.IsNull())
{
std::string message( "IGT Pipeline is not ready. Please 'Start Navigation' before adding points");
QMessageBox::warning(NULL, "Adding Fiducials not possible", message.c_str());
return;
}
if (m_FiducialRegistrationFilter->GetNumberOfOutputs() < 1 || m_FiducialRegistrationFilter->GetNumberOfInputs() < 1)
{
std::string message("There are no tracking instruments! Please add an instrument first!");
QMessageBox::warning(NULL, "Adding Fiducials not possible", message.c_str());
return;
}
if (m_FiducialRegistrationFilter->GetInput()->IsDataValid() == false)
{
std::string message("instrument can currently not be tracked. Please make sure that the instrument is visible to the tracker");
QMessageBox::warning(NULL, "Adding Fiducials not possible", message.c_str());
return;
}
- mitk::NavigationData::Pointer nd = m_Source->GetOutput(0);
+ mitk::NavigationData::Pointer nd = m_Source->GetOutput();
if( nd.IsNull() || !nd->IsDataValid())
QMessageBox::warning( 0, "Invalid tracking data", "Navigation data is not available or invalid!", QMessageBox::Ok );
// in case the tracker fiducials datanode has been renamed or removed
//if(trackerFiducialsPS.IsNull())
//{
// mitk::DataNode::Pointer trackerFiducialsDN = mitk::DataNode::New();
// trackerFiducialsDN->SetName(m_RegistrationTrackingFiducialsName);
// trackerFiducialsPS = mitk::PointSet::New();
// trackerFiducialsDN->SetData(trackerFiducialsPS);
// m_RegistrationWidget->SetTrackerFiducialsNode(trackerFiducialsDN);
//}
if(m_TrackerFiducialsDataNode.IsNotNull() && m_TrackerFiducialsDataNode->GetData() != NULL)
{
mitk::PointSet::Pointer ps = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
ps->InsertPoint(ps->GetSize(), nd->GetPosition());
}
else
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access Tracker Fiducials. Adding fiducial not possible!");
}
void QmitkIGTTrackingLabView::OnSetupNavigation()
{
if(m_Source.IsNotNull())
if(m_Source->IsTracking())
return;
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
{
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "can not access DataStorage. Navigation not possible");
return;
}
// Building up the filter pipeline
try
{
this->SetupIGTPipeline();
}
catch(std::exception& e)
{
QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Error while building the IGT-Pipeline: %1").arg(e.what()));
this->DestroyIGTPipeline(); // destroy the pipeline if building is incomplete
return;
}
catch(...)
{
QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Error while building the IGT-Pipeline"));
this->DestroyIGTPipeline();
return;
}
}
void QmitkIGTTrackingLabView::SetupIGTPipeline()
{
mitk::DataStorage* ds = this->GetDefaultDataStorage(); // check if DataStorage is available
if(ds == NULL)
throw std::invalid_argument("DataStorage is not available");
mitk::TrackingDevice::Pointer tracker = m_NDIConfigWidget->GetTracker(); // get current tracker from configuration widget
if(tracker.IsNull()) // check if tracker is valid
throw std::invalid_argument("tracking device is NULL!");
m_Source = mitk::TrackingDeviceSource::New(); // create new source for the IGT-Pipeline
m_Source->SetTrackingDevice(tracker); // set the found tracker from the configuration widget to the source
this->InitializeFilters(); // initialize all needed filters
if(m_NDIConfigWidget->GetTracker()->GetType() == mitk::NDIAurora)
{
for (unsigned int i=0; i < m_Source->GetNumberOfOutputs(); ++i)
{
m_FiducialRegistrationFilter->SetInput(i, m_Source->GetOutput(i)); // set input for registration filter
m_Visualizer->SetInput(i, m_FiducialRegistrationFilter->GetOutput(i)); // set input for visualization filter
}
for(unsigned int i= 0; i < m_Visualizer->GetNumberOfOutputs(); ++i)
{
const char* toolName = tracker->GetTool(i)->GetToolName();
mitk::DataNode::Pointer representation = this->CreateInstrumentVisualization(this->GetDefaultDataStorage(), toolName);
m_PSRecToolSelectionComboBox->addItem(QString(toolName));
m_PermanentRegistrationToolSelectionWidget->AddToolName(QString(toolName));
m_VirtualViewToolSelectionWidget->AddToolName(QString(toolName));
m_Visualizer->SetRepresentationObject(i, representation->GetData());
}
if(m_Source->GetTrackingDevice()->GetToolCount() > 0)
m_RenderingTimerWidget->setEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
this->GlobalReinit();
}
// this->CreateInstrumentVisualization(ds, tracker);//create for each single connected ND a corresponding 3D representation
}
void QmitkIGTTrackingLabView::InitializeFilters()
{
//1. Fiducial Registration Filters
m_FiducialRegistrationFilter = mitk::NavigationDataLandmarkTransformFilter::New(); // filter used for initial fiducial registration
//2. Visualization Filter
m_Visualizer = mitk::NavigationDataObjectVisualizationFilter::New(); // filter to display NavigationData
m_PermanentRegistrationFilter = mitk::NavigationDataLandmarkTransformFilter::New();
//3. Virtual Camera
m_VirtualView = mitk::CameraVisualization::New(); // filter to update the vtk camera according to the reference navigation data
m_VirtualView->SetRenderer(mitk::BaseRenderer::GetInstance(this->GetActiveStdMultiWidget()->mitkWidget4->GetRenderWindow()));
mitk::Vector3D viewUpInToolCoordinatesVector;
viewUpInToolCoordinatesVector[0]=1;
viewUpInToolCoordinatesVector[1]=0;
viewUpInToolCoordinatesVector[2]=0;
m_VirtualView->SetDirectionOfProjectionInToolCoordinates(m_DirectionOfProjectionVector);
m_VirtualView->SetFocalLength(5000.0);
m_VirtualView->SetViewUpInToolCoordinates(viewUpInToolCoordinatesVector);
}
void QmitkIGTTrackingLabView::OnRegisterFiducials( )
{
/* filter pipeline can only be build, if source and visualization filters exist */
if (m_Source.IsNull() || m_Visualizer.IsNull() || m_FiducialRegistrationFilter.IsNull())
{
QMessageBox::warning(NULL, "Registration not possible", "Navigation pipeline is not ready. Please (re)start the navigation");
return;
}
if (m_Source->IsTracking() == false)
{
QMessageBox::warning(NULL, "Registration not possible", "Registration only possible if navigation is running");
return;
}
/* retrieve fiducials from data storage */
mitk::DataStorage* ds = this->GetDefaultDataStorage();
mitk::PointSet::Pointer imageFiducials = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsDataNode->GetData());
mitk::PointSet::Pointer trackerFiducials = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
//mitk::PointSet::Pointer imageFiducials = ds->GetNamedObject<mitk::PointSet>(m_RegistrationImageFiducialsName.c_str());
//mitk::PointSet::Pointer trackerFiducials = ds->GetNamedObject<mitk::PointSet>(m_RegistrationTrackingFiducialsName.c_str());
if (imageFiducials.IsNull() || trackerFiducials.IsNull())
{
QMessageBox::warning(NULL, "Registration not possible", "Fiducial data objects not found. \n"
"Please set 3 or more fiducials in the image and with the tracking system.\n\n"
"Registration is not possible");
return;
}
unsigned int minFiducialCount = 3; // \Todo: move to view option
if ((imageFiducials->GetSize() < minFiducialCount) || (trackerFiducials->GetSize() < minFiducialCount) || (imageFiducials->GetSize() != trackerFiducials->GetSize()))
{
QMessageBox::warning(NULL, "Registration not possible", QString("Not enough fiducial pairs found. At least %1 fiducial must "
"exist for the image and the tracking system respectively.\n"
"Currently, %2 fiducials exist for the image, %3 fiducials exist for the tracking system").arg(minFiducialCount).arg(imageFiducials->GetSize()).arg(trackerFiducials->GetSize()));
return;
}
/* now we have two PointSets with enough points to perform a landmark based transform */
if ( m_RegistrationWidget->UseICPIsChecked() )
m_FiducialRegistrationFilter->UseICPInitializationOn();
else
m_FiducialRegistrationFilter->UseICPInitializationOff();
m_FiducialRegistrationFilter->SetSourceLandmarks(trackerFiducials);
m_FiducialRegistrationFilter->SetTargetLandmarks(imageFiducials);
if (m_FiducialRegistrationFilter.IsNotNull() && m_FiducialRegistrationFilter->IsInitialized()) // update registration quality display
{
QString registrationQuality = QString("%0: FRE is %1mm (Std.Dev. %2), \n"
"RMS error is %3mm,\n"
"Minimum registration error (best fitting landmark) is %4mm,\n"
"Maximum registration error (worst fitting landmark) is %5mm.")
.arg("Fiducial Registration")
.arg(m_FiducialRegistrationFilter->GetFRE(), 3, 'f', 3)
.arg(m_FiducialRegistrationFilter->GetFREStdDev(), 3, 'f', 3)
.arg(m_FiducialRegistrationFilter->GetRMSError(), 3, 'f', 3)
.arg(m_FiducialRegistrationFilter->GetMinError(), 3, 'f', 3)
.arg(m_FiducialRegistrationFilter->GetMaxError(), 3, 'f', 3);
m_RegistrationWidget->SetQualityDisplayText(registrationQuality);
}
//trackerFiducials->Clear();
//this->GlobalReinit();
}
void QmitkIGTTrackingLabView::OnTrackerDisconnected()
{
m_RenderingTimerWidget->DisableWidget();
this->DestroyInstrumentVisualization(this->GetDefaultDataStorage(), m_NDIConfigWidget->GetTracker());
}
mitk::DataNode::Pointer QmitkIGTTrackingLabView::CreateInstrumentVisualization(mitk::DataStorage* ds, const char* toolName)
{
//const char* toolName = tracker->GetTool(i)->GetToolName();
mitk::DataNode::Pointer toolRepresentationNode;
toolRepresentationNode = ds->GetNamedNode(toolName); // check if node with same name already exists
if(toolRepresentationNode.IsNotNull())
ds->Remove(toolRepresentationNode); // remove old node with same name
toolRepresentationNode = this->CreateConeRepresentation( toolName );
// m_Visualizer->SetRepresentationObject(i, toolRepresentationNode->GetData());
ds->Add(toolRepresentationNode); // adds node to data storage
return toolRepresentationNode;
}
mitk::DataNode::Pointer QmitkIGTTrackingLabView::CreateConeRepresentation( const char* label )
{
//new data
mitk::Cone::Pointer activeToolData = mitk::Cone::New();
vtkConeSource* vtkData = vtkConeSource::New();
vtkData->SetRadius(7.5);
vtkData->SetHeight(15.0);
vtkData->SetDirection(m_DirectionOfProjectionVector[0],m_DirectionOfProjectionVector[1],m_DirectionOfProjectionVector[2]);
vtkData->SetCenter(0.0, 0.0, 7.5);
vtkData->SetResolution(20);
vtkData->CappingOn();
vtkData->Update();
activeToolData->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
//new node
mitk::DataNode::Pointer coneNode = mitk::DataNode::New();
coneNode->SetData(activeToolData);
coneNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New( label ));
coneNode->GetPropertyList()->SetProperty("layer", mitk::IntProperty::New(0));
coneNode->GetPropertyList()->SetProperty("visible", mitk::BoolProperty::New(true));
coneNode->SetColor(1.0,0.0,0.0);
coneNode->SetOpacity(0.85);
coneNode->Modified();
return coneNode;
}
void QmitkIGTTrackingLabView::DestroyIGTPipeline()
{
if(m_Source.IsNotNull())
{
m_Source->StopTracking();
m_Source->Disconnect();
m_Source = NULL;
}
m_FiducialRegistrationFilter = NULL;
m_PermanentRegistrationFilter = NULL;
m_Visualizer = NULL;
m_VirtualView = NULL;
}
void QmitkIGTTrackingLabView::OnChangeToolName(int index, QString name)
{
if(m_Source.IsNull())
return;
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
{
QMessageBox::warning(NULL,"DataStorage Access Error", "Could not access DataStorage. Tool Name can not be changed!");
return;
}
mitk::NavigationData::Pointer tempND = m_Source->GetOutput(index);
if(tempND.IsNull())
return;
const char* oldName = tempND->GetName();
mitk::DataNode::Pointer tempNode = ds->GetNamedNode(oldName);
if(tempNode.IsNotNull())
{
tempNode->SetName(name.toStdString().c_str());
tempND->SetName(name.toStdString().c_str());
}
else
QMessageBox::warning(NULL, "Rename Tool Error", "Couldn't find the corresponding tool for changing it's name!");
}
void QmitkIGTTrackingLabView::OnToolLoaded(int index, mitk::DataNode::Pointer toolNode)
{
if(m_Source.IsNull() || m_Visualizer.IsNull())
return;
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
{
QMessageBox::warning(NULL,"DataStorage Access Error", "Could not access DataStorage. Loaded tool representation can not be shown!");
return;
}
mitk::NavigationData::Pointer tempND = m_Source->GetOutput(index);
if(tempND.IsNull())
return;
// try to find DataNode for tool in DataStorage
const char* toolName = tempND->GetName();
mitk::DataNode::Pointer tempNode = ds->GetNamedNode(toolName);
if(tempNode.IsNull())
{
tempNode = mitk::DataNode::New(); // create new node, if none was found
ds->Add(tempNode);
}
tempNode->SetData(toolNode->GetData());
tempNode->SetName(toolNode->GetName());
m_PSRecToolSelectionComboBox->setItemText(index,toolNode->GetName().c_str());
m_VirtualViewToolSelectionWidget->ChangeToolName(index, QString(toolNode->GetName().c_str()));
m_PermanentRegistrationToolSelectionWidget->ChangeToolName(index, QString(toolNode->GetName().c_str()));
m_Visualizer->SetRepresentationObject(index, tempNode->GetData());
m_Visualizer->Update();
tempNode->Modified();
this->GlobalReinit();
}
void QmitkIGTTrackingLabView::OnStartNavigation()
{
if(m_Source.IsNull())
{
QMessageBox::warning(NULL, "IGTTrackingLab: Error", "can not access tracking source. Navigation not possible");
return;
}
if(!m_Source->IsTracking())
{
m_Source->StartTracking();
try
{
m_RenderingTimerWidget->GetTimerInterval();
this->StartContinuousUpdate(); // start tracker with set interval
for(unsigned int i = 0; i < m_Source->GetNumberOfOutputs(); i++) // add navigation data to bundle widgets
{
m_ToolStatusWidget->AddNavigationData(dynamic_cast<mitk::NavigationData*>(m_Source->GetOutputs().at(i).GetPointer()));
}
m_ToolStatusWidget->ShowStatusLabels(); // show status for every tool if ND is valid or not
//m_IGTPlayerWidget->setEnabled(true);
}
catch(...)
{
//m_IGTPlayerWidget->setDisabled(true);
this->StopContinuousUpdate();
this->DestroyIGTPipeline();
return;
}
m_NDIConfigWidget->EnableAddToolsButton(false);
}
}
void QmitkIGTTrackingLabView::StopContinuousUpdate()
{
if (this->m_RenderingTimerWidget->GetUpdateTimer() != NULL)
{
m_RenderingTimerWidget->StopTimer();
disconnect( (QTimer*) m_RenderingTimerWidget->GetUpdateTimer(), SIGNAL(timeout()), this, SLOT(RenderScene()) ); // disconnect timer from RenderScene() method
}
if(m_PointSetRecordPushButton)
m_PointSetRecordPushButton->setDisabled(true);
}
void QmitkIGTTrackingLabView::RenderScene( )
{
try
{
if (m_Visualizer.IsNull() || this->GetActiveStdMultiWidget() == NULL)
return;
try
{
if(m_Source.IsNotNull() && m_Source->IsTracking())
m_ToolStatusWidget->Refresh();
if(m_VirtualViewToolSelectionWidget->IsSelectedToolActivated())
{
m_VirtualView->Update();
mitk::Point3D p = m_Visualizer->GetOutput(m_VirtualViewToolSelectionWidget->GetCurrentSelectedIndex())->GetPosition();
this->GetActiveStdMultiWidget()->MoveCrossToPosition(p);
}
if(m_PermanentRegistrationToolSelectionWidget->IsSelectedToolActivated() && m_PermanentRegistrationToolSelectionWidget->GetCurrentSelectedIndex() >= 0 )
{
mitk::NavigationData::Pointer permRegTool = m_Source->GetOutput((unsigned int) m_PermanentRegistrationToolSelectionWidget->GetCurrentSelectedIndex());
m_PermanentRegistrationFilter->SetSourceLandmarks(this->GetVirtualPointSetFromPosition(permRegTool));
}
if(m_PointSetRecording && m_PSRecordingPointSet.IsNotNull())
{
int size = m_PSRecordingPointSet->GetSize();
mitk::NavigationData::Pointer nd= m_Visualizer->GetOutput(m_PSRecToolSelectionComboBox->currentIndex());
if(size > 0)
{
mitk::Point3D p = m_PSRecordingPointSet->GetPoint(size-1);
if(p.EuclideanDistanceTo(nd->GetPosition()) > (double) m_PSRecordingSpinBox->value())
m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
}
else
m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
}
}
catch(std::exception& e)
{
MITK_WARN << "Exception during QmitkIGTTrackingLab::RenderScene():" << e.what() << "\n";
}
//if(m_VirtualViewCheckBox->isChecked())
// mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
////update all Widgets
//else
m_Visualizer->Update();
mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
}
catch (std::exception& e)
{
MITK_WARN << "RenderAll exception: " << e.what() << "\n";
}
catch (...)
{
MITK_WARN << "RenderAll unknown exception\n";
}
}
void QmitkIGTTrackingLabView::StartContinuousUpdate( )
{
if (m_Source.IsNull() || m_Visualizer.IsNull() )
throw std::invalid_argument("Pipeline is not set up correctly");
if (m_RenderingTimerWidget->GetUpdateTimer() == NULL)
return;
else
{
connect( (QTimer*) m_RenderingTimerWidget->GetUpdateTimer(), SIGNAL(timeout()), this, SLOT(RenderScene()) ); // connect update timer to RenderScene() method
}
if(m_PointSetRecordPushButton)
m_PointSetRecordPushButton->setEnabled(true);
}
void QmitkIGTTrackingLabView::OnStopNavigation()
{
if(m_Source.IsNull())
{
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "can not access tracking source. Navigation not possible");
return;
}
if(m_Source->IsTracking())
{
m_Source->StopTracking();
this->StopContinuousUpdate();
m_ToolStatusWidget->RemoveStatusLabels();
m_NDIConfigWidget->EnableAddToolsButton(true);
}
}
void QmitkIGTTrackingLabView::OnToolsAdded(QStringList toolsList)
{
if(m_Source.IsNull() || m_FiducialRegistrationFilter.IsNull() || m_Visualizer.IsNull())
return;
m_Source->UpdateOutputInformation();
unsigned int nrOfOldOutputs = m_Visualizer->GetNumberOfOutputs();
for(unsigned int i = nrOfOldOutputs; i < m_Source->GetNumberOfOutputs(); ++i)
{
m_FiducialRegistrationFilter->SetInput(i, m_Source->GetOutput(i));
m_Visualizer->SetInput(i, m_FiducialRegistrationFilter->GetOutput(i));
}
for(unsigned int j = nrOfOldOutputs; j < m_Visualizer->GetNumberOfOutputs(); ++j)
{
mitk::DataNode::Pointer representation = this->CreateInstrumentVisualization(this->GetDefaultDataStorage(), m_Source->GetTrackingDevice()->GetTool(j)->GetToolName());
m_PSRecToolSelectionComboBox->addItem(QString(m_Source->GetTrackingDevice()->GetTool(j)->GetToolName()));
m_PermanentRegistrationToolSelectionWidget->AddToolName(QString(m_Source->GetTrackingDevice()->GetTool(j)->GetToolName()));
m_VirtualViewToolSelectionWidget->AddToolName(QString(m_Source->GetTrackingDevice()->GetTool(j)->GetToolName()));
m_Visualizer->SetRepresentationObject(j, representation->GetData());
}
if(m_Source->GetTrackingDevice()->GetToolCount() > 0)
m_RenderingTimerWidget->setEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
this->GlobalReinit();
//mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
}
void QmitkIGTTrackingLabView::InitializeRegistration()
{
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if( ds == NULL )
return;
m_RegistrationWidget->SetMultiWidget(this->GetActiveStdMultiWidget()); // passing multiwidget to pointsetwidget
if(m_ImageFiducialsDataNode.IsNull())
{
m_ImageFiducialsDataNode = mitk::DataNode::New();
mitk::PointSet::Pointer ifPS = mitk::PointSet::New();
m_ImageFiducialsDataNode->SetData(ifPS);
mitk::Color color;
color.Set(1.0f, 0.0f, 0.0f);
m_ImageFiducialsDataNode->SetName(m_RegistrationImageFiducialsName);
m_ImageFiducialsDataNode->SetColor(color);
m_ImageFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
ds->Add(m_ImageFiducialsDataNode);
}
m_RegistrationWidget->SetMultiWidget(this->GetActiveStdMultiWidget());
m_RegistrationWidget->SetImageFiducialsNode(m_ImageFiducialsDataNode);
if(m_TrackerFiducialsDataNode.IsNull())
{
m_TrackerFiducialsDataNode = mitk::DataNode::New();
mitk::PointSet::Pointer tfPS = mitk::PointSet::New();
m_TrackerFiducialsDataNode->SetData(tfPS);
mitk::Color color;
color.Set(0.0f, 1.0f, 0.0f);
m_TrackerFiducialsDataNode->SetName(m_RegistrationTrackingFiducialsName);
m_TrackerFiducialsDataNode->SetColor(color);
m_TrackerFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
ds->Add(m_TrackerFiducialsDataNode);
}
m_RegistrationWidget->SetTrackerFiducialsNode(m_TrackerFiducialsDataNode);
}
void QmitkIGTTrackingLabView::OnToolBoxCurrentChanged(const int index)
{
switch (index)
{
case RegistrationWidget:
this->InitializeRegistration();
break;
default:
break;
}
}
mitk::DataNode::Pointer QmitkIGTTrackingLabView::CreateRegistrationFiducialsNode( const std::string& label, const mitk::Color& color)
{
mitk::DataNode::Pointer fiducialsNode = mitk::DataNode::New();
mitk::PointSet::Pointer fiducialsPointSet = mitk::PointSet::New();
fiducialsNode->SetData(fiducialsPointSet);
fiducialsNode->SetName( label );
fiducialsNode->SetColor( color );
fiducialsNode->SetBoolProperty( "updateDataOnRender", false );
return fiducialsNode;
}
void QmitkIGTTrackingLabView::ChangeToolRepresentation( int toolID , mitk::Surface::Pointer surface )
{
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
{
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access DataStorage. Changing tool representation not possible!");
return;
}
mitk::TrackingDevice::Pointer tracker = m_NDIConfigWidget->GetTracker();
if(tracker.IsNull())
{
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access Tracker. Changing tool representation not possible!");
return;
}
try
{
const char* name = tracker->GetTool(toolID)->GetToolName(); // get tool name by id
mitk::DataNode::Pointer toolNode = ds->GetNamedNode(name);
if(toolNode.IsNull())
return;
toolNode->SetData(surface); // change surface representation of node
toolNode->SetColor(0.45,0.70,0.85); //light blue like old 5D sensors
toolNode->Modified();
m_Visualizer->SetRepresentationObject( toolID, toolNode->GetData()); // updating node with changed surface back in visualizer
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
catch(std::exception& e)
{
QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Can not change tool representation!").arg(e.what()));
return;
}
}
QWidget* QmitkIGTTrackingLabView::CreatePointSetRecordingWidget(QWidget* parent)
{
QWidget* pointSetRecordingWidget = new QWidget(parent);
m_PSRecToolSelectionComboBox = new QComboBox(pointSetRecordingWidget);
m_PSRecordingSpinBox = new QSpinBox(pointSetRecordingWidget);
QLabel* psRecordingEpsilonDistance = new QLabel("mm (point distance)", pointSetRecordingWidget);
// the recording button
m_PointSetRecordPushButton = new QPushButton("Start PointSet Recording", pointSetRecordingWidget);
m_PointSetRecordPushButton->setDisabled(true);
m_PointSetRecordPushButton->setIcon(QIcon(":/QmitkQmitkIGTTrackingLabView/start_rec.png"));
m_PointSetRecordPushButton->setCheckable(true);
connect( m_PointSetRecordPushButton, SIGNAL(toggled(bool)), this, SLOT(OnPointSetRecording(bool)) );
// distances spin
m_PSRecordingSpinBox->setValue(1);
m_PSRecordingSpinBox->setMinimum(1);
m_PSRecordingSpinBox->setMaximum(20);
QLabel* toolSelectLabel = new QLabel("Select tool for recording:", pointSetRecordingWidget);
QGridLayout* layout = new QGridLayout(pointSetRecordingWidget);
int row = 0;
int col = 0;
layout->addWidget(toolSelectLabel,row,col++,1,1,Qt::AlignRight);
layout->addWidget(m_PSRecToolSelectionComboBox,row,col++,1,3,Qt::AlignLeft);
col +=2;
layout->addWidget(m_PSRecordingSpinBox,row,col++,1,1,Qt::AlignRight);
layout->addWidget(psRecordingEpsilonDistance, row, col++,1,1,Qt::AlignLeft);
row++;
col=4;
layout->addWidget(m_PointSetRecordPushButton,row,col++,1,2,Qt::AlignRight);
return pointSetRecordingWidget;
}
void QmitkIGTTrackingLabView::OnPointSetRecording(bool record)
{
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
return;
if(record)
{
mitk::DataNode::Pointer psRecND = ds->GetNamedNode(m_PointSetRecordingDataNodeName);
if(m_PSRecordingPointSet.IsNull() || psRecND.IsNull())
{
m_PSRecordingPointSet = NULL;
m_PSRecordingPointSet = mitk::PointSet::New();
mitk::DataNode::Pointer dn = mitk::DataNode::New();
dn->SetName(m_PointSetRecordingDataNodeName);
dn->SetColor(0.,1.,0.);
dn->SetData(m_PSRecordingPointSet);
ds->Add(dn);
}
else
m_PSRecordingPointSet->Clear();
m_PointSetRecording = true;
m_PointSetRecordPushButton->setText("Stop PointSet Recording");
m_PSRecToolSelectionComboBox->setDisabled(true);
}
else
{
m_PointSetRecording = false;
m_PointSetRecordPushButton->setText("Start PointSet Recording");
m_PSRecToolSelectionComboBox->setEnabled(true);
}
}
void QmitkIGTTrackingLabView::DestroyInstrumentVisualization(mitk::DataStorage* ds, mitk::TrackingDevice::Pointer tracker)
{
if(ds == NULL || tracker.IsNull())
return;
for(int i=0; i < tracker->GetToolCount(); ++i)
{
mitk::DataNode::Pointer dn = ds->GetNamedNode(tracker->GetTool(i)->GetToolName());
if(dn.IsNotNull())
ds->Remove(dn);
}
}
void QmitkIGTTrackingLabView::GlobalReinit()
{
// request global reiinit
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
//global reinit end
}
void QmitkIGTTrackingLabView::OnVirtualCamera(int toolNr, bool on)
{
if(m_VirtualView.IsNull() || m_FiducialRegistrationFilter.IsNull())
return;
if(on)
{
m_VirtualView->SetInput(m_FiducialRegistrationFilter->GetOutput(toolNr));
this->GetActiveStdMultiWidget()->SetWidgetPlaneModeToRotation(true);
}
else
this->GetActiveStdMultiWidget()->SetWidgetPlaneModeToSlicing(true);
}
void QmitkIGTTrackingLabView::OnPermanentRegistration(int toolID, bool on)
{
if (m_PermanentRegistrationFilter.IsNull() || m_FiducialRegistrationFilter.IsNull())
return;
if(on)
{
if(m_PermanentRegistrationSourcePoints.IsNull())
m_PermanentRegistrationSourcePoints = mitk::PointSet::New();
// interconnectiong permanent registration filter between tracking source and fiducial registration filter
for(unsigned int i=0; i < m_Source->GetNumberOfOutputs(); ++i)
{
m_PermanentRegistrationFilter->SetInput(i,m_Source->GetOutput(i));
m_FiducialRegistrationFilter->SetInput(i,m_PermanentRegistrationFilter->GetOutput(i));
}
mitk::NavigationData::Pointer nd = m_Source->GetOutput((unsigned int) toolID);
m_PermanentRegistrationFilter->SetTargetLandmarks(this->GetVirtualPointSetFromPosition(nd));
}
else
{
for(unsigned int i=0; i < m_FiducialRegistrationFilter->GetNumberOfOutputs(); ++i)
m_FiducialRegistrationFilter->SetInput(i,m_Source->GetOutput());
}
}
mitk::PointSet::Pointer QmitkIGTTrackingLabView::GetVirtualPointSetFromPosition(mitk::NavigationData::Pointer navigationData)
{
typedef itk::QuaternionRigidTransform<double> QuaternionTransformType;
mitk::NavigationData::PositionType pointA;
mitk::NavigationData::PositionType pointB;
mitk::NavigationData::PositionType pointC;
//initializing three points with position(0|0|0)
pointA.Fill(0);
pointB.Fill(0);
pointC.Fill(0);
// changing position off all points in order to make them orthogonal
pointA[0] = 1;
pointB[1] = 1;
pointC[2] = 1;
QuaternionTransformType::Pointer quatTransform = QuaternionTransformType::New();
// orientation of NavigationData from parameter
mitk::NavigationData::OrientationType quatIn = navigationData->GetOrientation();
// set orientation to quaternion transform
vnl_quaternion<double> const vnlQuatIn(quatIn.x(), quatIn.y(), quatIn.z(), quatIn.r());
quatTransform->SetRotation(vnlQuatIn);
// transform each point
pointA = quatTransform->TransformPoint(pointA);
pointB = quatTransform->TransformPoint(pointB);
pointC = quatTransform->TransformPoint(pointC);
// add position data from NavigationData parameter to each point
pointA[0] += navigationData->GetPosition()[0];
pointA[1] += navigationData->GetPosition()[1];
pointA[2] += navigationData->GetPosition()[2];
pointB[0] += navigationData->GetPosition()[0];
pointB[1] += navigationData->GetPosition()[1];
pointB[2] += navigationData->GetPosition()[2];
pointC[0] += navigationData->GetPosition()[0];
pointC[1] += navigationData->GetPosition()[1];
pointC[2] += navigationData->GetPosition()[2];
// insert points in source points pointset for the permanent registration landmark transform
m_PermanentRegistrationSourcePoints->InsertPoint(0,pointA);
m_PermanentRegistrationSourcePoints->InsertPoint(1,pointB);
m_PermanentRegistrationSourcePoints->InsertPoint(2,pointC);
return m_PermanentRegistrationSourcePoints;
}
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTutorialView.cpp b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTutorialView.cpp
index e3bbc70a7d..2c699bb98c 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTutorialView.cpp
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTutorialView.cpp
@@ -1,240 +1,240 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkIGTTutorialView.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkStdMultiWidgetEditor.h"
#include "mitkNDIPassiveTool.h"
#include "mitkNDITrackingDevice.h"
#include "mitkVirtualTrackingDevice.h"
#include "mitkStandardFileLocations.h"
#include "mitkSerialCommunication.h"
#include "mitkCone.h"
#include <QTimer>
#include <QMessageBox>
const std::string QmitkIGTTutorialView::VIEW_ID = "org.mitk.views.igttutorial";
QmitkIGTTutorialView::QmitkIGTTutorialView()
: QmitkFunctionality(),
m_Controls(NULL), m_MultiWidget(NULL), m_Source(NULL), m_Visualizer(NULL), m_Timer(NULL)
{
}
QmitkIGTTutorialView::~QmitkIGTTutorialView()
{
}
void QmitkIGTTutorialView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widget
m_Controls = new Ui::QmitkIGTTutorialViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
}
}
void QmitkIGTTutorialView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkIGTTutorialView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkIGTTutorialView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_StartButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnStartIGT()));
connect( (QObject*)(m_Controls->m_StopButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnStopIGT()));
}
}
void QmitkIGTTutorialView::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkIGTTutorialView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
void QmitkIGTTutorialView::OnStartIGT()
{
//This method is called when the Do IGT button is pressed. Any kind of navigation application will
//start with the connection to a tracking system and as we do image guided procedures we want to show
//something on the screen. In this tutorial we connect to the NDI Polaris tracking system and we will
//show the movement of a tool as cone in MITK.
//Check if we have a widget for visualization. Makes no sense to start otherwise.
//If there is no multiwidget, create one.
//if (m_MultiWidget == NULL)
//{
//}
if (m_MultiWidget == NULL) // if creating the multiwidget failed, stop here.
{
QMessageBox::warning ( NULL, "Error", "Starting the tutorial is not possible without an initialized "
"rendering widget. Please load a dataset first.");
return;
}
try
{
/**************** Variant 1: Use a NDI Polaris Tracking Device ****************/
////Here we want to use the NDI Polaris tracking device. Therefore we instantiate a object of the class
////NDITrackingDevice and make some settings which are necessary for a proper connection to the device.
//mitk::NDITrackingDevice::Pointer tracker = mitk::NDITrackingDevice::New(); //instantiate
//tracker->SetPortNumber(mitk::SerialCommunication::COM4); //set the comport
//tracker->SetBaudRate(mitk::SerialCommunication::BaudRate115200); //set the baud rate
//tracker->SetType(mitk::NDIPolaris); //set the type there you can choose between Polaris and Aurora
////The tools represent the sensors of the tracking device. In this case we have one pointer tool.
////The TrackingDevice object it self fills the tool with data. So we have to add the tool to the
////TrackingDevice object.
//mitk::NDIPassiveTool::Pointer tool = mitk::NDIPassiveTool::New();
//tool->SetToolName("MyInstrument"); //Every tool should have a name.
//tool->LoadSROMFile("c:\\myinstrument.rom"); //The Polaris system needs a ".rom" file which describes
////the geometry of the markers related to the tool tip.
////NDI provides an own software (NDI architect) to
////generate those files.
////tool->LoadSROMFile(mitk::StandardFileLocations::GetInstance()->FindFile("myToolDefinitionFile.srom").c_str());
//tracker->Add6DTool(tool); //Add the tool to the TrackingDevice object.
/**************** End of Variant 1 ****************/
/**************** Variant 2: Emulate a Tracking Device with mitk::VirtualTrackingDevice ****************/
// For tests, it is useful to simulate a tracking device in software. This is what mitk::VirtualTrackingDevice does.
// It will produce random position, orientation and error values for each tool that is added.
mitk::VirtualTrackingDevice::Pointer tracker = mitk::VirtualTrackingDevice::New(); // create virtual tracker
mitk::ScalarType bounds[] = {0.0, 200.0, 0.0, 200.0, 0.0, 200.0};
tracker->SetBounds(bounds);
tracker->AddTool("MyInstrument"); // add a tool to tracker
/**************** End of Variant 2 ****************/
//The tracking device object is used for the physical connection to the device. To use the
//data inside of our tracking pipeline we need a source. This source encapsulate the tracking device
//and provides objects of the type mitk::NavigationData as output. The NavigationData objects stores
//position, orientation, if the data is valid or not and special error informations in a covariance
//matrix.
//
//Typically the start of a pipeline is a TrackingDeviceSource. To work correct we have to set a
//TrackingDevice object. Attention you have to set the tools before you set the whole TrackingDevice
//object to the TrackingDeviceSource because the source need to know how many outputs should be
//generated.
m_Source = mitk::TrackingDeviceSource::New(); //We need the filter objects to stay alive,
//therefore they must be members.
m_Source->SetTrackingDevice(tracker); //Here we set the tracking device to the source of the pipeline.
m_Source->Connect(); //Now we connect to the tracking system.
//Note we do not call this on the TrackingDevice object
//As we wish to visualize our tool we need to have a PolyData which shows us the movement of our tool.
//Here we take a cone shaped PolyData. In MITK you have to add the PolyData as a node into the DataStorage
//to show it inside of the rendering windows. After that you can change the properties of the cone
//to manipulate rendering, e.g. the position and orientation as in our case.
mitk::Cone::Pointer cone = mitk::Cone::New(); //instantiate a new cone
float scale[] = {10.0, 10.0, 10.0};
cone->GetGeometry()->SetSpacing(scale); //scale it a little that so we can see something
mitk::DataNode::Pointer node = mitk::DataNode::New(); //generate a new node to store the cone into
//the DataStorage.
node->SetData(cone); //The data of that node is our cone.
node->SetName("My tracked object"); //The node has additional properties like a name
node->SetColor(1.0, 0.0, 0.0); //or the color. Here we make it red.
this->GetDefaultDataStorage()->Add(node); //After adding the Node with the cone in it to the
//DataStorage, MITK will show the cone in the
//render windows.
//For updating the render windows we use another filter of the MITK-IGT pipeline concept. The
//NavigationDataObjectVisualizationFilter needs as input a NavigationData and a
//PolyData. In our case the input is the source and the PolyData our cone.
//First we create a new filter for the visualization update.
m_Visualizer = mitk::NavigationDataObjectVisualizationFilter::New();
- m_Visualizer->SetInput(0, m_Source->GetOutput(0)); //Then we connect to the pipeline.
+ m_Visualizer->SetInput(0, m_Source->GetOutput()); //Then we connect to the pipeline.
m_Visualizer->SetRepresentationObject(0, cone); //After that we have to assign the cone to the input
//Now this simple pipeline is ready, so we can start the tracking. Here again: We do not call the
//StartTracking method from the tracker object itself. Instead we call this method from our source.
m_Source->StartTracking();
//Now every call of m_Visualizer->Update() will show us the cone at the position and orientation
//given from the tracking device.
//We use a QTimer object to call this Update() method in a fixed interval.
if (m_Timer == NULL)
{
m_Timer = new QTimer(this); //create a new timer
}
connect(m_Timer, SIGNAL(timeout()), this, SLOT(OnTimer())); //connect the timer to the method OnTimer()
m_Timer->start(100); //Every 100ms the method OnTimer() is called. -> 10fps
//Now have look at the OnTimer() method.
}
catch (std::exception& e)
{
// add cleanup
std::cout << "Error in QmitkIGTTutorial::OnDoIGT():" << e.what() << std::endl;
}
}
void QmitkIGTTutorialView::OnTimer()
{
//Here we call the Update() method from the Visualization Filter. Internally the filter checks if
//new NavigationData is available. If we have a new NavigationData the cone position and orientation
//will be adapted.
m_Visualizer->Update();
mitk::RenderingManager::GetInstance()->RequestUpdateAll(); //update the render windows
}
void QmitkIGTTutorialView::OnStopIGT()
{
//This method is called when the Stop button is pressed. Here we disconnect the pipeline.
if (m_Timer == NULL)
{
std::cout << "No Timer was set yet!" << std::endl;
return;
}
//To disconnect the pipeline in a save way we first stop the timer than we disconnect the tracking device.
//After that we destroy all filters with changing them to NULL.
m_Timer->stop();
disconnect(m_Timer, SIGNAL(timeout()), this, SLOT(OnTimer()));
m_Timer = NULL;
m_Source->StopTracking();
m_Source->Disconnect();
m_Source = NULL;
m_Visualizer = NULL;
m_Source = NULL;
this->GetDefaultDataStorage()->Remove(this->GetDefaultDataStorage()->GetNamedNode("My tracked object"));
}
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index d5e1df3008..aa8a4982a3 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,676 +1,679 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkMITKIGTTrackingToolboxView.h"
#include "QmitkStdMultiWidget.h"
// Qt
#include <QMessageBox>
#include <qfiledialog.h>
// MITK
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkTrackingDeviceSourceConfigurator.h>
#include <mitkTrackingVolumeGenerator.h>
#include <mitkNDITrackingDevice.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNavigationToolStorageSerializer.h>
// vtk
#include <vtkSphereSource.h>
//for exceptions
#include <mitkIGTException.h>
#include <mitkIGTIOException.h>
const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
{
m_TrackingTimer = new QTimer(this);
m_tracking = false;
m_logging = false;
m_loggedFrames = 0;
}
QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
{
//remove the tracking volume
this->GetDataStorage()->Remove(m_TrackingVolumeNode);
}
void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
m_Controls->setupUi( parent );
//create connections
connect( m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()) );
connect( m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()) );
connect( m_Controls->m_Disconnect, SIGNAL(clicked()), this, SLOT(OnDisconnect()) );
connect( m_Controls->m_StartTracking, SIGNAL(clicked()), this, SLOT(OnStartTracking()) );
connect( m_Controls->m_StopTracking, SIGNAL(clicked()), this, SLOT(OnStopTracking()) );
connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
connect( m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
connect( m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
connect( m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
connect( m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
connect( m_Controls->m_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
connect( m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
connect( m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
connect( m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
connect( m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
connect( m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
connect( m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
//initialize widgets
m_Controls->m_configurationWidget->EnableAdvancedUserControl(false);
m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
//initialize tracking volume node
m_TrackingVolumeNode = mitk::DataNode::New();
m_TrackingVolumeNode->SetName("TrackingVolume");
m_TrackingVolumeNode->SetOpacity(0.25);
m_TrackingVolumeNode->SetBoolProperty("Backface Culling",true);
mitk::Color red;
red.SetRed(1);
m_TrackingVolumeNode->SetColor(red);
GetDataStorage()->Add(m_TrackingVolumeNode);
//initialize buttons
m_Controls->m_Connect->setEnabled(true);
m_Controls->m_Disconnect->setEnabled(false);
m_Controls->m_StartTracking->setEnabled(false);
m_Controls->m_StopTracking->setEnabled(false);
m_Controls->m_AutoDetectTools->setVisible(false); //only visible if tracking device is Aurora
//Update List of available models for selected tool.
std::vector<mitk::TrackingDeviceData> Compatibles = mitk::GetDeviceDataForLine( m_Controls->m_configurationWidget->GetTrackingDevice()->GetType());
m_Controls->m_VolumeSelectionBox->clear();
for(int i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
}
void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
{
//read in filename
QString filename = QFileDialog::getOpenFileName(NULL,tr("Open Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
if (filename.isNull()) return;
//read tool storage from disk
std::string errorMessage = "";
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
// try-catch block for exceptions
try
{
m_toolStorage = myDeserializer->Deserialize(filename.toStdString());
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during deserializing. Problems with file,please check the file?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
return;
}
if(m_toolStorage->isEmpty())
{
errorMessage = myDeserializer->GetErrorMessage();
MessageBox(errorMessage);
return;
}
//update label
Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
m_Controls->m_toolLabel->setText(toolLabel);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
}
void QmitkMITKIGTTrackingToolboxView::OnResetTools()
{
m_toolStorage = NULL;
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
QString toolLabel = QString("Loaded Tools: <none>");
m_Controls->m_toolLabel->setText(toolLabel);
}
void QmitkMITKIGTTrackingToolboxView::OnConnect()
{
//check if everything is ready to start tracking
if (this->m_toolStorage.IsNull())
{
MessageBox("Error: No Tools Loaded Yet!");
return;
}
else if (this->m_toolStorage->GetToolCount() == 0)
{
MessageBox("Error: No Way To Track Without Tools!");
return;
}
//build the IGT pipeline
mitk::TrackingDevice::Pointer trackingDevice = this->m_Controls->m_configurationWidget->GetTrackingDevice();
//Get Tracking Volume Data
mitk::TrackingDeviceData data = mitk::DeviceDataUnspecified;
QString qstr = m_Controls->m_VolumeSelectionBox->currentText();
if ( (! qstr.isNull()) || (! qstr.isEmpty()) ) {
std::string str = qstr.toStdString();
data = mitk::GetDeviceDataByName(str); //Data will be set later, after device generation
}
//Create Navigation Data Source with the factory class
mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(this->m_toolStorage,trackingDevice);
m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(this->m_ToolVisualizationFilter);
+ MITK_INFO << "Number of tools: " << m_TrackingDeviceSource->GetNumberOfOutputs();
//First check if the created object is valid
if (m_TrackingDeviceSource.IsNull())
{
MessageBox(myTrackingDeviceSourceFactory->GetErrorMessage());
return;
}
//The tools are maybe reordered after initialization, e.g. in case of auto-detected tools of NDI Aurora
mitk::NavigationToolStorage::Pointer toolsInNewOrder = myTrackingDeviceSourceFactory->GetUpdatedNavigationToolStorage();
if ((toolsInNewOrder.IsNotNull()) && (toolsInNewOrder->GetToolCount() > 0))
{
//so delete the old tools in wrong order and add them in the right order
//we cannot simply replace the tool storage because the new storage is
//not correctly initialized with the right data storage
m_toolStorage->DeleteAllTools();
for (int i=0; i < toolsInNewOrder->GetToolCount(); i++) {m_toolStorage->AddTool(toolsInNewOrder->GetTool(i));}
}
//connect to device
try
{
m_TrackingDeviceSource->Connect();
//Microservice registration:
m_TrackingDeviceSource->RegisterAsMicroservice();
m_toolStorage->RegisterAsMicroservice(m_TrackingDeviceSource->GetMicroserviceID());
}
catch (...) //todo: change to mitk::IGTException
{
MessageBox("Error while starting the tracking device!");
return;
}
//enable/disable Buttons
m_Controls->m_Disconnect->setEnabled(true);
m_Controls->m_StartTracking->setEnabled(true);
m_Controls->m_StopTracking->setEnabled(false);
m_Controls->m_Connect->setEnabled(false);
DisableOptionsButtons();
DisableTrackingConfigurationButtons();
m_Controls->m_configurationWidget->ConfigurationFinished();
m_Controls->m_TrackingControlLabel->setText("Status: connected");
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
{
if (m_tracking) this->OnStopTracking();
m_TrackingDeviceSource->Disconnect();
m_TrackingDeviceSource->UnRegisterMicroservice();
//ToolStorages unregisters automatically
//enable/disable Buttons
m_Controls->m_Disconnect->setEnabled(false);
m_Controls->m_StartTracking->setEnabled(false);
m_Controls->m_StopTracking->setEnabled(false);
m_Controls->m_Connect->setEnabled(true);
EnableOptionsButtons();
EnableTrackingConfigurationButtons();
m_Controls->m_configurationWidget->Reset();
m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
}
void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
{
try
{
m_TrackingDeviceSource->StartTracking();
}
catch (...) //todo: change to mitk::IGTException
{
MessageBox("Error while starting the tracking device!");
return;
}
m_TrackingTimer->start(1000/(m_Controls->m_UpdateRate->value()));
m_Controls->m_TrackingControlLabel->setText("Status: tracking");
//connect the tool visualization widget
for(int i=0; i<m_TrackingDeviceSource->GetNumberOfOutputs(); i++)
{
m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_TrackingDeviceSource->GetOutput(i));
}
m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
if (m_Controls->m_ShowToolQuaternions->isChecked()) {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true);}
else {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false);}
//show tracking volume
this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
//enable/disable Buttons
m_Controls->m_Disconnect->setEnabled(true);
m_Controls->m_StartTracking->setEnabled(false);
m_Controls->m_StopTracking->setEnabled(true);
m_Controls->m_Connect->setEnabled(false);
m_tracking = true;
this->GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
{
if (!m_tracking) return;
m_TrackingTimer->stop();
m_TrackingDeviceSource->StopTracking();
m_Controls->m_TrackingControlLabel->setText("Status: connected");
if (m_logging) StopLogging();
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_tracking = false;
//enable/disable Buttons
m_Controls->m_Disconnect->setEnabled(true);
m_Controls->m_StartTracking->setEnabled(true);
m_Controls->m_StopTracking->setEnabled(false);
m_Controls->m_Connect->setEnabled(false);
this->GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
{
mitk::TrackingDeviceType Type = m_Controls->m_configurationWidget->GetTrackingDevice()->GetType();
// Code to enable/disable device specific buttons
if (Type == mitk::NDIAurora) //Aurora
{
m_Controls->m_AutoDetectTools->setVisible(true);
m_Controls->m_AddSingleTool->setEnabled(false);
}
else //Polaris or Microntracker
{
m_Controls->m_AutoDetectTools->setVisible(false);
m_Controls->m_AddSingleTool->setEnabled(true);
}
// Code to select appropriate tracking volume for current type
std::vector<mitk::TrackingDeviceData> Compatibles = mitk::GetDeviceDataForLine(Type);
m_Controls->m_VolumeSelectionBox->clear();
for(int i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
{
if (qstr.isNull()) return;
if (qstr.isEmpty()) return;
if (m_Controls->m_ShowTrackingVolume->isChecked())
{
mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
std::string str = qstr.toStdString();
mitk::TrackingDeviceData data = mitk::GetDeviceDataByName(str);
volumeGenerator->SetTrackingDeviceData(data);
volumeGenerator->Update();
mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
m_TrackingVolumeNode->SetData(volumeSurface);
GlobalReinit();
}
}
void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
{
if (m_Controls->m_ShowTrackingVolume->isChecked())
{
OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
GetDataStorage()->Add(m_TrackingVolumeNode);
}
else
{
GetDataStorage()->Remove(m_TrackingVolumeNode);
GlobalReinit();
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
{
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() == mitk::NDIAurora)
{
DisableTrackingConfigurationButtons();
mitk::NDITrackingDevice::Pointer currentDevice = dynamic_cast<mitk::NDITrackingDevice*>(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
currentDevice->OpenConnection();
currentDevice->StartTracking();
mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(this->GetDataStorage());
for (int i=0; i<currentDevice->GetToolCount(); i++)
{
//create a navigation tool with sphere as surface
std::stringstream toolname;
toolname << "AutoDetectedTool" << i;
mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
newTool->SetSerialNumber(dynamic_cast<mitk::NDIPassiveTool*>(currentDevice->GetTool(i))->GetSerialNumber());
newTool->SetIdentifier(toolname.str());
newTool->SetTrackingDeviceType(mitk::NDIAurora);
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
mitk::Surface::Pointer mySphere = mitk::Surface::New();
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(3.0f);
vtkData->SetCenter(0.0, 0.0, 0.0);
vtkData->Update();
mySphere->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
newNode->SetData(mySphere);
newNode->SetName(toolname.str());
newTool->SetDataNode(newNode);
autoDetectedStorage->AddTool(newTool);
}
//save detected tools
m_toolStorage = autoDetectedStorage;
//update label
QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
m_Controls->m_toolLabel->setText(toolLabel);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
currentDevice->StopTracking();
currentDevice->CloseConnection();
EnableTrackingConfigurationButtons();
if (m_toolStorage->GetToolCount()>0)
{
//ask the user if he wants to save the detected tools
QMessageBox msgBox;
switch(m_toolStorage->GetToolCount())
{
case 1:
msgBox.setText("Found one tool!");
break;
default:
msgBox.setText("Found " + QString::number(m_toolStorage->GetToolCount()) + " tools!");
}
msgBox.setInformativeText("Do you want to save this tools as tool storage, so you can load them again?");
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
msgBox.setDefaultButton(QMessageBox::No);
int ret = msgBox.exec();
if (ret == 16384) //yes
{
//ask the user for a filename
QString fileName = QFileDialog::getSaveFileName(NULL, tr("Save File"),"/",tr("*.IGTToolStorage"));
//check for empty filename
if(fileName == "") {return;}
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
//when Serialize method is used exceptions are thrown, need to be adapted
//try-catch block for exception handling in Serializer
try
{
mySerializer->Serialize(fileName.toStdString(),m_toolStorage);
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during serialization. Please check the Zip file.";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());}
return;
}
else if (ret == 65536) //no
{
return;
}
}
}
}
void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkMITKIGTTrackingToolboxView::UpdateTrackingTimer()
{
m_ToolVisualizationFilter->Update();
+ MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
+ MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
if (m_logging)
{
this->m_loggingFilter->Update();
m_loggedFrames = this->m_loggingFilter->GetRecordCounter();
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: "+QString::number(m_loggedFrames));
//check if logging stopped automatically
if((m_loggedFrames>1)&&(!m_loggingFilter->GetRecording())){StopLogging();}
}
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
{
QString filename = QFileDialog::getSaveFileName(NULL,tr("Choose Logging File"), "/", "*.*");
if (filename == "") return;
this->m_Controls->m_LoggingFileName->setText(filename);
}
void QmitkMITKIGTTrackingToolboxView::StartLogging()
{
if (!m_logging)
{
//initialize logging filter
m_loggingFilter = mitk::NavigationDataRecorder::New();
m_loggingFilter->SetRecordingMode(mitk::NavigationDataRecorder::NormalFile);
if (m_Controls->m_xmlFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::xml);
else if (m_Controls->m_csvFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::csv);
std::string filename = m_Controls->m_LoggingFileName->text().toStdString().c_str();
// this part has been changed in order to prevent crash of the program
if(!filename.empty())
m_loggingFilter->SetFileName(filename);
else if(filename.empty()){
std::string errormessage = "File name has not been set, please set the file name";
mitkThrowException(mitk::IGTIOException)<<errormessage;
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_loggingFilter->SetFileName(filename);
}
if (m_Controls->m_LoggingLimit->isChecked()){m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value());}
//connect filter
for(int i=0; i<m_ToolVisualizationFilter->GetNumberOfOutputs(); i++){m_loggingFilter->AddNavigationData(m_ToolVisualizationFilter->GetOutput(i));}
//start filter with try-catch block for exceptions
try
{
m_loggingFilter->StartRecording();
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start recording. Recorder already started recording?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_loggingFilter->StopRecording();
return;
}
//update labels / logging variables
this->m_Controls->m_LoggingLabel->setText("Logging ON");
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
m_loggedFrames = 0;
m_logging = true;
DisableLoggingButtons();
}
}
void QmitkMITKIGTTrackingToolboxView::StopLogging()
{
if (m_logging)
{
//update label
this->m_Controls->m_LoggingLabel->setText("Logging OFF");
m_loggingFilter->StopRecording();
m_logging = false;
EnableLoggingButtons();
}
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
{
QString Identifier = "Tool#";
if (m_toolStorage.IsNotNull()) Identifier += QString::number(m_toolStorage->GetToolCount());
else Identifier += "0";
m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(),Identifier.toStdString());
m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType(),false);
m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
if (this->m_toolStorage.IsNull()) m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
QString toolLabel = QString("Loaded Tools: <manually added>");
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
}
void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
{
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(false);
m_Controls->m_LoggingFileName->setEnabled(false);
m_Controls->m_ChooseFile->setEnabled(false);
m_Controls->m_LoggingLimit->setEnabled(false);
m_Controls->m_LoggedFramesLimit->setEnabled(false);
m_Controls->m_csvFormat->setEnabled(false);
m_Controls->m_xmlFormat->setEnabled(false);
m_Controls->m_StopLogging->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(true);
m_Controls->m_LoggingFileName->setEnabled(true);
m_Controls->m_ChooseFile->setEnabled(true);
m_Controls->m_LoggingLimit->setEnabled(true);
m_Controls->m_LoggedFramesLimit->setEnabled(true);
m_Controls->m_csvFormat->setEnabled(true);
m_Controls->m_xmlFormat->setEnabled(true);
m_Controls->m_StopLogging->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_ShowToolQuaternions->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(true);
m_Controls->m_UpdateRate->setEnabled(true);
m_Controls->m_ShowToolQuaternions->setEnabled(true);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(true);
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) m_Controls->m_AddSingleTool->setEnabled(true);
m_Controls->m_LoadTools->setEnabled(true);
m_Controls->m_ResetTools->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(false);
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) m_Controls->m_AddSingleTool->setEnabled(false);
m_Controls->m_LoadTools->setEnabled(false);
m_Controls->m_ResetTools->setEnabled(false);
}
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
index 4a7f2d3d74..f7e429234f 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,722 +1,723 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkImageStatisticsView.h"
// Qt includes
#include <qclipboard.h>
// berry includes
#include <berryIWorkbenchPage.h>
// mitk includes
#include "mitkNodePredicateDataType.h"
#include "mitkPlanarFigureInteractor.h"
// itk includes
#include "itksys/SystemTools.hxx"
#include <mitkILinkedRenderWindowPart.h>
#include <QmitkRenderWindow.h>
const std::string QmitkImageStatisticsView::VIEW_ID = "org.mitk.views.imagestatistics";
QmitkImageStatisticsView::QmitkImageStatisticsView(QObject* /*parent*/, const char* /*name*/)
: m_Controls( NULL ),
m_TimeStepperAdapter( NULL ),
m_SelectedImage( NULL ),
m_SelectedImageMask( NULL ),
m_SelectedPlanarFigure( NULL ),
m_ImageObserverTag( -1 ),
m_ImageMaskObserverTag( -1 ),
m_PlanarFigureObserverTag( -1 ),
m_CurrentStatisticsValid( false ),
m_StatisticsUpdatePending( false ),
m_DataNodeSelectionChanged ( false ),
m_Visible(false)
{
this->m_CalculationThread = new QmitkImageStatisticsCalculationThread;
}
QmitkImageStatisticsView::~QmitkImageStatisticsView()
{
if ( m_SelectedImage != NULL )
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
if ( m_SelectedImageMask != NULL )
m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
if ( m_SelectedPlanarFigure != NULL )
m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
while(this->m_CalculationThread->isRunning()) // wait until thread has finished
{
itksys::SystemTools::Delay(100);
}
delete this->m_CalculationThread;
}
void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
{
if (m_Controls == NULL)
{
m_Controls = new Ui::QmitkImageStatisticsViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
m_Controls->m_ErrorMessageLabel->hide();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
m_Controls->m_LineProfileWidget->SetPathModeToPlanarFigure();
}
}
void QmitkImageStatisticsView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(this->m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardHistogramButtonClicked()) );
connect( (QObject*)(this->m_Controls->m_ButtonCopyStatisticsToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardStatisticsButtonClicked()) );
connect( (QObject*)(this->m_Controls->m_IgnoreZerosCheckbox), SIGNAL(clicked()),(QObject*) this, SLOT(OnIgnoreZerosCheckboxClicked()) );
connect( (QObject*) this->m_CalculationThread, SIGNAL(finished()),this, SLOT( OnThreadedStatisticsCalculationEnds()),Qt::QueuedConnection);
connect( (QObject*) this, SIGNAL(StatisticsUpdate()),this, SLOT( RequestStatisticsUpdate()), Qt::QueuedConnection);
connect( (QObject*) this->m_Controls->m_StatisticsTable, SIGNAL(cellDoubleClicked(int,int)),this, SLOT( JumpToCoordinates(int,int)) );
connect( (QObject*) (this->m_Controls->m_barRadioButton), SIGNAL(clicked()), (QObject*) (this->m_Controls->m_JSHistogram), SLOT(OnBarRadioButtonSelected()));
connect( (QObject*) (this->m_Controls->m_lineRadioButton), SIGNAL(clicked()), (QObject*) (this->m_Controls->m_JSHistogram), SLOT(OnLineRadioButtonSelected()));
}
}
void QmitkImageStatisticsView::JumpToCoordinates(int row ,int col)
{
mitk::Point3D world;
if (row==4)
world = m_WorldMin;
else if (row==3)
world = m_WorldMax;
else
return;
mitk::IRenderWindowPart* part = this->GetRenderWindowPart();
if (part)
{
part->GetRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(world);
part->GetRenderWindow("sagittal")->GetSliceNavigationController()->SelectSliceByPoint(world);
part->GetRenderWindow("coronal")->GetSliceNavigationController()->SelectSliceByPoint(world);
}
}
void QmitkImageStatisticsView::OnIgnoreZerosCheckboxClicked()
{
emit StatisticsUpdate();
}
void QmitkImageStatisticsView::OnClipboardHistogramButtonClicked()
{
if ( m_CurrentStatisticsValid )
{
typedef mitk::ImageStatisticsCalculator::HistogramType HistogramType;
const HistogramType *histogram = this->m_CalculationThread->GetTimeStepHistogram().GetPointer();
QString clipboard( "Measurement \t Frequency\n" );
for ( HistogramType::ConstIterator it = histogram->Begin();
it != histogram->End();
++it )
{
clipboard = clipboard.append( "%L1 \t %L2\n" )
.arg( it.GetMeasurementVector()[0], 0, 'f', 2 )
.arg( it.GetFrequency() );
}
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
}
void QmitkImageStatisticsView::OnClipboardStatisticsButtonClicked()
{
if ( this->m_CurrentStatisticsValid )
{
const mitk::ImageStatisticsCalculator::Statistics &statistics =
this->m_CalculationThread->GetStatisticsData();
// Copy statistics to clipboard ("%Ln" will use the default locale for
// number formatting)
QString clipboard( "Mean \t StdDev \t RMS \t Max \t Min \t N \t V (mm³)\n" );
clipboard = clipboard.append( "%L1 \t %L2 \t %L3 \t %L4 \t %L5 \t %L6 \t %L7" )
.arg( statistics.Mean, 0, 'f', 10 )
.arg( statistics.Sigma, 0, 'f', 10 )
.arg( statistics.RMS, 0, 'f', 10 )
.arg( statistics.Max, 0, 'f', 10 )
.arg( statistics.Min, 0, 'f', 10 )
.arg( statistics.N )
.arg( m_Controls->m_StatisticsTable->item( 0, 6 )->text() );
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
}
void QmitkImageStatisticsView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*part*/,
const QList<mitk::DataNode::Pointer> &selectedNodes )
{
if (this->m_Visible)
{
this->SelectionChanged( selectedNodes );
}
else
{
this->m_DataNodeSelectionChanged = true;
}
}
void QmitkImageStatisticsView::SelectionChanged(const QList<mitk::DataNode::Pointer> &selectedNodes)
{
if( this->m_StatisticsUpdatePending )
{
this->m_DataNodeSelectionChanged = true;
return; // not ready for new data now!
}
if (selectedNodes.size() == this->m_SelectedDataNodes.size())
{
int i = 0;
for (; i < selectedNodes.size(); ++i)
{
if (selectedNodes.at(i) != this->m_SelectedDataNodes.at(i))
{
break;
}
}
// node selection did not change
if (i == selectedNodes.size()) return;
}
this->ReinitData();
if (!selectedNodes.size())
{
m_Controls->m_JSHistogram->ClearHistogram();
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_InfoLabel->setText(QString(""));
}
if(selectedNodes.size() == 1 || selectedNodes.size() == 2)
{
bool isBinary = false;
selectedNodes.value(0)->GetBoolProperty("binary",isBinary);
if(isBinary)
{
m_Controls->m_JSHistogram->ClearHistogram();
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_InfoLabel->setText(QString(""));
}
for (int i= 0; i< selectedNodes.size(); ++i)
{
this->m_SelectedDataNodes.push_back(selectedNodes.at(i));
}
this->m_DataNodeSelectionChanged = false;
this->m_Controls->m_ErrorMessageLabel->setText( "" );
this->m_Controls->m_ErrorMessageLabel->hide();
emit StatisticsUpdate();
}
else
{
this->m_DataNodeSelectionChanged = false;
}
}
void QmitkImageStatisticsView::ReinitData()
{
while( this->m_CalculationThread->isRunning()) // wait until thread has finished
{
itksys::SystemTools::Delay(100);
}
if(this->m_SelectedImage != NULL)
{
this->m_SelectedImage->RemoveObserver( this->m_ImageObserverTag);
this->m_SelectedImage = NULL;
}
if(this->m_SelectedImageMask != NULL)
{
this->m_SelectedImageMask->RemoveObserver( this->m_ImageMaskObserverTag);
this->m_SelectedImageMask = NULL;
}
if(this->m_SelectedPlanarFigure != NULL)
{
this->m_SelectedPlanarFigure->RemoveObserver( this->m_PlanarFigureObserverTag);
this->m_SelectedPlanarFigure = NULL;
}
this->m_SelectedDataNodes.clear();
this->m_StatisticsUpdatePending = false;
m_Controls->m_ErrorMessageLabel->setText( "" );
m_Controls->m_ErrorMessageLabel->hide();
this->InvalidateStatisticsTableView();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
}
void QmitkImageStatisticsView::OnThreadedStatisticsCalculationEnds()
{
std::stringstream message;
message << "";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->hide();
this->WriteStatisticsToGUI();
}
void QmitkImageStatisticsView::UpdateStatistics()
{
mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
if ( renderPart == NULL )
{
this->m_StatisticsUpdatePending = false;
return;
}
m_WorldMin.Fill(-1);
m_WorldMax.Fill(-1);
// classify selected nodes
mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
std::string maskName = std::string();
std::string maskType = std::string();
unsigned int maskDimension = 0;
// reset data from last run
ITKCommandType::Pointer changeListener = ITKCommandType::New();
changeListener->SetCallbackFunction( this, &QmitkImageStatisticsView::SelectedDataModified );
mitk::DataNode::Pointer planarFigureNode;
for( int i= 0 ; i < this->m_SelectedDataNodes.size(); ++i)
{
mitk::PlanarFigure::Pointer planarFig = dynamic_cast<mitk::PlanarFigure*>(this->m_SelectedDataNodes.at(i)->GetData());
if( imagePredicate->CheckNode(this->m_SelectedDataNodes.at(i)) )
{
bool isMask = false;
this->m_SelectedDataNodes.at(i)->GetPropertyValue("binary", isMask);
if( this->m_SelectedImageMask == NULL && isMask)
{
this->m_SelectedImageMask = dynamic_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
this->m_ImageMaskObserverTag = this->m_SelectedImageMask->AddObserver(itk::ModifiedEvent(), changeListener);
maskName = this->m_SelectedDataNodes.at(i)->GetName();
maskType = m_SelectedImageMask->GetNameOfClass();
maskDimension = 3;
}
else if( !isMask )
{
if(this->m_SelectedImage == NULL)
{
this->m_SelectedImage = static_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
}
}
}
else if (planarFig.IsNotNull())
{
if(this->m_SelectedPlanarFigure == NULL)
{
this->m_SelectedPlanarFigure = planarFig;
this->m_PlanarFigureObserverTag =
this->m_SelectedPlanarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), changeListener);
maskName = this->m_SelectedDataNodes.at(i)->GetName();
maskType = this->m_SelectedPlanarFigure->GetNameOfClass();
maskDimension = 2;
planarFigureNode = m_SelectedDataNodes.at(i);
}
}
else
{
std::stringstream message;
message << "<font color='red'>" << "Invalid data node type!" << "</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
}
}
if(maskName == "")
{
maskName = "None";
maskType = "";
maskDimension = 0;
}
if (m_SelectedPlanarFigure != NULL && m_SelectedImage == NULL)
{
mitk::DataStorage::SetOfObjects::ConstPointer parentSet = this->GetDataStorage()->GetSources(planarFigureNode);
for (int i=0; i<parentSet->Size(); i++)
{
mitk::DataNode::Pointer node = parentSet->ElementAt(i);
if( imagePredicate->CheckNode(node) )
{
bool isMask = false;
node->GetPropertyValue("binary", isMask);
if( !isMask )
{
if(this->m_SelectedImage == NULL)
{
this->m_SelectedImage = static_cast<mitk::Image*>(node->GetData());
this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
}
}
}
}
}
unsigned int timeStep = renderPart->GetTimeNavigationController()->GetTime()->GetPos();
if ( m_SelectedImage != NULL && m_SelectedImage->IsInitialized())
{
// Check if a the selected image is a multi-channel image. If yes, statistics
// cannot be calculated currently.
if ( m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
{
std::stringstream message;
message << "<font color='red'>Multi-component images not supported.</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
this->InvalidateStatisticsTableView();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
m_Controls->m_JSHistogram->ClearHistogram();
m_CurrentStatisticsValid = false;
this->m_StatisticsUpdatePending = false;
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_InfoLabel->setText(QString(""));
return;
}
std::stringstream maskLabel;
maskLabel << maskName;
if ( maskDimension > 0 )
{
maskLabel << " [" << maskDimension << "D " << maskType << "]";
}
m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
// check time step validity
if(m_SelectedImage->GetDimension() <= 3 && timeStep > m_SelectedImage->GetDimension(3)-1)
{
timeStep = m_SelectedImage->GetDimension(3)-1;
}
//// initialize thread and trigger it
this->m_CalculationThread->SetIgnoreZeroValueVoxel( m_Controls->m_IgnoreZerosCheckbox->isChecked() );
this->m_CalculationThread->Initialize( m_SelectedImage, m_SelectedImageMask, m_SelectedPlanarFigure );
this->m_CalculationThread->SetTimeStep( timeStep );
std::stringstream message;
message << "<font color='red'>Calculating statistics...</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
try
{
// Compute statistics
this->m_CalculationThread->start();
}
catch ( const mitk::Exception& e)
{
std::stringstream message;
message << "<font color='red'>" << e.GetDescription() << "</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
this->m_StatisticsUpdatePending = false;
}
catch ( const std::runtime_error &e )
{
// In case of exception, print error message on GUI
std::stringstream message;
message << "<font color='red'>" << e.what() << "</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
this->m_StatisticsUpdatePending = false;
}
catch ( const std::exception &e )
{
MITK_ERROR << "Caught exception: " << e.what();
// In case of exception, print error message on GUI
std::stringstream message;
message << "<font color='red'>Error! Unequal Dimensions of Image and Segmentation. No recompute possible </font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
this->m_StatisticsUpdatePending = false;
}
}
else
{
this->m_StatisticsUpdatePending = false;
}
}
void QmitkImageStatisticsView::SelectedDataModified()
{
if( !m_StatisticsUpdatePending )
{
emit StatisticsUpdate();
}
}
void QmitkImageStatisticsView::NodeRemoved(const mitk::DataNode *node)
{
while(this->m_CalculationThread->isRunning()) // wait until thread has finished
{
itksys::SystemTools::Delay(100);
}
if (node->GetData() == m_SelectedImage)
{
m_SelectedImage = NULL;
}
}
void QmitkImageStatisticsView::RequestStatisticsUpdate()
{
if ( !m_StatisticsUpdatePending )
{
if(this->m_DataNodeSelectionChanged)
{
this->SelectionChanged(this->GetCurrentSelection());
}
else
{
this->m_StatisticsUpdatePending = true;
this->UpdateStatistics();
}
}
if (this->GetRenderWindowPart())
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkImageStatisticsView::WriteStatisticsToGUI()
{
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_InfoLabel->setText(QString(""));
if(m_DataNodeSelectionChanged)
{
this->m_StatisticsUpdatePending = false;
this->RequestStatisticsUpdate();
return; // stop visualization of results and calculate statistics of new selection
}
if ( this->m_CalculationThread->GetStatisticsUpdateSuccessFlag())
{
if ( this->m_CalculationThread->GetStatisticsChangedFlag() )
{
// Do not show any error messages
m_Controls->m_ErrorMessageLabel->hide();
m_CurrentStatisticsValid = true;
}
if (m_Controls->m_barRadioButton->isChecked())
{
m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
}
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
m_Controls->m_JSHistogram->ComputeHistogram( this->m_CalculationThread->GetTimeStepHistogram().GetPointer() );
this->FillStatisticsTableView( this->m_CalculationThread->GetStatisticsData(), this->m_CalculationThread->GetStatisticsImage());
}
else
{
m_Controls->m_SelectedMaskLabel->setText( "None" );
m_Controls->m_ErrorMessageLabel->setText( m_CalculationThread->GetLastErrorMessage().c_str() );
m_Controls->m_ErrorMessageLabel->show();
// Clear statistics and histogram
this->InvalidateStatisticsTableView();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
//m_Controls->m_JSHistogram->clearHistogram();
m_CurrentStatisticsValid = false;
// If a (non-closed) PlanarFigure is selected, display a line profile widget
if ( m_SelectedPlanarFigure != NULL )
{
// check whether PlanarFigure is initialized
const mitk::Geometry2D *planarFigureGeometry2D = m_SelectedPlanarFigure->GetGeometry2D();
if ( planarFigureGeometry2D == NULL )
{
// Clear statistics, histogram, and GUI
this->InvalidateStatisticsTableView();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
m_Controls->m_JSHistogram->ClearHistogram();
m_CurrentStatisticsValid = false;
m_Controls->m_ErrorMessageLabel->hide();
m_Controls->m_SelectedMaskLabel->setText( "None" );
this->m_StatisticsUpdatePending = false;
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_InfoLabel->setText(QString(""));
return;
}
unsigned int timeStep = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
m_Controls->m_JSHistogram->SetImage(this->m_CalculationThread->GetStatisticsImage());
m_Controls->m_JSHistogram->SetPlanarFigure(m_SelectedPlanarFigure);
m_Controls->m_JSHistogram->ComputeIntensityProfile(timeStep);
m_Controls->m_lineRadioButton->setEnabled(false);
m_Controls->m_barRadioButton->setEnabled(false);
std::stringstream message;
message << "<font color='red'>Only linegraph available for an intesityprofile!</font>";
m_Controls->m_InfoLabel->setText(message.str().c_str());
}
}
this->m_StatisticsUpdatePending = false;
}
void QmitkImageStatisticsView::ComputeIntensityProfile( mitk::PlanarLine* line )
{
double sampling = 300;
QmitkVtkHistogramWidget::HistogramType::Pointer histogram = QmitkVtkHistogramWidget::HistogramType::New();
- itk::Size<1> siz;
- siz[0] = sampling;
- itk::FixedArray<double,1> lower, higher;
+ QmitkVtkHistogramWidget::HistogramType::SizeType size;
+ size.Fill(1);
+ size[0] = sampling;
+ itk::Array<double> lower, higher;
lower.Fill(0);
mitk::Point3D begin = line->GetWorldControlPoint(0);
mitk::Point3D end = line->GetWorldControlPoint(1);
itk::Vector<double,3> direction = (end - begin);
higher.Fill(direction.GetNorm());
- histogram->Initialize(siz, lower, higher);
+ histogram->Initialize(size, lower, higher);
for(int i = 0; i < sampling; i++)
{
- double d = m_SelectedImage->GetPixelValueByWorldCoordinate(begin + double(i)/sampling * direction);
+ double d = m_SelectedImage->GetPixelValueByWorldCoordinate(begin + mitk::Point3D::VectorType(double(i)/sampling * direction));
histogram->SetFrequency(i,d);
}
m_Controls->m_JSHistogram->ComputeHistogram( histogram );
}
void QmitkImageStatisticsView::FillStatisticsTableView(
const mitk::ImageStatisticsCalculator::Statistics &s,
const mitk::Image *image )
{
if (s.MaxIndex.size()==3)
{
mitk::Point3D index;
index[0] = s.MaxIndex[0];
index[1] = s.MaxIndex[1];
index[2] = s.MaxIndex[2];
m_SelectedImage->GetGeometry()->IndexToWorld(index, m_WorldMax);
index[0] = s.MinIndex[0];
index[1] = s.MinIndex[1];
index[2] = s.MinIndex[2];
m_SelectedImage->GetGeometry()->IndexToWorld(index, m_WorldMin);
}
int decimals = 2;
mitk::PixelType doublePix = mitk::MakeScalarPixelType< double >();
mitk::PixelType floatPix = mitk::MakeScalarPixelType< float >();
if (image->GetPixelType()==doublePix || image->GetPixelType()==floatPix)
decimals = 5;
this->m_Controls->m_StatisticsTable->setItem( 0, 0, new QTableWidgetItem(
QString("%1").arg(s.Mean, 0, 'f', decimals) ) );
this->m_Controls->m_StatisticsTable->setItem( 0, 1, new QTableWidgetItem(
QString("%1").arg(s.Sigma, 0, 'f', decimals) ) );
this->m_Controls->m_StatisticsTable->setItem( 0, 2, new QTableWidgetItem(
QString("%1").arg(s.RMS, 0, 'f', decimals) ) );
QString max; max.append(QString("%1").arg(s.Max, 0, 'f', decimals));
max += " (";
for (int i=0; i<s.MaxIndex.size(); i++)
{
max += QString::number(s.MaxIndex[i]);
if (i<s.MaxIndex.size()-1)
max += ",";
}
max += ")";
this->m_Controls->m_StatisticsTable->setItem( 0, 3, new QTableWidgetItem( max ) );
QString min; min.append(QString("%1").arg(s.Min, 0, 'f', decimals));
min += " (";
for (int i=0; i<s.MinIndex.size(); i++)
{
min += QString::number(s.MinIndex[i]);
if (i<s.MinIndex.size()-1)
min += ",";
}
min += ")";
this->m_Controls->m_StatisticsTable->setItem( 0, 4, new QTableWidgetItem( min ) );
this->m_Controls->m_StatisticsTable->setItem( 0, 5, new QTableWidgetItem(
QString("%1").arg(s.N) ) );
const mitk::Geometry3D *geometry = image->GetGeometry();
if ( geometry != NULL )
{
const mitk::Vector3D &spacing = image->GetGeometry()->GetSpacing();
double volume = spacing[0] * spacing[1] * spacing[2] * (double) s.N;
this->m_Controls->m_StatisticsTable->setItem( 0, 6, new QTableWidgetItem(
QString("%1").arg(volume, 0, 'f', decimals) ) );
}
else
{
this->m_Controls->m_StatisticsTable->setItem( 0, 6, new QTableWidgetItem(
"NA" ) );
}
}
void QmitkImageStatisticsView::InvalidateStatisticsTableView()
{
for ( unsigned int i = 0; i < 7; ++i )
{
this->m_Controls->m_StatisticsTable->setItem( 0, i, new QTableWidgetItem( "NA" ) );
}
}
void QmitkImageStatisticsView::Activated()
{
}
void QmitkImageStatisticsView::Deactivated()
{
}
void QmitkImageStatisticsView::Visible()
{
m_Visible = true;
if (m_DataNodeSelectionChanged)
{
if (this->IsCurrentSelectionValid())
{
this->SelectionChanged(this->GetCurrentSelection());
}
else
{
this->SelectionChanged(this->GetDataManagerSelection());
}
m_DataNodeSelectionChanged = false;
}
}
void QmitkImageStatisticsView::Hidden()
{
m_Visible = false;
}
void QmitkImageStatisticsView::SetFocus()
{
}
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
index b24ecc7980..0439fedde7 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
@@ -1,751 +1,751 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#define MEASUREMENT_DEBUG MITK_DEBUG("QmitkMeasurementView") << __LINE__ << ": "
#include "QmitkMeasurementView.h"
#include <QtGui>
#include <mitkVtkLayerController.h>
#include <mitkWeakPointer.h>
#include <mitkPlanarCircle.h>
#include <mitkPlanarPolygon.h>
#include <mitkPlanarAngle.h>
#include <mitkPlanarRectangle.h>
#include <mitkPlanarLine.h>
#include <mitkPlanarCross.h>
#include <mitkPlanarFourPointAngle.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkPlaneGeometry.h>
#include <mitkGlobalInteraction.h>
#include <mitkILinkedRenderWindowPart.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateNot.h>
#include <QmitkRenderWindow.h>
struct QmitkPlanarFigureData
{
QmitkPlanarFigureData()
: m_Figure(0), m_EndPlacementObserverTag(0), m_SelectObserverTag(0), m_StartInteractionObserverTag(0), m_EndInteractionObserverTag(0)
{
}
mitk::PlanarFigure* m_Figure;
unsigned int m_EndPlacementObserverTag;
unsigned int m_SelectObserverTag;
unsigned int m_StartInteractionObserverTag;
unsigned int m_EndInteractionObserverTag;
};
struct QmitkMeasurementViewData
{
QmitkMeasurementViewData()
: m_LineCounter(0), m_PathCounter(0), m_AngleCounter(0),
m_FourPointAngleCounter(0), m_EllipseCounter(0),
m_RectangleCounter(0), m_PolygonCounter(0), m_UnintializedPlanarFigure(false)
{
}
// internal vars
unsigned int m_LineCounter;
unsigned int m_PathCounter;
unsigned int m_AngleCounter;
unsigned int m_FourPointAngleCounter;
unsigned int m_EllipseCounter;
unsigned int m_RectangleCounter;
unsigned int m_PolygonCounter;
QList<mitk::DataNode::Pointer> m_CurrentSelection;
std::map<mitk::DataNode*, QmitkPlanarFigureData> m_DataNodeToPlanarFigureData;
mitk::WeakPointer<mitk::DataNode> m_SelectedImageNode;
bool m_UnintializedPlanarFigure;
// WIDGETS
QWidget* m_Parent;
QLabel* m_SelectedImageLabel;
QAction* m_DrawLine;
QAction* m_DrawPath;
QAction* m_DrawAngle;
QAction* m_DrawFourPointAngle;
QAction* m_DrawEllipse;
QAction* m_DrawRectangle;
QAction* m_DrawPolygon;
QToolBar* m_DrawActionsToolBar;
QActionGroup* m_DrawActionsGroup;
QTextBrowser* m_SelectedPlanarFiguresText;
QPushButton* m_CopyToClipboard;
QGridLayout* m_Layout;
};
const std::string QmitkMeasurementView::VIEW_ID = "org.mitk.views.measurement";
QmitkMeasurementView::QmitkMeasurementView()
: d( new QmitkMeasurementViewData )
{
}
QmitkMeasurementView::~QmitkMeasurementView()
{
this->RemoveAllInteractors();
delete d;
}
void QmitkMeasurementView::CreateQtPartControl(QWidget* parent)
{
d->m_Parent = parent;
// image label
QLabel* selectedImageLabel = new QLabel("Reference Image: ");
d->m_SelectedImageLabel = new QLabel;
d->m_SelectedImageLabel->setStyleSheet("font-weight: bold;");
d->m_DrawActionsToolBar = new QToolBar;
d->m_DrawActionsGroup = new QActionGroup(this);
d->m_DrawActionsGroup->setExclusive(true);
//# add actions
MEASUREMENT_DEBUG << "Draw Line";
QAction* currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
":/measurement/line.png"), "Draw Line");
currentAction->setCheckable(true);
d->m_DrawLine = currentAction;
d->m_DrawActionsToolBar->addAction(currentAction);
d->m_DrawActionsGroup->addAction(currentAction);
MEASUREMENT_DEBUG << "Draw Path";
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
":/measurement/path.png"), "Draw Path");
currentAction->setCheckable(true);
d->m_DrawPath = currentAction;
d->m_DrawActionsToolBar->addAction(currentAction);
d->m_DrawActionsGroup->addAction(currentAction);
MEASUREMENT_DEBUG << "Draw Angle";
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
":/measurement/angle.png"), "Draw Angle");
currentAction->setCheckable(true);
d->m_DrawAngle = currentAction;
d->m_DrawActionsToolBar->addAction(currentAction);
d->m_DrawActionsGroup->addAction(currentAction);
MEASUREMENT_DEBUG << "Draw Four Point Angle";
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
":/measurement/four-point-angle.png"), "Draw Four Point Angle");
currentAction->setCheckable(true);
d->m_DrawFourPointAngle = currentAction;
d->m_DrawActionsToolBar->addAction(currentAction);
d->m_DrawActionsGroup->addAction(currentAction);
MEASUREMENT_DEBUG << "Draw Circle";
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
":/measurement/circle.png"), "Draw Circle");
currentAction->setCheckable(true);
d->m_DrawEllipse = currentAction;
d->m_DrawActionsToolBar->addAction(currentAction);
d->m_DrawActionsGroup->addAction(currentAction);
MEASUREMENT_DEBUG << "Draw Rectangle";
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
":/measurement/rectangle.png"), "Draw Rectangle");
currentAction->setCheckable(true);
d->m_DrawRectangle = currentAction;
d->m_DrawActionsToolBar->addAction(currentAction);
d->m_DrawActionsGroup->addAction(currentAction);
MEASUREMENT_DEBUG << "Draw Polygon";
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
":/measurement/polygon.png"), "Draw Polygon");
currentAction->setCheckable(true);
d->m_DrawPolygon = currentAction;
d->m_DrawActionsToolBar->addAction(currentAction);
d->m_DrawActionsGroup->addAction(currentAction);
// planar figure details text
d->m_SelectedPlanarFiguresText = new QTextBrowser;
// copy to clipboard button
d->m_CopyToClipboard = new QPushButton("Copy to Clipboard");
d->m_Layout = new QGridLayout;
d->m_Layout->addWidget(selectedImageLabel, 0, 0, 1, 1);
d->m_Layout->addWidget(d->m_SelectedImageLabel, 0, 1, 1, 1);
d->m_Layout->addWidget(d->m_DrawActionsToolBar, 1, 0, 1, 2);
d->m_Layout->addWidget(d->m_SelectedPlanarFiguresText, 2, 0, 1, 2);
d->m_Layout->addWidget(d->m_CopyToClipboard, 3, 0, 1, 2);
d->m_Parent->setLayout(d->m_Layout);
// create connections
this->CreateConnections();
// readd interactors and observers
this->AddAllInteractors();
}
void QmitkMeasurementView::CreateConnections()
{
QObject::connect( d->m_DrawLine, SIGNAL( triggered(bool) )
, this, SLOT( ActionDrawLineTriggered(bool) ) );
QObject::connect( d->m_DrawPath, SIGNAL( triggered(bool) )
, this, SLOT( ActionDrawPathTriggered(bool) ) );
QObject::connect( d->m_DrawAngle, SIGNAL( triggered(bool) )
, this, SLOT( ActionDrawAngleTriggered(bool) ) );
QObject::connect( d->m_DrawFourPointAngle, SIGNAL( triggered(bool) )
, this, SLOT( ActionDrawFourPointAngleTriggered(bool) ) );
QObject::connect( d->m_DrawEllipse, SIGNAL( triggered(bool) )
, this, SLOT( ActionDrawEllipseTriggered(bool) ) );
QObject::connect( d->m_DrawRectangle, SIGNAL( triggered(bool) )
, this, SLOT( ActionDrawRectangleTriggered(bool) ) );
QObject::connect( d->m_DrawPolygon, SIGNAL( triggered(bool) )
, this, SLOT( ActionDrawPolygonTriggered(bool) ) );
QObject::connect( d->m_CopyToClipboard, SIGNAL( clicked(bool) )
, this, SLOT( CopyToClipboard(bool) ) );
}
void QmitkMeasurementView::NodeAdded( const mitk::DataNode* node )
{
// add observer for selection in renderwindow
mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
bool isPositionMarker (false);
node->GetBoolProperty("isContourMarker", isPositionMarker);
if( figure && !isPositionMarker )
{
MEASUREMENT_DEBUG << "figure added. will add interactor if needed.";
mitk::PlanarFigureInteractor::Pointer figureInteractor
= dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", nonConstNode);
}
else
{
// just to be sure that the interactor is not added twice
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
}
MEASUREMENT_DEBUG << "adding interactor to globalinteraction";
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
MEASUREMENT_DEBUG << "will now add observers for planarfigure";
QmitkPlanarFigureData data;
data.m_Figure = figure;
// add observer for event when figure has been placed
typedef itk::SimpleMemberCommand< QmitkMeasurementView > SimpleCommandType;
SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
initializationCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureInitialized );
data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
// add observer for event when figure is picked (selected)
typedef itk::MemberCommand< QmitkMeasurementView > MemberCommandType;
MemberCommandType::Pointer selectCommand = MemberCommandType::New();
selectCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureSelected );
data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
// add observer for event when interaction with figure starts
SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
startInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::DisableCrosshairNavigation);
data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
// add observer for event when interaction with figure starts
SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
endInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::EnableCrosshairNavigation);
data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
// adding to the map of tracked planarfigures
d->m_DataNodeToPlanarFigureData[nonConstNode] = data;
}
this->CheckForTopMostVisibleImage();
}
void QmitkMeasurementView::NodeChanged(const mitk::DataNode* node)
{
// DETERMINE IF WE HAVE TO RENEW OUR DETAILS TEXT (ANY NODE CHANGED IN OUR SELECTION?)
bool renewText = false;
for( int i=0; i < d->m_CurrentSelection.size(); ++i )
{
if( node == d->m_CurrentSelection.at(i) )
{
renewText = true;
break;
}
}
if(renewText)
{
MEASUREMENT_DEBUG << "Selected nodes changed. Refreshing text.";
this->UpdateMeasurementText();
}
this->CheckForTopMostVisibleImage();
}
void QmitkMeasurementView::CheckForTopMostVisibleImage(mitk::DataNode* _NodeToNeglect)
{
d->m_SelectedImageNode = this->DetectTopMostVisibleImage().GetPointer();
if( d->m_SelectedImageNode.GetPointer() == _NodeToNeglect )
d->m_SelectedImageNode = 0;
if( d->m_SelectedImageNode.IsNotNull() && d->m_UnintializedPlanarFigure == false )
{
MEASUREMENT_DEBUG << "Reference image found";
d->m_SelectedImageLabel->setText( QString::fromStdString( d->m_SelectedImageNode->GetName() ) );
d->m_DrawActionsToolBar->setEnabled(true);
MEASUREMENT_DEBUG << "Updating Measurement text";
}
else
{
MEASUREMENT_DEBUG << "No reference image available. Will disable actions for creating new planarfigures";
if( d->m_UnintializedPlanarFigure == false )
d->m_SelectedImageLabel->setText( "No visible image available." );
d->m_DrawActionsToolBar->setEnabled(false);
}
}
void QmitkMeasurementView::NodeRemoved(const mitk::DataNode* node)
{
MEASUREMENT_DEBUG << "node removed from data storage";
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
d->m_DataNodeToPlanarFigureData.find(nonConstNode);
bool isFigureFinished = false;
bool isPlaced = false;
if( it != d->m_DataNodeToPlanarFigureData.end() )
{
QmitkPlanarFigureData& data = it->second;
// remove observers
data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
MEASUREMENT_DEBUG << "removing from the list of tracked planar figures";
- d->m_DataNodeToPlanarFigureData.erase( it );
isFigureFinished = data.m_Figure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
}
+ d->m_DataNodeToPlanarFigureData.erase( it );
}
mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
mitk::DataStorage::SetOfObjects::ConstPointer nodes =
GetDataStorage()->GetDerivations(node,isPlanarFigure);
for (unsigned int x = 0; x < nodes->size(); x++)
{
mitk::PlanarFigure* planarFigure = dynamic_cast<mitk::PlanarFigure*> (nodes->at(x)->GetData());
if (planarFigure != NULL) {
isFigureFinished = planarFigure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
GetDataStorage()->Remove(nodes->at(x));
if( !d->m_DataNodeToPlanarFigureData.empty() )
{
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it2 =
d->m_DataNodeToPlanarFigureData.find(nodes->at(x));
//check if returned it2 valid
if( it2 != d->m_DataNodeToPlanarFigureData.end() )
{
d->m_DataNodeToPlanarFigureData.erase( it2 );// removing planar figure from tracked figure list
PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
EnableCrosshairNavigation();
}
}
}
}
}
this->CheckForTopMostVisibleImage(nonConstNode);
}
void QmitkMeasurementView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
{
MEASUREMENT_DEBUG << "planar figure " << object << " selected";
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
d->m_DataNodeToPlanarFigureData.begin();
d->m_CurrentSelection.clear();
while( it != d->m_DataNodeToPlanarFigureData.end())
{
mitk::DataNode* node = it->first;
QmitkPlanarFigureData& data = it->second;
if( data.m_Figure == object )
{
MITK_DEBUG << "selected node found. enabling selection";
node->SetSelected(true);
d->m_CurrentSelection.push_back( node );
}
else
{
node->SetSelected(false);
}
++it;
}
this->UpdateMeasurementText();
this->RequestRenderWindowUpdate();
}
void QmitkMeasurementView::PlanarFigureInitialized()
{
MEASUREMENT_DEBUG << "planar figure initialized";
d->m_UnintializedPlanarFigure = false;
d->m_DrawActionsToolBar->setEnabled(true);
d->m_DrawLine->setChecked(false);
d->m_DrawPath->setChecked(false);
d->m_DrawAngle->setChecked(false);
d->m_DrawFourPointAngle->setChecked(false);
d->m_DrawEllipse->setChecked(false);
d->m_DrawRectangle->setChecked(false);
d->m_DrawPolygon->setChecked(false);
}
void QmitkMeasurementView::SetFocus()
{
d->m_SelectedImageLabel->setFocus();
}
void QmitkMeasurementView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
const QList<mitk::DataNode::Pointer> &nodes)
{
MEASUREMENT_DEBUG << "Determine the top most visible image";
MEASUREMENT_DEBUG << "The PlanarFigure interactor will take the currently visible PlaneGeometry from the slice navigation controller";
this->CheckForTopMostVisibleImage();
MEASUREMENT_DEBUG << "refreshing selection and detailed text";
d->m_CurrentSelection = nodes;
this->UpdateMeasurementText();
for( int i=d->m_CurrentSelection.size()-1; i>= 0; --i)
{
mitk::DataNode* node = d->m_CurrentSelection.at(i);
mitk::PlanarFigure* _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
// the last selected planar figure
if( _PlanarFigure )
{
mitk::ILinkedRenderWindowPart* linkedRenderWindow =
dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
if( linkedRenderWindow )
{
mitk::Point3D centerP = _PlanarFigure->GetGeometry()->GetOrigin();
linkedRenderWindow->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(centerP);
}
break;
}
}
this->RequestRenderWindowUpdate();
}
void QmitkMeasurementView::ActionDrawLineTriggered(bool checked)
{
Q_UNUSED(checked)
mitk::PlanarLine::Pointer figure = mitk::PlanarLine::New();
QString qString = QString("Line%1").arg(++d->m_LineCounter);
this->AddFigureToDataStorage(figure, qString);
MEASUREMENT_DEBUG << "PlanarLine initialized...";
}
void QmitkMeasurementView::ActionDrawPathTriggered(bool checked)
{
Q_UNUSED(checked)
mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
figure->ClosedOff();
QString qString = QString("Path%1").arg(++d->m_PathCounter);
mitk::DataNode::Pointer node = this->AddFigureToDataStorage(figure, qString);
mitk::BoolProperty::Pointer closedProperty = mitk::BoolProperty::New( false );
node->SetProperty("ClosedPlanarPolygon", closedProperty);
MEASUREMENT_DEBUG << "PlanarPath initialized...";
}
void QmitkMeasurementView::ActionDrawAngleTriggered(bool checked)
{
Q_UNUSED(checked)
mitk::PlanarAngle::Pointer figure = mitk::PlanarAngle::New();
QString qString = QString("Angle%1").arg(++d->m_AngleCounter);
this->AddFigureToDataStorage(figure, qString);
MEASUREMENT_DEBUG << "PlanarAngle initialized...";
}
void QmitkMeasurementView::ActionDrawFourPointAngleTriggered(bool checked)
{
Q_UNUSED(checked)
mitk::PlanarFourPointAngle::Pointer figure =
mitk::PlanarFourPointAngle::New();
QString qString = QString("Four Point Angle%1").arg(++d->m_FourPointAngleCounter);
this->AddFigureToDataStorage(figure, qString);
MEASUREMENT_DEBUG << "PlanarFourPointAngle initialized...";
}
void QmitkMeasurementView::ActionDrawEllipseTriggered(bool checked)
{
Q_UNUSED(checked)
mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
QString qString = QString("Circle%1").arg(++d->m_EllipseCounter);
this->AddFigureToDataStorage(figure, qString);
MEASUREMENT_DEBUG << "PlanarCircle initialized...";
}
void QmitkMeasurementView::ActionDrawRectangleTriggered(bool checked)
{
Q_UNUSED(checked)
mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
QString qString = QString("Rectangle%1").arg(++d->m_RectangleCounter);
this->AddFigureToDataStorage(figure, qString);
MEASUREMENT_DEBUG << "PlanarRectangle initialized...";
}
void QmitkMeasurementView::ActionDrawPolygonTriggered(bool checked)
{
Q_UNUSED(checked)
mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
figure->ClosedOn();
QString qString = QString("Polygon%1").arg(++d->m_PolygonCounter);
this->AddFigureToDataStorage(figure, qString);
MEASUREMENT_DEBUG << "PlanarPolygon initialized...";
}
void QmitkMeasurementView::CopyToClipboard( bool checked )
{
Q_UNUSED(checked)
MEASUREMENT_DEBUG << "Copying current Text to clipboard...";
QString clipboardText = d->m_SelectedPlanarFiguresText->toPlainText();
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
}
mitk::DataNode::Pointer QmitkMeasurementView::AddFigureToDataStorage(
mitk::PlanarFigure* figure, const QString& name)
{
// add as
MEASUREMENT_DEBUG << "Adding new figure to datastorage...";
if( d->m_SelectedImageNode.IsNull() )
{
MITK_ERROR << "No reference image available";
return 0;
}
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetName(name.toStdString());
newNode->SetData(figure);
// set as selected
newNode->SetSelected( true );
this->GetDataStorage()->Add(newNode, d->m_SelectedImageNode);
// set all others in selection as deselected
for( int i=0; i<d->m_CurrentSelection.size(); ++i)
d->m_CurrentSelection.at(i)->SetSelected(false);
d->m_CurrentSelection.clear();
d->m_CurrentSelection.push_back( newNode );
this->UpdateMeasurementText();
this->DisableCrosshairNavigation();
d->m_DrawActionsToolBar->setEnabled(false);
d->m_UnintializedPlanarFigure = true;
return newNode;
}
void QmitkMeasurementView::UpdateMeasurementText()
{
d->m_SelectedPlanarFiguresText->clear();
QString infoText;
QString plainInfoText;
int j = 1;
mitk::PlanarFigure* _PlanarFigure = 0;
mitk::PlanarAngle* planarAngle = 0;
mitk::PlanarFourPointAngle* planarFourPointAngle = 0;
mitk::DataNode::Pointer node = 0;
for (int i=0; i<d->m_CurrentSelection.size(); ++i, ++j)
{
plainInfoText.clear();
node = d->m_CurrentSelection.at(i);
_PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
if( !_PlanarFigure )
continue;
if(j>1)
infoText.append("<br />");
infoText.append(QString("<b>%1</b><hr />").arg(QString::fromStdString(
node->GetName())));
plainInfoText.append(QString("%1").arg(QString::fromStdString(
node->GetName())));
planarAngle = dynamic_cast<mitk::PlanarAngle*> (_PlanarFigure);
if(!planarAngle)
{
planarFourPointAngle = dynamic_cast<mitk::PlanarFourPointAngle*> (_PlanarFigure);
}
double featureQuantity = 0.0;
for (unsigned int k = 0; k < _PlanarFigure->GetNumberOfFeatures(); ++k)
{
if ( !_PlanarFigure->IsFeatureActive( k ) ) continue;
featureQuantity = _PlanarFigure->GetQuantity(k);
if ((planarAngle && k == planarAngle->FEATURE_ID_ANGLE)
|| (planarFourPointAngle && k == planarFourPointAngle->FEATURE_ID_ANGLE))
featureQuantity = featureQuantity * 180 / vnl_math::pi;
infoText.append(
QString("<i>%1</i>: %2 %3") .arg(QString(
_PlanarFigure->GetFeatureName(k))) .arg(featureQuantity, 0, 'f',
2) .arg(QString(_PlanarFigure->GetFeatureUnit(k))));
plainInfoText.append(
QString("\n%1: %2 %3") .arg(QString(_PlanarFigure->GetFeatureName(k))) .arg(
featureQuantity, 0, 'f', 2) .arg(QString(
_PlanarFigure->GetFeatureUnit(k))));
if(k+1 != _PlanarFigure->GetNumberOfFeatures())
infoText.append("<br />");
}
if (j != d->m_CurrentSelection.size())
infoText.append("<br />");
}
d->m_SelectedPlanarFiguresText->setHtml(infoText);
}
void QmitkMeasurementView::AddAllInteractors()
{
MEASUREMENT_DEBUG << "Adding interactors to all planar figures";
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
const mitk::DataNode* node = 0;
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
; it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
this->NodeAdded( node );
}
}
void QmitkMeasurementView::RemoveAllInteractors()
{
MEASUREMENT_DEBUG << "Removing interactors and observers from all planar figures";
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
const mitk::DataNode* node = 0;
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
; it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
this->NodeRemoved( node );
}
}
mitk::DataNode::Pointer QmitkMeasurementView::DetectTopMostVisibleImage()
{
// get all images from the data storage which are not a segmentation
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
mitk::DataStorage::SetOfObjects::ConstPointer Images
= this->GetDataStorage()->GetSubset( isNormalImage );
mitk::DataNode::Pointer currentNode;
int maxLayer = itk::NumericTraits<int>::min();
// iterate over selection
for (mitk::DataStorage::SetOfObjects::ConstIterator sofIt = Images->Begin(); sofIt != Images->End(); ++sofIt)
{
mitk::DataNode::Pointer node = sofIt->Value();
if ( node.IsNull() )
continue;
if (node->IsVisible(NULL) == false)
continue;
// we also do not want to assign planar figures to helper objects ( even if they are of type image )
if (node->GetProperty("helper object"))
continue;
int layer = 0;
node->GetIntProperty("layer", layer);
if ( layer < maxLayer )
{
continue;
}
else
{
maxLayer = layer;
currentNode = node;
}
}
return currentNode;
}
void QmitkMeasurementView::EnableCrosshairNavigation()
{
MEASUREMENT_DEBUG << "EnableCrosshairNavigation";
// enable the crosshair navigation
if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
{
MEASUREMENT_DEBUG << "enabling linked navigation";
linkedRenderWindow->EnableLinkedNavigation(true);
linkedRenderWindow->EnableSlicingPlanes(true);
}
}
void QmitkMeasurementView::DisableCrosshairNavigation()
{
MEASUREMENT_DEBUG << "DisableCrosshairNavigation";
// disable the crosshair navigation during the drawing
if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
{
MEASUREMENT_DEBUG << "disabling linked navigation";
linkedRenderWindow->EnableLinkedNavigation(false);
linkedRenderWindow->EnableSlicingPlanes(false);
}
}
diff --git a/Plugins/org.mitk.gui.qt.properties/CMakeLists.txt b/Plugins/org.mitk.gui.qt.properties/CMakeLists.txt
new file mode 100644
index 0000000000..edf096cfa2
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/CMakeLists.txt
@@ -0,0 +1,7 @@
+project(org_mitk_gui_qt_properties)
+
+MACRO_CREATE_MITK_CTK_PLUGIN(
+ EXPORT_DIRECTIVE PROPERTIES_EXPORT
+ EXPORTED_INCLUDE_SUFFIXES src
+ MODULE_DEPENDENCIES Properties QmitkExt
+)
diff --git a/Plugins/org.mitk.gui.qt.properties/files.cmake b/Plugins/org.mitk.gui.qt.properties/files.cmake
new file mode 100644
index 0000000000..6a61ba0288
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/files.cmake
@@ -0,0 +1,45 @@
+set(SRC_CPP_FILES
+)
+
+set(INTERNAL_CPP_FILES
+ org_mitk_gui_qt_properties_Activator.cpp
+ QmitkPropertiesPreferencePage.cpp
+ QmitkPropertyItemDelegate.cpp
+ QmitkPropertyItem.cpp
+ QmitkPropertyItemModel.cpp
+ QmitkPropertyItemSortFilterProxyModel.cpp
+ QmitkPropertyTreeView.cpp
+)
+
+set(UI_FILES
+ src/internal/QmitkPropertiesPreferencePage.ui
+ src/internal/QmitkPropertyTreeView.ui
+)
+
+set(MOC_H_FILES
+ src/internal/QmitkPropertiesPreferencePage.h
+ src/internal/org_mitk_gui_qt_properties_Activator.h
+ src/internal/QmitkPropertyItemDelegate.h
+ src/internal/QmitkPropertyItemModel.h
+ src/internal/QmitkPropertyItemSortFilterProxyModel.h
+ src/internal/QmitkPropertyTreeView.h
+)
+
+set(CACHED_RESOURCE_FILES
+ resources/icon.png
+ plugin.xml
+)
+
+set(QRC_FILES
+)
+
+set(CPP_FILES
+)
+
+foreach(file ${SRC_CPP_FILES})
+ set(CPP_FILES ${CPP_FILES} src/${file})
+endforeach()
+
+foreach(file ${INTERNAL_CPP_FILES})
+ set(CPP_FILES ${CPP_FILES} src/internal/${file})
+endforeach()
diff --git a/Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.properties/manifest_headers.cmake
similarity index 83%
copy from Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake
copy to Plugins/org.mitk.gui.qt.properties/manifest_headers.cmake
index 912e7b0cf4..49a9ff6bc5 100644
--- a/Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.properties/manifest_headers.cmake
@@ -1,5 +1,5 @@
-set(Plugin-Name "MITK Simulation")
+set(Plugin-Name "MITK Properties")
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)
diff --git a/Plugins/org.mitk.gui.qt.properties/plugin.xml b/Plugins/org.mitk.gui.qt.properties/plugin.xml
new file mode 100644
index 0000000000..961cb29811
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/plugin.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<plugin>
+ <extension point="org.blueberry.ui.views">
+ <view id="org.mitk.views.properties"
+ name="Properties"
+ class="QmitkPropertyTreeView"
+ icon="resources/icon.png" />
+ </extension>
+ <extension point="org.blueberry.ui.preferencePages">
+ <page id="org.mitk.gui.qt.application.PropertiesPreferencePage" name="Properties" class="QmitkPropertiesPreferencePage" />
+ </extension>
+</plugin>
diff --git a/Plugins/org.mitk.gui.qt.properties/resources/icon.png b/Plugins/org.mitk.gui.qt.properties/resources/icon.png
new file mode 100644
index 0000000000..0a55fbdd74
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.properties/resources/icon.png differ
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp
new file mode 100644
index 0000000000..8da2375f20
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp
@@ -0,0 +1,79 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "QmitkPropertiesPreferencePage.h"
+#include <berryIPreferencesService.h>
+
+const std::string QmitkPropertiesPreferencePage::FILTER_PROPERTIES = "filter properties";
+const std::string QmitkPropertiesPreferencePage::SHOW_ALIASES = "show aliases";
+const std::string QmitkPropertiesPreferencePage::SHOW_DESCRIPTIONS = "show descriptions";
+const std::string QmitkPropertiesPreferencePage::SHOW_GENUINE_NAMES = "show genuine names";
+
+QmitkPropertiesPreferencePage::QmitkPropertiesPreferencePage()
+ : m_Control(NULL),
+ m_Preferences(berry::Platform::GetServiceRegistry().GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID)->GetSystemPreferences()->Node("/org.mitk.views.properties"))
+{
+}
+
+QmitkPropertiesPreferencePage::~QmitkPropertiesPreferencePage()
+{
+}
+
+void QmitkPropertiesPreferencePage::CreateQtControl(QWidget* parent)
+{
+ m_Control = new QWidget(parent);
+ m_Controls.setupUi(m_Control);
+
+ connect(m_Controls.showDescriptionsCheckBox, SIGNAL(stateChanged(int)), this, SLOT(OnShowDescriptionsStateChanged(int)));
+
+ this->Update();
+}
+
+QWidget* QmitkPropertiesPreferencePage::GetQtControl() const
+{
+ return m_Control;
+}
+
+void QmitkPropertiesPreferencePage::Init(berry::IWorkbench::Pointer)
+{
+}
+
+void QmitkPropertiesPreferencePage::OnShowDescriptionsStateChanged(int state)
+{
+ m_Controls.showGenuineNamesCheckBox->setEnabled(state != Qt::Unchecked);
+}
+
+bool QmitkPropertiesPreferencePage::PerformOk()
+{
+ m_Preferences->PutBool(FILTER_PROPERTIES, m_Controls.filterPropertiesCheckBox->isChecked());
+ m_Preferences->PutBool(SHOW_ALIASES, m_Controls.showAliasesCheckBox->isChecked());
+ m_Preferences->PutBool(SHOW_DESCRIPTIONS, m_Controls.showDescriptionsCheckBox->isChecked());
+ m_Preferences->PutBool(SHOW_GENUINE_NAMES, m_Controls.showGenuineNamesCheckBox->isChecked());
+
+ return true;
+}
+
+void QmitkPropertiesPreferencePage::PerformCancel()
+{
+}
+
+void QmitkPropertiesPreferencePage::Update()
+{
+ m_Controls.filterPropertiesCheckBox->setChecked(m_Preferences->GetBool(FILTER_PROPERTIES, true));
+ m_Controls.showAliasesCheckBox->setChecked(m_Preferences->GetBool(SHOW_ALIASES, true));
+ m_Controls.showDescriptionsCheckBox->setChecked(m_Preferences->GetBool(SHOW_DESCRIPTIONS, true));
+ m_Controls.showGenuineNamesCheckBox->setChecked(m_Preferences->GetBool(SHOW_GENUINE_NAMES, true));
+}
diff --git a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h
similarity index 54%
copy from Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.h
copy to Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h
index 484c855305..79f53b3b35 100644
--- a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.h
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h
@@ -1,57 +1,53 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#ifndef QmitkSimulationPreferencePage_h
-#define QmitkSimulationPreferencePage_h
+#ifndef QmitkPropertiesPreferencePage_h
+#define QmitkPropertiesPreferencePage_h
#include <berryIQtPreferencePage.h>
-#include <berryIPreferences.h>
-#include <org_mitk_gui_qt_simulation_Export.h>
-#include <ui_QmitkSimulationPreferencePageControls.h>
+#include <ui_QmitkPropertiesPreferencePage.h>
-berry::IPreferences::Pointer getSimulationPreferences();
-void initSOFAPlugins(berry::IPreferences::Pointer preferences = getSimulationPreferences());
-
-class SIMULATION_EXPORT QmitkSimulationPreferencePage : public QObject, public berry::IQtPreferencePage
+class QmitkPropertiesPreferencePage : public QObject, public berry::IQtPreferencePage
{
Q_OBJECT
Q_INTERFACES(berry::IPreferencePage)
public:
- static const std::string PLUGIN_PATHS;
+ static const std::string FILTER_PROPERTIES;
+ static const std::string SHOW_ALIASES;
+ static const std::string SHOW_DESCRIPTIONS;
+ static const std::string SHOW_GENUINE_NAMES;
- QmitkSimulationPreferencePage();
- ~QmitkSimulationPreferencePage();
+ QmitkPropertiesPreferencePage();
+ ~QmitkPropertiesPreferencePage();
void CreateQtControl(QWidget* parent);
QWidget* GetQtControl() const;
void Init(berry::IWorkbench::Pointer workbench);
- void PerformCancel();
bool PerformOk();
+ void PerformCancel();
void Update();
private slots:
- void OnAddButtonClicked();
- void OnPluginTreeWidgetItemSelectionChanged();
- void OnRemoveButtonClicked();
+ void OnShowDescriptionsStateChanged(int state);
private:
- berry::IPreferences::Pointer m_Preferences;
QWidget* m_Control;
- Ui::QmitkSimulationPreferencePageControls m_Controls;
+ Ui::QmitkPropertiesPreferencePage m_Controls;
+ berry::IPreferences::Pointer m_Preferences;
};
#endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui
new file mode 100644
index 0000000000..a9a1783f30
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui
@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QmitkPropertiesPreferencePage</class>
+ <widget class="QWidget" name="QmitkPropertiesPreferencePage">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>400</width>
+ <height>300</height>
+ </rect>
+ </property>
+ <property name="windowTitle">
+ <string/>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout_4">
+ <item>
+ <widget class="QGroupBox" name="aliasesGroupBox">
+ <property name="title">
+ <string>Aliases</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout_2">
+ <item>
+ <widget class="QCheckBox" name="showAliasesCheckBox">
+ <property name="text">
+ <string>Replace genuine property names by aliases</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <widget class="QGroupBox" name="descriptionsGroupBox">
+ <property name="title">
+ <string>Descriptions</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <widget class="QCheckBox" name="showDescriptionsCheckBox">
+ <property name="text">
+ <string>Show descriptions</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QCheckBox" name="showGenuineNamesCheckBox">
+ <property name="styleSheet">
+ <string notr="true">margin-left: 18px;</string>
+ </property>
+ <property name="text">
+ <string>Show genuine names of property aliases</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <widget class="QGroupBox" name="filtersGroupBox">
+ <property name="title">
+ <string>Filters</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout_3">
+ <item>
+ <widget class="QCheckBox" name="filterPropertiesCheckBox">
+ <property name="text">
+ <string>Only show filtered properties</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <spacer name="verticalSpacer">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>204</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ <tabstops>
+ <tabstop>showAliasesCheckBox</tabstop>
+ <tabstop>showDescriptionsCheckBox</tabstop>
+ <tabstop>showGenuineNamesCheckBox</tabstop>
+ </tabstops>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItem.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItem.cpp
new file mode 100644
index 0000000000..b6382bf1ef
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItem.cpp
@@ -0,0 +1,124 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "QmitkPropertyItem.h"
+#include <QStringList>
+
+QmitkPropertyItem::QmitkPropertyItem(const QList<QVariant>& data)
+ : m_Data(data),
+ m_Parent(NULL)
+{
+}
+
+QmitkPropertyItem::~QmitkPropertyItem()
+{
+ qDeleteAll(m_Children);
+}
+
+void QmitkPropertyItem::AppendChild(QmitkPropertyItem* child)
+{
+ if (child == NULL)
+ return;
+
+ // If property name doesn't contain full stop(s), append property directly.
+ if (!child->GetData(0).toString().contains('.'))
+ {
+ m_Children.append(child);
+ child->m_Parent = this;
+ }
+ else
+ {
+ // Property name contains full stop(s). Split accordingly.
+ QStringList names = child->GetData(0).toString().split('.');
+
+ // Traverse subtree and insert nodes if not already present.
+ QmitkPropertyItem* currentParent = this;
+
+ for (int i = 0; i < names.count(); ++i)
+ {
+ if (i != names.count() - 1)
+ {
+ QmitkPropertyItem* currentChild = NULL;
+
+ // Search for current node.
+ for (int j = 0; j < currentParent->m_Children.count(); ++j)
+ {
+ if (currentParent->m_Children[j]->GetData(0).toString() == names[i])
+ {
+ currentChild = currentParent->m_Children[j];
+ break;
+ }
+ }
+
+ // Node doesn't exist. Create and append it.
+ if (currentChild == NULL)
+ {
+ QList<QVariant> data;
+ data << names[i] << QVariant();
+
+ currentChild = new QmitkPropertyItem(data);
+ currentParent->AppendChild(currentChild);
+ }
+
+ currentParent = currentChild;
+ }
+ else
+ {
+ // Subtree already present, append property as leaf node.
+ QList<QVariant> data;
+ data << names[i] << child->m_Data[1];
+
+ currentParent->AppendChild(new QmitkPropertyItem(data));
+
+ delete child;
+ child = NULL;
+ }
+ }
+ }
+}
+
+QmitkPropertyItem* QmitkPropertyItem::GetChild(int row) const
+{
+ return m_Children.value(row);
+}
+
+int QmitkPropertyItem::GetChildCount() const
+{
+ return m_Children.count();
+}
+
+int QmitkPropertyItem::GetColumnCount() const
+{
+ return m_Data.count();
+}
+
+QVariant QmitkPropertyItem::GetData(int column) const
+{
+ return m_Data.value(column);
+}
+
+QmitkPropertyItem* QmitkPropertyItem::GetParent() const
+{
+ return m_Parent;
+}
+
+int QmitkPropertyItem::GetRow()
+{
+ if (m_Parent != NULL)
+ return m_Parent->m_Children.indexOf(this);
+
+ return 0;
+}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeItem.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItem.h
similarity index 58%
rename from Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeItem.h
rename to Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItem.h
index 7d47c33b9f..905a1d11ec 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeItem.h
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItem.h
@@ -1,43 +1,46 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#ifndef QMITKPROPERTYTREEITEM_H
-#define QMITKPROPERTYTREEITEM_H
+#ifndef QmitkPropertyItem_h
+#define QmitkPropertyItem_h
#include <QList>
#include <QVariant>
-class QmitkPropertyTreeItem
+class QmitkPropertyItem
{
public:
- explicit QmitkPropertyTreeItem(const QList<QVariant> &data);
- ~QmitkPropertyTreeItem();
+ explicit QmitkPropertyItem(const QList<QVariant>& data);
+ ~QmitkPropertyItem();
- void AppendChild(QmitkPropertyTreeItem *child);
- QmitkPropertyTreeItem * GetChild(int row);
+ void AppendChild(QmitkPropertyItem* child);
+ QmitkPropertyItem* GetChild(int row) const;
int GetChildCount() const;
int GetColumnCount() const;
QVariant GetData(int column) const;
- QmitkPropertyTreeItem * GetParent();
- int GetRow() const;
+ QmitkPropertyItem* GetParent() const;
+ int GetRow();
private:
- QList<QmitkPropertyTreeItem *> m_Children;
+ QmitkPropertyItem(const QmitkPropertyItem&);
+ QmitkPropertyItem& operator=(const QmitkPropertyItem&);
+
QList<QVariant> m_Data;
- QmitkPropertyTreeItem *m_Parent;
+ QList<QmitkPropertyItem*> m_Children;
+ QmitkPropertyItem* m_Parent;
};
#endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemDelegate.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemDelegate.cpp
new file mode 100644
index 0000000000..266f836828
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemDelegate.cpp
@@ -0,0 +1,172 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "QmitkPropertyItemDelegate.h"
+#include <mitkBaseProperty.h>
+#include <QComboBox>
+#include <QPainter>
+#include <QSpinBox>
+
+static mitk::BaseProperty* GetBaseProperty(const QVariant& data)
+{
+ return data.isValid()
+ ? reinterpret_cast<mitk::BaseProperty*>(data.value<void*>())
+ : NULL;
+}
+
+QmitkPropertyItemDelegate::QmitkPropertyItemDelegate(QObject* parent)
+ : QStyledItemDelegate(parent)
+{
+}
+
+QmitkPropertyItemDelegate::~QmitkPropertyItemDelegate()
+{
+}
+
+QWidget* QmitkPropertyItemDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const
+{
+ QVariant data = index.data(Qt::EditRole);
+
+ if (data.isValid())
+ {
+ if (data.type() == QVariant::Int)
+ {
+ QSpinBox* spinBox = new QSpinBox(parent);
+
+ connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished()));
+
+ return spinBox;
+ }
+
+ if (data.type() == QVariant::Double || static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
+ {
+ QDoubleSpinBox* spinBox = new QDoubleSpinBox(parent);
+
+ spinBox->setDecimals(4);
+ spinBox->setSingleStep(0.1);
+
+ QString name = index.model()->data(index.model()->index(index.row(), index.column() - 1)).toString();
+
+ if (name == "opacity")
+ {
+ spinBox->setMinimum(0.0);
+ spinBox->setMaximum(1.0);
+ }
+
+ connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished()));
+
+ return spinBox;
+ }
+
+ if (data.type() == QVariant::StringList)
+ {
+ QComboBox* comboBox = new QComboBox(parent);
+
+ comboBox->addItems(data.toStringList());
+
+ connect(comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnComboBoxCurrentIndexChanged(int)));
+
+ return comboBox;
+ }
+ }
+
+ return QStyledItemDelegate::createEditor(parent, option, index);
+}
+
+void QmitkPropertyItemDelegate::OnComboBoxCurrentIndexChanged(int)
+{
+ QComboBox* comboBox = qobject_cast<QComboBox*>(sender());
+
+ emit commitData(comboBox);
+ emit closeEditor(comboBox);
+}
+
+void QmitkPropertyItemDelegate::OnSpinBoxEditingFinished()
+{
+ QAbstractSpinBox* spinBox = qobject_cast<QAbstractSpinBox*>(sender());
+
+ emit commitData(spinBox);
+ emit closeEditor(spinBox);
+}
+
+void QmitkPropertyItemDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const
+{
+ QVariant data = index.data();
+
+ if (index.column() == 1 && data.type() == QVariant::Color)
+ {
+ painter->fillRect(option.rect, data.value<QColor>());
+ return;
+ }
+
+ QStyledItemDelegate::paint(painter, option, index);
+}
+
+void QmitkPropertyItemDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const
+{
+ QVariant data = index.data(Qt::EditRole);
+
+ if (!data.isValid())
+ return;
+
+ if (data.type() == QVariant::StringList)
+ {
+ QComboBox* comboBox = qobject_cast<QComboBox*>(editor);
+ comboBox->setCurrentIndex(comboBox->findText(index.data().toString()));
+ }
+ else
+ {
+ QStyledItemDelegate::setEditorData(editor, index);
+ }
+}
+
+void QmitkPropertyItemDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const
+{
+ QVariant data = index.data(Qt::EditRole);
+
+ if (!data.isValid())
+ return;
+
+ if (data.type() == QVariant::Int)
+ {
+ QSpinBox* spinBox = qobject_cast<QSpinBox*>(editor);
+ model->setData(index, spinBox->value());
+ }
+ else if (data.type() == QVariant::Double)
+ {
+ QDoubleSpinBox* spinBox = qobject_cast<QDoubleSpinBox*>(editor);
+ model->setData(index, spinBox->value());
+ }
+ else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
+ {
+ QDoubleSpinBox* spinBox = qobject_cast<QDoubleSpinBox*>(editor);
+ model->setData(index, static_cast<float>(spinBox->value()));
+ }
+ else if (data.type() == QVariant::StringList)
+ {
+ QComboBox* comboBox = qobject_cast<QComboBox*>(editor);
+ model->setData(index, comboBox->currentText());
+ }
+ else
+ {
+ QStyledItemDelegate::setModelData(editor, model, index);
+ }
+}
+
+QSize QmitkPropertyItemDelegate::sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const
+{
+ return QStyledItemDelegate::sizeHint(option, index);
+}
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemDelegate.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemDelegate.h
new file mode 100644
index 0000000000..a66796c1ae
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemDelegate.h
@@ -0,0 +1,41 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef QmitkPropertyItemDelegate_h
+#define QmitkPropertyItemDelegate_h
+
+#include <QStyledItemDelegate>
+
+class QmitkPropertyItemDelegate : public QStyledItemDelegate
+{
+ Q_OBJECT
+
+public:
+ explicit QmitkPropertyItemDelegate(QObject* parent = NULL);
+ ~QmitkPropertyItemDelegate();
+
+ QWidget* createEditor(QWidget *parent, const QStyleOptionViewItem& option, const QModelIndex& index) const;
+ void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const;
+ void setEditorData(QWidget* editor, const QModelIndex& index) const;
+ void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const;
+ QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const;
+
+private slots:
+ void OnComboBoxCurrentIndexChanged(int index);
+ void OnSpinBoxEditingFinished();
+};
+
+#endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemModel.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemModel.cpp
new file mode 100644
index 0000000000..463b5f89dc
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemModel.cpp
@@ -0,0 +1,498 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkGetPropertyService.h"
+#include "QmitkPropertiesPreferencePage.h"
+#include "QmitkPropertyItem.h"
+#include "QmitkPropertyItemModel.h"
+#include <berryIBerryPreferences.h>
+#include <mitkColorProperty.h>
+#include <mitkEnumerationProperty.h>
+#include <mitkProperties.h>
+#include <mitkPropertyAliases.h>
+#include <mitkPropertyFilters.h>
+#include <mitkRenderingManager.h>
+#include <mitkStringProperty.h>
+
+static QColor MitkToQt(const mitk::Color &color)
+{
+ return QColor(color.GetRed() * 255, color.GetGreen() * 255, color.GetBlue() * 255);
+}
+
+static mitk::BaseProperty* GetBaseProperty(const QVariant& data)
+{
+ return data.isValid()
+ ? reinterpret_cast<mitk::BaseProperty*>(data.value<void*>())
+ : NULL;
+}
+
+static mitk::Color QtToMitk(const QColor &color)
+{
+ mitk::Color mitkColor;
+
+ mitkColor.SetRed(color.red() / 255.0f);
+ mitkColor.SetGreen(color.green() / 255.0f);
+ mitkColor.SetBlue(color.blue() / 255.0f);
+
+ return mitkColor;
+}
+
+class PropertyEqualTo
+{
+public:
+ PropertyEqualTo(const mitk::BaseProperty* property)
+ : m_Property(property)
+ {
+ }
+
+ bool operator()(const mitk::PropertyList::PropertyMapElementType& pair) const
+ {
+ return pair.second.GetPointer() == m_Property;
+ }
+
+private:
+ const mitk::BaseProperty* m_Property;
+};
+
+QmitkPropertyItemModel::QmitkPropertyItemModel(QObject* parent)
+ : QAbstractItemModel(parent),
+ m_PropertyAliases(NULL),
+ m_PropertyFilters(NULL)
+{
+ this->CreateRootItem();
+}
+
+QmitkPropertyItemModel::~QmitkPropertyItemModel()
+{
+ this->SetNewPropertyList(NULL);
+}
+
+int QmitkPropertyItemModel::columnCount(const QModelIndex& parent) const
+{
+ if (parent.isValid())
+ return static_cast<QmitkPropertyItem*>(parent.internalPointer())->GetColumnCount();
+ else
+ return m_RootItem->GetColumnCount();
+}
+
+void QmitkPropertyItemModel::CreateRootItem()
+{
+ QList<QVariant> rootData;
+ rootData << "Property" << "Value";
+
+ m_RootItem.reset(new QmitkPropertyItem(rootData));
+
+ this->reset();
+}
+
+QVariant QmitkPropertyItemModel::data(const QModelIndex& index, int role) const
+{
+ if(!index.isValid())
+ return QVariant();
+
+ mitk::BaseProperty* property = index.column() == 1
+ ? GetBaseProperty(static_cast<QmitkPropertyItem*>(index.internalPointer())->GetData(1))
+ : NULL;
+
+ if (role == Qt::DisplayRole)
+ {
+ if (index.column() == 0)
+ {
+ return static_cast<QmitkPropertyItem*>(index.internalPointer())->GetData(0);
+ }
+ else if (index.column() == 1 && property != NULL)
+ {
+ if (mitk::ColorProperty* colorProperty = dynamic_cast<mitk::ColorProperty*>(property))
+ return MitkToQt(colorProperty->GetValue());
+ else if (dynamic_cast<mitk::BoolProperty*>(property) == NULL)
+ return QString::fromStdString(property->GetValueAsString());
+ }
+ }
+ else if (index.column() == 1 && property != NULL)
+ {
+ if (role == Qt::CheckStateRole)
+ {
+ if (mitk::BoolProperty* boolProperty = dynamic_cast<mitk::BoolProperty*>(property))
+ return boolProperty->GetValue() ? Qt::Checked : Qt::Unchecked;
+ }
+ else if (role == Qt::EditRole)
+ {
+ if (dynamic_cast<mitk::StringProperty*>(property) != NULL)
+ {
+ return QString::fromStdString(property->GetValueAsString());
+ }
+ else if (mitk::IntProperty* intProperty = dynamic_cast<mitk::IntProperty*>(property))
+ {
+ return intProperty->GetValue();
+ }
+ else if (mitk::FloatProperty* floatProperty = dynamic_cast<mitk::FloatProperty*>(property))
+ {
+ return floatProperty->GetValue();
+ }
+ else if (mitk::DoubleProperty* doubleProperty = dynamic_cast<mitk::DoubleProperty*>(property))
+ {
+ return doubleProperty->GetValue();
+ }
+ else if (mitk::EnumerationProperty* enumProperty = dynamic_cast<mitk::EnumerationProperty*>(property))
+ {
+ QStringList values;
+
+ for (mitk::EnumerationProperty::EnumConstIterator it = enumProperty->Begin(); it != enumProperty->End(); it++)
+ values << QString::fromStdString(it->second);
+
+ return values;
+ }
+ else if (mitk::ColorProperty* colorProperty = dynamic_cast<mitk::ColorProperty*>(property))
+ {
+ return MitkToQt(colorProperty->GetValue());
+ }
+ }
+ }
+
+ return QVariant();
+}
+
+QModelIndex QmitkPropertyItemModel::FindProperty(const mitk::BaseProperty* property)
+{
+ if (property == NULL)
+ return QModelIndex();
+
+ typedef mitk::PropertyList::PropertyMap PropertyMap;
+ const PropertyMap* propertyMap = m_PropertyList->GetMap();
+
+ PropertyMap::const_iterator it = std::find_if(propertyMap->begin(), propertyMap->end(), PropertyEqualTo(property));
+
+ if (it == propertyMap->end())
+ return QModelIndex();
+
+ QString name = QString::fromStdString(it->first);
+
+ if (!name.contains('.'))
+ {
+ QModelIndexList item = this->match(index(0, 0), Qt::DisplayRole, name, 1, Qt::MatchExactly);
+
+ if (!item.empty())
+ return item[0];
+ }
+ else
+ {
+ QStringList names = name.split('.');
+ QModelIndexList items = this->match(index(0, 0), Qt::DisplayRole, names.last(), -1, Qt::MatchRecursive | Qt::MatchExactly);
+
+ foreach(QModelIndex item, items)
+ {
+ QModelIndex candidate = item;
+
+ for (int i = names.length() - 1; i != 0; --i)
+ {
+ QModelIndex parent = item.parent();
+
+ if (parent.parent() == QModelIndex())
+ {
+ if (parent.data() != names.first())
+ break;
+
+ return candidate;
+ }
+
+ if (parent.data() != names[i - 1])
+ break;
+
+ item = parent;
+ }
+ }
+ }
+
+ return QModelIndex();
+}
+
+Qt::ItemFlags QmitkPropertyItemModel::flags(const QModelIndex& index) const
+{
+ Qt::ItemFlags flags = QAbstractItemModel::flags(index);
+
+ if (index.column() == 1)
+ {
+ if (index.data(Qt::EditRole).isValid())
+ flags |= Qt::ItemIsEditable;
+
+ if (index.data(Qt::CheckStateRole).isValid())
+ flags |= Qt::ItemIsUserCheckable;
+ }
+
+ return flags;
+}
+
+mitk::PropertyList* QmitkPropertyItemModel::GetPropertyList() const
+{
+ return m_PropertyList.GetPointer();
+}
+
+QVariant QmitkPropertyItemModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+ if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
+ return m_RootItem->GetData(section);
+
+ return QVariant();
+}
+
+QModelIndex QmitkPropertyItemModel::index(int row, int column, const QModelIndex& parent) const
+{
+ if (!this->hasIndex(row, column, parent))
+ return QModelIndex();
+
+ QmitkPropertyItem* parentItem = parent.isValid()
+ ? static_cast<QmitkPropertyItem*>(parent.internalPointer())
+ : m_RootItem.get();
+
+ QmitkPropertyItem* childItem = parentItem->GetChild(row);
+
+ return childItem != NULL
+ ? this->createIndex(row, column, childItem)
+ : QModelIndex();
+}
+
+void QmitkPropertyItemModel::OnPreferencesChanged(const berry::IBerryPreferences* preferences)
+{
+ bool showAliases = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_ALIASES, true);
+ bool filterProperties = preferences->GetBool(QmitkPropertiesPreferencePage::FILTER_PROPERTIES, true);
+
+ bool updateAliases = showAliases != (m_PropertyAliases != NULL);
+ bool updateFilters = filterProperties != (m_PropertyFilters != NULL);
+
+ bool resetPropertyList = false;
+
+ if (updateAliases)
+ {
+ m_PropertyAliases = showAliases
+ ? mitk::GetPropertyService<mitk::PropertyAliases>()
+ : NULL;
+
+ resetPropertyList = m_PropertyList.IsNotNull();
+ }
+
+ if (updateFilters)
+ {
+ m_PropertyFilters = filterProperties
+ ? mitk::GetPropertyService<mitk::PropertyFilters>()
+ : NULL;
+
+ if (!resetPropertyList)
+ resetPropertyList = m_PropertyList.IsNotNull();
+ }
+
+ if (resetPropertyList)
+ this->SetNewPropertyList(m_PropertyList.GetPointer());
+}
+
+void QmitkPropertyItemModel::OnPropertyDeleted(const itk::Object* property, const itk::EventObject&)
+{
+ /*QModelIndex index = this->FindProperty(static_cast<const mitk::BaseProperty*>(property));
+
+ if (index != QModelIndex())
+ this->reset();*/
+}
+
+void QmitkPropertyItemModel::OnPropertyListDeleted(const itk::Object*)
+{
+ this->CreateRootItem();
+}
+
+void QmitkPropertyItemModel::OnPropertyModified(const itk::Object* property, const itk::EventObject&)
+{
+ QModelIndex index = this->FindProperty(static_cast<const mitk::BaseProperty*>(property));
+
+ if (index != QModelIndex())
+ emit dataChanged(index, index);
+}
+
+QModelIndex QmitkPropertyItemModel::parent(const QModelIndex& child) const
+{
+ if (!child.isValid())
+ return QModelIndex();
+
+ QmitkPropertyItem* parentItem = static_cast<QmitkPropertyItem*>(child.internalPointer())->GetParent();
+
+ if (parentItem == m_RootItem.get())
+ return QModelIndex();
+
+ return this->createIndex(parentItem->GetRow(), 0, parentItem);
+}
+
+int QmitkPropertyItemModel::rowCount(const QModelIndex& parent) const
+{
+ if (parent.column() > 0)
+ return 0;
+
+ QmitkPropertyItem *parentItem = parent.isValid()
+ ? static_cast<QmitkPropertyItem*>(parent.internalPointer())
+ : m_RootItem.get();
+
+ return parentItem->GetChildCount();
+}
+
+bool QmitkPropertyItemModel::setData(const QModelIndex& index, const QVariant& value, int role)
+{
+ if (!index.isValid() || index.column() != 1 || (role != Qt::EditRole && role != Qt::CheckStateRole))
+ return false;
+
+ mitk::BaseProperty* property = GetBaseProperty(static_cast<QmitkPropertyItem*>(index.internalPointer())->GetData(1));
+
+ if (property == NULL)
+ return false;
+
+ if (mitk::BoolProperty* boolProperty = dynamic_cast<mitk::BoolProperty*>(property))
+ {
+ boolProperty->SetValue(value.toInt() == Qt::Checked ? true : false);
+ }
+ else if (mitk::StringProperty* stringProperty = dynamic_cast<mitk::StringProperty*>(property))
+ {
+ stringProperty->SetValue(value.toString().toStdString());
+ }
+ else if (mitk::IntProperty* intProperty = dynamic_cast<mitk::IntProperty*>(property))
+ {
+ intProperty->SetValue(value.toInt());
+ }
+ else if (mitk::FloatProperty* floatProperty = dynamic_cast<mitk::FloatProperty*>(property))
+ {
+ floatProperty->SetValue(value.toFloat());
+ }
+ else if (mitk::DoubleProperty* doubleProperty = dynamic_cast<mitk::DoubleProperty*>(property))
+ {
+ doubleProperty->SetValue(value.toDouble());
+ }
+ else if (mitk::EnumerationProperty* enumProperty = dynamic_cast<mitk::EnumerationProperty*>(property))
+ {
+ std::string selection = value.toString().toStdString();
+
+ if (selection != enumProperty->GetValueAsString() && enumProperty->IsValidEnumerationValue(selection))
+ enumProperty->SetValue(selection);
+ }
+ else if (mitk::ColorProperty* colorProperty = dynamic_cast<mitk::ColorProperty*>(property))
+ {
+ colorProperty->SetValue(QtToMitk(value.value<QColor>()));
+ }
+
+ m_PropertyList->InvokeEvent(itk::ModifiedEvent());
+ m_PropertyList->Modified();
+
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+
+ return true;
+}
+
+void QmitkPropertyItemModel::SetNewPropertyList(mitk::PropertyList* propertyList)
+{
+ typedef mitk::PropertyList::PropertyMap PropertyMap;
+
+ this->beginResetModel();
+
+ if (m_PropertyList.IsNotNull())
+ {
+ mitk::MessageDelegate1<QmitkPropertyItemModel, const itk::Object*> delegate(this, &QmitkPropertyItemModel::OnPropertyListDeleted);
+ m_PropertyList.ObjectDelete.RemoveListener(delegate);
+
+ const PropertyMap* propertyMap = m_PropertyList->GetMap();
+
+ for (PropertyMap::const_iterator propertyIt = propertyMap->begin(); propertyIt != propertyMap->end(); ++propertyIt)
+ {
+ std::map<std::string, unsigned long>::const_iterator tagIt = m_PropertyModifiedTags.find(propertyIt->first);
+
+ if (tagIt != m_PropertyModifiedTags.end())
+ propertyIt->second->RemoveObserver(tagIt->second);
+
+ tagIt = m_PropertyDeletedTags.find(propertyIt->first);
+
+ if (tagIt != m_PropertyDeletedTags.end())
+ propertyIt->second->RemoveObserver(tagIt->second);
+ }
+
+ m_PropertyModifiedTags.clear();
+ }
+
+ m_PropertyList = propertyList;
+
+ if (m_PropertyList.IsNotNull())
+ {
+ mitk::MessageDelegate1<QmitkPropertyItemModel, const itk::Object*> delegate(this, &QmitkPropertyItemModel::OnPropertyListDeleted);
+ m_PropertyList.ObjectDelete.AddListener(delegate);
+
+ mitk::MessageDelegate2<QmitkPropertyItemModel, const itk::Object*, const itk::EventObject&> propertyDelegate(this, &QmitkPropertyItemModel::OnPropertyModified);
+
+ itk::MemberCommand<QmitkPropertyItemModel>::Pointer modifiedCommand = itk::MemberCommand<QmitkPropertyItemModel>::New();
+ modifiedCommand->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyModified);
+
+ const PropertyMap* propertyMap = m_PropertyList->GetMap();
+
+ for (PropertyMap::const_iterator it = propertyMap->begin(); it != propertyMap->end(); ++it)
+ m_PropertyModifiedTags.insert(std::make_pair(it->first, it->second->AddObserver(itk::ModifiedEvent(), modifiedCommand)));
+
+ itk::MemberCommand<QmitkPropertyItemModel>::Pointer deletedCommand = itk::MemberCommand<QmitkPropertyItemModel>::New();
+ deletedCommand->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyDeleted);
+
+ for (PropertyMap::const_iterator it = propertyMap->begin(); it != propertyMap->end(); ++it)
+ m_PropertyDeletedTags.insert(std::make_pair(it->first, it->second->AddObserver(itk::DeleteEvent(), deletedCommand)));
+ }
+
+ this->CreateRootItem();
+
+ if (m_PropertyList != NULL && !m_PropertyList->IsEmpty())
+ {
+ mitk::PropertyList::PropertyMap filteredProperties;
+ bool filterProperties = false;
+
+ if (m_PropertyFilters != NULL && (m_PropertyFilters->HasFilter() || m_PropertyFilters->HasFilter(m_ClassName.toStdString())))
+ {
+ filteredProperties = m_PropertyFilters->ApplyFilter(m_ClassName.toStdString(), *m_PropertyList->GetMap());
+ filterProperties = true;
+ }
+
+ const mitk::PropertyList::PropertyMap* propertyMap = !filterProperties
+ ? m_PropertyList->GetMap()
+ : &filteredProperties;
+
+ mitk::PropertyList::PropertyMap::const_iterator end = propertyMap->end();
+
+ for (mitk::PropertyList::PropertyMap::const_iterator iter = propertyMap->begin(); iter != end; ++iter)
+ {
+ QStringList nameAndAlias(QString::fromStdString(iter->first));
+
+ nameAndAlias << (m_PropertyAliases != NULL
+ ? QString::fromStdString(m_PropertyAliases->GetAlias(iter->first))
+ : "");
+
+ QList<QVariant> data;
+
+ data << (nameAndAlias[1].isEmpty()
+ ? nameAndAlias[0]
+ : nameAndAlias[1]);
+
+ data << QVariant::fromValue((reinterpret_cast<void *>(iter->second.GetPointer())));
+
+ m_RootItem->AppendChild(new QmitkPropertyItem(data));
+ }
+ }
+
+ this->endResetModel();
+}
+
+void QmitkPropertyItemModel::SetPropertyList(mitk::PropertyList* propertyList, const QString& className)
+{
+ if (m_PropertyList.GetPointer() != propertyList)
+ {
+ m_ClassName = className;
+ this->SetNewPropertyList(propertyList);
+ }
+}
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemModel.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemModel.h
new file mode 100644
index 0000000000..c057eb8147
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemModel.h
@@ -0,0 +1,74 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef QmitkPropertyItemModel_h
+#define QmitkPropertyItemModel_h
+
+#include <QAbstractItemModel>
+#include <mitkPropertyList.h>
+#include <mitkWeakPointer.h>
+
+class QmitkPropertyItem;
+
+namespace berry
+{
+ struct IBerryPreferences;
+}
+
+namespace mitk
+{
+ class PropertyAliases;
+ class PropertyFilters;
+}
+
+class QmitkPropertyItemModel : public QAbstractItemModel
+{
+ Q_OBJECT
+
+public:
+ explicit QmitkPropertyItemModel(QObject* parent = NULL);
+ ~QmitkPropertyItemModel();
+
+ int columnCount(const QModelIndex& parent = QModelIndex()) const;
+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
+ Qt::ItemFlags flags(const QModelIndex& index) const;
+ mitk::PropertyList* GetPropertyList() const;
+ QVariant headerData(int section, Qt::Orientation orientation, int role) const;
+ QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const;
+ void OnPreferencesChanged(const berry::IBerryPreferences* preferences);
+ QModelIndex parent(const QModelIndex& child) const;
+ int rowCount(const QModelIndex& parent = QModelIndex()) const;
+ bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
+ void SetPropertyList(mitk::PropertyList* propertyList, const QString& className = "");
+
+private:
+ void CreateRootItem();
+ QModelIndex FindProperty(const mitk::BaseProperty* property);
+ void OnPropertyDeleted(const itk::Object* property, const itk::EventObject& event);
+ void OnPropertyListDeleted(const itk::Object* propertyList);
+ void OnPropertyModified(const itk::Object* property, const itk::EventObject& event);
+ void SetNewPropertyList(mitk::PropertyList* propertyList);
+
+ mitk::PropertyAliases* m_PropertyAliases;
+ mitk::PropertyFilters* m_PropertyFilters;
+ mitk::WeakPointer<mitk::PropertyList> m_PropertyList;
+ QString m_ClassName;
+ std::auto_ptr<QmitkPropertyItem> m_RootItem;
+ std::map<std::string, unsigned long> m_PropertyDeletedTags;
+ std::map<std::string, unsigned long> m_PropertyModifiedTags;
+};
+
+#endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.cpp
new file mode 100644
index 0000000000..d0e96f4653
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.cpp
@@ -0,0 +1,58 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "QmitkPropertyItemSortFilterProxyModel.h"
+
+QmitkPropertyItemSortFilterProxyModel::QmitkPropertyItemSortFilterProxyModel(QObject* parent)
+ : QSortFilterProxyModel(parent)
+{
+}
+
+QmitkPropertyItemSortFilterProxyModel::~QmitkPropertyItemSortFilterProxyModel()
+{
+}
+
+bool QmitkPropertyItemSortFilterProxyModel::FilterAcceptsAnyChildRow(const QModelIndex& sourceParent) const
+{
+ QString propertyName = this->sourceModel()->data(sourceParent).toString();
+
+ if (propertyName.contains(filterRegExp()))
+ return true;
+
+ if (this->sourceModel()->hasChildren(sourceParent))
+ {
+ for (int row = 0; row < this->sourceModel()->rowCount(sourceParent); ++row)
+ {
+ if(this->FilterAcceptsAnyChildRow(this->sourceModel()->index(row, 0, sourceParent)))
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool QmitkPropertyItemSortFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const
+{
+ return this->FilterAcceptsAnyChildRow(this->sourceModel()->index(sourceRow, 0, sourceParent));
+}
+
+bool QmitkPropertyItemSortFilterProxyModel::lessThan(const QModelIndex& left, const QModelIndex& right) const
+{
+ QString leftString = this->sourceModel()->data(left).toString();
+ QString rightString = this->sourceModel()->data(right).toString();
+
+ return leftString.compare(rightString, this->sortCaseSensitivity()) < 0;
+}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeFilterProxyModel.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.h
similarity index 55%
rename from Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeFilterProxyModel.h
rename to Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.h
index 4e89b16c6c..022bafbd5f 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkPropertyTreeFilterProxyModel.h
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyItemSortFilterProxyModel.h
@@ -1,38 +1,38 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#ifndef QMITKPROPERTYTREEFILTERPROXYMODEL_H
-#define QMITKPROPERTYTREEFILTERPROXYMODEL_H
+#ifndef QmitkPropertyItemSortFilterProxyModel_h
+#define QmitkPropertyItemSortFilterProxyModel_h
#include <QSortFilterProxyModel>
-class QmitkPropertyTreeFilterProxyModel : public QSortFilterProxyModel
+class QmitkPropertyItemSortFilterProxyModel : public QSortFilterProxyModel
{
Q_OBJECT
public:
- QmitkPropertyTreeFilterProxyModel(QObject *parent = NULL);
- ~QmitkPropertyTreeFilterProxyModel();
+ explicit QmitkPropertyItemSortFilterProxyModel(QObject* parent = NULL);
+ ~QmitkPropertyItemSortFilterProxyModel();
protected:
- bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const;
- bool lessThan(const QModelIndex &left, const QModelIndex &right) const;
+ bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const;
+ bool lessThan(const QModelIndex& left, const QModelIndex& right) const;
private:
- bool filterAcceptsAnyChildRows(const QModelIndex &sourceParent) const;
+ bool FilterAcceptsAnyChildRow(const QModelIndex& sourceParent) const;
};
#endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
new file mode 100644
index 0000000000..5158cefba1
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
@@ -0,0 +1,269 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkGetPropertyService.h"
+#include "QmitkPropertiesPreferencePage.h"
+#include "QmitkPropertyItemDelegate.h"
+#include "QmitkPropertyItemModel.h"
+#include "QmitkPropertyItemSortFilterProxyModel.h"
+#include "QmitkPropertyTreeView.h"
+#include <berryIBerryPreferences.h>
+#include <mitkPropertyAliases.h>
+#include <mitkPropertyDescriptions.h>
+#include <QPainter>
+
+const std::string QmitkPropertyTreeView::VIEW_ID = "org.mitk.views.properties";
+
+QmitkPropertyTreeView::QmitkPropertyTreeView()
+ : m_PropertyNameChangedTag(0),
+ m_PropertyAliases(NULL),
+ m_PropertyDescriptions(NULL),
+ m_ShowGenuineNames(false),
+ m_ProxyModel(NULL),
+ m_Model(NULL)
+{
+}
+
+QmitkPropertyTreeView::~QmitkPropertyTreeView()
+{
+}
+
+void QmitkPropertyTreeView::CreateQtPartControl(QWidget* parent)
+{
+ m_Controls.setupUi(parent);
+
+ m_Controls.filter->SetDefaultText("Filter");
+
+ m_Controls.description->hide();
+
+ m_ProxyModel = new QmitkPropertyItemSortFilterProxyModel(m_Controls.treeView);
+ m_Model = new QmitkPropertyItemModel(m_ProxyModel);
+
+ m_ProxyModel->setSourceModel(m_Model);
+ m_ProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
+ m_ProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
+ m_ProxyModel->setDynamicSortFilter(true);
+
+ m_Controls.treeView->setItemDelegateForColumn(1, new QmitkPropertyItemDelegate(m_Controls.treeView));
+ m_Controls.treeView->setModel(m_ProxyModel);
+ m_Controls.treeView->setColumnWidth(0, 150);
+ m_Controls.treeView->sortByColumn(0, Qt::AscendingOrder);
+ m_Controls.treeView->setSelectionBehavior(QAbstractItemView::SelectRows);
+ m_Controls.treeView->setSelectionMode(QAbstractItemView::SingleSelection);
+ m_Controls.treeView->setEditTriggers(QAbstractItemView::SelectedClicked | QAbstractItemView::DoubleClicked);
+
+ connect(m_Controls.filter, SIGNAL(textChanged(const QString&)), this, SLOT(OnFilterTextChanged(const QString&)));
+ connect(m_Controls.treeView->selectionModel(), SIGNAL(currentRowChanged(const QModelIndex&, const QModelIndex&)), this, SLOT(OnCurrentRowChanged(const QModelIndex&, const QModelIndex&)));
+ connect(m_Model, SIGNAL(modelReset()), this, SLOT(OnModelReset()));
+}
+
+QString QmitkPropertyTreeView::GetPropertyNameOrAlias(const QModelIndex& index)
+{
+ QString propertyName;
+
+ if (index.isValid())
+ {
+ QModelIndex current = index;
+
+ while (current.isValid())
+ {
+ QString name = m_ProxyModel->data(m_ProxyModel->index(current.row(), 0, current.parent())).toString();
+
+ propertyName.prepend(propertyName.isEmpty()
+ ? name
+ : name.append('.'));
+
+ current = current.parent();
+ }
+ }
+
+ return propertyName;
+}
+
+void QmitkPropertyTreeView::OnCurrentRowChanged(const QModelIndex& current, const QModelIndex&)
+{
+ if (m_PropertyDescriptions != NULL && current.isValid())
+ {
+ QString name = this->GetPropertyNameOrAlias(current);
+
+ if (!name.isEmpty())
+ {
+ QString alias;
+ bool isTrueName = true;
+
+ if (m_PropertyAliases != NULL)
+ {
+ std::string trueName = m_PropertyAliases->GetPropertyName(name.toStdString());
+
+ if (!trueName.empty())
+ {
+ alias = name;
+ name = QString::fromStdString(trueName);
+ isTrueName = false;
+ }
+ }
+
+ QString description = QString::fromStdString(m_PropertyDescriptions->GetDescription(name.toStdString()));
+
+ if (!description.isEmpty())
+ {
+ if (!isTrueName && alias.isEmpty() && m_PropertyAliases != NULL)
+ alias = QString::fromStdString(m_PropertyAliases->GetAlias(name.toStdString()));
+
+ QString customizedDescription;
+
+ if (!alias.isEmpty())
+ {
+ if (m_ShowGenuineNames)
+ {
+ customizedDescription = "<h3 style=\"margin-bottom:0\">" + alias + "</h3>";
+ customizedDescription += "<h5 style=\"margin-top:0;margin-bottom:10px\">" + name + "</h5>";
+ }
+ else
+ {
+ customizedDescription = "<h3 style=\"margin-bottom:10px\">" + alias + "</h3>";
+ }
+ }
+ else
+ {
+ customizedDescription = "<h3 style=\"margin-bottom:10px\">" + name + "</h3>";
+ }
+
+ customizedDescription += description;
+
+ m_Controls.description->setText(customizedDescription);
+ m_Controls.description->show();
+
+ return;
+ }
+ }
+ }
+
+ m_Controls.description->hide();
+}
+
+void QmitkPropertyTreeView::OnFilterTextChanged(const QString& filter)
+{
+ m_ProxyModel->setFilterWildcard(filter);
+
+ if (filter.isEmpty())
+ m_Controls.treeView->collapseAll();
+ else
+ m_Controls.treeView->expandAll();
+}
+
+void QmitkPropertyTreeView::OnModelReset()
+{
+ m_Controls.description->hide();
+}
+
+void QmitkPropertyTreeView::OnPreferencesChanged(const berry::IBerryPreferences* preferences)
+{
+ bool showAliases = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_ALIASES, true);
+ bool showDescriptions = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_DESCRIPTIONS, true);
+ bool showGenuineNames = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_GENUINE_NAMES, true);
+
+ bool updateAliases = showAliases != (m_PropertyAliases != NULL);
+ bool updateDescriptions = showDescriptions != (m_PropertyDescriptions != NULL);
+ bool updateGenuineNames = showGenuineNames != m_ShowGenuineNames;
+
+ if (updateAliases)
+ m_PropertyAliases = showAliases
+ ? mitk::GetPropertyService<mitk::PropertyAliases>()
+ : NULL;
+
+ if (updateDescriptions)
+ m_PropertyDescriptions = showDescriptions
+ ? mitk::GetPropertyService<mitk::PropertyDescriptions>()
+ : NULL;
+
+ if (updateGenuineNames)
+ m_ShowGenuineNames = showGenuineNames;
+
+ if (updateDescriptions || updateGenuineNames)
+ {
+ QModelIndexList selection = m_Controls.treeView->selectionModel()->selectedRows();
+
+ if (!selection.isEmpty())
+ this->OnCurrentRowChanged(selection[0], selection[0]);
+ }
+
+ m_Model->OnPreferencesChanged(preferences);
+}
+
+void QmitkPropertyTreeView::OnPropertyNameChanged(const itk::EventObject&)
+{
+ mitk::PropertyList* propertyList = m_Model->GetPropertyList();
+
+ if (propertyList != NULL)
+ {
+ mitk::BaseProperty* nameProperty = propertyList->GetProperty("name");
+
+ if (nameProperty != NULL)
+ {
+ std::ostringstream partName;
+ partName << "Properties (" << nameProperty->GetValueAsString() << ')';
+ this->SetPartName(partName.str());
+ }
+ }
+}
+
+void QmitkPropertyTreeView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
+{
+ mitk::PropertyList* propertyList = m_Model->GetPropertyList();
+
+ if (propertyList != NULL)
+ {
+ mitk::BaseProperty* nameProperty = propertyList->GetProperty("name");
+
+ if (nameProperty != NULL)
+ nameProperty->RemoveObserver(m_PropertyNameChangedTag);
+
+ m_PropertyNameChangedTag = 0;
+ }
+
+ if (nodes.empty() || nodes.front().IsNull())
+ {
+ this->SetPartName("Properties");
+ m_Model->SetPropertyList(NULL);
+ }
+ else
+ {
+ QString selectionClassName = nodes.front()->GetData() != NULL
+ ? nodes.front()->GetData()->GetNameOfClass()
+ : "";
+
+ m_Model->SetPropertyList(nodes.front()->GetPropertyList(), selectionClassName);
+ OnPropertyNameChanged(itk::ModifiedEvent());
+
+ mitk::BaseProperty* nameProperty = nodes.front()->GetProperty("name");
+
+ if (nameProperty != NULL)
+ {
+ itk::ReceptorMemberCommand<QmitkPropertyTreeView>::Pointer command = itk::ReceptorMemberCommand<QmitkPropertyTreeView>::New();
+ command->SetCallbackFunction(this, &QmitkPropertyTreeView::OnPropertyNameChanged);
+ m_PropertyNameChangedTag = nameProperty->AddObserver(itk::ModifiedEvent(), command);
+ }
+ }
+
+ if (!m_ProxyModel->filterRegExp().isEmpty())
+ m_Controls.treeView->expandAll();
+}
+
+void QmitkPropertyTreeView::SetFocus()
+{
+ m_Controls.filter->setFocus();
+}
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h
new file mode 100644
index 0000000000..2e8957c298
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h
@@ -0,0 +1,70 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef QmitkPropertyTreeView_h
+#define QmitkPropertyTreeView_h
+
+#include <QmitkAbstractView.h>
+#include <ui_QmitkPropertyTreeView.h>
+
+class QmitkPropertyItemModel;
+class QmitkPropertyItemSortFilterProxyModel;
+
+namespace mitk
+{
+ class PropertyAliases;
+ class PropertyDescriptions;
+}
+
+class QmitkPropertyTreeView : public QmitkAbstractView
+{
+ Q_OBJECT
+
+public:
+ static const std::string VIEW_ID;
+
+ berryObjectMacro(QmitkPropertyTreeView)
+
+ QmitkPropertyTreeView();
+ ~QmitkPropertyTreeView();
+
+ void SetFocus();
+
+protected:
+ void CreateQtPartControl(QWidget* parent);
+
+private:
+ QString GetPropertyNameOrAlias(const QModelIndex& index);
+ void OnPreferencesChanged(const berry::IBerryPreferences* preferences);
+ void OnPropertyNameChanged(const itk::EventObject& event);
+ void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes);
+
+private slots:
+ void OnCurrentRowChanged(const QModelIndex& current, const QModelIndex& previous);
+ void OnFilterTextChanged(const QString& filter);
+ void OnModelReset();
+
+private:
+ unsigned long m_PropertyNameChangedTag;
+ mitk::PropertyAliases* m_PropertyAliases;
+ mitk::PropertyDescriptions* m_PropertyDescriptions;
+ bool m_ShowGenuineNames;
+ Ui::QmitkPropertyTreeView m_Controls;
+ QmitkPropertyItemSortFilterProxyModel* m_ProxyModel;
+ QmitkPropertyItemModel* m_Model;
+};
+
+#endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.ui b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.ui
new file mode 100644
index 0000000000..87333b23d5
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.ui
@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QmitkPropertyTreeView</class>
+ <widget class="QWidget" name="QmitkPropertyTreeView">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>300</width>
+ <height>600</height>
+ </rect>
+ </property>
+ <property name="windowTitle">
+ <string></string>
+ </property>
+ <layout class="QVBoxLayout" name="layout">
+ <item>
+ <widget class="QmitkLineEdit" name="filter"/>
+ </item>
+ <item>
+ <widget class="QTreeView" name="treeView">
+ <property name="focusPolicy">
+ <enum>Qt::NoFocus</enum>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">::item {
+ border-right: 1px solid palette(midlight);
+ padding-bottom: 1px;
+ padding-top: 1px;
+}
+
+::item:last {
+ border-right: 0;
+}
+
+::item:selected {
+ background: palette(highlight);
+ color: palette(highlighted-text);
+}</string>
+ </property>
+ <property name="horizontalScrollBarPolicy">
+ <enum>Qt::ScrollBarAsNeeded</enum>
+ </property>
+ <property name="alternatingRowColors">
+ <bool>true</bool>
+ </property>
+ <property name="sortingEnabled">
+ <bool>true</bool>
+ </property>
+ <attribute name="headerDefaultSectionSize">
+ <number>54</number>
+ </attribute>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLabel" name="description">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="text">
+ <string/>
+ </property>
+ <property name="textFormat">
+ <enum>Qt::RichText</enum>
+ </property>
+ <property name="wordWrap">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ <customwidgets>
+ <customwidget>
+ <class>QmitkLineEdit</class>
+ <extends>QLineEdit</extends>
+ <header>QmitkLineEdit.h</header>
+ </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/mitkGetPropertyService.h b/Plugins/org.mitk.gui.qt.properties/src/internal/mitkGetPropertyService.h
new file mode 100644
index 0000000000..be6bb9d9e0
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/mitkGetPropertyService.h
@@ -0,0 +1,39 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkGetPropertyService_h
+#define mitkGetPropertyService_h
+
+#include "org_mitk_gui_qt_properties_Activator.h"
+#include <mitkLoadPropertiesModule.h>
+
+namespace mitk
+{
+ template <class T>
+ T* GetPropertyService()
+ {
+ mitk::LoadPropertiesModule();
+
+ ctkPluginContext* context = mitk::org_mitk_gui_qt_properties_Activator::GetContext();
+ ctkServiceReference serviceRef = context->getServiceReference<T>();
+
+ return serviceRef
+ ? context->getService<T>(serviceRef)
+ : NULL;
+ }
+}
+
+#endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.cpp
new file mode 100644
index 0000000000..16112dd4f4
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.cpp
@@ -0,0 +1,41 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "org_mitk_gui_qt_properties_Activator.h"
+#include "QmitkPropertiesPreferencePage.h"
+#include "QmitkPropertyTreeView.h"
+#include <QtPlugin>
+
+ctkPluginContext* mitk::org_mitk_gui_qt_properties_Activator::m_Context = NULL;
+
+ctkPluginContext* mitk::org_mitk_gui_qt_properties_Activator::GetContext()
+{
+ return m_Context;
+}
+
+void mitk::org_mitk_gui_qt_properties_Activator::start(ctkPluginContext* context)
+{
+ BERRY_REGISTER_EXTENSION_CLASS(QmitkPropertiesPreferencePage, context);
+ BERRY_REGISTER_EXTENSION_CLASS(QmitkPropertyTreeView, context);
+ m_Context = context;
+}
+
+void mitk::org_mitk_gui_qt_properties_Activator::stop(ctkPluginContext*)
+{
+ m_Context = NULL;
+}
+
+Q_EXPORT_PLUGIN2(org_mitk_gui_qt_properties, mitk::org_mitk_gui_qt_properties_Activator)
diff --git a/Core/Code/Rendering/mitkVtkMapper3D.h b/Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.h
similarity index 50%
copy from Core/Code/Rendering/mitkVtkMapper3D.h
copy to Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.h
index f31560ec0f..331a0bebd8 100644
--- a/Core/Code/Rendering/mitkVtkMapper3D.h
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/org_mitk_gui_qt_properties_Activator.h
@@ -1,31 +1,40 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
+#ifndef org_mitk_gui_qt_properties_Activator_h
+#define org_mitk_gui_qt_properties_Activator_h
-#ifndef BASEVTKMAPPER3D_H_HEADER_INCLUDED
-#define BASEVTKMAPPER3D_H_HEADER_INCLUDED
+#include <ctkPluginActivator.h>
-#include "mitkVtkMapper.h"
+namespace mitk
+{
+ class org_mitk_gui_qt_properties_Activator : public QObject, public ctkPluginActivator
+ {
+ Q_OBJECT
+ Q_INTERFACES(ctkPluginActivator)
-namespace mitk {
+ public:
+ static ctkPluginContext* GetContext();
- // typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead
- DEPRECATED(typedef VtkMapper VtkMapper3D);
+ void start(ctkPluginContext* context);
+ void stop(ctkPluginContext* context);
-} // namespace mitk
+ private:
+ static ctkPluginContext* m_Context;
+ };
+}
-#endif /* BASEVTKMAPPER3D_H_HEADER_INCLUDED */
+#endif
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkDeformableRegistrationView.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkDeformableRegistrationView.cpp
index e9dbc917ca..6f31cdea6b 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkDeformableRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkDeformableRegistrationView.cpp
@@ -1,644 +1,644 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkDeformableRegistrationView.h"
#include "ui_QmitkDeformableRegistrationViewControls.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkCommonFunctionality.h"
#include "qinputdialog.h"
#include "qmessagebox.h"
#include "qcursor.h"
#include "qapplication.h"
#include "qradiobutton.h"
#include "qslider.h"
#include <vtkTransform.h>
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateProperty.h"
#include "mitkNodePredicateAnd.h"
#include "mitkNodePredicateNot.h"
#include "mitkVectorImageMapper2D.h"
#include "itkImageFileReader.h"
#include "itkWarpImageFilter.h"
#include "mitkDataNodeObject.h"
#include "berryIWorkbenchWindow.h"
#include "berryISelectionService.h"
typedef itk::Vector< float, 3 > VectorType;
typedef itk::Image< VectorType, 3 > DeformationFieldType;
typedef itk::ImageFileReader< DeformationFieldType > ImageReaderType;
const std::string QmitkDeformableRegistrationView::VIEW_ID = "org.mitk.views.deformableregistration";
using namespace berry;
struct SelListenerDeformableRegistration : ISelectionListener
{
berryObjectMacro(SelListenerDeformableRegistration);
SelListenerDeformableRegistration(QmitkDeformableRegistrationView* 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)
{
if (m_View->m_CurrentSelection->Size() != 2)
{
if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
m_View->m_Controls.TextLabelFixed->hide();
m_View->m_Controls.m_SwitchImages->hide();
m_View->m_Controls.m_FixedLabel->hide();
m_View->m_Controls.TextLabelMoving->hide();
m_View->m_Controls.m_MovingLabel->hide();
m_View->m_Controls.m_OpacityLabel->setEnabled(false);
m_View->m_Controls.m_OpacitySlider->setEnabled(false);
m_View->m_Controls.label->setEnabled(false);
m_View->m_Controls.label_2->setEnabled(false);
m_View->m_Controls.m_ShowRedGreenValues->setEnabled(false);
}
}
else
{
m_View->m_Controls.m_StatusLabel->hide();
bool foundFixedImage = false;
mitk::DataNode::Pointer fixedNode;
// 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("Image").compare(node->GetData()->GetNameOfClass())==0)
{
if (dynamic_cast<mitk::Image*>(node->GetData())->GetDimension() == 4)
{
m_View->m_Controls.m_StatusLabel->show();
QMessageBox::information( NULL, "DeformableRegistration", "Only 2D or 3D images can be processed.", QMessageBox::Ok );
return;
}
if (foundFixedImage == false)
{
fixedNode = node;
foundFixedImage = true;
}
else
{
m_View->SetImagesVisible(selection);
m_View->FixedSelected(fixedNode);
m_View->MovingSelected(node);
m_View->m_Controls.m_StatusLabel->hide();
m_View->m_Controls.TextLabelFixed->show();
m_View->m_Controls.m_SwitchImages->show();
m_View->m_Controls.m_FixedLabel->show();
m_View->m_Controls.TextLabelMoving->show();
m_View->m_Controls.m_MovingLabel->show();
m_View->m_Controls.m_OpacityLabel->setEnabled(true);
m_View->m_Controls.m_OpacitySlider->setEnabled(true);
m_View->m_Controls.label->setEnabled(true);
m_View->m_Controls.label_2->setEnabled(true);
m_View->m_Controls.m_ShowRedGreenValues->setEnabled(true);
}
}
else
{
m_View->m_Controls.m_StatusLabel->show();
return;
}
}
}
}
}
else if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
}
}
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);
}
}
}
QmitkDeformableRegistrationView* m_View;
};
QmitkDeformableRegistrationView::QmitkDeformableRegistrationView(QObject * /*parent*/, const char * /*name*/)
: QmitkFunctionality() , m_MultiWidget(NULL), m_MovingNode(NULL), m_FixedNode(NULL), m_ShowRedGreen(false),
m_Opacity(0.5), m_OriginalOpacity(1.0), m_Deactivated(false)
{
this->GetDataStorage()->RemoveNodeEvent.AddListener(mitk::MessageDelegate1<QmitkDeformableRegistrationView,
const mitk::DataNode*> ( this, &QmitkDeformableRegistrationView::DataNodeHasBeenRemoved ));
}
QmitkDeformableRegistrationView::~QmitkDeformableRegistrationView()
{
if (m_SelListener.IsNotNull())
{
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
}
}
void QmitkDeformableRegistrationView::CreateQtPartControl(QWidget* parent)
{
m_Controls.setupUi(parent);
m_Parent->setEnabled(false);
this->CreateConnections();
m_Controls.TextLabelFixed->hide();
m_Controls.m_SwitchImages->hide();
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.m_OpacityLabel->setEnabled(false);
m_Controls.m_OpacitySlider->setEnabled(false);
m_Controls.label->setEnabled(false);
m_Controls.label_2->setEnabled(false);
m_Controls.m_ShowRedGreenValues->setEnabled(false);
m_Controls.m_DeformableTransform->hide();
if (m_Controls.m_DeformableTransform->currentIndex() == 0)
{
m_Controls.m_QmitkDemonsRegistrationViewControls->show();
m_Controls.m_QmitkBSplineRegistrationViewControls->hide();
}
else
{
m_Controls.m_QmitkDemonsRegistrationViewControls->hide();
m_Controls.m_QmitkBSplineRegistrationViewControls->show();
}
this->CheckCalculateEnabled();
}
void QmitkDeformableRegistrationView::DataNodeHasBeenRemoved(const mitk::DataNode* node)
{
if(node == m_FixedNode || node == m_MovingNode)
{
m_Controls.m_StatusLabel->show();
m_Controls.TextLabelFixed->hide();
m_Controls.m_SwitchImages->hide();
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.m_OpacityLabel->setEnabled(false);
m_Controls.m_OpacitySlider->setEnabled(false);
m_Controls.label->setEnabled(false);
m_Controls.label_2->setEnabled(false);
m_Controls.m_ShowRedGreenValues->setEnabled(false);
m_Controls.m_DeformableTransform->hide();
m_Controls.m_CalculateTransformation->setEnabled(false);
}
}
void QmitkDeformableRegistrationView::ApplyDeformationField()
{
ImageReaderType::Pointer reader = ImageReaderType::New();
reader->SetFileName( m_Controls.m_QmitkBSplineRegistrationViewControls->m_Controls.m_DeformationField->text().toStdString() );
reader->Update();
DeformationFieldType::Pointer deformationField = reader->GetOutput();
mitk::Image * mimage = dynamic_cast<mitk::Image*> (m_MovingNode->GetData());
mitk::Image * fimage = dynamic_cast<mitk::Image*> (m_FixedNode->GetData());
typedef itk::Image<float, 3> FloatImageType;
FloatImageType::Pointer itkMovingImage = FloatImageType::New();
FloatImageType::Pointer itkFixedImage = FloatImageType::New();
mitk::CastToItkImage(mimage, itkMovingImage);
mitk::CastToItkImage(fimage, itkFixedImage);
typedef itk::WarpImageFilter<
FloatImageType,
FloatImageType,
DeformationFieldType > WarperType;
typedef itk::LinearInterpolateImageFunction<
FloatImageType,
double > InterpolatorType;
WarperType::Pointer warper = WarperType::New();
InterpolatorType::Pointer interpolator = InterpolatorType::New();
warper->SetInput( itkMovingImage );
warper->SetInterpolator( interpolator );
warper->SetOutputSpacing( itkFixedImage->GetSpacing() );
warper->SetOutputOrigin( itkFixedImage->GetOrigin() );
warper->SetOutputDirection (itkFixedImage->GetDirection() );
- warper->SetDeformationField( deformationField );
+ warper->SetDisplacementField( deformationField );
warper->Update();
FloatImageType::Pointer outputImage = warper->GetOutput();
mitk::Image::Pointer result = mitk::Image::New();
mitk::CastToMitkImage(outputImage, result);
// Create new DataNode
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetData( result );
newNode->SetProperty( "name", mitk::StringProperty::New("warped image") );
// add the new datatree node to the datatree
this->GetDefaultDataStorage()->Add(newNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
//Image::Pointer outputImage = this->GetOutput();
//mitk::CastToMitkImage( warper->GetOutput(), outputImage );
}
void QmitkDeformableRegistrationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_Parent->setEnabled(true);
m_MultiWidget = &stdMultiWidget;
m_MultiWidget->SetWidgetPlanesVisibility(true);
}
void QmitkDeformableRegistrationView::StdMultiWidgetNotAvailable()
{
m_Parent->setEnabled(false);
m_MultiWidget = NULL;
}
void QmitkDeformableRegistrationView::CreateConnections()
{
connect(m_Controls.m_ShowRedGreenValues, SIGNAL(toggled(bool)), this, SLOT(ShowRedGreen(bool)));
connect(m_Controls.m_DeformableTransform, SIGNAL(currentChanged(int)), this, SLOT(TabChanged(int)));
connect(m_Controls.m_OpacitySlider, SIGNAL(sliderMoved(int)), this, SLOT(OpacityUpdate(int)));
connect(m_Controls.m_CalculateTransformation, SIGNAL(clicked()), this, SLOT(Calculate()));
connect((QObject*)(m_Controls.m_SwitchImages),SIGNAL(clicked()),this,SLOT(SwitchImages()));
connect(this,SIGNAL(calculateBSplineRegistration()),m_Controls.m_QmitkBSplineRegistrationViewControls,SLOT(CalculateTransformation()));
connect( (QObject*)(m_Controls.m_QmitkBSplineRegistrationViewControls->m_Controls.m_ApplyDeformationField),
SIGNAL(clicked()),
(QObject*) this,
SLOT(ApplyDeformationField()) );
}
void QmitkDeformableRegistrationView::Activated()
{
m_Deactivated = false;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Activated();
if (m_SelListener.IsNull())
{
m_SelListener = berry::ISelectionListener::Pointer(new SelListenerDeformableRegistration(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<SelListenerDeformableRegistration>()->DoSelectionChanged(sel);
}
this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
}
void QmitkDeformableRegistrationView::Visible()
{
/*
m_Deactivated = false;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Activated();
if (m_SelListener.IsNull())
{
m_SelListener = berry::ISelectionListener::Pointer(new SelListenerDeformableRegistration(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<SelListenerDeformableRegistration>()->DoSelectionChanged(sel);
}
this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());*/
}
void QmitkDeformableRegistrationView::Deactivated()
{
m_Deactivated = true;
this->SetImageColor(false);
if (m_FixedNode.IsNotNull())
m_FixedNode->SetOpacity(1.0);
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
}
m_FixedNode = NULL;
m_MovingNode = NULL;
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
}
void QmitkDeformableRegistrationView::Hidden()
{
/*
m_Deactivated = true;
this->SetImageColor(false);
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
}
m_FixedNode = NULL;
m_MovingNode = NULL;
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;*/
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
//QmitkFunctionality::Deactivated();
}
void QmitkDeformableRegistrationView::FixedSelected(mitk::DataNode::Pointer fixedImage)
{
if (fixedImage.IsNotNull())
{
if (m_FixedNode != fixedImage)
{
// remove changes on previous selected node
if (m_FixedNode.IsNotNull())
{
this->SetImageColor(false);
m_FixedNode->SetOpacity(1.0);
m_FixedNode->SetVisibility(false);
m_FixedNode->SetProperty("selectedFixedImage", mitk::BoolProperty::New(false));
}
// get selected node
m_FixedNode = fixedImage;
m_FixedNode->SetOpacity(0.5);
m_Controls.TextLabelFixed->setText(QString::fromStdString(m_FixedNode->GetName()));
m_Controls.m_FixedLabel->show();
m_Controls.TextLabelFixed->show();
m_Controls.m_SwitchImages->show();
mitk::ColorProperty::Pointer colorProperty;
colorProperty = dynamic_cast<mitk::ColorProperty*>(m_FixedNode->GetProperty("color"));
if ( colorProperty.IsNotNull() )
{
m_FixedColor = colorProperty->GetColor();
}
this->SetImageColor(m_ShowRedGreen);
m_FixedNode->SetVisibility(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
else
{
m_FixedNode = fixedImage;
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.m_SwitchImages->hide();
}
this->CheckCalculateEnabled();
}
void QmitkDeformableRegistrationView::MovingSelected(mitk::DataNode::Pointer movingImage)
{
if (movingImage.IsNotNull())
{
if (m_MovingNode != movingImage)
{
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
if (m_FixedNode == m_MovingNode)
m_FixedNode->SetOpacity(0.5);
this->SetImageColor(false);
}
m_MovingNode = movingImage;
m_Controls.TextLabelMoving->setText(QString::fromStdString(m_MovingNode->GetName()));
m_Controls.m_MovingLabel->show();
m_Controls.TextLabelMoving->show();
mitk::ColorProperty::Pointer colorProperty;
colorProperty = dynamic_cast<mitk::ColorProperty*>(m_MovingNode->GetProperty("color"));
if ( colorProperty.IsNotNull() )
{
m_MovingColor = colorProperty->GetColor();
}
this->SetImageColor(m_ShowRedGreen);
m_MovingNode->GetFloatProperty("opacity", m_OriginalOpacity);
this->OpacityUpdate(m_Opacity);
m_MovingNode->SetVisibility(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
else
{
m_MovingNode = NULL;
m_Controls.m_MovingLabel->hide();
m_Controls.TextLabelMoving->hide();
}
this->CheckCalculateEnabled();
}
bool QmitkDeformableRegistrationView::CheckCalculate()
{
if(m_MovingNode==m_FixedNode)
return false;
return true;
}
void QmitkDeformableRegistrationView::ShowRedGreen(bool redGreen)
{
m_ShowRedGreen = redGreen;
this->SetImageColor(m_ShowRedGreen);
}
void QmitkDeformableRegistrationView::SetImageColor(bool redGreen)
{
if (!redGreen && m_FixedNode.IsNotNull())
{
m_FixedNode->SetColor(m_FixedColor);
}
if (!redGreen && m_MovingNode.IsNotNull())
{
m_MovingNode->SetColor(m_MovingColor);
}
if (redGreen && m_FixedNode.IsNotNull())
{
m_FixedNode->SetColor(1.0f, 0.0f, 0.0f);
}
if (redGreen && m_MovingNode.IsNotNull())
{
m_MovingNode->SetColor(0.0f, 1.0f, 0.0f);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkDeformableRegistrationView::OpacityUpdate(float opacity)
{
m_Opacity = opacity;
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_Opacity);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkDeformableRegistrationView::OpacityUpdate(int opacity)
{
float fValue = ((float)opacity)/100.0f;
this->OpacityUpdate(fValue);
}
void QmitkDeformableRegistrationView::CheckCalculateEnabled()
{
if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
{
m_Controls.m_CalculateTransformation->setEnabled(true);
}
else
{
m_Controls.m_CalculateTransformation->setEnabled(false);
}
}
void QmitkDeformableRegistrationView::Calculate()
{
if (m_Controls.m_DeformableTransform->tabText(m_Controls.m_DeformableTransform->currentIndex()) == "Demons")
{
m_Controls.m_QmitkDemonsRegistrationViewControls->SetFixedNode(m_FixedNode);
m_Controls.m_QmitkDemonsRegistrationViewControls->SetMovingNode(m_MovingNode);
try
{
m_Controls.m_QmitkDemonsRegistrationViewControls->CalculateTransformation();
}
catch (itk::ExceptionObject& excpt)
{
QMessageBox::information( NULL, "Registration exception", excpt.GetDescription(), QMessageBox::Ok );
return;
}
mitk::Image::Pointer resultImage = m_Controls.m_QmitkDemonsRegistrationViewControls->GetResultImage();
mitk::Image::Pointer resultDeformationField = m_Controls.m_QmitkDemonsRegistrationViewControls->GetResultDeformationfield();
if (resultImage.IsNotNull())
{
mitk::DataNode::Pointer resultImageNode = mitk::DataNode::New();
resultImageNode->SetData(resultImage);
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelWindow;
levelWindow.SetAuto( resultImage );
levWinProp->SetLevelWindow(levelWindow);
resultImageNode->GetPropertyList()->SetProperty("levelwindow",levWinProp);
resultImageNode->SetStringProperty("name", "DeformableRegistrationResultImage");
this->GetDataStorage()->Add(resultImageNode, m_MovingNode);
}
if (resultDeformationField.IsNotNull())
{
mitk::DataNode::Pointer resultDeformationFieldNode = mitk::DataNode::New();
resultDeformationFieldNode->SetData(resultDeformationField);
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelWindow;
levelWindow.SetAuto( resultDeformationField );
levWinProp->SetLevelWindow(levelWindow);
resultDeformationFieldNode->GetPropertyList()->SetProperty("levelwindow",levWinProp);
resultDeformationFieldNode->SetStringProperty("name", "DeformableRegistrationResultDeformationField");
mitk::VectorImageMapper2D::Pointer mapper = mitk::VectorImageMapper2D::New();
resultDeformationFieldNode->SetMapper(1, mapper);
resultDeformationFieldNode->SetVisibility(false);
this->GetDataStorage()->Add(resultDeformationFieldNode, m_MovingNode);
}
}
else if (m_Controls.m_DeformableTransform->tabText(m_Controls.m_DeformableTransform->currentIndex()) == "B-Spline")
{
m_Controls.m_QmitkBSplineRegistrationViewControls->SetFixedNode(m_FixedNode);
m_Controls.m_QmitkBSplineRegistrationViewControls->SetMovingNode(m_MovingNode);
emit calculateBSplineRegistration();
}
}
void QmitkDeformableRegistrationView::SetImagesVisible(berry::ISelection::ConstPointer /*selection*/)
{
if (this->m_CurrentSelection->Size() == 0)
{
// show all images
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
{
nodeIt->Value()->SetVisibility(true);
}
}
}
else
{
// hide all images
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
{
nodeIt->Value()->SetVisibility(false);
}
}
}
}
void QmitkDeformableRegistrationView::TabChanged(int index)
{
if (index == 0)
{
m_Controls.m_QmitkDemonsRegistrationViewControls->show();
m_Controls.m_QmitkBSplineRegistrationViewControls->hide();
}
else
{
m_Controls.m_QmitkDemonsRegistrationViewControls->hide();
m_Controls.m_QmitkBSplineRegistrationViewControls->show();
}
}
void QmitkDeformableRegistrationView::SwitchImages()
{
mitk::DataNode::Pointer newMoving = m_FixedNode;
mitk::DataNode::Pointer newFixed = m_MovingNode;
this->FixedSelected(newFixed);
this->MovingSelected(newMoving);
}
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
index 0f62da5d3b..2b81668b77 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
@@ -1,1359 +1,1359 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkPointBasedRegistrationView.h"
#include "ui_QmitkPointBasedRegistrationViewControls.h"
#include "QmitkPointListWidget.h"
#include <vtkIterativeClosestPointTransform.h>
#include <vtkMatrix4x4.h>
#include <vtkMath.h>
#include <vtkLandmarkTransform.h>
#include <QmitkStdMultiWidget.h>
#include "QmitkCommonFunctionality.h"
#include "qradiobutton.h"
#include "qapplication.h"
#include <qcursor.h>
#include <qinputdialog.h>
#include <qlcdnumber.h>
#include <qlabel.h>
#include "qmessagebox.h"
#include "mitkLandmarkWarping.h"
#include <mitkPointOperation.h>
#include <mitkPositionEvent.h>
#include "mitkOperationEvent.h"
#include "mitkUndoController.h"
#include <mitkPointSetWriter.h>
#include <mitkPointSetReader.h>
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateProperty.h"
#include "mitkNodePredicateAnd.h"
#include "mitkNodePredicateNot.h"
#include <mitkMessage.h>
#include <itkCommand.h>
#include "mitkDataNodeObject.h"
#include "berryIWorkbenchWindow.h"
#include "berryISelectionService.h"
const std::string QmitkPointBasedRegistrationView::VIEW_ID = "org.mitk.views.pointbasedregistration";
using namespace berry;
struct SelListenerPointBasedRegistration : ISelectionListener
{
berryObjectMacro(SelListenerPointBasedRegistration);
SelListenerPointBasedRegistration(QmitkPointBasedRegistrationView* 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)
{
if (m_View->m_CurrentSelection->Size() != 2)
{
if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
m_View->m_Controls.TextLabelFixed->hide();
m_View->m_Controls.m_FixedLabel->hide();
m_View->m_Controls.line2->hide();
m_View->m_Controls.m_FixedPointListWidget->hide();
m_View->m_Controls.TextLabelMoving->hide();
m_View->m_Controls.m_MovingLabel->hide();
m_View->m_Controls.line1->hide();
m_View->m_Controls.m_MovingPointListWidget->hide();
m_View->m_Controls.m_OpacityLabel->hide();
m_View->m_Controls.m_OpacitySlider->hide();
m_View->m_Controls.label->hide();
m_View->m_Controls.label_2->hide();
m_View->m_Controls.m_SwitchImages->hide();
m_View->m_Controls.m_ShowRedGreenValues->setEnabled(false);
}
}
else
{
m_View->m_Controls.m_StatusLabel->hide();
bool foundFixedImage = false;
mitk::DataNode::Pointer fixedNode;
// 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::TNodePredicateDataType<mitk::BaseData>::Pointer isBaseData(mitk::TNodePredicateDataType<mitk::BaseData>::New());
mitk::TNodePredicateDataType<mitk::PointSet>::Pointer isPointSet(mitk::TNodePredicateDataType<mitk::PointSet>::New());
mitk::NodePredicateNot::Pointer notPointSet = mitk::NodePredicateNot::New(isPointSet);
mitk::TNodePredicateDataType<mitk::Geometry2DData>::Pointer isGeometry2DData(mitk::TNodePredicateDataType<mitk::Geometry2DData>::New());
mitk::NodePredicateNot::Pointer notGeometry2DData = mitk::NodePredicateNot::New(isGeometry2DData);
mitk::NodePredicateAnd::Pointer notPointSetAndNotGeometry2DData = mitk::NodePredicateAnd::New( notPointSet, notGeometry2DData );
mitk::NodePredicateAnd::Pointer predicate = mitk::NodePredicateAnd::New( isBaseData, notPointSetAndNotGeometry2DData );
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = m_View->GetDataStorage()->GetSubset(predicate);
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
// only look at interesting types
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if(nodeIt->Value().GetPointer() == node.GetPointer())
{
// was - compare()
// use contain to allow other Image types to be selected, i.e. a diffusion image
if (QString( node->GetData()->GetNameOfClass() ).contains("Image") )
{
// verify that the node selected by name is really an image or derived class
mitk::Image* _image = dynamic_cast<mitk::Image*>(node->GetData());
if (_image != NULL)
{
if( _image->GetDimension() == 4)
{
m_View->m_Controls.m_StatusLabel->show();
QMessageBox::information( NULL, "PointBasedRegistration", "Only 2D or 3D images can be processed.", QMessageBox::Ok );
return;
}
if (foundFixedImage == false)
{
fixedNode = node;
foundFixedImage = true;
}
else
{
m_View->SetImagesVisible(selection);
m_View->FixedSelected(fixedNode);
m_View->MovingSelected(node);
m_View->m_Controls.m_StatusLabel->hide();
m_View->m_Controls.TextLabelFixed->show();
m_View->m_Controls.m_FixedLabel->show();
m_View->m_Controls.line2->show();
m_View->m_Controls.m_FixedPointListWidget->show();
m_View->m_Controls.TextLabelMoving->show();
m_View->m_Controls.m_MovingLabel->show();
m_View->m_Controls.line1->show();
m_View->m_Controls.m_MovingPointListWidget->show();
m_View->m_Controls.m_OpacityLabel->show();
m_View->m_Controls.m_OpacitySlider->show();
m_View->m_Controls.label->show();
m_View->m_Controls.label_2->show();
m_View->m_Controls.m_SwitchImages->show();
m_View->m_Controls.m_ShowRedGreenValues->setEnabled(true);
}
}
}
else
{
m_View->m_Controls.m_StatusLabel->show();
return;
}
}
}
}
}
if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
}
}
}
else if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
}
}
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);
}
}
}
QmitkPointBasedRegistrationView* m_View;
};
QmitkPointBasedRegistrationView::QmitkPointBasedRegistrationView(QObject * /*parent*/, const char * /*name*/)
: QmitkFunctionality(), m_SelListener(0), m_MultiWidget(NULL), m_FixedLandmarks(NULL), m_MovingLandmarks(NULL), m_MovingNode(NULL),
m_FixedNode(NULL), m_ShowRedGreen(false), m_Opacity(0.5), m_OriginalOpacity(1.0), m_Transformation(0), m_HideFixedImage(false), m_HideMovingImage(false),
m_OldFixedLabel(""), m_OldMovingLabel(""), m_Deactivated (false), m_CurrentFixedLandmarksObserverID(0), m_CurrentMovingLandmarksObserverID(0)
{
m_FixedLandmarksChangedCommand = itk::SimpleMemberCommand<QmitkPointBasedRegistrationView>::New();
m_FixedLandmarksChangedCommand->SetCallbackFunction(this, &QmitkPointBasedRegistrationView::updateFixedLandmarksList);
m_MovingLandmarksChangedCommand = itk::SimpleMemberCommand<QmitkPointBasedRegistrationView>::New();
m_MovingLandmarksChangedCommand->SetCallbackFunction(this, &QmitkPointBasedRegistrationView::updateMovingLandmarksList);
this->GetDataStorage()->RemoveNodeEvent.AddListener(mitk::MessageDelegate1<QmitkPointBasedRegistrationView,
const mitk::DataNode*> ( this, &QmitkPointBasedRegistrationView::DataNodeHasBeenRemoved ));
}
QmitkPointBasedRegistrationView::~QmitkPointBasedRegistrationView()
{
if(m_SelListener.IsNotNull())
{
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
}
if (m_FixedPointSetNode.IsNotNull())
{
m_Controls.m_FixedPointListWidget->DeactivateInteractor(true);
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
}
if (m_MovingPointSetNode.IsNotNull())
{
m_Controls.m_MovingPointListWidget->DeactivateInteractor(true);
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
}
m_Controls.m_FixedPointListWidget->SetPointSetNode(NULL);
m_Controls.m_MovingPointListWidget->SetPointSetNode(NULL);
}
void QmitkPointBasedRegistrationView::CreateQtPartControl(QWidget* parent)
{
m_Controls.setupUi(parent);
m_Parent->setEnabled(false);
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
m_Controls.m_SwitchImages->hide();
m_Controls.m_ShowRedGreenValues->setEnabled(false);
this->CreateConnections();
// let the point set widget know about the multi widget (cross hair updates)
m_Controls.m_FixedPointListWidget->SetMultiWidget( m_MultiWidget );
m_Controls.m_MovingPointListWidget->SetMultiWidget( m_MultiWidget );
}
void QmitkPointBasedRegistrationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_Parent->setEnabled(true);
m_MultiWidget = &stdMultiWidget;
m_MultiWidget->SetWidgetPlanesVisibility(true);
m_Controls.m_FixedPointListWidget->SetMultiWidget( m_MultiWidget );
m_Controls.m_MovingPointListWidget->SetMultiWidget( m_MultiWidget );
}
void QmitkPointBasedRegistrationView::StdMultiWidgetNotAvailable()
{
m_Parent->setEnabled(false);
m_MultiWidget = NULL;
m_Controls.m_FixedPointListWidget->SetMultiWidget( NULL );
m_Controls.m_MovingPointListWidget->SetMultiWidget( NULL );
}
void QmitkPointBasedRegistrationView::CreateConnections()
{
connect( (QObject*)(m_Controls.m_FixedPointListWidget), SIGNAL(EditPointSets(bool)), (QObject*)(m_Controls.m_MovingPointListWidget), SLOT(DeactivateInteractor(bool)));
connect( (QObject*)(m_Controls.m_MovingPointListWidget), SIGNAL(EditPointSets(bool)), (QObject*)(m_Controls.m_FixedPointListWidget), SLOT(DeactivateInteractor(bool)));
connect( (QObject*)(m_Controls.m_FixedPointListWidget), SIGNAL(EditPointSets(bool)), this, SLOT(HideMovingImage(bool)));
connect( (QObject*)(m_Controls.m_MovingPointListWidget), SIGNAL(EditPointSets(bool)), this, SLOT(HideFixedImage(bool)));
connect( (QObject*)(m_Controls.m_FixedPointListWidget), SIGNAL(PointListChanged()), this, SLOT(updateFixedLandmarksList()));
connect( (QObject*)(m_Controls.m_MovingPointListWidget), SIGNAL(PointListChanged()), this, SLOT(updateMovingLandmarksList()));
connect((QObject*)(m_Controls.m_Calculate),SIGNAL(clicked()),this,SLOT(calculate()));
connect((QObject*)(m_Controls.m_SwitchImages),SIGNAL(clicked()),this,SLOT(SwitchImages()));
connect((QObject*)(m_Controls.m_UndoTransformation),SIGNAL(clicked()),this,SLOT(UndoTransformation()));
connect((QObject*)(m_Controls.m_RedoTransformation),SIGNAL(clicked()),this,SLOT(RedoTransformation()));
connect((QObject*)(m_Controls.m_ShowRedGreenValues),SIGNAL(toggled(bool)),this,SLOT(showRedGreen(bool)));
connect((QObject*)(m_Controls.m_OpacitySlider),SIGNAL(valueChanged(int)),this,SLOT(OpacityUpdate(int)));
connect((QObject*)(m_Controls.m_SelectedTransformationClass),SIGNAL(activated(int)), this,SLOT(transformationChanged(int)));
connect((QObject*)(m_Controls.m_UseICP),SIGNAL(toggled(bool)), this,SLOT(checkCalculateEnabled()));
connect((QObject*)(m_Controls.m_UseICP),SIGNAL(toggled(bool)), this,SLOT(checkLandmarkError()));
}
void QmitkPointBasedRegistrationView::Activated()
{
m_Deactivated = false;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Activated();
this->clearTransformationLists();
if (m_SelListener.IsNull())
{
m_SelListener = berry::ISelectionListener::Pointer(new SelListenerPointBasedRegistration(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<SelListenerPointBasedRegistration>()->DoSelectionChanged(sel);
}
this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
this->showRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
}
void QmitkPointBasedRegistrationView::Visible()
{
}
void QmitkPointBasedRegistrationView::Deactivated()
{
m_Deactivated = true;
if (m_FixedPointSetNode.IsNotNull())
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
m_Controls.m_FixedPointListWidget->SetPointSetNode(NULL);
m_Controls.m_FixedPointListWidget->DeactivateInteractor(true);
if (m_MovingPointSetNode.IsNotNull())
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
m_Controls.m_MovingPointListWidget->SetPointSetNode(NULL);
m_Controls.m_MovingPointListWidget->DeactivateInteractor(true);
this->setImageColor(false);
if (m_FixedNode.IsNotNull())
m_FixedNode->SetOpacity(1.0);
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
}
this->clearTransformationLists();
if (m_FixedPointSetNode.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_FixedLandmarks->GetSize() == 0)
{
this->GetDataStorage()->Remove(m_FixedPointSetNode);
}
if (m_MovingPointSetNode.IsNotNull() && m_MovingLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() == 0)
{
this->GetDataStorage()->Remove(m_MovingPointSetNode);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_FixedNode = NULL;
m_MovingNode = NULL;
if(m_FixedLandmarks.IsNotNull())
m_FixedLandmarks->RemoveObserver(m_CurrentFixedLandmarksObserverID);
m_FixedLandmarks = NULL;
if(m_MovingLandmarks.IsNotNull())
m_MovingLandmarks->RemoveObserver(m_CurrentMovingLandmarksObserverID);
m_MovingLandmarks = NULL;
m_FixedPointSetNode = NULL;
m_MovingPointSetNode = NULL;
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
m_Controls.m_SwitchImages->hide();
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
}
void QmitkPointBasedRegistrationView::Hidden()
{
/*
m_Deactivated = true;
if (m_FixedPointSetNode.IsNotNull())
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
m_Controls.m_FixedPointListWidget->SetPointSetNode(NULL);
m_Controls.m_FixedPointListWidget->DeactivateInteractor(true);
if (m_MovingPointSetNode.IsNotNull())
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
m_Controls.m_MovingPointListWidget->SetPointSetNode(NULL);
m_Controls.m_MovingPointListWidget->DeactivateInteractor(true);
this->setImageColor(false);
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
}
this->clearTransformationLists();
if (m_FixedPointSetNode.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_FixedLandmarks->GetSize() == 0)
{
this->GetDataStorage()->Remove(m_FixedPointSetNode);
}
if (m_MovingPointSetNode.IsNotNull() && m_MovingLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() == 0)
{
this->GetDataStorage()->Remove(m_MovingPointSetNode);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_FixedNode = NULL;
m_MovingNode = NULL;
if(m_FixedLandmarks.IsNotNull())
m_FixedLandmarks->RemoveObserver(m_CurrentFixedLandmarksObserverID);
m_FixedLandmarks = NULL;
if(m_MovingLandmarks.IsNotNull())
m_MovingLandmarks->RemoveObserver(m_CurrentMovingLandmarksObserverID);
m_MovingLandmarks = NULL;
m_FixedPointSetNode = NULL;
m_MovingPointSetNode = NULL;
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
m_Controls.m_SwitchImages->hide();
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
//QmitkFunctionality::Deactivated();*/
}
void QmitkPointBasedRegistrationView::DataNodeHasBeenRemoved(const mitk::DataNode* node)
{
if(node == m_FixedNode || node == m_MovingNode)
{
m_Controls.m_StatusLabel->show();
m_Controls.TextLabelFixed->hide();
m_Controls.m_FixedLabel->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
m_Controls.m_SwitchImages->hide();
m_Controls.m_ShowRedGreenValues->setEnabled(false);
}
}
void QmitkPointBasedRegistrationView::FixedSelected(mitk::DataNode::Pointer fixedImage)
{
if(m_FixedLandmarks.IsNotNull())
m_FixedLandmarks->RemoveObserver(m_CurrentFixedLandmarksObserverID);
if (fixedImage.IsNotNull())
{
if (m_FixedNode != fixedImage)
{
// remove changes on previous selected node
if (m_FixedNode.IsNotNull())
{
this->setImageColor(false);
m_FixedNode->SetOpacity(1.0);
if (m_FixedPointSetNode.IsNotNull())
{
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
}
}
// get selected node
m_FixedNode = fixedImage;
m_FixedNode->SetOpacity(0.5);
m_FixedNode->SetVisibility(true);
m_Controls.m_FixedLabel->setText(QString::fromStdString(m_FixedNode->GetName()));
m_Controls.m_FixedLabel->show();
m_Controls.m_SwitchImages->show();
m_Controls.TextLabelFixed->show();
m_Controls.line2->show();
m_Controls.m_FixedPointListWidget->show();
mitk::ColorProperty::Pointer colorProperty;
colorProperty = dynamic_cast<mitk::ColorProperty*>(m_FixedNode->GetProperty("color"));
if ( colorProperty.IsNotNull() )
{
m_FixedColor = colorProperty->GetColor();
}
this->setImageColor(m_ShowRedGreen);
bool hasPointSetNode = false;
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_FixedNode);
unsigned long size;
size = children->Size();
for (unsigned long i = 0; i < size; ++i)
{
mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(children->GetElement(i)->GetProperty("name"));
if(nameProp.IsNotNull() && nameProp->GetValueAsString()=="PointBasedRegistrationNode")
{
m_FixedPointSetNode=children->GetElement(i);
m_FixedLandmarks = dynamic_cast<mitk::PointSet*> (m_FixedPointSetNode->GetData());
this->GetDataStorage()->Remove(m_FixedPointSetNode);
hasPointSetNode = true;
break;
}
}
if (!hasPointSetNode)
{
m_FixedLandmarks = mitk::PointSet::New();
m_FixedPointSetNode = mitk::DataNode::New();
m_FixedPointSetNode->SetData(m_FixedLandmarks);
m_FixedPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
}
m_FixedPointSetNode->GetStringProperty("label", m_OldFixedLabel);
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New("F "));
m_FixedPointSetNode->SetProperty("color", mitk::ColorProperty::New(0.0f, 1.0f, 1.0f));
m_FixedPointSetNode->SetVisibility(true);
m_Controls.m_FixedPointListWidget->SetPointSetNode(m_FixedPointSetNode);
this->GetDataStorage()->Add(m_FixedPointSetNode, m_FixedNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
if (m_FixedPointSetNode.IsNull())
{
m_FixedLandmarks = mitk::PointSet::New();
m_FixedPointSetNode = mitk::DataNode::New();
m_FixedPointSetNode->SetData(m_FixedLandmarks);
m_FixedPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
m_FixedPointSetNode->GetStringProperty("label", m_OldFixedLabel);
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New("F "));
m_FixedPointSetNode->SetProperty("color", mitk::ColorProperty::New(0.0f, 1.0f, 1.0f));
m_FixedPointSetNode->SetVisibility(true);
m_Controls.m_FixedPointListWidget->SetPointSetNode(m_FixedPointSetNode);
this->GetDataStorage()->Add(m_FixedPointSetNode, m_FixedNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
else
{
m_FixedNode = NULL;
if (m_FixedPointSetNode.IsNotNull())
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
m_FixedPointSetNode = NULL;
m_FixedLandmarks = NULL;
m_Controls.m_FixedPointListWidget->SetPointSetNode(m_FixedPointSetNode);
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.m_SwitchImages->hide();
}
if(m_FixedLandmarks.IsNotNull())
m_CurrentFixedLandmarksObserverID = m_FixedLandmarks->AddObserver(itk::ModifiedEvent(), m_FixedLandmarksChangedCommand);
}
void QmitkPointBasedRegistrationView::MovingSelected(mitk::DataNode::Pointer movingImage)
{
if(m_MovingLandmarks.IsNotNull())
m_MovingLandmarks->RemoveObserver(m_CurrentMovingLandmarksObserverID);
if (movingImage.IsNotNull())
{
if (m_MovingNode != movingImage)
{
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
if (m_FixedNode == m_MovingNode)
m_FixedNode->SetOpacity(0.5);
this->setImageColor(false);
if (m_MovingNode != m_FixedNode)
{
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
}
else
{
m_OldFixedLabel = m_OldMovingLabel;
}
}
if (m_MovingPointSetNode.IsNotNull())
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
m_MovingNode = movingImage;
m_MovingNode->SetVisibility(true);
m_Controls.m_MovingLabel->setText(QString::fromStdString(m_MovingNode->GetName()));
m_Controls.m_MovingLabel->show();
m_Controls.TextLabelMoving->show();
m_Controls.line1->show();
m_Controls.m_MovingPointListWidget->show();
m_Controls.m_OpacityLabel->show();
m_Controls.m_OpacitySlider->show();
m_Controls.label->show();
m_Controls.label_2->show();
mitk::ColorProperty::Pointer colorProperty;
colorProperty = dynamic_cast<mitk::ColorProperty*>(m_MovingNode->GetProperty("color"));
if ( colorProperty.IsNotNull() )
{
m_MovingColor = colorProperty->GetColor();
}
this->setImageColor(m_ShowRedGreen);
m_MovingNode->GetFloatProperty("opacity", m_OriginalOpacity);
this->OpacityUpdate(m_Opacity);
bool hasPointSetNode = false;
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
unsigned long size;
size = children->Size();
for (unsigned long i = 0; i < size; ++i)
{
mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(children->GetElement(i)->GetProperty("name"));
if(nameProp.IsNotNull() && nameProp->GetValueAsString()=="PointBasedRegistrationNode")
{
m_MovingPointSetNode=children->GetElement(i);
m_MovingLandmarks = dynamic_cast<mitk::PointSet*> (m_MovingPointSetNode->GetData());
this->GetDataStorage()->Remove(m_MovingPointSetNode);
hasPointSetNode = true;
break;
}
}
if (!hasPointSetNode)
{
m_MovingLandmarks = mitk::PointSet::New();
m_MovingPointSetNode = mitk::DataNode::New();
m_MovingPointSetNode->SetData(m_MovingLandmarks);
m_MovingPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
}
this->GetDataStorage()->Add(m_MovingPointSetNode, m_MovingNode);
m_MovingPointSetNode->GetStringProperty("label", m_OldMovingLabel);
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New("M "));
m_MovingPointSetNode->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f));
m_MovingPointSetNode->SetVisibility(true);
m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->clearTransformationLists();
this->OpacityUpdate(m_Opacity);
}
if (m_MovingPointSetNode.IsNull())
{
m_MovingLandmarks = mitk::PointSet::New();
m_MovingPointSetNode = mitk::DataNode::New();
m_MovingPointSetNode->SetData(m_MovingLandmarks);
m_MovingPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
m_MovingPointSetNode->GetStringProperty("label", m_OldMovingLabel);
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New("M "));
m_MovingPointSetNode->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f));
m_MovingPointSetNode->SetVisibility(true);
m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);
this->GetDataStorage()->Add(m_MovingPointSetNode, m_MovingNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
else
{
m_MovingNode = NULL;
if (m_MovingPointSetNode.IsNotNull())
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
m_MovingPointSetNode = NULL;
m_MovingLandmarks = NULL;
m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);
m_Controls.m_MovingLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
}
if(m_MovingLandmarks.IsNotNull())
m_CurrentMovingLandmarksObserverID = m_MovingLandmarks->AddObserver(itk::ModifiedEvent(), m_MovingLandmarksChangedCommand);
}
void QmitkPointBasedRegistrationView::updateMovingLandmarksList()
{
// mitk::PointSet* ps = mitk::PointSet::New();
// ps = dynamic_cast<mitk::PointSet*>(m_MovingPointSetNode->GetData());
// mitk::DataNode::Pointer tmpPtr = m_MovingPointSetNode;
// m_MovingLandmarks = 0;
// m_MovingLandmarks = (ps);
m_MovingLandmarks = dynamic_cast<mitk::PointSet*>(m_MovingPointSetNode->GetData());
// m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode); //Workaround: m_MovingPointListWidget->m_PointListView->m_PointListModel loses the pointer on the pointsetnode
this->checkLandmarkError();
this->CheckCalculate();
}
void QmitkPointBasedRegistrationView::updateFixedLandmarksList()
{
m_FixedLandmarks = dynamic_cast<mitk::PointSet*>(m_FixedPointSetNode->GetData());
this->checkLandmarkError();
this->CheckCalculate();
}
void QmitkPointBasedRegistrationView::HideFixedImage(bool hide)
{
m_HideFixedImage = hide;
if(m_FixedNode.IsNotNull())
{
m_FixedNode->SetVisibility(!hide);
}
if (hide)
{
//this->reinitMovingClicked();
}
if (!m_HideMovingImage && !m_HideFixedImage)
{
//this->globalReinitClicked();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkPointBasedRegistrationView::HideMovingImage(bool hide)
{
m_HideMovingImage = hide;
if(m_MovingNode.IsNotNull())
{
m_MovingNode->SetVisibility(!hide);
}
if (hide)
{
//this->reinitFixedClicked();
}
if (!m_HideMovingImage && !m_HideFixedImage)
{
//this->globalReinitClicked();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
bool QmitkPointBasedRegistrationView::CheckCalculate()
{
if((m_MovingPointSetNode.IsNull())||(m_FixedPointSetNode.IsNull()||m_FixedLandmarks.IsNull()||m_MovingLandmarks.IsNull()))
return false;
if(m_MovingNode==m_FixedNode)
return false;
return this->checkCalculateEnabled();
}
void QmitkPointBasedRegistrationView::UndoTransformation()
{
if(!m_UndoPointsGeometryList.empty())
{
- mitk::AffineGeometryFrame3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
+ mitk::Geometry3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
m_RedoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.GetPointer()));
m_MovingLandmarks->SetGeometry(m_UndoPointsGeometryList.back());
m_UndoPointsGeometryList.pop_back();
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingPointSetNode->SetMapper(1, NULL);
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
- mitk::AffineGeometryFrame3D::Pointer movingGeometry = movingData->GetGeometry(0)->Clone();
+ mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0)->Clone();
m_RedoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingGeometry.GetPointer()));
movingData->SetGeometry(m_UndoGeometryList.back());
m_UndoGeometryList.pop_back();
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingNode->SetMapper(1, NULL);
mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
movingData->GetTimeSlicedGeometry()->UpdateInformation();
m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
m_Controls.m_RedoTransformation->setEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->checkLandmarkError();
}
if(!m_UndoPointsGeometryList.empty())
{
m_Controls.m_UndoTransformation->setEnabled(true);
}
else
{
m_Controls.m_UndoTransformation->setEnabled(false);
}
}
void QmitkPointBasedRegistrationView::RedoTransformation()
{
if(!m_RedoPointsGeometryList.empty())
{
- mitk::AffineGeometryFrame3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
+ mitk::Geometry3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
m_UndoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.GetPointer()));
m_MovingLandmarks->SetGeometry(m_RedoPointsGeometryList.back());
m_RedoPointsGeometryList.pop_back();
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingPointSetNode->SetMapper(1, NULL);
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
- mitk::AffineGeometryFrame3D::Pointer movingGeometry = movingData->GetGeometry(0)->Clone();
+ mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0)->Clone();
m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingGeometry.GetPointer()));
movingData->SetGeometry(m_RedoGeometryList.back());
m_RedoGeometryList.pop_back();
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingNode->SetMapper(1, NULL);
mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
movingData->GetTimeSlicedGeometry()->UpdateInformation();
m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
m_Controls.m_UndoTransformation->setEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->checkLandmarkError();
}
if(!m_RedoPointsGeometryList.empty())
{
m_Controls.m_RedoTransformation->setEnabled(true);
}
else
{
m_Controls.m_RedoTransformation->setEnabled(false);
}
}
void QmitkPointBasedRegistrationView::showRedGreen(bool redGreen)
{
m_ShowRedGreen = redGreen;
this->setImageColor(m_ShowRedGreen);
}
void QmitkPointBasedRegistrationView::setImageColor(bool redGreen)
{
if (!redGreen && m_FixedNode.IsNotNull())
{
m_FixedNode->SetColor(m_FixedColor);
}
if (!redGreen && m_MovingNode.IsNotNull())
{
m_MovingNode->SetColor(m_MovingColor);
}
if (redGreen && m_FixedNode.IsNotNull())
{
m_FixedNode->SetColor(1.0f, 0.0f, 0.0f);
}
if (redGreen && m_MovingNode.IsNotNull())
{
m_MovingNode->SetColor(0.0f, 1.0f, 0.0f);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkPointBasedRegistrationView::OpacityUpdate(float opacity)
{
if (opacity > 1)
{
opacity = opacity/100.0f;
}
m_Opacity = opacity;
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_Opacity);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkPointBasedRegistrationView::OpacityUpdate(int opacity)
{
float fValue = ((float)opacity)/100.0f;
this->OpacityUpdate(fValue);
}
void QmitkPointBasedRegistrationView::clearTransformationLists()
{
m_Controls.m_UndoTransformation->setEnabled(false);
m_Controls.m_RedoTransformation->setEnabled(false);
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
m_UndoGeometryList.clear();
m_UndoPointsGeometryList.clear();
m_RedoGeometryList.clear();
m_RedoPointsGeometryList.clear();
}
void QmitkPointBasedRegistrationView::checkLandmarkError()
{
double totalDist = 0, dist = 0, dist2 = 0;
mitk::Point3D point1, point2, point3;
double p1[3], p2[3];
if(m_Transformation < 3)
{
if (m_Controls.m_UseICP->isChecked())
{
if (m_MovingLandmarks.IsNotNull() && m_FixedLandmarks.IsNotNull()&& m_MovingLandmarks->GetSize() != 0 && m_FixedLandmarks->GetSize() != 0)
{
for(int pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
{
point1 = m_MovingLandmarks->GetPoint(pointId);
point2 = m_FixedLandmarks->GetPoint(0);
p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = point1[2];
p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = point2[2];
dist = vtkMath::Distance2BetweenPoints(p1, p2);
for(int pointId2 = 1; pointId2 < m_FixedLandmarks->GetSize(); ++pointId2)
{
point2 = m_FixedLandmarks->GetPoint(pointId2);
p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = p1[2];
p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = p2[2];
dist2 = vtkMath::Distance2BetweenPoints(p1, p2);
if (dist2 < dist)
{
dist = dist2;
}
}
totalDist += dist;
}
m_Controls.m_MeanErrorLCD->display(sqrt(totalDist/m_FixedLandmarks->GetSize()));
m_Controls.m_MeanErrorLCD->show();
m_Controls.m_MeanError->show();
}
else
{
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
}
}
else
{
if (m_MovingLandmarks.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() != 0 && m_FixedLandmarks->GetSize() != 0 && m_MovingLandmarks->GetSize() == m_FixedLandmarks->GetSize())
{
for(int pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
{
point1 = m_MovingLandmarks->GetPoint(pointId);
point2 = m_FixedLandmarks->GetPoint(pointId);
p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = point1[2];
p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = point2[2];
totalDist += vtkMath::Distance2BetweenPoints(p1, p2);
}
m_Controls.m_MeanErrorLCD->display(sqrt(totalDist/m_FixedLandmarks->GetSize()));
m_Controls.m_MeanErrorLCD->show();
m_Controls.m_MeanError->show();
}
else
{
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
}
}
}
else
{
if (m_MovingLandmarks.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() != 0 && m_FixedLandmarks->GetSize() != 0 && m_MovingLandmarks->GetSize() == m_FixedLandmarks->GetSize())
{
for(int pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
{
point1 = m_MovingLandmarks->GetPoint(pointId);
point2 = m_FixedLandmarks->GetPoint(pointId);
p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = point1[2];
p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = point2[2];
totalDist += vtkMath::Distance2BetweenPoints(p1, p2);
}
m_Controls.m_MeanErrorLCD->display(sqrt(totalDist/m_FixedLandmarks->GetSize()));
m_Controls.m_MeanErrorLCD->show();
m_Controls.m_MeanError->show();
}
else
{
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
}
}
}
void QmitkPointBasedRegistrationView::transformationChanged(int transform)
{
m_Transformation = transform;
this->checkCalculateEnabled();
this->checkLandmarkError();
}
// ICP with vtkLandmarkTransformation
void QmitkPointBasedRegistrationView::calculateLandmarkbasedWithICP()
{
if(CheckCalculate())
{
mitk::Geometry3D::Pointer pointsGeometry = m_MovingLandmarks->GetGeometry(0);
- mitk::AffineGeometryFrame3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
+ mitk::Geometry3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
m_UndoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.GetPointer()));
mitk::BaseData::Pointer originalData = m_MovingNode->GetData();
- mitk::AffineGeometryFrame3D::Pointer originalDataGeometry = originalData->GetGeometry(0)->Clone();
+ mitk::Geometry3D::Pointer originalDataGeometry = originalData->GetGeometry(0)->Clone();
m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(originalDataGeometry.GetPointer()));
vtkIdType pointId;
vtkPoints* vPointsSource=vtkPoints::New();
vtkCellArray* vCellsSource=vtkCellArray::New();
for(pointId=0; pointId<m_MovingLandmarks->GetSize();++pointId)
{
mitk::Point3D pointSource=m_MovingLandmarks->GetPoint(pointId);
vPointsSource->InsertNextPoint(pointSource[0],pointSource[1],pointSource[2]);
vCellsSource->InsertNextCell(1, &pointId);
}
vtkPoints* vPointsTarget=vtkPoints::New();
vtkCellArray* vCellsTarget = vtkCellArray::New();
for(pointId=0; pointId<m_FixedLandmarks->GetSize();++pointId)
{
mitk::Point3D pointTarget=m_FixedLandmarks->GetPoint(pointId);
vPointsTarget->InsertNextPoint(pointTarget[0],pointTarget[1],pointTarget[2]);
vCellsTarget->InsertNextCell(1, &pointId);
}
vtkPolyData* vPointSetSource=vtkPolyData::New();
vtkPolyData* vPointSetTarget=vtkPolyData::New();
vPointSetTarget->SetPoints(vPointsTarget);
vPointSetTarget->SetVerts(vCellsTarget);
vPointSetSource->SetPoints(vPointsSource);
vPointSetSource->SetVerts(vCellsSource);
vtkIterativeClosestPointTransform * icp=vtkIterativeClosestPointTransform::New();
icp->SetCheckMeanDistance(1);
icp->SetSource(vPointSetSource);
icp->SetTarget(vPointSetTarget);
icp->SetMaximumNumberOfIterations(50);
icp->StartByMatchingCentroidsOn();
vtkLandmarkTransform * transform=icp->GetLandmarkTransform();
if(m_Transformation==0)
{
transform->SetModeToRigidBody();
}
if(m_Transformation==1)
{
transform->SetModeToSimilarity();
}
if(m_Transformation==2)
{
transform->SetModeToAffine();
}
vtkMatrix4x4 * matrix=icp->GetMatrix();
double determinant = fabs(matrix->Determinant());
if((determinant < mitk::eps) || (determinant > 100) || (determinant < 0.01)
|| (determinant==itk::NumericTraits<double>::infinity())
|| (determinant==itk::NumericTraits<double>::quiet_NaN())
|| (determinant==itk::NumericTraits<double>::signaling_NaN())
|| (determinant==-itk::NumericTraits<double>::infinity())
|| (determinant==-itk::NumericTraits<double>::quiet_NaN())
|| (determinant==-itk::NumericTraits<double>::signaling_NaN())
|| (!(determinant <= 0) && !(determinant > 0)))
{
QMessageBox msgBox;
msgBox.setText("Suspicious determinant of matrix calculated by ICP.\n"
"Please select more points or other points!" );
msgBox.exec();
return;
}
pointsGeometry->Compose(matrix);
m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0);
movingGeometry->Compose(matrix);
movingData->GetTimeSlicedGeometry()->UpdateInformation();
m_Controls.m_UndoTransformation->setEnabled(true);
m_Controls.m_RedoTransformation->setEnabled(false);
m_RedoGeometryList.clear();
m_RedoPointsGeometryList.clear();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->checkLandmarkError();
}
}
// only vtkLandmarkTransformation
void QmitkPointBasedRegistrationView::calculateLandmarkbased()
{
if(CheckCalculate())
{
mitk::Geometry3D::Pointer pointsGeometry = m_MovingLandmarks->GetGeometry(0);
- mitk::AffineGeometryFrame3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
- m_UndoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.GetPointer()));
+ mitk::Geometry3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
+ m_UndoPointsGeometryList.push_back(movingLandmarksGeometry.GetPointer());
mitk::BaseData::Pointer originalData = m_MovingNode->GetData();
- mitk::AffineGeometryFrame3D::Pointer originalDataGeometry = originalData->GetGeometry(0)->Clone();
- m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(originalDataGeometry.GetPointer()));
+ mitk::Geometry3D::Pointer originalDataGeometry = originalData->GetGeometry(0)->Clone();
+ m_UndoGeometryList.push_back(originalDataGeometry.GetPointer());
vtkIdType pointId;
vtkPoints* vPointsSource=vtkPoints::New();
for(pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
{
mitk::Point3D sourcePoint = m_MovingLandmarks->GetPoint(pointId);
vPointsSource->InsertNextPoint(sourcePoint[0],sourcePoint[1],sourcePoint[2]);
}
vtkPoints* vPointsTarget=vtkPoints::New();
for(pointId=0; pointId<m_FixedLandmarks->GetSize();++pointId)
{
mitk::Point3D targetPoint=m_FixedLandmarks->GetPoint(pointId);
vPointsTarget->InsertNextPoint(targetPoint[0],targetPoint[1],targetPoint[2]);
}
vtkLandmarkTransform * transform= vtkLandmarkTransform::New();
transform->SetSourceLandmarks(vPointsSource);
transform->SetTargetLandmarks(vPointsTarget);
if(m_Transformation==0)
{
transform->SetModeToRigidBody();
}
if(m_Transformation==1)
{
transform->SetModeToSimilarity();
}
if(m_Transformation==2)
{
transform->SetModeToAffine();
}
vtkMatrix4x4 * matrix=transform->GetMatrix();
double determinant = fabs(matrix->Determinant());
if((determinant < mitk::eps) || (determinant > 100) || (determinant < 0.01)
|| (determinant==itk::NumericTraits<double>::infinity())
|| (determinant==itk::NumericTraits<double>::quiet_NaN())
|| (determinant==itk::NumericTraits<double>::signaling_NaN())
|| (determinant==-itk::NumericTraits<double>::infinity())
|| (determinant==-itk::NumericTraits<double>::quiet_NaN())
|| (determinant==-itk::NumericTraits<double>::signaling_NaN())
|| (!(determinant <= 0) && !(determinant > 0)))
{
QMessageBox msgBox;
msgBox.setText("Suspicious determinant of matrix calculated.\n"
"Please select more points or other points!" );
msgBox.exec();
return;
}
pointsGeometry->Compose(matrix);
m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0);
movingGeometry->Compose(matrix);
movingData->GetTimeSlicedGeometry()->UpdateInformation();
m_Controls.m_UndoTransformation->setEnabled(true);
m_Controls.m_RedoTransformation->setEnabled(false);
m_RedoGeometryList.clear();
m_RedoPointsGeometryList.clear();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->checkLandmarkError();
}
}
void QmitkPointBasedRegistrationView::calculateLandmarkWarping()
{
mitk::LandmarkWarping* registration = new mitk::LandmarkWarping();
mitk::LandmarkWarping::FixedImageType::Pointer fixedImage = mitk::LandmarkWarping::FixedImageType::New();
mitk::Image::Pointer fimage = dynamic_cast<mitk::Image*>(m_FixedNode->GetData());
mitk::LandmarkWarping::MovingImageType::Pointer movingImage = mitk::LandmarkWarping::MovingImageType::New();
mitk::Image::Pointer mimage = dynamic_cast<mitk::Image*>(m_MovingNode->GetData());
if (fimage.IsNotNull() && /*fimage->GetDimension() == 2 || */ fimage->GetDimension() == 3 && mimage.IsNotNull() && mimage->GetDimension() == 3)
{
mitk::CastToItkImage(fimage, fixedImage);
mitk::CastToItkImage(mimage, movingImage);
registration->SetFixedImage(fixedImage);
registration->SetMovingImage(movingImage);
unsigned int pointId;
mitk::Point3D sourcePoint, targetPoint;
mitk::LandmarkWarping::LandmarkContainerType::Pointer fixedLandmarks = mitk::LandmarkWarping::LandmarkContainerType::New();
mitk::LandmarkWarping::LandmarkPointType point;
for(pointId = 0; pointId < (unsigned int)m_FixedLandmarks->GetSize(); ++pointId)
{
fimage->GetGeometry(0)->WorldToItkPhysicalPoint(m_FixedLandmarks->GetPoint(pointId), point);
fixedLandmarks->InsertElement( pointId, point);
}
mitk::LandmarkWarping::LandmarkContainerType::Pointer movingLandmarks = mitk::LandmarkWarping::LandmarkContainerType::New();
for(pointId = 0; pointId < (unsigned int)m_MovingLandmarks->GetSize(); ++pointId)
{
mitk::BaseData::Pointer fixedData = m_FixedNode->GetData();
mitk::Geometry3D::Pointer fixedGeometry = fixedData->GetGeometry(0);
fixedGeometry->WorldToItkPhysicalPoint(m_MovingLandmarks->GetPoint(pointId), point);
movingLandmarks->InsertElement( pointId, point);
}
registration->SetLandmarks(fixedLandmarks.GetPointer(), movingLandmarks.GetPointer());
mitk::LandmarkWarping::MovingImageType::Pointer output = registration->Register();
if (output.IsNotNull())
{
mitk::Image::Pointer image = mitk::Image::New();
mitk::CastToMitkImage(output, image);
m_MovingNode->SetData(image);
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelWindow;
levelWindow.SetAuto( image );
levWinProp->SetLevelWindow(levelWindow);
m_MovingNode->GetPropertyList()->SetProperty("levelwindow",levWinProp);
movingLandmarks = registration->GetTransformedTargetLandmarks();
mitk::PointSet::PointDataIterator it;
it = m_MovingLandmarks->GetPointSet()->GetPointData()->Begin();
//increase the eventId to encapsulate the coming operations
mitk::OperationEvent::IncCurrObjectEventId();
mitk::OperationEvent::ExecuteIncrement();
for(pointId=0; pointId<movingLandmarks->Size();++pointId, ++it)
{
int position = it->Index();
mitk::PointSet::PointType pt = m_MovingLandmarks->GetPoint(position);
mitk::Point3D undoPoint = ( pt );
point = movingLandmarks->GetElement(pointId);
fimage->GetGeometry(0)->ItkPhysicalPointToWorld(point, pt);
mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVE, pt, position);
//undo operation
mitk::PointOperation* undoOp = new mitk::PointOperation(mitk::OpMOVE, undoPoint, position);
mitk::OperationEvent* operationEvent = new mitk::OperationEvent(m_MovingLandmarks, doOp, undoOp, "Move point");
mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent(operationEvent);
//execute the Operation
m_MovingLandmarks->ExecuteOperation(doOp);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->clearTransformationLists();
this->checkLandmarkError();
}
}
}
bool QmitkPointBasedRegistrationView::checkCalculateEnabled()
{
if (m_FixedLandmarks.IsNotNull() && m_MovingLandmarks.IsNotNull())
{
int fixedPoints = m_FixedLandmarks->GetSize();
int movingPoints = m_MovingLandmarks->GetSize();
if (m_Transformation == 0 || m_Transformation == 1 || m_Transformation == 2)
{
if (m_Controls.m_UseICP->isChecked())
{
if((movingPoints > 0 && fixedPoints > 0))
{
m_Controls.m_Calculate->setEnabled(true);
return true;
}
else
{
m_Controls.m_Calculate->setEnabled(false);
return false;
}
}
else
{
if ((movingPoints == fixedPoints) && movingPoints > 0)
{
m_Controls.m_Calculate->setEnabled(true);
return true;
}
else
{
m_Controls.m_Calculate->setEnabled(false);
return false;
}
}
}
else
{
m_Controls.m_Calculate->setEnabled(true);
return true;
}
}
else
{
return false;
}
}
void QmitkPointBasedRegistrationView::calculate()
{
if (m_Transformation == 0 || m_Transformation == 1 || m_Transformation == 2)
{
if (m_Controls.m_UseICP->isChecked())
{
if (m_MovingLandmarks->GetSize() == 1 && m_FixedLandmarks->GetSize() == 1)
{
this->calculateLandmarkbased();
}
else
{
this->calculateLandmarkbasedWithICP();
}
}
else
{
this->calculateLandmarkbased();
}
}
else
{
this->calculateLandmarkWarping();
}
}
void QmitkPointBasedRegistrationView::SetImagesVisible(berry::ISelection::ConstPointer /*selection*/)
{
if (this->m_CurrentSelection->Size() == 0)
{
// show all images
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
{
nodeIt->Value()->SetVisibility(true);
}
}
}
else
{
// hide all images
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
{
nodeIt->Value()->SetVisibility(false);
}
}
}
}
void QmitkPointBasedRegistrationView::SwitchImages()
{
mitk::DataNode::Pointer newMoving = m_FixedNode;
mitk::DataNode::Pointer newFixed = m_MovingNode;
this->FixedSelected(newFixed);
this->MovingSelected(newMoving);
}
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.cpp
index 703d4a7220..ff41ff7742 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationSelectorView.cpp
@@ -1,774 +1,773 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkImageTimeSelector.h"
#include <QValidator>
#include <vtkTransform.h>
#include <vtkMatrix4x4.h>
#include "mitkMatrixConvert.h"
#include <qinputdialog.h>
#include <qmessagebox.h>
#include "QmitkLoadPresetDialog.h"
#include <itkArray.h>
#include "mitkRigidRegistrationPreset.h"
#include "mitkProgressBar.h"
#include "QmitkRigidRegistrationSelectorView.h"
#include "QmitkTranslationTransformView.h"
#include "QmitkScaleTransformView.h"
#include "QmitkScaleLogarithmicTransformView.h"
#include "QmitkAffineTransformView.h"
#include "QmitkFixedCenterOfRotationAffineTransformView.h"
-#include "QmitkRigid3DTransformView.h"
#include "QmitkEuler3DTransformView.h"
#include "QmitkCenteredEuler3DTransformView.h"
#include "QmitkQuaternionRigidTransformView.h"
#include "QmitkVersorTransformView.h"
#include "QmitkVersorRigid3DTransformView.h"
#include "QmitkScaleSkewVersor3DTransformView.h"
#include "QmitkSimilarity3DTransformView.h"
#include "QmitkRigid2DTransformView.h"
#include "QmitkCenteredRigid2DTransformView.h"
#include "QmitkEuler2DTransformView.h"
#include "QmitkSimilarity2DTransformView.h"
#include "QmitkCenteredSimilarity2DTransformView.h"
#include "QmitkMeanSquaresMetricView.h"
#include "QmitkNormalizedCorrelationMetricView.h"
#include "QmitkGradientDifferenceMetricView.h"
#include "QmitkKullbackLeiblerCompareHistogramMetricView.h"
#include "QmitkCorrelationCoefficientHistogramMetricView.h"
#include "QmitkMeanSquaresHistogramMetricView.h"
#include "QmitkMutualInformationHistogramMetricView.h"
#include "QmitkNormalizedMutualInformationHistogramMetricView.h"
#include "QmitkMattesMutualInformationMetricView.h"
#include "QmitkMeanReciprocalSquareDifferenceMetricView.h"
#include "QmitkMutualInformationMetricView.h"
#include "QmitkMatchCardinalityMetricView.h"
#include "QmitkKappaStatisticMetricView.h"
#include "QmitkExhaustiveOptimizerView.h"
#include "QmitkGradientDescentOptimizerView.h"
#include "QmitkQuaternionRigidTransformGradientDescentOptimizerView.h"
#include "QmitkLBFGSBOptimizerView.h"
#include "QmitkOnePlusOneEvolutionaryOptimizerView.h"
#include "QmitkPowellOptimizerView.h"
#include "QmitkFRPROptimizerView.h"
#include "QmitkRegularStepGradientDescentOptimizerView.h"
#include "QmitkVersorTransformOptimizerView.h"
#include "QmitkAmoebaOptimizerView.h"
#include "QmitkConjugateGradientOptimizerView.h"
#include "QmitkLBFGSOptimizerView.h"
#include "QmitkSPSAOptimizerView.h"
#include "QmitkVersorRigid3DTransformOptimizerView.h"
QmitkRigidRegistrationSelectorView::QmitkRigidRegistrationSelectorView(QWidget* parent, Qt::WindowFlags f ) : QWidget( parent, f ),
m_FixedNode(NULL), m_FixedMaskNode(NULL), m_MovingNode(NULL), m_MovingMaskNode(NULL), m_FixedDimension(0), m_MovingDimension(0),
m_StopOptimization(false), m_GeometryItkPhysicalToWorldTransform(NULL), m_GeometryWorldToItkPhysicalTransform(NULL),
m_MovingGeometry(NULL), m_ImageGeometry(NULL)
{
m_Controls.setupUi(parent);
this->AddTransform(new QmitkTranslationTransformView(this, f));
this->AddTransform(new QmitkScaleTransformView(this, f));
this->AddTransform(new QmitkScaleLogarithmicTransformView(this, f));
this->AddTransform(new QmitkAffineTransformView(this, f));
this->AddTransform(new QmitkFixedCenterOfRotationAffineTransformView(this, f));
this->AddTransform(new QmitkEuler3DTransformView(this, f));
this->AddTransform(new QmitkCenteredEuler3DTransformView(this, f));
this->AddTransform(new QmitkQuaternionRigidTransformView(this, f));
this->AddTransform(new QmitkVersorTransformView(this, f));
this->AddTransform(new QmitkVersorRigid3DTransformView(this, f));
this->AddTransform(new QmitkScaleSkewVersor3DTransformView(this, f));
this->AddTransform(new QmitkSimilarity3DTransformView(this, f));
this->AddTransform(new QmitkRigid2DTransformView(this, f));
this->AddTransform(new QmitkCenteredRigid2DTransformView(this, f));
this->AddTransform(new QmitkEuler2DTransformView(this, f));
this->AddTransform(new QmitkSimilarity2DTransformView(this, f));
this->AddTransform(new QmitkCenteredSimilarity2DTransformView(this, f));
this->AddMetric(new QmitkMeanSquaresMetricView(this, f));
this->AddMetric(new QmitkNormalizedCorrelationMetricView(this, f));
this->AddMetric(new QmitkGradientDifferenceMetricView(this, f));
this->AddMetric(new QmitkKullbackLeiblerCompareHistogramMetricView(this, f));
this->AddMetric(new QmitkCorrelationCoefficientHistogramMetricView(this, f));
this->AddMetric(new QmitkMeanSquaresHistogramMetricView(this, f));
this->AddMetric(new QmitkMutualInformationHistogramMetricView(this, f));
this->AddMetric(new QmitkNormalizedMutualInformationHistogramMetricView(this, f));
this->AddMetric(new QmitkMattesMutualInformationMetricView(this, f));
this->AddMetric(new QmitkMeanReciprocalSquareDifferenceMetricView(this, f));
this->AddMetric(new QmitkMutualInformationMetricView(this, f));
this->AddMetric(new QmitkMatchCardinalityMetricView(this, f));
this->AddMetric(new QmitkKappaStatisticMetricView(this, f));
this->AddOptimizer(new QmitkExhaustiveOptimizerView(this, f));
this->AddOptimizer(new QmitkGradientDescentOptimizerView(this, f));
this->AddOptimizer(new QmitkQuaternionRigidTransformGradientDescentOptimizerView(this, f));
this->AddOptimizer(new QmitkLBFGSBOptimizerView(this, f));
this->AddOptimizer(new QmitkOnePlusOneEvolutionaryOptimizerView(this, f));
this->AddOptimizer(new QmitkPowellOptimizerView(this, f));
this->AddOptimizer(new QmitkFRPROptimizerView(this, f));
this->AddOptimizer(new QmitkRegularStepGradientDescentOptimizerView(this, f));
this->AddOptimizer(new QmitkVersorTransformOptimizerView(this, f));
this->AddOptimizer(new QmitkAmoebaOptimizerView(this, f));
this->AddOptimizer(new QmitkConjugateGradientOptimizerView(this, f));
this->AddOptimizer(new QmitkLBFGSOptimizerView(this, f));
this->AddOptimizer(new QmitkSPSAOptimizerView(this, f));
this->AddOptimizer(new QmitkVersorRigid3DTransformOptimizerView(this, f));
m_Observer = mitk::RigidRegistrationObserver::New();
m_Controls.m_TransformFrame->setEnabled(true);
m_Controls.m_MetricFrame->setEnabled(true);
m_Controls.m_OptimizerFrame->setEnabled(true);
m_Controls.m_InterpolatorFrame->setEnabled(true);
m_Controls.m_TransformFrame->hide();
m_Controls.m_MetricFrame->hide();
m_Controls.m_OptimizerFrame->hide();
m_Controls.m_InterpolatorFrame->hide();
m_Controls.m_TransformBox->setCurrentIndex(0);
m_Controls.m_MetricBox->setCurrentIndex(0);
m_Controls.m_OptimizerBox->setCurrentIndex(0);
m_Controls.m_TransformWidgetStack->setCurrentIndex(0);
m_Controls.m_MetricWidgetStack->setCurrentIndex(0);
m_Controls.m_OptimizerWidgetStack->setCurrentIndex(0);
/// and show the selected views
this->TransformSelected(m_Controls.m_TransformBox->currentIndex());
this->MetricSelected(m_Controls.m_MetricBox->currentIndex());
this->OptimizerSelected(m_Controls.m_OptimizerBox->currentIndex());
//// create connections
connect( m_Controls.m_TransformGroup, SIGNAL(clicked(bool)), m_Controls.m_TransformFrame, SLOT(setVisible(bool)));
connect( m_Controls.m_TransformBox, SIGNAL(activated(int)), m_Controls.m_TransformWidgetStack, SLOT(setCurrentIndex(int)));
connect( m_Controls.m_TransformBox, SIGNAL(activated(int)), this, SLOT(TransformSelected(int)));
connect( m_Controls.m_MetricBox, SIGNAL(activated(int)), this, SLOT(MetricSelected(int)));
connect( m_Controls.m_OptimizerBox, SIGNAL(activated(int)), this, SLOT(OptimizerSelected(int)));
connect( m_Controls.m_MetricGroup, SIGNAL(clicked(bool)), m_Controls.m_MetricFrame, SLOT(setVisible(bool)));
connect( m_Controls.m_MetricBox, SIGNAL(activated(int)), m_Controls.m_MetricWidgetStack, SLOT(setCurrentIndex(int)));
connect( m_Controls.m_OptimizerGroup, SIGNAL(clicked(bool)), m_Controls.m_OptimizerFrame, SLOT(setVisible(bool)));
connect( m_Controls.m_OptimizerBox, SIGNAL(activated(int)), m_Controls.m_OptimizerWidgetStack, SLOT(setCurrentIndex(int)));
connect( m_Controls.m_InterpolatorGroup, SIGNAL(toggled(bool)), m_Controls.m_InterpolatorFrame, SLOT(setVisible(bool)));
m_Preset = new mitk::RigidRegistrationPreset();
m_Preset->LoadPreset();
this->DoLoadRigidRegistrationPreset("AffineMutualInformationGradientDescent");
}
QmitkRigidRegistrationSelectorView::~QmitkRigidRegistrationSelectorView()
{
}
/// this method starts the registration process
void QmitkRigidRegistrationSelectorView::CalculateTransformation(unsigned int timestep)
{
if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
{
emit AddNewTransformationToUndoList();
mitk::Image::Pointer fimage = dynamic_cast<mitk::Image*>(m_FixedNode->GetData());
mitk::Image::Pointer mimage = dynamic_cast<mitk::Image*>(m_MovingNode->GetData());
mitk::Image::Pointer mmimage = NULL;
mitk::Image::Pointer fmimage = NULL;
if (m_MovingMaskNode.IsNotNull())
{
mmimage = dynamic_cast<mitk::Image*>(m_MovingMaskNode->GetData());
}
if (m_FixedMaskNode.IsNotNull())
{
fmimage = dynamic_cast<mitk::Image*>(m_FixedMaskNode->GetData());
}
mitk::ImageTimeSelector::Pointer its = mitk::ImageTimeSelector::New();
if(fimage->GetDimension()>3)
{
its->SetInput(fimage);
its->SetTimeNr(timestep);
its->Update();
fimage = its->GetOutput();
}
if(mimage->GetDimension()>3)
{
its->SetInput(mimage);
its->SetTimeNr(timestep);
its->Update();
mimage = its->GetOutput();
}
// Initial moving image geometry
m_ImageGeometry = m_MovingNode->GetData()->GetGeometry()->Clone();
std::cout << "Moving Image Geometry (IndexToWorldTransform)" << std::endl;
std::cout << m_ImageGeometry->GetIndexToWorldTransform()->GetMatrix();
mitk::Geometry3D::TransformType::InputPointType center = m_ImageGeometry->GetIndexToWorldTransform()->GetCenter();
std::cout << "center " << center[0] << " " << center[1] << " " << center[2] << std::endl;
mitk::Geometry3D::TransformType::OutputVectorType offset = m_ImageGeometry->GetIndexToWorldTransform()->GetOffset();
std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2] << std::endl;
std::cout << std::endl;
// Fixed image geometry
// mitk::AffineGeometryFrame3D::Pointer m_FixedGeometryCopy = m_FixedNode->GetData()->GetGeometry()->Clone();
// std::cout << "Fixed Image Geometry (IndexToWorldTransform)" << std::endl;
// std::cout << m_FixedGeometryCopy->GetIndexToWorldTransform()->GetMatrix();
// center = m_FixedGeometryCopy->GetIndexToWorldTransform()->GetCenter();
// std::cout << "center " << center[0] << " " << center[1] << " " << center[2] << std::endl;
// offset = m_FixedGeometryCopy->GetIndexToWorldTransform()->GetOffset();
// std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2] << std::endl;
// std::cout << std::endl;
// Calculate the World to ITK-Physical transform for the moving image
m_MovingGeometry = m_MovingNode->GetData()->GetGeometry();
unsigned long size;
size = m_MovingNodeChildren->Size();
mitk::DataNode::Pointer childNode;
for (unsigned long i = 0; i < size; ++i)
{
m_ChildNodes.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(m_MovingNodeChildren->GetElement(i), m_MovingNodeChildren->GetElement(i)->GetData()->GetGeometry()));
- m_ChildNodes2.insert(std::pair<mitk::DataNode::Pointer, mitk::AffineGeometryFrame3D::Pointer>(m_MovingNodeChildren->GetElement(i), m_MovingNodeChildren->GetElement(i)->GetData()->GetGeometry()->Clone()));
+ m_ChildNodes2.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D::Pointer>(m_MovingNodeChildren->GetElement(i), m_MovingNodeChildren->GetElement(i)->GetData()->GetGeometry()->Clone()));
}
m_GeometryWorldToItkPhysicalTransform = mitk::Geometry3D::TransformType::New();
GetWorldToItkPhysicalTransform(m_MovingGeometry, m_GeometryWorldToItkPhysicalTransform.GetPointer());
// std::cout << "Moving Image: World to ITK-physical transform" << std::endl;
// std::cout << m_GeometryWorldToItkPhysicalTransform->GetMatrix();
// center = m_GeometryWorldToItkPhysicalTransform->GetCenter();
// std::cout << "center " << center[0] << " " << center[1] << " " << center[2] << std::endl;
// offset = m_GeometryWorldToItkPhysicalTransform->GetOffset();
// std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2] << std::endl;
// std::cout << std::endl;
// Calculate the ITK-Physical to World transform for the fixed image
m_GeometryItkPhysicalToWorldTransform = mitk::Geometry3D::TransformType::New();
mitk::Geometry3D::TransformType::Pointer fixedWorld2Phys = mitk::Geometry3D::TransformType::New();
GetWorldToItkPhysicalTransform(m_FixedNode->GetData()->GetGeometry(), fixedWorld2Phys.GetPointer());
fixedWorld2Phys->GetInverse(m_GeometryItkPhysicalToWorldTransform);
// std::cout << "Fixed Image: ITK-physical to World transform" << std::endl;
// std::cout << m_GeometryItkPhysicalToWorldTransform->GetMatrix();
// center = m_GeometryItkPhysicalToWorldTransform->GetCenter();
// std::cout << "center " << center[0] << " " << center[1] << " " << center[2] << std::endl;
// offset = m_GeometryItkPhysicalToWorldTransform->GetOffset();
// std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2] << std::endl;
// std::cout << std::endl;
// init callback
itk::ReceptorMemberCommand<QmitkRigidRegistrationSelectorView>::Pointer command = itk::ReceptorMemberCommand<QmitkRigidRegistrationSelectorView>::New();
command->SetCallbackFunction(this, &QmitkRigidRegistrationSelectorView::SetOptimizerValue);
int observer = m_Observer->AddObserver( itk::AnyEvent(), command );
std::vector<std::string> presets;
// init registration method
mitk::ImageRegistrationMethod::Pointer registration = mitk::ImageRegistrationMethod::New();
registration->SetObserver(m_Observer);
registration->SetInterpolator(m_Controls.m_InterpolatorBox->currentIndex());
registration->SetReferenceImage(fimage);
registration->SetInput(mimage);
if (mmimage.IsNotNull())
{
registration->SetMovingMask(mmimage);
}
if (fmimage.IsNotNull())
{
registration->SetFixedMask(fmimage);
}
dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->SetFixedImage(dynamic_cast<mitk::Image*>(m_FixedNode->GetData()));
dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->SetMovingImage(dynamic_cast<mitk::Image*>(m_MovingNode->GetData()));
registration->SetOptimizerScales(dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->GetScales());
registration->SetTransform(dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->GetTransform());
dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->currentWidget())->SetMovingImage(dynamic_cast<mitk::Image*>(m_MovingNode->GetData()));
registration->SetMetric(dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->currentWidget())->GetMetric());
registration->SetOptimizer(dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->currentWidget())->GetOptimizer());
double time(0.0);
double tstart(0.0);
tstart = clock();
try
{
registration->Update();
}
catch (itk::ExceptionObject e)
{
MITK_INFO << "Caught exception: "<<e.GetDescription();
QMessageBox::information( this, "Registration exception", e.GetDescription());
mitk::ProgressBar::GetInstance()->Progress(20);
}
time += clock() - tstart;
time = time / CLOCKS_PER_SEC;
//printOut of the Time
MITK_INFO << "Registration Time: " << time;
m_Observer->RemoveObserver(observer);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkRigidRegistrationSelectorView::SetFixedNode( mitk::DataNode * fixedNode )
{
m_FixedNode = fixedNode;
m_Controls.m_TransformBox->setCurrentIndex(m_Controls.m_TransformBox->currentIndex());
}
void QmitkRigidRegistrationSelectorView::SetFixedDimension( int dimension )
{
m_FixedDimension = dimension;
}
void QmitkRigidRegistrationSelectorView::SetMovingNode( mitk::DataNode * movingNode )
{
m_MovingNode = movingNode;
this->TransformSelected(m_Controls.m_TransformBox->currentIndex());
}
void QmitkRigidRegistrationSelectorView::SetMovingDimension(int dimension )
{
m_MovingDimension = dimension;
}
// this is a callback function that retrieves the current transformation
// parameters after every step of progress in the optimizer.
// depending on the choosen transformation, we construct a vtktransform
// that will be applied to the geometry of the moving image.
// the values are delivered by mitkRigidRgistrationObserver.cpp
void QmitkRigidRegistrationSelectorView::SetOptimizerValue( const itk::EventObject & )
{
if (m_StopOptimization)
{
m_Observer->SetStopOptimization(true);
m_StopOptimization = false;
}
// retreive optimizer value for the current transformation
double value = m_Observer->GetCurrentOptimizerValue();
// retreive current parameterset of the transformation
itk::Array<double> transformParams = m_Observer->GetCurrentTranslation();
// init an empty affine transformation that will be filled with
// the corresponding transformation parameters in the following
vtkMatrix4x4* vtkmatrix = vtkMatrix4x4::New();
vtkmatrix->Identity();
// init a transform that will be initialized with the vtkmatrix later
vtkTransform* vtktransform = vtkTransform::New();
if (m_MovingNode.IsNotNull())
{
vtktransform = dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->Transform(vtkmatrix, vtktransform, transformParams);
// the retrieved transform goes from fixed to moving space.
// invert the transform in order to go from moving to fixed space.
vtkMatrix4x4* vtkmatrix_inv = vtkMatrix4x4::New();
vtktransform->GetInverse(vtkmatrix_inv);
// now adapt the moving geometry accordingly
m_MovingGeometry->GetIndexToWorldTransform()->SetIdentity();
// the next view lines: Phi(Phys2World)*Phi(Result)*Phi(World2Phy)*Phi(Initial)
// set moving image geometry to registration result
m_MovingGeometry->SetIndexToWorldTransformByVtkMatrix(vtkmatrix_inv);
/*std::cout << std::endl;
std::cout << m_MovingGeometry->GetIndexToWorldTransform()->GetMatrix();
mitk::Geometry3D::TransformType::OutputVectorType offset = m_MovingGeometry->GetIndexToWorldTransform()->GetOffset();
std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2] << std::endl;*/
#if !defined(ITK_IMAGE_BEHAVES_AS_ORIENTED_IMAGE)
// the next few lines: Phi(Phys2World)*Phi(Result)*Phi(World2Phy)*Phi(Initial)
// go to itk physical space before applying the registration result
m_MovingGeometry->Compose(m_GeometryWorldToItkPhysicalTransform, 1);
// right in the beginning, transform by initial moving image geometry
m_MovingGeometry->Compose(m_ImageGeometry->GetIndexToWorldTransform(), 1);
// in the end, go back to world space
m_MovingGeometry->Compose(m_GeometryItkPhysicalToWorldTransform, 0);
#else
m_MovingGeometry->Compose(m_ImageGeometry->GetIndexToWorldTransform(), 1);
#endif
/*std::cout << std::endl << m_MovingGeometry->GetIndexToWorldTransform()->GetMatrix();
offset = m_MovingGeometry->GetIndexToWorldTransform()->GetOffset();
std::cout << "offset " << offset[0] << " " << offset[1] << " " << offset[2] << std::endl << std::endl;*/
// now adapt all children geometries accordingly if children exist
std::map<mitk::DataNode::Pointer, mitk::Geometry3D*>::iterator iter;
std::map<mitk::DataNode::Pointer, mitk::AffineGeometryFrame3D::Pointer>::iterator iter2;
mitk::DataNode::Pointer childNode;
for( iter = m_ChildNodes.begin(); iter != m_ChildNodes.end(); iter++ )
{
childNode = (*iter).first;
if (childNode.IsNotNull())
{
mitk::Geometry3D* childGeometry;
mitk::AffineGeometryFrame3D::Pointer childImageGeometry;
// Calculate the World to ITK-Physical transform for the moving mask
childGeometry = (*iter).second;
iter2 = m_ChildNodes2.find(childNode);
childImageGeometry = (*iter2).second;
childGeometry->GetIndexToWorldTransform()->SetIdentity();
// the next view lines: Phi(Phys2World)*Phi(Result)*Phi(World2Phy)*Phi(Initial)
// set moving mask geometry to registration result
childGeometry->SetIndexToWorldTransformByVtkMatrix(vtkmatrix_inv);
#if !defined(ITK_IMAGE_BEHAVES_AS_ORIENTED_IMAGE)
// the next few lines: Phi(Phys2World)*Phi(Result)*Phi(World2Phy)*Phi(Initial)
// go to itk physical space before applying the registration result
childGeometry->Compose(m_GeometryWorldToItkPhysicalTransform, 1);
// right in the beginning, transform by initial moving image geometry
childGeometry->Compose(childImageGeometry->GetIndexToWorldTransform(), 1);
// in the end, go back to world space
childGeometry->Compose(m_GeometryItkPhysicalToWorldTransform, 0);
#else
childGeometry->Compose(childImageGeometry->GetIndexToWorldTransform(), 1);
#endif
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
emit OptimizerChanged(value);
}
/// this method is called whenever the combobox with the selectable transforms changes
/// responsible for showing the selected transform parameters
void QmitkRigidRegistrationSelectorView::TransformSelected( int transform )
{
if (m_FixedNode.IsNotNull())
{
dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(transform))->SetFixedImage(dynamic_cast<mitk::Image*>(m_FixedNode->GetData()));
}
if (m_MovingNode.IsNotNull())
{
dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(transform))->SetMovingImage(dynamic_cast<mitk::Image*>(m_MovingNode->GetData()));
}
int numberOfTransformParameters = dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(transform))->GetNumberOfTransformParameters();
dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->currentWidget())->SetNumberOfTransformParameters(numberOfTransformParameters);
//set fixed height
m_Controls.m_TransformWidgetStack->setFixedHeight( dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(transform))->minimumSizeHint().height() );
this->OptimizerSelected(m_Controls.m_OptimizerWidgetStack->currentIndex());
}
/// this method is called whenever the combobox with the selectable metrics changes
/// responsible for showing the selected metric parameters
void QmitkRigidRegistrationSelectorView::MetricSelected( int metric )
{
if (m_FixedNode.IsNotNull())
{
dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->widget(metric))->SetMovingImage(dynamic_cast<mitk::Image*>(m_MovingNode->GetData()));
}
//set fixed height
m_Controls.m_MetricWidgetStack->setFixedHeight( dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->widget(metric))->minimumSizeHint().height() );
}
/// this method is called whenever the combobox with the selectable optimizers changes
/// responsible for showing the selected optimizer parameters
void QmitkRigidRegistrationSelectorView::OptimizerSelected( int optimizer )
{
int numberOfTransformParameters = dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->GetNumberOfTransformParameters();
dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->widget(optimizer))->SetNumberOfTransformParameters(numberOfTransformParameters);
//set fixed height
m_Controls.m_OptimizerWidgetStack->setFixedHeight( dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->widget(optimizer))->minimumSizeHint().height() );
}
void QmitkRigidRegistrationSelectorView::LoadRigidRegistrationParameter()
{
this->DoLoadRigidRegistrationParameter();
}
void QmitkRigidRegistrationSelectorView::DoLoadRigidRegistrationParameter()
{
std::map<std::string, itk::Array<double> > existingPresets;
existingPresets = m_Preset->getTransformValuesPresets();
std::map<std::string, itk::Array<double> >::iterator iter;
std::list<std::string> presets;
for( iter = existingPresets.begin(); iter != existingPresets.end(); iter++ )
{
presets.push_back( (*iter).first );
}
if (presets.empty())
{
QMessageBox::warning( NULL, "RigidRegistrationParameters.xml", "RigidRegistrationParameters.xml is empty/does not exist. There are no presets to select.");
return;
}
presets.sort();
// ask about the name to load a preset
QmitkLoadPresetDialog dialog( this, 0, "Load Preset", presets ); // needs a QWidget as parent
int dialogReturnValue = dialog.exec();
if ( dialogReturnValue == QDialog::Rejected ) return; // user clicked cancel or pressed Esc or something similar
this->DoLoadRigidRegistrationPreset(dialog.GetPresetName());
}
void QmitkRigidRegistrationSelectorView::DoLoadRigidRegistrationPreset(std::string presetName)
{
itk::Array<double> transformValues;
transformValues = m_Preset->getTransformValues(presetName);
m_Controls.m_TransformGroup->setChecked(true);
m_Controls.m_TransformFrame->setVisible(true);
m_Controls.m_TransformBox->setCurrentIndex((int)transformValues[0]);
m_Controls.m_TransformWidgetStack->setCurrentIndex((int)transformValues[0]);
this->TransformSelected((int)transformValues[0]);
itk::Array<double> transformValuesForGUI;
transformValuesForGUI.SetSize(transformValues.Size());
transformValuesForGUI.fill(0);
for (unsigned int i = 1; i < transformValues.Size(); i++)
{
transformValuesForGUI[i-1] = transformValues[i];
}
dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->SetTransformParameters(transformValuesForGUI);
itk::Array<double> metricValues;
metricValues = m_Preset->getMetricValues(presetName);
m_Controls.m_MetricGroup->setChecked(true);
m_Controls.m_MetricFrame->setVisible(true);
m_Controls.m_MetricBox->setCurrentIndex((int)metricValues[0]);
m_Controls.m_MetricWidgetStack->setCurrentIndex((int)metricValues[0]);
this->MetricSelected((int)metricValues[0]);
itk::Array<double> metricValuesForGUI;
metricValuesForGUI.SetSize(metricValues.Size());
metricValuesForGUI.fill(0);
for (unsigned int i = 1; i < metricValues.Size(); i++)
{
metricValuesForGUI[i-1] = metricValues[i];
}
dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->currentWidget())->SetMetricParameters(metricValuesForGUI);
itk::Array<double> optimizerValues;
optimizerValues = m_Preset->getOptimizerValues(presetName);
m_Controls.m_OptimizerGroup->setChecked(true);
m_Controls.m_OptimizerFrame->setVisible(true);
m_Controls.m_OptimizerBox->setCurrentIndex((int)optimizerValues[0]);
m_Controls.m_OptimizerWidgetStack->setCurrentIndex((int)optimizerValues[0]);
this->OptimizerSelected((int)optimizerValues[0]);
itk::Array<double> optimizerValuesForGUI;
optimizerValuesForGUI.SetSize(optimizerValues.Size());
optimizerValuesForGUI.fill(0);
for (unsigned int i = 1; i < optimizerValues.Size(); i++)
{
optimizerValuesForGUI[i-1] = optimizerValues[i];
}
dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->currentWidget())->SetOptimizerParameters(optimizerValuesForGUI);
itk::Array<double> interpolatorValues;
interpolatorValues = m_Preset->getInterpolatorValues(presetName);
m_Controls.m_InterpolatorGroup->setChecked(true);
m_Controls.m_InterpolatorFrame->setVisible(true);
m_Controls.m_InterpolatorBox->setCurrentIndex((int)interpolatorValues[0]);
}
void QmitkRigidRegistrationSelectorView::SaveRigidRegistrationParameter()
{
this->DoSaveRigidRegistrationParameter();
}
void QmitkRigidRegistrationSelectorView::DoSaveRigidRegistrationParameter()
{
bool ok;
QString text = QInputDialog::getText(this,
"Save Parameter Preset", "Enter name for preset:", QLineEdit::Normal,
QString::null, &ok );
if ( ok )
{
std::map<std::string, itk::Array<double> > existingPresets;
existingPresets = m_Preset->getTransformValuesPresets();
std::map<std::string, itk::Array<double> >::iterator iter = existingPresets.find(std::string((const char*)text.toLatin1()));
if (iter != existingPresets.end())
{
QMessageBox::critical( this, "Preset definition",
"Presetname already exists.");
return;
}
if (text.isEmpty())
{
QMessageBox::critical( this, "Preset definition",
"Presetname has to be set.\n"
"You have to enter a Presetname." );
return;
}
itk::Array<double> transformValues;
transformValues.SetSize(25);
transformValues.fill(0);
transformValues[0] = m_Controls.m_TransformBox->currentIndex();
itk::Array<double> transformValuesFromGUI = dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->currentWidget())->GetTransformParameters();
for (unsigned int i = 0; i < transformValuesFromGUI.Size(); i++)
{
transformValues[i+1] = transformValuesFromGUI[i];
}
std::map<std::string, itk::Array<double> > transformMap;
transformMap = m_Preset->getTransformValuesPresets();
transformMap[std::string((const char*)text.toLatin1())] = transformValues;
itk::Array<double> metricValues;
metricValues.SetSize(25);
metricValues.fill(0);
metricValues[0] = m_Controls.m_MetricBox->currentIndex();
itk::Array<double> metricValuesFromGUI = dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->currentWidget())->GetMetricParameters();
for (unsigned int i = 0; i < metricValuesFromGUI.Size(); i++)
{
metricValues[i+1] = metricValuesFromGUI[i];
}
std::map<std::string, itk::Array<double> > metricMap;
metricMap = m_Preset->getMetricValuesPresets();
metricMap[std::string((const char*)text.toLatin1())] = metricValues;
itk::Array<double> optimizerValues;
optimizerValues.SetSize(25);
optimizerValues.fill(0);
optimizerValues[0] = m_Controls.m_OptimizerBox->currentIndex();
itk::Array<double> optimizerValuesFromGUI = dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->currentWidget())->GetOptimizerParameters();
for (unsigned int i = 0; i < optimizerValuesFromGUI.Size(); i++)
{
optimizerValues[i+1] = optimizerValuesFromGUI[i];
}
std::map<std::string, itk::Array<double> > optimizerMap;
optimizerMap = m_Preset->getOptimizerValuesPresets();
optimizerMap[std::string((const char*)text.toLatin1())] = optimizerValues;
itk::Array<double> interpolatorValues;
interpolatorValues.SetSize(25);
interpolatorValues.fill(0);
interpolatorValues[0] = m_Controls.m_InterpolatorBox->currentIndex();
std::map<std::string, itk::Array<double> > interpolatorMap;
interpolatorMap = m_Preset->getInterpolatorValuesPresets();
interpolatorMap[std::string((const char*)text.toLatin1())] = interpolatorValues;
m_Preset->newPresets(transformMap, metricMap, optimizerMap, interpolatorMap);
}
else
{
// user pressed Cancel
}
}
void QmitkRigidRegistrationSelectorView::StopOptimization(bool stopOptimization)
{
m_StopOptimization = stopOptimization;
}
int QmitkRigidRegistrationSelectorView::GetSelectedTransform()
{
return m_Controls.m_TransformBox->currentIndex();
}
void QmitkRigidRegistrationSelectorView::SetFixedMaskNode( mitk::DataNode * fixedMaskNode )
{
m_FixedMaskNode = fixedMaskNode;
this->TransformSelected(m_Controls.m_TransformBox->currentIndex());
}
void QmitkRigidRegistrationSelectorView::SetMovingMaskNode( mitk::DataNode * movingMaskNode )
{
m_MovingMaskNode = movingMaskNode;
this->TransformSelected(m_Controls.m_TransformBox->currentIndex());
}
void QmitkRigidRegistrationSelectorView::SetMovingNodeChildren(mitk::DataStorage::SetOfObjects::ConstPointer children)
{
m_MovingNodeChildren = children;
}
void QmitkRigidRegistrationSelectorView::AddTransform(QmitkRigidRegistrationTransformsGUIBase* transform)
{
m_Controls.m_TransformBox->addItem(transform->GetName());
int i = 0;
if (!dynamic_cast<QmitkRigidRegistrationTransformsGUIBase*>(m_Controls.m_TransformWidgetStack->widget(i)))
{
m_Controls.m_TransformWidgetStack->addWidget(transform);
m_Controls.m_TransformWidgetStack->removeWidget(m_Controls.m_TransformWidgetStack->widget(i));
transform->SetupUI(m_Controls.m_TransformWidgetStack->widget(i));
}
else
{
i = m_Controls.m_TransformWidgetStack->addWidget(transform);
transform->SetupUI(m_Controls.m_TransformWidgetStack->widget(i));
}
}
void QmitkRigidRegistrationSelectorView::AddMetric(QmitkRigidRegistrationMetricsGUIBase* metric)
{
m_Controls.m_MetricBox->addItem(metric->GetName());
int i = 0;
if (!dynamic_cast<QmitkRigidRegistrationMetricsGUIBase*>(m_Controls.m_MetricWidgetStack->widget(i)))
{
m_Controls.m_MetricWidgetStack->addWidget(metric);
m_Controls.m_MetricWidgetStack->removeWidget(m_Controls.m_MetricWidgetStack->widget(i));
metric->SetupUI(m_Controls.m_MetricWidgetStack->widget(i));
}
else
{
i = m_Controls.m_MetricWidgetStack->addWidget(metric);
metric->SetupUI(m_Controls.m_MetricWidgetStack->widget(i));
}
}
void QmitkRigidRegistrationSelectorView::AddOptimizer(QmitkRigidRegistrationOptimizerGUIBase* optimizer)
{
m_Controls.m_OptimizerBox->addItem(optimizer->GetName());
int i = 0;
if (!dynamic_cast<QmitkRigidRegistrationOptimizerGUIBase*>(m_Controls.m_OptimizerWidgetStack->widget(i)))
{
m_Controls.m_OptimizerWidgetStack->addWidget(optimizer);
m_Controls.m_OptimizerWidgetStack->removeWidget(m_Controls.m_OptimizerWidgetStack->widget(i));
optimizer->SetupUI(m_Controls.m_OptimizerWidgetStack->widget(i));
}
else
{
i = m_Controls.m_OptimizerWidgetStack->addWidget(optimizer);
optimizer->SetupUI(m_Controls.m_OptimizerWidgetStack->widget(i));
}
}
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/mitkLandmarkWarping.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/mitkLandmarkWarping.cpp
index d6b36a8b01..cef1fe45ba 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/mitkLandmarkWarping.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/mitkLandmarkWarping.cpp
@@ -1,124 +1,124 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLandmarkWarping.h"
mitk::LandmarkWarping::LandmarkWarping()
{
m_Deformer = DeformationSourceType::New();
m_LandmarkDeformer = DeformationSourceType::New();
}
mitk::LandmarkWarping::~LandmarkWarping()
{
}
void mitk::LandmarkWarping::SetFixedImage(FixedImageType::Pointer fixedImage)
{
m_FixedImage = fixedImage;
m_Deformer->SetOutputSpacing( m_FixedImage->GetSpacing() );
m_Deformer->SetOutputOrigin( m_FixedImage->GetOrigin() );
m_Deformer->SetOutputRegion( m_FixedImage->GetLargestPossibleRegion() );
}
void mitk::LandmarkWarping::SetMovingImage(MovingImageType::Pointer movingImage)
{
m_MovingImage = movingImage;
m_LandmarkDeformer->SetOutputSpacing( m_MovingImage->GetSpacing() );
m_LandmarkDeformer->SetOutputOrigin( m_MovingImage->GetOrigin() );
m_LandmarkDeformer->SetOutputRegion( m_MovingImage->GetLargestPossibleRegion() );
}
void mitk::LandmarkWarping::SetLandmarks(LandmarkContainerType::Pointer source, LandmarkContainerType::Pointer target)
{
m_SourceLandmarks = source;
m_TargetLandmarks = target;
m_Deformer->SetSourceLandmarks( source );
m_Deformer->SetTargetLandmarks( target );
m_LandmarkDeformer->SetSourceLandmarks( target );
m_LandmarkDeformer->SetTargetLandmarks( source );
}
mitk::LandmarkWarping::MovingImageType::Pointer mitk::LandmarkWarping::Register()
{
try
{
m_Observer = Observer::New();
unsigned long obs = m_Deformer->AddObserver(itk::ProgressEvent(), m_Observer);
mitk::ProgressBar::GetInstance()->AddStepsToDo(120);
m_Deformer->UpdateLargestPossibleRegion();
m_Deformer->RemoveObserver(obs);
}
catch( itk::ExceptionObject & excp )
{
std::cerr << "Exception thrown " << std::endl;
std::cerr << excp << std::endl;
return NULL;
}
try
{
unsigned long obs2 = m_LandmarkDeformer->AddObserver(itk::ProgressEvent(), m_Observer);
m_LandmarkDeformer->UpdateLargestPossibleRegion();
m_LandmarkDeformer->RemoveObserver(obs2);
}
catch( itk::ExceptionObject & excp )
{
std::cerr << "Exception thrown " << std::endl;
std::cerr << excp << std::endl;
return NULL;
}
m_DeformationField = m_Deformer->GetOutput();
m_InverseDeformationField = m_LandmarkDeformer->GetOutput();
m_Warper = FilterType::New();
typedef itk::LinearInterpolateImageFunction<
MovingImageType, double > InterpolatorType;
InterpolatorType::Pointer interpolator = InterpolatorType::New();
m_Warper->SetInterpolator( interpolator );
m_Warper->SetOutputSpacing( m_DeformationField->GetSpacing() );
m_Warper->SetOutputOrigin( m_DeformationField->GetOrigin() );
- m_Warper->SetDeformationField( m_DeformationField );
+ m_Warper->SetDisplacementField( m_DeformationField );
m_Warper->SetInput( m_MovingImage );
unsigned long obs3 = m_Warper->AddObserver(itk::ProgressEvent(), m_Observer);
m_Warper->UpdateLargestPossibleRegion();
m_Warper->RemoveObserver(obs3);
return m_Warper->GetOutput();
}
mitk::LandmarkWarping::LandmarkContainerType::Pointer mitk::LandmarkWarping::GetTransformedTargetLandmarks()
{
LandmarkContainerType::Pointer landmarks = LandmarkContainerType::New();
LandmarkWarping::LandmarkPointType transformedTargetPoint;
for(unsigned int pointId=0; pointId<m_TargetLandmarks->Size();++pointId)
{
LandmarkWarping::LandmarkPointType targetPoint=m_TargetLandmarks->GetElement(pointId);
transformedTargetPoint = m_LandmarkDeformer->GetKernelTransform()->TransformPoint(targetPoint);
landmarks->InsertElement(pointId, transformedTargetPoint );
}
return landmarks;
}
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/mitkLandmarkWarping.h b/Plugins/org.mitk.gui.qt.registration/src/internal/mitkLandmarkWarping.h
index 7c992d6b8d..fb23ed0dbf 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/mitkLandmarkWarping.h
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/mitkLandmarkWarping.h
@@ -1,114 +1,114 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKLANDMARKWARPING_H
#define MITKLANDMARKWARPING_H
-#include "itkDeformationFieldSource.h"
+#include "itkLandmarkDisplacementFieldSource.h"
#include "itkWarpImageFilter.h"
#include "itkCommand.h"
#include "mitkProgressBar.h"
namespace mitk
{
class LandmarkWarping
{
public:
LandmarkWarping();
~LandmarkWarping();
static const unsigned int Dimension = 3;
typedef float VectorComponentType;
typedef itk::Vector< VectorComponentType, Dimension > VectorType;
typedef itk::Image< VectorType, Dimension > DeformationFieldType;
typedef unsigned char PixelType;
typedef itk::Image< PixelType, Dimension > FixedImageType;
typedef itk::Image< PixelType, Dimension > MovingImageType;
- typedef itk::DeformationFieldSource< DeformationFieldType > DeformationSourceType;
+ typedef itk::LandmarkDisplacementFieldSource< DeformationFieldType > DeformationSourceType;
typedef DeformationSourceType::LandmarkContainerPointer LandmarkContainerPointer;
typedef DeformationSourceType::LandmarkContainer LandmarkContainerType;
typedef DeformationSourceType::LandmarkPointType LandmarkPointType;
typedef itk::WarpImageFilter< MovingImageType, MovingImageType, DeformationFieldType > FilterType;
FixedImageType::Pointer m_FixedImage;
MovingImageType::Pointer m_MovingImage;
DeformationSourceType::Pointer m_Deformer;
DeformationSourceType::Pointer m_LandmarkDeformer;
LandmarkWarping::LandmarkContainerType::Pointer m_TargetLandmarks;
LandmarkWarping::LandmarkContainerType::Pointer m_SourceLandmarks;
FilterType::Pointer m_Warper;
DeformationFieldType::ConstPointer m_DeformationField;
DeformationFieldType::ConstPointer m_InverseDeformationField;
void SetFixedImage(FixedImageType::Pointer fi);
void SetMovingImage(MovingImageType::Pointer mi);
void SetLandmarks(LandmarkContainerType::Pointer source, LandmarkContainerType::Pointer target);
MovingImageType::Pointer Register();
LandmarkContainerType::Pointer GetTransformedTargetLandmarks();
protected:
// observerclass to react on changes on pointsetnodes
class Observer : public itk::Command
{
public:
typedef Observer Self;
typedef itk::Command Superclass;
typedef itk::SmartPointer<Self> Pointer;
itkNewMacro( Self );
protected:
Observer()
{
m_Counter = 0;
};
unsigned int m_Counter;
public:
void Execute(itk::Object *object, const itk::EventObject & event)
{
Execute( (const itk::Object*) object, event );
}
void Execute(const itk::Object * object, const itk::EventObject & /*event*/)
{
const itk::ProcessObject * internalFilter = dynamic_cast<const itk::ProcessObject *>( object );
if (!(internalFilter->GetProgress() == 0 || internalFilter->GetProgress() == 1))
{
++m_Counter;
mitk::ProgressBar::GetInstance()->Progress();
}
if (internalFilter->GetProgress() == 1 && m_Counter > 20 && m_Counter < 120)
{
mitk::ProgressBar::GetInstance()->Progress(120 - m_Counter);
m_Counter = 120;
}
}
};
Observer::Pointer m_Observer;
};
}
#endif // MITKLANDMARKWARPING_H
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox
index e087268bb7..5a7657ce68 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox
+++ b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox
@@ -1,292 +1,309 @@
/**
\page org_mitk_views_segmentation The Segmentation Plugin
\image html segmentation.png "Icon of the Plugin"
<i>Some of the features described below are closed source additions to the open source toolkit MITK and are not available in every application.</i>
Available sections:
- \ref org_mitk_gui_qt_segmentationUserManualOverview
- \ref org_mitk_gui_qt_segmentationUserManualTechnical
- \ref org_mitk_gui_qt_segmentationUserManualImageSelection
- \ref org_mitk_gui_qt_segmentationUserManualManualKringeling
- \ref org_mitk_gui_qt_segmentationUserManualManualKringeling1
- \ref org_mitk_gui_qt_segmentationUserManualManualKringeling2
- \ref org_mitk_gui_qt_segmentationUserManualManualKringeling3
- \ref org_mitk_gui_qt_segmentationUserManualManualKringeling4
- \ref org_mitk_gui_qt_segmentationUserManualManualKringeling5
- \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation
- \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation1
- \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation2
- \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation99
- \ref org_mitk_gui_qt_segmentationUserManualLesionSegmentation
- \ref org_mitk_gui_qt_segmentationUserManualPostprocessing
- \ref org_mitk_gui_qt_segmentationUserManualSurfaceMasking
- \ref org_mitk_gui_qt_segmentationUserManualTechnicalDetail
\section org_mitk_gui_qt_segmentationUserManualOverview Overview
The <b>Segmentation perspective</b> allows you to create segmentations of anatomical and pathological structures in medical images of the human body.
The perspective groups a number of tools which can be used for:
<ul>
<li> (semi-)automatic segmentation of organs on CT or MR image volumes
<li> semi-automatic segmentation of lesions such as enlarged lymph nodes or tumors
<li> manual segmentation of any structures you might want to delineate
</ul>
\image html org_mitk_gui_qt_segmentationIMGapplication.png Segmentation perspective consisting of the Data Manager view and the Segmentation view
If you wonder what segmentations are good for, we shortly revisit the concept of a segmentation here.
A CT or MR image is made up of volume of physical measurements (volume elements are called voxels).
In CT images, for example, the gray value of each voxel corresponds to the mass absorbtion coefficient for X-rays in this voxel, which is similar in many %parts of the human body.
The gray value does not contain any further information, so the computer does not know whether a given voxel is part of the body or the background, nor can it tell a brain from a liver.
However, the distinction between a foreground and a background structure is required when:
<ul>
<li>you want to know the volume of a given organ (the computer needs to know which %parts of the image belong to this organ)
<li>you want to create 3D polygon visualizations (the computer needs to know the surfaces of structures that should be drawn)
<li>as a necessary pre-processing step for therapy planning, therapy support, and therapy monitoring
</ul>
Creating this distinction between foreground and background is called <i>segmentation</i>.
The Segmentation perspective of the MITK Workbench uses a voxel based approach to segmentation, i.e. each voxel of an image must be completely assigned to either foreground or background.
This is in contrast to some other applications which might use an approach based on contours, where the border of a structure might cut a voxel into two %parts.
The remainder of this document will summarize the features of the Segmentation perspective and how they are used.
\section org_mitk_gui_qt_segmentationUserManualTechnical Technical Issues
The Segmentation perspective makes a number of assumptions. To know what this view can be used for, it will help you to know that:
<ul>
<li> Images must be 2D, 3D, or 3D+t
<li> Images must be single-values, i.e. CT, MRI or "normal" ultrasound. Images from color doppler or photographic (RGB) images are not supported
<li> Segmentations are handled as binary images of the same extent as the original image
</ul>
\section org_mitk_gui_qt_segmentationUserManualImageSelection Image Selection
The Segmentation perspective makes use of the Data Manager view to give you an overview of all images and segmentations.
\image html org_mitk_gui_qt_segmentationIMGselection.png Data Manager is used for selecting the current segmentation. The reference image is selected in the drop down box of the control area.
To select the reference image (e.g. the original CT/MR image) use the drop down box in the control area of the Segmentation view. The segmentation image selected in the Data Manager is displayed below the drop down box. If no segmentation image exists or none is selected create a new segmentation image by using the "New segmentation" button.
Some items of the graphical user interface might be disabled when no image is selected.
In any case, the application will give you hints if a selection is needed.
\section org_mitk_gui_qt_segmentationUserManualManualKringeling Manual Contouring
With manual contouring you define which voxels are part of the segmentation and which are not.
This allows you to create segmentations of any structeres that you may find in an image, even if they are not part of the human body.
You might also use manual contouring to correct segmentations that result from sub-optimal automatic methods.
The drawback of manual contouring is that you might need to define contours on many 2D slices.
However, this is moderated by the interpolation feature, which will make suggestions for a segmentation.
\subsection org_mitk_gui_qt_segmentationUserManualManualKringeling1 Creating New Segmentations
Unless you want to edit existing segmentations, you have to create a new, empty segmentation before you can edit it.
To do so, click the "New manual segmentation" button.
Input fields will appear where you can choose a name for the new segmentation and a color for its display.
Click the checkmark button to confirm or the X button to cancel the new segmentation.
Notice that the input field suggests names once you %start typing and that it also suggests colors for known organ names.
If you use names that are not yet known to the application, it will automatically remember these names and consider them the next time you create a new segmentation.
Once you created a new segmentation, you can notice a new item with the "binary mask" icon in the Data Manager tree view.
This item is automatically selected for you, allowing you to %start editing the new segmentation right away.
\subsection org_mitk_gui_qt_segmentationUserManualManualKringeling2 Selecting Segmentations for Editing
As you might want to have segmentations of multiple structures in a single patient image, the application needs to know which of them to use for editing.
You select a segmenation by clicking it in the tree view of Data Manager. Note that segmentations are usually displayed as sub-items of "their" patient image.
In the rare case, where you need to edit a segmentation that is not displayed as a a sub-item, you can click both the original image AND the segmentation while holding down CTRL or for Mac OS X the CMD on the keyboard.
When a selection is made, the Segmentation View will hide all but the selected segmentation and the corresponding original image.
When there are multiple segmentations, the unselected ones will remain in the Data Manager, you can make them visible at any time by selecting them.
\subsection org_mitk_gui_qt_segmentationUserManualManualKringeling3 Selecting Editing Tools
If you are familiar with the MITK Workbench, you know that clicking and moving the mouse in any of the 2D render windows will move around the crosshair that defines what part of the image is displayed.
This behavior is disabled while any of the manual segmentation tools are active -- otherwise you might have a hard time concentrating on the contour you are drawing.
To %start using one of the editing tools, click its button the the displayed toolbox.
The selected editing tool will be active and its corresponding button will stay pressed until you click the button again.
Selecting a different tool also deactivates the previous one.
If you have to delineate a lot of images, you should try using shortcuts to switch tools. Just hit the first letter of each tool to activate it (A for Add, S for Subtract, etc.).
\subsection org_mitk_gui_qt_segmentationUserManualManualKringeling4 Using Editing Tools
All of the editing tools work by the same principle: you use the mouse (left button) to click anywhere in a 2D window (any of the orientations axial, sagittal, or frontal), move the mouse while holding the mouse button and release to finish the editing action.
Multi-step undo and redo is fully supported by all editing tools. Use the application-wide undo button in the toolbar to revert erroneous %actions.
\image html org_mitk_gui_qt_segmentationIMGiconAddSubtract.png Add and Subtract Tools
Use the left mouse button to draw a closed contour. When releasing the mouse button, the contour will be added (Add tool) to or removed from (Subtract tool) the current segmentation.
Hold down the CTRL / CMD key to invert the operation (this will switch tools temporarily to allow for quick corrections).
\image html org_mitk_gui_qt_segmentationIMGiconPaintWipe.png Paint and Wipe Tools
Use the slider below the toolbox to change the radius of these round paintbrush tools. Move the mouse in any 2D window and press the left button to draw or erase pixels.
As the Add/Subtract tools, holding CTRL / CMD while drawing will invert the current tool's behavior.
\image html org_mitk_gui_qt_segmentationIMGiconRegionGrowing.png Region Growing Tool
Click at one point in a 2D slice widget to add an image region to the segmentation with the region growing tool. Moving up the cursor while holding the left mouse button widens the range for the included grey values; moving it down narrows it.
When working on an image with a high range of grey values, the selection range can be influenced more strongly by moving the cursor at higher velocity.
Region Growing selects all pixels around the mouse cursor that have a similar gray value as the pixel below the mouse cursor.
This enables you to quickly create segmentations of structures that have a good contrast to surrounding tissue, e.g. the lungs.
The tool will select more or less pixels (corresponding to a changing gray value interval width) when you move the mouse up or down while holding down the left mouse button.
A common issue with region growing is the so called "leakage" which happens when the structure of interest is connected to other pixels, of similar gray values, through a narrow "bridge" at the border of the structure.
The Region Growing tool comes with a "leakage detection/removal" feature. If leakage happens, you can left-click into the leakage region and the tool will try to automatically remove this region (see illustration below).
\image html org_mitk_gui_qt_segmentationIMGleakage.png Leakage correction feature of the Region Growing tool
<br>
\image html org_mitk_gui_qt_segmentationIMGiconCorrection.png Correction Tool
You do not have to draw a closed contour to use the Correction tool and do not need to switch between the Add and Substract tool to perform
small corrective changes. The following figure shows the usage of this tool:
<ul>
<li> if the user draws a line which %starts and ends outside the segmenation AND it intersects no other segmentation the endpoints of the line are connected and the resulting contour is filled
<li> if the user draws a line which %starts and ends outside the segmenation a part of it is cut off (left image)
<li> if the line is drawn fully inside the segmentation the marked region is added to the segmentation (right image)
</ul>
\image html org_mitk_gui_qt_segmentationIMGcorrectionActions.png %Actions of the Correction tool illustrated.
<br>
\image html org_mitk_gui_qt_segmentationIMGiconFill.png Fill Tool
Left-click inside a segmentation with holes to completely fill all holes.
\image html org_mitk_gui_qt_segmentationIMGiconErase.png Erase Tool
This tool removes a connected part of pixels that form a segmentation. You may use it to remove so called islands (see picture) or to clear a whole slice at once (hold CTRL while clicking).
+\image html org_mitk_gui_qt_segmentationIMGiconLiveWire.png LiveWire Tool
+
+The LiveWire Tool acts as a magnetic lasso with a contour snapping to edges of objects.
+
+\image html org_mitk_gui_qt_segmentationIMGLiveWireUsage.png Steps for using LiveWire Tool
+
+<ul>
+<li>(1) To start the Tool you have to double click near the edge of the object you want to segment. The initial anchor point will snap to the edge within a 3x3 region.
+<li>(2) Move the mouse. You don't have trace the edge of the object. The contour will automatically snap to it.
+<li>(3) To fix a segment you can set anchor points by single left mouse button click.
+<li>(4) Go on with moving the mouse and setting anchor points.
+<li>(5) To close the contour double click on the initial anchor point.
+<li>(6) After closing the contour can be edited by moving, inserting and deleting anchor points.
+</ul>
+
+The contour will be transfered to its binary image representation by deactivating the tool.
+
\subsection org_mitk_gui_qt_segmentationUserManualManualKringeling5 Interpolation
Creating segmentations for modern CT volumes is very time-consuming, because structures of interest can easily cover a range of 50 or more slices.
The Manual Segmentation View offers two helpful features for these cases:
<ul>
<li> <b>3D Interpolation</b>
<li> <b>2D Interpolation</b>
</ul>
<br>
<b>The 3D interpolation</b> is activated by default when using the manual segmentation tools. That means if you start contouring, from the second contour onwards, the surface of the segmented area will be interpolated based on the given contour information.
The interpolation works with all available manual tools. Please note that this is currently a pure mathematical interpolation, i.e. image intensity information is not taken into account. With each further contour the interpolation result will be improved,
but the more contours you provide the longer the recalculation will take. To achieve an optimal interpolation result and in this way a most accurate segmentation you should try to describe the surface with sparse contours by segmenting in arbitrary
oriented planes. The 3D interpolation is not meant to be used for parallel slice-wise segmentation.
\image html org_mitk_gui_qt_segmentation3DInterpolationWrongRight.png 3D Interpolation HowTo
You can accept the interpolation result by clicking the "Accept" - button below the tool buttons.
In this case the 3D interpolation will be deactivated automatically so that the result can be postprocessed without any interpolation running in background. During recalculation the interpolated surface is blinking yellow/white. When the interpolation
has finished the surface is shown yellow with a small opacity. Additional to the surface, black contours are shown in the 3D render window. They mark the positions of all the drawn contours which were used for the interpolation.
You can navigate between the drawn contours by clicking on the „Position“ - Nodes in the datamanager which are located below the selected segmentation. If you don't want to see these nodes just unckeck the „Show Position Nodes“ Checkbox and these nodes will be hidden.
If you want to delete a drawn contour we recommend to use the Erase-Tool since Redo/Undo is not yet working for 3D interpolation.
<br>
<b>The 2D Interpolation</b> creates suggestions for a segmentation whenever you have a slice that
<ul>
<li> has got neighboring slices with segmentations (these do not need to be direct neighbors but could also be a couple of slices away) AND
<li> is completely clear of a manual segmentation -- i.e. there will be no suggestion if there is even only a single pixel of segmentation in the current slice.
</ul>
Interpolated suggestions are displayed in a different way than manual segmentations are, until you "accept" them as part of the segmentation.
To accept single slices, click the "Accept" button below the toolbox.
If you have segmented a whole organ in every-x-slice, you may also review the interpolations and then accept all of them at once by clicking "... all slices".
\section org_mitk_gui_qt_segmentationUserManualOrganSegmentation Organ Segmentation
\note This feature is only available in our 3M3 Demo Application (http://www.mint-medical.de/productssolutions/mitk3m3/mitk3m3/#downloads) but not in the open source part of MITK
The manual contouring described above is a fallback option that will work for any kind of images and structures of interest.
However, manual contouring is very time-consuming and tedious.
This is why a major part of image analysis research is working towards automatic segmentation methods.
The Segmentation View comprises a number of easy-to-use tools for segmentation of CT images (Liver) and MR image (left ventricle and wall, left and right lung).
\subsection org_mitk_gui_qt_segmentationUserManualOrganSegmentation1 Liver on CT Images
On CT image volumes, preferrably with a contrast agent in the portal venous phase, the Liver tool will fully automatically analyze and segment the image.
All you have to do is to load and select the image, then click the "Liver" button.
During the process, which takes a minute or two, you will get visual progress feedback by means of a contour that moves closer and closer to the real liver boundaries.
\subsection org_mitk_gui_qt_segmentationUserManualOrganSegmentation2 Heart, Lung, and Hippocampus on MRI
While liver segmentation is performed fully automatic, the following tools for segmentation of the heart, the lungs, and the hippocampus need a minimum amount of guidance.
Click one of the buttons on the "Organ segmentation" page to add an average %model of the respective organ to the image.
This %model can be dragged to the right position by using the left mouse button while holding down the CTRL key.
You can also use CTRL + middle mouse button to rotate or CTRL + right mouse button to scale the %model.
Before starting the automatic segmentation process by clicking the "Start segmentation" button, try placing the %model closely to the organ in the MR image
(in most cases, you do not need to rotate or scale the %model).
During the segmentation process, a green contour that moves closer and closer to the real liver boundaries will provide you with visual feedback of the segmentation progress.
The algorithms used for segmentation of the heart and lung are method which need training by a number of example images.
They will not work well with other kind of images, so here is a list of the image types that were used for training:
<ul>
<li> Hippocampus segmentation: T1-weighted MR images, 1.5 Tesla scanner (Magnetom Vision, Siemens Medical Solutions), 1.0 mm isotropic resolution
<li> Heart: Left ventricle inner segmentation (LV Model): MRI; velocity encoded cine (VEC-cine) MRI sequence; trained on systole and diastole
<li> Heart: Left ventricular wall segmentation (LV Inner Wall, LV Outer Wall): 4D MRI; short axis 12 slice spin lock sequence(SA_12_sl); trained on whole heart cycle
<li> Lung segmentation: 3D and 4D MRI; works best on FLASH3D and TWIST4D sequences
</ul>
\subsection org_mitk_gui_qt_segmentationUserManualOrganSegmentation99 Other Organs
As mentioned in the Heart/Lung section, most of the underlying methods are based on "training".
The basic algorithm is versatile and can be applied on all kinds of segmentation problems where the structure of interest is topologically like a sphere (and not like a torus etc.).
If you are interested in other organs than those offered by the current version of the Segmentation view,
please contact our research team.
\section org_mitk_gui_qt_segmentationUserManualLesionSegmentation Lesion Segmentation
\note This feature is only available in our 3M3 Demo Application (http://www.mint-medical.de/productssolutions/mitk3m3/mitk3m3/#downloads) but not in the open source part of MITK
Lesion segmentation is a little different from organ segmentation. Since lesions are not part of the healthy body, they sometimes have a diffused border,
and are often found in varying places all over the body.
The tools in this section offer efficient ways to create 3D segmentations of such lesions.
The Segmentation View currently offers supoprt for enlarged lymph nodes.
To segment an enlarged lymph node, find a more or less central slice of it, activate the "Lymph Node" tool and draw a rough contour on the inside of the lymph node.
When releaseing the mouse button, a segmentation algorithm is started in a background task. The result will become visible after a couple of seconds, but you do not have to wait for it.
If you need to segment several lymph nodes, you can continue to inspect the image right after closing the drawn contour.
If the lymph node segmentation is not to your content, you can select the "Lymph Node Correction" tool and drag %parts of the lymph node surface towards the right position (works in 3D, not slice-by-slice).
This kind of correction helps in many cases.
If nothing else helps, you can still use the pure manual tools as a fallback.
\section org_mitk_gui_qt_segmentationUserManualPostprocessing Things you can do with segmentations
As mentioned in the introduction, segmentations are never an end in themselves.
Consequently, the Segmentation view adds a couple of "post-processing" %actions to the Data Manager.
These %actions are accessible through the context-menu of segmentations in Data Manager's list view
\image html org_mitk_gui_qt_segmentationIMGDataManagerContextMenu.png Context menu items for segmentations.
<ul>
<li> <b>Create polygon %model</b> applies the marching cubes algorithms to the segmentation. This polygon %model can be used for visualization in 3D or other things such as stereolithography (3D printing).
<li> <b>Create smoothed polygon %model</b> uses smoothing in addition to the marching cubes algorithms, which creates models that do not follow the exact outlines of the segmentation, but look smoother.
<li> <b>Statistics</b> goes through all the voxels in the patient image that are part of the segmentation and calculates some statistical measures (minumum, maximum, median, histogram, etc.). Note that the statistics are ALWAYS calculated for the parent element of the segmentation as shown in Data Manager.
<li> <b>Autocrop</b> can save memory. Manual segmentations have the same extent as the patient image, even if the segmentation comprises only a small sub-volume. This invisible and meaningless margin is removed by autocropping.
</ul>
\section org_mitk_gui_qt_segmentationUserManualSurfaceMasking Surface Masking
You can use the surface masking tool to create binary images from a surface which
is used used as a mask on an image. This task is demonstrated below:
\image html segmentationFromSurfaceBefore.png Load an image and a surface.
Select the image and the surface in the corresponding drop-down boxes (both are selected automatically if there is just one image and one surface)
\image html segmentationFromSurfaceAfter.png Create segmentation from surface
After clicking "Create segmentation from surface" the newly created binary image is inserted in the DataManager and can be used for further processing
\section org_mitk_gui_qt_segmentationUserManualTechnicalDetail Technical Information for Developers
For technical specifications see \subpage QmitkSegmentationTechnicalPage and for information on the extensions of the tools system \subpage toolextensions .
*/
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentationIMGLiveWireUsage.PNG b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentationIMGLiveWireUsage.PNG
new file mode 100644
index 0000000000..fb667cdc1c
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentationIMGLiveWireUsage.PNG differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentationIMGiconLiveWire.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentationIMGiconLiveWire.png
new file mode 100644
index 0000000000..befc1f39bd
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentationIMGiconLiveWire.png differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/files.cmake b/Plugins/org.mitk.gui.qt.segmentation/files.cmake
index bec23ea488..09cd72094c 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/files.cmake
+++ b/Plugins/org.mitk.gui.qt.segmentation/files.cmake
@@ -1,64 +1,64 @@
set(SRC_CPP_FILES
QmitkSegmentationPreferencePage.cpp
)
set(INTERNAL_CPP_FILES
mitkPluginActivator.cpp
QmitkSegmentationView.cpp
QmitkSegmentationPostProcessing.cpp
QmitkThresholdAction.cpp
QmitkCreatePolygonModelAction.cpp
- QmitkStatisticsAction.cpp
+ #QmitkStatisticsAction.cpp
QmitkAutocropAction.cpp
QmitkBooleanOperationsView.cpp
QmitkDeformableClippingPlaneView.cpp
regiongrowing/QmitkRegionGrowingView.cpp
QmitkOtsuAction.cpp
)
set(UI_FILES
src/internal/QmitkSegmentationControls.ui
src/internal/QmitkBooleanOperationsView.ui
src/internal/QmitkDeformableClippingPlaneViewControls.ui
src/internal/regiongrowing/QmitkRegionGrowingViewControls.ui
)
set(MOC_H_FILES
src/QmitkSegmentationPreferencePage.h
src/internal/mitkPluginActivator.h
src/internal/QmitkSegmentationView.h
src/internal/QmitkSegmentationPostProcessing.h
src/internal/QmitkThresholdAction.h
src/internal/QmitkCreatePolygonModelAction.h
- src/internal/QmitkStatisticsAction.h
+ #src/internal/QmitkStatisticsAction.h
src/internal/QmitkAutocropAction.h
src/internal/QmitkBooleanOperationsView.h
src/internal/QmitkDeformableClippingPlaneView.h
src/internal/regiongrowing/QmitkRegionGrowingView.h
src/internal/QmitkOtsuAction.h
)
set(CACHED_RESOURCE_FILES
resources/segmentation.png
resources/boolean.png
resources/deformablePlane.png
resources/regiongrowing.xpm
plugin.xml
)
set(QRC_FILES
resources/segmentation.qrc
resources/boolean.qrc
resources/regiongrowing.qrc
)
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/Plugins/org.mitk.gui.qt.segmentation/plugin.xml b/Plugins/org.mitk.gui.qt.segmentation/plugin.xml
index efc274f7f5..a20655207c 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.segmentation/plugin.xml
@@ -1,48 +1,47 @@
<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.0"?>
<plugin>
<extension point="org.blueberry.ui.views">
<category
id="org.mitk.views.general"
name="MITK General"/>
<view id="org.mitk.views.segmentation"
name="Segmentation"
icon="resources/segmentation.png"
class="QmitkSegmentationView" />
<view id="org.mitk.views.segmentationboolean"
name="Boolean Operations"
class="QmitkBooleanOperationsView"
icon="resources/boolean.png" />
<view id="org.mitk.views.deformableclippingplane"
name="Clipping Plane"
class="QmitkDeformableClippingPlaneView"
icon="resources/deformablePlane.png" />
<view
id="org.mitk.views.regiongrowing"
name="RegionGrowing"
category="org.mitk.views.general"
icon="resources/regiongrowing.xpm"
class="QmitkRegionGrowingView" />
</extension>
<extension point="org.blueberry.ui.preferencePages">
<page id="org.mitk.gui.qt.application.SegmentationPreferencePage" name="Segmentation" class="QmitkSegmentationPreferencePage">
<keywordreference id="org.mitk.gui.qt.application.SegmentationPreferencePageKeywords"></keywordreference>
</page>
</extension>
<extension point="org.blueberry.ui.keywords">
<keyword id="org.mitk.gui.qt.application.SegmentationPreferencePageKeywords" label="data manager"></keyword>
</extension>
<extension point="org.mitk.gui.qt.datamanager.contextMenuActions">
<contextMenuAction nodeDescriptorName="Image" label="Threshold..." icon="" class="QmitkThresholdAction" />
<contextMenuAction nodeDescriptorName="Image" label="Otsu Segmentation" icon="" class="QmitkOtsuAction" />
<contextMenuAction nodeDescriptorName="ImageMask" label="Create polygon model" icon="" smoothed="false" class="QmitkCreatePolygonModelAction" />
<contextMenuAction nodeDescriptorName="ImageMask" label="Create smoothed polygon model" icon="" smoothed = "true" class="QmitkCreatePolygonModelAction" />
- <contextMenuAction nodeDescriptorName="ImageMask" label="Statistics" icon="" class="QmitkStatisticsAction" />
<contextMenuAction nodeDescriptorName="ImageMask" label="Autocrop" icon="" class="QmitkAutocropAction" />
</extension>
</plugin>
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp
index 6d624b6906..a1371739e5 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp
@@ -1,181 +1,188 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkSegmentationPreferencePage.h"
#include <QLabel>
#include <QPushButton>
#include <QFormLayout>
#include <QCheckBox>
#include <QGroupBox>
#include <QRadioButton>
#include <QMessageBox>
#include <QDoubleSpinBox>
#include <berryIPreferencesService.h>
#include <berryPlatform.h>
QmitkSegmentationPreferencePage::QmitkSegmentationPreferencePage()
: m_MainControl(0)
, m_Initializing(false)
{
}
QmitkSegmentationPreferencePage::~QmitkSegmentationPreferencePage()
{
}
void QmitkSegmentationPreferencePage::Init(berry::IWorkbench::Pointer )
{
}
void QmitkSegmentationPreferencePage::CreateQtControl(QWidget* parent)
{
m_Initializing = true;
berry::IPreferencesService::Pointer prefService
= berry::Platform::GetServiceRegistry()
.GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
m_SegmentationPreferencesNode = prefService->GetSystemPreferences()->Node("/org.mitk.views.segmentation");
m_MainControl = new QWidget(parent);
QVBoxLayout* displayOptionsLayout = new QVBoxLayout;
m_RadioOutline = new QRadioButton( "Draw as outline", m_MainControl);
displayOptionsLayout->addWidget( m_RadioOutline );
m_RadioOverlay = new QRadioButton( "Draw as transparent overlay", m_MainControl);
displayOptionsLayout->addWidget( m_RadioOverlay );
QFormLayout *formLayout = new QFormLayout;
formLayout->setHorizontalSpacing(8);
formLayout->setVerticalSpacing(24);
formLayout->addRow( "2D display", displayOptionsLayout );
m_VolumeRenderingCheckBox = new QCheckBox( "Show as volume rendering", m_MainControl );
formLayout->addRow( "3D display", m_VolumeRenderingCheckBox );
connect( m_VolumeRenderingCheckBox, SIGNAL(stateChanged(int)), this, SLOT(OnVolumeRenderingCheckboxChecked(int)) );
QFormLayout* surfaceLayout = new QFormLayout;
surfaceLayout->setSpacing(8);
m_SmoothingCheckBox = new QCheckBox("Use image spacing as smoothing value hint", m_MainControl);
surfaceLayout->addRow(m_SmoothingCheckBox);
connect(m_SmoothingCheckBox, SIGNAL(stateChanged(int)), this, SLOT(OnSmoothingCheckboxChecked(int)));
m_SmoothingSpinBox = new QDoubleSpinBox(m_MainControl);
m_SmoothingSpinBox->setMinimum(0.0);
m_SmoothingSpinBox->setSingleStep(0.5);
m_SmoothingSpinBox->setValue(1.0);
m_SmoothingSpinBox->setToolTip("The Smoothing value is used as variance for a gaussian blur.");
surfaceLayout->addRow("Smoothing value (mm)", m_SmoothingSpinBox);
m_DecimationSpinBox = new QDoubleSpinBox(m_MainControl);
m_DecimationSpinBox->setMinimum(0.0);
m_DecimationSpinBox->setMaximum(0.99);
m_DecimationSpinBox->setSingleStep(0.1);
m_DecimationSpinBox->setValue(0.5);
m_DecimationSpinBox->setToolTip("Valid range is [0, 1). High values increase decimation, especially when very close to 1. A value of 0 disables decimation.");
surfaceLayout->addRow("Decimation rate", m_DecimationSpinBox);
m_ClosingSpinBox = new QDoubleSpinBox(m_MainControl);
m_ClosingSpinBox->setMinimum(0.0);
m_ClosingSpinBox->setMaximum(1.0);
m_ClosingSpinBox->setSingleStep(0.1);
m_ClosingSpinBox->setValue(0.0);
m_ClosingSpinBox->setToolTip("Valid range is [0, 1]. Higher values increase closing. A value of 0 disables closing.");
surfaceLayout->addRow("Closing Ratio", m_ClosingSpinBox);
+ m_SelectionModeCheckBox = new QCheckBox("Enable auto-selection mode", m_MainControl);
+ m_SelectionModeCheckBox->setToolTip("If checked the segmentation plugin ensures that only one segmentation and the according greyvalue image are visible at one time.");
+ formLayout->addRow("Data node selection mode",m_SelectionModeCheckBox);
+
formLayout->addRow("Smoothed surface creation", surfaceLayout);
m_MainControl->setLayout(formLayout);
this->Update();
m_Initializing = false;
}
QWidget* QmitkSegmentationPreferencePage::GetQtControl() const
{
return m_MainControl;
}
bool QmitkSegmentationPreferencePage::PerformOk()
{
m_SegmentationPreferencesNode->PutBool("draw outline", m_RadioOutline->isChecked());
m_SegmentationPreferencesNode->PutBool("volume rendering", m_VolumeRenderingCheckBox->isChecked());
m_SegmentationPreferencesNode->PutBool("smoothing hint", m_SmoothingCheckBox->isChecked());
m_SegmentationPreferencesNode->PutDouble("smoothing value", m_SmoothingSpinBox->value());
m_SegmentationPreferencesNode->PutDouble("decimation rate", m_DecimationSpinBox->value());
m_SegmentationPreferencesNode->PutDouble("closing ratio", m_ClosingSpinBox->value());
+ m_SegmentationPreferencesNode->PutBool("auto selection", m_SelectionModeCheckBox->isChecked());
return true;
}
void QmitkSegmentationPreferencePage::PerformCancel()
{
}
void QmitkSegmentationPreferencePage::Update()
{
//m_EnableSingleEditing->setChecked(m_SegmentationPreferencesNode->GetBool("Single click property editing", true));
if (m_SegmentationPreferencesNode->GetBool("draw outline", true) )
{
m_RadioOutline->setChecked( true );
}
else
{
m_RadioOverlay->setChecked( true );
}
m_VolumeRenderingCheckBox->setChecked( m_SegmentationPreferencesNode->GetBool("volume rendering", false) );
if (m_SegmentationPreferencesNode->GetBool("smoothing hint", true))
{
m_SmoothingCheckBox->setChecked(true);
m_SmoothingSpinBox->setDisabled(true);
}
else
{
- m_SmoothingCheckBox->setChecked(false);
- m_SmoothingSpinBox->setEnabled(true);
+ m_SmoothingCheckBox->setChecked(false);
+ m_SmoothingSpinBox->setEnabled(true);
}
+ m_SelectionModeCheckBox->setChecked( m_SegmentationPreferencesNode->GetBool("auto selection", true) );
+
m_SmoothingSpinBox->setValue(m_SegmentationPreferencesNode->GetDouble("smoothing value", 1.0));
m_DecimationSpinBox->setValue(m_SegmentationPreferencesNode->GetDouble("decimation rate", 0.5));
m_ClosingSpinBox->setValue(m_SegmentationPreferencesNode->GetDouble("closing ratio", 0.0));
}
void QmitkSegmentationPreferencePage::OnVolumeRenderingCheckboxChecked(int state)
{
if (m_Initializing) return;
if ( state != Qt::Unchecked )
{
QMessageBox::information(NULL,
"Memory warning",
"Turning on volume rendering of segmentations will make the application more memory intensive (and potentially prone to crashes).\n\n"
"If you encounter out-of-memory problems, try turning off volume rendering again.");
}
}
void QmitkSegmentationPreferencePage::OnSmoothingCheckboxChecked(int state)
{
if (state != Qt::Unchecked)
m_SmoothingSpinBox->setDisabled(true);
else
m_SmoothingSpinBox->setEnabled(true);
}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.h b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.h
index f5662af5b0..dd3fd87765 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.h
@@ -1,83 +1,84 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkSegmentationPreferencePage_h_included
#define QmitkSegmentationPreferencePage_h_included
#include "berryIQtPreferencePage.h"
#include "org_mitk_gui_qt_segmentation_Export.h"
#include <berryIPreferences.h>
class QWidget;
class QCheckBox;
class QRadioButton;
class QDoubleSpinBox;
class MITK_QT_SEGMENTATION QmitkSegmentationPreferencePage : public QObject, public berry::IQtPreferencePage
{
Q_OBJECT
Q_INTERFACES(berry::IPreferencePage)
public:
QmitkSegmentationPreferencePage();
~QmitkSegmentationPreferencePage();
void Init(berry::IWorkbench::Pointer workbench);
void CreateQtControl(QWidget* widget);
QWidget* GetQtControl() const;
///
/// \see IPreferencePage::PerformOk()
///
virtual bool PerformOk();
///
/// \see IPreferencePage::PerformCancel()
///
virtual void PerformCancel();
///
/// \see IPreferencePage::Update()
///
virtual void Update();
protected slots:
void OnVolumeRenderingCheckboxChecked(int);
void OnSmoothingCheckboxChecked(int);
protected:
QWidget* m_MainControl;
QRadioButton* m_RadioOutline;
QRadioButton* m_RadioOverlay;
QCheckBox* m_VolumeRenderingCheckBox;
QCheckBox* m_SmoothingCheckBox;
QDoubleSpinBox* m_SmoothingSpinBox;
QDoubleSpinBox* m_DecimationSpinBox;
QDoubleSpinBox* m_ClosingSpinBox;
+ QCheckBox* m_SelectionModeCheckBox;
bool m_Initializing;
berry::IPreferences::Pointer m_SegmentationPreferencesNode;
};
#endif /* QMITKDATAMANAGERPREFERENCEPAGE_H_ */
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkOtsuAction.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkOtsuAction.cpp
index afeeab8217..375c25e8f3 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkOtsuAction.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkOtsuAction.cpp
@@ -1,198 +1,197 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkOtsuAction.h"
// MITK
#include <itkOtsuMultipleThresholdsImageFilter.h>
#include <mitkRenderingManager.h>
#include <mitkImage.h>
#include <mitkImageCast.h>
#include <mitkITKImageImport.h>
#include <mitkLevelWindowProperty.h>
#include <mitkRenderingModeProperty.h>
#include <mitkLookupTable.h>
#include <mitkLookupTableProperty.h>
// ITK
#include <itkMultiplyImageFilter.h>
// Qt
#include <QDialog>
#include <QVBoxLayout>
#include <QApplication>
#include <QList>
#include <QLabel>
#include <QMessageBox>
using namespace berry;
using namespace mitk;
using namespace std;
QmitkOtsuAction::QmitkOtsuAction()
: m_OtsuSegmentationDialog(NULL)
{
}
QmitkOtsuAction::~QmitkOtsuAction()
{
}
void QmitkOtsuAction::Run(const QList<DataNode::Pointer> &selectedNodes)
{
this->m_DataNode = selectedNodes[0];
//this->m_selectedNodes = selectedNodes;
m_OtsuSegmentationDialog = new QDialog(QApplication::activeWindow(),Qt::WindowTitleHint | Qt::WindowSystemMenuHint);
QVBoxLayout *layout = new QVBoxLayout;
layout->setContentsMargins(0, 0, 0, 0);
QHBoxLayout* spinBoxLayout = new QHBoxLayout;
QHBoxLayout* buttonLayout = new QHBoxLayout;
m_OtsuSpinBox = new QSpinBox;
m_OtsuSpinBox->setRange(2, 32);
m_OtsuSpinBox->setValue(2);
m_OtsuPushButton = new QPushButton("OK");
QPushButton* CancelButton = new QPushButton("Cancel");
connect(m_OtsuPushButton, SIGNAL(clicked()), this, SLOT(OtsuSegmentationDone()));
connect(CancelButton, SIGNAL(clicked()), m_OtsuSegmentationDialog, SLOT(reject()));
QLabel* numberOfThresholdsLabel = new QLabel("Select number of Regions of Interest:");
numberOfThresholdsLabel->setAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
layout->addWidget(numberOfThresholdsLabel);
layout->addLayout(spinBoxLayout);
spinBoxLayout->addSpacing(50);
spinBoxLayout->addWidget(m_OtsuSpinBox);
spinBoxLayout->addSpacing(50);
layout->addLayout(buttonLayout);
buttonLayout->addWidget(m_OtsuPushButton);
buttonLayout->addWidget(CancelButton);
m_OtsuSegmentationDialog->setLayout(layout);
m_OtsuSegmentationDialog->setFixedSize(300, 80);
m_OtsuSegmentationDialog->open();
}
void QmitkOtsuAction::OtsuSegmentationDone()
{
this->PerformOtsuSegmentation();
m_OtsuSegmentationDialog->deleteLater();
m_OtsuSegmentationDialog = NULL;
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkOtsuAction::SetDataStorage(DataStorage *dataStorage)
{
m_DataStorage = dataStorage;
}
void QmitkOtsuAction::SetFunctionality(QtViewPart* /*functionality*/)
{
}
void QmitkOtsuAction::PerformOtsuSegmentation()
{
this->m_OtsuSegmentationDialog->setCursor(Qt::WaitCursor);
int numberOfThresholds = this->m_OtsuSpinBox->value() - 1;
int proceed;
QMessageBox* messageBox = new QMessageBox(QMessageBox::Question, NULL, "The otsu segmentation computation may take several minutes depending on the number of Regions you selected. Proceed anyway?", QMessageBox::Ok | QMessageBox::Cancel);
if (numberOfThresholds >= 5)
{
proceed = messageBox->exec();
if (proceed != QMessageBox::Ok) return;
}
mitk::Image::Pointer mitkImage = 0;
mitkImage = dynamic_cast<mitk::Image*>( this->m_DataNode->GetData() );
try
{
// get selected mitk image
const unsigned short dim = 3;
typedef short InputPixelType;
typedef unsigned char OutputPixelType;
typedef itk::Image< InputPixelType, dim > InputImageType;
typedef itk::Image< OutputPixelType, dim > OutputImageType;
typedef itk::OtsuMultipleThresholdsImageFilter< InputImageType, OutputImageType > FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetNumberOfThresholds(numberOfThresholds);
InputImageType::Pointer itkImage;
mitk::CastToItkImage(mitkImage, itkImage);
filter->SetInput( itkImage );
filter->Update();
mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
std::string nameOfResultImage = this->m_DataNode->GetName();
nameOfResultImage.append("Otsu");
resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
resultNode->SetProperty("binary", mitk::BoolProperty::New(false) );
-
mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
renderingMode->SetValue( mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR );
resultNode->SetProperty("Image Rendering.Mode", renderingMode);
mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
mitk::LookupTableProperty::Pointer prop = mitk::LookupTableProperty::New(lut);
vtkLookupTable *lookupTable = vtkLookupTable::New();
lookupTable->SetHueRange(1.0, 0.0);
lookupTable->SetSaturationRange(1.0, 1.0);
lookupTable->SetValueRange(1.0, 1.0);
lookupTable->SetTableRange(-1.0, 1.0);
lookupTable->Build();
lut->SetVtkLookupTable(lookupTable);
prop->SetLookupTable(lut);
resultNode->SetProperty("LookupTable",prop);
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelwindow;
- levelwindow.SetRangeMinMax(0, numberOfThresholds + 1);
+ levelwindow.SetRangeMinMax(0, numberOfThresholds);
levWinProp->SetLevelWindow( levelwindow );
resultNode->SetProperty( "levelwindow", levWinProp );
resultNode->SetData( mitk::ImportItkImage ( filter->GetOutput() ) );
this->m_DataStorage->Add(resultNode, this->m_DataNode);
this->m_OtsuSegmentationDialog->setCursor(Qt::ArrowCursor);
}
catch( std::exception& err )
{
MITK_ERROR(this->GetClassName()) << err.what();
}
}
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationControls.ui b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationControls.ui
index 892e83065a..5150f403b5 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationControls.ui
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationControls.ui
@@ -1,729 +1,495 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkSegmentationControls</class>
<widget class="QWidget" name="QmitkSegmentationControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>246</width>
<height>591</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="font">
<font>
<family>MS Shell Dlg 2</family>
<pointsize>8</pointsize>
<weight>50</weight>
<italic>false</italic>
<bold>false</bold>
<underline>false</underline>
<strikeout>false</strikeout>
</font>
</property>
<property name="windowTitle">
<string>QmitkSegmentation</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_6">
<item>
<widget class="QGroupBox" name="groupBox">
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
- <widget class="QLabel" name="lblRefImage">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="minimumSize">
- <size>
- <width>0</width>
- <height>0</height>
- </size>
- </property>
- <property name="maximumSize">
- <size>
- <width>16777215</width>
- <height>16777215</height>
- </size>
- </property>
+ <widget class="QLabel" name="lblPatientImage">
<property name="text">
- <string>Reference image</string>
+ <string>Patient Image</string>
</property>
</widget>
</item>
<item>
- <widget class="QmitkDataStorageComboBox" name="refImageSelector">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="sizeAdjustPolicy">
- <enum>QComboBox::AdjustToMinimumContentsLength</enum>
- </property>
- </widget>
+ <widget class="QmitkDataStorageComboBox" name="patImageSelector"/>
</item>
</layout>
</item>
- <item>
- <widget class="QLabel" name="lblReferenceImageSelectionWarning">
- <property name="palette">
- <palette>
- <active>
- <colorrole role="WindowText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="Text">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="ButtonText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- </active>
- <inactive>
- <colorrole role="WindowText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="Text">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="ButtonText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- </inactive>
- <disabled>
- <colorrole role="WindowText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>84</red>
- <green>82</green>
- <blue>78</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="Text">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>84</red>
- <green>82</green>
- <blue>78</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="ButtonText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>84</red>
- <green>82</green>
- <blue>78</blue>
- </color>
- </brush>
- </colorrole>
- </disabled>
- </palette>
- </property>
- <property name="font">
- <font>
- <weight>50</weight>
- <bold>false</bold>
- </font>
- </property>
- <property name="text">
- <string>Please load an image!</string>
- </property>
- </widget>
- </item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
- <widget class="QLabel" name="lblSegImage">
+ <widget class="QLabel" name="lblSegmentation">
<property name="text">
- <string>Segmentation image</string>
+ <string>Segmentation</string>
</property>
</widget>
</item>
<item>
- <widget class="QLabel" name="lblSegmentation">
- <property name="text">
- <string/>
- </property>
- </widget>
+ <widget class="QmitkDataStorageComboBox" name="segImageSelector"/>
</item>
</layout>
</item>
</layout>
</widget>
</item>
+ <item>
+ <widget class="QLabel" name="lblSegmentationWarnings">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="palette">
+ <palette>
+ <active>
+ <colorrole role="WindowText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>200</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Text">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>200</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ButtonText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>200</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ </active>
+ <inactive>
+ <colorrole role="WindowText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>200</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Text">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>200</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ButtonText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>200</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ </inactive>
+ <disabled>
+ <colorrole role="WindowText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>84</red>
+ <green>82</green>
+ <blue>78</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Text">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>84</red>
+ <green>82</green>
+ <blue>78</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ButtonText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>84</red>
+ <green>82</green>
+ <blue>78</blue>
+ </color>
+ </brush>
+ </colorrole>
+ </disabled>
+ </palette>
+ </property>
+ <property name="font">
+ <font>
+ <weight>50</weight>
+ <bold>false</bold>
+ </font>
+ </property>
+ <property name="text">
+ <string>Please load an image!</string>
+ </property>
+ </widget>
+ </item>
<item>
<widget class="QToolBox" name="widgetStack">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="pageManual">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>259</width>
- <height>316</height>
+ <width>222</width>
+ <height>323</height>
</rect>
</property>
<attribute name="icon">
<iconset resource="../../resources/segmentation.qrc">
<normaloff>:/segmentation/segmentation.png</normaloff>:/segmentation/segmentation.png</iconset>
</attribute>
<attribute name="label">
<string>Contouring</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="leftMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
- <item>
- <widget class="QLabel" name="lblAlignmentWarning">
- <property name="palette">
- <palette>
- <active>
- <colorrole role="WindowText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="Text">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="ButtonText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- </active>
- <inactive>
- <colorrole role="WindowText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="Text">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="ButtonText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- </inactive>
- <disabled>
- <colorrole role="WindowText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>84</red>
- <green>82</green>
- <blue>78</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="Text">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>84</red>
- <green>82</green>
- <blue>78</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="ButtonText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>84</red>
- <green>82</green>
- <blue>78</blue>
- </color>
- </brush>
- </colorrole>
- </disabled>
- </palette>
- </property>
- <property name="font">
- <font>
- <weight>50</weight>
- <bold>false</bold>
- </font>
- </property>
- <property name="text">
- <string>You are now working with rotated planes</string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QLabel" name="lblWorkingImageSelectionWarning">
- <property name="palette">
- <palette>
- <active>
- <colorrole role="WindowText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="Text">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="ButtonText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- </active>
- <inactive>
- <colorrole role="WindowText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="Text">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="ButtonText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>200</red>
- <green>0</green>
- <blue>0</blue>
- </color>
- </brush>
- </colorrole>
- </inactive>
- <disabled>
- <colorrole role="WindowText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>84</red>
- <green>82</green>
- <blue>78</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="Text">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>84</red>
- <green>82</green>
- <blue>78</blue>
- </color>
- </brush>
- </colorrole>
- <colorrole role="ButtonText">
- <brush brushstyle="SolidPattern">
- <color alpha="255">
- <red>84</red>
- <green>82</green>
- <blue>78</blue>
- </color>
- </brush>
- </colorrole>
- </disabled>
- </palette>
- </property>
- <property name="font">
- <font>
- <weight>50</weight>
- <bold>false</bold>
- </font>
- </property>
- <property name="text">
- <string>Select or create a segmentation!</string>
- </property>
- </widget>
- </item>
<item>
<widget class="QToolButton" name="btnNewSegmentation">
<property name="enabled">
<bool>false</bool>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Fixed">
<horstretch>1</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
<property name="toolTip">
<string>New segmentation</string>
</property>
<property name="text">
<string>New segmentation</string>
</property>
<property name="icon">
<iconset resource="../../resources/segmentation.qrc">
<normaloff>:/segmentation/btnNew.png</normaloff>:/segmentation/btnNew.png</iconset>
</property>
<property name="toolButtonStyle">
<enum>Qt::ToolButtonTextBesideIcon</enum>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="lblManualTools">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Editing tools</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkToolSelectionBox" name="m_ManualToolSelectionBox" native="true">
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<widget class="QmitkToolGUIArea" name="m_ManualToolGUIContainer" native="true">
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<widget class="QmitkSlicesInterpolator" name="m_SlicesInterpolator" native="true">
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="pageOrgans">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>98</width>
- <height>44</height>
+ <width>222</width>
+ <height>323</height>
</rect>
</property>
<attribute name="label">
<string>Organs</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_2">
<property name="leftMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<item>
<widget class="QmitkToolSelectionBox" name="m_OrganToolSelectionBox" native="true">
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<widget class="QmitkToolGUIArea" name="m_OrganToolGUIContainer" native="true">
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="pageLesions">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>98</width>
- <height>44</height>
+ <width>222</width>
+ <height>323</height>
</rect>
</property>
<attribute name="label">
<string>Lesions</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_4">
<property name="leftMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<item>
<widget class="QmitkToolSelectionBox" name="m_LesionToolSelectionBox" native="true">
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<widget class="QmitkToolGUIArea" name="m_LesionToolGUIContainer" native="true">
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer_3">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="SurfaceMasking">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>273</width>
- <height>116</height>
+ <height>308</height>
</rect>
</property>
<attribute name="label">
<string>Surface Masking</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_5">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Select Surface For Image Masking:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkDataStorageComboBox" name="MaskSurfaces"/>
</item>
<item>
<widget class="QPushButton" name="CreateSegmentationFromSurface">
<property name="enabled">
<bool>false</bool>
</property>
<property name="toolTip">
<string/>
</property>
<property name="text">
<string>Create Segmentation From Surface</string>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer_4">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
<customwidget>
<class>QmitkDataStorageComboBox</class>
<extends>QComboBox</extends>
<header location="global">QmitkDataStorageComboBox.h</header>
</customwidget>
<customwidget>
<class>QmitkToolSelectionBox</class>
<extends>QWidget</extends>
<header location="global">QmitkToolSelectionBox.h</header>
</customwidget>
<customwidget>
<class>QmitkSlicesInterpolator</class>
<extends>QWidget</extends>
<header location="global">QmitkSlicesInterpolator.h</header>
</customwidget>
<customwidget>
<class>QmitkToolGUIArea</class>
<extends>QWidget</extends>
<header location="global">QmitkToolGUIArea.h</header>
</customwidget>
</customwidgets>
<includes>
<include location="global">QmitkToolReferenceDataSelectionBox.h</include>
<include location="global">QmitkToolGUIArea.h</include>
<include location="global">QmitkToolSelectionBox.h</include>
<include location="global">QmitkSlicesInterpolator.h</include>
</includes>
<resources>
<include location="../../resources/segmentation.qrc"/>
</resources>
<connections/>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index e0410c695d..5e5846604d 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,1252 +1,1044 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#include "mitkDataNodeObject.h"
#include "mitkProperties.h"
#include "mitkSegTool2D.h"
-#include "mitkGlobalInteraction.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkNewSegmentationDialog.h"
#include <QMessageBox>
#include <berryIWorkbenchPage.h>
#include "QmitkSegmentationView.h"
-#include "QmitkSegmentationPostProcessing.h"
#include "QmitkSegmentationOrganNamesHandling.cpp"
#include <mitkSurfaceToImageFilter.h>
-#include <vtkPolyData.h>
-//For Segmentation in rotated slices
-//TODO clean up includes
#include "mitkVtkResliceInterpolationProperty.h"
-#include "mitkPlanarCircle.h"
#include "mitkGetModuleContext.h"
#include "mitkModule.h"
#include "mitkModuleRegistry.h"
#include "mitkSegmentationObjectFactory.h"
const std::string QmitkSegmentationView::VIEW_ID =
-"org.mitk.views.segmentation";
+ "org.mitk.views.segmentation";
// public methods
QmitkSegmentationView::QmitkSegmentationView()
:m_Parent(NULL)
,m_Controls(NULL)
,m_MultiWidget(NULL)
-,m_RenderingManagerObserverTag(0)
,m_DataSelectionChanged(false)
{
RegisterSegmentationObjectFactory();
+ mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
+ mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
+ mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
+ mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
+ isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
+ m_IsOfTypeImagePredicate = mitk::NodePredicateOr::New(isDiffusionImage, mitk::TNodePredicateDataType<mitk::Image>::New());
+
+ m_IsBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
+ m_IsNotBinaryPredicate = mitk::NodePredicateNot::New( m_IsBinaryPredicate );
+
+ m_IsNotABinaryImagePredicate = mitk::NodePredicateAnd::New( m_IsOfTypeImagePredicate, m_IsNotBinaryPredicate );
+ m_IsABinaryImagePredicate = mitk::NodePredicateAnd::New( m_IsOfTypeImagePredicate, m_IsBinaryPredicate);
}
QmitkSegmentationView::~QmitkSegmentationView()
{
- // delete m_PostProcessing;
delete m_Controls;
}
void QmitkSegmentationView::NewNodesGenerated()
{
-// ForceDisplayPreferencesUponAllImages();
+ MITK_WARN<<"Use of deprecated function: NewNodesGenerated!! This function is empty and will be removed in the next time!";
}
void QmitkSegmentationView::NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType* nodes)
{
if (!nodes) return;
mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
if (!toolManager) return;
for (mitk::ToolManager::DataVectorType::iterator iter = nodes->begin(); iter != nodes->end(); ++iter)
{
this->FireNodeSelected( *iter );
// only last iteration meaningful, multiple generated objects are not taken into account here
}
}
void QmitkSegmentationView::Visible()
{
if (m_DataSelectionChanged)
{
this->OnSelectionChanged(this->GetDataManagerSelection());
}
}
void QmitkSegmentationView::Activated()
{
// should be moved to ::BecomesVisible() or similar
if( m_Controls )
{
m_Controls->m_ManualToolSelectionBox->setEnabled( true );
m_Controls->m_OrganToolSelectionBox->setEnabled( true );
m_Controls->m_LesionToolSelectionBox->setEnabled( true );
m_Controls->m_SlicesInterpolator->Enable3DInterpolation( m_Controls->widgetStack->currentWidget() == m_Controls->pageManual );
- //TODO Remove Observer
- itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command1 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
- command1->SetCallbackFunction( this, &QmitkSegmentationView::RenderingManagerReinitialized );
- m_RenderingManagerObserverTag = mitk::RenderingManager::GetInstance()->AddObserver( mitk::RenderingManagerViewsInitializedEvent(), command1 );
-
- //Adding observers for node visibility to existing segmentations
- mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
- mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
- mitk::NodePredicateAnd::Pointer isSegmentation = mitk::NodePredicateAnd::New( isImage, isBinary );
- mitk::DataStorage::SetOfObjects::ConstPointer segmentations = this->GetDefaultDataStorage()->GetSubset( isSegmentation );
+ mitk::DataStorage::SetOfObjects::ConstPointer segmentations = this->GetDefaultDataStorage()->GetSubset( m_IsABinaryImagePredicate );
- mitk::DataStorage::SetOfObjects::ConstPointer image = this->GetDefaultDataStorage()->GetSubset( isImage );
+ mitk::DataStorage::SetOfObjects::ConstPointer image = this->GetDefaultDataStorage()->GetSubset( m_IsNotABinaryImagePredicate );
if (!image->empty()) {
OnSelectionChanged(*image->begin());
}
+
for ( mitk::DataStorage::SetOfObjects::const_iterator iter = segmentations->begin();
- iter != segmentations->end();
- ++iter)
+ iter != segmentations->end();
+ ++iter)
{
- mitk::DataNode* node = *iter;
- itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
- command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
- m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( node, node->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
- }
+ mitk::DataNode* node = *iter;
+ itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
+ command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
+ m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( node, node->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
- if(segmentations->Size() > 0)
- {
- FireNodeSelected(segmentations->ElementAt(0));
- segmentations->ElementAt(0)->GetProperty("visible")->Modified();
+ itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
+ command2->SetCallbackFunction(this, &QmitkSegmentationView::OnBinaryPropertyChanged);
+ m_BinaryPropertyObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( node, node->GetProperty("binary")->AddObserver( itk::ModifiedEvent(), command2 ) ) );
}
}
+ this->SetToolManagerSelection(m_Controls->patImageSelector->GetSelectedNode(), m_Controls->segImageSelector->GetSelectedNode());
}
void QmitkSegmentationView::Deactivated()
{
if( m_Controls )
{
- mitk::RenderingManager::GetInstance()->RemoveObserver( m_RenderingManagerObserverTag );
m_Controls->m_ManualToolSelectionBox->setEnabled( false );
//deactivate all tools
m_Controls->m_ManualToolSelectionBox->GetToolManager()->ActivateTool(-1);
m_Controls->m_OrganToolSelectionBox->setEnabled( false );
m_Controls->m_LesionToolSelectionBox->setEnabled( false );
m_Controls->m_SlicesInterpolator->EnableInterpolation( false );
//Removing all observers
for ( NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter )
{
(*dataIter).first->GetProperty("visible")->RemoveObserver( (*dataIter).second );
}
m_WorkingDataObserverTags.clear();
- if (m_MultiWidget)
+ for ( NodeTagMapType::iterator dataIter = m_BinaryPropertyObserverTags.begin(); dataIter != m_BinaryPropertyObserverTags.end(); ++dataIter )
{
- mitk::SlicesCoordinator *coordinator = m_MultiWidget->GetSlicesRotator();
-
- if (coordinator)
- coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
-
- coordinator = m_MultiWidget->GetSlicesSwiveller();
-
- if (coordinator)
- coordinator->RemoveObserver(m_SlicesRotationObserverTag2);
-
+ (*dataIter).first->GetProperty("binary")->RemoveObserver( (*dataIter).second );
}
+ m_BinaryPropertyObserverTags.clear();
// gets the context of the "Mitk" (Core) module (always has id 1)
- // TODO Workaround until CTL plugincontext is available
+ // TODO Workaround until CTK plugincontext is available
mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
// Workaround end
mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
- //mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
service->RemoveAllPlanePositions();
}
}
void QmitkSegmentationView::StdMultiWidgetAvailable( QmitkStdMultiWidget& stdMultiWidget )
{
SetMultiWidget(&stdMultiWidget);
}
void QmitkSegmentationView::StdMultiWidgetNotAvailable()
{
SetMultiWidget(NULL);
}
void QmitkSegmentationView::StdMultiWidgetClosed( QmitkStdMultiWidget& /*stdMultiWidget*/ )
{
SetMultiWidget(NULL);
}
void QmitkSegmentationView::SetMultiWidget(QmitkStdMultiWidget* multiWidget)
{
- if (m_MultiWidget)
- {
- mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
- if (coordinator)
- {
- coordinator->RemoveObserver( m_SlicesRotationObserverTag1 );
- }
- coordinator = m_MultiWidget->GetSlicesSwiveller();
- if (coordinator)
- {
- coordinator->RemoveObserver( m_SlicesRotationObserverTag2 );
- }
- }
-
// save the current multiwidget as the working widget
m_MultiWidget = multiWidget;
- //TODO Remove Observers
- if (m_MultiWidget)
- {
- mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
- if (coordinator)
- {
- itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
- command2->SetCallbackFunction( this, &QmitkSegmentationView::SliceRotation );
- m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
- }
-
- coordinator = m_MultiWidget->GetSlicesSwiveller();
- if (coordinator)
- {
- itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
- command2->SetCallbackFunction( this, &QmitkSegmentationView::SliceRotation );
- m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
- }
- }
- //TODO End Remove Observers
-
if (m_Parent)
{
m_Parent->setEnabled(m_MultiWidget);
}
// tell the interpolation about toolmanager and multiwidget (and data storage)
if (m_Controls && m_MultiWidget)
{
mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
m_Controls->m_SlicesInterpolator->SetDataStorage( *(this->GetDefaultDataStorage()));
m_Controls->m_SlicesInterpolator->Initialize( toolManager, m_MultiWidget );
}
}
-void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences*)
-{
- ForceDisplayPreferencesUponAllImages();
-}
-
-//TODO remove function
-void QmitkSegmentationView::RenderingManagerReinitialized(const itk::EventObject&)
-{
- CheckImageAlignment();
-}
-
-//TODO remove function
-void QmitkSegmentationView::SliceRotation(const itk::EventObject&)
+void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
{
- CheckImageAlignment();
+ m_AutoSelectionEnabled = prefs->GetBool("auto selection", false);
}
-
-// protected slots
-
void QmitkSegmentationView::CreateNewSegmentation()
{
mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
if (node.IsNotNull())
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
if (image.IsNotNull())
{
if (image->GetDimension()>1)
{
// ask about the name and organ type of the new segmentation
QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog( m_Parent ); // needs a QWidget as parent, "this" is not QWidget
QString storedList = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
QStringList organColors;
if (storedList.isEmpty())
{
organColors = GetDefaultOrganColorString();
}
else
{
/*
a couple of examples of how organ names are stored:
a simple item is built up like 'name#AABBCC' where #AABBCC is the hexadecimal notation of a color as known from HTML
items are stored separated by ';'
this makes it necessary to escape occurrences of ';' in name.
otherwise the string "hugo;ypsilon#AABBCC;eugen#AABBCC" could not be parsed as two organs
but we would get "hugo" and "ypsilon#AABBCC" and "eugen#AABBCC"
so the organ name "hugo;ypsilon" is stored as "hugo\;ypsilon"
and must be unescaped after loading
the following lines could be one split with Perl's negative lookbehind
*/
// recover string list from BlueBerry view's preferences
QString storedString = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
MITK_DEBUG << "storedString: " << storedString.toStdString();
// match a string consisting of any number of repetitions of either "anything but ;" or "\;". This matches everything until the next unescaped ';'
QRegExp onePart("(?:[^;]|\\\\;)*");
MITK_DEBUG << "matching " << onePart.pattern().toStdString();
int count = 0;
int pos = 0;
while( (pos = onePart.indexIn( storedString, pos )) != -1 )
{
++count;
int length = onePart.matchedLength();
if (length == 0) break;
QString matchedString = storedString.mid(pos, length);
MITK_DEBUG << " Captured length " << length << ": " << matchedString.toStdString();
pos += length + 1; // skip separating ';'
// unescape possible occurrences of '\;' in the string
matchedString.replace("\\;", ";");
// add matched string part to output list
organColors << matchedString;
}
- MITK_DEBUG << "Captured " << count << " organ name/colors";
- }
+ MITK_DEBUG << "Captured " << count << " organ name/colors";
+ }
- dialog->SetSuggestionList( organColors );
+ dialog->SetSuggestionList( organColors );
- int dialogReturnValue = dialog->exec();
+ int dialogReturnValue = dialog->exec();
- if ( dialogReturnValue == QDialog::Rejected ) return; // user clicked cancel or pressed Esc or something similar
+ if ( dialogReturnValue == QDialog::Rejected ) return; // user clicked cancel or pressed Esc or something similar
- // ask the user about an organ type and name, add this information to the image's (!) propertylist
- // create a new image of the same dimensions and smallest possible pixel type
- mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
- mitk::Tool* firstTool = toolManager->GetToolById(0);
- if (firstTool)
- {
- try
- {
- mitk::DataNode::Pointer emptySegmentation =
- firstTool->CreateEmptySegmentationNode( image, dialog->GetSegmentationName().toStdString(), dialog->GetColor() );
+ // ask the user about an organ type and name, add this information to the image's (!) propertylist
+ // create a new image of the same dimensions and smallest possible pixel type
+ mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
+ mitk::Tool* firstTool = toolManager->GetToolById(0);
+ if (firstTool)
+ {
+ try
+ {
+ mitk::DataNode::Pointer emptySegmentation =
+ firstTool->CreateEmptySegmentationNode( image, dialog->GetSegmentationName().toStdString(), dialog->GetColor() );
- //Here we change the reslice interpolation mode for a segmentation, so that contours in rotated slice can be shown correctly
- emptySegmentation->SetProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_NEAREST) );
- // initialize showVolume to false to prevent recalculating the volume while working on the segmentation
- emptySegmentation->SetProperty( "showVolume", mitk::BoolProperty::New( false ) );
+ //Here we change the reslice interpolation mode for a segmentation, so that contours in rotated slice can be shown correctly
+ emptySegmentation->SetProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_NEAREST) );
+ // initialize showVolume to false to prevent recalculating the volume while working on the segmentation
+ emptySegmentation->SetProperty( "showVolume", mitk::BoolProperty::New( false ) );
- if (!emptySegmentation) return; // could be aborted by user
+ if (!emptySegmentation) return; // could be aborted by user
- UpdateOrganList( organColors, dialog->GetSegmentationName(), dialog->GetColor() );
+ UpdateOrganList( organColors, dialog->GetSegmentationName(), dialog->GetColor() );
- /*
- escape ';' here (replace by '\;'), see longer comment above
- */
+ /*
+ escape ';' here (replace by '\;'), see longer comment above
+ */
std::string stringForStorage = organColors.replaceInStrings(";","\\;").join(";").toStdString();
MITK_DEBUG << "Will store: " << stringForStorage;
this->GetPreferences()->PutByteArray("Organ-Color-List", stringForStorage );
this->GetPreferences()->Flush();
if(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0))
{
m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0)->SetSelected(false);
}
emptySegmentation->SetSelected(true);
this->GetDefaultDataStorage()->Add( emptySegmentation, node ); // add as a child, because the segmentation "derives" from the original
+ itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
+ command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
+ m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( emptySegmentation, emptySegmentation->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
+
+ itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
+ command2->SetCallbackFunction(this, &QmitkSegmentationView::OnBinaryPropertyChanged);
+ m_BinaryPropertyObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( emptySegmentation, emptySegmentation->GetProperty("binary")->AddObserver( itk::ModifiedEvent(), command2 ) ) );
+
+ this->ApplyDisplayOptions( emptySegmentation );
this->FireNodeSelected( emptySegmentation );
this->OnSelectionChanged( emptySegmentation );
- this->SetToolManagerSelection(node, emptySegmentation);
+// m_Controls->segImageSelector->show();
}
catch (std::bad_alloc)
{
QMessageBox::warning(NULL,"Create new segmentation","Could not allocate memory for new segmentation");
}
}
}
else
{
QMessageBox::information(NULL,"Segmentation","Segmentation is currently not supported for 2D images");
}
}
}
else
{
MITK_ERROR << "'Create new segmentation' button should never be clickable unless a patient image is selected...";
}
}
-void QmitkSegmentationView::OnWorkingNodeVisibilityChanged(/*const itk::Object* caller, const itk::EventObject& e*/)
+void QmitkSegmentationView::OnWorkingNodeVisibilityChanged()
{
- if (!m_Parent || !m_Parent->isVisible()) return;
-
- // The new selection behaviour is:
- //
- // When clicking on the checkbox of a segmentation the node will e selected and its reference node either
- // The previous selected segmentation (if there is one) will be deselected. Additionally a reinit on the
- // selected segmenation will be performed.
- // If more than one segmentation is selected the tools will be disabled.
-
- if (!m_Controls) return; // might happen on initialization (preferences loaded)
- mitk::DataNode::Pointer referenceDataNew;
- mitk::DataNode::Pointer workingData;
-
- bool workingNodeIsVisible (true);
+ m_Controls->m_ManualToolSelectionBox->setEnabled(false);
+ if (!m_Controls->m_ManualToolSelectionBox->isEnabled())
+ {
+ this->UpdateWarningLabel("The selected segmentation is currently not visible!");
+ }
+ else
+ {
+ this->UpdateWarningLabel("");
+ }
+}
- unsigned int numberOfSelectedSegmentations (0);
+void QmitkSegmentationView::OnBinaryPropertyChanged()
+{
+ mitk::DataStorage::SetOfObjects::ConstPointer patImages = m_Controls->patImageSelector->GetNodes();
- // iterate all images
- mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
+ bool isBinary(false);
- mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDefaultDataStorage()->GetSubset( isImage );
- for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin();
- iter != allImages->end();
- ++iter)
+ for (mitk::DataStorage::SetOfObjects::ConstIterator it = patImages->Begin(); it != patImages->End(); ++it)
{
- mitk::DataNode* node = *iter;
- // apply display preferences
- ApplyDisplayOptions(node);
+ const mitk::DataNode* node = it->Value();
+ node->GetBoolProperty("binary", isBinary);
- bool isSegmentation(false);
- node->GetBoolProperty("binary", isSegmentation);
- if (node->IsSelected() && isSegmentation)
+ if(isBinary)
{
- workingNodeIsVisible = node->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
- if (!workingNodeIsVisible)
- return;
- numberOfSelectedSegmentations++;
-
- workingData = node;
-
- if (this->GetDefaultDataStorage()->GetSources(node)->Size() != 0)
- {
- referenceDataNew = this->GetDefaultDataStorage()->GetSources(node)->ElementAt(0);
- }
-
- bool isBinary(false);
-
- //Find topmost source or first source which is no binary image
- while (referenceDataNew.IsNotNull() && this->GetDefaultDataStorage()->GetSources(referenceDataNew)->Size() != 0)
- {
- referenceDataNew = this->GetDefaultDataStorage()->GetSources(referenceDataNew)->ElementAt(0);
-
- referenceDataNew->GetBoolProperty("binary",isBinary);
- if (!isBinary)
- break;
- }
-
- if (workingNodeIsVisible && referenceDataNew)
- {
- //Since the binary property of a segmentation can be set to false and afterwards you can create a new segmentation out of it
- //->could lead to a deadloop
- NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( referenceDataNew );
- if ( searchIter != m_WorkingDataObserverTags.end())
- {
- referenceDataNew->GetProperty("visible")->RemoveObserver( (*searchIter).second );
- }
- referenceDataNew->SetVisibility(true);
- }
+ m_Controls->patImageSelector->RemoveNode(node);
+ m_Controls->segImageSelector->AddNode(node);
+ this->SetToolManagerSelection(NULL,NULL);
+ return;
+ }
+ }
- //set comboBox to reference image
- disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
- this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
+ mitk::DataStorage::SetOfObjects::ConstPointer segImages = m_Controls->segImageSelector->GetNodes();
- m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(referenceDataNew) );
+ isBinary = true;
- connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
- this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
+ for (mitk::DataStorage::SetOfObjects::ConstIterator it = segImages->Begin(); it != segImages->End(); ++it)
+ {
+ const mitk::DataNode* node = it->Value();
+ node->GetBoolProperty("binary", isBinary);
- continue;
- }
- if (workingData.IsNull() || (workingNodeIsVisible && node != referenceDataNew))
+ if(!isBinary)
{
- node->SetVisibility((false));
+ m_Controls->segImageSelector->RemoveNode(node);
+ m_Controls->patImageSelector->AddNode(node);
+ if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0) == node)
+ m_Controls->m_ManualToolSelectionBox->GetToolManager()->SetWorkingData(NULL);
+ return;
}
}
+}
- if(numberOfSelectedSegmentations == 1)
- SetToolManagerSelection(referenceDataNew, workingData);
-
- mitk::DataStorage::SetOfObjects::Pointer temp = mitk::DataStorage::SetOfObjects::New();
- temp->InsertElement(0,workingData);
- mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(temp);
-
+void QmitkSegmentationView::NodeAdded(const mitk::DataNode *node)
+{
+ bool isBinary (false);
+ bool isHelperObject (false);
+ node->GetBoolProperty("binary", isBinary);
+ node->GetBoolProperty("helper object", isHelperObject);
+ if (m_AutoSelectionEnabled)
+ {
+ if (!isBinary && dynamic_cast<mitk::Image*>(node->GetData()))
+ {
+ FireNodeSelected(const_cast<mitk::DataNode*>(node));
+ }
+ }
+ if (isBinary && !isHelperObject)
+ {
+ itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
+ command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
+ m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( const_cast<mitk::DataNode*>(node), node->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
- // Reinit current node
- ForceDisplayPreferencesUponAllImages();
+ itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
+ command2->SetCallbackFunction(this, &QmitkSegmentationView::OnBinaryPropertyChanged);
+ m_BinaryPropertyObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( const_cast<mitk::DataNode*>(node), node->GetProperty("binary")->AddObserver( itk::ModifiedEvent(), command2 ) ) );
- // initialize the views to the bounding geometry
- /*mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();*/
+ this->ApplyDisplayOptions( const_cast<mitk::DataNode*>(node) );
+ }
}
void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
{
bool isSeg(false);
bool isHelperObject(false);
node->GetBoolProperty("helper object", isHelperObject);
node->GetBoolProperty("binary", isSeg);
mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
if(isSeg && !isHelperObject && image)
{
+ //First of all remove all possible contour markers of the segmentation
mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(node, mitk::NodePredicateProperty::New("isContourMarker"
- , mitk::BoolProperty::New(true)));
+ , mitk::BoolProperty::New(true)));
// gets the context of the "Mitk" (Core) module (always has id 1)
- // TODO Workaround until CTL plugincontext is available
+ // TODO Workaround until CTK plugincontext is available
mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
// Workaround end
mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
- //mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
{
std::string nodeName = node->GetName();
unsigned int t = nodeName.find_last_of(" ");
unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
service->RemovePlanePosition(id);
this->GetDataStorage()->Remove(it->Value());
}
- mitk::DataNode* tempNode = const_cast<mitk::DataNode*>(node);
- node->GetProperty("visible")->RemoveObserver( m_WorkingDataObserverTags[tempNode] );
- m_WorkingDataObserverTags.erase(tempNode);
+
+ if ((m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0) == node) && m_Controls->patImageSelector->GetSelectedNode().IsNotNull())
+ {
+ this->SetToolManagerSelection(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0), NULL);
+ this->UpdateWarningLabel("Select or create a segmentation!");
+ }
mitk::SurfaceInterpolationController::GetInstance()->RemoveSegmentationFromContourList(image);
}
+ mitk::DataNode* tempNode = const_cast<mitk::DataNode*>(node);
+ //Since the binary property could be changed during runtime by the user
+ if (image && !isHelperObject)
+ {
+ node->GetProperty("visible")->RemoveObserver( m_WorkingDataObserverTags[tempNode] );
+ m_WorkingDataObserverTags.erase(tempNode);
+ node->GetProperty("binary")->RemoveObserver( m_BinaryPropertyObserverTags[tempNode] );
+ m_BinaryPropertyObserverTags.erase(tempNode);
+ }
- if((m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0) == node)||
- (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0) == node))
+ if((m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0) == node))
{
- //as we don't know which node was actually remove e.g. our reference node, disable 'New Segmentation' button.
- //consider the case that there is no more image in the datastorage
+ //as we don't know which node was actually removed e.g. our reference node, disable 'New Segmentation' button.
+ //consider the case that there is no more image in the datastorage
this->SetToolManagerSelection(NULL, NULL);
}
}
void QmitkSegmentationView::CreateSegmentationFromSurface()
{
mitk::DataNode::Pointer surfaceNode =
- m_Controls->MaskSurfaces->GetSelectedNode();
+ m_Controls->MaskSurfaces->GetSelectedNode();
mitk::Surface::Pointer surface(0);
if(surfaceNode.IsNotNull())
surface = dynamic_cast<mitk::Surface*> ( surfaceNode->GetData() );
if(surface.IsNull())
{
this->HandleException( "No surface selected.", m_Parent, true);
return;
}
mitk::DataNode::Pointer imageNode
- = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
+ = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
mitk::Image::Pointer image(0);
if (imageNode.IsNotNull())
image = dynamic_cast<mitk::Image*>( imageNode->GetData() );
if(image.IsNull())
{
this->HandleException( "No image selected.", m_Parent, true);
return;
}
mitk::SurfaceToImageFilter::Pointer s2iFilter
- = mitk::SurfaceToImageFilter::New();
+ = mitk::SurfaceToImageFilter::New();
s2iFilter->MakeOutputBinaryOn();
s2iFilter->SetInput(surface);
s2iFilter->SetImage(image);
s2iFilter->Update();
mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
std::string nameOfResultImage = imageNode->GetName();
nameOfResultImage.append(surfaceNode->GetName());
resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
resultNode->SetProperty("binary", mitk::BoolProperty::New(true) );
resultNode->SetData( s2iFilter->GetOutput() );
this->GetDataStorage()->Add(resultNode, imageNode);
}
void QmitkSegmentationView::ToolboxStackPageChanged(int id)
{
// interpolation only with manual tools visible
m_Controls->m_SlicesInterpolator->EnableInterpolation( id == 0 );
if( id == 0 )
{
mitk::DataNode::Pointer workingData = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0);
if( workingData.IsNotNull() )
{
- m_Controls->lblSegmentation->setText( workingData->GetName().c_str() );
- m_Controls->lblSegImage->show();
- m_Controls->lblSegmentation->show();
+ m_Controls->segImageSelector->setCurrentIndex( m_Controls->segImageSelector->Find(workingData) );
}
}
- else
- {
- m_Controls->lblSegImage->hide();
- m_Controls->lblSegmentation->hide();
- }
// this is just a workaround, should be removed when all tools support 3D+t
if (id==2) // lesions
{
mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
if (node.IsNotNull())
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
if (image.IsNotNull())
{
if (image->GetDimension()>3)
{
m_Controls->widgetStack->setCurrentIndex(0);
QMessageBox::information(NULL,"Segmentation","Lesion segmentation is currently not supported for 4D images");
}
}
}
}
}
// protected
-void QmitkSegmentationView::OnComboBoxSelectionChanged( const mitk::DataNode* node )
+void QmitkSegmentationView::OnPatientComboBoxSelectionChanged( const mitk::DataNode* node )
{
- mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
- if( selectedNode != NULL )
+ //mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
+ if( node != NULL )
{
- m_Controls->refImageSelector->show();
- m_Controls->lblReferenceImageSelectionWarning->hide();
-
- bool isBinary(false);
- selectedNode->GetBoolProperty("binary", isBinary);
- if ( isBinary )
+ this->UpdateWarningLabel("");
+ mitk::DataNode* segNode = m_Controls->segImageSelector->GetSelectedNode();
+ if (segNode)
{
- FireNodeSelected(selectedNode);
- selectedNode->SetVisibility(true);
- }
- else if (node != m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0))
- {
- if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0))
- m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0)->SetVisibility(false);
- if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0))
+ mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDefaultDataStorage()->GetSources( segNode, m_IsNotABinaryImagePredicate );
+ bool isSourceNode(false);
+
+ for (mitk::DataStorage::SetOfObjects::ConstIterator it = possibleParents->Begin(); it != possibleParents->End(); it++)
{
- m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0)->SetVisibility(false);
+ if (it.Value() == node)
+ isSourceNode = true;
+ }
+
+ if ( !isSourceNode && (!this->CheckForSameGeometry(segNode, node) || possibleParents->Size() > 0 ))
+ {
+ this->SetToolManagerSelection(node, NULL);
+ this->UpdateWarningLabel("The selected patient image does not\nmatch with the selected segmentation!");
+ }
+ else if ((!isSourceNode && this->CheckForSameGeometry(segNode, node)) || isSourceNode )
+ {
+ this->SetToolManagerSelection(node, segNode);
+ //Doing this we can assure that the segmenation is always visible if the segmentation and the patient image are
+ //loaded separately
+ int layer(10);
+ node->GetIntProperty("layer", layer);
+ layer++;
+ segNode->SetProperty("layer", mitk::IntProperty::New(layer));
+ this->UpdateWarningLabel("");
}
- FireNodeSelected(selectedNode);
- selectedNode->SetVisibility(true);
- SetToolManagerSelection(selectedNode, NULL);
+ }
+ else
+ {
+ this->SetToolManagerSelection(node, NULL);
+ this->UpdateWarningLabel("Select or create a segmentation");
}
}
else
{
- m_Controls->refImageSelector->hide();
- m_Controls->lblReferenceImageSelectionWarning->show();
+ this->UpdateWarningLabel("Please load an image!");
}
}
+void QmitkSegmentationView::OnSegmentationComboBoxSelectionChanged(const mitk::DataNode *node)
+{
+ if ( node == 0)
+ return;
+
+ mitk::DataNode* refNode = m_Controls->patImageSelector->GetSelectedNode();
+
+ if (m_AutoSelectionEnabled)
+ {
+ this->OnSelectionChanged(const_cast<mitk::DataNode*>(node));
+ }
+ else
+ {
+ mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDefaultDataStorage()->GetSources( node, m_IsNotABinaryImagePredicate );
+
+ if ( possibleParents->Size() == 1 )
+ {
+ mitk::DataNode* parentNode = possibleParents->ElementAt(0);
+
+ if (parentNode != refNode)
+ {
+ this->UpdateWarningLabel("The selected segmentation does not\nmatch with the selected patient image!");
+ this->SetToolManagerSelection(NULL, node);
+ }
+ else
+ {
+ this->UpdateWarningLabel("");
+ this->SetToolManagerSelection(refNode, node);
+ }
+
+ }
+ else if (refNode && this->CheckForSameGeometry(node, refNode))
+ {
+ this->UpdateWarningLabel("");
+ this->SetToolManagerSelection(refNode, node);
+ }
+ else if (!refNode || !this->CheckForSameGeometry(node, refNode))
+ {
+ this->UpdateWarningLabel("Please select or load the according patient image!");
+ }
+ }
+}
void QmitkSegmentationView::OnShowMarkerNodes (bool state)
{
mitk::SegTool2D::Pointer manualSegmentationTool;
unsigned int numberOfExistingTools = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetTools().size();
for(unsigned int i = 0; i < numberOfExistingTools; i++)
{
manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetToolById(i));
if (manualSegmentationTool)
{
if(state == true)
{
manualSegmentationTool->SetShowMarkerNodes( true );
}
else
{
manualSegmentationTool->SetShowMarkerNodes( false );
}
}
}
}
+
void QmitkSegmentationView::OnSelectionChanged(mitk::DataNode* node)
{
std::vector<mitk::DataNode*> nodes;
nodes.push_back( node );
this->OnSelectionChanged( nodes );
}
void QmitkSegmentationView::OnSurfaceSelectionChanged()
{
// if Image and Surface are selected, enable button
- if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
- (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
+ if ( (m_Controls->patImageSelector->GetSelectedNode().IsNull()) ||
+ (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
m_Controls->CreateSegmentationFromSurface->setEnabled(false);
else
m_Controls->CreateSegmentationFromSurface->setEnabled(true);
}
void QmitkSegmentationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
{
- // if the selected node is a contourmarker
- if ( !nodes.empty() )
+ if (m_AutoSelectionEnabled && this->IsActivated())
{
- std::string markerName = "Position";
- unsigned int numberOfNodes = nodes.size();
- std::string nodeName = nodes.at( 0 )->GetName();
- if ( ( numberOfNodes == 1 ) && ( nodeName.find( markerName ) == 0) )
+ if (nodes.size() == 0 && m_Controls->patImageSelector->GetSelectedNode().IsNull())
{
- this->OnContourMarkerSelected( nodes.at( 0 ) );
+ SetToolManagerSelection(NULL,NULL);
}
- }
-
- // if Image and Surface are selected, enable button
- if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
- (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
- m_Controls->CreateSegmentationFromSurface->setEnabled(false);
- else
- m_Controls->CreateSegmentationFromSurface->setEnabled(true);
-
- m_DataSelectionChanged = false;
- if (!m_Parent || !m_Parent->isVisible())
- {
- m_DataSelectionChanged = true;
- return;
- }
-
- // reaction to BlueBerry selection events
- // this method will try to figure out if a relevant segmentation and its corresponding original image were selected
- // a warning is issued if the selection is invalid
- // appropriate reactions are triggered otherwise
-
- mitk::DataNode::Pointer referenceData = FindFirstRegularImage( nodes ); //m_Controls->refImageSelector->GetSelectedNode(); //FindFirstRegularImage( nodes );
- mitk::DataNode::Pointer workingData = FindFirstSegmentation( nodes );
-
- if(referenceData.IsNull() && workingData.IsNull())
- return;
-
- bool invalidSelection( !nodes.empty() &&
- (
- nodes.size() > 2 || // maximum 2 selected nodes
- (nodes.size() == 2 && (workingData.IsNull() || referenceData.IsNull()) ) || // with two nodes, one must be the original image, one the segmentation
- ( workingData.GetPointer() == referenceData.GetPointer() ) //one node is selected as reference and working image
- // one item is always ok (might be working or reference or nothing
- )
- );
-
- if (invalidSelection)
- {
- // TODO visible warning when two images are selected
- MITK_ERROR << "WARNING: No image, too many (>2) or two equal images were selected.";
- workingData = NULL;
-
- if( m_Controls->refImageSelector->GetSelectedNode().IsNull() )
- referenceData = NULL;
- }
-
- if ( workingData.IsNotNull() && referenceData.IsNull() )
- {
- // find the DataStorage parent of workingData
- // try to find a "normal image" parent, select this as reference image
- mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
- mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
- mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
- mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
-
- mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDefaultDataStorage()->GetSources( workingData, isNormalImage );
-
- if (possibleParents->size() > 0)
+ else if (nodes.size() == 1)
{
- if (possibleParents->size() > 1)
+ mitk::DataNode::Pointer selectedNode = nodes.at(0);
+ if(selectedNode.IsNull())
{
- // TODO visible warning for this rare case
- MITK_ERROR << "Selected binary image has multiple parents. Using arbitrary first one for segmentation.";
+ return;
}
- referenceData = (*possibleParents)[0];
- }
+ std::string markerName = "Position";
+ unsigned int numberOfNodes = nodes.size();
+ std::string nodeName = nodes.at( 0 )->GetName();
+ if ( ( numberOfNodes == 1 ) && ( nodeName.find( markerName ) == 0) )
+ {
+ this->OnContourMarkerSelected( nodes.at( 0 ) );
+ return;
+ }
- NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( workingData );
- if ( searchIter == m_WorkingDataObserverTags.end() )
- {
- //MITK_INFO<<"Creating new observer";
- itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
- command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
- m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( workingData, workingData->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
- workingData->GetProperty("visible")->Modified();
+ mitk::Image::Pointer selectedImage = dynamic_cast<mitk::Image*>(selectedNode->GetData());
+ if (selectedImage.IsNull())
+ {
+ SetToolManagerSelection(NULL,NULL);
+ return;
+ }
+ else
+ {
+ bool isASegmentation(false);
+ selectedNode->GetBoolProperty("binary", isASegmentation);
- return;
- }
+ if (isASegmentation)
+ {
- if(workingData->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))))
- {
- //set comboBox to reference image
- disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
- this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
+ //If a segmentation is selected find a possible reference image:
+ mitk::DataStorage::SetOfObjects::ConstPointer sources = this->GetDataStorage()->GetSources(selectedNode, m_IsNotABinaryImagePredicate);
+ mitk::DataNode::Pointer refNode;
+ if (sources->Size() != 0)
+ {
+ refNode = sources->ElementAt(0);
- m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(workingData) );
+ refNode->SetVisibility(true);
+ selectedNode->SetVisibility(true);
+ SetToolManagerSelection(refNode,selectedNode);
- connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
- this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
+ mitk::DataStorage::SetOfObjects::ConstPointer otherSegmentations = this->GetDataStorage()->GetSubset(m_IsABinaryImagePredicate);
+ for(mitk::DataStorage::SetOfObjects::const_iterator iter = otherSegmentations->begin(); iter != otherSegmentations->end(); ++iter)
+ {
+ mitk::DataNode* node = *iter;
+ if (dynamic_cast<mitk::Image*>(node->GetData()) != selectedImage.GetPointer())
+ node->SetVisibility(false);
+ }
+ mitk::DataStorage::SetOfObjects::ConstPointer otherPatientImages = this->GetDataStorage()->GetSubset(m_IsNotABinaryImagePredicate);
+ for(mitk::DataStorage::SetOfObjects::const_iterator iter = otherPatientImages->begin(); iter != otherPatientImages->end(); ++iter)
+ {
+ mitk::DataNode* node = *iter;
+ if (dynamic_cast<mitk::Image*>(node->GetData()) != dynamic_cast<mitk::Image*>(refNode->GetData()))
+ node->SetVisibility(false);
+ }
+ }
+ else
+ {
+ mitk::DataStorage::SetOfObjects::ConstPointer possiblePatientImages = this->GetDataStorage()->GetSubset(m_IsNotABinaryImagePredicate);
- // if Image and Surface are selected, enable button
- if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
- (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()) ||
- (!referenceData))
- m_Controls->CreateSegmentationFromSurface->setEnabled(false);
- else
- m_Controls->CreateSegmentationFromSurface->setEnabled(true);
+ for (mitk::DataStorage::SetOfObjects::ConstIterator it = possiblePatientImages->Begin(); it != possiblePatientImages->End(); it++)
+ {
+ refNode = it->Value();
+
+ if (this->CheckForSameGeometry(selectedNode, it->Value()))
+ {
+ refNode->SetVisibility(true);
+ selectedNode->SetVisibility(true);
+
+ mitk::DataStorage::SetOfObjects::ConstPointer otherSegmentations = this->GetDataStorage()->GetSubset(m_IsABinaryImagePredicate);
+ for(mitk::DataStorage::SetOfObjects::const_iterator iter = otherSegmentations->begin(); iter != otherSegmentations->end(); ++iter)
+ {
+ mitk::DataNode* node = *iter;
+ if (dynamic_cast<mitk::Image*>(node->GetData()) != selectedImage.GetPointer())
+ node->SetVisibility(false);
+ }
+
+ mitk::DataStorage::SetOfObjects::ConstPointer otherPatientImages = this->GetDataStorage()->GetSubset(m_IsNotABinaryImagePredicate);
+ for(mitk::DataStorage::SetOfObjects::const_iterator iter = otherPatientImages->begin(); iter != otherPatientImages->end(); ++iter)
+ {
+ mitk::DataNode* node = *iter;
+ if (dynamic_cast<mitk::Image*>(node->GetData()) != dynamic_cast<mitk::Image*>(refNode->GetData()))
+ node->SetVisibility(false);
+ }
+ this->SetToolManagerSelection(refNode, selectedNode);
+
+ //Doing this we can assure that the segmenation is always visible if the segmentation and the patient image are at the
+ //same level in the datamanager
+ int layer(10);
+ refNode->GetIntProperty("layer", layer);
+ layer++;
+ selectedNode->SetProperty("layer", mitk::IntProperty::New(layer));
+ return;
+ }
+ }
+ this->SetToolManagerSelection(NULL, selectedNode);
- SetToolManagerSelection(referenceData, workingData);
- FireNodeSelected(workingData);
- }
- else
- {
- SetToolManagerSelection(NULL, NULL);
- FireNodeSelected(workingData);
+ }
+ }
+ else
+ {
+ if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0) != selectedNode)
+ {
+ SetToolManagerSelection(selectedNode, NULL);
+ //May be a bug in the selection services. A node which is deselected will be passed as selected node to the OnSelectionChanged function
+ if (!selectedNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))))
+ selectedNode->SetVisibility(true);
+ this->UpdateWarningLabel("The selected patient image does not\nmatchwith the selected segmentation!");
+ }
+ }
+ }
}
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
- else
- {
- //set comboBox to reference image
- disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
- this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
-
- m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(referenceData) );
-
- connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
- this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
-
- // if Image and Surface are selected, enable button
- if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
- (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()) ||
- (!referenceData))
- m_Controls->CreateSegmentationFromSurface->setEnabled(false);
- else
- m_Controls->CreateSegmentationFromSurface->setEnabled(true);
-
- SetToolManagerSelection(referenceData, workingData);
-
- FireNodeSelected(referenceData);
- }
}
void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode *node)
{
- //TODO renderWindow anders bestimmen, siehe CheckAlignment
QmitkRenderWindow* selectedRenderWindow = 0;
QmitkRenderWindow* RenderWindow1 =
- this->GetActiveStdMultiWidget()->GetRenderWindow1();
+ this->GetActiveStdMultiWidget()->GetRenderWindow1();
QmitkRenderWindow* RenderWindow2 =
- this->GetActiveStdMultiWidget()->GetRenderWindow2();
+ this->GetActiveStdMultiWidget()->GetRenderWindow2();
QmitkRenderWindow* RenderWindow3 =
- this->GetActiveStdMultiWidget()->GetRenderWindow3();
+ this->GetActiveStdMultiWidget()->GetRenderWindow3();
QmitkRenderWindow* RenderWindow4 =
- this->GetActiveStdMultiWidget()->GetRenderWindow4();
+ this->GetActiveStdMultiWidget()->GetRenderWindow4();
bool PlanarFigureInitializedWindow = false;
// find initialized renderwindow
if (node->GetBoolProperty("PlanarFigureInitializedWindow",
- PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
+ PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
{
selectedRenderWindow = RenderWindow1;
}
if (!selectedRenderWindow && node->GetBoolProperty(
- "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
- RenderWindow2->GetRenderer()))
+ "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
+ RenderWindow2->GetRenderer()))
{
selectedRenderWindow = RenderWindow2;
}
if (!selectedRenderWindow && node->GetBoolProperty(
- "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
- RenderWindow3->GetRenderer()))
+ "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
+ RenderWindow3->GetRenderer()))
{
selectedRenderWindow = RenderWindow3;
}
if (!selectedRenderWindow && node->GetBoolProperty(
- "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
- RenderWindow4->GetRenderer()))
+ "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
+ RenderWindow4->GetRenderer()))
{
selectedRenderWindow = RenderWindow4;
}
// make node visible
if (selectedRenderWindow)
{
std::string nodeName = node->GetName();
unsigned int t = nodeName.find_last_of(" ");
unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
// gets the context of the "Mitk" (Core) module (always has id 1)
// TODO Workaround until CTL plugincontext is available
mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
// Workaround end
mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
- //mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
selectedRenderWindow->GetRenderer()->GetDisplayGeometry()->Fit();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
-mitk::DataNode::Pointer QmitkSegmentationView::FindFirstRegularImage( std::vector<mitk::DataNode*> nodes )
-{
- if (nodes.empty()) return NULL;
-
- for(unsigned int i = 0; i < nodes.size(); ++i)
- {
- //mitk::DataNode::Pointer node = i.value()
- bool isImage(false);
- if (nodes.at(i)->GetData())
- {
- isImage = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData()) != NULL;
- }
-
- // make sure this is not a binary image
- bool isSegmentation(false);
- nodes.at(i)->GetBoolProperty("binary", isSegmentation);
-
- // return first proper mitk::Image
- if (isImage && !isSegmentation) return nodes.at(i);
- }
-
- return NULL;
-}
-
-
-mitk::DataNode::Pointer QmitkSegmentationView::FindFirstSegmentation( std::vector<mitk::DataNode*> nodes )
-{
- if (nodes.empty()) return NULL;
-
-
- for(unsigned int i = 0; i < nodes.size(); ++i)
- {
- bool isImage(false);
- if (nodes.at(i)->GetData())
- {
- isImage = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData()) != NULL;
- }
-
- bool isSegmentation(false);
- nodes.at(i)->GetBoolProperty("binary", isSegmentation);
-
- // return first proper binary mitk::Image
- if (isImage && isSegmentation)
- {
- return nodes.at(i);
- }
- }
-
- return NULL;
-}
-
void QmitkSegmentationView::SetToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData)
{
// called as a result of new BlueBerry selections
// tells the ToolManager for manual segmentation about new selections
// updates GUI information about what the user should select
mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
toolManager->SetReferenceData(const_cast<mitk::DataNode*>(referenceData));
toolManager->SetWorkingData( const_cast<mitk::DataNode*>(workingData));
// check original image
m_Controls->btnNewSegmentation->setEnabled(referenceData != NULL);
if (referenceData)
{
- m_Controls->lblReferenceImageSelectionWarning->hide();
- }
- else
- {
- m_Controls->lblReferenceImageSelectionWarning->show();
- m_Controls->lblWorkingImageSelectionWarning->hide();
- m_Controls->lblSegImage->hide();
- m_Controls->lblSegmentation->hide();
- }
+ this->UpdateWarningLabel("");
+ disconnect( m_Controls->patImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
+ this, SLOT( OnPatientComboBoxSelectionChanged( const mitk::DataNode* ) ) );
+
+ m_Controls->patImageSelector->setCurrentIndex( m_Controls->patImageSelector->Find(referenceData) );
- //TODO remove statement
- // check, wheter reference image is aligned like render windows. Otherwise display a visible warning (because 2D tools will probably not work)
- CheckImageAlignment();
+ connect( m_Controls->patImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
+ this, SLOT( OnPatientComboBoxSelectionChanged( const mitk::DataNode* ) ) );
+ }
// check segmentation
if (referenceData)
{
- if (!workingData)
- {
- m_Controls->lblWorkingImageSelectionWarning->show();
-
- if( m_Controls->widgetStack->currentIndex() == 0 )
- {
- m_Controls->lblSegImage->hide();
- m_Controls->lblSegmentation->hide();
- }
- }
- else
+ if (workingData)
{
- m_Controls->lblWorkingImageSelectionWarning->hide();
this->FireNodeSelected(const_cast<mitk::DataNode*>(workingData));
+// mitk::RenderingManager::GetInstance()->InitializeViews(workingData->GetData()->GetTimeSlicedGeometry(),
+// mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
if( m_Controls->widgetStack->currentIndex() == 0 )
{
- m_Controls->lblSegmentation->setText( workingData->GetName().c_str() );
- m_Controls->lblSegmentation->show();
- m_Controls->lblSegImage->show();
- }
- }
- }
-}
-
-//TODO remove function
-void QmitkSegmentationView::CheckImageAlignment()
-{
- bool wrongAlignment(true);
-
- mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
- if (node.IsNotNull())
- {
- mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
-
- if (image.IsNotNull() && m_MultiWidget)
- {
-
- wrongAlignment = !( IsRenderWindowAligned(m_MultiWidget->GetRenderWindow1(), image )
- && IsRenderWindowAligned(m_MultiWidget->GetRenderWindow2(), image )
- && IsRenderWindowAligned(m_MultiWidget->GetRenderWindow3(), image )
- );
- }
- }
- m_Controls->lblAlignmentWarning->setVisible(wrongAlignment);
-}
-
-//TODO remove function
-bool QmitkSegmentationView::IsRenderWindowAligned(QmitkRenderWindow* renderWindow, mitk::Image* image)
-{
- if (!renderWindow) return false;
-
- // for all 2D renderwindows of m_MultiWidget check alignment
- mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( renderWindow->GetRenderer()->GetCurrentWorldGeometry2D() );
- if (displayPlane.IsNull()) return false;
-
- int affectedDimension(-1);
- int affectedSlice(-1);
- return mitk::SegTool2D::DetermineAffectedImageSlice( image, displayPlane, affectedDimension, affectedSlice );
-}
-
-//TODO remove function
-void QmitkSegmentationView::ForceDisplayPreferencesUponAllImages()
-{
- if (!m_Parent || !m_Parent->isVisible()) return;
-
- // check all images and segmentations in DataStorage:
- // (items in brackets are implicitly done by previous steps)
- // 1.
- // if a reference image is selected,
- // show the reference image
- // and hide all other images (orignal and segmentation),
- // (and hide all segmentations of the other original images)
- // and show all the reference's segmentations
- // if no reference image is selected, do do nothing
- //
- // 2.
- // if a segmentation is selected,
- // show it
- // (and hide all all its siblings (childs of the same parent, incl, NULL parent))
- // if no segmentation is selected, do nothing
-
- if (!m_Controls) return; // might happen on initialization (preferences loaded)
- mitk::DataNode::Pointer referenceData = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
-
- // 1.
- if (referenceData.IsNotNull())
- {
- // iterate all images
- mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
+ disconnect( m_Controls->segImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
+ this, SLOT( OnSegmentationComboBoxSelectionChanged( const mitk::DataNode* ) ) );
- mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDefaultDataStorage()->GetSubset( isImage );
- //mitk::DataStorage::SetOfObjects::ConstPointer allSegmentationChilds = this->GetDefaultDataStorage()->GetDerivations(referenceData, isImage );
- for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin();
- iter != allImages->end();
- ++iter)
+ m_Controls->segImageSelector->setCurrentIndex(m_Controls->segImageSelector->Find(workingData));
- {
- mitk::DataNode* node = *iter;
- // apply display preferences
- ApplyDisplayOptions(node);
-
- // set visibility
- if(!node->IsSelected() || (node->IsSelected() && !node->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")))))
- node->SetVisibility((node == referenceData) || node->IsSelected() );
+ connect( m_Controls->segImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
+ this, SLOT( OnSegmentationComboBoxSelectionChanged(const mitk::DataNode*)) );
+ }
}
-
- // Reinit current node
- mitk::RenderingManager::GetInstance()->InitializeViews(
- referenceData->GetData()->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
}
-
- // 2.
- //if (workingData.IsNotNull() && !workingData->IsSelected())
- //{
- // workingData->SetVisibility(true);
- //}
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
{
if (!node) return;
bool isBinary(false);
node->GetPropertyValue("binary", isBinary);
if (isBinary)
{
node->SetProperty( "outline binary", mitk::BoolProperty::New( this->GetPreferences()->GetBool("draw outline", true)) );
node->SetProperty( "outline width", mitk::FloatProperty::New( 2.0 ) );
node->SetProperty( "opacity", mitk::FloatProperty::New( this->GetPreferences()->GetBool("draw outline", true) ? 1.0 : 0.3 ) );
node->SetProperty( "volumerendering", mitk::BoolProperty::New( this->GetPreferences()->GetBool("volume rendering", false) ) );
}
}
+bool QmitkSegmentationView::CheckForSameGeometry(const mitk::DataNode *node1, const mitk::DataNode *node2) const
+{
+ bool isSameGeometry(true);
+
+ mitk::Image* image1 = dynamic_cast<mitk::Image*>(node1->GetData());
+ mitk::Image* image2 = dynamic_cast<mitk::Image*>(node2->GetData());
+ if (image1 && image2)
+ {
+ mitk::Geometry3D* geo1 = image1->GetGeometry();
+ mitk::Geometry3D* geo2 = image2->GetGeometry();
+
+ isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetOrigin(), geo2->GetOrigin());
+ isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(0), geo2->GetExtent(0));
+ isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(1), geo2->GetExtent(1));
+ isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(2), geo2->GetExtent(2));
+ isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetSpacing(), geo2->GetSpacing());
+ isSameGeometry = isSameGeometry && mitk::MatrixEqualElementWise(geo1->GetIndexToWorldTransform()->GetMatrix(), geo2->GetIndexToWorldTransform()->GetMatrix());
+
+ return isSameGeometry;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+void QmitkSegmentationView::UpdateWarningLabel(QString text)
+{
+ m_Controls->lblSegmentationWarnings->setText(text);
+}
+
void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
{
// setup the basic GUI of this view
m_Parent = parent;
m_Controls = new Ui::QmitkSegmentationControls;
m_Controls->setupUi(parent);
- m_Controls->lblWorkingImageSelectionWarning->hide();
- m_Controls->lblAlignmentWarning->hide();
- m_Controls->lblSegImage->hide();
- m_Controls->lblSegmentation->hide();
-
- m_Controls->refImageSelector->SetDataStorage(this->GetDefaultDataStorage());
- mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
-
- mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
- mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
- mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
- mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
- isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
+ m_Controls->patImageSelector->SetDataStorage(this->GetDefaultDataStorage());
+ m_Controls->patImageSelector->SetPredicate(m_IsNotABinaryImagePredicate);
- mitk::NodePredicateOr::Pointer isImage = mitk::NodePredicateOr::New(isDiffusionImage, isMitkImage);
+ this->UpdateWarningLabel("Please load an image");
- m_Controls->refImageSelector->SetPredicate(isImage);
-
- if( m_Controls->refImageSelector->GetSelectedNode().IsNotNull() )
- m_Controls->lblReferenceImageSelectionWarning->hide();
- else
- m_Controls->refImageSelector->hide();
+ if( m_Controls->patImageSelector->GetSelectedNode().IsNotNull() )
+ this->UpdateWarningLabel("Select or create a segmentation");
+ m_Controls->segImageSelector->SetDataStorage(this->GetDefaultDataStorage());
+ m_Controls->segImageSelector->SetPredicate(m_IsABinaryImagePredicate);
+ if( m_Controls->segImageSelector->GetSelectedNode().IsNotNull() )
+ this->UpdateWarningLabel("");
mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
toolManager->SetDataStorage( *(this->GetDefaultDataStorage()) );
assert ( toolManager );
// all part of open source MITK
m_Controls->m_ManualToolSelectionBox->SetGenerateAccelerators(true);
m_Controls->m_ManualToolSelectionBox->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer );
- m_Controls->m_ManualToolSelectionBox->SetDisplayedToolGroups("Add Subtract Paint Wipe 'Region Growing' Correction Fill Erase");
- m_Controls->m_ManualToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingData );
+ m_Controls->m_ManualToolSelectionBox->SetDisplayedToolGroups("Add Subtract Paint Wipe 'Region Growing' Correction Fill Erase LiveWire");
+ m_Controls->m_ManualToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
// available only in the 3M application
if ( !m_Controls->m_OrganToolSelectionBox->children().count() )
{
m_Controls->widgetStack->setItemEnabled( 1, false );
}
m_Controls->m_OrganToolSelectionBox->SetToolManager( *toolManager );
m_Controls->m_OrganToolSelectionBox->SetToolGUIArea( m_Controls->m_OrganToolGUIContainer );
m_Controls->m_OrganToolSelectionBox->SetDisplayedToolGroups("'Hippocampus left' 'Hippocampus right' 'Lung left' 'Lung right' 'Liver' 'Heart LV' 'Endocard LV' 'Epicard LV' 'Prostate'");
m_Controls->m_OrganToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceData );
// available only in the 3M application
if ( !m_Controls->m_LesionToolSelectionBox->children().count() )
{
m_Controls->widgetStack->setItemEnabled( 2, false );
}
m_Controls->m_LesionToolSelectionBox->SetToolManager( *toolManager );
m_Controls->m_LesionToolSelectionBox->SetToolGUIArea( m_Controls->m_LesionToolGUIContainer );
m_Controls->m_LesionToolSelectionBox->SetDisplayedToolGroups("'Lymph Node'");
m_Controls->m_LesionToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceData );
toolManager->NewNodesGenerated +=
- mitk::MessageDelegate<QmitkSegmentationView>( this, &QmitkSegmentationView::NewNodesGenerated ); // update the list of segmentations
+ mitk::MessageDelegate<QmitkSegmentationView>( this, &QmitkSegmentationView::NewNodesGenerated ); // update the list of segmentations
toolManager->NewNodeObjectsGenerated +=
- mitk::MessageDelegate1<QmitkSegmentationView, mitk::ToolManager::DataVectorType*>( this, &QmitkSegmentationView::NewNodeObjectsGenerated ); // update the list of segmentations
+ mitk::MessageDelegate1<QmitkSegmentationView, mitk::ToolManager::DataVectorType*>( this, &QmitkSegmentationView::NewNodeObjectsGenerated ); // update the list of segmentations
// create signal/slot connections
- connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
- this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
+ connect( m_Controls->patImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
+ this, SLOT( OnPatientComboBoxSelectionChanged( const mitk::DataNode* ) ) );
+ connect( m_Controls->segImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
+ this, SLOT( OnSegmentationComboBoxSelectionChanged( const mitk::DataNode* ) ) );
connect( m_Controls->btnNewSegmentation, SIGNAL(clicked()), this, SLOT(CreateNewSegmentation()) );
connect( m_Controls->CreateSegmentationFromSurface, SIGNAL(clicked()), this, SLOT(CreateSegmentationFromSurface()) );
connect( m_Controls->widgetStack, SIGNAL(currentChanged(int)), this, SLOT(ToolboxStackPageChanged(int)) );
connect(m_Controls->MaskSurfaces, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
- this, SLOT( OnSurfaceSelectionChanged( ) ) );
-
- connect(m_Controls->MaskSurfaces, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
- this, SLOT( OnSurfaceSelectionChanged( ) ) );
+ this, SLOT( OnSurfaceSelectionChanged( ) ) );
connect(m_Controls->m_SlicesInterpolator, SIGNAL(SignalShowMarkerNodes(bool)), this, SLOT(OnShowMarkerNodes(bool)));
+ connect(m_Controls->m_SlicesInterpolator, SIGNAL(Signal3DInterpolationEnabled(bool)), this, SLOT(On3DInterpolationEnabled(bool)));
m_Controls->MaskSurfaces->SetDataStorage(this->GetDefaultDataStorage());
m_Controls->MaskSurfaces->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
-
- //// create helper class to provide context menus for segmentations in data manager
- // m_PostProcessing = new QmitkSegmentationPostProcessing(this->GetDefaultDataStorage(), this, m_Parent);
-
}
-
-//void QmitkSegmentationView::OnPlaneModeChanged(int i)
-//{
-// //if plane mode changes, disable all tools
-// if (m_MultiWidget)
-// {
-// mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
-//
-// if (toolManager)
-// {
-// if (toolManager->GetActiveToolID() >= 0)
-// {
-// toolManager->ActivateTool(-1);
-// }
-// else
-// {
-// m_MultiWidget->EnableNavigationControllerEventListening();
-// }
-// }
-// }
-//}
-
-
// ATTENTION some methods for handling the known list of (organ names, colors) are defined in QmitkSegmentationOrganNamesHandling.cpp
-
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
index e049f1327f..e4d82e0638 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
@@ -1,166 +1,175 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkSegmentationView_h
#define QmitkSegmentationView_h
#include "QmitkFunctionality.h"
#include <berryIBerryPreferences.h>
#include "ui_QmitkSegmentationControls.h"
class QmitkRenderWindow;
-// class QmitkSegmentationPostProcessing;
/**
* \ingroup ToolManagerEtAl
* \ingroup org_mitk_gui_qt_segmentation_internal
* \warning Implementation of this class is split up into two .cpp files to make things more compact. Check both this file and QmitkSegmentationOrganNamesHandling.cpp
*/
class QmitkSegmentationView : public QmitkFunctionality
{
Q_OBJECT
public:
QmitkSegmentationView();
virtual ~QmitkSegmentationView();
typedef std::map<mitk::DataNode*, unsigned long> NodeTagMapType;
/*!
\brief Invoked when the DataManager selection changed
*/
virtual void OnSelectionChanged(mitk::DataNode* node);
virtual void OnSelectionChanged(std::vector<mitk::DataNode*> nodes);
// reaction to new segmentations being created by segmentation tools
void NewNodesGenerated();
void NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType*);
// QmitkFunctionality's activate/deactivate
virtual void Activated();
virtual void Deactivated();
virtual void Visible();
// QmitkFunctionality's changes regarding THE QmitkStdMultiWidget
virtual void StdMultiWidgetAvailable(QmitkStdMultiWidget& stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
virtual void StdMultiWidgetClosed(QmitkStdMultiWidget& stdMultiWidget);
// BlueBerry's notification about preference changes (e.g. from a dialog)
- virtual void OnPreferencesChanged(const berry::IBerryPreferences*);
+ virtual void OnPreferencesChanged(const berry::IBerryPreferences* prefs);
// observer to mitk::RenderingManager's RenderingManagerViewsInitializedEvent event
void RenderingManagerReinitialized(const itk::EventObject&);
// observer to mitk::SliceController's SliceRotation event
void SliceRotation(const itk::EventObject&);
static const std::string VIEW_ID;
protected slots:
- void OnComboBoxSelectionChanged(const mitk::DataNode* node);
+ void OnPatientComboBoxSelectionChanged(const mitk::DataNode* node);
+ void OnSegmentationComboBoxSelectionChanged(const mitk::DataNode* node);
// reaction to the button "New segmentation"
void CreateNewSegmentation();
// reaction to the button "New segmentation"
void CreateSegmentationFromSurface();
// called when one of "Manual", "Organ", "Lesion" pages of the QToolbox is selected
void ToolboxStackPageChanged(int id);
void OnSurfaceSelectionChanged();
- //called when the checkbox Remember Contour Positions is selected/deselected
-
void OnWorkingNodeVisibilityChanged();
+ // called if a node's binary property has changed
+ void OnBinaryPropertyChanged();
+
void OnShowMarkerNodes(bool);
protected:
// a type for handling lists of DataNodes
typedef std::vector<mitk::DataNode*> NodeList;
// set available multiwidget
void SetMultiWidget(QmitkStdMultiWidget* multiWidget);
// actively query the current selection of data manager
//void PullCurrentDataManagerSelection();
// reactions to selection events from data manager (and potential other senders)
//void BlueBerrySelectionChanged(berry::IWorkbenchPart::Pointer sourcepart, berry::ISelection::ConstPointer selection);
mitk::DataNode::Pointer FindFirstRegularImage( std::vector<mitk::DataNode*> nodes );
mitk::DataNode::Pointer FindFirstSegmentation( std::vector<mitk::DataNode*> nodes );
// propagate BlueBerry selection to ToolManager for manual segmentation
void SetToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData);
- // checks if selected reference image is aligned with the slices stack orientation of the StdMultiWidget
- void CheckImageAlignment();
-
// checks if given render window aligns with the slices of given image
bool IsRenderWindowAligned(QmitkRenderWindow* renderWindow, mitk::Image* image);
// make sure all images/segmentations look as selected by the users in this view's preferences
void ForceDisplayPreferencesUponAllImages();
// decorates a DataNode according to the user preference settings
void ApplyDisplayOptions(mitk::DataNode* node);
// GUI setup
void CreateQtPartControl(QWidget* parent);
// handling of a list of known (organ name, organ color) combination
// ATTENTION these methods are defined in QmitkSegmentationOrganNamesHandling.cpp
QStringList GetDefaultOrganColorString();
void UpdateOrganList(QStringList& organColors, const QString& organname, mitk::Color colorname);
void AppendToOrganList(QStringList& organColors, const QString& organname, int r, int g, int b);
// If a contourmarker is selected, the plane in the related widget will be reoriented according to the marker`s geometry
void OnContourMarkerSelected (const mitk::DataNode* node);
void NodeRemoved(const mitk::DataNode* node);
+ void NodeAdded(const mitk::DataNode *node);
+
+ bool CheckForSameGeometry(const mitk::DataNode*, const mitk::DataNode*) const;
+
+ void UpdateWarningLabel(QString text/*, bool overwriteExistingText = true*/);
+
// the Qt parent of our GUI (NOT of this object)
QWidget* m_Parent;
// our GUI
Ui::QmitkSegmentationControls * m_Controls;
// THE currently existing QmitkStdMultiWidget
QmitkStdMultiWidget * m_MultiWidget;
- // QmitkSegmentationPostProcessing* m_PostProcessing;
-
- unsigned long m_RenderingManagerObserverTag;
- unsigned long m_SlicesRotationObserverTag1;
- unsigned long m_SlicesRotationObserverTag2;
unsigned long m_VisibilityChangedObserverTag;
bool m_DataSelectionChanged;
NodeTagMapType m_WorkingDataObserverTags;
+
+ NodeTagMapType m_BinaryPropertyObserverTags;
+
+ bool m_AutoSelectionEnabled;
+
+ mitk::NodePredicateOr::Pointer m_IsOfTypeImagePredicate;
+ mitk::NodePredicateProperty::Pointer m_IsBinaryPredicate;
+ mitk::NodePredicateNot::Pointer m_IsNotBinaryPredicate;
+ mitk::NodePredicateAnd::Pointer m_IsNotABinaryImagePredicate;
+ mitk::NodePredicateAnd::Pointer m_IsABinaryImagePredicate;
};
#endif /*QMITKsegmentationVIEW_H_*/
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkStatisticsAction.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkStatisticsAction.cpp
deleted file mode 100644
index b36aaafeab..0000000000
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkStatisticsAction.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-#include "QmitkStatisticsAction.h"
-
-QmitkStatisticsAction::QmitkStatisticsAction(): m_BlueBerryView(NULL)
-{
-}
-
-QmitkStatisticsAction::~QmitkStatisticsAction()
-{
-}
-
-void QmitkStatisticsAction::Run(const QList<mitk::DataNode::Pointer>& /*selectedNodes*/)
-{
- QSharedPointer<ctkPlugin> imageStatisticsBundle = berry::Platform::GetCTKPlugin("org.mitk.gui.qt.measurementtoolbox");
-
- if (m_BlueBerryView && !imageStatisticsBundle.isNull())
- {
- m_BlueBerryView->GetSite()->GetWorkbenchWindow()->GetActivePage()->ShowView("org.mitk.views.imagestatistics");
- }
-}
-
-void QmitkStatisticsAction::SetFunctionality(berry::QtViewPart* functionality)
-{
- this->m_BlueBerryView = functionality;
-}
-
-void QmitkStatisticsAction::SetDataStorage(mitk::DataStorage* /*dataStorage*/)
-{
- //not needed
-}
-
-void QmitkStatisticsAction::SetSmoothed(bool /*smoothed*/)
-{
- //not needed
-}
-
-void QmitkStatisticsAction::SetDecimated(bool /*decimated*/)
-{
- //not needed
-}
-
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/mitkPluginActivator.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/mitkPluginActivator.cpp
index d216c1172b..4ce3ef9ca3 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/mitkPluginActivator.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/mitkPluginActivator.cpp
@@ -1,49 +1,47 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPluginActivator.h"
#include "QmitkSegmentationView.h"
#include "QmitkBooleanOperationsView.h"
#include "QmitkThresholdAction.h"
#include "QmitkOtsuAction.h"
#include "QmitkCreatePolygonModelAction.h"
-#include "QmitkStatisticsAction.h"
#include "QmitkAutocropAction.h"
#include "QmitkSegmentationPreferencePage.h"
#include "QmitkDeformableClippingPlaneView.h"
#include "src/internal/regiongrowing/QmitkRegionGrowingView.h"
using namespace mitk;
void PluginActivator::start(ctkPluginContext *context)
{
BERRY_REGISTER_EXTENSION_CLASS(QmitkSegmentationView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkBooleanOperationsView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkThresholdAction, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkOtsuAction, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkCreatePolygonModelAction, context)
- BERRY_REGISTER_EXTENSION_CLASS(QmitkStatisticsAction, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkAutocropAction, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkSegmentationPreferencePage, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkDeformableClippingPlaneView, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkRegionGrowingView, context);
}
void PluginActivator::stop(ctkPluginContext *)
{
}
Q_EXPORT_PLUGIN2(org_mitk_gui_qt_segmentation, mitk::PluginActivator)
diff --git a/Plugins/org.mitk.gui.qt.simulation/CMakeLists.txt b/Plugins/org.mitk.gui.qt.simulation/CMakeLists.txt
index 84195b260a..e075434c20 100644
--- a/Plugins/org.mitk.gui.qt.simulation/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.simulation/CMakeLists.txt
@@ -1,7 +1,7 @@
project(org_mitk_gui_qt_simulation)
MACRO_CREATE_MITK_CTK_PLUGIN(
EXPORT_DIRECTIVE SIMULATION_EXPORT
EXPORTED_INCLUDE_SUFFIXES src
- MODULE_DEPENDENCIES Simulation Qmitk
+ MODULE_DEPENDENCIES Qmitk Simulation
)
diff --git a/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/DataManager_CreateSimulation.png b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/DataManager_CreateSimulation.png
new file mode 100644
index 0000000000..3804ba2b0f
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/DataManager_CreateSimulation.png differ
diff --git a/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/DataManager_SimulationNodes.png b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/DataManager_SimulationNodes.png
new file mode 100644
index 0000000000..9a1bdeac3a
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/DataManager_SimulationNodes.png differ
diff --git a/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/DataManager_Snapshots_Record.png b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/DataManager_Snapshots_Record.png
new file mode 100644
index 0000000000..135df62ed4
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/DataManager_Snapshots_Record.png differ
diff --git a/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/Properties_Simulation.png b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/Properties_Simulation.png
new file mode 100644
index 0000000000..5ac4ba370e
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/Properties_Simulation.png differ
diff --git a/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/Properties_SimulationTemplate.png b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/Properties_SimulationTemplate.png
new file mode 100644
index 0000000000..c411484623
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/Properties_SimulationTemplate.png differ
diff --git a/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/SimulationView_Inactive_Active.png b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/SimulationView_Inactive_Active.png
new file mode 100644
index 0000000000..d59d2bdc7a
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/SimulationView_Inactive_Active.png differ
diff --git a/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/SimulationView_Recording.png b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/SimulationView_Recording.png
new file mode 100644
index 0000000000..3ee71df525
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/SimulationView_Recording.png differ
diff --git a/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/org_mitk_gui_qt_simulation.dox b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/org_mitk_gui_qt_simulation.dox
new file mode 100644
index 0000000000..d2a5a4846f
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/org_mitk_gui_qt_simulation.dox
@@ -0,0 +1,108 @@
+/**
+\page org_mitk_gui_qt_simulation The Simulation Plugin
+
+\image html org_mitk_gui_qt_simulation.png "Icon of the Simulation Plugin."
+
+Available sections:
+ - \ref org_mitk_gui_qt_simulationOverview
+ - \ref org_mitk_gui_qt_simulationUsage
+ - \ref org_mitk_gui_qt_simulationAdvancedUsage
+ - \ref org_mitk_gui_qt_simulationSOFAPlugins
+ - \ref org_mitk_gui_qt_simulationSimulationTemplates
+
+\section org_mitk_gui_qt_simulationOverview Overview
+
+The Simulation View allows you to run SOFA simulations.
+Its layout is very similar to the <tt>runSofa</tt> application and if you used SOFA before, you should immediately feel comfortable.
+Currently you can animate your simulation, step through with arbitrary time steps, and reset your simulation scene.
+Rendering options, e.g. rendering force fields or visual mappings, are represented by properties of a simulation data node.
+SOFA plugins can be loaded via the simulation preferences.
+
+You can easily take snapshots of your simulation scene, which are represented by 3D surfaces, or record your simulation scene as 3D+t surface.
+An advantage over <tt>runSofa</tt> is the ability to load multiple simulation scenes in parallel.
+There is also support for a kind of predefined editing of simulation scene files by writing simulation scene templates, which can be adjusted in the Properties View.
+
+\section org_mitk_gui_qt_simulationUsage Usage
+
+Simulation scenes are easily recognizable in the Data Manager by their SOFA icon.
+
+\image html DataManager_SimulationNodes.png "Data Manager with three simulation scenes."
+
+Selection of simulation scenes in the Data Manager does not affect the active simulation, which must be explicitly selected in the Simulation View.
+However, rendering properties, which can be seen in the Properties View, refer to the selected simulation scene in the Data Manager.
+
+\image html Properties_Simulation.png "Properties of a simulation scene."
+
+The appearance of the Simulation View changes slightly depending on which operations are currently possible or make sense, i.e. when no simulation scene was loaded, most of the Simulation View controls are disabled.
+
+\image html SimulationView_Inactive_Active.png "The Simulation View enables its controls depending on which of them can be executed at the moment."
+
+You can take snapshots of the active simulation scene by pressing the <tt>Take Snapshot</tt> button.
+You can toggle the <tt>Record</tt> button at any time to record all following simulation steps until you toggle it again.
+The number of recorded steps is shown during recording.
+
+\image html SimulationView_Recording.png "Recording simulation steps."
+
+Snapshots and records are appended to the corresponding simulation scene in the Data Manager.
+Snapshots are represented by 3D surfaces and recordings with more than a single frame as 3D+t surfaces.
+You can step through a 3D+t surface by using the <tt>Time</tt> slider of the Image Navigator View.
+
+\image html DataManager_Snapshots_Record.png "The caduceus simulation scene has two snapshots and a record."
+
+\section org_mitk_gui_qt_simulationAdvancedUsage Advanced Usage
+
+\subsection org_mitk_gui_qt_simulationSOFAPlugins SOFA Plugins
+
+SOFA plugins are supported by MITK and can be loaded during runtime. For more information, see \ref SimulationManualSOFAPluginBuildInstructions.
+
+\subsection org_mitk_gui_qt_simulationSimulationTemplates Simulation Templates
+
+Simulation templates are extended SOFA scene files and have the file extension <tt>.scn.template</tt>.
+They contain special strings which are parsed and displayed as properties in the Properties View.
+You can create a simulation scene from a simulation template via its context menu in the Data Manager.
+Behind the scenes all templates of a simulation template file are replaced by concrete values.
+This simulation scene is saved in the same directory as the simulation template and automatically loaded.
+
+\image html DataManager_CreateSimulation.png "A simulation can be created from a simulation template via its context menu in the Data Manager."
+
+<br>
+
+\image html Properties_SimulationTemplate.png "A simulation template typically has several properties which can be adjusted before creating a simulation."
+
+The syntax for templates is as follows:
+
+\code
+{id='Collision.Alarm Distance' type='int' default='5'}
+\endcode
+
+<tt>id</tt> must be unique and is parsed as property name, i.e. use periods to arrange properties in tree order.
+<tt>type</tt> is optional and its default is <tt>string</tt>.
+Other valid types are <tt>int</tt> and <tt>float</tt>.
+<tt>default</tt> is also optional and specifies the default value of the property.
+
+Since IDs must be unique but some values are supposed to appear in multiple places in a simulation template, you can specify references to templates as follows:
+
+\code
+{'Collision.Alarm Distance'}
+\endcode
+
+\warning
+Braces are only allowed to open or close templates and references.
+References must begin with <tt>{'</tt> and end with <tt>'}'</tt>.
+You must escape single quotation marks C-style, e.g. <tt>{id='Flinders\'s Cat' default='Trim'}</tt>.
+
+A good practice is to list all templates within XML comments at the beginning of the simulation template file and to just reference them as needed.
+
+\code
+<?xml version="1.0"?>
+
+<!-- {id='Simulation.Time Step' type='float' default='0.1'} -->
+<!-- {id='Collision.Alarm Distance' type='float' default='5'} -->
+<!-- {id='Collision.Contact Distance' type='float' default='3'} -->
+
+<Node dt="{'Simulation.Time Step'}">
+ <MinProximityIntersection alarmDistance="{'Collision.Alarm Distance'}" contactDistance="{'Collision.Contact Distance'}" />
+
+<!-- ... -->
+\endcode
+*/
diff --git a/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/org_mitk_gui_qt_simulation.png b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/org_mitk_gui_qt_simulation.png
new file mode 100644
index 0000000000..9a145b327a
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.simulation/documentation/UserManual/org_mitk_gui_qt_simulation.png differ
diff --git a/Plugins/org.mitk.gui.qt.simulation/files.cmake b/Plugins/org.mitk.gui.qt.simulation/files.cmake
index 342a0f859e..3be5b42edf 100644
--- a/Plugins/org.mitk.gui.qt.simulation/files.cmake
+++ b/Plugins/org.mitk.gui.qt.simulation/files.cmake
@@ -1,39 +1,41 @@
set(SRC_CPP_FILES
)
set(INTERNAL_CPP_FILES
org_mitk_gui_qt_simulation_Activator.cpp
+ QmitkCreateSimulationAction.cpp
QmitkSimulationPreferencePage.cpp
QmitkSimulationView.cpp
)
set(UI_FILES
src/internal/QmitkSimulationPreferencePageControls.ui
src/internal/QmitkSimulationViewControls.ui
)
set(MOC_H_FILES
src/internal/org_mitk_gui_qt_simulation_Activator.h
+ src/internal/QmitkCreateSimulationAction.h
src/internal/QmitkSimulationPreferencePage.h
src/internal/QmitkSimulationView.h
)
set(CACHED_RESOURCE_FILES
resources/icon.png
plugin.xml
)
set(QRC_FILES
resources/Simulation.qrc
)
set(CPP_FILES
)
foreach(file ${SRC_CPP_FILES})
set(CPP_FILES ${CPP_FILES} src/${file})
endforeach()
foreach(file ${INTERNAL_CPP_FILES})
set(CPP_FILES ${CPP_FILES} src/internal/${file})
endforeach()
diff --git a/Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake
index 912e7b0cf4..8ff31cfca6 100644
--- a/Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake
@@ -1,5 +1,5 @@
set(Plugin-Name "MITK Simulation")
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)
+set(Require-Plugin org.mitk.simulation org.mitk.gui.qt.datamanager)
diff --git a/Plugins/org.mitk.gui.qt.simulation/plugin.xml b/Plugins/org.mitk.gui.qt.simulation/plugin.xml
index b16639779a..fe22cf383a 100644
--- a/Plugins/org.mitk.gui.qt.simulation/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.simulation/plugin.xml
@@ -1,14 +1,20 @@
<?xml version="1.0"?>
<plugin>
<extension point="org.blueberry.ui.views">
<view id="org.mitk.views.simulation"
name="Simulation"
class="QmitkSimulationView"
icon="resources/icon.png" />
</extension>
<extension point="org.blueberry.ui.preferencePages">
<page id="org.mitk.gui.qt.application.SimulationPreferencePage"
name="Simulation"
class="QmitkSimulationPreferencePage" />
</extension>
+ <extension point="org.mitk.gui.qt.datamanager.contextMenuActions">
+ <contextMenuAction nodeDescriptorName="SimulationTemplate"
+ label="Create Simulation"
+ icon=""
+ class="QmitkCreateSimulationAction" />
+ </extension>
</plugin>
diff --git a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkCreateSimulationAction.cpp b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkCreateSimulationAction.cpp
new file mode 100644
index 0000000000..79cbc6d2b6
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkCreateSimulationAction.cpp
@@ -0,0 +1,118 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "QmitkCreateSimulationAction.h"
+#include <mitkIOUtil.h>
+#include <mitkNodePredicateNot.h>
+#include <mitkNodePredicateProperty.h>
+#include <mitkIRenderingManager.h>
+#include <mitkSimulationTemplate.h>
+#include <algorithm>
+
+static std::string CreateFileName(mitk::DataNode::Pointer dataNode)
+{
+ std::string path;
+ dataNode->GetStringProperty("path", path);
+
+ std::string name;
+ dataNode->GetStringProperty("name", name);
+
+ if (name.length() < 5)
+ {
+ name += ".scn";
+ }
+ else
+ {
+ std::string ext = name.substr(name.length() - 4);
+ std::transform(ext.begin(), ext.end(), ext.begin(), tolower);
+
+ if (ext != ".scn" && ext != ".xml")
+ name += ".scn";
+ }
+
+ return path + "/" + name;
+}
+
+static void InitializeViews(mitk::DataStorage::Pointer dataStorage)
+{
+ mitk::NodePredicateNot::Pointer predicate = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
+ mitk::DataStorage::SetOfObjects::ConstPointer subset = dataStorage->GetSubset(predicate);
+ mitk::TimeSlicedGeometry::Pointer geometry = dataStorage->ComputeBoundingGeometry3D(subset);
+
+ mitk::RenderingManager::GetInstance()->InitializeViews(geometry);
+}
+
+QmitkCreateSimulationAction::QmitkCreateSimulationAction()
+{
+}
+
+QmitkCreateSimulationAction::~QmitkCreateSimulationAction()
+{
+}
+
+void QmitkCreateSimulationAction::Run(const QList<mitk::DataNode::Pointer>& selectedNodes)
+{
+ mitk::DataNode::Pointer dataNode;
+
+ foreach(dataNode, selectedNodes)
+ {
+ if (dynamic_cast<mitk::SimulationTemplate*>(dataNode->GetData()) != NULL)
+ {
+ mitk::SimulationTemplate* simulationTemplate = static_cast<mitk::SimulationTemplate*>(dataNode->GetData());
+ std::string contents = simulationTemplate->CreateSimulation();
+
+ if (contents.empty())
+ {
+ MITK_ERROR << "Could not create simulation from template '" << dataNode->GetName() << "'!";
+ continue;
+ }
+
+ std::string fileName = CreateFileName(dataNode);
+
+ std::ofstream file(fileName.c_str());
+ file << contents;
+ file.close();
+
+ std::vector<std::string> fileNames;
+ fileNames.push_back(fileName);
+
+ mitk::DataNode::Pointer simulationNode = mitk::IOUtil::LoadDataNode(fileName);
+
+ if (simulationNode.IsNotNull())
+ {
+ m_DataStorage->Add(simulationNode, dataNode);
+ InitializeViews(m_DataStorage);
+ }
+ }
+ }
+}
+
+void QmitkCreateSimulationAction::SetDataStorage(mitk::DataStorage* dataStorage)
+{
+ m_DataStorage = dataStorage;
+}
+
+void QmitkCreateSimulationAction::SetFunctionality(berry::QtViewPart*)
+{
+}
+
+void QmitkCreateSimulationAction::SetDecimated(bool)
+{
+}
+
+void QmitkCreateSimulationAction::SetSmoothed(bool)
+{
+}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkStatisticsAction.h b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkCreateSimulationAction.h
similarity index 53%
rename from Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkStatisticsAction.h
rename to Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkCreateSimulationAction.h
index 8aae686c73..e5817552eb 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkStatisticsAction.h
+++ b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkCreateSimulationAction.h
@@ -1,50 +1,45 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#ifndef QMITK_STATISTICSACTION_H
-#define QMITK_STATISTICSACTION_H
-#include <berryIWorkbenchPage.h>
-#include "berryQtViewPart.h"
+#ifndef QmitkCreateSimulationAction_h
+#define QmitkCreateSimulationAction_h
-#include "mitkIContextMenuAction.h"
+#include <QObject>
+#include <mitkIContextMenuAction.h>
-#include "org_mitk_gui_qt_segmentation_Export.h"
-
-class QmitkStdMultiWidget;
-
-class MITK_QT_SEGMENTATION QmitkStatisticsAction: public QObject, public mitk::IContextMenuAction
+class QmitkCreateSimulationAction : public QObject, public mitk::IContextMenuAction
{
Q_OBJECT
Q_INTERFACES(mitk::IContextMenuAction)
public:
+ QmitkCreateSimulationAction();
+ ~QmitkCreateSimulationAction();
- QmitkStatisticsAction();
- virtual ~QmitkStatisticsAction();
-
- //interface methods
- void Run( const QList<mitk::DataNode::Pointer>& selectedNodes );
+ void Run(const QList<mitk::DataNode::Pointer>& selectedNodes);
void SetDataStorage(mitk::DataStorage* dataStorage);
- void SetSmoothed(bool smoothed);
- void SetDecimated(bool decimated);
void SetFunctionality(berry::QtViewPart* functionality);
+ void SetDecimated(bool decimated);
+ void SetSmoothed(bool smoothed);
-protected:
+private:
+ QmitkCreateSimulationAction(const QmitkCreateSimulationAction&);
+ QmitkCreateSimulationAction& operator=(const QmitkCreateSimulationAction&);
- //needs to be set over the IContextMenuAction (with this - QmitkDataManagerView - as parameter)
- berry::QtViewPart* m_BlueBerryView;
+ mitk::DataStorage::Pointer m_DataStorage;
};
-#endif // QMITK_STATISTICSACTION_H
+
+#endif
diff --git a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.cpp b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.cpp
index d22ca55d04..b8d857a62f 100644
--- a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.cpp
@@ -1,244 +1,207 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkSimulationPreferencePage.h"
-#include <sofa/helper/system/PluginManager.h>
-#include <berryIPreferencesService.h>
+#include <mitkGetSimulationPreferences.h>
#include <QFileDialog>
#include <QMessageBox>
-#include <cassert>
+#include <sofa/helper/system/PluginManager.h>
typedef sofa::helper::system::Plugin Plugin;
typedef sofa::helper::system::PluginManager PluginManager;
typedef sofa::helper::system::PluginManager::PluginIterator PluginIterator;
typedef sofa::helper::system::PluginManager::PluginMap PluginMap;
-berry::IPreferences::Pointer getSimulationPreferences()
-{
- berry::ServiceRegistry& serviceRegistry = berry::Platform::GetServiceRegistry();
- berry::IPreferencesService::Pointer preferencesService = serviceRegistry.GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
- berry::IPreferences::Pointer preferences = preferencesService->GetSystemPreferences();
- return preferences->Node("/org.mitk.views.simulation");
-}
-
-void initSOFAPlugins(berry::IPreferences::Pointer preferences)
-{
- if (preferences.IsNull())
- return;
-
- QString pluginPaths = preferences->GetByteArray(QmitkSimulationPreferencePage::PLUGIN_PATHS, "").c_str();
-
- if (pluginPaths.isEmpty())
- return;
-
- QStringList pluginPathList = pluginPaths.split(';', QString::SkipEmptyParts);
- QStringListIterator it(pluginPathList);
-
- typedef sofa::helper::system::PluginManager PluginManager;
- PluginManager& pluginManager = PluginManager::getInstance();
-
- while (it.hasNext())
- {
- std::string path = it.next().toStdString();
- std::ostringstream errlog;
-
- pluginManager.loadPlugin(path, &errlog);
-
- if (errlog.str().empty())
- pluginManager.getPluginMap()[path].initExternalModule();
- }
-}
-
-const std::string QmitkSimulationPreferencePage::PLUGIN_PATHS = "plugin paths";
-
QmitkSimulationPreferencePage::QmitkSimulationPreferencePage()
- : m_Preferences(getSimulationPreferences()),
+ : m_Preferences(mitk::GetSimulationPreferences()),
m_Control(NULL)
{
- initSOFAPlugins(m_Preferences);
}
QmitkSimulationPreferencePage::~QmitkSimulationPreferencePage()
{
}
void QmitkSimulationPreferencePage::CreateQtControl(QWidget* parent)
{
m_Control = new QWidget(parent);
m_Controls.setupUi(m_Control);
QStringList headerLabels;
headerLabels << "Name" << "License" << "Version" << "Path";
m_Controls.pluginsTreeWidget->setHeaderLabels(headerLabels);
connect(m_Controls.pluginsTreeWidget, SIGNAL(itemSelectionChanged()), this, SLOT(OnPluginTreeWidgetItemSelectionChanged()));
connect(m_Controls.addButton, SIGNAL(clicked()), this, SLOT(OnAddButtonClicked()));
connect(m_Controls.removeButton, SIGNAL(clicked()), this, SLOT(OnRemoveButtonClicked()));
this->Update();
}
QWidget* QmitkSimulationPreferencePage::GetQtControl() const
{
return m_Control;
}
void QmitkSimulationPreferencePage::Init(berry::IWorkbench::Pointer)
{
}
void QmitkSimulationPreferencePage::OnAddButtonClicked()
{
QString filter = "SOFA Plugins ";
#if defined(__APPLE__)
filter += "(*.dylib*)";
#elif defined(WIN32)
filter += "(*.dll)";
#else
filter += "(*.so)";
#endif
std::string path = QFileDialog::getOpenFileName(m_Control, "Add SOFA Library", "", filter).toStdString();
+ if (path.empty())
+ return;
+
PluginManager &pluginManager = PluginManager::getInstance();
std::ostringstream errlog;
if (pluginManager.loadPlugin(path, &errlog))
{
if (!errlog.str().empty())
{
QMessageBox* messageBox = new QMessageBox(m_Control);
messageBox->setIcon(QMessageBox::Warning);
messageBox->setStandardButtons(QMessageBox::Ok);
messageBox->setText(errlog.str().c_str());
messageBox->setWindowTitle("Warning");
messageBox->show();
}
Plugin& plugin = pluginManager.getPluginMap()[path];
plugin.initExternalModule();
QStringList pluginItem;
pluginItem
<< plugin.getModuleName()
<< plugin.getModuleLicense()
<< plugin.getModuleVersion()
<< path.c_str();
m_Controls.pluginsTreeWidget->addTopLevelItem(new QTreeWidgetItem(pluginItem));
}
else
{
QMessageBox* messageBox = new QMessageBox(m_Control);
messageBox->setIcon(QMessageBox::Critical);
messageBox->setStandardButtons(QMessageBox::Ok);
messageBox->setText(errlog.str().c_str());
messageBox->setWindowTitle("Error");
messageBox->show();
}
}
void QmitkSimulationPreferencePage::OnPluginTreeWidgetItemSelectionChanged()
{
QList<QTreeWidgetItem*> selectedItems = m_Controls.pluginsTreeWidget->selectedItems();
if (!selectedItems.isEmpty())
{
PluginMap& pluginMap = sofa::helper::system::PluginManager::getInstance().getPluginMap();
std::string path = selectedItems[0]->text(3).toStdString();
m_Controls.descriptionPlainTextEdit->setPlainText(pluginMap[path].getModuleDescription());
m_Controls.removeButton->setEnabled(true);
}
else
{
m_Controls.descriptionPlainTextEdit->clear();
m_Controls.componentsListWidget->clear();
m_Controls.removeButton->setEnabled(false);
}
}
void QmitkSimulationPreferencePage::OnRemoveButtonClicked()
{
QList<QTreeWidgetItem*> selectedItems = m_Controls.pluginsTreeWidget->selectedItems();
if (selectedItems.isEmpty())
return;
std::string path = selectedItems[0]->text(3).toStdString();
PluginManager& pluginManager = PluginManager::getInstance();
std::ostringstream errlog;
if (pluginManager.unloadPlugin(path, &errlog))
{
delete selectedItems[0];
}
else
{
QMessageBox* messageBox = new QMessageBox(m_Control);
messageBox->setIcon(QMessageBox::Critical);
messageBox->setStandardButtons(QMessageBox::Ok);
messageBox->setText(errlog.str().c_str());
messageBox->setWindowTitle("Error");
messageBox->show();
}
}
void QmitkSimulationPreferencePage::PerformCancel()
{
}
bool QmitkSimulationPreferencePage::PerformOk()
{
PluginManager& pluginManager = PluginManager::getInstance();
PluginMap& pluginMap = pluginManager.getPluginMap();
std::string pluginPaths;
for (PluginIterator it = pluginMap.begin(); it != pluginMap.end(); ++it)
{
if (!pluginPaths.empty())
pluginPaths += ";";
pluginPaths += it->first;
}
- m_Preferences->PutByteArray(PLUGIN_PATHS, pluginPaths);
+ m_Preferences->PutByteArray("plugin paths", pluginPaths);
return true;
}
void QmitkSimulationPreferencePage::Update()
{
PluginManager& pluginManager = PluginManager::getInstance();
PluginMap& pluginMap = pluginManager.getPluginMap();
for (PluginIterator it = pluginMap.begin(); it != pluginMap.end(); ++it)
{
Plugin& plugin = it->second;
QStringList pluginItem;
pluginItem
<< plugin.getModuleName()
<< plugin.getModuleLicense()
<< plugin.getModuleVersion()
<< it->first.c_str();
m_Controls.pluginsTreeWidget->addTopLevelItem(new QTreeWidgetItem(pluginItem));
}
}
diff --git a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.h b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.h
index 484c855305..d1fb5743e9 100644
--- a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.h
+++ b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationPreferencePage.h
@@ -1,57 +1,52 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkSimulationPreferencePage_h
#define QmitkSimulationPreferencePage_h
#include <berryIQtPreferencePage.h>
#include <berryIPreferences.h>
#include <org_mitk_gui_qt_simulation_Export.h>
#include <ui_QmitkSimulationPreferencePageControls.h>
-berry::IPreferences::Pointer getSimulationPreferences();
-void initSOFAPlugins(berry::IPreferences::Pointer preferences = getSimulationPreferences());
-
class SIMULATION_EXPORT QmitkSimulationPreferencePage : public QObject, public berry::IQtPreferencePage
{
Q_OBJECT
Q_INTERFACES(berry::IPreferencePage)
public:
- static const std::string PLUGIN_PATHS;
-
QmitkSimulationPreferencePage();
~QmitkSimulationPreferencePage();
void CreateQtControl(QWidget* parent);
QWidget* GetQtControl() const;
void Init(berry::IWorkbench::Pointer workbench);
void PerformCancel();
bool PerformOk();
void Update();
private slots:
void OnAddButtonClicked();
void OnPluginTreeWidgetItemSelectionChanged();
void OnRemoveButtonClicked();
private:
berry::IPreferences::Pointer m_Preferences;
QWidget* m_Control;
Ui::QmitkSimulationPreferencePageControls m_Controls;
};
#endif
diff --git a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp
index d54415ee0d..337a86fc45 100644
--- a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp
+++ b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp
@@ -1,263 +1,259 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#include "QmitkSimulationPreferencePage.h"
#include "QmitkSimulationView.h"
#include <mitkIRenderingManager.h>
#include <mitkNodePredicateDataType.h>
#include <mitkSimulation.h>
#include <mitkSimulationModel.h>
-#include <sofa/helper/system/PluginManager.h>
#include <sofa/simulation/common/UpdateContextVisitor.h>
-static void InitializeViews(mitk::IRenderWindowPart* renderWindowPart, mitk::Geometry3D* geometry)
-{
- if (renderWindowPart == NULL || geometry == NULL)
- return;
-
- mitk::IRenderingManager* renderingManager = renderWindowPart->GetRenderingManager();
-
- if (renderingManager != NULL)
- renderingManager->InitializeViews(geometry, mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
-}
-
QmitkSimulationView::QmitkSimulationView()
: m_SelectionWasRemovedFromDataStorage(false),
m_Timer(this)
{
this->GetDataStorage()->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkSimulationView, const mitk::DataNode*>(this, &QmitkSimulationView::OnNodeRemovedFromDataStorage));
connect(&m_Timer, SIGNAL(timeout()), this, SLOT(OnTimerTimeout()));
- initSOFAPlugins();
}
QmitkSimulationView::~QmitkSimulationView()
{
this->GetDataStorage()->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkSimulationView, const mitk::DataNode*>(this, &QmitkSimulationView::OnNodeRemovedFromDataStorage));
}
void QmitkSimulationView::CreateQtPartControl(QWidget* parent)
{
m_Controls.setupUi(parent);
m_Controls.simulationComboBox->SetDataStorage(this->GetDataStorage());
m_Controls.simulationComboBox->SetPredicate(mitk::NodePredicateDataType::New("Simulation"));
m_Controls.stepsRecordedLabel->hide();
connect(m_Controls.animateButton, SIGNAL(toggled(bool)), this, SLOT(OnAnimateButtonToggled(bool)));
connect(m_Controls.recordButton, SIGNAL(toggled(bool)), this, SLOT(OnRecordButtonToggled(bool)));
connect(m_Controls.resetButton, SIGNAL(clicked()), this, SLOT(OnResetButtonClicked()));
connect(m_Controls.stepButton, SIGNAL(clicked()), this, SLOT(OnStepButtonClicked()));
connect(m_Controls.simulationComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnSimulationComboBoxSelectionChanged(const mitk::DataNode*)));
connect(m_Controls.dtSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnDTSpinBoxValueChanged(double)));
connect(m_Controls.snapshotButton, SIGNAL(clicked()), this, SLOT(OnSnapshotButtonClicked()));
if (m_Controls.simulationComboBox->GetSelectedNode().IsNotNull())
this->OnSimulationComboBoxSelectionChanged(m_Controls.simulationComboBox->GetSelectedNode());
}
void QmitkSimulationView::OnAnimateButtonToggled(bool toggled)
{
if (this->SetSelectionAsCurrentSimulation())
{
mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
rootNode->getContext()->setAnimate(toggled);
if (toggled)
{
m_Controls.stepButton->setEnabled(false);
m_Timer.start(0);
}
}
if (!toggled)
{
m_Timer.stop();
m_Controls.stepButton->setEnabled(true);
}
}
void QmitkSimulationView::OnDTSpinBoxValueChanged(double value)
{
if (!this->SetSelectionAsCurrentSimulation())
return;
mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
- rootNode->setDt(value == 0.0
- ? simulation->GetDefaultDT()
- : value);
+ rootNode->setDt(std::max(0.0, value));
}
void QmitkSimulationView::OnNodeRemovedFromDataStorage(const mitk::DataNode* node)
{
if (m_Selection.IsNotNull() && m_Selection.GetPointer() == node)
m_SelectionWasRemovedFromDataStorage = true;
}
void QmitkSimulationView::OnRecordButtonToggled(bool toggled)
{
if (!toggled)
{
if (m_Record.IsNotNull())
{
mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
dataNode->SetData(m_Record);
dataNode->SetName(m_Record->GetTimeSteps() == 1 ? "Snapshot" : "Record");
this->GetDataStorage()->Add(dataNode, m_Selection);
- InitializeViews(this->GetRenderWindowPart(), m_Record->GetTimeSlicedGeometry());
+ mitk::RenderingManager::GetInstance()->InitializeViews(m_Record->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
m_Record = NULL;
}
m_Controls.stepsRecordedLabel->hide();
m_Controls.stepsRecordedLabel->setText("0 steps recorded");
}
else if (toggled)
{
m_Controls.stepsRecordedLabel->show();
}
}
void QmitkSimulationView::OnResetButtonClicked()
{
if (!this->SetSelectionAsCurrentSimulation())
return;
if (m_Controls.recordButton->isChecked())
m_Controls.recordButton->setChecked(false);
mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
- m_Controls.dtSpinBox->setValue(0.0);
+ m_Controls.dtSpinBox->setValue(simulation->GetDefaultDT());
sofaSimulation->reset(rootNode.get());
rootNode->setTime(0.0);
rootNode->execute<sofa::simulation::UpdateContextVisitor>(sofa::core::ExecParams::defaultInstance());
simulation->GetDrawTool()->Reset();
this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
}
void QmitkSimulationView::OnSimulationComboBoxSelectionChanged(const mitk::DataNode* node)
{
if (m_Controls.animateButton->isChecked())
m_Controls.animateButton->setChecked(false);
if (m_SelectionWasRemovedFromDataStorage)
{
m_SelectionWasRemovedFromDataStorage = false;
m_Selection = NULL;
}
if (m_Controls.recordButton->isChecked())
m_Controls.recordButton->setChecked(false);
if (node != NULL)
{
m_Selection = m_Controls.simulationComboBox->GetSelectedNode();
+ mitk::Simulation* simulation = static_cast<mitk::Simulation*>(m_Selection->GetData());
+
m_Controls.sceneGroupBox->setEnabled(true);
m_Controls.snapshotButton->setEnabled(true);
- static_cast<mitk::Simulation*>(node->GetData())->SetAsActiveSimulation();
+
+ simulation->SetAsActiveSimulation();
+ m_Controls.dtSpinBox->setValue(simulation->GetDefaultDT());
}
else
{
m_Selection = NULL;
+
m_Controls.sceneGroupBox->setEnabled(false);
m_Controls.snapshotButton->setEnabled(false);
+
mitk::Simulation::SetActiveSimulation(NULL);
+ m_Controls.dtSpinBox->setValue(0.0);
}
}
void QmitkSimulationView::OnSnapshotButtonClicked()
{
if (!this->SetSelectionAsCurrentSimulation())
return;
mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
mitk::Surface::Pointer snapshot = simulation->TakeSnapshot();
if (snapshot.IsNull())
return;
mitk::DataNode::Pointer snapshotDataNode = mitk::DataNode::New();
snapshotDataNode->SetData(snapshot);
snapshotDataNode->SetName("Snapshot");
this->GetDataStorage()->Add(snapshotDataNode, m_Selection);
}
void QmitkSimulationView::OnStepButtonClicked()
{
if (!this->SetSelectionAsCurrentSimulation())
return;
- mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Controls.simulationComboBox->GetSelectedNode()->GetData());
+ mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
simulation->GetDrawTool()->Reset();
sofaSimulation->animate(rootNode.get(), rootNode->getDt());
this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
if (m_Controls.recordButton->isChecked())
{
if (m_Record.IsNull())
m_Record = mitk::Surface::New();
- simulation->AppendSnapshot(m_Record);
-
- unsigned int numSteps = m_Record->GetTimeSteps();
- QString plural = numSteps != 1 ? "s" : "";
+ if (simulation->AppendSnapshot(m_Record))
+ {
+ unsigned int numSteps = m_Record->GetTimeSteps();
+ QString plural = numSteps != 1 ? "s" : "";
- m_Controls.stepsRecordedLabel->setText(QString("%1 step%2 recorded").arg(numSteps).arg(plural));
+ m_Controls.stepsRecordedLabel->setText(QString("%1 step%2 recorded").arg(numSteps).arg(plural));
+ }
+ else if (m_Record->GetTimeSteps() == 1)
+ {
+ m_Record = NULL;
+ }
}
}
void QmitkSimulationView::SetFocus()
{
m_Controls.animateButton->setFocus();
}
bool QmitkSimulationView::SetSelectionAsCurrentSimulation() const
{
if (m_Selection.IsNotNull())
{
static_cast<mitk::Simulation*>(m_Selection->GetData())->SetAsActiveSimulation();
return true;
}
return false;
}
void QmitkSimulationView::OnTimerTimeout()
{
this->OnStepButtonClicked();
}
diff --git a/Plugins/org.mitk.gui.qt.simulation/src/internal/org_mitk_gui_qt_simulation_Activator.cpp b/Plugins/org.mitk.gui.qt.simulation/src/internal/org_mitk_gui_qt_simulation_Activator.cpp
index d29e31d03b..9abd83b10a 100644
--- a/Plugins/org.mitk.gui.qt.simulation/src/internal/org_mitk_gui_qt_simulation_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.simulation/src/internal/org_mitk_gui_qt_simulation_Activator.cpp
@@ -1,42 +1,34 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "org_mitk_gui_qt_simulation_Activator.h"
+#include "QmitkCreateSimulationAction.h"
#include "QmitkSimulationPreferencePage.h"
#include "QmitkSimulationView.h"
-#include <mitkNodePredicateDataType.h>
-#include <QmitkNodeDescriptorManager.h>
#include <QtPlugin>
void mitk::org_mitk_gui_qt_simulation_Activator::start(ctkPluginContext* context)
{
+ BERRY_REGISTER_EXTENSION_CLASS(QmitkCreateSimulationAction, context);
BERRY_REGISTER_EXTENSION_CLASS(QmitkSimulationPreferencePage, context);
BERRY_REGISTER_EXTENSION_CLASS(QmitkSimulationView, context);
-
- QmitkNodeDescriptorManager* nodeDescriptorManager = QmitkNodeDescriptorManager::GetInstance();
-
- if (nodeDescriptorManager != NULL)
- {
- mitk::NodePredicateDataType::Pointer isSimulation = mitk::NodePredicateDataType::New("Simulation");
- nodeDescriptorManager->AddDescriptor(new QmitkNodeDescriptor("Simulation", ":/Simulation/icon.png", isSimulation, nodeDescriptorManager));
- }
}
void mitk::org_mitk_gui_qt_simulation_Activator::stop(ctkPluginContext*)
{
}
Q_EXPORT_PLUGIN2(org_mitk_gui_qt_simulation, mitk::org_mitk_gui_qt_simulation_Activator)
diff --git a/Plugins/org.mitk.gui.qt.toftutorial/src/internal/QmitkToFTutorialView.cpp b/Plugins/org.mitk.gui.qt.toftutorial/src/internal/QmitkToFTutorialView.cpp
index c80ad5df86..367f5220f3 100644
--- a/Plugins/org.mitk.gui.qt.toftutorial/src/internal/QmitkToFTutorialView.cpp
+++ b/Plugins/org.mitk.gui.qt.toftutorial/src/internal/QmitkToFTutorialView.cpp
@@ -1,195 +1,195 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkToFTutorialView.h"
#include "QmitkStdMultiWidget.h"
// Qt
#include <QMessageBox>
// mitk includes
#include <mitkCameraIntrinsics.h> // class holding the intrinsic parameters of the according camera
#include <mitkSurface.h>
// MITK-ToF related includes
#include <mitkToFCameraMITKPlayerDevice.h>
#include <mitkToFConfig.h> // configuration file holding e.g. plugin paths or path to test file directory
#include <mitkToFDistanceImageToSurfaceFilter.h> // filter from module ToFProcessing that calculates a surface from the given range image
#include <mitkToFImageGrabber.h> // allows access to images provided by the ToF camera
const std::string QmitkToFTutorialView::VIEW_ID = "org.mitk.views.toftutorial";
QmitkToFTutorialView::QmitkToFTutorialView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
{
}
QmitkToFTutorialView::~QmitkToFTutorialView()
{
}
void QmitkToFTutorialView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkToFTutorialViewControls;
m_Controls->setupUi( parent );
connect( m_Controls->step1Button, SIGNAL(clicked()), this, SLOT(OnStep1()) );
connect( m_Controls->step2Button, SIGNAL(clicked()), this, SLOT(OnStep2()) );
}
}
void QmitkToFTutorialView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkToFTutorialView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkToFTutorialView::OnStep1()
{
// clean up data storage
RemoveAllNodesFromDataStorage();
// Create an instance of ToFImageGrabber that holds a ToFCameraMITKPlayerDevice for playing ToF data
mitk::ToFImageGrabber::Pointer tofImageGrabber = mitk::ToFImageGrabber::New();
tofImageGrabber->SetCameraDevice(mitk::ToFCameraMITKPlayerDevice::New());
// set paths to test data
std::string distanceFileName = MITK_TOF_DATA_DIR;
distanceFileName.append("/PMDCamCube2_MF0_IT0_20Images_DistanceImage.pic");
std::string amplitudeFileName = MITK_TOF_DATA_DIR;
amplitudeFileName.append("/PMDCamCube2_MF0_IT0_20Images_AmplitudeImage.pic");
std::string intensityFileName = MITK_TOF_DATA_DIR;
intensityFileName.append("/PMDCamCube2_MF0_IT0_20Images_IntensityImage.pic");
// set file name property in image grabber. This will be propagated to the corresponding device and controller class
tofImageGrabber->SetProperty("DistanceImageFileName",mitk::StringProperty::New(distanceFileName));
tofImageGrabber->SetProperty("AmplitudeImageFileName",mitk::StringProperty::New(amplitudeFileName));
tofImageGrabber->SetProperty("IntensityImageFileName",mitk::StringProperty::New(intensityFileName));
// connect to device
if (tofImageGrabber->ConnectCamera())
{
//// start camera (internally starts thread that continuously grabs images from the camera)
tofImageGrabber->StartCamera();
// update image grabber which itself represents the source of a MITK filter pipeline
tofImageGrabber->Update();
// grab distance image
- mitk::Image::Pointer distanceImage = tofImageGrabber->GetOutput(0);
+ mitk::Image::Pointer distanceImage = tofImageGrabber->GetOutput();
// grab amplitude image
mitk::Image::Pointer amplitudeImage = tofImageGrabber->GetOutput(1);
// grab intensity image
mitk::Image::Pointer intensityImage = tofImageGrabber->GetOutput(2);
//add distance image to data storage
mitk::DataNode::Pointer distanceNode = mitk::DataNode::New();
distanceNode->SetName("Distance Image");
distanceNode->SetData(distanceImage);
this->GetDefaultDataStorage()->Add(distanceNode);
//add amplitude image to data storage
mitk::DataNode::Pointer amplitudeNode = mitk::DataNode::New();
amplitudeNode->SetName("Amplitude Image");
amplitudeNode->SetData(amplitudeImage);
this->GetDefaultDataStorage()->Add(amplitudeNode);
//add intensity image to data storage
mitk::DataNode::Pointer intensityNode = mitk::DataNode::New();
intensityNode->SetName("Intensity Image");
intensityNode->SetData(intensityImage);
this->GetDefaultDataStorage()->Add(intensityNode);
// stop camera (terminate internally used thread)
tofImageGrabber->StopCamera();
//// disconnect from camera
tofImageGrabber->DisconnectCamera();
// adjust views to new data in DataStorage
mitk::RenderingManager::GetInstance()->InitializeViews(distanceImage->GetGeometry());
}
else
{
MITK_ERROR<<"Connection to ToF camera could not be established";
}
}
void QmitkToFTutorialView::OnStep2()
{
// Check if distance image is available
mitk::DataNode::Pointer distanceNode = this->GetDefaultDataStorage()->GetNamedNode("Distance Image");
if (distanceNode.IsNotNull())
{
// get distance image from node and check if node contains image
mitk::Image::Pointer distanceImage = dynamic_cast<mitk::Image*>(distanceNode->GetData());
if (distanceImage.IsNotNull())
{
// create object of CameraIntrinsics that holds intrinsic parameters of the ToF camera
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
// set focal length in pixel
cameraIntrinsics->SetFocalLength(295.8,296.1);
// set principal point in pixel
cameraIntrinsics->SetPrincipalPoint(113.2,97.1);
// set up filter for surface calculation
mitk::ToFDistanceImageToSurfaceFilter::Pointer surfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
// apply intrinsic parameters to filter
surfaceFilter->SetCameraIntrinsics(cameraIntrinsics);
// set distance between pixels on chip in mm (in this example squared pixel)
mitk::ToFProcessingCommon::ToFPoint2D interPixelDistance;
interPixelDistance[0] = 0.045;
interPixelDistance[1] = 0.045;
surfaceFilter->SetInterPixelDistance(interPixelDistance);
// set distance image as input
surfaceFilter->SetInput(distanceImage);
// update the filter
surfaceFilter->Update();
// get surface from filter
mitk::Surface::Pointer surface = surfaceFilter->GetOutput();
// add surface to data storage
mitk::DataNode::Pointer surfaceNode = mitk::DataNode::New();
surfaceNode->SetName("ToF surface");
surfaceNode->SetData(surface);
this->GetDefaultDataStorage()->Add(surfaceNode);
// adjust views to new data in DataStorage
mitk::RenderingManager::GetInstance()->InitializeViews(surface->GetGeometry());
mitk::RenderingManager::GetInstance()->InitializeViews(surface->GetGeometry());
}
else
{
QMessageBox::warning(NULL,"ToF Tutorial","Node 'Distance Image' contains no image");
}
}
else
{
QMessageBox::warning(NULL,"ToF Tutorial","Perform Step 1 first to acquire a distance image");
}
}
void QmitkToFTutorialView::RemoveAllNodesFromDataStorage()
{
mitk::DataStorage::SetOfObjects::ConstPointer allNodes = this->GetDefaultDataStorage()->GetAll();
this->GetDefaultDataStorage()->Remove(allNodes);
}
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
index 3fde750bdb..36ce8f24f5 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,618 +1,663 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <mitkIRenderingManager.h>
#include <mitkIRenderWindowPart.h>
#include <mitkILinkedRenderWindowPart.h>
// Qmitk
#include "QmitkToFUtilView.h"
#include <QmitkStdMultiWidget.h>
#include <QmitkTextOverlay.h>
// Qt
#include <QMessageBox>
#include <QString>
//QT headers
#include <qmessagebox.h>
#include <qfiledialog.h>
#include <qcombobox.h>
// MITK
#include <mitkBaseRenderer.h>
#include <mitkGlobalInteraction.h>
#include <mitkLookupTableProperty.h>
#include <mitkToFDistanceImageToPointSetFilter.h>
#include <mitkTransferFunction.h>
#include <mitkTransferFunctionProperty.h>
#include <mitkToFDeviceFactoryManager.h>
#include <mitkToFCameraDevice.h>
#include <mitkCameraIntrinsicsProperty.h>
//itk headers
#include <itksys/SystemTools.hxx>
// VTK
#include <vtkCamera.h>
// ITK
#include <itkCommand.h>
+#include <mitkRenderingModeProperty.h>
const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
//Constructor
QmitkToFUtilView::QmitkToFUtilView()
- : QmitkAbstractView()
- , m_Controls(NULL), m_MultiWidget( NULL )
- , m_MitkDistanceImage(NULL), m_MitkAmplitudeImage(NULL), m_MitkIntensityImage(NULL), m_Surface(NULL)
- , m_DistanceImageNode(NULL), m_AmplitudeImageNode(NULL), m_IntensityImageNode(NULL), m_RGBImageNode(NULL), m_SurfaceNode(NULL)
- , m_ToFImageRecorder(NULL), m_ToFImageGrabber(NULL), m_ToFDistanceImageToSurfaceFilter(NULL), m_ToFCompositeFilter(NULL)
- , m_2DDisplayCount(0)
- , m_RealTimeClock(NULL)
- , m_StepsForFramerate(100)
- , m_2DTimeBefore(0.0)
- , m_2DTimeAfter(0.0)
- , m_CameraIntrinsics(NULL)
+ : QmitkAbstractView()
+ , m_Controls(NULL), m_MultiWidget( NULL )
+ , m_MitkDistanceImage(NULL), m_MitkAmplitudeImage(NULL), m_MitkIntensityImage(NULL), m_Surface(NULL)
+ , m_DistanceImageNode(NULL), m_AmplitudeImageNode(NULL), m_IntensityImageNode(NULL), m_RGBImageNode(NULL), m_SurfaceNode(NULL)
+ , m_ToFImageRecorder(NULL), m_ToFImageGrabber(NULL), m_ToFDistanceImageToSurfaceFilter(NULL), m_ToFCompositeFilter(NULL)
+ , m_2DDisplayCount(0)
+ , m_RealTimeClock(NULL)
+ , m_StepsForFramerate(100)
+ , m_2DTimeBefore(0.0)
+ , m_2DTimeAfter(0.0)
+ , m_CameraIntrinsics(NULL)
{
- this->m_Frametimer = new QTimer(this);
+ this->m_Frametimer = new QTimer(this);
- this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
- this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
- this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
- this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
+ this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
+ this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
+ this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
+ this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
}
//Destructor, specifically calling OnToFCameraStopped() and OnToFCammeraDiconnected()
QmitkToFUtilView::~QmitkToFUtilView()
{
- OnToFCameraStopped();
- OnToFCameraDisconnected();
+ OnToFCameraStopped();
+ OnToFCameraDisconnected();
}
//Createing the PartControl Signal-Slot principal
void QmitkToFUtilView::CreateQtPartControl( QWidget *parent )
{
- // build up qt view, unless already done
- if ( !m_Controls )
- {
- // create GUI widgets from the Qt Designer's .ui file
- m_Controls = new Ui::QmitkToFUtilViewControls;
- m_Controls->setupUi( parent );
-
- //Looking for Input and Defining reaction
- connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
-
- connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(KinectAcquisitionModeChanged()), this, SLOT(OnKinectAcquisitionModeChanged()) ); // Todo in Widget2
- connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
- connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
- connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraSelected(const QString)), this, SLOT(OnToFCameraSelected(const QString)) );
- connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
- connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
- connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
- connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
- connect( (QObject*)(m_Controls->m_SurfaceCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnSurfaceCheckboxChecked(bool)) );
- connect( (QObject*)(m_Controls->m_TextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTextureCheckBoxChecked(bool)) );
- connect( (QObject*)(m_Controls->m_KinectTextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnKinectRGBTextureCheckBoxChecked(bool)) );
-
- }
+ // build up qt view, unless already done
+ if ( !m_Controls )
+ {
+ // create GUI widgets from the Qt Designer's .ui file
+ m_Controls = new Ui::QmitkToFUtilViewControls;
+ m_Controls->setupUi( parent );
+
+ //Looking for Input and Defining reaction
+ connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
+
+ connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(KinectAcquisitionModeChanged()), this, SLOT(OnKinectAcquisitionModeChanged()) ); // Todo in Widget2
+ connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
+ connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
+ connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraSelected(const QString)), this, SLOT(OnToFCameraSelected(const QString)) );
+ connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
+ connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
+ connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
+ connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
+ connect( (QObject*)(m_Controls->m_SurfaceCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnSurfaceCheckboxChecked(bool)) );
+ connect( (QObject*)(m_Controls->m_TextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTextureCheckBoxChecked(bool)) );
+ connect( (QObject*)(m_Controls->m_KinectTextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnKinectRGBTextureCheckBoxChecked(bool)) );
+
+ }
}
//SetFocus-Method -> actually seting Focus to the Recorder
void QmitkToFUtilView::SetFocus()
{
- m_Controls->m_ToFRecorderWidget->setFocus();
+ m_Controls->m_ToFRecorderWidget->setFocus();
}
//Activated-Method->Generating RenderWindow
void QmitkToFUtilView::Activated()
{
- //get the current RenderWindowPart or open a new one if there is none
- if(this->GetRenderWindowPart(OPEN))
+ //get the current RenderWindowPart or open a new one if there is none
+ if(this->GetRenderWindowPart(OPEN))
+ {
+ mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
+ if(linkedRenderWindowPart == 0)
+ {
+ MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
+ }
+ else
+ {
+ linkedRenderWindowPart->EnableSlicingPlanes(false);
+ }
+ GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
+ GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOn();
+ GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
+ GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOn();
+ GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
+ GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOn();
+
+ this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
+
+ this->UseToFVisibilitySettings(true);
+
+ if (this->m_ToFCompositeFilter)
+ {
+ m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
+ }
+ if (this->GetDataStorage())
+ {
+ m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
+ }
+
+ if (this->m_ToFImageGrabber.IsNull())
{
- mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
- if(linkedRenderWindowPart == 0)
- {
- MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
- }
- else
- {
- linkedRenderWindowPart->EnableSlicingPlanes(false);
- }
- GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
- GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOn();
- GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
- GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOn();
- GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
- GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOn();
-
- this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
-
- this->UseToFVisibilitySettings(true);
-
- if (this->m_ToFCompositeFilter)
- {
- m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
- }
- if (this->GetDataStorage())
- {
- m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
- }
-
- if (this->m_ToFImageGrabber.IsNull())
- {
- m_Controls->m_ToFRecorderWidget->setEnabled(false);
- m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
- m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
- m_Controls->tofMeasurementWidget->setEnabled(false);
- m_Controls->SurfacePropertiesBox->setEnabled(false);
- }
+ m_Controls->m_ToFRecorderWidget->setEnabled(false);
+ m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
+ m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
+ m_Controls->tofMeasurementWidget->setEnabled(false);
+ m_Controls->SurfacePropertiesBox->setEnabled(false);
}
+ }
}
//ZomnnieView-Method -> Resetting GUI to default. Why not just QmitkToFUtilView()?!
void QmitkToFUtilView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer /*zombieView*/)
{
- ResetGUIToDefault();
+ ResetGUIToDefault();
}
void QmitkToFUtilView::Deactivated()
{
}
void QmitkToFUtilView::Visible()
{
}
//Reset of the ToFUtilView
void QmitkToFUtilView::Hidden()
{
- ResetGUIToDefault();
+ ResetGUIToDefault();
}
void QmitkToFUtilView::OnToFCameraConnected()
{
- MITK_DEBUG <<"OnToFCameraConnected";
- this->m_2DDisplayCount = 0;
+ MITK_DEBUG <<"OnToFCameraConnected";
+ this->m_2DDisplayCount = 0;
+
+ this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
+
+ // initialize surface generation
+ this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
+ this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
+
+ // initialize ToFImageRecorder and ToFRecorderWidget
+ this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
+ this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
+ m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
+ m_Controls->m_ToFRecorderWidget->setEnabled(true);
+ m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
+ m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
+
+ // initialize ToFCompositeFilterWidget
+ this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
+ if (this->m_ToFCompositeFilter)
+ {
+ m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
+ }
+ if (this->GetDataStorage())
+ {
+ m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
+ }
- this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
+ // initialize measurement widget
+ m_Controls->tofMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage(), this->m_ToFDistanceImageToSurfaceFilter->GetCameraIntrinsics());
- // initialize surface generation
- this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
- this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
+ this->m_RealTimeClock = mitk::RealTimeClock::New();
+ this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
- // initialize ToFImageRecorder and ToFRecorderWidget
- this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
- this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
- m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
- m_Controls->m_ToFRecorderWidget->setEnabled(true);
- m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
- m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
+ this->RequestRenderWindowUpdate();
+}
- // initialize ToFCompositeFilterWidget
- this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
- if (this->m_ToFCompositeFilter)
+void QmitkToFUtilView::ResetGUIToDefault()
+{
+ if(this->GetRenderWindowPart())
+ {
+ mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
+ if(linkedRenderWindowPart == 0)
{
- m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
+ MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
}
- if (this->GetDataStorage())
+ else
{
- m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
+ linkedRenderWindowPart->EnableSlicingPlanes(true);
}
+ GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
+ GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOff();
+ GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
+ GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOff();
+ GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
+ GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOff();
- // initialize measurement widget
- m_Controls->tofMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage(), this->m_ToFDistanceImageToSurfaceFilter->GetCameraIntrinsics());
-
- this->m_RealTimeClock = mitk::RealTimeClock::New();
- this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
+ this->UseToFVisibilitySettings(false);
+ //global reinit
+ this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
this->RequestRenderWindowUpdate();
-}
-
-void QmitkToFUtilView::ResetGUIToDefault()
-{
- if(this->GetRenderWindowPart())
- {
- mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
- if(linkedRenderWindowPart == 0)
- {
- MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
- }
- else
- {
- linkedRenderWindowPart->EnableSlicingPlanes(true);
- }
- GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
- GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOff();
- GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
- GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOff();
- GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
- GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOff();
-
- this->UseToFVisibilitySettings(false);
-
- //global reinit
- this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
- this->RequestRenderWindowUpdate();
- }
+ }
}
void QmitkToFUtilView::OnToFCameraDisconnected()
{
- m_Controls->m_ToFRecorderWidget->OnStop();
- m_Controls->m_ToFRecorderWidget->setEnabled(false);
- m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
- m_Controls->tofMeasurementWidget->setEnabled(false);
- m_Controls->SurfacePropertiesBox->setEnabled(false);
- //clean up measurement widget
- m_Controls->tofMeasurementWidget->CleanUpWidget();
+ m_Controls->m_ToFRecorderWidget->OnStop();
+ m_Controls->m_ToFRecorderWidget->setEnabled(false);
+ m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
+ m_Controls->tofMeasurementWidget->setEnabled(false);
+ m_Controls->SurfacePropertiesBox->setEnabled(false);
+ //clean up measurement widget
+ m_Controls->tofMeasurementWidget->CleanUpWidget();
}
void QmitkToFUtilView::OnKinectAcquisitionModeChanged()
{
- if (m_ToFCompositeFilter.IsNotNull()&&m_ToFImageGrabber.IsNotNull())
+ if (m_ToFCompositeFilter.IsNotNull()&&m_ToFImageGrabber.IsNotNull())
+ {
+ if (m_SelectedCamera.contains("Kinect"))
{
- if (m_SelectedCamera.contains("Kinect"))
- {
- if (m_ToFImageGrabber->GetBoolProperty("RGB"))
- {
- this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
- this->m_ToFDistanceImageToSurfaceFilter->SetInput(3,this->m_ToFImageGrabber->GetOutput(3));
- }
- else if (m_ToFImageGrabber->GetBoolProperty("IR"))
- {
- this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
- this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
- }
- }
- this->UseToFVisibilitySettings(true);
+ if (m_ToFImageGrabber->GetBoolProperty("RGB"))
+ {
+ this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
+ this->m_ToFDistanceImageToSurfaceFilter->SetInput(3,this->m_ToFImageGrabber->GetOutput(3));
+ }
+ else if (m_ToFImageGrabber->GetBoolProperty("IR"))
+ {
+ this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
+ this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
+ }
}
+ this->UseToFVisibilitySettings(true);
+ }
}
void QmitkToFUtilView::OnToFCameraStarted()
{
if (m_ToFImageGrabber.IsNotNull())
{
// initialize camera intrinsics
if (this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))
{
m_CameraIntrinsics = dynamic_cast<mitk::CameraIntrinsicsProperty*>(this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))->GetValue();
MITK_INFO << m_CameraIntrinsics->ToString();
}
else
{
m_CameraIntrinsics = NULL;
MITK_ERROR << "No camera intrinsics were found!";
}
// initial update of image grabber
this->m_ToFImageGrabber->Update();
- this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
- this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
- this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
-
- // initial update of composite filter
- this->m_ToFCompositeFilter->Update();
- this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput(0);
- this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
-
- std::string rgbFileName;
- m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
-
- if ((m_SelectedCamera.contains("Kinect"))||(rgbFileName!=""))
- {
- //set the reconstruction mode for kinect
- this->m_ToFDistanceImageToSurfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::Kinect);
- if (rgbFileName!="" || m_ToFImageGrabber->GetBoolProperty("RGB") )
- {
- this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
- }
- else if (m_ToFImageGrabber->GetBoolProperty("IR"))
- {
- this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
- }
- }
- else
- {
- this->m_RGBImageNode = NULL;
- this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
- this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
- this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
- this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
- }
- this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
- this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
-
- this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
- this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
- this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
- this->m_Surface = this->m_ToFDistanceImageToSurfaceFilter->GetOutput(0);
- this->m_SurfaceNode = ReplaceNodeData("Surface",m_Surface);
-
- this->UseToFVisibilitySettings(true);
-
- m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
- // initialize visualization widget
- m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode, this->m_AmplitudeImageNode, this->m_IntensityImageNode);
- // set distance image to measurement widget
- m_Controls->tofMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
-
- this->m_Frametimer->start(0);
-
- m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
- m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
- m_Controls->tofMeasurementWidget->setEnabled(true);
- m_Controls->SurfacePropertiesBox->setEnabled(true);
-
- if (m_Controls->m_TextureCheckBox->isChecked())
- {
- OnTextureCheckBoxChecked(true);
- }
- if (m_Controls->m_KinectTextureCheckBox->isChecked())
- {
- OnKinectRGBTextureCheckBoxChecked(true);
- }
+ this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
+ this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
+ this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
+
+ // initial update of composite filter
+ this->m_ToFCompositeFilter->Update();
+ this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput();
+ this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
+
+ std::string rgbFileName;
+ m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
+
+ bool hasRGBImage = false;
+ m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasRGBImage",hasRGBImage);
+
+ bool hasIntensityImage = false;
+ m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasIntensityImage",hasIntensityImage);
+
+ bool hasAmplitudeImage = false;
+ m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasAmplitudeImage",hasAmplitudeImage);
+
+ bool KinectReconstructionMode = false;
+ m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("KinectReconstructionMode",KinectReconstructionMode);
+ if(KinectReconstructionMode)
+ {
+ //set the reconstruction mode for kinect
+ this->m_ToFDistanceImageToSurfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::Kinect);
}
- m_Controls->m_TextureCheckBox->setEnabled(true);
+
+ if(hasRGBImage || (rgbFileName!=""))
+ {
+ if(m_ToFImageGrabber->GetBoolProperty("IR"))
+ {
+ this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
+ }
+ else
+ {
+ this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
+ }
+ }
+ else
+ {
+ this->m_RGBImageNode = NULL;
+ }
+
+ if(hasAmplitudeImage)
+ {
+ this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
+ this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
+ }
+
+ if(hasIntensityImage)
+ {
+ this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
+ this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
+ }
+
+ // if ((rgbFileName!="") || hasRGBImage)
+ // {
+
+ // }
+ // else
+ // {
+
+
+ // }
+ // this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
+ // this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
+
+ this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
+ this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
+ this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
+ this->m_Surface = this->m_ToFDistanceImageToSurfaceFilter->GetOutput(0);
+ this->m_SurfaceNode = ReplaceNodeData("Surface",m_Surface);
+
+ this->UseToFVisibilitySettings(true);
+
+ m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
+ // initialize visualization widget
+ m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode, this->m_AmplitudeImageNode, this->m_IntensityImageNode);
+ // set distance image to measurement widget
+ m_Controls->tofMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
+
+ this->m_Frametimer->start(0);
+
+ m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
+ m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
+ m_Controls->tofMeasurementWidget->setEnabled(true);
+ m_Controls->SurfacePropertiesBox->setEnabled(true);
+
+ if (m_Controls->m_TextureCheckBox->isChecked())
+ {
+ OnTextureCheckBoxChecked(true);
+ }
+ if (m_Controls->m_KinectTextureCheckBox->isChecked())
+ {
+ OnKinectRGBTextureCheckBoxChecked(true);
+ }
+ }
+ m_Controls->m_TextureCheckBox->setEnabled(true);
}
void QmitkToFUtilView::OnToFCameraStopped()
{
- m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
- m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
- m_Controls->SurfacePropertiesBox->setEnabled(false);
+ m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
+ m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
+ m_Controls->SurfacePropertiesBox->setEnabled(false);
- this->m_Frametimer->stop();
+ this->m_Frametimer->stop();
}
void QmitkToFUtilView::OnToFCameraSelected(const QString selected)
{
- m_SelectedCamera = selected;
- if ((selected.contains("CamBoard"))||(selected.contains("O3D")))
- {
- MITK_INFO<<"Surface representation currently not available for CamBoard and O3. Intrinsic parameters missing.";
- this->m_Controls->m_SurfaceCheckBox->setEnabled(false);
- this->m_Controls->m_TextureCheckBox->setEnabled(false);
- this->m_Controls->m_KinectTextureCheckBox->setEnabled(false);
- this->m_Controls->m_SurfaceCheckBox->setChecked(false);
- this->m_Controls->m_TextureCheckBox->setChecked(false);
- this->m_Controls->m_KinectTextureCheckBox->setChecked(false);
- }
- else
- {
- this->m_Controls->m_SurfaceCheckBox->setEnabled(true);
- this->m_Controls->m_TextureCheckBox->setEnabled(true);
- this->m_Controls->m_KinectTextureCheckBox->setEnabled(true);
- }
+ m_SelectedCamera = selected;
+ if (selected.contains("O3D"))
+ {
+ MITK_INFO<<"Surface representation currently not available for CamBoard and O3. Intrinsic parameters missing.";
+ this->m_Controls->m_SurfaceCheckBox->setEnabled(false);
+ this->m_Controls->m_TextureCheckBox->setEnabled(false);
+ this->m_Controls->m_KinectTextureCheckBox->setEnabled(false);
+ this->m_Controls->m_SurfaceCheckBox->setChecked(false);
+ this->m_Controls->m_TextureCheckBox->setChecked(false);
+ this->m_Controls->m_KinectTextureCheckBox->setChecked(false);
+ }
+ else
+ {
+ this->m_Controls->m_SurfaceCheckBox->setEnabled(true);
+ this->m_Controls->m_TextureCheckBox->setEnabled(true);
+ this->m_Controls->m_KinectTextureCheckBox->setEnabled(true);
+ }
}
void QmitkToFUtilView::OnSurfaceCheckboxChecked(bool checked)
{
- if(checked)
- {
- //initialize the surface once
- MITK_DEBUG << "OnSurfaceCheckboxChecked true";
- this->m_SurfaceNode->SetData(this->m_Surface);
- this->m_SurfaceNode->SetMapper(mitk::BaseRenderer::Standard3D, m_ToFSurfaceVtkMapper3D);
-
- //we need to initialize (reinit) the surface, to make it fit into the renderwindow
- this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
- this->m_Surface->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
-
- //the default camera position is rather unfortunate,
- //that's why we set our own position according to the surface center
- mitk::Point3D surfaceCenter= this->m_Surface->GetGeometry()->GetCenter();
- vtkCamera* camera3d = GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera();
- //1m distance to camera should be a nice default value for most cameras
- camera3d->SetPosition(0,0,-1000);
- camera3d->SetViewUp(0,-1,0);
- camera3d->SetFocalPoint(0,0,surfaceCenter[2]);
- camera3d->SetViewAngle(40);
- camera3d->SetClippingRange(1, 10000);
- }
+ if(checked)
+ {
+ //initialize the surface once
+ MITK_DEBUG << "OnSurfaceCheckboxChecked true";
+ this->m_SurfaceNode->SetData(this->m_Surface);
+ this->m_SurfaceNode->SetMapper(mitk::BaseRenderer::Standard3D, m_ToFSurfaceVtkMapper3D);
+
+ //we need to initialize (reinit) the surface, to make it fit into the renderwindow
+ this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
+ this->m_Surface->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
+
+ //the default camera position is rather unfortunate,
+ //that's why we set our own position according to the surface center
+ mitk::Point3D surfaceCenter= this->m_Surface->GetGeometry()->GetCenter();
+ vtkCamera* camera3d = GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera();
+ //1m distance to camera should be a nice default value for most cameras
+ camera3d->SetPosition(0,0,-1000);
+ camera3d->SetViewUp(0,-1,0);
+ camera3d->SetFocalPoint(0,0,surfaceCenter[2]);
+ camera3d->SetViewAngle(40);
+ camera3d->SetClippingRange(1, 10000);
+ }
}
void QmitkToFUtilView::OnUpdateCamera()
{
- //##### Code for surface #####
- if (m_Controls->m_SurfaceCheckBox->isChecked())
+ //##### Code for surface #####
+ if (m_Controls->m_SurfaceCheckBox->isChecked())
+ {
+ // update surface
+ m_ToFDistanceImageToSurfaceFilter->SetTextureIndex(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedImageIndex());
+
+ //if the user wants to see the texture, it has to be updated for every frame
+ if(m_Controls->m_KinectTextureCheckBox->isChecked() && (m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
{
- // update surface
- m_ToFDistanceImageToSurfaceFilter->SetTextureIndex(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedImageIndex());
-
- //if the user wants to see the texture, it has to be updated for every frame
- if(m_Controls->m_KinectTextureCheckBox->isChecked() && (m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
- {
- //remove the vtkScalarsToColors object, if there was one.
- this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(NULL);
- //set RGB-iamge as texture
- this->m_ToFSurfaceVtkMapper3D->SetTexture((this->m_ToFImageGrabber->GetOutput(3)->GetVtkImageData()));
- }
- else
- {
- //we have to delete the texture, if there was one.
- this->m_ToFSurfaceVtkMapper3D->SetTexture(NULL);
- //get the colortransferfunction from the visualization widget
- this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedColorTransferFunction());
- }
- //update pipeline
- this->m_Surface->Update();
+ //remove the vtkScalarsToColors object, if there was one.
+ this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(NULL);
+ //set RGB-iamge as texture
+ this->m_ToFSurfaceVtkMapper3D->SetTexture((this->m_ToFImageGrabber->GetOutput(3)->GetVtkImageData()));
}
- //##### End code for surface #####
else
{
- // update pipeline
- this->m_MitkDistanceImage->Update();
+ //we have to delete the texture, if there was one.
+ this->m_ToFSurfaceVtkMapper3D->SetTexture(NULL);
+ //get the colortransferfunction from the visualization widget
+ this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedColorTransferFunction());
}
+ //update pipeline
+ this->m_Surface->Update();
+ }
+ //##### End code for surface #####
+ else
+ {
+ // update pipeline
+ this->m_MitkDistanceImage->Update();
+ }
- this->RequestRenderWindowUpdate();
+ this->RequestRenderWindowUpdate();
- this->m_2DDisplayCount++;
- if ((this->m_2DDisplayCount % this->m_StepsForFramerate) == 0)
- {
- this->m_2DTimeAfter = this->m_RealTimeClock->GetCurrentStamp() - this->m_2DTimeBefore;
- MITK_INFO << " 2D-Display-framerate (fps): " << this->m_StepsForFramerate / (this->m_2DTimeAfter/1000);
- this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
- }
+ this->m_2DDisplayCount++;
+ if ((this->m_2DDisplayCount % this->m_StepsForFramerate) == 0)
+ {
+ this->m_2DTimeAfter = this->m_RealTimeClock->GetCurrentStamp() - this->m_2DTimeBefore;
+ MITK_INFO << " 2D-Display-framerate (fps): " << this->m_StepsForFramerate / (this->m_2DTimeAfter/1000);
+ this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
+ }
}
void QmitkToFUtilView::OnTextureCheckBoxChecked(bool checked)
{
- if(m_SurfaceNode.IsNotNull())
+ if(m_SurfaceNode.IsNotNull())
+ {
+ if (checked)
+ {
+ this->m_SurfaceNode->SetBoolProperty("scalar visibility", true);
+ }
+ else
{
- if (checked)
- {
- this->m_SurfaceNode->SetBoolProperty("scalar visibility", true);
- }
- else
- {
- this->m_SurfaceNode->SetBoolProperty("scalar visibility", false);
- }
+ this->m_SurfaceNode->SetBoolProperty("scalar visibility", false);
}
+ }
}
void QmitkToFUtilView::OnKinectRGBTextureCheckBoxChecked(bool checked)
{
- if((m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
+ if((m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
+ {
+ if (checked)
{
- if (checked)
- {
- //define the dimensions of the texture
- this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageWidth(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(0));
- this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageHeight(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(1));
- }
+ //define the dimensions of the texture
+ this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageWidth(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(0));
+ this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageHeight(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(1));
}
+ }
}
void QmitkToFUtilView::OnChangeCoronalWindowOutput(int index)
{
- this->OnToFCameraStopped();
- if(index == 0)
- {
- if(this->m_IntensityImageNode.IsNotNull())
- this->m_IntensityImageNode->SetVisibility(false);
- if(this->m_RGBImageNode.IsNotNull())
- this->m_RGBImageNode->SetVisibility(true);
- }
- else if(index == 1)
- {
- if(this->m_IntensityImageNode.IsNotNull())
- this->m_IntensityImageNode->SetVisibility(true);
- if(this->m_RGBImageNode.IsNotNull())
- this->m_RGBImageNode->SetVisibility(false);
- }
- this->RequestRenderWindowUpdate();
- this->OnToFCameraStarted();
+ this->OnToFCameraStopped();
+ if(index == 0)
+ {
+ if(this->m_IntensityImageNode.IsNotNull())
+ this->m_IntensityImageNode->SetVisibility(false);
+ if(this->m_RGBImageNode.IsNotNull())
+ this->m_RGBImageNode->SetVisibility(true);
+ }
+ else if(index == 1)
+ {
+ if(this->m_IntensityImageNode.IsNotNull())
+ this->m_IntensityImageNode->SetVisibility(true);
+ if(this->m_RGBImageNode.IsNotNull())
+ this->m_RGBImageNode->SetVisibility(false);
+ }
+ this->RequestRenderWindowUpdate();
+ this->OnToFCameraStarted();
}
mitk::DataNode::Pointer QmitkToFUtilView::ReplaceNodeData( std::string nodeName, mitk::BaseData* data )
{
- mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
- if (node.IsNull())
- {
- node = mitk::DataNode::New();
- node->SetData(data);
- node->SetName(nodeName);
- node->SetBoolProperty("binary",false);
- this->GetDataStorage()->Add(node);
- }
- else
- {
- node->SetData(data);
- }
- return node;
+ mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
+ if (node.IsNull())
+ {
+ node = mitk::DataNode::New();
+ node->SetData(data);
+ node->SetName(nodeName);
+ node->SetBoolProperty("binary",false);
+ this->GetDataStorage()->Add(node);
+ }
+ else
+ {
+ node->SetData(data);
+ }
+ return node;
}
void QmitkToFUtilView::UseToFVisibilitySettings(bool useToF)
{
- // set node properties
- if (m_DistanceImageNode.IsNotNull())
+ //We need this property for every node.
+ mitk::RenderingModeProperty::Pointer renderingModePropertyForTransferFunction = mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
+
+ // set node properties
+ if (m_DistanceImageNode.IsNotNull())
+ {
+ this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
+ this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
+ this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
+ this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
+ this->m_DistanceImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
+ }
+ if (m_AmplitudeImageNode.IsNotNull())
+ {
+ if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("RGB")))
{
- this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
- this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
- this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
- this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
- this->m_DistanceImageNode->SetBoolProperty("use color",!useToF);
- this->m_DistanceImageNode->GetPropertyList()->DeleteProperty("LookupTable");
+ this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
}
- if (m_AmplitudeImageNode.IsNotNull())
+ else
{
- if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("RGB")))
- {
- this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
- }
- else
- {
- this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
- }
- this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
- this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
- this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
- this->m_AmplitudeImageNode->SetBoolProperty("use color",!useToF);
- this->m_AmplitudeImageNode->GetPropertyList()->DeleteProperty("LookupTable");
+ this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
}
- if (m_IntensityImageNode.IsNotNull())
+ this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
+ this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
+ this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
+ this->m_AmplitudeImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
+ }
+ if (m_IntensityImageNode.IsNotNull())
+ {
+ if (m_SelectedCamera.contains("Kinect"))
{
- if (m_SelectedCamera.contains("Kinect"))
- {
- this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
- }
- else
- {
- this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
- this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
- this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
- this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
- this->m_IntensityImageNode->SetBoolProperty("use color",!useToF);
- this->m_IntensityImageNode->GetPropertyList()->DeleteProperty("LookupTable");
- }
+ this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
}
- if ((m_RGBImageNode.IsNotNull()))
+ else
{
- if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("IR")))
- {
- this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
- }
- else
- {
- this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
- this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
- this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
- this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
- }
+ this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
+ this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
+ this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
+ this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
+ this->m_IntensityImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
}
- // initialize images
- if (m_MitkDistanceImage.IsNotNull())
+ }
+ if ((m_RGBImageNode.IsNotNull()))
+ {
+ if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("IR")))
{
- this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
- this->m_MitkDistanceImage->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
+ this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
}
- if(this->m_SurfaceNode.IsNotNull())
+ else
+ {
+ this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
+ this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
+ this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
+ this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
+ }
+ }
+ // initialize images
+ if (m_MitkDistanceImage.IsNotNull())
+ {
+ this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
+ this->m_MitkDistanceImage->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
+ }
+ if(this->m_SurfaceNode.IsNotNull())
+ {
+ QHash<QString, QmitkRenderWindow*> renderWindowHashMap = this->GetRenderWindowPart()->GetQmitkRenderWindows();
+ QHashIterator<QString, QmitkRenderWindow*> i(renderWindowHashMap);
+ while (i.hasNext()){
+ i.next();
+ this->m_SurfaceNode->SetVisibility( false, mitk::BaseRenderer::GetInstance(i.value()->GetRenderWindow()) );
+ }
+ this->m_SurfaceNode->SetVisibility( true, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
+ }
+ //disable/enable gradient background
+ this->GetRenderWindowPart()->EnableDecorations(!useToF, QStringList(QString("background")));
+
+ if((this->m_RGBImageNode.IsNotNull()))
+ {
+ bool RGBImageHasDifferentResolution = false;
+ m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("RGBImageHasDifferentResolution",RGBImageHasDifferentResolution);
+ if(RGBImageHasDifferentResolution)
{
- QHash<QString, QmitkRenderWindow*> renderWindowHashMap = this->GetRenderWindowPart()->GetQmitkRenderWindows();
- QHashIterator<QString, QmitkRenderWindow*> i(renderWindowHashMap);
- while (i.hasNext()){
- i.next();
- this->m_SurfaceNode->SetVisibility( false, mitk::BaseRenderer::GetInstance(i.value()->GetRenderWindow()) );
- }
- this->m_SurfaceNode->SetVisibility( true, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
+ //update the display geometry by using the RBG image node. Only for renderwindow coronal
+ mitk::RenderingManager::GetInstance()->InitializeView( GetRenderWindowPart()->GetRenderWindow("coronal")->GetRenderWindow(), this->m_RGBImageNode->GetData()->GetGeometry() );
}
- //disable/enable gradient background
- this->GetRenderWindowPart()->EnableDecorations(!useToF, QStringList(QString("background")));
+ }
}
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.h b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.h
index 86f31022e3..f7f1067ec8 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.h
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.h
@@ -1,193 +1,193 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkToFUtilView_h
#define QmitkToFUtilView_h
#include <QmitkOverlayController.h>
#include <QmitkAbstractView.h>
#include <berryIWorkbenchPartReference.h>
#include <mitkIZombieViewPart.h>
#include <ui_QmitkToFUtilViewControls.h>
class QTimer;
#include <mitkRealTimeClock.h>
#include <mitkToFImageGrabber.h>
#include <mitkOpenCVVideoSource.h>
#include <mitkSurface.h>
#include <mitkToFDistanceImageToSurfaceFilter.h>
#include <mitkToFSurfaceVtkMapper3D.h>
#include <mitkToFImageRecorder.h>
#include <mitkToFCompositeFilter.h>
#include <mitkCameraIntrinsics.h>
/*!
\brief QmitkToFUtilView
Application that allows simple playing, recording, visualization, processing and measurement of Time-of-Flight (ToF) data.
Currently the following features are implemented:
<ul>
<li>Connecting and showing ToF data from various cameras (PMD CamCube 2/3, PMD CamBoard, PMD O3, MESA SwissRanger)</li>
<li>Recording and playing of ToF data</li>
<li>Color coded visualization of ToF images</li>
<li>Preprocessing of the distance data: Threshold, median, average and bilateral filtering; surface generation</li>
<li>Simple measurement and PointSet definition</li>
</ul>
\sa QmitkFunctionality
\ingroup Functionalities
*/
class QmitkToFUtilView : public QmitkAbstractView, public mitk::IZombieViewPart
{
- // this is needed for all Qt objects that should have a Qt meta-object
- // (everything that derives from QObject and wants to have signal/slots)
- Q_OBJECT
+ // this is needed for all Qt objects that should have a Qt meta-object
+ // (everything that derives from QObject and wants to have signal/slots)
+ Q_OBJECT
public:
- static const std::string VIEW_ID;
+ static const std::string VIEW_ID;
- QmitkToFUtilView();
- ~QmitkToFUtilView();
+ QmitkToFUtilView();
+ ~QmitkToFUtilView();
- virtual void CreateQtPartControl(QWidget *parent);
- /// \brief Called when the functionality is activated.
- virtual void Activated();
- /// \brief Called when the functionality is deactivated. In this case the zombie view of this functionality becomes active!
- virtual void ActivatedZombieView(berry::IWorkbenchPartReference::Pointer zombieView);
+ virtual void CreateQtPartControl(QWidget *parent);
+ /// \brief Called when the functionality is activated.
+ virtual void Activated();
+ /// \brief Called when the functionality is deactivated. In this case the zombie view of this functionality becomes active!
+ virtual void ActivatedZombieView(berry::IWorkbenchPartReference::Pointer zombieView);
- virtual void Deactivated();
- virtual void Visible();
- virtual void Hidden();
+ virtual void Deactivated();
+ virtual void Visible();
+ virtual void Hidden();
- void SetFocus();
+ void SetFocus();
protected slots:
- /*!
+ /*!
\brief Slot triggered from the timer to update the images and visualization
*/
- void OnUpdateCamera();
- /*!
+ void OnUpdateCamera();
+ /*!
\brief Slot called when the "Connect" button of the ConnectionWidget is pressed
*/
- void OnToFCameraConnected();
- /*!
+ void OnToFCameraConnected();
+ /*!
\brief Slot called when the "Disconnect" button of the ConnectionWidget is pressed
*/
- void OnToFCameraDisconnected();
- /*!
+ void OnToFCameraDisconnected();
+ /*!
\brief Slot called when the camera selection in the ConnectionWidget has changed
*/
- void OnToFCameraSelected(const QString selected);
- /*!
+ void OnToFCameraSelected(const QString selected);
+ /*!
\brief Slot called when the "Start" button of the RecorderWidget is pressed
*/
- void OnToFCameraStarted();
- /*!
+ void OnToFCameraStarted();
+ /*!
\brief Slot called when the "Stop" button of the RecorderWidget is pressed
*/
- void OnToFCameraStopped();
- /*!
+ void OnToFCameraStopped();
+ /*!
\brief Slot invoked when the texture checkbox is checked. Enables the scalar visibility of the surface
*/
- /**
+ /**
* @brief OnSurfaceCheckboxChecked Slot beeing called, if the "surface"-checkbox is clicked. This method initializes the surface once, if it is necessary.
* @param checked Is it checked or not?
*/
- void OnSurfaceCheckboxChecked(bool checked);
+ void OnSurfaceCheckboxChecked(bool checked);
- void OnTextureCheckBoxChecked(bool checked);
- /*!
+ void OnTextureCheckBoxChecked(bool checked);
+ /*!
\brief Slot invoked when the video texture checkbox is checked. Enables the texture of the surface
*/
- void OnKinectRGBTextureCheckBoxChecked(bool checked);
- /*!
+ void OnKinectRGBTextureCheckBoxChecked(bool checked);
+ /*!
\brief Slot invoked when user alters the coronal window input from RGB to Intensity or vice versa.
*/
- void OnChangeCoronalWindowOutput(int index);
- /*!
+ void OnChangeCoronalWindowOutput(int index);
+ /*!
\brief Slot invoked when acquisition mode of Kinect is changed
*/
- void OnKinectAcquisitionModeChanged();
+ void OnKinectAcquisitionModeChanged();
protected:
- /*!
+ /*!
\brief initialize the visibility settings of ToF data (images + surface)
\param useToF true: distance image: widget1, amplitude image: widget 2, intensity image: widget 3; false: standard
*/
- void UseToFVisibilitySettings(bool useToF);
+ void UseToFVisibilitySettings(bool useToF);
- Ui::QmitkToFUtilViewControls* m_Controls;
+ Ui::QmitkToFUtilViewControls* m_Controls;
- QmitkStdMultiWidget* m_MultiWidget;
+ QmitkStdMultiWidget* m_MultiWidget;
- QTimer* m_Frametimer; ///< Timer used to continuously update the images
+ QTimer* m_Frametimer; ///< Timer used to continuously update the images
- QString m_SelectedCamera; ///< String holding the selected camera
+ QString m_SelectedCamera; ///< String holding the selected camera
- mitk::Image::Pointer m_MitkDistanceImage; ///< member holding a pointer to the distance image of the selected camera
- mitk::Image::Pointer m_MitkAmplitudeImage; ///< member holding a pointer to the amplitude image of the selected camera
- mitk::Image::Pointer m_MitkIntensityImage; ///< member holding a pointer to the intensity image of the selected camera
- mitk::Surface::Pointer m_Surface; ///< member holding a pointer to the surface generated from the distance image of the selected camera
+ mitk::Image::Pointer m_MitkDistanceImage; ///< member holding a pointer to the distance image of the selected camera
+ mitk::Image::Pointer m_MitkAmplitudeImage; ///< member holding a pointer to the amplitude image of the selected camera
+ mitk::Image::Pointer m_MitkIntensityImage; ///< member holding a pointer to the intensity image of the selected camera
+ mitk::Surface::Pointer m_Surface; ///< member holding a pointer to the surface generated from the distance image of the selected camera
- mitk::DataNode::Pointer m_DistanceImageNode; ///< DataNode holding the distance image of the selected camera
- mitk::DataNode::Pointer m_AmplitudeImageNode; ///< DataNode holding the amplitude image of the selected camera
- mitk::DataNode::Pointer m_IntensityImageNode; ///< DataNode holding the intensity image of the selected camera
- mitk::DataNode::Pointer m_RGBImageNode; ///< DataNode holding the rgb image of the selected camera
- mitk::DataNode::Pointer m_SurfaceNode; ///< DataNode holding the surface generated from the distanc image of the selected camera
+ mitk::DataNode::Pointer m_DistanceImageNode; ///< DataNode holding the distance image of the selected camera
+ mitk::DataNode::Pointer m_AmplitudeImageNode; ///< DataNode holding the amplitude image of the selected camera
+ mitk::DataNode::Pointer m_IntensityImageNode; ///< DataNode holding the intensity image of the selected camera
+ mitk::DataNode::Pointer m_RGBImageNode; ///< DataNode holding the rgb image of the selected camera
+ mitk::DataNode::Pointer m_SurfaceNode; ///< DataNode holding the surface generated from the distanc image of the selected camera
- // ToF processing and recording filter
- mitk::ToFImageRecorder::Pointer m_ToFImageRecorder; ///< ToF image recorder used for lossless recording of ToF image data
- mitk::ToFImageGrabber::Pointer m_ToFImageGrabber; ///< Source of a ToF image processing pipeline. Provides pointers to distance, amplitude and intensity image
- mitk::ToFDistanceImageToSurfaceFilter::Pointer m_ToFDistanceImageToSurfaceFilter; ///< Filter for calculating a surface representation from a given distance image
- mitk::ToFCompositeFilter::Pointer m_ToFCompositeFilter; ///< Filter combining several processing steps (thresholding, Median filtering, Bilateral filtering)
+ // ToF processing and recording filter
+ mitk::ToFImageRecorder::Pointer m_ToFImageRecorder; ///< ToF image recorder used for lossless recording of ToF image data
+ mitk::ToFImageGrabber::Pointer m_ToFImageGrabber; ///< Source of a ToF image processing pipeline. Provides pointers to distance, amplitude and intensity image
+ mitk::ToFDistanceImageToSurfaceFilter::Pointer m_ToFDistanceImageToSurfaceFilter; ///< Filter for calculating a surface representation from a given distance image
+ mitk::ToFCompositeFilter::Pointer m_ToFCompositeFilter; ///< Filter combining several processing steps (thresholding, Median filtering, Bilateral filtering)
- int m_2DDisplayCount; ///< member used to determine whether frame rate output should be shown
- // members for calculating the frame rate
- mitk::RealTimeClock::Pointer m_RealTimeClock; ///< real time clock used to calculate the display framerate
- int m_StepsForFramerate; ///< number of steps used for calculating the display framerate
- double m_2DTimeBefore; ///< holds the time stamp at the beginning of the display framerate measurement
- double m_2DTimeAfter; ///< holds the time stamp at the end of the display framerate measurement
+ int m_2DDisplayCount; ///< member used to determine whether frame rate output should be shown
+ // members for calculating the frame rate
+ mitk::RealTimeClock::Pointer m_RealTimeClock; ///< real time clock used to calculate the display framerate
+ int m_StepsForFramerate; ///< number of steps used for calculating the display framerate
+ double m_2DTimeBefore; ///< holds the time stamp at the beginning of the display framerate measurement
+ double m_2DTimeAfter; ///< holds the time stamp at the end of the display framerate measurement
- mitk::CameraIntrinsics::Pointer m_CameraIntrinsics; ///< member holding the intrinsic parameters of the camera
+ mitk::CameraIntrinsics::Pointer m_CameraIntrinsics; ///< member holding the intrinsic parameters of the camera
private:
- /*!
+ /*!
\brief helper method to replace data of the specified node. If node does not exist it will be created
\param nodeName Name of the node
\param data Data object to be replaced
\return returns the node
*/
- mitk::DataNode::Pointer ReplaceNodeData(std::string nodeName, mitk::BaseData* data);
+ mitk::DataNode::Pointer ReplaceNodeData(std::string nodeName, mitk::BaseData* data);
- void ProcessVideoTransform();
+ void ProcessVideoTransform();
- /*!
+ /*!
\brief Reset all GUI related things to default. E.g. show sagittal and coronal slices in the renderwindows.
*/
- void ResetGUIToDefault();
+ void ResetGUIToDefault();
- mitk::ToFSurfaceVtkMapper3D::Pointer m_ToFSurfaceVtkMapper3D;
+ mitk::ToFSurfaceVtkMapper3D::Pointer m_ToFSurfaceVtkMapper3D;
};
#endif // _QMITKTOFUTILVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/Manual.dox
index 5f9dfdc00d..2b767e9cb6 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/Manual.dox
@@ -1,19 +1,68 @@
/**
-\page org_mitk_gui_qt_ultrasound Ultrasound
+\page org_mitk_gui_qt_ultrasound The Ultrasound Plugin
\image html icon.xpm "Icon of Ultrasound"
Available sections:
- \ref org_mitk_gui_qt_ultrasoundOverview
\section org_mitk_gui_qt_ultrasoundOverview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
+
+This plugin offers a simple interface to create and manage ultrasound devices.
+Devices, once configured, will be stored and loaded on the next start of MITK.
+One can configure several aspects of the images acquired.
+Last but not least, this plugin makes the configured devices available as a microservice,
+exposing them for further usage in other plugins.
+
+\section org_mitk_gui_qt_ultrasoundPrerequisites Prerequisites
+
+To make use of this plugin, you obviously require an ultrasound device.
+The device must have a video-out of one kind or another. Typical video-outs are: HDMI, DVI, VGA and S-Video.
+You also need a Video-Grabber that can acquire the image data from the ultrasound device.
+In principal, this plugin is compatible with any grabber that allows the Operating system to access it's functionality.
+
+However, not all grabbers are created equal. Make sure your grabber supports the video-out offered by your ultrasound device and that it can achieve a satisfying framerate.
+We have made good experiences with epiphan Grabbers and currently recommend the <a href="http://www.epiphan.com/products/dvi-frame-grabbers/dvi2usb-3-0/">epiphan DVI2USB 3.0 device</a> which supports HDMI, DVI and VGA, but less costly grabbers certainly are an option.
+
+\section org_mitk_gui_qt_ultrasoundCreateDevice Creating an Device
+
+To configure an ultrasound device, connect the ultrasound device to the grabber and the grabber to the computer. Start the ultrasound device and open the ultrasound plugin. The devicemanager will open.
+
+\image html devicemanager.png "MITK Screenshot with the devicemanager activated"
+
+Any currently configured devices are listed in the box, which accordingly is empty now.
+Click "New Device".
+
+\image html newvideodevice.png "The 'New Device' form"
+
+In the appearing form, enter descriptive data on your device in the corresponding fields.
+Manufacturer and model will be used to display the device in MITK.
+
+You may choose the video source ID if more than one is available (as is the case on laptops with built-in webcams). On Windows, try -1 (defaults to the first available source). On Linux and Mac try 0 and 1. If the wrong camera is address, simply try the next ID.
+
+Most ultrasound images are grey scale, so using a grey scale conversion doesn't take information away from the image, but makes processing images significantly faster. Only uncheck this box if you require color.
+
+Click Add Device to save your changes.
+
+\image html devicemanager_2.png "Devicemanager with configured device"
+
+\section org_mitk_gui_qt_ultrasoundActivateConnect Activation and Connection
+
+A ultrasound device in MITK can be connected and activated. The device you just created automatically became connected. A connected device is available to all other plugins in MITK, but does not jet generate image data. Disconnecting the device causes it to be deleted and not be available anymore.
+
+Click the device, then click "Activate Device". The device is now activated and generates image data continuously.
+
+Click the "US-Imaging Tab"
+
+\image html usimaging.png "US Imaging Tab"
+
+Select the device and click "Start Viewing". The US-Image should appear.
+You can adjust the cropping parameters to reduce the acquired image size which will further increase speed and remove unnecessary information.
+
+All changes are saved and restored whenever MITK is started.
+
+
+
*/
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/icon.xpm
index 9057c20bc6..54a1bcb8b9 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/icon.xpm
+++ b/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/icon.xpm
@@ -1,21 +1,105 @@
/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" c #FF0000",
+static char * C:\Builds\MITK\Plugins\org_mitk_gui_qt_ultrasound\resources\icon_xpm[] = {
+"100 100 2 1",
+" c None",
". c #000000",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" ",
-" "};
+" .......................................................................................... ",
+" .......................................................................................... ",
+" .......................................................................................... ",
+" ... .. ",
+" ... .. ",
+" ... .. ",
+" ... .. ",
+" ... .. ",
+" ... .. .. .. ",
+" ... .... ..... .. ",
+" ... ................... .. ",
+" ... ..................... .. ",
+" ... ....................... .. ",
+" ... ......................... .. ",
+" ... ........................... .. ",
+" ... ............................. .. ",
+" ... ............................... .. ",
+" ... ............ .................. .. ",
+" ... ............ ........ .... .. ",
+" ... ............. ....... .... .. ",
+" ... .............. ...... .... .. ",
+" ... ............... ..... .... .. ",
+" ... ................ ..... .... .. ",
+" ... ................ ..... ..... .. ",
+" ... ................. .... ...... .. ",
+" ... .................. .... ....... .. ",
+" ... ................... .... ........ .. ",
+" ... .......... ...... ... .......... .. ",
+" ... .. ...... ... ........... .. ",
+" ... .. ...... .. ............. .. ",
+" ... ... ...... ... ................ .. ",
+" ... .... ....... ......................... .. ",
+" ... ..... ...... .......................... .. ",
+" ... ....... ..... .......................... .. ",
+" ... ................. ... .......................... .. ",
+" ... .................. .. ........................... .. ",
+" ... .................. .......................... .. ",
+" ... ................. ......................... .. ",
+" ... ................ ......................... .. ",
+" ... ............... ........................ .. ",
+" ... ............. ......................... .. ",
+" ... ............ ........................ .. ",
+" ... ........... ......................... .. ",
+" ... .......... ........................ .. ",
+" ... ........ ......................... .. ",
+" ... ....... ....................... .. ",
+" ... ....... ....................... .. ",
+" ... ...... ....................... .. ",
+" ... ........................... .. .. ",
+" ... ................... ... .. ",
+" ... ..... .. ",
+" ... ...... .. ",
+" ... ....... .. ",
+" ... ....... .. ",
+" ... ........ .. ",
+" ... ......... .. ",
+" ... ......... .. ",
+" ... ......... .. ",
+" ... ......... .. ",
+" ... ......... .. ",
+" ... ......... .. ",
+" ... ......... .. ",
+" ... ......... .. ",
+" ... .......... .. ",
+" ... ......... .. ",
+" ... ......... .. ",
+" ... .......... .. ",
+" ... .......... ... ",
+" .......................................................................................... ",
+" .......................................................................................... ",
+" ................................. ",
+" ................................. ",
+" .................................. ",
+" ................................. ",
+" .................................. ",
+" .................................. ",
+" ................................. ",
+" ................................. ",
+" ................................ ",
+" ................................ ",
+" ................................ ",
+" ............................... ",
+" .............................. ",
+" .............................. ",
+" ............................ ",
+" ............................ ",
+" ........................... ",
+" ........................... ",
+" .......................... ",
+" .......................... ",
+" ......................... ",
+" ....................... ",
+" ..................... ",
+" ..................... ",
+" .................... ",
+" ..................... ",
+" ..................... ",
+" .................... ",
+" ..................... ",
+" ..................... "};
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/devicemanagement.png b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/devicemanagement.png
new file mode 100644
index 0000000000..c355ad1e50
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/devicemanagement.png differ
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/devicemanagement_2.png b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/devicemanagement_2.png
new file mode 100644
index 0000000000..84ede8a48d
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/devicemanagement_2.png differ
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/modules.dox
index 22a80e24b6..4dae7e103b 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/modules.dox
+++ b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/modules.dox
@@ -1,16 +1,16 @@
/**
\defgroup org_mitk_gui_qt_ultrasound org.mitk.gui.qt.ultrasound
\ingroup MITKPlugins
- \brief Describe your plugin here.
+ \brief A plugin that manages and views images from ultrasound devices.
*/
/**
\defgroup org_mitk_gui_qt_ultrasound_internal Internal
\ingroup org_mitk_gui_qt_ultrasound
\brief This subcategory includes the internal classes of the org.mitk.gui.qt.ultrasound plugin. Other
plugins must not rely on these classes. They contain implementation details and their interface
may change at any time. We mean it.
*/
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/newvideodevice.png b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/newvideodevice.png
new file mode 100644
index 0000000000..31f4ed2f46
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/newvideodevice.png differ
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/usimaging.png b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/usimaging.png
new file mode 100644
index 0000000000..52a2e8f23c
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.ultrasound/documentation/doxygen/usimaging.png differ
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
index 5a696f73a5..48bcc422eb 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
@@ -1,214 +1,211 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
//Mitk
#include <mitkDataNode.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
// Qmitk
#include "UltrasoundSupport.h"
#include <QTimer>
// Qt
#include <QMessageBox>
// Ultrasound
#include "mitkUSDevice.h"
const std::string UltrasoundSupport::VIEW_ID = "org.mitk.views.ultrasoundsupport";
void UltrasoundSupport::SetFocus()
{
m_Controls.m_AddDevice->setFocus();
}
void UltrasoundSupport::CreateQtPartControl( QWidget *parent )
{
m_Timer = new QTimer(this);
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi( parent );
connect( m_Controls.m_AddDevice, SIGNAL(clicked()), this, SLOT(OnClickedAddNewDevice()) ); // Change Widget Visibilities
connect( m_Controls.m_AddDevice, SIGNAL(clicked()), this->m_Controls.m_NewVideoDeviceWidget, SLOT(CreateNewDevice()) ); // Init NewDeviceWidget
connect( m_Controls.m_NewVideoDeviceWidget, SIGNAL(Finished()), this, SLOT(OnNewDeviceWidgetDone()) ); // After NewDeviceWidget finished editing
connect( m_Controls.m_BtnView, SIGNAL(clicked()), this, SLOT(OnClickedViewDevice()) );
connect( m_Timer, SIGNAL(timeout()), this, SLOT(DisplayImage()));
connect( m_Controls.crop_left, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
connect( m_Controls.crop_right, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
connect( m_Controls.crop_top, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
connect( m_Controls.crop_bot, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
-
-
//connect (m_Controls.m_ActiveVideoDevices, SIGNAL())
// Initializations
m_Controls.m_NewVideoDeviceWidget->setVisible(false);
std::string filter = "(&(" + mitk::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.UltrasoundDevice)(" + mitk::USDevice::US_PROPKEY_ISACTIVE + "=true))";
m_Controls.m_ActiveVideoDevices->Initialize<mitk::USDevice>(mitk::USDevice::US_PROPKEY_LABEL ,filter);
//UI initializations
m_Controls.crop_left->setEnabled(false);
m_Controls.crop_right->setEnabled(false);
m_Controls.crop_bot->setEnabled(false);
m_Controls.crop_top->setEnabled(false);
m_Node = mitk::DataNode::New();
m_Node->SetName("US Image Stream");
this->GetDataStorage()->Add(m_Node);
}
void UltrasoundSupport::OnClickedAddNewDevice()
{
m_Controls.m_NewVideoDeviceWidget->setVisible(true);
m_Controls.m_DeviceManagerWidget->setVisible(false);
m_Controls.m_AddDevice->setVisible(false);
m_Controls.m_Headline->setText("Add New Device:");
}
void UltrasoundSupport::DisplayImage()
{
m_Device->UpdateOutputData(0);
m_Node->SetData(m_Device->GetOutput());
this->RequestRenderWindowUpdate();
m_FrameCounter ++;
if (m_FrameCounter == 10)
{
int nMilliseconds = m_Clock.restart();
int fps = 10000.0f / (nMilliseconds );
m_Controls.m_FramerateLabel->setText("Current Framerate: "+ QString::number(fps) +" FPS");
m_FrameCounter = 0;
}
}
void UltrasoundSupport::OnCropAreaChanged()
{
if (m_Device->GetDeviceClass()=="org.mitk.modules.us.USVideoDevice")
{
mitk::USVideoDevice::Pointer currentVideoDevice = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
mitk::USDevice::USImageCropArea newArea;
newArea.cropLeft = m_Controls.crop_left->value();
newArea.cropTop = m_Controls.crop_top->value();
newArea.cropRight = m_Controls.crop_right->value();
newArea.cropBottom = m_Controls.crop_bot->value();
//check enabled: if not we are in the initializing step and don't need to do anything
//otherwise: update crop area
if (m_Controls.crop_right->isEnabled())
currentVideoDevice->SetCropArea(newArea);
GlobalReinit();
}
else
{
MITK_WARN << "No USVideoDevice: Cannot Crop!";
- }
+ }
}
void UltrasoundSupport::OnClickedViewDevice()
{
m_FrameCounter = 0;
-
// We use the activity state of the timer to determine whether we are currently viewing images
if ( ! m_Timer->isActive() ) // Activate Imaging
{
//get device & set data node
m_Device = m_Controls.m_ActiveVideoDevices->GetSelectedService<mitk::USDevice>();
if (m_Device.IsNull()){
m_Timer->stop();
return;
}
m_Device->Update();
m_Node->SetData(m_Device->GetOutput());
//start timer
int interval = (1000 / m_Controls.m_FrameRate->value());
m_Timer->setInterval(interval);
m_Timer->start();
//reinit view
GlobalReinit();
//change UI elements
m_Controls.m_BtnView->setText("Stop Viewing");
m_Controls.m_FrameRate->setEnabled(false);
m_Controls.crop_left->setValue(m_Device->GetCropArea().cropLeft);
m_Controls.crop_right->setValue(m_Device->GetCropArea().cropRight);
m_Controls.crop_bot->setValue(m_Device->GetCropArea().cropBottom);
m_Controls.crop_top->setValue(m_Device->GetCropArea().cropTop);
m_Controls.crop_left->setEnabled(true);
m_Controls.crop_right->setEnabled(true);
m_Controls.crop_bot->setEnabled(true);
m_Controls.crop_top->setEnabled(true);
}
else //deactivate imaging
{
//stop timer & release data
m_Timer->stop();
m_Node->ReleaseData();
this->RequestRenderWindowUpdate();
//change UI elements
m_Controls.m_BtnView->setText("Start Viewing");
m_Controls.m_FrameRate->setEnabled(true);
m_Controls.crop_left->setEnabled(false);
m_Controls.crop_right->setEnabled(false);
m_Controls.crop_bot->setEnabled(false);
m_Controls.crop_top->setEnabled(false);
}
}
void UltrasoundSupport::OnNewDeviceWidgetDone()
{
m_Controls.m_NewVideoDeviceWidget->setVisible(false);
m_Controls.m_DeviceManagerWidget->setVisible(true);
m_Controls.m_AddDevice->setVisible(true);
m_Controls.m_Headline->setText("Connected Devices:");
}
void UltrasoundSupport::GlobalReinit()
{
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
UltrasoundSupport::UltrasoundSupport()
{
-m_DevicePersistence = mitk::USDevicePersistence::New();
-m_DevicePersistence->RestoreLastDevices();
+ m_DevicePersistence = mitk::USDevicePersistence::New();
+ m_DevicePersistence->RestoreLastDevices();
}
UltrasoundSupport::~UltrasoundSupport()
{
-m_DevicePersistence->StoreCurrentDevices();
-m_Controls.m_DeviceManagerWidget->DisconnectAllDevices();
+ m_DevicePersistence->StoreCurrentDevices();
+ m_Controls.m_DeviceManagerWidget->DisconnectAllDevices();
}
\ No newline at end of file
diff --git a/Plugins/org.mitk.simulation/CMakeLists.txt b/Plugins/org.mitk.simulation/CMakeLists.txt
new file mode 100644
index 0000000000..66f2590747
--- /dev/null
+++ b/Plugins/org.mitk.simulation/CMakeLists.txt
@@ -0,0 +1,7 @@
+project(org_mitk_simulation)
+
+MACRO_CREATE_MITK_CTK_PLUGIN(
+ EXPORT_DIRECTIVE SIMULATION_INIT_EXPORT
+ EXPORTED_INCLUDE_SUFFIXES src
+ MODULE_DEPENDENCIES Properties Qmitk Simulation
+)
diff --git a/Plugins/org.mitk.simulation/files.cmake b/Plugins/org.mitk.simulation/files.cmake
new file mode 100644
index 0000000000..cfe1fc0b72
--- /dev/null
+++ b/Plugins/org.mitk.simulation/files.cmake
@@ -0,0 +1,31 @@
+set(SRC_CPP_FILES
+ mitkGetSimulationPreferences.cpp
+)
+
+set(INTERNAL_CPP_FILES
+ org_mitk_simulation_Activator.cpp
+)
+
+set(MOC_H_FILES
+ src/internal/org_mitk_simulation_Activator.h
+)
+
+set(CACHED_RESOURCE_FILES
+ resources/simulation.png
+ resources/simulationTemplate.png
+)
+
+set(QRC_FILES
+ resources/Simulation.qrc
+)
+
+set(CPP_FILES
+)
+
+foreach(file ${SRC_CPP_FILES})
+ set(CPP_FILES ${CPP_FILES} src/${file})
+endforeach()
+
+foreach(file ${INTERNAL_CPP_FILES})
+ set(CPP_FILES ${CPP_FILES} src/internal/${file})
+endforeach()
diff --git a/Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake b/Plugins/org.mitk.simulation/manifest_headers.cmake
similarity index 52%
copy from Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake
copy to Plugins/org.mitk.simulation/manifest_headers.cmake
index 912e7b0cf4..893c3d887f 100644
--- a/Plugins/org.mitk.gui.qt.simulation/manifest_headers.cmake
+++ b/Plugins/org.mitk.simulation/manifest_headers.cmake
@@ -1,5 +1,6 @@
-set(Plugin-Name "MITK Simulation")
+set(Plugin-Name "MITK Simulation Initialization")
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)
+set(Require-Plugin org.mitk.gui.common)
+set(Plugin-ActivationPolicy eager)
diff --git a/Plugins/org.mitk.simulation/resources/Simulation.qrc b/Plugins/org.mitk.simulation/resources/Simulation.qrc
new file mode 100644
index 0000000000..00b2d1b9fb
--- /dev/null
+++ b/Plugins/org.mitk.simulation/resources/Simulation.qrc
@@ -0,0 +1,8 @@
+<RCC>
+ <qresource prefix="/Simulation">
+ <file>simulation.png</file>
+ </qresource>
+ <qresource prefix="/Simulation">
+ <file>simulationTemplate.png</file>
+ </qresource>
+</RCC>
diff --git a/Plugins/org.mitk.simulation/resources/simulation.png b/Plugins/org.mitk.simulation/resources/simulation.png
new file mode 100644
index 0000000000..3e0ce703ea
Binary files /dev/null and b/Plugins/org.mitk.simulation/resources/simulation.png differ
diff --git a/Plugins/org.mitk.simulation/resources/simulationTemplate.png b/Plugins/org.mitk.simulation/resources/simulationTemplate.png
new file mode 100644
index 0000000000..fdf69c0bbd
Binary files /dev/null and b/Plugins/org.mitk.simulation/resources/simulationTemplate.png differ
diff --git a/Plugins/org.mitk.simulation/src/internal/org_mitk_simulation_Activator.cpp b/Plugins/org.mitk.simulation/src/internal/org_mitk_simulation_Activator.cpp
new file mode 100644
index 0000000000..06c1e94ab4
--- /dev/null
+++ b/Plugins/org.mitk.simulation/src/internal/org_mitk_simulation_Activator.cpp
@@ -0,0 +1,113 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "org_mitk_simulation_Activator.h"
+#include <mitkGetSimulationPreferences.h>
+#include <mitkLoadPropertiesModule.h>
+#include <mitkNodePredicateDataType.h>
+#include <mitkPropertyFilters.h>
+#include <mitkSimulationObjectFactory.h>
+#include <QmitkNodeDescriptorManager.h>
+#include <QtPlugin>
+#include <sofa/helper/system/PluginManager.h>
+
+template <class T>
+T* GetPropertyService(ctkPluginContext* context)
+{
+ if (context == NULL)
+ return NULL;
+
+ mitk::LoadPropertiesModule();
+
+ ctkServiceReference serviceRef = context->getServiceReference<T>();
+
+ return serviceRef
+ ? context->getService<T>(serviceRef)
+ : NULL;
+}
+
+static void InitSOFAPlugins()
+{
+ berry::IPreferences::Pointer preferences = mitk::GetSimulationPreferences();
+
+ if (preferences.IsNull())
+ return;
+
+ QString pluginPaths = preferences->GetByteArray("plugin paths", "").c_str();
+
+ if (pluginPaths.isEmpty())
+ return;
+
+ QStringList pluginPathList = pluginPaths.split(';', QString::SkipEmptyParts);
+ QStringListIterator it(pluginPathList);
+
+ typedef sofa::helper::system::PluginManager PluginManager;
+ PluginManager& pluginManager = PluginManager::getInstance();
+
+ while (it.hasNext())
+ {
+ std::string path = it.next().toStdString();
+ std::ostringstream errlog;
+
+ pluginManager.loadPlugin(path, &errlog);
+
+ if (errlog.str().empty())
+ pluginManager.getPluginMap()[path].initExternalModule();
+ }
+}
+
+static void SetPropertyFilters(ctkPluginContext* context)
+{
+ mitk::PropertyFilters* propertyFilters = GetPropertyService<mitk::PropertyFilters>(context);
+
+ if (propertyFilters == NULL)
+ return;
+
+ mitk::PropertyFilter simulationFilter;
+
+ simulationFilter.AddEntry("layer", mitk::PropertyFilter::Blacklist);
+ simulationFilter.AddEntry("name", mitk::PropertyFilter::Blacklist);
+ simulationFilter.AddEntry("path", mitk::PropertyFilter::Blacklist);
+ simulationFilter.AddEntry("selected", mitk::PropertyFilter::Blacklist);
+ simulationFilter.AddEntry("visible", mitk::PropertyFilter::Blacklist);
+
+ propertyFilters->AddFilter("Simulation", simulationFilter);
+ propertyFilters->AddFilter("SimulationTemplate", simulationFilter);
+}
+
+void mitk::org_mitk_simulation_Activator::start(ctkPluginContext* context)
+{
+ RegisterSimulationObjectFactory();
+ InitSOFAPlugins();
+ SetPropertyFilters(context);
+
+ QmitkNodeDescriptorManager* nodeDescriptorManager = QmitkNodeDescriptorManager::GetInstance();
+
+ if (nodeDescriptorManager != NULL)
+ {
+ mitk::NodePredicateDataType::Pointer isSimulation = mitk::NodePredicateDataType::New("Simulation");
+ nodeDescriptorManager->AddDescriptor(new QmitkNodeDescriptor("Simulation", ":/Simulation/simulation.png", isSimulation, nodeDescriptorManager));
+
+ mitk::NodePredicateDataType::Pointer isSimulationTemplate = mitk::NodePredicateDataType::New("SimulationTemplate");
+ nodeDescriptorManager->AddDescriptor(new QmitkNodeDescriptor("SimulationTemplate", ":/Simulation/simulationTemplate.png", isSimulationTemplate, nodeDescriptorManager));
+ }
+}
+
+void mitk::org_mitk_simulation_Activator::stop(ctkPluginContext*)
+{
+}
+
+Q_EXPORT_PLUGIN2(org_mitk_simulation, mitk::org_mitk_simulation_Activator)
diff --git a/Core/Code/Rendering/mitkVtkMapper2D.h b/Plugins/org.mitk.simulation/src/internal/org_mitk_simulation_Activator.h
similarity index 58%
copy from Core/Code/Rendering/mitkVtkMapper2D.h
copy to Plugins/org.mitk.simulation/src/internal/org_mitk_simulation_Activator.h
index f9db3be352..ffcb990bdd 100644
--- a/Core/Code/Rendering/mitkVtkMapper2D.h
+++ b/Plugins/org.mitk.simulation/src/internal/org_mitk_simulation_Activator.h
@@ -1,32 +1,34 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#ifndef BASEVTKMAPPER2D_H_HEADER_INCLUDED
-#define BASEVTKMAPPER2D_H_HEADER_INCLUDED
-
-#include "mitkVtkMapper.h"
-
-namespace mitk {
-
- // typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead.
- DEPRECATED(typedef VtkMapper VtkMapper2D);
-
-} // namespace mitk
-
-
-#endif /* BASEVTKMAPPER2D_H_HEADER_INCLUDED */
+#ifndef org_mitk_simulation_Activator_h
+#define org_mitk_simulation_Activator_h
+
+#include <ctkPluginActivator.h>
+
+namespace mitk
+{
+ class org_mitk_simulation_Activator : public QObject, public ctkPluginActivator
+ {
+ Q_OBJECT
+ Q_INTERFACES(ctkPluginActivator)
+
+ void start(ctkPluginContext* context);
+ void stop(ctkPluginContext* context);
+ };
+}
+#endif
diff --git a/Plugins/org.mitk.simulation/src/mitkGetSimulationPreferences.cpp b/Plugins/org.mitk.simulation/src/mitkGetSimulationPreferences.cpp
new file mode 100644
index 0000000000..d10b8403ac
--- /dev/null
+++ b/Plugins/org.mitk.simulation/src/mitkGetSimulationPreferences.cpp
@@ -0,0 +1,28 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkGetSimulationPreferences.h"
+#include <berryIPreferencesService.h>
+#include <berryPlatform.h>
+#include <berryServiceRegistry.h>
+
+berry::IPreferences::Pointer mitk::GetSimulationPreferences()
+{
+ berry::ServiceRegistry& serviceRegistry = berry::Platform::GetServiceRegistry();
+ berry::IPreferencesService::Pointer preferencesService = serviceRegistry.GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
+ berry::IPreferences::Pointer preferences = preferencesService->GetSystemPreferences();
+ return preferences->Node("/org.mitk.views.simulation");
+}
diff --git a/Core/Code/Rendering/mitkVtkMapper2D.h b/Plugins/org.mitk.simulation/src/mitkGetSimulationPreferences.h
similarity index 58%
copy from Core/Code/Rendering/mitkVtkMapper2D.h
copy to Plugins/org.mitk.simulation/src/mitkGetSimulationPreferences.h
index f9db3be352..debded83a3 100644
--- a/Core/Code/Rendering/mitkVtkMapper2D.h
+++ b/Plugins/org.mitk.simulation/src/mitkGetSimulationPreferences.h
@@ -1,32 +1,28 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
+#ifndef mitkGetSimulationPreferences_h
+#define mitkGetSimulationPreferences_h
-#ifndef BASEVTKMAPPER2D_H_HEADER_INCLUDED
-#define BASEVTKMAPPER2D_H_HEADER_INCLUDED
+#include <berryIPreferences.h>
+#include <org_mitk_simulation_Export.h>
-#include "mitkVtkMapper.h"
+namespace mitk
+{
+ SIMULATION_INIT_EXPORT berry::IPreferences::Pointer GetSimulationPreferences();
+}
-namespace mitk {
-
- // typedef allows integration of mappers into the new mapper architecture
- // @deprecated Use VtkMapper instead.
- DEPRECATED(typedef VtkMapper VtkMapper2D);
-
-} // namespace mitk
-
-
-#endif /* BASEVTKMAPPER2D_H_HEADER_INCLUDED */
+#endif
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index d886c417bd..2642419af0 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,353 +1,361 @@
#-----------------------------------------------------------------------------
# Convenient macro allowing to download a file
#-----------------------------------------------------------------------------
macro(downloadFile url dest)
file(DOWNLOAD ${url} ${dest} STATUS status)
list(GET status 0 error_code)
list(GET status 1 error_msg)
if(error_code)
message(FATAL_ERROR "error: Failed to download ${url} - ${error_msg}")
endif()
endmacro()
#-----------------------------------------------------------------------------
# MITK Prerequisites
#-----------------------------------------------------------------------------
if(UNIX AND NOT APPLE)
include(mitkFunctionCheckPackageHeader)
# Check for libxt-dev
mitkFunctionCheckPackageHeader(StringDefs.h libxt-dev /usr/include/X11/)
# Check for libtiff4-dev
mitkFunctionCheckPackageHeader(tiff.h libtiff4-dev)
# Check for libwrap0-dev
mitkFunctionCheckPackageHeader(tcpd.h libwrap0-dev)
endif()
#-----------------------------------------------------------------------------
# ExternalProjects
#-----------------------------------------------------------------------------
set(external_projects
VTK
GDCM
CableSwig
ITK
Boost
DCMTK
CTK
OpenCV
SOFA
MITKData
)
set(MITK_USE_CableSwig ${MITK_USE_Python})
set(MITK_USE_GDCM 1)
set(MITK_USE_ITK 1)
set(MITK_USE_VTK 1)
foreach(proj VTK GDCM CableSwig ITK DCMTK CTK OpenCV SOFA)
if(MITK_USE_${proj})
set(EXTERNAL_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory")
mark_as_advanced(EXTERNAL_${proj}_DIR)
if(EXTERNAL_${proj}_DIR)
set(${proj}_DIR ${EXTERNAL_${proj}_DIR})
endif()
endif()
endforeach()
if(MITK_USE_Boost)
set(EXTERNAL_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory")
mark_as_advanced(EXTERNAL_BOOST_ROOT)
if(EXTERNAL_BOOST_ROOT)
set(BOOST_ROOT ${EXTERNAL_BOOST_ROOT})
endif()
endif()
if(BUILD_TESTING)
set(EXTERNAL_MITK_DATA_DIR "${MITK_DATA_DIR}" CACHE PATH "Path to the MITK data directory")
mark_as_advanced(EXTERNAL_MITK_DATA_DIR)
if(EXTERNAL_MITK_DATA_DIR)
set(MITK_DATA_DIR ${EXTERNAL_MITK_DATA_DIR})
endif()
endif()
# Look for git early on, if needed
if((BUILD_TESTING AND NOT EXTERNAL_MITK_DATA_DIR) OR
(MITK_USE_CTK AND NOT EXTERNAL_CTK_DIR))
find_package(Git REQUIRED)
endif()
#-----------------------------------------------------------------------------
# External project settings
#-----------------------------------------------------------------------------
include(ExternalProject)
set(ep_base "${CMAKE_BINARY_DIR}/CMakeExternals")
set_property(DIRECTORY PROPERTY EP_BASE ${ep_base})
set(ep_install_dir ${ep_base}/Install)
#set(ep_build_dir ${ep_base}/Build)
set(ep_source_dir ${ep_base}/Source)
#set(ep_parallelism_level)
set(ep_build_shared_libs ON)
set(ep_build_testing OFF)
if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL)
set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty)
endif()
# Compute -G arg for configuring external projects with the same CMake generator:
if(CMAKE_EXTRA_GENERATOR)
set(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
else()
set(gen "${CMAKE_GENERATOR}")
endif()
# Use this value where semi-colons are needed in ep_add args:
set(sep "^^")
##
if(MSVC_VERSION)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
endif()
set(ep_common_args
-DBUILD_TESTING:BOOL=${ep_build_testing}
-DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-DBUILD_SHARED_LIBS:BOOL=ON
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
-DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS}
#debug flags
-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
#release flags
-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
#relwithdebinfo
-DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
-DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
#link flags
-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS}
-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS}
)
# Include external projects
foreach(p ${external_projects})
include(CMakeExternals/${p}.cmake)
endforeach()
#-----------------------------------------------------------------------------
# Set superbuild boolean args
#-----------------------------------------------------------------------------
set(mitk_cmake_boolean_args
BUILD_SHARED_LIBS
WITH_COVERAGE
BUILD_TESTING
MITK_USE_QT
MITK_BUILD_ALL_PLUGINS
MITK_BUILD_ALL_APPS
MITK_BUILD_TUTORIAL # Deprecated. Use MITK_BUILD_EXAMPLES instead
MITK_BUILD_EXAMPLES
MITK_USE_Boost
MITK_USE_SYSTEM_Boost
MITK_USE_BLUEBERRY
MITK_USE_CTK
MITK_USE_DCMTK
MITK_DCMTK_BUILD_SHARED_LIBS
MITK_USE_OpenCV
MITK_USE_SOFA
MITK_USE_Python
MITK_USE_OpenCL
)
#-----------------------------------------------------------------------------
# Create the final variable containing superbuild boolean args
#-----------------------------------------------------------------------------
set(mitk_superbuild_boolean_args)
foreach(mitk_cmake_arg ${mitk_cmake_boolean_args})
list(APPEND mitk_superbuild_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}})
endforeach()
if(MITK_BUILD_ALL_PLUGINS)
list(APPEND mitk_superbuild_boolean_args -DBLUEBERRY_BUILD_ALL_PLUGINS:BOOL=ON)
endif()
#-----------------------------------------------------------------------------
# MITK Utilities
#-----------------------------------------------------------------------------
set(proj MITK-Utilities)
ExternalProject_Add(${proj}
DOWNLOAD_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
DEPENDS
# Mandatory dependencies
${VTK_DEPENDS}
${ITK_DEPENDS}
# Optionnal dependencies
${Boost_DEPENDS}
${CTK_DEPENDS}
${DCMTK_DEPENDS}
${OpenCV_DEPENDS}
${SOFA_DEPENDS}
${MITK-Data_DEPENDS}
)
#-----------------------------------------------------------------------------
# Additional MITK CXX/C Flags
#-----------------------------------------------------------------------------
set(MITK_ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags for MITK")
set(MITK_ADDITIONAL_C_FLAGS_RELEASE "" CACHE STRING "Additional Release C Flags for MITK")
set(MITK_ADDITIONAL_C_FLAGS_DEBUG "" CACHE STRING "Additional Debug C Flags for MITK")
mark_as_advanced(MITK_ADDITIONAL_C_FLAGS MITK_ADDITIONAL_C_FLAGS_DEBUG MITK_ADDITIONAL_C_FLAGS_RELEASE)
set(MITK_ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags for MITK")
set(MITK_ADDITIONAL_CXX_FLAGS_RELEASE "" CACHE STRING "Additional Release CXX Flags for MITK")
set(MITK_ADDITIONAL_CXX_FLAGS_DEBUG "" CACHE STRING "Additional Debug CXX Flags for MITK")
mark_as_advanced(MITK_ADDITIONAL_CXX_FLAGS MITK_ADDITIONAL_CXX_FLAGS_DEBUG MITK_ADDITIONAL_CXX_FLAGS_RELEASE)
set(MITK_ADDITIONAL_EXE_LINKER_FLAGS "" CACHE STRING "Additional exe linker flags for MITK")
set(MITK_ADDITIONAL_SHARED_LINKER_FLAGS "" CACHE STRING "Additional shared linker flags for MITK")
set(MITK_ADDITIONAL_MODULE_LINKER_FLAGS "" CACHE STRING "Additional module linker flags for MITK")
mark_as_advanced(MITK_ADDITIONAL_EXE_LINKER_FLAGS MITK_ADDITIONAL_SHARED_LINKER_FLAGS MITK_ADDITIONAL_MODULE_LINKER_FLAGS)
#-----------------------------------------------------------------------------
# MITK Configure
#-----------------------------------------------------------------------------
if(MITK_INITIAL_CACHE_FILE)
set(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}")
endif()
set(mitk_optional_cache_args )
foreach(type RUNTIME ARCHIVE LIBRARY)
if(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
list(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
endif()
endforeach()
+# Optional python variables
+if(MITK_USE_Python)
+ list(APPEND mitk_optional_cache_args
+ -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
+ -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
+ -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY} )
+endif()
+
set(proj MITK-Configure)
ExternalProject_Add(${proj}
LIST_SEPARATOR ^^
DOWNLOAD_COMMAND ""
CMAKE_GENERATOR ${gen}
CMAKE_CACHE_ARGS
# --------------- Build options ----------------
-DBUILD_TESTING:BOOL=${ep_build_testing}
-DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_BINARY_DIR}/MITK-build/install
-DBUILD_SHARED_LIBS:BOOL=ON
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
# --------------- Compile options ----------------
-DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
-DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
"-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${MITK_ADDITIONAL_C_FLAGS}"
"-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_ADDITIONAL_CXX_FLAGS}"
# debug flags
"-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} ${MITK_ADDITIONAL_CXX_FLAGS_DEBUG}"
"-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} ${MITK_ADDITIONAL_C_FLAGS_DEBUG}"
# release flags
"-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} ${MITK_ADDITIONAL_CXX_FLAGS_RELEASE}"
"-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} ${MITK_ADDITIONAL_C_FLAGS_RELEASE}"
# relwithdebinfo
-DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
-DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
# link flags
"-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} ${MITK_ADDITIONAL_EXE_LINKER_FLAGS}"
"-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} ${MITK_ADDITIONAL_SHARED_LINKER_FLAGS}"
"-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ${MITK_ADDITIONAL_MODULE_LINKER_FLAGS}"
# Output directories
-DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
-DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
-DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
# ------------- Boolean build options --------------
${mitk_superbuild_boolean_args}
${mitk_optional_cache_args}
-DMITK_USE_SUPERBUILD:BOOL=OFF
-DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
# ----------------- Miscellaneous ---------------
-DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE}
-DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
-DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD}
-DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}
-DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}
-DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
-DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS}
# --------------- External project dirs ---------------
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE}
-DCTK_DIR:PATH=${CTK_DIR}
-DDCMTK_DIR:PATH=${DCMTK_DIR}
-DVTK_DIR:PATH=${VTK_DIR} # FindVTK expects VTK_DIR
-DITK_DIR:PATH=${ITK_DIR} # FindITK expects ITK_DIR
-DOpenCV_DIR:PATH=${OpenCV_DIR}
-DSOFA_DIR:PATH=${SOFA_DIR}
-DGDCM_DIR:PATH=${GDCM_DIR}
-DBOOST_ROOT:PATH=${BOOST_ROOT}
-DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
-DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
CMAKE_ARGS
${mitk_initial_cache_arg}
SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
BUILD_COMMAND ""
INSTALL_COMMAND ""
DEPENDS
MITK-Utilities
)
#-----------------------------------------------------------------------------
# MITK
#-----------------------------------------------------------------------------
if(CMAKE_GENERATOR MATCHES ".*Makefiles.*")
set(mitk_build_cmd "$(MAKE)")
else()
set(mitk_build_cmd ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build --config ${CMAKE_CFG_INTDIR})
endif()
if(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET)
set(MITKBUILD_TARGET_ALL_OPTION "ALL")
else()
set(MITKBUILD_TARGET_ALL_OPTION "")
endif()
add_custom_target(MITK-build ${MITKBUILD_TARGET_ALL_OPTION}
COMMAND ${mitk_build_cmd}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
DEPENDS MITK-Configure
)
#-----------------------------------------------------------------------------
# Custom target allowing to drive the build of the MITK project itself
#-----------------------------------------------------------------------------
add_custom_target(MITK
COMMAND ${mitk_build_cmd}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
)

File Metadata

Mime Type
application/octet-stream
Expires
Fri, Oct 11, 12:18 PM (1 d, 21 h)
Storage Engine
chunks
Storage Format
Chunks
Storage Handle
OG7KLB6esWUO
Default Alt Text
(7 MB)

Event Timeline

MITK · MIC · IMSY · DKFZ