diff --git a/Applications/CMakeLists.txt b/Applications/CMakeLists.txt
index 88e2c69c17..78029a2750 100644
--- a/Applications/CMakeLists.txt
+++ b/Applications/CMakeLists.txt
@@ -1,27 +1,27 @@
set(MITK_CPACK_PACKAGE_EXECUTABLES "" CACHE INTERNAL "Collecting windows shortcuts to executables" FORCE)
set(MITK_DIR ${PROJECT_BINARY_DIR})
set(MITK_EXPORTS_FILE_INCLUDED 1)
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
if(MITK_USE_CTK)
add_subdirectory(PluginGenerator)
endif()
if(MITK_USE_BLUEBERRY)
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)
add_subdirectory(${target_dir})
endif()
endforeach()
endif()
endif()
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake b/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake
index 1d05bb125a..1d9cc7761a 100644
--- a/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake
+++ b/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake
@@ -1,213 +1,213 @@
#-----------------------------------------------------------------------------
# MITK
#-----------------------------------------------------------------------------
set(MITK_DEPENDS)
set(proj_DEPENDENCIES)
set(proj MITK)
if(NOT MITK_DIR)
#-----------------------------------------------------------------------------
# Create CMake options to customize the MITK build
#-----------------------------------------------------------------------------
option(MITK_USE_SUPERBUILD "Use superbuild for MITK" ON)
option(MITK_USE_BLUEBERRY "Build the BlueBerry platform in MITK" ON)
option(MITK_BUILD_EXAMPLES "Build the MITK examples" OFF)
option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
option(MITK_BUILD_TESTING "Build the MITK unit tests" OFF)
option(MITK_USE_ACVD "Use Approximated Centroidal Voronoi Diagrams" OFF)
option(MITK_USE_CTK "Use CTK in MITK" ${MITK_USE_BLUEBERRY})
option(MITK_USE_DCMTK "Use DCMTK in MITK" ON)
- option(MITK_USE_QT "Use Qt library in MITK" ON)
+ option(MITK_USE_Qt5 "Use Qt 5 library in MITK" ON)
option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF)
option(MITK_USE_SOFA "Use Simulation Open Framework Architecture" OFF)
option(MITK_USE_VMTK "Use the Vascular Modeling Toolkit in MITK" OFF)
option(MITK_USE_Python "Enable Python wrapping in MITK" OFF)
if(MITK_USE_BLUEBERRY AND 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()
- if(MITK_USE_CTK AND NOT MITK_USE_QT)
- message("Forcing MITK_USE_QT to ON because of MITK_USE_CTK")
- set(MITK_USE_QT ON CACHE BOOL "Use Qt library in MITK" FORCE)
+ if(MITK_USE_CTK AND NOT MITK_USE_Qt5)
+ message("Forcing MITK_USE_Qt5 to ON because of MITK_USE_CTK")
+ set(MITK_USE_Qt5 ON CACHE BOOL "Use Qt 5 library in MITK" FORCE)
endif()
set(MITK_USE_CableSwig ${MITK_USE_Python})
set(MITK_USE_GDCM 1)
set(MITK_USE_ITK 1)
set(MITK_USE_VTK 1)
mark_as_advanced(MITK_USE_SUPERBUILD
MITK_BUILD_ALL_PLUGINS
MITK_BUILD_TESTING
)
set(mitk_cmake_boolean_args
MITK_USE_SUPERBUILD
MITK_USE_BLUEBERRY
MITK_BUILD_EXAMPLES
MITK_BUILD_ALL_PLUGINS
MITK_USE_ACVD
MITK_USE_CTK
MITK_USE_DCMTK
- MITK_USE_QT
+ MITK_USE_Qt5
MITK_USE_OpenCV
MITK_USE_SOFA
MITK_USE_VMTK
MITK_USE_Python
)
- if(MITK_USE_QT)
+ if(MITK_USE_Qt5)
# Look for Qt at the superbuild level, to catch missing Qt libs early
find_package(Qt5Widgets REQUIRED)
endif()
set(additional_mitk_cmakevars )
# Configure the set of default 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")
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
""
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")
foreach(_arg MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES MITK_ACCESSBYITK_DIMENSIONS)
mark_as_advanced(${_arg})
list(APPEND additional_mitk_cmakevars "-D${_arg}:STRING=${${_arg}}")
endforeach()
#-----------------------------------------------------------------------------
# Create options to inject pre-build dependencies
#-----------------------------------------------------------------------------
foreach(proj CTK DCMTK GDCM VTK ACVD ITK OpenCV SOFA VMTK CableSwig)
if(MITK_USE_${proj})
set(MITK_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory")
mark_as_advanced(MITK_${proj}_DIR)
if(MITK_${proj}_DIR)
list(APPEND additional_mitk_cmakevars "-D${proj}_DIR:PATH=${MITK_${proj}_DIR}")
endif()
endif()
endforeach()
set(MITK_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory")
mark_as_advanced(MITK_BOOST_ROOT)
if(MITK_BOOST_ROOT)
list(APPEND additional_mitk_cmakevars "-DBOOST_ROOT:PATH=${MITK_BOOST_ROOT}")
endif()
set(MITK_SOURCE_DIR "" CACHE PATH "MITK source code location. If empty, MITK will be cloned from MITK_GIT_REPOSITORY")
set(MITK_GIT_REPOSITORY "https://phabricator.mitk.org/diffusion/MITK/mitk.git" CACHE STRING "The git repository for cloning MITK")
- set(MITK_GIT_TAG "origin/master" CACHE STRING "The git tag/hash to be used when cloning from MITK_GIT_REPOSITORY")
+ set(MITK_GIT_TAG "origin/release/2016-11" CACHE STRING "The git tag/hash to be used when cloning from MITK_GIT_REPOSITORY")
mark_as_advanced(MITK_SOURCE_DIR MITK_GIT_REPOSITORY MITK_GIT_TAG)
#-----------------------------------------------------------------------------
# Create the final variable containing superbuild boolean args
#-----------------------------------------------------------------------------
set(mitk_boolean_args)
foreach(mitk_cmake_arg ${mitk_cmake_boolean_args})
list(APPEND mitk_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}})
endforeach()
#-----------------------------------------------------------------------------
# Additional MITK CMake variables
#-----------------------------------------------------------------------------
- if(MITK_USE_QT)
+ if(MITK_USE_Qt5)
list(APPEND additional_mitk_cmakevars "-DCMAKE_PREFIX_PATH:PATH=${CMAKE_PREFIX_PATH}")
endif()
if(MITK_USE_CTK)
list(APPEND additional_mitk_cmakevars "-DGIT_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}")
endif()
if(MITK_INITIAL_CACHE_FILE)
list(APPEND additional_mitk_cmakevars "-DMITK_INITIAL_CACHE_FILE:INTERNAL=${MITK_INITIAL_CACHE_FILE}")
endif()
if(MITK_USE_SUPERBUILD)
set(MITK_BINARY_DIR ${proj}-superbuild)
else()
set(MITK_BINARY_DIR ${proj}-build)
endif()
set(proj_DEPENDENCIES)
set(MITK_DEPENDS ${proj})
# Configure the MITK souce code location
if(NOT MITK_SOURCE_DIR)
set(mitk_source_location
SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
GIT_REPOSITORY ${MITK_GIT_REPOSITORY}
GIT_TAG ${MITK_GIT_TAG}
)
else()
set(mitk_source_location
SOURCE_DIR ${MITK_SOURCE_DIR}
)
endif()
ExternalProject_Add(${proj}
${mitk_source_location}
BINARY_DIR ${MITK_BINARY_DIR}
PREFIX ${proj}${ep_suffix}
INSTALL_COMMAND ""
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
${mitk_boolean_args}
${additional_mitk_cmakevars}
-DBUILD_SHARED_LIBS:BOOL=ON
-DBUILD_TESTING:BOOL=${MITK_BUILD_TESTING}
CMAKE_CACHE_ARGS
${ep_common_cache_args}
CMAKE_CACHE_DEFAULT_ARGS
${ep_common_cache_default_args}
DEPENDS
${proj_DEPENDENCIES}
)
if(MITK_USE_SUPERBUILD)
set(MITK_DIR "${CMAKE_CURRENT_BINARY_DIR}/${MITK_BINARY_DIR}/MITK-build")
else()
set(MITK_DIR "${CMAKE_CURRENT_BINARY_DIR}/${MITK_BINARY_DIR}")
endif()
else()
# The project is provided using MITK_DIR, nevertheless since other
# projects may depend on MITK, let's add an 'empty' one
MacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
# Further, do some sanity checks in the case of a pre-built MITK
set(my_itk_dir ${ITK_DIR})
set(my_vtk_dir ${VTK_DIR})
find_package(MITK REQUIRED)
if(my_itk_dir AND NOT my_itk_dir STREQUAL ${ITK_DIR})
message(FATAL_ERROR "ITK packages do not match:\n ${MY_PROJECT_NAME}: ${my_itk_dir}\n MITK: ${ITK_DIR}")
endif()
if(my_vtk_dir AND NOT my_vtk_dir STREQUAL ${VTK_DIR})
message(FATAL_ERROR "VTK packages do not match:\n ${MY_PROJECT_NAME}: ${my_vtk_dir}\n MITK: ${VTK_DIR}")
endif()
endif()
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt b/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
index ef518598c6..ead618feae 100644
--- a/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
+++ b/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
@@ -1,340 +1,340 @@
cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
# Change project and application name to your own
set(MY_PROJECT_NAME $(project-name))
set(MY_APP_NAME $(project-app-name))
#-----------------------------------------------------------------------------
# Set the language standard (MITK requires C++11)
#-----------------------------------------------------------------------------
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED 1)
set(CMAKE_CXX_EXTENSIONS 0)
#-----------------------------------------------------------------------------
# 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
CMP0020 # NEW: Automatically link Qt executables to qtmain target on Windows.
CMP0028 # NEW: Double colon in target name means ALIAS or IMPORTED target.
)
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
#-----------------------------------------------------------------------------
set(${PROJECT_NAME}_MODULES_PACKAGE_DEPENDS_DIR "${PROJECT_SOURCE_DIR}/CMake/PackageDepends")
set(MODULES_PACKAGE_DEPENDS_DIRS ${${PROJECT_NAME}_MODULES_PACKAGE_DEPENDS_DIR})
-find_package(MITK 2016.03.99 REQUIRED)
+find_package(MITK 2016.11.00 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()
#-----------------------------------------------------------------------------
# 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()
#-----------------------------------------------------------------------------
# MITK modules
#-----------------------------------------------------------------------------
#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
#-----------------------------------------------------------------------------
diff --git a/Applications/Solstice/CMakeLists.txt b/Applications/Solstice/CMakeLists.txt
index dd9c7e732c..9cc9b05aa8 100644
--- a/Applications/Solstice/CMakeLists.txt
+++ b/Applications/Solstice/CMakeLists.txt
@@ -1,68 +1,68 @@
project(Solstice)
set(_app_options)
if(MITK_SHOW_CONSOLE_WINDOW)
list(APPEND _app_options SHOW_CONSOLE)
endif()
set(MITK_EXTAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/MitkWorkbench.provisioning")
# Plug-ins listed below will not be
# - added as a build-time dependency to the executable
# - listed in the provisioning file for the executable
# - installed if they are external plug-ins
set(_exclude_plugins
org.blueberry.test
org.blueberry.uitest
org.mitk.gui.qt.coreapplication
org.mitk.gui.qt.diffusionimagingapp
)
FunctionCreateBlueBerryApplication(
NAME MitkSolstice
DESCRIPTION "MITK Workbench"
EXCLUDE_PLUGINS ${_exclude_plugins}
${_app_options}
)
add_executable(${OSGI_APP} MACOSX_BUNDLE "src/application/berryMain.cpp")
target_link_libraries(${OSGI_APP} PRIVATE ${PROJECT_NAME} mbilog)
if(_ctk_test_plugins)
add_dependencies(${OSGI_APP} ${_ctk_test_plugins})
add_dependencies(BlueBerry ${OSGI_APP})
set_property(TARGET ${OSGI_APP} APPEND PROPERTY LABELS BlueBerry)
endif()
configure_file(src/application/solstice.ini
${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}.ini)
add_executable(${OSGI_UI_APP} MACOSX_BUNDLE "src/application/berryMainUI.cpp")
target_link_libraries(${OSGI_UI_APP} PRIVATE ${PROJECT_NAME} mbilog)
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
target_link_libraries(${OSGI_UI_APP} PRIVATE Qt5::Widgets)
endif()
if(_ctk_test_plugins)
add_dependencies(${OSGI_UI_APP} ${_ctk_test_plugins})
add_dependencies(BlueBerry ${OSGI_UI_APP})
set_property(TARGET ${OSGI_UI_APP} APPEND PROPERTY LABELS BlueBerry)
endif()
configure_file(src/application/solstice.ini
${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_UI_APP}.ini)
# Add meta dependencies (e.g. on auto-load modules from depending modules)
if(TARGET ${CMAKE_PROJECT_NAME}-autoload)
add_dependencies(MitkWorkbench ${CMAKE_PROJECT_NAME}-autoload)
endif()
#Setting application icon for mac os x systems
set_target_properties(MitkWorkbench PROPERTIES MACOSX_BUNDLE_ICON_FILE "icon.icns")
if(APPLE)
install(FILES "icons/icon.icns" DESTINATION "MitkWorkbench.app/Contents/Resources")
endif(APPLE)
diff --git a/Applications/Workbench/target_libraries.cmake b/Applications/Workbench/target_libraries.cmake
index 454061bdda..d88d280b30 100644
--- a/Applications/Workbench/target_libraries.cmake
+++ b/Applications/Workbench/target_libraries.cmake
@@ -1,9 +1,8 @@
# A list of plug-in targets which should be automatically enabled
# (or be available in external projects) for this application.
set(target_libraries
org_blueberry_ui_qt
- org_blueberry_ui_qt_help
org_mitk_gui_qt_extapplication
)
diff --git a/CMake/MITKDashboardScript.TEMPLATE.cmake b/CMake/MITKDashboardScript.TEMPLATE.cmake
index 193f6cbe34..1417d2aa01 100644
--- a/CMake/MITKDashboardScript.TEMPLATE.cmake
+++ b/CMake/MITKDashboardScript.TEMPLATE.cmake
@@ -1,146 +1,146 @@
#
# 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 3.5 FATAL_ERROR)
#
# Dashboard properties
#
set(MY_COMPILER "gcc-4.9.x")
# For Windows, e.g.
#set(MY_COMPILER "VC12.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 12 2013 Win64")
#set(CTEST_DASHBOARD_ROOT "C:/dartclients")
# The directory containing the Qt binaries
set(QT5_INSTALL_PREFIX "/home/user/Qt/5.6/gcc_64")
# For Windows, e.g.
-#set(QT5_INSTALL_PREFIX "C:/Qt/5.6/msvc2013_64_opengl")
+#set(QT5_INSTALL_PREFIX "C:/Qt/5.6/msvc2013_64")
set(QT_BINARY_DIR "${QT5_INSTALL_PREFIX}/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
CMAKE_PREFIX_PATH:PATH=${CMAKE_PREFIX_PATH}
")
# 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(IS_PHABRICATOR_URL FALSE)
set(url "https://raw.githubusercontent.com/MITK/MITK/master/CMake/MITKDashboardSetup.cmake")
else()
set(IS_PHABRICATOR_URL TRUE)
- set(url "https://phabricator.mitk.org/diffusion/MITK/browse/${GIT_BRANCH}/CMake/MITKDashboardSetup.cmake?view=raw")
+ set(url "https://phabricator.mitk.org/source/mitk/browse/${GIT_BRANCH}/CMake/MITKDashboardSetup.cmake?view=raw")
endif()
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 938eff9b1d..34a2f05048 100644
--- a/CMake/MITKDashboardSetup.cmake
+++ b/CMake/MITKDashboardSetup.cmake
@@ -1,161 +1,161 @@
# 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 )
if(UNIX)
# Download a utility script
if(IS_PHABRICATOR_URL)
- set(url "https://phabricator.mitk.org/diffusion/MITK/browse/${GIT_BRANCH}/CMake/mitkDetectOS.sh?view=raw")
+ set(url "https://phabricator.mitk.org/source/mitk/browse/${GIT_BRANCH}/CMake/mitkDetectOS.sh?view=raw")
else()
set(url "https://raw.githubusercontent.com/MITK/MITK/master/CMake/mitkDetectOS.sh")
endif()
set(dest "${CTEST_SCRIPT_DIRECTORY}/mitkDetectOS.sh")
downloadFile("${url}" "${dest}")
execute_process(COMMAND sh "${dest}"
RESULT_VARIABLE _result OUTPUT_VARIABLE _out
OUTPUT_STRIP_TRAILING_WHITESPACE)
if(NOT _result)
set(MY_OPERATING_SYSTEM "${_out}")
endif()
endif()
if(NOT MY_OPERATING_SYSTEM)
set(MY_OPERATING_SYSTEM "${CMAKE_HOST_SYSTEM}") # Windows 7, Linux-2.6.32, Darwin...
endif()
site_name(CTEST_SITE)
-if(NOT DEFINED MITK_USE_QT)
- set(MITK_USE_QT 1)
+if(NOT DEFINED MITK_USE_Qt5)
+ set(MITK_USE_Qt5 1)
endif()
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
if(NOT QT_QMAKE_EXECUTABLE)
find_program(QT_QMAKE_EXECUTABLE NAMES qmake qmake-qt5
HINTS ${QT_BINARY_DIR})
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})
endif()
#
# Project specific properties
#
if(NOT CTEST_BUILD_NAME)
- if(MITK_USE_QT)
+ if(MITK_USE_Qt5)
set(CTEST_BUILD_NAME "${MY_OPERATING_SYSTEM} ${MY_COMPILER} Qt${MY_QT_VERSION} ${CTEST_BUILD_CONFIGURATION}")
else()
set(CTEST_BUILD_NAME "${MY_OPERATING_SYSTEM} ${MY_COMPILER} ${CTEST_BUILD_CONFIGURATION}")
endif()
set(CTEST_BUILD_NAME "${CTEST_BUILD_NAME}${CTEST_BUILD_NAME_SUFFIX}")
endif()
set(PROJECT_BUILD_DIR "MITK-build")
set(CTEST_PATH "$ENV{PATH}")
if(WIN32)
if("${CTEST_CMAKE_GENERATOR}" MATCHES ".*Win64")
set(CMAKE_LIBRARY_ARCHITECTURE x64)
else()
set(CMAKE_LIBRARY_ARCHITECTURE x86)
endif()
string(SUBSTRING "${MY_COMPILER}" 2 2 vc_version)
set(OPENCV_BIN_DIR "${CTEST_BINARY_DIRECTORY}/ep/${CMAKE_LIBRARY_ARCHITECTURE}/vc${vc_version}/bin")
set(SOFA_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/ep/src/SOFA-build/bin/${CTEST_BUILD_CONFIGURATION}")
set(BLUEBERRY_RUNTIME_DIR "${CTEST_BINARY_DIRECTORY}/MITK-build/bin/plugins/${CTEST_BUILD_CONFIGURATION}")
set(PYTHON_BINARY_DIRS "${CTEST_BINARY_DIRECTORY}/ep/src/CTK-build/CMakeExternals/Install/bin")
list(APPEND PYTHON_BINARY_DIRS "${CTEST_BINARY_DIRECTORY}/ep/lib/python2.7/bin")
set(CTEST_PATH "${CTEST_PATH};${CTEST_BINARY_DIRECTORY}/ep/bin;${QT_BINARY_DIR};${SOFA_BINARY_DIR};${BLUEBERRY_RUNTIME_DIR};${OPENCV_BIN_DIR};${PYTHON_BINARY_DIRS}")
endif()
set(ENV{PATH} "${CTEST_PATH}")
# 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 "https://phabricator.mitk.org/diffusion/MITK/mitk.git")
+ set(GIT_REPOSITORY "https://phabricator.mitk.org/source/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(CTEST_CMAKE_GENERATOR MATCHES ".*Makefiles.*")
set(CTEST_USE_LAUNCHERS 1)
else()
set(CTEST_USE_LAUNCHERS 0)
endif()
set(ENV{CTEST_USE_LAUNCHERS_DEFAULT} ${CTEST_USE_LAUNCHERS})
# 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_BUILD_CONFIGURATION)
set(MITK_BUILD_CONFIGURATION "All")
endif()
if(NOT DEFINED MITK_VTK_DEBUG_LEAKS)
set(MITK_VTK_DEBUG_LEAKS 1)
endif()
set(INITIAL_CMAKECACHE_OPTIONS "
SUPERBUILD_EXCLUDE_MITKBUILD_TARGET:BOOL=TRUE
MITK_BUILD_CONFIGURATION:STRING=${MITK_BUILD_CONFIGURATION}
MITK_VTK_DEBUG_LEAKS:BOOL=${MITK_VTK_DEBUG_LEAKS}
${ADDITIONAL_CMAKECACHE_OPTION}
")
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
set(INITIAL_CMAKECACHE_OPTIONS "${INITIAL_CMAKECACHE_OPTIONS}
QT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}")
endif()
# 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
#
if(IS_PHABRICATOR_URL)
- set(url "https://phabricator.mitk.org/diffusion/MITK/browse/${GIT_BRANCH}/CMake/MITKDashboardDriverScript.cmake?view=raw")
+ set(url "https://phabricator.mitk.org/source/mitk/browse/${GIT_BRANCH}/CMake/MITKDashboardDriverScript.cmake?view=raw")
else()
set(url "https://raw.githubusercontent.com/MITK/MITK/master/CMake/MITKDashboardDriverScript.cmake")
endif()
set(dest ${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}.driver)
downloadFile("${url}" "${dest}")
include(${dest})
diff --git a/CMake/PackageDepends/MITK_VTK_Config.cmake b/CMake/PackageDepends/MITK_VTK_Config.cmake
index 895d835441..e81aee00b9 100644
--- a/CMake/PackageDepends/MITK_VTK_Config.cmake
+++ b/CMake/PackageDepends/MITK_VTK_Config.cmake
@@ -1,12 +1,12 @@
find_package(VTK COMPONENTS ${VTK_REQUIRED_COMPONENTS_BY_MODULE} REQUIRED)
if(VTK_FOUND AND NOT VTK_BUILD_SHARED_LIBS)
message(FATAL_ERROR "MITK only supports a VTK which was built with shared libraries. Turn on BUILD_SHARED_LIBS in your VTK config.")
endif()
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
find_package(Qt5Widgets REQUIRED QUIET)
endif()
list(APPEND ALL_INCLUDE_DIRECTORIES ${VTK_INCLUDE_DIRS})
list(APPEND ALL_LIBRARIES ${VTK_LIBRARIES})
list(APPEND ALL_COMPILE_DEFINITIONS ${VTK_DEFINITIONS})
diff --git a/CMake/mitkFunctionCreateModule.cmake b/CMake/mitkFunctionCreateModule.cmake
index df79827d47..f13ab42f13 100644
--- a/CMake/mitkFunctionCreateModule.cmake
+++ b/CMake/mitkFunctionCreateModule.cmake
@@ -1,655 +1,655 @@
##################################################################
#
# mitk_create_module
#
#! Creates a module for the automatic module dependency system within MITK.
#!
#! Example:
#!
#! \code
#! mitk_create_module(
#! DEPENDS PUBLIC MitkCore
#! PACKAGE_DEPENDS
#! PRIVATE Qt5|Xml+Networking
#! PUBLIC ITK|Watershed
#! WARNINGS_AS_ERRORS
#! \endcode
#!
#! The <moduleName> parameter specifies the name of the module which is used
#! to create a logical target name. The parameter is optional in case the
#! MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME variable evaluates to TRUE. The
#! module name will then be derived from the directory name in which this
#! function is called.
#!
#! If set, the following variables will be used to validate the module name:
#!
#! MITK_MODULE_NAME_REGEX_MATCH The module name must match this regular expression.
#! MITK_MODULE_NAME_REGEX_NOT_MATCH The module name must not match this regular expression.
#!
#! If the MITK_MODULE_NAME_PREFIX variable is set, the module name will be prefixed
#! with its contents.
#!
#! A modules source files are specified in a separate CMake file usually
#! called files.cmake, located in the module root directory. The
#! mitk_create_module() macro evaluates the following CMake variables
#! from the files.cmake file:
#!
#! - CPP_FILES A list of .cpp files
#! - H_FILES A list of .h files without a corresponding .cpp file
#! - TXX_FILES A list of .txx files
#! - RESOURCE_FILES A list of files (resources) which are embedded into the module
#! - MOC_H_FILES A list of Qt header files which should be processed by the MOC
#! - UI_FILES A list of .ui Qt UI files
#! - QRC_FILES A list of .qrc Qt resource files
#! - DOX_FILES A list of .dox Doxygen files
#!
#! List of variables available after the function is called:
#! - MODULE_NAME
#! - MODULE_TARGET
#! - MODULE_IS_ENABLED
#! - MODULE_SUBPROJECTS
#!
#! \sa mitk_create_executable
#!
#! Parameters (all optional):
#!
#! \param <moduleName> The module name (also used as target name)
#! \param FILES_CMAKE File name of a CMake file setting source list variables
#! (defaults to files.cmake)
#! \param VERSION Module version number, e.g. "1.2.0"
#! \param AUTOLOAD_WITH A module target name identifying the module which will
#! trigger the automatic loading of this module
#! \param DEPRECATED_SINCE Marks this modules as deprecated since <arg>
#! \param DESCRIPTION A description for this module
#!
#! Multi-value Parameters (all optional):
#!
#! \param SUBPROJECTS List of CDash labels
#! \param INCLUDE_DIRS Include directories for this module:
#! \verbatim
#! [[PUBLIC|PRIVATE|INTERFACE] <dir1>...]...
#! \endverbatim
#! The default scope for include directories is PUBLIC.
#! \param DEPENDS List of module dependencies:
#! \verbatim
#! [[PUBLIC|PRIVATE|INTERFACE] <module1>...]...
#! \endverbatim
#! The default scope for module dependencies is PUBLIC.
#! \param PACKAGE_DEPENDS List of public packages dependencies (e.g. Qt, VTK, etc.).
#! Package dependencies have the following syntax:
#! \verbatim
#! [PUBLIC|PRIVATE|INTERFACE] PACKAGE[|COMPONENT1[+COMPONENT2]...]
#! \endverbatim
#! The default scope for package dependencies is PRIVATE.
#! \param ADDITIONAL_LIBS List of additional private libraries linked to this module.
#! The folder containing the library will be added to the global list of library search paths.
#! \param CPP_FILES List of source files for this module. If the list is non-empty,
#! the module does not need to provide a files.cmake file or FILES_CMAKE argument.
#! \param H_FILES List of public header files for this module. It is recommended to use
#! a files.cmake file instead.
#!
#! Options (optional)
#!
#! \param FORCE_STATIC Force building this module as a static library
#! \param GCC_DEFAULT_VISIBILITY Do not use gcc visibility flags - all
#! symbols will be exported
#! \param NO_INIT Do not create CppMicroServices initialization code
#! \param NO_FEATURE_INFO Do not create a feature info by calling add_feature_info()
#! \param WARNINGS_AS_ERRORS Treat compiler warnings as errors
#
##################################################################
function(mitk_create_module)
set(_macro_params
VERSION # module version number, e.g. "1.2.0"
EXPORT_DEFINE # export macro name for public symbols of this module (DEPRECATED)
AUTOLOAD_WITH # a module target name identifying the module which will trigger the
# automatic loading of this module
FILES_CMAKE # file name of a CMake file setting source list variables
# (defaults to files.cmake)
DEPRECATED_SINCE # marks this modules as deprecated
DESCRIPTION # a description for this module
)
set(_macro_multiparams
SUBPROJECTS # list of CDash labels
INCLUDE_DIRS # include directories: [PUBLIC|PRIVATE|INTERFACE] <list>
INTERNAL_INCLUDE_DIRS # include dirs internal to this module (DEPRECATED)
DEPENDS # list of modules this module depends on: [PUBLIC|PRIVATE|INTERFACE] <list>
DEPENDS_INTERNAL # list of modules this module internally depends on (DEPRECATED)
PACKAGE_DEPENDS # list of "packages this module depends on (e.g. Qt, VTK, etc.): [PUBLIC|PRIVATE|INTERFACE] <package-list>
TARGET_DEPENDS # list of CMake targets this module should depend on
ADDITIONAL_LIBS # list of addidtional private libraries linked to this module.
CPP_FILES # list of cpp files
H_FILES # list of header files: [PUBLIC|PRIVATE] <list>
)
set(_macro_options
FORCE_STATIC # force building this module as a static library
HEADERS_ONLY # this module is a headers-only library
GCC_DEFAULT_VISIBILITY # do not use gcc visibility flags - all symbols will be exported
NO_DEFAULT_INCLUDE_DIRS # do not add default include directories like "include" or "."
NO_INIT # do not create CppMicroServices initialization code
NO_FEATURE_INFO # do not create a feature info by calling add_feature_info()
WARNINGS_AS_ERRORS # treat all compiler warnings as errors
EXECUTABLE # create an executable; do not use directly, use mitk_create_executable() instead
C_MODULE # compile all source files as C sources
CXX_MODULE # compile all source files as C++ sources
)
cmake_parse_arguments(MODULE "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
set(MODULE_NAME ${MODULE_UNPARSED_ARGUMENTS})
# -----------------------------------------------------------------
# Sanity checks
if(NOT MODULE_NAME)
if(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME)
get_filename_component(MODULE_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
else()
message(SEND_ERROR "The module name must not be empty")
endif()
endif()
set(_deprecated_args INTERNAL_INCLUDE_DIRS DEPENDS_INTERNAL EXPORT_DEFINE TARGET_DEPENDS HEADERS_ONLY)
foreach(_deprecated_arg ${_deprecated_args})
if(MODULE_${_deprecated_arg})
message(WARNING "The ${_deprecated_arg} argument is deprecated")
endif()
endforeach()
set(_module_type module)
set(_Module_type Module)
if(MODULE_EXECUTABLE)
set(_module_type executable)
set(_Module_type Executable)
endif()
if(MITK_MODULE_NAME_REGEX_MATCH)
if(NOT ${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_MATCH})
message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" does not match the regular expression \"${MITK_MODULE_NAME_REGEX_MATCH}\".")
endif()
endif()
if(MITK_MODULE_NAME_REGEX_NOT_MATCH)
if(${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_NOT_MATCH})
message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" must not match the regular expression \"${MITK_MODULE_NAME_REGEX_NOT_MATCH}\".")
endif()
endif()
if(MITK_MODULE_NAME_PREFIX AND NOT MODULE_NAME MATCHES "^${MITK_MODULE_NAME_PREFIX}.*$")
set(MODULE_NAME "${MITK_MODULE_NAME_PREFIX}${MODULE_NAME}")
endif()
if(NOT MODULE_FILES_CMAKE)
set(MODULE_FILES_CMAKE files.cmake)
endif()
if(NOT IS_ABSOLUTE ${MODULE_FILES_CMAKE})
set(MODULE_FILES_CMAKE ${CMAKE_CURRENT_SOURCE_DIR}/${MODULE_FILES_CMAKE})
endif()
if(NOT MODULE_SUBPROJECTS)
if(MITK_DEFAULT_SUBPROJECTS)
set(MODULE_SUBPROJECTS ${MITK_DEFAULT_SUBPROJECTS})
endif()
endif()
# check if the subprojects exist as targets
if(MODULE_SUBPROJECTS)
foreach(subproject ${MODULE_SUBPROJECTS})
if(NOT TARGET ${subproject})
message(SEND_ERROR "The subproject ${subproject} does not have a corresponding target")
endif()
endforeach()
endif()
# -----------------------------------------------------------------
# Check if module should be build
set(MODULE_TARGET ${MODULE_NAME})
# assume worst case
set(MODULE_IS_ENABLED 0)
# first we check if we have an explicit module build list
if(MITK_MODULES_TO_BUILD)
list(FIND MITK_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX)
if(_MOD_INDEX EQUAL -1)
set(MODULE_IS_EXCLUDED 1)
endif()
endif()
if(NOT MODULE_IS_EXCLUDED)
# first of all we check for the dependencies
_mitk_parse_package_args(${MODULE_PACKAGE_DEPENDS})
mitk_check_module_dependencies(MODULES ${MODULE_DEPENDS}
PACKAGES ${PACKAGE_NAMES}
MISSING_DEPENDENCIES_VAR _MISSING_DEP
PACKAGE_DEPENDENCIES_VAR PACKAGE_NAMES)
if(_MISSING_DEP)
if(MODULE_NO_FEATURE_INFO)
message("${_Module_type} ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}")
endif()
set(MODULE_IS_ENABLED 0)
else()
set(MODULE_IS_ENABLED 1)
# now check for every package if it is enabled. This overlaps a bit with
# MITK_CHECK_MODULE ...
foreach(_package ${PACKAGE_NAMES})
if((DEFINED MITK_USE_${_package}) AND NOT (MITK_USE_${_package}))
message("${_Module_type} ${MODULE_NAME} won't be built. Turn on MITK_USE_${_package} if you want to use it.")
set(MODULE_IS_ENABLED 0)
break()
endif()
endforeach()
endif()
endif()
# -----------------------------------------------------------------
# Start creating the module
if(MODULE_IS_ENABLED)
# clear variables defined in files.cmake
set(RESOURCE_FILES )
set(CPP_FILES )
set(H_FILES )
set(TXX_FILES )
set(DOX_FILES )
set(UI_FILES )
set(MOC_H_FILES )
set(QRC_FILES )
# clear other variables
set(Q${KITNAME}_GENERATED_CPP )
set(Q${KITNAME}_GENERATED_MOC_CPP )
set(Q${KITNAME}_GENERATED_QRC_CPP )
set(Q${KITNAME}_GENERATED_UI_CPP )
# check and set-up auto-loading
if(MODULE_AUTOLOAD_WITH)
if(NOT TARGET "${MODULE_AUTOLOAD_WITH}")
message(SEND_ERROR "The module target \"${MODULE_AUTOLOAD_WITH}\" specified as the auto-loading module for \"${MODULE_NAME}\" does not exist")
endif()
endif()
set(_module_autoload_meta_target "${CMAKE_PROJECT_NAME}-autoload")
# create a meta-target if it does not already exist
if(NOT TARGET ${_module_autoload_meta_target})
add_custom_target(${_module_autoload_meta_target})
endif()
if(NOT MODULE_EXPORT_DEFINE)
set(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT)
endif()
if(MITK_GENERATE_MODULE_DOT)
message("MODULEDOTNAME ${MODULE_NAME}")
foreach(dep ${MODULE_DEPENDS})
message("MODULEDOT \"${MODULE_NAME}\" -> \"${dep}\" ; ")
endforeach(dep)
endif(MITK_GENERATE_MODULE_DOT)
if (EXISTS ${MODULE_FILES_CMAKE})
include(${MODULE_FILES_CMAKE})
endif()
if(MODULE_CPP_FILES)
list(APPEND CPP_FILES ${MODULE_CPP_FILES})
endif()
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src")
# Preprend the "src" directory to the cpp file list
set(_cpp_files ${CPP_FILES})
set(CPP_FILES )
foreach(_cpp_file ${_cpp_files})
list(APPEND CPP_FILES "src/${_cpp_file}")
endforeach()
endif()
if(CPP_FILES OR RESOURCE_FILES OR UI_FILES OR MOC_H_FILES OR QRC_FILES)
set(MODULE_HEADERS_ONLY 0)
if(MODULE_C_MODULE)
set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE C)
elseif(MODULE_CXX_MODULE)
set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE CXX)
endif()
else()
set(MODULE_HEADERS_ONLY 1)
if(MODULE_AUTOLOAD_WITH)
message(SEND_ERROR "A headers only module cannot be auto-loaded")
endif()
endif()
set(module_c_flags )
set(module_c_flags_debug )
set(module_c_flags_release )
set(module_cxx_flags )
set(module_cxx_flags_debug )
set(module_cxx_flags_release )
if(MODULE_GCC_DEFAULT_VISIBILITY OR NOT CMAKE_COMPILER_IS_GNUCXX)
# We only support hidden visibility for gcc for now. Clang still has troubles with
# correctly marking template declarations and explicit template instantiations as exported.
# See http://comments.gmane.org/gmane.comp.compilers.clang.scm/50028
# and http://llvm.org/bugs/show_bug.cgi?id=10113
set(CMAKE_CXX_VISIBILITY_PRESET default)
set(CMAKE_VISIBILITY_INLINES_HIDDEN 0)
else()
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
endif()
if(MODULE_WARNINGS_AS_ERRORS)
if(MSVC_VERSION)
mitkFunctionCheckCAndCXXCompilerFlags("/WX" module_c_flags module_cxx_flags)
else()
mitkFunctionCheckCAndCXXCompilerFlags(-Werror module_c_flags module_cxx_flags)
# The flag "c++0x-static-nonintegral-init" has been renamed in newer Clang
# versions to "static-member-init", see
# http://clang-developers.42468.n3.nabble.com/Wc-0x-static-nonintegral-init-gone-td3999651.html
#
# Also, older Clang and seemingly all gcc versions do not warn if unknown
# "-no-*" flags are used, so CMake will happily append any -Wno-* flag to the
# command line. This may get confusing if unrelated compiler errors happen and
# the error output then additionally contains errors about unknown flags (which
# is not the case if there were no compile errors).
#
# So instead of using -Wno-* we use -Wno-error=*, which will be properly rejected by
# the compiler and if applicable, prints the specific warning as a real warning and
# not as an error (although -Werror was given).
mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=c++0x-static-nonintegral-init" module_c_flags module_cxx_flags)
mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=static-member-init" module_c_flags module_cxx_flags)
mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=unknown-warning" module_c_flags module_cxx_flags)
mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=gnu" module_c_flags module_cxx_flags)
mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=inconsistent-missing-override" module_c_flags module_cxx_flags)
endif()
endif(MODULE_WARNINGS_AS_ERRORS)
if(MODULE_FORCE_STATIC)
set(_STATIC STATIC)
else()
set(_STATIC )
endif(MODULE_FORCE_STATIC)
if(NOT MODULE_HEADERS_ONLY)
if(NOT MODULE_NO_INIT OR RESOURCE_FILES)
find_package(CppMicroServices QUIET NO_MODULE REQUIRED)
endif()
if(NOT MODULE_NO_INIT)
usFunctionGenerateModuleInit(CPP_FILES)
endif()
set(binary_res_files )
set(source_res_files )
if(RESOURCE_FILES)
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/resource")
set(res_dir resource)
elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Resources")
set(res_dir Resources)
else()
message(SEND_ERROR "Resources specified but ${CMAKE_CURRENT_SOURCE_DIR}/resource directory not found.")
endif()
foreach(res_file ${RESOURCE_FILES})
if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}/${res_file})
list(APPEND binary_res_files "${res_file}")
else()
list(APPEND source_res_files "${res_file}")
endif()
endforeach()
# Add a source level dependencies on resource files
usFunctionGetResourceSource(TARGET ${MODULE_TARGET} OUT CPP_FILES)
endif()
endif()
- if(MITK_USE_QT)
+ if(MITK_USE_Qt5)
if(UI_FILES)
qt5_wrap_ui(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES})
endif()
if(MOC_H_FILES)
qt5_wrap_cpp(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES} OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
endif()
if(QRC_FILES)
qt5_add_resources(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES})
endif()
endif()
set(Q${KITNAME}_GENERATED_CPP ${Q${KITNAME}_GENERATED_CPP} ${Q${KITNAME}_GENERATED_UI_CPP} ${Q${KITNAME}_GENERATED_MOC_CPP} ${Q${KITNAME}_GENERATED_QRC_CPP})
mitkFunctionOrganizeSources(
SOURCE ${CPP_FILES}
HEADER ${H_FILES}
TXX ${TXX_FILES}
DOC ${DOX_FILES}
UI ${UI_FILES}
QRC ${QRC_FILES}
MOC ${Q${KITNAME}_GENERATED_MOC_CPP}
GEN_QRC ${Q${KITNAME}_GENERATED_QRC_CPP}
GEN_UI ${Q${KITNAME}_GENERATED_UI_CPP}
)
set(coverage_sources
${CPP_FILES} ${H_FILES} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES}
${TOOL_CPPS} ${TOOL_GUI_CPPS})
if(MODULE_SUBPROJECTS)
set_property(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
endif()
# ---------------------------------------------------------------
# Create the actual module target
if(MODULE_HEADERS_ONLY)
add_library(${MODULE_TARGET} INTERFACE)
else()
if(MODULE_EXECUTABLE)
add_executable(${MODULE_TARGET}
${MODULE_CPP_FILES} ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
${DOX_FILES} ${UI_FILES} ${QRC_FILES})
set(_us_module_name main)
else()
add_library(${MODULE_TARGET} ${_STATIC}
${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
${DOX_FILES} ${UI_FILES} ${QRC_FILES})
set(_us_module_name ${MODULE_TARGET})
endif()
# Apply properties to the module target.
target_compile_definitions(${MODULE_TARGET} PRIVATE US_MODULE_NAME=${_us_module_name})
if(MODULE_C_MODULE)
if(module_c_flags)
string(REPLACE " " ";" module_c_flags "${module_c_flags}")
target_compile_options(${MODULE_TARGET} PRIVATE ${module_c_flags})
endif()
if(module_c_flags_debug)
string(REPLACE " " ";" module_c_flags_debug "${module_c_flags_debug}")
target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_c_flags_debug}>)
endif()
if(module_c_flags_release)
string(REPLACE " " ";" module_c_flags_release "${module_c_flags_release}")
target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_c_flags_release}>)
endif()
else()
if(module_cxx_flags)
string(REPLACE " " ";" module_cxx_flags "${module_cxx_flags}")
target_compile_options(${MODULE_TARGET} PRIVATE ${module_cxx_flags})
endif()
if(module_cxx_flags_debug)
string(REPLACE " " ";" module_cxx_flags_debug "${module_cxx_flags_debug}")
target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_cxx_flags_debug}>)
endif()
if(module_cxx_flags_release)
string(REPLACE " " ";" module_cxx_flags_release "${module_cxx_flags_release}")
target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_cxx_flags_release}>)
endif()
endif()
set_property(TARGET ${MODULE_TARGET} PROPERTY US_MODULE_NAME ${_us_module_name})
if(MINGW)
target_link_libraries(${MODULE_TARGET} ssp) # add stack smash protection lib
endif()
# Add additional library search directories to a global property which
# can be evaluated by other CMake macros, e.g. our install scripts.
if(MODULE_ADDITIONAL_LIBS)
target_link_libraries(${MODULE_TARGET} PRIVATE ${MODULE_ADDITIONAL_LIBS})
get_property(_mitk_additional_library_search_paths GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
foreach(_lib_filepath ${MODULE_ADDITIONAL_LIBS})
get_filename_component(_search_path "${_lib_filepath}" PATH)
if(_search_path)
list(APPEND _mitk_additional_library_search_paths "${_search_path}")
endif()
endforeach()
if(_mitk_additional_library_search_paths)
list(REMOVE_DUPLICATES _mitk_additional_library_search_paths)
set_property(GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS ${_mitk_additional_library_search_paths})
endif()
endif()
# add the target name to a global property which is used in the top-level
# CMakeLists.txt file to export the target
set_property(GLOBAL APPEND PROPERTY MITK_MODULE_TARGETS ${MODULE_TARGET})
if(MODULE_AUTOLOAD_WITH)
# for auto-loaded modules, adapt the output directory
add_dependencies(${_module_autoload_meta_target} ${MODULE_TARGET})
if(WIN32)
set(_module_output_prop RUNTIME_OUTPUT_DIRECTORY)
else()
set(_module_output_prop LIBRARY_OUTPUT_DIRECTORY)
endif()
set(_module_output_dir ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
get_target_property(_module_is_imported ${MODULE_AUTOLOAD_WITH} IMPORTED)
if(NOT _module_is_imported)
# if the auto-loading module is not imported, get its location
# and put the auto-load module relative to it.
get_target_property(_module_output_dir ${MODULE_AUTOLOAD_WITH} ${_module_output_prop})
set_target_properties(${MODULE_TARGET} PROPERTIES
${_module_output_prop} ${_module_output_dir}/${MODULE_AUTOLOAD_WITH})
else()
set_target_properties(${MODULE_TARGET} PROPERTIES
${_module_output_prop} ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
endif()
set_target_properties(${MODULE_TARGET} PROPERTIES
MITK_AUTOLOAD_DIRECTORY ${MODULE_AUTOLOAD_WITH})
# add the auto-load module name as a property
set_property(TARGET ${MODULE_AUTOLOAD_WITH} APPEND PROPERTY MITK_AUTOLOAD_TARGETS ${MODULE_TARGET})
endif()
if(binary_res_files)
usFunctionAddResources(TARGET ${MODULE_TARGET}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}
FILES ${binary_res_files})
endif()
if(source_res_files)
usFunctionAddResources(TARGET ${MODULE_TARGET}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${res_dir}
FILES ${source_res_files})
endif()
if(binary_res_files OR source_res_files)
usFunctionEmbedResources(TARGET ${MODULE_TARGET})
endif()
if(MODULE_DEPRECATED_SINCE)
set_property(TARGET ${MODULE_TARGET} PROPERTY MITK_MODULE_DEPRECATED_SINCE ${MODULE_DEPRECATED_SINCE})
endif()
# create export macros
if (NOT MODULE_EXECUTABLE)
set(_export_macro_name )
if(MITK_LEGACY_EXPORT_MACRO_NAME)
set(_export_macro_names
EXPORT_MACRO_NAME ${MODULE_EXPORT_DEFINE}
NO_EXPORT_MACRO_NAME ${MODULE_NAME}_NO_EXPORT
DEPRECATED_MACRO_NAME ${MODULE_NAME}_DEPRECATED
NO_DEPRECATED_MACRO_NAME ${MODULE_NAME}_NO_DEPRECATED
)
endif()
generate_export_header(${MODULE_NAME}
${_export_macro_names}
EXPORT_FILE_NAME ${MODULE_NAME}Exports.h
)
endif()
target_include_directories(${MODULE_TARGET} PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
endif()
# ---------------------------------------------------------------
# Properties for both header-only and compiled modules
if(MODULE_HEADERS_ONLY)
set(_module_property_type INTERFACE)
else()
set(_module_property_type PUBLIC)
endif()
if(MODULE_TARGET_DEPENDS)
add_dependencies(${MODULE_TARGET} ${MODULE_TARGET_DEPENDS})
endif()
if(MODULE_SUBPROJECTS AND NOT MODULE_HEADERS_ONLY)
set_property(TARGET ${MODULE_TARGET} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
foreach(subproject ${MODULE_SUBPROJECTS})
add_dependencies(${subproject} ${MODULE_TARGET})
endforeach()
endif()
set(DEPENDS "${MODULE_DEPENDS}")
if(NOT MODULE_NO_INIT AND NOT MODULE_HEADERS_ONLY)
# Add a CppMicroServices dependency implicitly, since it is
# needed for the generated "module initialization" code.
set(DEPENDS "CppMicroServices;${DEPENDS}")
endif()
if(DEPENDS OR MODULE_PACKAGE_DEPENDS)
mitk_use_modules(TARGET ${MODULE_TARGET}
MODULES ${DEPENDS}
PACKAGES ${MODULE_PACKAGE_DEPENDS}
)
endif()
if(NOT MODULE_C_MODULE)
target_compile_features(${MODULE_TARGET} ${_module_property_type} ${MITK_CXX_FEATURES})
endif()
# add include directories
if(MODULE_INTERNAL_INCLUDE_DIRS)
target_include_directories(${MODULE_TARGET} PRIVATE ${MODULE_INTERNAL_INCLUDE_DIRS})
endif()
if(NOT MODULE_NO_DEFAULT_INCLUDE_DIRS)
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/include)
target_include_directories(${MODULE_TARGET} ${_module_property_type} include)
else()
target_include_directories(${MODULE_TARGET} ${_module_property_type} .)
endif()
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/src)
target_include_directories(${MODULE_TARGET} PRIVATE src)
endif()
endif()
target_include_directories(${MODULE_TARGET} ${_module_property_type} ${MODULE_INCLUDE_DIRS})
endif()
# -----------------------------------------------------------------
# Record missing dependency information
if(_MISSING_DEP)
if(MODULE_DESCRIPTION)
set(MODULE_DESCRIPTION "${MODULE_DESCRIPTION} (missing dependencies: ${_MISSING_DEP})")
else()
set(MODULE_DESCRIPTION "(missing dependencies: ${_MISSING_DEP})")
endif()
endif()
if(NOT MODULE_NO_FEATURE_INFO)
add_feature_info(${MODULE_NAME} MODULE_IS_ENABLED "${MODULE_DESCRIPTION}")
endif()
set(MODULE_NAME ${MODULE_NAME} PARENT_SCOPE)
set(MODULE_TARGET ${MODULE_TARGET} PARENT_SCOPE)
set(MODULE_IS_ENABLED ${MODULE_IS_ENABLED} PARENT_SCOPE)
set(MODULE_SUBPROJECTS ${MODULE_SUBPROJECTS} PARENT_SCOPE)
endfunction()
diff --git a/CMake/mitkFunctionGetLibrarySearchPaths.cmake b/CMake/mitkFunctionGetLibrarySearchPaths.cmake
index 93d5f2a02b..f172bce679 100644
--- a/CMake/mitkFunctionGetLibrarySearchPaths.cmake
+++ b/CMake/mitkFunctionGetLibrarySearchPaths.cmake
@@ -1,168 +1,168 @@
function(mitkFunctionGetLibrarySearchPaths search_path intermediate_dir)
set(_dir_candidates
"${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
"${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins"
"${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
"${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}/plugins"
)
if(MITK_EXTERNAL_PROJECT_PREFIX)
list(APPEND _dir_candidates
"${MITK_EXTERNAL_PROJECT_PREFIX}/bin"
"${MITK_EXTERNAL_PROJECT_PREFIX}/lib"
)
endif()
# Determine the Qt5 library installation prefix
set(_qmake_location )
- if(MITK_USE_QT AND TARGET ${Qt5Core_QMAKE_EXECUTABLE})
+ if(MITK_USE_Qt5 AND TARGET ${Qt5Core_QMAKE_EXECUTABLE})
get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE}
PROPERTY IMPORT_LOCATION)
endif()
if(_qmake_location)
if(NOT _qt_install_libs)
if(WIN32)
execute_process(COMMAND ${_qmake_location} -query QT_INSTALL_BINS
OUTPUT_VARIABLE _qt_install_libs
OUTPUT_STRIP_TRAILING_WHITESPACE)
else()
execute_process(COMMAND ${_qmake_location} -query QT_INSTALL_LIBS
OUTPUT_VARIABLE _qt_install_libs
OUTPUT_STRIP_TRAILING_WHITESPACE)
endif()
file(TO_CMAKE_PATH "${_qt_install_libs}" _qt_install_libs)
set(_qt_install_libs ${_qt_install_libs} CACHE INTERNAL "Qt library installation prefix" FORCE)
endif()
if(_qt_install_libs)
list(APPEND _dir_candidates ${_qt_install_libs})
endif()
- elseif(MITK_USE_QT)
+ elseif(MITK_USE_Qt5)
message(WARNING "The qmake executable could not be found.")
endif()
get_property(_additional_paths GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
if(MITK_USE_HDF5)
FIND_PACKAGE(HDF5 COMPONENTS C HL NO_MODULE REQUIRED shared)
get_target_property(_location hdf5-shared LOCATION)
get_filename_component(_location ${_location} PATH)
list(APPEND _additional_paths ${_location})
# This is a work-around. The hdf5-config.cmake file is not robust enough
# to be included several times via find_pakcage calls.
set(HDF5_LIBRARIES ${HDF5_LIBRARIES} PARENT_SCOPE)
endif()
if(MITK_USE_Vigra)
# we cannot use _find_package(Vigra) here because the vigra-config.cmake file
# always includes the target-exports files without using an include guard. This
# would lead to errors when another find_package(Vigra) call is processed. The
# (bad) assumption here is that for the time being, only the Classification module
# is using Vigra.
if(UNIX)
list(APPEND _additional_paths ${Vigra_DIR}/lib)
else()
list(APPEND _additional_paths ${Vigra_DIR}/bin)
endif()
endif()
if(_additional_paths)
list(APPEND _dir_candidates ${_additional_paths})
endif()
# The code below is sub-optimal. It makes assumptions about
# the structure of the build directories, pointed to by
# the *_DIR variables. Instead, we should rely on package
# specific "LIBRARY_DIRS" variables, if they exist.
if(WIN32)
if(SOFA_DIR)
list(APPEND _dir_candidates "${SOFA_DIR}/bin")
endif()
list(APPEND _dir_candidates "${ITK_DIR}/bin")
else()
if(SOFA_DIR)
list(APPEND _dir_candidates "${SOFA_DIR}/lib")
endif()
endif()
if(MITK_USE_MatchPoint)
if(WIN32)
list(APPEND _dir_candidates "${MatchPoint_DIR}/bin")
else()
list(APPEND _dir_candidates "${MatchPoint_DIR}/lib")
endif()
endif()
if(OpenCV_DIR)
set(_opencv_link_directories
"${OpenCV_LIB_DIR_DBG}"
"${OpenCV_LIB_DIR_OPT}"
"${OpenCV_3RDPARTY_LIB_DIR_DBG}"
"${OpenCV_3RDPARTY_LIB_DIR_OPT}")
list(REMOVE_DUPLICATES _opencv_link_directories)
if(WIN32)
foreach(_opencv_link_directory ${_opencv_link_directories})
list(APPEND _dir_candidates "${_opencv_link_directory}/../bin")
endforeach()
else()
list(APPEND _dir_candidates ${_opencv_link_directories})
endif()
endif()
if(MITK_USE_Python)
list(APPEND _dir_candidates "${CTK_DIR}/CMakeExternals/Install/bin")
list(APPEND _dir_candidates "${MITK_EXTERNAL_PROJECT_PREFIX}/lib/python2.7/bin")
endif()
if(MITK_USE_TOF_PMDO3 OR MITK_USE_TOF_PMDCAMCUBE OR MITK_USE_TOF_PMDCAMBOARD)
list(APPEND _dir_candidates "${MITK_PMD_SDK_DIR}/plugins" "${MITK_PMD_SDK_DIR}/bin")
endif()
if(MITK_USE_CTK)
list(APPEND _dir_candidates "${CTK_LIBRARY_DIRS}")
foreach(_ctk_library ${CTK_LIBRARIES})
if(${_ctk_library}_LIBRARY_DIRS)
list(APPEND _dir_candidates "${${_ctk_library}_LIBRARY_DIRS}")
endif()
endforeach()
endif()
if(MITK_USE_BLUEBERRY)
if(DEFINED CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY)
if(IS_ABSOLUTE "${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
list(APPEND _dir_candidates "${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
else()
list(APPEND _dir_candidates "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
endif()
endif()
endif()
if(MITK_LIBRARY_DIRS)
list(APPEND _dir_candidates ${MITK_LIBRARY_DIRS})
endif()
list(REMOVE_DUPLICATES _dir_candidates)
set(_search_dirs )
foreach(_dir ${_dir_candidates})
if(EXISTS "${_dir}/${intermediate_dir}")
list(APPEND _search_dirs "${_dir}/${intermediate_dir}")
else()
list(APPEND _search_dirs "${_dir}")
endif()
endforeach()
# Special handling for "internal" search dirs. The intermediate directory
# might not have been created yet, so we can't check for its existence.
# Hence we just add it for Windows without checking.
set(_internal_search_dirs "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins")
if(WIN32)
foreach(_dir ${_internal_search_dirs})
set(_search_dirs "${_dir}/${intermediate_dir}" ${_search_dirs})
endforeach()
else()
set(_search_dirs ${_internal_search_dirs} ${_search_dirs})
endif()
list(REMOVE_DUPLICATES _search_dirs)
set(${search_path} ${_search_dirs} PARENT_SCOPE)
endfunction()
diff --git a/CMake/mitkInstallRules.cmake b/CMake/mitkInstallRules.cmake
index 222dfa4abf..e818345fe2 100644
--- a/CMake/mitkInstallRules.cmake
+++ b/CMake/mitkInstallRules.cmake
@@ -1,158 +1,178 @@
MITK_INSTALL(FILES "${MITK_SOURCE_DIR}/mitk.ico")
MITK_INSTALL(FILES "${MITK_SOURCE_DIR}/mitk.bmp")
# Install CTK Qt (designer) plugins
if(MITK_USE_CTK)
if(EXISTS ${CTK_QTDESIGNERPLUGINS_DIR})
set(_qtplugin_install_destinations)
if(MACOSX_BUNDLE_NAMES)
foreach(bundle_name ${MACOSX_BUNDLE_NAMES})
list(APPEND _qtplugin_install_destinations
${bundle_name}.app/Contents/MacOS/${_install_DESTINATION}/plugins/designer)
endforeach()
else()
list(APPEND _qtplugin_install_destinations bin/plugins/designer)
endif()
set(_ctk_qt_plugin_folder_release)
set(_ctk_qt_plugin_folder_debug)
if(NOT CMAKE_CFG_INTDIR STREQUAL ".")
set(_ctk_qt_plugin_folder_release "Release/")
set(_ctk_qt_plugin_folder_debug "Debug/")
endif()
foreach(_qtplugin_install_dir ${_qtplugin_install_destinations})
install(DIRECTORY "${CTK_QTDESIGNERPLUGINS_DIR}/designer/${_ctk_qt_plugin_folder_release}"
DESTINATION ${_qtplugin_install_dir}
CONFIGURATIONS Release
)
install(DIRECTORY "${CTK_QTDESIGNERPLUGINS_DIR}/designer/${_ctk_qt_plugin_folder_debug}"
DESTINATION ${_qtplugin_install_dir}
CONFIGURATIONS Debug
)
endforeach()
endif()
endif()
# related to MITK:T19679
if(MACOSX_BUNDLE_NAMES)
foreach(bundle_name ${MACOSX_BUNDLE_NAMES})
get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE}
PROPERTY IMPORT_LOCATION)
get_filename_component(_qmake_path "${_qmake_location}" DIRECTORY)
install(FILES "${_qmake_path}/../plugins/platforms/libqcocoa.dylib"
DESTINATION "${bundle_name}.app/Contents/MacOS/platforms"
CONFIGURATIONS Release)
install(FILES "${_qmake_path}/../plugins/sqldrivers/libqsqlite.dylib"
DESTINATION "${bundle_name}.app/Contents/MacOS/sqldrivers"
CONFIGURATIONS Release)
install(FILES "${_qmake_path}/../plugins/iconengines/libqsvgicon.dylib"
DESTINATION "${bundle_name}.app/Contents/MacOS/iconengines"
CONFIGURATIONS Release)
# related to MITK:T19679-InstallQtWebEnginProcess
- if(MITK_USE_QT_WEBENGINE)
+ if(MITK_USE_Qt5_WebEngine)
get_filename_component(ABS_DIR_HELPERS "${_qmake_path}/../lib/QtWebEngineCore.framework/Helpers" REALPATH)
install(DIRECTORY ${ABS_DIR_HELPERS}
DESTINATION "${bundle_name}.app/Contents/Frameworks/QtWebEngineCore.framework/"
CONFIGURATIONS Release)
endif()
endforeach()
endif()
if(WIN32)
- if(MITK_USE_QT)
+ if(MITK_USE_Qt5)
get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE}
PROPERTY IMPORT_LOCATION)
get_filename_component(_qmake_path "${_qmake_location}" DIRECTORY)
install(FILES "${_qmake_path}/../plugins/platforms/qwindows.dll"
DESTINATION "bin/plugins/platforms"
CONFIGURATIONS Release)
install(FILES "${_qmake_path}/../plugins/sqldrivers/qsqlite.dll"
DESTINATION "bin/plugins/sqldrivers"
CONFIGURATIONS Release)
install(FILES "${_qmake_path}/../plugins/imageformats/qsvg.dll"
DESTINATION "bin/plugins/imageformats"
CONFIGURATIONS Release)
install(FILES "${_qmake_path}/../plugins/iconengines/qsvgicon.dll"
DESTINATION "bin/plugins/iconengines"
CONFIGURATIONS Release)
- if(MITK_USE_QT_WEBENGINE)
+ if(MITK_USE_Qt5_WebEngine)
MITK_INSTALL( FILES "${_qmake_path}/QtWebEngineProcess.exe")
endif()
install(DIRECTORY "${_qmake_path}/../resources/"
DESTINATION "bin/resources/"
CONFIGURATIONS Release)
+ install(DIRECTORY "${_qmake_path}/../translations/qtwebengine_locales/"
+ DESTINATION "bin/translations/qtwebengine_locales/"
+ CONFIGURATIONS Release)
install(FILES "${_qmake_path}/../plugins/platforms/qwindowsd.dll"
DESTINATION "bin/plugins/platforms"
CONFIGURATIONS Debug)
install(FILES "${_qmake_path}/../plugins/sqldrivers/qsqlited.dll"
DESTINATION "bin/plugins/sqldrivers"
CONFIGURATIONS Debug)
install(FILES "${_qmake_path}/../plugins/imageformats/qsvgd.dll"
DESTINATION "bin/plugins/imageformats"
CONFIGURATIONS Debug)
install(FILES "${_qmake_path}/../plugins/iconengines/qsvgicond.dll"
DESTINATION "bin/plugins/iconengines"
CONFIGURATIONS Debug)
install(DIRECTORY "${_qmake_path}/../resources/"
DESTINATION "bin/resources/"
CONFIGURATIONS Debug)
+ install(DIRECTORY "${_qmake_path}/../translations/qtwebengine_locales/"
+ DESTINATION "bin/translations/qtwebengine_locales/"
+ CONFIGURATIONS Debug)
endif()
#DCMTK Dlls install target (shared libs on gcc only)
if(MINGW AND DCMTK_ofstd_LIBRARY)
set(_dcmtk_libs
${DCMTK_dcmdata_LIBRARY}
${DCMTK_dcmimgle_LIBRARY}
${DCMTK_dcmnet_LIBRARY}
${DCMTK_ofstd_LIBRARY}
)
foreach(_dcmtk_lib ${_dcmtk_libs})
MITK_INSTALL(FILES ${_dcmtk_lib} )
endforeach()
endif()
#MinGW dll
if(MINGW)
find_library(MINGW_RUNTIME_DLL "mingwm10.dll" HINTS ${CMAKE_FIND_ROOT_PATH}/sys-root/mingw/bin)
if(MINGW_RUNTIME_DLL)
MITK_INSTALL(FILES ${MINGW_RUNTIME_DLL} )
else()
message(SEND_ERROR "Could not find mingwm10.dll which is needed for a proper install")
endif()
find_library(MINGW_GCC_RUNTIME_DLL "libgcc_s_dw2-1.dll" HINTS ${CMAKE_FIND_ROOT_PATH}/sys-root/mingw/bin)
if(MINGW_GCC_RUNTIME_DLL)
MITK_INSTALL(FILES ${MINGW_GCC_RUNTIME_DLL} )
else()
message(SEND_ERROR "Could not find libgcc_s_dw2-1.dll which is needed for a proper install")
endif()
endif()
else()
#DCMTK Dlls install target (shared libs on gcc only)
if(DCMTK_ofstd_LIBRARY)
set(_dcmtk_libs
${DCMTK_dcmdata_LIBRARY}
${DCMTK_dcmimgle_LIBRARY}
${DCMTK_dcmnet_LIBRARY}
${DCMTK_ofstd_LIBRARY}
)
foreach(_dcmtk_lib ${_dcmtk_libs})
#MITK_INSTALL(FILES ${_dcmtk_lib} DESTINATION lib)
endforeach()
endif()
+# We need to install Webengineprocess and related files on unix as well
+ if(UNIX)
+ if(MITK_USE_Qt5_WebEngine)
+ get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE}
+ PROPERTY IMPORT_LOCATION)
+ get_filename_component(_qmake_path "${_qmake_location}" DIRECTORY)
+ MITK_INSTALL_HELPER_APP( EXECUTABLES "${_qmake_path}/../libexec/QtWebEngineProcess")
+ install(DIRECTORY "${_qmake_path}/../resources/"
+ DESTINATION "bin/resources/")
+ install(DIRECTORY "${_qmake_path}/../translations/qtwebengine_locales/"
+ DESTINATION "bin/translations/qtwebengine_locales/")
+ endif()
+ endif()
+
endif()
#install Matchpoint libs that are currently not auto detected
if(MITK_USE_MatchPoint)
install(DIRECTORY "${MITK_EXTERNAL_PROJECT_PREFIX}/bin/"
DESTINATION "bin"
FILES_MATCHING PATTERN "MAPUtilities*")
install(DIRECTORY "${MITK_EXTERNAL_PROJECT_PREFIX}/bin/"
DESTINATION "bin"
FILES_MATCHING PATTERN "MAPAlgorithms*")
endif()
diff --git a/CMake/mitkMacroInstallHelperApp.cmake b/CMake/mitkMacroInstallHelperApp.cmake
index 1478e684e8..788d121a58 100644
--- a/CMake/mitkMacroInstallHelperApp.cmake
+++ b/CMake/mitkMacroInstallHelperApp.cmake
@@ -1,109 +1,109 @@
#! MITK specific cross plattform install macro
#!
#! Usage: MITK_INSTALL_HELPER_APP(target1 [target2] ....)
#!
macro(MITK_INSTALL_HELPER_APP)
cmake_parse_arguments(_install "GLOB_PLUGINS" "" "TARGETS;EXECUTABLES;PLUGINS;LIBRARY_DIRS" ${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()
mitkFunctionGetLibrarySearchPaths(DIRS ${intermediate_dir})
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(_target_location bin/${_target_name})
+ set(${_target_location}_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/CMakeExternals/MITKData.cmake b/CMakeExternals/MITKData.cmake
index 143793a446..1db98363bc 100644
--- a/CMakeExternals/MITKData.cmake
+++ b/CMakeExternals/MITKData.cmake
@@ -1,39 +1,39 @@
#-----------------------------------------------------------------------------
# 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 b8db25fb) # first 8 characters of hash-tag
set(revision_tag 2ec7124c) # first 8 characters of hash-tag
# ^^^^^^^^ these are just to check correct length of hash part
ExternalProject_Add(${proj}
SOURCE_DIR ${proj}
# GIT_REPOSITORY https://phabricator.mitk.org/diffusion/MD/mitk-data.git
# GIT_TAG ${revision_tag}
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 ${CMAKE_CURRENT_BINARY_DIR}/${proj})
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif(BUILD_TESTING)
diff --git a/CMakeExternals/MatchPoint.cmake b/CMakeExternals/MatchPoint.cmake
index cf2ec08d6e..68517ac8dc 100644
--- a/CMakeExternals/MatchPoint.cmake
+++ b/CMakeExternals/MatchPoint.cmake
@@ -1,62 +1,62 @@
#-----------------------------------------------------------------------------
# MatchPoint
#-----------------------------------------------------------------------------
if(MITK_USE_MatchPoint)
set(MatchPoint_SOURCE_DIR "" CACHE PATH "Location of the MatchPoint source directory")
mark_as_advanced(MatchPoint_SOURCE_DIR)
# Sanity checks
if(DEFINED MatchPoint_DIR AND NOT EXISTS ${MatchPoint_DIR})
message(FATAL_ERROR "MatchPoint_DIR variable is defined but corresponds to non-existing directory")
endif()
if(NOT MatchPoint_DIR AND MatchPoint_SOURCE_DIR AND NOT EXISTS ${MatchPoint_SOURCE_DIR})
message(FATAL_ERROR "MatchPoint_SOURCE_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj MatchPoint)
set(proj_DEPENDENCIES ITK)
set(MatchPoint_DEPENDS ${proj})
if(NOT MatchPoint_DIR)
if(MatchPoint_SOURCE_DIR)
set(download_step SOURCE_DIR ${MatchPoint_SOURCE_DIR})
else()
set(download_step
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/MatchPoint_rev1610.tar.gz
- URL_MD5 a9508c8d9ab58a20cf8fa45adb972a02
+ URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/MatchPoint_rev1681.tar.gz
+ URL_MD5 fa18c890751a192ac72803d115a1c702
)
endif()
ExternalProject_Add(${proj}
${download_step}
# INSTALL_COMMAND "${CMAKE_COMMAND} -P cmake_install.cmake"
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
${additional_cmake_args}
-DBUILD_TESTING:BOOL=OFF
-DITK_DIR:PATH=${ITK_DIR} #/src/ITK-build
-DMAP_USE_SYSTEM_GDCM:BOOL=ON
-DMAP_DISABLE_ITK_IO_FACTORY_AUTO_REGISTER:BOOL=ON
-DMAP_WRAP_Plastimatch:BOOL=ON
-DGDCM_DIR:PATH=${GDCM_DIR}
CMAKE_CACHE_ARGS
${ep_common_cache_args}
CMAKE_CACHE_DEFAULT_ARGS
${ep_common_cache_default_args}
DEPENDS ${proj_DEPENDENCIES}
)
ExternalProject_Get_Property(${proj} binary_dir)
set(${proj}_DIR ${binary_dir})
mitkFunctionInstallExternalCMakeProject(${proj})
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
endif(MITK_USE_MatchPoint)
diff --git a/CMakeExternals/OpenCV.cmake b/CMakeExternals/OpenCV.cmake
index c542c9b0c1..c1bbfd676b 100644
--- a/CMakeExternals/OpenCV.cmake
+++ b/CMakeExternals/OpenCV.cmake
@@ -1,103 +1,103 @@
#-----------------------------------------------------------------------------
# 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
-DBUILD_opencv_java:BOOL=OFF
-DBUILD_opencv_ts:BOOL=OFF
-DBUILD_PERF_TESTS:BOOL=OFF
)
if(MITK_USE_Python)
if(NOT MITK_USE_SYSTEM_PYTHON)
list(APPEND proj_DEPENDENCIES Python Numpy)
# export python home
set(ENV{PYTHONHOME} "${Python_DIR}")
set(CV_PACKAGE_PATH -DPYTHON_PACKAGES_PATH:PATH=${MITK_PYTHON_SITE_DIR})
else()
set(CV_PACKAGE_PATH -DPYTHON_PACKAGES_PATH:PATH=${ep_prefix}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
endif()
list(APPEND additional_cmake_args
-DBUILD_opencv_python:BOOL=ON
-DBUILD_NEW_PYTHON_SUPPORT:BOOL=ON
-DPYTHON_DEBUG_LIBRARY:FILEPATH=${PYTHON_DEBUG_LIBRARY}
-DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
-DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
-DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
-DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
${CV_PACKAGE_PATH}
#-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)
+ if(MITK_USE_Qt5)
list(APPEND additional_cmake_args
-DWITH_QT:BOOL=OFF
-DWITH_QT_OPENGL:BOOL=OFF
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
)
endif()
if(CTEST_USE_LAUNCHERS)
list(APPEND additional_cmake_args
"-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
)
endif()
set(opencv_url ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/opencv-2.4.13.2.tar.gz)
set(opencv_url_md5 80a4a3bee0e98898bbbc68986ca73655)
ExternalProject_Add(${proj}
LIST_SEPARATOR ${sep}
URL ${opencv_url}
URL_MD5 ${opencv_url_md5}
# Related bug: http://bugs.mitk.org/show_bug.cgi?id=5912
PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/OpenCV.patch
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
-DBUILD_TESTS:BOOL=OFF
-DBUILD_DOCS:BOOL=OFF
-DBUILD_EXAMPLES:BOOL=OFF
-DBUILD_DOXYGEN_DOCS:BOOL=OFF
-DWITH_CUDA:BOOL=OFF
${additional_cmake_args}
CMAKE_CACHE_ARGS
${ep_common_cache_args}
CMAKE_CACHE_DEFAULT_ARGS
${ep_common_cache_default_args}
DEPENDS ${proj_DEPENDENCIES}
)
set(OpenCV_DIR ${ep_prefix})
mitkFunctionInstallExternalCMakeProject(${proj})
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
endif()
diff --git a/CMakeExternals/VTK.cmake b/CMakeExternals/VTK.cmake
index 9d0756d51e..1e27a03e16 100644
--- a/CMakeExternals/VTK.cmake
+++ b/CMakeExternals/VTK.cmake
@@ -1,117 +1,117 @@
#-----------------------------------------------------------------------------
# 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(MITK_USE_HDF5)
list(APPEND proj_DEPENDENCIES HDF5)
endif()
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()
# Optionally enable memory leak checks for any objects derived from vtkObject. This
# will force unit tests to fail if they have any of these memory leaks.
option(MITK_VTK_DEBUG_LEAKS OFF)
mark_as_advanced(MITK_VTK_DEBUG_LEAKS)
list(APPEND additional_cmake_args
-DVTK_DEBUG_LEAKS:BOOL=${MITK_VTK_DEBUG_LEAKS}
)
if(MITK_USE_Python)
if(NOT MITK_USE_SYSTEM_PYTHON)
list(APPEND proj_DEPENDENCIES Python)
set(_vtk_install_python_dir -DVTK_INSTALL_PYTHON_MODULE_DIR:FILEPATH=${MITK_PYTHON_SITE_DIR})
else()
set(_vtk_install_python_dir -DVTK_INSTALL_PYTHON_MODULE_DIR:PATH=${ep_prefix}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
endif()
list(APPEND additional_cmake_args
-DVTK_WRAP_PYTHON:BOOL=ON
-DVTK_USE_TK:BOOL=OFF
-DVTK_WINDOWS_PYTHON_DEBUGGABLE:BOOL=OFF
-DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
-DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
-DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
-DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
${_vtk_install_python_dir}
)
else()
list(APPEND additional_cmake_args
-DVTK_WRAP_PYTHON:BOOL=OFF
-DVTK_WINDOWS_PYTHON_DEBUGGABLE:BOOL=OFF
)
endif()
- if(MITK_USE_QT)
+ if(MITK_USE_Qt5)
list(APPEND additional_cmake_args
-DVTK_QT_VERSION:STRING=5
-DVTK_Group_Qt:BOOL=ON
-DVTK_INSTALL_NO_QT_PLUGIN:BOOL=ON
)
endif()
if(CTEST_USE_LAUNCHERS)
list(APPEND additional_cmake_args
"-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
)
endif()
set(VTK_URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/VTK-7.0.0.tar.gz)
set(VTK_URL_MD5 5fe35312db5fb2341139b8e4955c367d)
ExternalProject_Add(${proj}
LIST_SEPARATOR ${sep}
URL ${VTK_URL}
URL_MD5 ${VTK_URL_MD5}
PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/VTK.patch
CMAKE_GENERATOR ${gen}
CMAKE_ARGS
${ep_common_args}
-DVTK_WRAP_TCL:BOOL=OFF
-DVTK_WRAP_PYTHON:BOOL=OFF
-DVTK_WRAP_JAVA:BOOL=OFF
-DVTK_USE_SYSTEM_FREETYPE:BOOL=${VTK_USE_SYSTEM_FREETYPE}
-DVTK_LEGACY_REMOVE:BOOL=ON
-DModule_vtkTestingRendering:BOOL=ON
-DVTK_MAKE_INSTANTIATORS:BOOL=ON
-DVTK_USE_CXX11_FEATURES:BOOL=ON
-DVTK_RENDERING_BACKEND:STRING=OpenGL
${additional_cmake_args}
CMAKE_CACHE_ARGS
${ep_common_cache_args}
CMAKE_CACHE_DEFAULT_ARGS
${ep_common_cache_default_args}
DEPENDS ${proj_DEPENDENCIES}
)
set(VTK_DIR ${ep_prefix})
mitkFunctionInstallExternalCMakeProject(${proj})
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9cc3fa5524..a3709f9483 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,1384 +1,1373 @@
set(MITK_CMAKE_MINIMUM_REQUIRED_VERSION 3.5)
cmake_minimum_required(VERSION ${MITK_CMAKE_MINIMUM_REQUIRED_VERSION})
#-----------------------------------------------------------------------------
-# See http://www.cmake.org/cmake/help/v3.2/manual/cmake-policies.7.html for details
+# See http://www.cmake.org/cmake/help/v3.5/manual/cmake-policies.7.html for details
#-----------------------------------------------------------------------------
set(project_policies )
foreach(policy ${project_policies})
if(POLICY ${policy})
cmake_policy(SET ${policy} NEW)
endif()
endforeach()
#-----------------------------------------------------------------------------
# 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 VERSION 2016.03.99)
+ project(MITK VERSION 2016.11.00)
endif()
#-----------------------------------------------------------------------------
# Update CMake module path
#------------------------------------------------------------------------------
set(MITK_CMAKE_DIR ${MITK_SOURCE_DIR}/CMake)
set(CMAKE_MODULE_PATH
${MITK_CMAKE_DIR}
${CMAKE_MODULE_PATH}
)
#-----------------------------------------------------------------------------
# CMake function(s) and macro(s)
#-----------------------------------------------------------------------------
# Standard CMake macros
include(FeatureSummary)
include(CTestUseLaunchers)
include(CMakeParseArguments)
include(FindPackageHandleStandardArgs)
# MITK macros
include(mitkFunctionGetGccVersion)
include(mitkFunctionCheckCompilerFlags)
include(mitkFunctionSuppressWarnings) # includes several functions
include(mitkMacroEmptyExternalProject)
include(mitkFunctionGenerateProjectXml)
include(mitkFunctionEnableBuildConfiguration)
include(mitkFunctionWhitelists)
include(mitkFunctionAddExternalProject)
SUPPRESS_VC_DEPRECATED_WARNINGS()
#-----------------------------------------------------------------------------
# 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()
#-----------------------------------------------------------------------------
# Check miminum Mac OS X version
#-----------------------------------------------------------------------------
# The minimum supported Mac OS X version is 10.9. If you use a version less than 10.9, there is no guarantee that the build still works.
if(APPLE)
exec_program(sw_vers ARGS -productVersion OUTPUT_VARIABLE osx_version)
if (osx_version VERSION_LESS "10.9")
message(WARNING "Detected OS X version \"${osx_version}\" is not supported anymore. Minimum required OS X version is 10.9 or greater.")
endif()
if (CMAKE_OSX_DEPLOYMENT_TARGET AND CMAKE_OSX_DEPLOYMENT_TARGET VERSION_LESS 10.9)
message(WARNING "Detected OS X deployment target \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" is not supported anymore. Minimum required OS X version is 10.9 or greater.")
endif()
endif()
#-----------------------------------------------------------------------------
# Check miminum compiler versions
#-----------------------------------------------------------------------------
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
# require at least gcc 4.9 as provided by ppa:ubuntu-toolchain-r/test for Ubuntu 12.04
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
message(FATAL_ERROR "GCC version must be at least 4.9
If you are using Ubuntu 12.04, you can easily install gcc and g++ 4.9 (or any later version available) in addition to your version ${CMAKE_CXX_COMPILER_VERSION}:
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt-get update
sudo apt-get install gcc-4.9 g++-4.9
Make sure to explicitly specify these compilers when configuring MITK:
CMAKE_C_COMPILER:FILEPATH=/usr/bin/gcc-4.9
CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/g++-4.9
For more information on the proposed PPA see the Toolchain Updates section of https://wiki.ubuntu.com/ToolChain.")
endif()
elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
# require at least clang 3.4 as provided by Ubuntu 12.04
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
message(FATAL_ERROR "Clang version must be at least 3.4")
endif()
elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
# require at least clang 5.0
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
message(FATAL_ERROR "Apple Clang version must be at least 5.0")
endif()
elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
# require at least Visual Studio 2013
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.40629.0)
message(FATAL_ERROR "Microsoft Visual Studio 2013 Update 5 or newer required (MSVC 18.0.40629.0)")
endif()
else()
message(WARNING "You are using an unsupported compiler! Compilation has only been tested with Clang (Linux or Apple), GCC and MSVC.")
endif()
if(CMAKE_COMPILER_IS_GNUCXX)
mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
else()
set(GCC_VERSION 0)
endif()
set(MITK_CXX_STANDARD 11)
set(CMAKE_CXX_EXTENSIONS 0)
set(CMAKE_CXX_STANDARD ${MITK_CXX_STANDARD})
set(CMAKE_CXX_STANDARD_REQUIRED 1)
# This is necessary to avoid problems with compile feature checks.
# CMAKE_CXX_STANDARD seems to only set the -std=c++11 flag for targets.
# However, compile flag checks also need to be done with -std=c++11.
# The MITK_CXX11_FLAG variable is also used for external projects
# build during the MITK super-build.
mitkFunctionCheckCompilerFlags("-std=c++11" MITK_CXX11_FLAG)
if(NOT MITK_CXX11_FLAG)
# Older gcc compilers use -std=c++0x
mitkFunctionCheckCompilerFlags("-std=c++0x" MITK_CXX11_FLAG)
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 34) # _src_dir_length_max - strlen(ep/src/ITK-build)
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()
#-----------------------------------------------------------------------------
# Additional MITK Options (also shown during superbuild)
#-----------------------------------------------------------------------------
macro(env_option name doc value)
set(_value $ENV{${name}})
if("${_value}" STREQUAL "")
set(_value ${value})
endif()
option(${name} "${doc}" ${_value})
endmacro()
# -----------------------------------------
# General build options
option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON)
option(WITH_COVERAGE "Enable/Disable coverage" OFF)
option(BUILD_TESTING "Test the project" ON)
env_option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF)
env_option(MITK_BUILD_EXAMPLES "Build the MITK Examples" OFF)
option(MITK_ENABLE_PIC_READER "Enable support for reading the DKFZ pic file format." ON)
mark_as_advanced(MITK_BUILD_ALL_APPS
MITK_ENABLE_PIC_READER
)
# -----------------------------------------
# Qt version related variables
-env_option(MITK_USE_QT "Use Qt library" ON)
-env_option(MITK_USE_QT_WEBENGINE "Use Qt WebEngine library" ON)
+env_option(MITK_USE_Qt5 "Use Qt 5 library" ON)
+env_option(MITK_USE_Qt5_WebEngine "Use Qt 5 WebEngine library" ON)
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
set(MITK_QT5_MINIMUM_VERSION 5.6.0)
set(MITK_QT5_COMPONENTS Concurrent OpenGL PrintSupport Script Sql Svg Widgets Xml XmlPatterns UiTools Help LinguistTools)
- if(MITK_USE_QT_WEBENGINE)
+ if(MITK_USE_Qt5_WebEngine)
set(MITK_QT5_COMPONENTS ${MITK_QT5_COMPONENTS} WebEngineWidgets)
endif()
if(APPLE)
set(MITK_QT5_COMPONENTS ${MITK_QT5_COMPONENTS} DBus)
endif()
find_package(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS} REQUIRED)
if(Qt5_DIR)
get_filename_component(_Qt5_DIR "${Qt5_DIR}/../../../" ABSOLUTE)
list(FIND CMAKE_PREFIX_PATH "${_Qt5_DIR}" _result)
if(_result LESS 0)
set(CMAKE_PREFIX_PATH "${_Qt5_DIR};${CMAKE_PREFIX_PATH}" CACHE PATH "" FORCE)
endif()
endif()
-elseif(MITK_USE_QT_WEBENGINE)
- set(MITK_USE_QT_WEBENGINE OFF)
+elseif(MITK_USE_Qt5_WebEngine)
+ set(MITK_USE_Qt5_WebEngine OFF)
endif()
# ------------------------------------------------------------------------
# Register external projects which can be build with the MITK superbuild
# system. Each mitkFunctionAddExternalProject() call registers an external
# project for which a CMakeExternals/<project>.cmake file must exist. The
# call also creates a MITK_USE_<project> variable (appearing in the CMake
# UI if the NO_CACHE option is *not* given).
# -----------------------------------------
# Optional external projects with no
# inter-dependencies
set_property(GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS "")
mitkFunctionAddExternalProject(NAME Poco ON COMPONENTS Foundation Net Util XML Zip)
mitkFunctionAddExternalProject(NAME DCMTK ON DOC "EXPERIMENTAL, superbuild only: Use DCMTK in MITK")
mitkFunctionAddExternalProject(NAME OpenIGTLink OFF)
mitkFunctionAddExternalProject(NAME tinyxml ON ADVANCED)
mitkFunctionAddExternalProject(NAME GDCM ON ADVANCED)
mitkFunctionAddExternalProject(NAME GLUT OFF ADVANCED)
mitkFunctionAddExternalProject(NAME Raptor2 OFF ADVANCED)
mitkFunctionAddExternalProject(NAME Eigen ON ADVANCED DOC "Use the Eigen library")
mitkFunctionAddExternalProject(NAME GLEW ON ADVANCED DOC "Use the GLEW library")
mitkFunctionAddExternalProject(NAME ANN ON ADVANCED DOC "Use Approximate Nearest Neighbor Library")
mitkFunctionAddExternalProject(NAME CppUnit ON ADVANCED DOC "Use CppUnit for unit tests")
mitkFunctionAddExternalProject(NAME PCRE OFF ADVANCED NO_PACKAGE)
mitkFunctionAddExternalProject(NAME ZLIB OFF ADVANCED NO_PACKAGE NO_CACHE)
mitkFunctionAddExternalProject(NAME HDF5 OFF ADVANCED)
# -----------------------------------------
# The following external projects must be
# ordered according to their
# inter-dependencies
mitkFunctionAddExternalProject(NAME SWIG OFF ADVANCED NO_PACKAGE DEPENDS PCRE)
mitkFunctionAddExternalProject(NAME Python OFF NO_PACKAGE DEPENDS SWIG DOC "Use Python wrapping in MITK")
mitkFunctionAddExternalProject(NAME Numpy OFF ADVANCED NO_PACKAGE)
mitkFunctionAddExternalProject(NAME OpenCV OFF)
mitkFunctionAddExternalProject(NAME Vigra OFF DEPENDS HDF5)
# These are "hard" dependencies and always set to ON
mitkFunctionAddExternalProject(NAME ITK ON NO_CACHE)
mitkFunctionAddExternalProject(NAME VTK ON NO_CACHE)
mitkFunctionAddExternalProject(NAME Boost ON NO_CACHE)
mitkFunctionAddExternalProject(NAME SimpleITK OFF DEPENDS ITK GDCM SWIG)
mitkFunctionAddExternalProject(NAME ACVD OFF DOC "Use Approximated Centroidal Voronoi Diagrams")
mitkFunctionAddExternalProject(NAME CTK ON DEPENDS QT DCMTK DOC "Use CTK in MITK")
mitkFunctionAddExternalProject(NAME Rasqal OFF DEPENDS Raptor2 PCRE ADVANCED)
mitkFunctionAddExternalProject(NAME Redland OFF DEPENDS Rasqal DOC "Use the Redland RDF library")
mitkFunctionAddExternalProject(NAME SOFA OFF DEPENDS GLUT Boost DOC "Use Simulation Open Framework Architecture")
mitkFunctionAddExternalProject(NAME VMTK OFF DEPENDS ITK VTK)
mitkFunctionAddExternalProject(NAME MatchPoint OFF ADVANCED DEPENDS ITK DOC "Use the MatchPoint translation image registration library")
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
mitkFunctionAddExternalProject(NAME Qwt ON ADVANCED DEPENDS QT)
endif()
# -----------------------------------------
# Other MITK_USE_* options not related to
# external projects build via the
# MITK superbuild
env_option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
env_option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF)
#-----------------------------------------------------------------------------
# Build configurations
#-----------------------------------------------------------------------------
set(_buildConfigs "Custom")
file(GLOB _buildConfigFiles CMake/BuildConfigurations/*.cmake)
foreach(_buildConfigFile ${_buildConfigFiles})
get_filename_component(_buildConfigFile ${_buildConfigFile} NAME_WE)
list(APPEND _buildConfigs ${_buildConfigFile})
endforeach()
set(MITK_BUILD_CONFIGURATION "Custom" CACHE STRING "Use pre-defined MITK configurations")
set_property(CACHE MITK_BUILD_CONFIGURATION PROPERTY STRINGS ${_buildConfigs})
mitkFunctionEnableBuildConfiguration()
mitkFunctionCreateWhitelistPaths(MITK)
mitkFunctionFindWhitelists(MITK)
# -----------------------------------------
# Custom dependency logic
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")
if(MITK_USE_SOFA)
# SOFA requires boost system library
list(FIND MITK_USE_Boost_LIBRARIES system _result)
if(_result LESS 0)
message("> Adding 'system' to MITK_USE_Boost_LIBRARIES.")
list(APPEND MITK_USE_Boost_LIBRARIES system)
endif()
# SOFA requires boost thread library
list(FIND MITK_USE_Boost_LIBRARIES thread _result)
if(_result LESS 0)
message("> Adding 'thread' to MITK_USE_Boost_LIBRARIES.")
list(APPEND MITK_USE_Boost_LIBRARIES thread)
endif()
# Simulation plugin requires boost chrono library
list(FIND MITK_USE_Boost_LIBRARIES chrono _result)
if(_result LESS 0)
message("> Adding 'chrono' to MITK_USE_Boost_LIBRARIES.")
list(APPEND MITK_USE_Boost_LIBRARIES chrono)
endif()
set(MITK_USE_Boost_LIBRARIES ${MITK_USE_Boost_LIBRARIES} CACHE STRING "" FORCE)
# Allow setting external SOFA plugins directory and SOFA plugins
set(MITK_USE_SOFA_PLUGINS_DIR ${MITK_USE_SOFA_PLUGINS_DIR} CACHE PATH "External SOFA plugins directory" FORCE)
set(MITK_USE_SOFA_PLUGINS ${MITK_USE_SOFA_PLUGINS} CACHE PATH "List of semicolon-separated plugin names" FORCE)
endif()
-# sanity check for supported Qt version. Only >= 5.3 is supported by CTK/PythonQt
-if(MITK_USE_QT AND MITK_USE_Python)
- set(minimum_required_python_qt5_version "5.3.0")
- find_package(Qt5 COMPONENTS Core REQUIRED)
-
- if(${Qt5Core_VERSION_STRING} VERSION_LESS ${minimum_required_python_qt5_version})
- message(WARNING "Can't build MITK Python with Qt version < ${minimum_required_python_qt5_version}. Disabling Python support")
- set(MITK_USE_Python OFF CACHE BOOL "Use python wrapping in MITK" FORCE)
- endif()
-endif()
-
# only windows can't build python in debug mode
if(MITK_USE_Python AND "${CMAKE_BUILD_TYPE}" STREQUAL "Debug" AND WIN32)
message(WARNING "Disabling Python support. Building MITK Python in debug mode on Windowsis not supported!")
set(MITK_USE_Python OFF CACHE BOOL "Use python wrapping in MITK" FORCE)
set(MITK_USE_Numpy OFF CACHE BOOL "Use Numpy" FORCE)
set(MITK_USE_SimpleITK OFF CACHE BOOL "Use SimpleITK" FORCE)
elseif(MITK_USE_Python)
set(MITK_USE_ZLIB ON)
if(NOT MITK_USE_Numpy)
message("> Forcing MITK_USE_Numpy to ON because of MITK_USE_Python")
set(MITK_USE_Numpy ON CACHE BOOL "Use Numpy" FORCE)
endif()
if(NOT MITK_USE_SimpleITK)
message("> Forcing MITK_USE_SimpleITK to ON because of MITK_USE_Python")
set(MITK_USE_SimpleITK ON CACHE BOOL "Use SimpleITK" FORCE)
endif()
option(MITK_USE_SYSTEM_PYTHON "Use the system python runtime" OFF)
if(MITK_USE_SYSTEM_PYTHON)
find_package(PythonLibs REQUIRED)
find_package(PythonInterp REQUIRED)
endif()
elseif(MITK_USE_Python AND "${CMAKE_BUILD_TYPE}" STREQUAL "Debug" AND WIN32)
message(WARNING "Disabling Python support. Building MITK Python in debug mode on Windowsis not supported!")
set(MITK_USE_Python OFF CACHE BOOL "Use python wrapping in MITK" FORCE)
endif()
if(BUILD_TESTING AND NOT MITK_USE_CppUnit)
message("> Forcing MITK_USE_CppUnit to ON because BUILD_TESTING=ON")
set(MITK_USE_CppUnit ON CACHE BOOL "Use CppUnit for unit tests" FORCE)
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()
#-----------------------------------------------------------------------------
# Pixel type multiplexing
#-----------------------------------------------------------------------------
# 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_VECTOR_PIXEL_TYPES)
string(REPLACE "," ";" _integral_types ${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES})
string(REPLACE "," ";" _floating_types ${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES})
foreach(_scalar_type ${_integral_types} ${_floating_types})
set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES
"${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}itk::VariableLengthVector<${_scalar_type}>,")
endforeach()
string(LENGTH "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" _length)
math(EXPR _length "${_length} - 1")
string(SUBSTRING "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" 0 ${_length} MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES)
set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES ${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
CACHE STRING "List of vector pixel types used in AccessByItk and InstantiateAccessFunction macros for itk::VectorImage types" 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)
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")
# Print configuration summary
message("\n\n")
feature_summary(
DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
WHAT ALL)
return()
endif()
#*****************************************************************************
#**************************** END OF SUPERBUILD ****************************
#*****************************************************************************
#-----------------------------------------------------------------------------
# CMake function(s) and macro(s)
#-----------------------------------------------------------------------------
include(WriteBasicConfigVersionFile)
include(CheckCXXSourceCompiles)
include(GenerateExportHeader)
include(mitkFunctionAddCustomModuleTest)
include(mitkFunctionCheckModuleDependencies)
include(mitkFunctionCompileSnippets)
include(mitkFunctionConfigureVisualStudioUserProjectFile)
include(mitkFunctionConvertXPSchema)
include(mitkFunctionCreateBlueBerryApplication)
include(mitkFunctionCreateCommandLineApp)
include(mitkFunctionCreateModule)
include(mitkFunctionCreatePlugin)
include(mitkFunctionCreateProvisioningFile)
include(mitkFunctionGetLibrarySearchPaths)
include(mitkFunctionGetVersion)
include(mitkFunctionGetVersionDescription)
include(mitkFunctionInstallAutoLoadModules)
include(mitkFunctionInstallCTKPlugin)
include(mitkFunctionInstallProvisioningFiles)
include(mitkFunctionInstallThirdPartyCTKPlugins)
include(mitkFunctionOrganizeSources)
include(mitkFunctionTestPlugin)
include(mitkFunctionUseModules)
if( ${MITK_USE_MatchPoint} )
include(mitkFunctionCreateMatchPointDeployedAlgorithm)
endif()
include(mitkMacroConfigureItkPixelTypes)
include(mitkMacroCreateExecutable)
include(mitkMacroCreateModuleTests)
include(mitkMacroGenerateToolsLibrary)
include(mitkMacroGetLinuxDistribution)
include(mitkMacroGetPMDPlatformString)
include(mitkMacroInstall)
include(mitkMacroInstallHelperApp)
include(mitkMacroInstallTargets)
include(mitkMacroMultiplexPicType)
# Deprecated
include(mitkMacroCreateCTKPlugin)
#-----------------------------------------------------------------------------
# Global CMake variables
#-----------------------------------------------------------------------------
# Required and enabled C++11 features for all MITK code.
# These are added as PUBLIC compile features to all MITK modules.
set(MITK_CXX_FEATURES
cxx_auto_type
cxx_decltype
cxx_enum_forward_declarations
cxx_extended_friend_declarations
cxx_extern_templates
cxx_final
cxx_lambdas
cxx_local_type_template_args
cxx_long_long_type
cxx_nullptr
cxx_override
cxx_range_for
cxx_right_angle_brackets
cxx_rvalue_references
cxx_static_assert
cxx_strong_enums
cxx_template_template_parameters
cxx_trailing_return_types
cxx_variadic_macros
)
if(NOT DEFINED CMAKE_DEBUG_POSTFIX)
# We can't do this yet because the CTK Plugin Framework
# cannot cope with a postfix yet.
#set(CMAKE_DEBUG_POSTFIX d)
endif()
#-----------------------------------------------------------------------------
# Output directories.
#-----------------------------------------------------------------------------
set(_default_LIBRARY_output_dir lib)
set(_default_RUNTIME_output_dir bin)
set(_default_ARCHIVE_output_dir lib)
foreach(type LIBRARY RUNTIME ARCHIVE)
# Make sure the directory exists
if(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_CMAKE_${type}_OUTPUT_DIRECTORY)
set(CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
else()
set(CMAKE_${type}_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${_default_${type}_output_dir})
set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY})
endif()
set(CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY} CACHE INTERNAL "Output directory for ${type} files.")
mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
endforeach()
#-----------------------------------------------------------------------------
# Set MITK specific options and variables (NOT available during superbuild)
#-----------------------------------------------------------------------------
# Look for optional Doxygen package
find_package(Doxygen)
option(BLUEBERRY_DEBUG_SMARTPOINTER "Enable code for debugging smart pointers" OFF)
mark_as_advanced(BLUEBERRY_DEBUG_SMARTPOINTER)
# 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()
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()
if(MITK_BUILD_ALL_PLUGINS)
set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
endif()
# Configure pixel types used for ITK image access multiplexing
mitkMacroConfigureItkPixelTypes()
# Configure module naming conventions
set(MITK_MODULE_NAME_REGEX_MATCH "^[A-Z].*$")
set(MITK_MODULE_NAME_REGEX_NOT_MATCH "^[Mm][Ii][Tt][Kk].*$")
set(MITK_MODULE_NAME_PREFIX "Mitk")
set(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME 1)
#-----------------------------------------------------------------------------
# Get MITK version info
#-----------------------------------------------------------------------------
mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK)
# MITK_VERSION
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()
#-----------------------------------------------------------------------------
# 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} Mitk${app_name})
endif()
endforeach()
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 "${COVERAGE_CXX_FLAGS} ${MITK_CXX11_FLAG}")
set(MITK_CXX_FLAGS_DEBUG )
set(MITK_CXX_FLAGS_RELEASE )
set(MITK_EXE_LINKER_FLAGS )
set(MITK_SHARED_LINKER_FLAGS )
find_package(OpenMP)
if (OPENMP_FOUND)
set(MITK_C_FLAGS "${MITK_C_FLAGS} ${OpenMP_C_FLAGS}")
set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
endif()
if(WIN32)
set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -D_WIN32_WINNT=0x0501 -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN -DNOMINMAX")
mitkFunctionCheckCompilerFlags("/wd4005" MITK_CXX_FLAGS) # warning C4005: macro redefinition
mitkFunctionCheckCompilerFlags("/wd4231" MITK_CXX_FLAGS) # warning C4231: nonstandard extension used : 'extern' before template explicit instantiation
# the following line should be removed after fixing bug 17637
mitkFunctionCheckCompilerFlags("/wd4316" MITK_CXX_FLAGS) # warning C4316: object alignment on heap
mitkFunctionCheckCompilerFlags("/wd4180" MITK_CXX_FLAGS) # warning C4180: qualifier applied to function type has no meaning
endif()
if(NOT MSVC_VERSION)
foreach(_flag
-Wall
-Wextra
-Wpointer-arith
-Winvalid-pch
-Wcast-align
-Wwrite-strings
-Wno-error=gnu
-Wno-error=unknown-pragmas
# The strict-overflow warning is generated by ITK template code
-Wno-error=strict-overflow
-Woverloaded-virtual
-Wstrict-null-sentinel
#-Wold-style-cast
#-Wsign-promo
-Wno-array-bounds
-fdiagnostics-show-option
)
mitkFunctionCheckCAndCXXCompilerFlags(${_flag} MITK_C_FLAGS MITK_CXX_FLAGS)
endforeach()
endif()
if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)
mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" MITK_SHARED_LINKER_FLAGS)
mitkFunctionCheckCompilerFlags("-Wl,--as-needed" MITK_SHARED_LINKER_FLAGS)
endif()
if(CMAKE_COMPILER_IS_GNUCXX)
mitkFunctionCheckCAndCXXCompilerFlags("-fstack-protector-all" MITK_C_FLAGS MITK_CXX_FLAGS)
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 "-U_FORTIFY_SOURCES -D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}")
endif()
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
mitkFunctionCheckCompilerFlags("-stdlib=libc++" MITK_CXX_FLAGS) # T20092
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})
if(NOT MITK_USE_SYSTEM_Boost)
set(Boost_NO_SYSTEM_PATHS 1)
endif()
set(Boost_USE_MULTITHREADED 1)
set(Boost_USE_STATIC_LIBS 0)
set(Boost_USE_STATIC_RUNTIME 0)
set(Boost_ADDITIONAL_VERSIONS "1.60" "1.60.0")
# This property is populated at the top half of this file
get_property(MITK_EXTERNAL_PROJECTS GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
foreach(ep ${MITK_EXTERNAL_PROJECTS})
get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE)
get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
if(MITK_USE_${ep} AND _package)
if(_components)
find_package(${_package} COMPONENTS ${_components} REQUIRED CONFIG)
else()
# Prefer config mode first because it finds external
# <proj>Config.cmake files pointed at by <proj>_DIR variables.
# Otherwise, existing Find<proj>.cmake files could fail.
# (e.g. in the case of GLEW and the FindGLEW.cmake file shipped
# with CMake).
find_package(${_package} QUIET CONFIG)
string(TOUPPER "${_package}" _package_uc)
if(NOT (${_package}_FOUND OR ${_package_uc}_FOUND))
find_package(${_package} REQUIRED)
endif()
endif()
endif()
endforeach()
# Ensure that the MITK CMake module path comes first
set(CMAKE_MODULE_PATH
${MITK_CMAKE_DIR}
${CMAKE_MODULE_PATH}
)
if(MITK_USE_Python)
find_package(PythonLibs REQUIRED)
find_package(PythonInterp REQUIRED)
if(MITK_USE_Numpy)
find_package(Numpy REQUIRED)
endif()
endif()
if(MITK_USE_SOFA)
# The SOFAConfig.cmake file does not provide exported targets or
# libraries with absolute paths, hence we need to make the link
# directories globally available until the SOFAConfig.cmake file
# supports a proper mechanism for handling targets.
# The same code is needed in MITKConfig.cmake.
link_directories(${SOFA_LIBRARY_DIRS})
endif()
# Same as SOFA above
link_directories(${Boost_LIBRARY_DIRS})
if(MITK_USE_OpenIGTLink)
# Same as SOFA above
link_directories(${OpenIGTLink_LIBRARY_DIRS})
endif()
if(MITK_USE_SimpleITK)
link_directories(${SimpleITK_LIBRARY_DIRS})
endif()
if(MITK_USE_OpenCL)
find_package(OpenCL REQUIRED)
endif()
# Qt support
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED) # at least Core required
get_target_property(_qmake_exec Qt5::qmake LOCATION)
execute_process(COMMAND ${_qmake_exec} -query QT_INSTALL_BINS
RESULT_VARIABLE _result
OUTPUT_VARIABLE QT_BINARY_DIR
ERROR_VARIABLE _error
)
string(STRIP "${QT_BINARY_DIR}" QT_BINARY_DIR)
if(_result OR NOT EXISTS "${QT_BINARY_DIR}")
message(FATAL_ERROR "Could not determine Qt binary directory: ${_result} ${QT_BINARY_DIR} ${_error}")
endif()
find_program(QT_HELPGENERATOR_EXECUTABLE
NAMES qhelpgenerator qhelpgenerator-qt5 qhelpgenerator5
PATHS ${QT_BINARY_DIR}
NO_DEFAULT_PATH
)
find_program(QT_COLLECTIONGENERATOR_EXECUTABLE
NAMES qcollectiongenerator qcollectiongenerator-qt5 qcollectiongenerator5
PATHS ${QT_BINARY_DIR}
NO_DEFAULT_PATH
)
find_program(QT_ASSISTANT_EXECUTABLE
NAMES assistant assistant-qt5 assistant5
PATHS ${QT_BINARY_DIR}
NO_DEFAULT_PATH
)
find_program(QT_XMLPATTERNS_EXECUTABLE
NAMES xmlpatterns
PATHS ${QT_BINARY_DIR}
NO_DEFAULT_PATH
)
mark_as_advanced(QT_HELPGENERATOR_EXECUTABLE
QT_COLLECTIONGENERATOR_EXECUTABLE
QT_ASSISTANT_EXECUTABLE
QT_XMLPATTERNS_EXECUTABLE
)
if(MITK_USE_BLUEBERRY)
option(BLUEBERRY_USE_QT_HELP "Enable support for integrating plugin documentation into Qt Help" ${DOXYGEN_FOUND})
mark_as_advanced(BLUEBERRY_USE_QT_HELP)
# Sanity checks for in-application BlueBerry plug-in help generation
if(BLUEBERRY_USE_QT_HELP)
set(_force_blueberry_use_qt_help_to_off 0)
if(NOT DOXYGEN_FOUND)
message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because Doxygen was not found.")
set(_force_blueberry_use_qt_help_to_off 1)
endif()
if(DOXYGEN_FOUND AND DOXYGEN_VERSION VERSION_LESS 1.8.7)
message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because Doxygen version 1.8.7 or newer not found.")
set(_force_blueberry_use_qt_help_to_off 1)
endif()
if(NOT QT_HELPGENERATOR_EXECUTABLE)
message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because QT_HELPGENERATOR_EXECUTABLE is empty.")
set(_force_blueberry_use_qt_help_to_off 1)
endif()
- if(NOT MITK_USE_QT_WEBENGINE)
- message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because MITK_USE_QT_WEBENGINE is OFF.")
+ if(NOT MITK_USE_Qt5_WebEngine)
+ message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because MITK_USE_Qt5_WebEngine is OFF.")
set(_force_blueberry_use_qt_help_to_off 1)
endif()
if(NOT QT_XMLPATTERNS_EXECUTABLE)
message("You have enabled Qt Help support, but QT_XMLPATTERNS_EXECUTABLE is empty")
set(_force_blueberry_use_qt_help_to_off 1)
endif()
if(_force_blueberry_use_qt_help_to_off)
set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating plugin documentation into Qt Help" FORCE)
endif()
endif()
if(BLUEBERRY_QT_HELP_REQUIRED AND NOT BLUEBERRY_USE_QT_HELP)
message(FATAL_ERROR "BLUEBERRY_USE_QT_HELP is required to be set to ON")
endif()
endif()
endif()
#-----------------------------------------------------------------------------
# Testing
#-----------------------------------------------------------------------------
if(BUILD_TESTING)
enable_testing()
include(CTest)
mark_as_advanced(TCL_TCLSH DART_ROOT)
option(MITK_ENABLE_RENDERING_TESTING OFF "Enable the MITK rendering tests. Requires x-server in Linux.")
#Rendering testing does not work for Linux nightlies, thus it is disabled per default
#and activated for Mac and Windows.
if(WIN32 OR APPLE)
set(MITK_ENABLE_RENDERING_TESTING ON)
endif()
mark_as_advanced( MITK_ENABLE_RENDERING_TESTING )
# Setup file for setting custom ctest vars
configure_file(
CMake/CTestCustom.cmake.in
${MITK_BINARY_DIR}/CTestCustom.cmake
@ONLY
)
# Initial cache for ProjectTemplate and PluginGenerator tests
configure_file(
CMake/mitkTestInitialCache.txt.in
${MITK_BINARY_DIR}/mitkTestInitialCache.txt
@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()
#-----------------------------------------------------------------------------
# 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}")
#-----------------------------------------------------------------------------
# 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
#-----------------------------------------------------------------------------
add_subdirectory(Utilities)
add_subdirectory(Modules)
if(MITK_USE_BLUEBERRY)
set(BLUEBERRY_XPDOC_OUTPUT_DIR ${MITK_DOXYGEN_OUTPUT_DIR}/html/extension-points/html/)
set(MITK_DEFAULT_SUBPROJECTS MITK-Plugins)
# Plug-in testing (needs some work to be enabled again)
if(BUILD_TESTING)
set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp")
if(TARGET 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()
endif()
set(BLUEBERRY_TEST_APP_ID "org.mitk.qt.coreapplication")
endif()
include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake")
mitkFunctionWhitelistPlugins(MITK MITK_PLUGINS)
set(mitk_plugins_fullpath "")
foreach(mitk_plugin ${MITK_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()
if(MITK_BUILD_EXAMPLES)
include("${CMAKE_CURRENT_SOURCE_DIR}/Examples/Plugins/PluginList.cmake")
set(mitk_example_plugins_fullpath )
foreach(mitk_example_plugin ${MITK_EXAMPLE_PLUGINS})
list(APPEND mitk_example_plugins_fullpath Examples/Plugins/${mitk_example_plugin})
list(APPEND mitk_plugins_fullpath Examples/Plugins/${mitk_example_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})
# extract option_name
string(REPLACE "^^" "\\;" target_info ${mitk_app})
set(target_info_list ${target_info})
list(GET target_info_list 0 directory_name)
list(GET target_info_list 1 option_name)
if(${option_name})
list(APPEND mitk_apps_fullpath "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${directory_name}^^${option_name}")
endif()
endforeach()
if (mitk_plugins_fullpath)
ctkMacroSetupPlugins(${mitk_plugins_fullpath}
BUILD_OPTION_PREFIX MITK_BUILD_
APPS ${mitk_apps_fullpath}
BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
COMPACT_OPTIONS)
endif()
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()
endif()
#-----------------------------------------------------------------------------
# Documentation
#-----------------------------------------------------------------------------
if(DOXYGEN_FOUND)
add_subdirectory(Documentation)
endif()
#-----------------------------------------------------------------------------
# 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)
list(GET target_info_list 2 executable_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 "${executable_name}")
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
#-----------------------------------------------------------------------------
# ---------------- Export targets -----------------
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()
get_target_property(deprecated_module ${target_to_export} MITK_MODULE_DEPRECATED_SINCE)
if(deprecated_module)
set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
set_target_properties(${target_to_export} PROPERTIES MITK_MODULE_DEPRECATED_SINCE \"${deprecated_module}\")")
endif()
endforeach()
# ---------------- External projects -----------------
get_property(MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS_CONFIG GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
set(MITK_CONFIG_EXTERNAL_PROJECTS )
#string(REPLACE "^^" ";" _mitk_external_projects ${MITK_EXTERNAL_PROJECTS})
foreach(ep ${MITK_EXTERNAL_PROJECTS})
get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS}
set(MITK_USE_${ep} ${MITK_USE_${ep}})
set(MITK_${ep}_DIR \"${${ep}_DIR}\")
set(MITK_${ep}_COMPONENTS ${_components})
")
endforeach()
foreach(ep ${MITK_EXTERNAL_PROJECTS})
get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE)
get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
if(_components)
set(_components_arg COMPONENTS \${_components})
else()
set(_components_arg)
endif()
if(_package)
set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS}
if(MITK_USE_${ep})
set(${ep}_DIR \${MITK_${ep}_DIR})
if(MITK_${ep}_COMPONENTS)
mitkMacroFindDependency(${_package} COMPONENTS \${MITK_${ep}_COMPONENTS})
else()
mitkMacroFindDependency(${_package})
endif()
endif()")
endif()
endforeach()
# ---------------- Tools -----------------
configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in
${MITK_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY)
configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in
${MITK_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY)
configure_file(${MITK_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in
${MITK_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY)
# ---------------- Configure files -----------------
configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc)
set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities)
configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
write_basic_config_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
VERSION ${MITK_VERSION_STRING} COMPATIBILITY AnyNewerVersion)
#-----------------------------------------------------------------------------
# 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()
#-----------------------------------------------------------------------------
# Print configuration summary
#-----------------------------------------------------------------------------
message("\n\n")
feature_summary(
DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
WHAT ALL
)
diff --git a/Changelog.txt b/Changelog.txt
deleted file mode 100644
index 1508a8069d..0000000000
--- a/Changelog.txt
+++ /dev/null
@@ -1,113 +0,0 @@
-================================================================================
-==== Medical Imaging Interaction Toolkit (MITK) Changelog ====
-================================================================================
-
-This document should be updated with every release. Major changes
-in the trunk version can be listed right on top to simplify creation
-of release notes for the next release.
-
-======== New stuff only in the SVN trunk ========
-
-- more flexible GUI presentation of renderwindows
-
-======== Changes in release 1.0 (2010-TBD) ========
-
-
-======== Changes in release 0.12.2 (2009-Jun-12) ========
-
-0.12.2 is a bugfix release for 0.12. Issues fixed:
-- The source packages from SourceForge produced CMake configuration
- errors
- - ImageCropper functionality/bundle took too much time for cropping
- - Segmentation tools were deactivated during segmentation
- - Accept All did not work for interpolations
- - The broken "File/Save Project..." menu entry was misleading
-
-======== Changes in release 0.12 (2009-May-08) ========
-
-- Application module "deformable registration"
-- Application module "point set interaction"
-- Paintbrush tool in InteractiveSegmentation
-- localizer widget in MainApp
-- a PointListWidget
-- Volume rendering: MIP support and transfer function presets
-- DataStorage: new events, can be used without DataTree for rendering
-- new histogram and plot widgets based on Qwt
-- Qt4 version: many many impovements, nearly complete MainApp,
- - most functionalities have been ported from Qt3,
- - bundle generator (similar to Qt3 functionality generator)
-- gcc 4.3 compatibility (Ubuntu 8.10, Fedora 9)
-- VTK 5.2 and VTK 5.4 compatibility
-- ITK 3.10 and ITK 3.12 compatibility
-- Windows Vista 64 Bit compatibility
-- new framework MITK-IGT: image guided therapy with MITK, support for tracking devices etc.,
- see http://mitk.org/wiki/IGT for details
-
-======== Changes in release 0.10 (2008-Nov-21) ========
-
-Application changes:
-
-- application modules for image-based rigid and landmarked-based registration
-- optional splash screen
-- new level-window widget behaviour (reacts to 2D mouse movements now)
-- interactive segmentation tool set now easily extensible by plugins
- (see http://docs.mitk.org/nightly/toolextensions.html)
-- Rendering changes:
- - Improved Volume-Rendering: Level-of-Detail Mechanism now works
- for multiple simultaneous 3D RenderWindows and datasets
- - Experimental: user interaction during volume rendering
- (enable by setting flag "LOD abort mechanism" in Global Options)
-
-Under-the-hood changes:
-
-- compatibility with ITK 3.8
-- build system now produces shared libraries (smaller packages, faster linking)
-- support for UnstructuredGrid VTK data
-- reworked rendering mechanism
- - rendering Requests are now directly issued via Qt events instead of
- delayed QTimer calls
- - easier integration of standard VTK-props with mitk
- - Added properties for annotating and clipping datasets in 3D windows
-- several bug fixes, more testing and minor improvements
-- EXPERIMENTAL: Qt4 based application platform based on OSGi and the Eclipse RCP,
- called BlueBerry. If you want to build modular, service oriented applications
- you can use BlueBerry as your application platform. Build the platform by
- setting "BUILD_BLUEBERRY=TRUE" (default is FALSE). You are strongly advised
- to regularly update to the SVN HEAD revision since the platform is
- experimental and is being intensively worked on. Use the mitk mailinglist for
- questions - tutorials and documentation will be provided in the near future.
-- EXPERIMENTAL: compatibility with VTK 5.2
-
-
-
-======== Changes in release 0.8 (2007-Dec-19) ========
-
-- Subversion!
-- functionality for slice-by-slice segmentation including interpolation between segmented slices (QmitkInteractiveSegmentation).
- For more information see http://www.mitk.org/slicebasedsegmentation.html
- - example code for
- - use of zlib for image compression ( mitk::CompressedImageContainer )
- - observe changes in the slicer/MPR ( QmitkSlicesInterpolator )
- - how to safely implement undo
-- MPR planes rotatable
-- improved level-window slider including scale marks, definable presets, selection of image to work on, etc.
-- additional tutorial step describing functionality creation, see http://www.mitk.org/documentation/doxygen/Step9Page.html
-- better build system, esp. those cmake files that need to be changed to add sources are much simpler
-- GUI for basic RAW image import (contribution - Xabier ...)
-- DataStorage -- needs explanation!
-- Progress bar
-- always-available modules for standard views and selection of slices
-- Level-Of-Detail mechanism for volume rendering
-- Textual volume annotation in 2D views
-- Two plane rotation modes: axis rotation and swivel rotation
-- Rendering of multiple overlapping/semi-transparent image-slices in 3D
-- Unified properties for plane reslicing / rendering interpolation modes
-- Improved 3D+t concepts; 3D+t support for Surfaces and PointSets
-- support for "Connexion 3D SpaceNavigator (TM) Mouse": Activate option MITK_USE_TD_MOUSE in cmake to enable interaction with a connexion 3D mouse in 3D widget.
-
-Minor interface changes to lower command complexibility (-classes::method):
-- mitkDataNode::GetInteractor(): now returns a standard C-Pointer, not a SmartPointer.
-- mitkDataNode::GetPropertyList() and ::GetProperty(): now returns a standard C-Pointer, not a SmartPointer.
-- mitkPropertyList::GetProperty(): now returns a standard C-Pointer, not a SmartPointer.
-
-
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildInstructions.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildInstructions.dox
index ff68800dba..3d47cc93d6 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildInstructions.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildInstructions.dox
@@ -1,211 +1,219 @@
/**
\page BuildInstructionsPage Build Instructions
\tableofcontents
\section BuildInstructions_Introduction Introduction
The CMake-based build system of MITK supports a "superbuild" process,
meaning that it will download, configure, and build all required third-party
libraries (except Qt) automatically. These instructions will show you how to use
the MITK superbuild.
\note This page explains explicitly how to build MITK itself. If you want to
create your own project based on MITK, the process described below is completely
automated. Please see \ref HowToNewProject.
For more advanced users, the last sections explains how to inject custom build
libraries into the superbuild process.
\section BuildInstructions_Prerequisites Prerequisites
You need:
-# Git from http://git-scm.com (there are also numerous third-party graphical
clients available). We recomment using Git, but see below for a way how to
get the current source code without using it.
-# <a href="http://www.cmake.org">CMake</a> (version \minimumCMakeVersion or higher)
- -# <a href="http://qt.io">Qt</a> 5.x if you plan to develop Qt-based
+ -# <a href="http://qt.io">Qt</a> 5.6 or 5.7.1 if you plan to develop Qt-based
applications
-# If you are using <b>Mac OS X</b> you need an XCode installation as it
provides the neccessary compilers and SDKs
\section BuildInstructions_Qt A note about Qt
As we do not provide Qt in the MITK superbuild you need to install Qt manually.
Installing Qt dramatically improved since Qt 5, as The Qt Company provides
<a href="http://www.qt.io/download/">sophisticated online installers for all
supported platforms</a>.
-\note Make sure that you select a Qt version which provides the right <b>OpenGL-enabled</b>
-packages for your architecture and compiler.
-
\section BuildInstructions_Get_Source Get a source tree
Since MITK is under active development we recommend to use Git to check out
the latest stable release from the homepage. If you decide to use the most
current nightly release, make sure to get a stable tree: Check the
<a href="http://cdash.mitk.org/index.php?project=MITK">MITK dashboard</a>
before checking out. If the build tree is not clean, you can specify an
older revision for the checkout or get a stable tar ball from
<a href="http://www.mitk.org">www.mitk.org</a>.
-If you don't want to use Git, you may also download a snapshot of the current source code
-(or any other older version) as a <a href="http://mitk.org/git/?p=MITK.git;a=shortlog;h=refs/heads/master">tar.gz package</a>.
-
To clone MITK's current Git repository do:
\code
-git clone https://phabricator.mitk.org/diffusion/MITK/mitk.git MITK
+git clone https://phabricator.mitk.org/source/mitk.git MITK
\endcode
\section BuildInstructions_Build_With_CMake Build MITK with CMake
Create a new directory for the superbuild binary tree, change to it and call CMake:
In the shell (assuming your current directory is the same as the one where you
issued the git clone command):
\code
mkdir MITK-superbuild
cd MITK-superbuild
ccmake ../MITK
\endcode
If you use <b>Windows</b> or prefer to use the CMake GUI, start the CMake GUI and enter the
location of the source tree and binary tree, choose a suitable generator
and configure the project.
CMake will present you a couple of options, these are the most important ones:
- - <tt><b>CMAKE_PREFIX_PATH</b></tt> The path to your Qt installation, e.g., <i>C:/Qt/5.4/msvc2013_64_opengl</i> or <i>/home/user/Qt/5.4/gcc_64</i>
+ - <tt><b>CMAKE_PREFIX_PATH</b></tt> The path to your Qt installation, e.g., <i>C:/Qt/5.6/msvc2013_64</i> or <i>/home/user/Qt/5.6/gcc_64</i>
- <tt><b>MITK_USE_ACVD</b></tt> Build MITK code which depends on ACVD (this
will download and build ACVD)
- <tt><b>MITK_USE_BLUEBERRY</b></tt> Build the BlueBerry application framework
- <tt><b>MITK_USE_Boost_LIBRARIES</b></tt> If you need binary Boost libraries,
specify them here.
- <tt><b>MITK_USE_OpenCV</b></tt> Build MITK code which depends on OpenCV (this
will download and build OpenCV 2.4)
- <tt><b>MITK_USE_Python</b></tt> Enables Python wrapping in MITK. This will also
configure ITK, VTK, and OpenCV (if enabled) to build Python wrappers.
- - <tt><b>MITK_USE_QT</b></tt> Build MITK code which depends on Qt
+ - <tt><b>MITK_USE_Qt5</b></tt> Build MITK code which depends on Qt 5
- <tt><b>MITK_USE_SOFA</b></tt> Build MITK code which depends on SOFA (this will
download and build SOFA)
- - <tt><b>CMAKE_PREFIX_PATH</b></tt> If Qt5 is not found automatically, set
- this variable to the base directory of your Qt5 installation.
If you are satisfied with the configuration of your MITK superbuild, generate
the project files with CMake by pressing "Generate".
<b>Linux</b> and <b>Mac OS X</b> users usually just enter "make" (optionally
supplying the number threads to be used for a parallel build):
\code
make -j6
\endcode
<b>Windows</b> users using Visual Studio can open the generated
<tt>MITK-superbuild.sln</tt> solution file in the <tt>MITK-superbuild</tt>
directory and start the build by building the <tt>BUILD_ALL</tt> project.
\section BuildInstructions_Customize Customize your MITK superbuild
The MITK superbuild configures MITK as well as all external libraries. The
build directories of these libraries, and of MITK itself are located inside
the <tt>MITK-superbuild</tt> directory. For example, the directory layout may
look like:
\code
MITK-superbuild
|- ep "external projects"
|-bin
|-lib
|-include
|-src
|- MITK-build
\endcode
To change the configuration of the MITK build itself, choose the MITK-build directory
as the binary directory in the CMake GUI (not the MITK-superbuild directory).
After generating the project files, build the MITK project by either issuing "make"
in the MITK-build directory (Linux, Mac OS X), or by opening MITK-build/MITK.sln (Windows).
You may also change the configuration of any project configured via the
superbuild process. Make sure to also build the changed project and also the
projects which depend on it.
\section BuildInstructions_Running Running Applications
On Linux, just execute the application you want to run. MITK executables are
located in <tt>MITK-superbuild/MITK-build/bin</tt>
On Windows, the <tt>PATH</tt> environment variable must contain the directories
-containing the third-party libraries. The MITK build system generated <b>Windows batch
-files</b> in the <tt>MITK-build</tt> directory set up a correct environment
-and opens the appropriate Visual Studio solution file. Use these batch files to be able
-to start and debug MITK applications from inside Visual Studio.
+containing the third-party libraries. This is automatically done from Visual Studio.
+For running the applications directly use the generated batch files in the
+<tt>MITK-superbuild/MITK-build/bin</tt>.
\section BuildInstructions_Documentation Documentation
If you have the <a href="http://www.doxygen.org">Doxygen</a> documentation tool
installed, you get a new project (Visual Studio) or "make" target named "doc".
You can build this to generate the HTML documentation of MITK in the
Documentation/Doxygen directory of your MITK-build binary tree or in the
<tt>MITK_DOXYGEN_OUTPUT_DIR</tt> CMake variable (if specified).
\section BuildInstructions_Extending Extend MITK on your own (using the application framework BlueBerry)
Please see \ref NewPluginPage
\section BuildInstructions_As_Toolkit Use MITK in your own project (as a toolkit)
To use MITK in your external project, add the CMake command
<code>find_package(MITK REQUIRED)</code> to your CMakeLists.txt and make use of
the CMake macros <code>mitk_create_module()</code> and
<code>mitk_create_executable()</code> provided by MITK.
-Here is an example CMakeLists.txt (from the Examples/QtAppExample/ directory)
-which allows you to create a Qt-based application using MITK to display an image.
-\include QtAppExample/CMakeLists.txt
+Here is a very basic example CMakeLists.txt including MITK as a project:
+\code
+cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
+
+project(MyProject)
+
+find_package(MITK 2016.11 REQUIRED)
+
+add_executable(MyApp main.cpp)
+
+target_link_libraries(MyApp MitkCore)
+\endcode
+
+with the main.ccp being
+\code
+#include <iostream>
+#include <mitkLogMacros.h>
+
+int main()
+{
+ MITK_INFO << "Hello world!";
+ return 0;
+}
+\endcode
\section BuildInstructions_Advanced_Customization Superbuild customization
You can inject pre-build third-party libraries into the MITK superbuild by
setting certain CMake variables before the first configure step. MITK will
then use these third-party libraries instead of downloading and building them
by itself. Note that you must take care of configuring those libraries with all options
MITK requires.
The variables listed below are provided for injecting third-party libraries.
Their occurrence in the CMake GUI or in ccmake may depend on specific
MITK_USE_* options set to ON. You may also use the variable names below without
the <tt>EXTERNAL_</tt> prefix, for example when providing their values on a
command line call to CMake.
- <tt><b>EXTERNAL_BOOST_ROOT</b></tt> Set this variable to your custom Boost
installation
- <tt><b>EXTERNAL_CTK_DIR</b></tt> Set this variable to your CTK binary tree
(the directory containing the CTKConfig.cmake file)
- <tt><b>EXTERNAL_CableSwig_DIR</b></tt> Set this variable to your CableSwig
binary tree for Python wrapping (the directory containing the
CableSwigConfig.cmake file)
- <tt><b>EXTERNAL_DCMTK_DIR</b></tt> Set this variable to your DCMTK binary
tree (the directory containing the DCMTKConfig.cmake file)
- <tt><b>EXTERNAL_GDCM_DIR</b></tt> Set this variable to your GDCM binary
tree (the directory containing the GDCMConfig.cmake file)
- <tt><b>EXTERNAL_ITK_DIR</b></tt> Set this variable to your ITK binary tree
(the directory containing the ITKConfig.cmake file)
- <tt><b>EXTERNAL_OpenCV_DIR</b></tt> Set this variable to your OpenCV binary
tree (the directory containing the OpenCVConfig.cmake file)
- <tt><b>EXTERNAL_VTK_DIR</b></tt> Set this variable to your VTK binary tree
(the directory containing the VTKConfig.cmake file)
To set CMake options before the first configure step is invoked, supply them
on the command line, i.e.
\code
ccmake -DITK_DIR:PATH=/opt/ITK-release ../MITK
\endcode
-See the following link for more information about how to configure third-party
-libraries:
-\subpage BuildToolkits "How to build ITK, VTK and Qt"
-
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildToolkits.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildToolkits.dox
deleted file mode 100644
index 4a3d172013..0000000000
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildToolkits.dox
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
-\page BuildToolkits Build Toolkits
-
-If you are using the superbuild ITK and VTK will be downloaded and build during the processm by default. Only Qt will have to be build beforehand. You can of course use your own versions of ITK and VTK during the superbuild as described in BuildInstructions_Advanced_Customization .
-
-\section BuildToolkits_ITK ITK
-
-For building ITK please refer to the ITK documentation
-
-<a>http://www.itk.org/Wiki/ITK_Getting_Started</a>
-
-\section BuildToolkits_QT QT
-
-For detailed build instructions please refer to
-
-<a>http://doc.trolltech.com/4.5/installation.html</a>
-
-(If you are using a version other than QT 4.5 please change the link accordingly.)
-
-\section BuildToolkits_VTK VTK
-
-For building VTK please refer to the VTK documentation
-
-<a>http://www.vtk.org/Wiki/VTK_Building_VTK</a>
-
-Please note, that you have to link VTK against your QT by checking:
-
- - \b VTK_USE_GUISUPPORT
- - \b VTK_USE_QVTK
-
-*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
index 897d0e6a1c..13ac5709ed 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
@@ -1,257 +1,257 @@
/**
\page HowToNewProject Creating a new MITK project
\tableofcontents
This page is intended to give a comprehensive guide to setting up your own MITK based
project. It will use the application framework provided by MITK and is probably the
preferred way for most users.
The first part of this document is a tutorial aimed at newcomers to MITK and possibly
%CMake and tries to give as much help as possible on setting up your own project. If
you are looking for more technical information about customizing MITK, the structure
of the superbuild or packaging you might want to read the
\ref HowToNewProjectAdvancedInformation.
If you have set up your MITK project already and want to start developing you could
take a look at \ref TutorialPage.
\section HowToNewProjectGettingStarted Getting Started
To bootstrap your project MITK offers two convenient options:
<ol>
<li> Use the MITK Plugin Generator, a command line tool used to generate a customized
MITK project and/or MITK plug-ins (available for download
<a href="http://www.mitk.org/Download#Plugin_Generator">here</a>).
<li> Use the <a href="https://github.com/MITK/MITK-ProjectTemplate">MITK project template</a>
as an example project.
</ol>
Both options will provide you with a project which contains a "superbuild" mechanism
to automatically download, configure, and build MITK as a dependency of your own project.
The MITK Plugin Generator generates code using the supplied command line arguments,
whereas the MITK project template needs immediate modifications to customize it to
your naming schemes. However, the project template will potentially contain more
code demonstrating features of MITK.
\note Using the MITK Plugin Generator is recommended for beginners.
\section HowToNewProjectPrerequisites Prerequisites
What ever option you choose, a MITK-based project needs essentially the same
prerequisites as MITK itself. Please see \ref BuildInstructions_Prerequisites for
details.
\note If you use one of the two options above you will \b not \b need to build MITK
yourself. This will be done automatically.
\section HowToNewProjectCreatingSourceDir Preparing your source directory
In order to start developing with MITK, you first have to set up the source directory
for your project.
\subsection HowToNewProjectSourceUsingGenerator Using the MITK Plugin Generator
The usage of the Plugin Generator for creating a new project is described in
\ref NewPluginWithProject, please have a look there.
\subsection HowToNewProjectSourceUsingTemplate Using the MITK Project Template
Download the project as a tarball or zipball and extract it to your desired source
directory.
\note This is a \b template \b. You must modify it such that it fits the needs of
your particular project. Especially you should do a global search and replace for
the string "awesome" to rename the template application and plug-in. You may want
to rename some files too.
\section HowToNewProjectGeneratingCMake Generating your binary with CMake
After you have set up your source directory you can proceed to generate your binary
directory using %CMake. Depending on your operating system and preferences you might
want to use "cmake-gui" or "ccmake" (shell). This document assumes you are using
cmake-gui.
<ol>
<li> Start "cmake-gui" and enter your source (e.g. "D:\AwesomeProject") and binary
directory (e.g. "D:\AwesomeProject-superbuild").
<li> Upon first pressing "Configure" you will be prompted to select your generator.
This determines what project files will be generated by %CMake. Set this to the
development tool you are intending to use (e.g. "Visual Studio 2010 64Bit" or
"linux makefiles".
<li> Press "Configure" until no new variables appear and then "Generate". Now all
project files have been generated into your binary directory.
<li> Double-check that the right Qt version is used.
</ol>
Now you are ready to compile your code. Depending on your choice of tool this will
be done differently, we cover two possibilities here.
\subsection HowToNewProjectCompilingLinuxMakefiles Compiling using linux makefiles
<ol>
<li> In the shell, switch to your binary directory.
<li> type "make" and hit enter
</ol>
\subsection HowToNewProjectCompilingVisualStudio Compiling using visual studio
We assume your application is called "AwesomeApp" and your project "AwesomeProject"
and your binary directory is "D:\AwesomeProject-superbuild\". Replace names and
paths accordingly.
<ol>
<li> Close %CMake and open "D:\AwesomeProject-superbuild\AwesomeProject-superbuild.sln".
Your Visual Studio should appear and by pressing F7 you start the compilation.
This will clone the MITK source code, build it, and then start building your own
project.
<li> After the superbuild compilation has finished, close the solution file and start
the batch file "D:\AwesomeProject-superbuild\AwesomeProject-build\StartVS_debug.bat"
(or _release.bat if you built in Release mode) which opens the
"D:\AwesomeProject-superbuild\AweseomeProject-build\AwesomeProject.sln" solution.
<li> Set the "AwesomeApp" project as start-up project (right click > "Set as StartUp
Project") and press "F5" to start your MITK AwesomeApp.
</ol>
\note Just opening AwesomeProject.sln from your explorer by double-cliking won`t
allow you to start or debug your application because the required environment
variables would be missing. Use the supplied batch files or set your PATH variable
accordingly.
\section HowToNewProjectAddingMITKFunctionality I want to use some MITK plugin but
it is not available
Due to the sheer number of MITK plugins not every plugin is activated by default.
To activate a specific plugin (again replace paths as needed):
<ol>
<li> Start "cmake-gui" and set the binary directory to
"D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\", the source will
adjust automatically and you will see new settings appear.
<li> Navigate to the plugin you want to use (e.g. "MITK_BUILD_org.mitk.gui.qt.segmentation")
and tick the checkbox behind it
<li> Press "Configure" until no new variables appear and then "Generate".
<li> Build MITK using your development tool (as in
\ref HowToNewProjectCompilingLinuxMakefiles or \ref HowToNewProjectCompilingVisualStudio
only in the "D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\" directory )
<li> Start "cmake-gui" and set the binary directory to
"D:\AwesomeProject-superbuild\AwesomeProject-build\", the source will adjust
automatically and you will see new settings appear.
<li> Press "Configure" until no new variables appear and then "Generate".
<li> Build your project
<li> Start your application
</ol>
\note If you want to use an application provided by MITK (e.g. MITK Workbench) you
have to tick the appropriate checkbox as well (in this case MITK_BUILD_APP_Workbench)
and build MITK. Do note, that this application will be located in the bin directory
of the "D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\" folder.
\section HowToNewProjectAdvancedInformation Information for advanced users
\subsection HowToNewProjectCustomizingMITK Customizing MITK
The %CMake scripts from the Plugin Generator of the project template provide some
handy options which allow you to customize the MITK build used in your project.
You can either inject an already build MITK to be used by your project or configure
some MITK options directly in your project's superbuild configuration if MITK is
going to be build inside your project.
\subsubsection HowToNewProjectCustomizingMITKInjectMITK Inject a MITK build
By setting the \b EXTERNAL_MITK_DIR \b variable in your project's superbuild
%CMake configuration to a MITK build directory (containing the MITKConfig.cmake)
you can skip the MITK build process.
If MITK is the only external project in your project, you might want to disable
the superbuild of your project completely (set <your-proj-name>_USE_SUPERBUILD
to OFF or edit your CMakeLists.txt file to set it to OFF by default) and set
the \b MITK_DIR \b %CMake variable to your MITK build directory.
\subsubsection HowToNewProjectCustomizingMITKConfigure Configure the MITK superbuild
If MITK is being build inside your project's superbuild process, you can enable
the use of certain third-party libraries inside of MITK. The following variables
control the MITK configuration:
<ul>
<li> \b MITK_USE_BLUEBERRY Enable the use of the BlueBerry application framework
<li> \b MITK_USE_CTK Download, compile, and use CTK in MITK
<li> \b MITK_USE_DCMTK Download, compile, and use DCMTK in MITK
<li> \b MITK_USE_OpenCV Download, compile, and use OpenCV in MITK
<li> \b MITK_USE_Python Download and compile 1CableSwig and enable Python
wrapping in ITK, VTK, OpenCV, and MITK
- <li> \b MITK_USE_QT Use the Qt framework in MITK
+ <li> \b MITK_USE_Qt5 Use the Qt 5 framework in MITK
</ul>
You can also inject already build third-party libraries from inside your project's
superbuild in the MITK superbuild by using any of the following %CMake variables:
<ul>
<li> \b MITK_CTK_DIR Reuse a CTK build directory in MITK.
<li> \b MITK_CableSwig_DIR Reuse a 1CableSwig build directory in MITK.
<li> \b MITK_DCMTK_DIR Reuse a DCMKT build directory in MITK.
<li> \b MITK_GDCM_DIR Reuse a GDCM build directory in MITK.
<li> \b MITK_ITK_DIR Reuse a ITK build directory in MITK.
<li> \b MITK_OpenCV_DIR Reuse a OpenCV build directory in MITK.
<li> \b MITK_VTK_DIR Reuse a VTK build directory in MITK.
</ul>
If the corresponding \b MITK_USE_<proj> \b option is set to on, the MITK
superbuild will use the provided build directory instead of building the
project itself.
You can also control the source code location for MITK in your project's
superbuild configuration by using the following %CMake variables:
<ul>
<li> \b MITK_SOURCE_DIR The path to the MITK source directory. If the value
for this variable is non-empty, the variables below are ignored.
<li> \b MITK_GIT_REPOSITORY The Git repository containing the MITK source code.
<li> \b MITK_GIT_TAG The hash id, tag or branch name used for a checkout
from MITK_GIT_REPOSITORY.
</ul>
\subsubsection HowToNewProjectProjectStructure Project Structure
If you are using the superbuild feature of the generated project (the default),
you might want to familiarise yourself with the layout of your build tree.
The top-level build directory which you specified in %CMake when configuring
your project will contain all the required dependencies.
Suppose we call our project MyProject and the build directory is
"C:\MyProject-superbuild". Then the layout looks something like this:
MyProjectLayout.png The top-level directory contains the source code and the
build directories from the dependencies of your project. In the current case,
the only dependency of MyProject is MITK, which in turn has downloaded and built
its own dependencies (CTK, DCMTK, ITK, etc.). The "real" build tree for your
project is located in MyProject-superbuild/MyProject-build, so point the
%CMake-GUI to this build directory if you want to change the set of enabled
plug-ins for example.
Further, you should open the MyProject.sln solution file (for Visual Studio)
or execute "make" in the MyProject-superbuild/MyProject-build/ directory.
Only for the very first time or if you want to update and newly build the
project's dependencies should you use the project files in the
MyProject-superbuild directory directly.
The same applies for the MyProject-superbuild/MITK-superbuild directory. This
directory contains the MITK superbuild, nested inside your project's superbuild.
If you want to change %CMake options for MITK, use the
MyProject-superbuild/MITK-superbuild/MITK-build build directory.
\imageMacro{HowToNewProject-MyProjectLayout.png,"Layout of MyProject",4.02}
\subsubsection HowToNewProjectPackaging Packaging
The project template and the generated projects by the Plugin Generator come
with full packaging support. You can create deployable packages of your project
for all supported operating systems my building the PACKAGE target. On Linux,
this will create a tarball, on MacOS a .dmg file, and on Windows a zipball and
an NSIS installer (if NSIS is installed and found).
You can read more about deployment \ref DeploymentPage "here".
*/
diff --git a/Documentation/Doxygen/4-API/Pages.dox b/Documentation/Doxygen/4-API/Pages.dox
index 9fe46d1779..d29909ecc2 100644
--- a/Documentation/Doxygen/4-API/Pages.dox
+++ b/Documentation/Doxygen/4-API/Pages.dox
@@ -1,30 +1,33 @@
/**
\defgroup MITKDeprecatedAPI Deprecated
\page deprecatedSince2012_09 Deprecated as of 2012.09
\ingroup MITKDeprecatedAPI
\page deprecatedSince2013_03 Deprecated as of 2013.03
\ingroup MITKDeprecatedAPI
\page deprecatedSince2013_06 Deprecated as of 2013.06
\ingroup MITKDeprecatedAPI
\page deprecatedSince2013_09 Deprecated as of 2013.09
\ingroup MITKDeprecatedAPI
\page deprecatedSince2014_03 Deprecated as of 2014.03
\ingroup MITKDeprecatedAPI
\page deprecatedSince2014_10 Deprecated as of 2014.10
\ingroup MITKDeprecatedAPI
\page deprecatedSince2015_05 Deprecated as of 2015.05
\ingroup MITKDeprecatedAPI
\page deprecatedSince2016_03 Deprecated as of 2016.03
\ingroup MITKDeprecatedAPI
+\page deprecatedSince2016_11 Deprecated as of 2016.11
+\ingroup MITKDeprecatedAPI
+
*/
diff --git a/Examples/QuickRender/README.md b/Examples/QuickRender/README.md
index 7bc30dc8cd..194010ce0b 100644
--- a/Examples/QuickRender/README.md
+++ b/Examples/QuickRender/README.md
@@ -1,52 +1,51 @@
MITK Rendering with QML prototype
=================================================
Summary
------------------
This mini-application "QuickRender" demonstrates how to build a Qt5 QML based
application that integrates MITK render windows.
The `QuickRender` application is located in `Examples/QuickRender.
The following plugins are showcased in a QtQuick environment:
- DataManager
- Level/Window
- Transfer Function
- Image Navigator
Interaction:
- mouse clicks place the cross-hair
- mouse scroll wheel moves to neighboring slice
- holding the right mouse button and moving up/down changes the zoom level
- holding the middle mouse button and mosing pans the scene (only when zoomed in)
Code Changes
------------------
- added class `QmlMitkStdMultiItem`, which replaces the `QmlMitkFourRenderWindowWidget`
- different approach to register QmlMitkRenderWindowItems
- resembles more the QmitkStdMultiWidget (e.g. storing planes...)
- added the respective qml file: MitkStdMultiItem.qml
- update class `QmlMitkRenderWindowItem`:
- removed interaction legacy
- updated interactions
- `QVTKQuickItem` now uses framebuffer objects to render external OpenGL context
Build Instructions
------------------
- - - install Qt 5.5
+ - - install Qt 5.6 or 5.7.1
- build MITK superbuild with
- `MITK_BUILD_EXAMPLES` variable switched to `ON`
- - `MITK_USE_QT` switched to `ON`
- - `DESIRED_QT_VERSION` to `5`
+ - `MITK_USE_Qt5` switched to `ON`
- `MITK_USE_CTK` switched to `ON`
- `MITK_USE_BLUEBERRY` switched to `ON`
Open Issues
------------------
- threading issue, since QtQuick's scene graph rendering will happen on a dedicated render thread
- cleaner, fuller interfaces for the two new widgets
diff --git a/LICENSE.txt b/LICENSE.txt
index 6497b058db..c80d298413 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,36 +1,36 @@
-Copyright (c) 2003-2012 German Cancer Research Center,
+Copyright (c) 2003-2017 German Cancer Research Center,
Division of Medical and Biological Informatics
All rights reserved.
Redistribution and use in source and binary forms, with or
without modification, are permitted provided that the
following conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the German Cancer Research Center,
nor the names of its contributors may be used to endorse
or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in
index f960074a55..35451d3879 100644
--- a/MITKConfig.cmake.in
+++ b/MITKConfig.cmake.in
@@ -1,307 +1,307 @@
if(CMAKE_VERSION VERSION_LESS @MITK_CMAKE_MINIMUM_REQUIRED_VERSION@)
message(FATAL_ERROR "MITK requires at least CMake Version @MITK_CMAKE_MINIMUM_REQUIRED_VERSION@")
endif()
# The MITK version number
set(MITK_VERSION_MAJOR "@MITK_VERSION_MAJOR@")
set(MITK_VERSION_MINOR "@MITK_VERSION_MINOR@")
set(MITK_VERSION_PATCH "@MITK_VERSION_PATCH@")
set(MITK_VERSION_STRING "@MITK_VERSION_STRING@")
#-----------------------------------------------------------------------------
# C++ language standard
#-----------------------------------------------------------------------------
set(MITK_CXX_STANDARD @MITK_CXX_STANDARD@)
#-----------------------------------------------------------------------------
# Include required CMake scripts
#-----------------------------------------------------------------------------
# Update the CMake module path
set(MITK_CMAKE_MODULE_PATH "@MITK_SOURCE_DIR@/CMake")
list(APPEND CMAKE_MODULE_PATH ${MITK_CMAKE_MODULE_PATH})
# Standard CMake macros
include(CMakeParseArguments)
include(FeatureSummary)
include(FindPackageHandleStandardArgs)
include(GenerateExportHeader)
# Include MITK macros
include(MacroParseArguments)
include(mitkFunctionAddCustomModuleTest)
include(mitkFunctionCheckMitkCompatibility)
include(mitkFunctionCheckModuleDependencies)
include(mitkFunctionConfigureVisualStudioUserProjectFile)
include(mitkFunctionCreateBlueBerryApplication)
include(mitkFunctionCreateCommandLineApp)
include(mitkFunctionCreateModule)
include(mitkFunctionCreatePlugin)
include(mitkFunctionCreateProvisioningFile)
include(mitkFunctionCreateWindowsBatchScript)
include(mitkFunctionGetLibrarySearchPaths)
include(mitkFunctionInstallAutoLoadModules)
include(mitkFunctionInstallCTKPlugin)
include(mitkFunctionInstallProvisioningFiles)
include(mitkFunctionInstallThirdPartyCTKPlugins)
include(mitkFunctionOrganizeSources)
include(mitkFunctionUseModules)
include(mitkMacroCreateExecutable)
include(mitkMacroCreateModuleTests)
include(mitkMacroFindDependency)
include(mitkMacroGenerateToolsLibrary)
include(mitkMacroGetPMDPlatformString)
include(mitkMacroInstall)
include(mitkMacroInstallHelperApp)
include(mitkMacroInstallTargets)
include(mitkMacroMultiplexPicType)
#-----------------------------------------------------------------------------
# MITK flags and directories
#-----------------------------------------------------------------------------
# MITK compiler flags
set(MITK_C_FLAGS "@MITK_C_FLAGS@")
set(MTTK_C_FLAGS_DEBUG "@MITK_C_FLAGS_DEBUG@")
set(MITK_C_FLAGS_RELEASE "@MITK_C_FLAGS_RELEASE@")
set(MITK_CXX_FLAGS "@MITK_CXX_FLAGS@")
set(MTTK_CXX_FLAGS_DEBUG "@MITK_CXX_FLAGS_DEBUG@")
set(MITK_CXX_FLAGS_RELEASE "@MITK_CXX_FLAGS_RELEASE@")
# MITK linker flags
set(MITK_EXE_LINKER_FLAGS "@MITK_EXE_LINKER_FLAGS@")
set(MITK_SHARED_LINKER_FLAGS "@MITK_SHARED_LINKER_FLAGS@")
set(MITK_MODULE_LINKER_FLAGS "@MITK_MODULE_LINKER_FLAGS@")
# MITK specific directories
set(MITK_SOURCE_DIR "@MITK_SOURCE_DIR@")
set(MITK_BINARY_DIR "@MITK_BINARY_DIR@")
set(MITK_CMAKE_DIR "@MITK_CMAKE_DIR@")
# MITK output directories
set(MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY "@MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY@")
set(MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY "@MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY@")
set(MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY "@MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
#-----------------------------------------------------------------------------
# Miscellaneous variables
#-----------------------------------------------------------------------------
# Internal version numbers, used for approximate compatibility checks
# of a MITK development version (non-release).
set(MITK_VERSION_PLUGIN_SYSTEM 2) # dropped legacy BlueBerry plug-in CMake support
set(MITK_DATA_DIR "@MITK_DATA_DIR@")
set(UTILITIES_DIR "@UTILITIES_DIR@")
set(REGISTER_QFUNCTIONALITY_CPP_IN "@REGISTER_QFUNCTIONALITY_CPP_IN@")
set(MITK_DOXYGEN_TAGFILE_NAME "@MITK_DOXYGEN_TAGFILE_NAME@")
set(MITK_LEGACY_EXPORT_MACRO_NAME 1)
set(DCMTK_CMAKE_DEBUG_POSTFIX @DCMTK_CMAKE_DEBUG_POSTFIX@)
# Get the canonical name of the directory to avoid potential case mismatch,
# e.g. in the drive letter on Windows.
get_filename_component(CMAKE_CURRENT_LIST_DIR_REALPATH ${CMAKE_CURRENT_LIST_DIR} REALPATH)
if(CMAKE_CURRENT_LIST_DIR_REALPATH STREQUAL MITK_BINARY_DIR)
set(MITK_EXTERNAL_PROJECT_PREFIX @MITK_EXTERNAL_PROJECT_PREFIX@)
endif()
set(MITK_MODULES_PACKAGE_DEPENDS_DIR "@MITK_MODULES_PACKAGE_DEPENDS_DIR@")
if(MODULES_PACKAGE_DEPENDS_DIRS)
list(APPEND MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
list(REMOVE_DUPLICATES MODULES_PACKAGE_DEPENDS_DIRS)
else()
set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
endif()
#-----------------------------------------------------------------------------
# External dependencies
#-----------------------------------------------------------------------------
list(APPEND CMAKE_PREFIX_PATH "@MITK_EXTERNAL_PROJECT_PREFIX@")
# -----------------------------------------
# Qt variables and dependencies
-set(MITK_USE_QT @MITK_USE_QT@)
-set(MITK_USE_QT_WEBENGINE @MITK_USE_QT_WEBENGINE@)
+set(MITK_USE_Qt5 @MITK_USE_Qt5@)
+set(MITK_USE_Qt5_WebEngine @MITK_USE_Qt5_WebEngine@)
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
set(MITK_QT5_MINIMUM_VERSION @MITK_QT5_MINIMUM_VERSION@)
set(MITK_QT5_COMPONENTS @MITK_QT5_COMPONENTS@)
mitkMacroFindDependency(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS})
endif()
# -----------------------------------------
# Special Python variables
set(MITK_USE_Python @MITK_USE_Python@)
set(MITK_USE_SYSTEM_PYTHON @MITK_USE_SYSTEM_PYTHON@)
if(MITK_USE_Python)
set(PYTHON_EXECUTABLE "@PYTHON_EXECUTABLE@" CACHE FILEPATH "")
set(PYTHON_INCLUDE_DIR "@PYTHON_INCLUDE_DIR@" CACHE PATH "")
set(PYTHON_LIBRARY "@PYTHON_LIBRARY@" CACHE FILEPATH "")
set(PYTHON_INCLUDE_DIR2 "@PYTHON_INCLUDE_DIR2@" CACHE PATH "")
mitkMacroFindDependency(PythonLibs)
mitkMacroFindDependency(PythonInterp)
endif()
# -----------------------------------------
# Special Boost variables
set(MITK_USE_Boost_LIBRARIES @MITK_USE_Boost_LIBRARIES@)
set(MITK_USE_SYSTEM_Boost @MITK_USE_SYSTEM_Boost@)
set(BOOST_ROOT "@BOOST_ROOT@" CACHE PATH "")
set(BOOST_LIBRARYDIR "@BOOST_LIBRARYDIR@" CACHE PATH "")
set(Boost_ADDITIONAL_VERSIONS "1.60" "1.60.0")
# -----------------------------------------
# External dependencies from the superbuild
# or injected from somewhere else via
# <project>_DIR variables.
@MITK_CONFIG_EXTERNAL_PROJECTS@
# Ensure the MITK module path comes first
set(CMAKE_MODULE_PATH ${MITK_CMAKE_MODULE_PATH} ${CMAKE_MODULE_PATH})
# -----------------------------------------
# Special handling for SOFA
if(MITK_USE_SOFA)
# The SOFAConfig.cmake file does not provide exported targets or
# libraries with absolute paths, hence we need to make the link
# directories globally available until the SOFAConfig.cmake file
# supports a proper mechanism for handling targets.
# find_package(SOFA PATHS ${SOFA_DIR} CONFIG REQUIRED)
link_directories(${SOFA_LIBRARY_DIRS})
endif()
# -----------------------------------------
# Special handling for VMTK
if(MITK_USE_VMTK)
# Same as SOFA above
link_directories(${VMTK_LIBRARY_DIRS})
endif()
# -----------------------------------------
# Special handling for Boost
if(MITK_USE_Boost)
# Same as SOFA above
link_directories(${Boost_LIBRARY_DIRS})
endif()
# -----------------------------------------
# Special handling for OpenIGTLink
if(MITK_USE_OpenIGTLink)
# Same as SOFA above
link_directories(${OpenIGTLink_LIBRARY_DIRS})
endif()
# -----------------------------------------
# Internal project dependencies
set(CppMicroServices_DIR "@CppMicroServices_DIR@")
mitkMacroFindDependency(CppMicroServices)
set(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@)
if(MITK_USE_BLUEBERRY)
set(MITK_PLUGIN_USE_FILE "@MITK_PLUGIN_USE_FILE@")
if(MITK_PLUGIN_USE_FILE)
if(EXISTS "${MITK_PLUGIN_USE_FILE}")
include("${MITK_PLUGIN_USE_FILE}")
endif()
endif()
set(MITK_PLUGIN_PROVISIONING_FILE "@MITK_EXTAPP_PROVISIONING_FILE@")
set(MITK_PROVISIONING_FILES
"${BLUEBERRY_PLUGIN_PROVISIONING_FILE}"
"${MITK_PLUGIN_PROVISIONING_FILE}")
endif()
set(BLUEBERRY_USE_QT_HELP @BLUEBERRY_USE_QT_HELP@)
if(BLUEBERRY_USE_QT_HELP AND DOXYGEN_VERSION VERSION_LESS "1.8.7")
message("Setting BLUEBERRY_USE_QT_HELP to OFF because Doxygen version 1.8.7 or newer not found.")
set(BLUEBERRY_USE_QT_HELP OFF)
endif()
set(BLUEBERRY_QTPLUGIN_PATH "@BLUEBERRY_QTPLUGIN_PATH@")
set(QT_HELPGENERATOR_EXECUTABLE "@QT_HELPGENERATOR_EXECUTABLE@")
set(QT_COLLECTIONGENERATOR_EXECUTABLE "@QT_COLLECTIONGENERATOR_EXECUTABLE@")
set(QT_ASSISTANT_EXECUTABLE "@QT_ASSISTANT_EXECUTABLE@")
set(QT_XMLPATTERNS_EXECUTABLE "@QT_XMLPATTERNS_EXECUTABLE@")
#-----------------------------------------------------------------------------
# MITK sub-project variables
#-----------------------------------------------------------------------------
# External SDK directories
set(MITK_PMD_SDK_DIR @MITK_PMD_SDK_DIR@)
# MITK ToF use variables
set(MITK_TOF_PMDCAMCUBE_AVAILABLE @MITK_USE_TOF_PMDCAMCUBE@)
if(MITK_TOF_PMDCAMCUBE_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
option(MITK_USE_TOF_PMDCAMCUBE "Enable support for PMD Cam Cube" @MITK_USE_TOF_PMDCAMCUBE@)
mark_as_advanced(MITK_USE_TOF_PMDCAMCUBE)
endif()
set(MITK_TOF_PMDCAMBOARD_AVAILABLE @MITK_USE_TOF_PMDCAMBOARD@)
if(MITK_TOF_PMDCAMBOARD_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
option(MITK_USE_TOF_PMDCAMBOARD "Enable support for PMD Cam Board" @MITK_USE_TOF_PMDCAMBOARD@)
mark_as_advanced(MITK_USE_TOF_PMDCAMBOARD)
endif()
set(MITK_TOF_PMDO3_AVAILABLE @MITK_USE_TOF_PMDO3@)
if(MITK_TOF_PMDO3_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
option(MITK_USE_TOF_PMDO3 "Enable support for PMD =3" @MITK_USE_TOF_PMDO3@)
mark_as_advanced(MITK_USE_TOF_PMDO3)
endif()
set(MITK_TOF_KINECT_AVAILABLE @MITK_USE_TOF_KINECT@)
if(MITK_TOF_KINECT_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
option(MITK_USE_TOF_KINECT "Enable support for Kinect" @MITK_USE_TOF_KINECT@)
mark_as_advanced(MITK_USE_TOF_KINECT)
endif()
set(MITK_TOF_MESASR4000_AVAILABLE @MITK_USE_TOF_MESASR4000@)
if(MITK_TOF_MESASR4000_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
option(MITK_USE_TOF_MESASR4000 "Enable support for MESA SR4000" @MITK_USE_TOF_MESASR4000@)
mark_as_advanced(MITK_USE_TOF_MESASR4000)
endif()
if(MITK_USE_IGT)
#include("${MITK_DIR}/mitkIGTConfig.cmake")
endif()
#-----------------------------------------------------------------------------
# Import MITK targets and set custom properties
#-----------------------------------------------------------------------------
if(NOT MITK_EXPORTS_FILE_INCLUDED)
if(EXISTS "@MITK_EXPORTS_FILE@")
set(MITK_EXPORTS_FILE_INCLUDED 1)
include("@MITK_EXPORTS_FILE@")
endif()
endif()
# Set properties on exported targets
@MITK_EXPORTED_TARGET_PROPERTIES@
#-----------------------------------------------------------------------------
# Install rules
#-----------------------------------------------------------------------------
# Install rules for ToF libraries loaded at runtime
if(EXISTS "@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake")
include("@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake")
endif()
diff --git a/Modules/BoundingShape/include/mitkBoundingShapeVtkMapper2D.h b/Modules/BoundingShape/include/mitkBoundingShapeVtkMapper2D.h
index c0df5fffa0..837f0d961c 100644
--- a/Modules/BoundingShape/include/mitkBoundingShapeVtkMapper2D.h
+++ b/Modules/BoundingShape/include/mitkBoundingShapeVtkMapper2D.h
@@ -1,85 +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 mitkBoundingShapeVtkMapper2D_h
#define mitkBoundingShapeVtkMapper2D_h
#include <mitkVtkMapper.h>
#include <MitkBoundingShapeExports.h>
#include <vtkActor2D.h>
#include <vtkCutter.h>
#include <vtkPlane.h>
#include <vtkPolyDataMapper2D.h>
#include <vtkPropAssembly.h>
#include <vtkSmartPointer.h>
#include <vtkSphereSource.h>
namespace mitk
{
class MITKBOUNDINGSHAPE_EXPORT BoundingShapeVtkMapper2D final : public VtkMapper
{
class LocalStorage : public Mapper::BaseLocalStorage
{
public:
LocalStorage();
~LocalStorage();
bool IsUpdateRequired(mitk::BaseRenderer *renderer, mitk::Mapper *mapper, mitk::DataNode *dataNode);
vtkSmartPointer<vtkActor> m_Actor;
vtkSmartPointer<vtkActor2D> m_HandleActor;
vtkSmartPointer<vtkActor2D> m_SelectedHandleActor;
vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
vtkSmartPointer<vtkPolyDataMapper2D> m_HandleMapper;
vtkSmartPointer<vtkPolyDataMapper2D> m_SelectedHandleMapper;
vtkSmartPointer<vtkCutter> m_Cutter;
vtkSmartPointer<vtkPlane> m_CuttingPlane;
+ unsigned int m_LastSliceNumber;
std::vector<vtkSmartPointer<vtkSphereSource>> m_Handles;
vtkSmartPointer<vtkPropAssembly> m_PropAssembly;
double m_ZoomFactor;
private:
LocalStorage(const LocalStorage &);
LocalStorage &operator=(const LocalStorage &);
};
public:
static void SetDefaultProperties(DataNode *node, BaseRenderer *renderer = nullptr, bool overwrite = false);
mitkClassMacro(BoundingShapeVtkMapper2D, VtkMapper);
itkFactorylessNewMacro(Self) itkCloneMacro(Self)
void ApplyColorAndOpacityProperties(BaseRenderer *, vtkActor *) override;
vtkProp *GetVtkProp(BaseRenderer *renderer) override;
private:
BoundingShapeVtkMapper2D();
~BoundingShapeVtkMapper2D();
BoundingShapeVtkMapper2D(const Self &);
Self &operator=(const Self &);
void GenerateDataForRenderer(BaseRenderer *renderer) override;
void Update(mitk::BaseRenderer *renderer) override;
class Impl;
Impl *m_Impl;
};
}
#endif
diff --git a/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeCropper.cpp b/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeCropper.cpp
index 852efff158..b69e42537e 100644
--- a/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeCropper.cpp
+++ b/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeCropper.cpp
@@ -1,317 +1,337 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBoundingShapeCropper.h"
#include "mitkGeometry3D.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkImageToItk.h"
#include "mitkStatusBar.h"
#include "mitkTimeHelper.h"
#include <math.h>
#include "vtkMatrix4x4.h"
#include "vtkSmartPointer.h"
#include "vtkTransform.h"
#include "itkImageRegionIteratorWithIndex.h"
#include <itkImageIOBase.h>
#include <itkImageRegionConstIterator.h>
#include <itkRGBAPixel.h>
#include <itkRGBPixel.h>
namespace mitk
{
BoundingShapeCropper::BoundingShapeCropper()
: m_Geometry(nullptr),
m_OutsideValue(0),
m_UseCropTimeStepOnly(false),
m_CurrentTimeStep(0),
m_UseWholeInputRegion(false),
m_InputTimeSelector(mitk::ImageTimeSelector::New()),
m_OutputTimeSelector(mitk::ImageTimeSelector::New())
{
this->SetNumberOfIndexedInputs(2);
this->SetNumberOfRequiredInputs(2);
}
BoundingShapeCropper::~BoundingShapeCropper() {}
+
template <typename TPixel, unsigned int VImageDimension>
void BoundingShapeCropper::CutImage(itk::Image<TPixel, VImageDimension> *inputItkImage, int timeStep)
{
MITK_INFO << "Scalar Pixeltype" << std::endl;
typedef TPixel TOutputPixel;
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;
TOutputPixel outsideValue = this->GetOutsideValue();
// currently 0 if not set in advance
// TODO: change default value to itk::NumericTraits<TOutputPixel>::min();
if (this->m_Geometry.IsNull())
return;
if (inputItkImage == nullptr)
{
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;
}
// first convert the index
typename ItkRegionType::IndexType::IndexValueType tmpIndex[3];
itk2vtk(this->m_InputRequestedRegion.GetIndex(), tmpIndex);
typename ItkRegionType::IndexType index;
index.SetIndex(tmpIndex);
// then convert the size
typename ItkRegionType::SizeType::SizeValueType tmpSize[3];
itk2vtk(this->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);
// Get access to the MITK output image via an ITK image
typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk =
mitk::ImageToItk<ItkOutputImageType>::New();
outputimagetoitk->SetInput(this->m_OutputTimeSelector->GetOutput());
outputimagetoitk->Update();
typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
// create the iterators
ItkInputImageIteratorType inputIt(inputItkImage, inputRegionOfInterest);
ItkOutputImageIteratorType outputIt(outputItkImage, outputItkImage->GetLargestPossibleRegion());
// Cut the boundingbox out of the image by iterating through all images
// TODO: use more efficient method by using the contour instead off all single pixels
mitk::Point3D p;
mitk::BaseGeometry *inputGeometry = this->GetInput()->GetGeometry(timeStep);
// calculates translation based on offset+extent not on the transformation matrix
// NOTE: center of the box is
vtkSmartPointer<vtkMatrix4x4> imageTransform = this->m_Geometry->GetGeometry()->GetVtkTransform()->GetMatrix();
Point3D center = this->m_Geometry->GetGeometry()->GetCenter();
auto translation = vtkSmartPointer<vtkTransform>::New();
translation->Translate(center[0] - imageTransform->GetElement(0, 3),
center[1] - imageTransform->GetElement(1, 3),
center[2] - imageTransform->GetElement(2, 3));
auto transform = vtkSmartPointer<vtkTransform>::New();
transform->SetMatrix(imageTransform);
transform->PostMultiply();
transform->Concatenate(translation);
transform->Update();
mitk::Vector3D extent;
for (unsigned int i = 0; i < 3; ++i)
extent[i] = (this->m_Geometry->GetGeometry()->GetExtent(i));
for (inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt)
{
vtk2itk(inputIt.GetIndex(), p);
inputGeometry->IndexToWorld(p, p);
ScalarType p2[4];
p2[0] = p[0];
p2[1] = p[1];
p2[2] = p[2];
p2[3] = 1;
// transform point from world to object coordinates
transform->GetInverse()->TransformPoint(p2, p2);
// check if the world point is within bounds
bool isInside = (p2[0] >= (-extent[0] / 2.0)) && (p2[0] <= (extent[0] / 2.0)) && (p2[1] >= (-extent[1] / 2.0)) &&
(p2[1] <= (extent[1] / 2.0)) && (p2[2] >= (-extent[2] / 2.0)) && (p2[2] <= (extent[2] / 2.0));
if ((!this->m_UseCropTimeStepOnly && isInside) ||
- (this->m_UseCropTimeStepOnly && timeStep != this->m_CurrentTimeStep) ||
(this->m_UseCropTimeStepOnly && timeStep == this->m_CurrentTimeStep && isInside))
{
outputIt.Set((TOutputPixel)inputIt.Value());
}
else
{
outputIt.Set(outsideValue);
}
}
}
void BoundingShapeCropper::SetGeometry(const mitk::GeometryData *geometry)
{
m_Geometry = const_cast<mitk::GeometryData *>(geometry);
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(1, const_cast<mitk::GeometryData *>(geometry));
}
// const mitk::GeometryData* BoundingShapeCropper::GetGeometryData() const
//{
// return m_Geometry.GetPointer();
//}
const mitk::PixelType BoundingShapeCropper::GetOutputPixelType() { return this->GetInput()->GetPixelType(); }
void BoundingShapeCropper::GenerateInputRequestedRegion()
{
mitk::Image *output = this->GetOutput();
if ((output->IsInitialized() == false) || (m_Geometry.IsNull()) ||
(m_Geometry->GetTimeGeometry()->CountTimeSteps() == 0))
return;
GenerateTimeInInputRegion(output, const_cast<mitk::Image *>(this->GetInput()));
}
void BoundingShapeCropper::GenerateOutputInformation()
{
// Set Cropping region
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())
{
mitkThrow() << "Input is not a mitk::Image";
}
itkDebugMacro(<< "GenerateOutputInformation()");
unsigned int dimension = input->GetDimension();
if (dimension < 3)
{
mitkThrow() << "ImageCropper cannot handle 1D or 2D Objects.";
}
if ((m_Geometry.IsNull()) || (m_Geometry->GetTimeGeometry()->CountTimeSteps() == 0))
return;
mitk::BaseGeometry *bsGeometry = m_Geometry->GetGeometry();
mitk::BaseGeometry *inputImageGeometry = input->GetSlicedGeometry();
// calculate bounding box
mitk::BoundingBox::Pointer bsBoxRelativeToImage =
bsGeometry->CalculateBoundingBoxRelativeToTransform(inputImageGeometry->GetIndexToWorldTransform());
// pre-initialize input-requested-region to largest-possible-region
m_InputRequestedRegion = input->GetLargestPossibleRegion();
// build region out of bounding-box of index and size of the bounding box
mitk::SlicedData::IndexType index = m_InputRequestedRegion.GetIndex(); // init times and channels
mitk::BoundingBox::PointType min = bsBoxRelativeToImage->GetMinimum();
mitk::SlicedData::SizeType size = m_InputRequestedRegion.GetSize(); // init times and channels
mitk::BoundingBox::PointType max = bsBoxRelativeToImage->GetMaximum();
for (unsigned int i = 0; i < dimension; i++)
{
index[i] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[i]));
size[i] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[i]) - index[i]);
}
mitk::SlicedData::RegionType bsRegion(index, size);
if (m_UseWholeInputRegion == false)
{
// crop input-requested-region with region of bounding-object
if (m_InputRequestedRegion.Crop(bsRegion) == false)
{
// crop not possible => do nothing: set time size to 0.
size.Fill(0);
m_InputRequestedRegion.SetSize(size);
bsRegion.SetSize(size);
mitkThrow() << "No overlap of the image and the cropping object.";
}
}
// initialize output image
auto dimensions = new unsigned int[dimension];
if (dimension > 3 && !this->GetUseCropTimeStepOnly())
memcpy(dimensions + 3, input->GetDimensions() + 3, (dimension - 3) * sizeof(unsigned int));
else
dimension = 3; // set timeStep to zero if GetUseCropTimeStepOnly is true
itk2vtk(m_InputRequestedRegion.GetSize(), dimensions);
output->Initialize(mitk::PixelType(GetOutputPixelType()), dimension, dimensions);
delete[] dimensions;
// Apply transform of the input image to the new generated output image
mitk::BoundingShapeCropper::RegionType outputRegion = output->GetRequestedRegion();
m_TimeOfHeaderInitialization.Modified();
}
void BoundingShapeCropper::ComputeData(mitk::Image *image, int boTimeStep)
{
// examine dimension and pixeltype
if ((image == nullptr) || (image->GetDimension() > 4) || (image->GetDimension() <= 2))
{
MITK_ERROR << "Filter cannot handle dimensions less than 2 and greater than 4" << std::endl;
itkExceptionMacro("Filter cannot handle dimensions less than 2 and greater than 4");
return;
}
AccessByItk_1(image, CutImage, boTimeStep);
}
void BoundingShapeCropper::GenerateData()
{
MITK_INFO << "Generate Data" << std::endl;
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if (input.IsNull())
return;
if ((output->IsInitialized() == false) || (m_Geometry.IsNull()) ||
(m_Geometry->GetTimeGeometry()->CountTimeSteps() == 0))
return;
m_InputTimeSelector->SetInput(input);
m_OutputTimeSelector->SetInput(this->GetOutput());
mitk::BoundingShapeCropper::RegionType outputRegion = output->GetRequestedRegion();
mitk::BaseGeometry *inputImageGeometry = input->GetSlicedGeometry();
// iterate over all time steps and perform cropping or masking on all or a specific timestep (perviously specified
// by UseCurrentTimeStepOnly)
int tstart = outputRegion.GetIndex(3);
int tmax = tstart + outputRegion.GetSize(3);
- int t;
- for (t = tstart; t < tmax; ++t)
+
+ if (this->m_UseCropTimeStepOnly)
{
- mitk::SlicedGeometry3D *slicedGeometry = output->GetSlicedGeometry(t);
+ mitk::SlicedGeometry3D *slicedGeometry = output->GetSlicedGeometry(tstart);
auto indexToWorldTransform = AffineTransform3D::New();
- indexToWorldTransform->SetParameters(input->GetSlicedGeometry(t)->GetIndexToWorldTransform()->GetParameters());
+ indexToWorldTransform->SetParameters(input->GetSlicedGeometry(tstart)->GetIndexToWorldTransform()->GetParameters());
slicedGeometry->SetIndexToWorldTransform(indexToWorldTransform);
-
const mitk::SlicedData::IndexType &start = m_InputRequestedRegion.GetIndex();
mitk::Point3D origin;
vtk2itk(start, origin);
inputImageGeometry->IndexToWorld(origin, origin);
slicedGeometry->SetOrigin(origin);
- m_InputTimeSelector->SetTimeNr(t);
+ m_InputTimeSelector->SetTimeNr(m_CurrentTimeStep);
m_InputTimeSelector->UpdateLargestPossibleRegion();
- m_OutputTimeSelector->SetTimeNr(t);
+ m_OutputTimeSelector->SetTimeNr(tstart);
m_OutputTimeSelector->UpdateLargestPossibleRegion();
- ComputeData(m_InputTimeSelector->GetOutput(), t);
+ ComputeData(m_InputTimeSelector->GetOutput(), m_CurrentTimeStep);
+ }
+ else
+ {
+ int t;
+ for (t = tstart; t < tmax; ++t)
+ {
+ mitk::SlicedGeometry3D *slicedGeometry = output->GetSlicedGeometry(t);
+ auto indexToWorldTransform = AffineTransform3D::New();
+ indexToWorldTransform->SetParameters(input->GetSlicedGeometry(t)->GetIndexToWorldTransform()->GetParameters());
+ slicedGeometry->SetIndexToWorldTransform(indexToWorldTransform);
+ const mitk::SlicedData::IndexType &start = m_InputRequestedRegion.GetIndex();
+ mitk::Point3D origin;
+ vtk2itk(start, origin);
+ inputImageGeometry->IndexToWorld(origin, origin);
+ slicedGeometry->SetOrigin(origin);
+ m_InputTimeSelector->SetTimeNr(t);
+ m_InputTimeSelector->UpdateLargestPossibleRegion();
+ m_OutputTimeSelector->SetTimeNr(t);
+ m_OutputTimeSelector->UpdateLargestPossibleRegion();
+ ComputeData(m_InputTimeSelector->GetOutput(), t);
+ }
}
m_InputTimeSelector->SetInput(nullptr);
m_OutputTimeSelector->SetInput(nullptr);
m_TimeOfHeaderInitialization.Modified();
}
} // of namespace mitk
diff --git a/Modules/BoundingShape/src/Rendering/mitkBoundingShapeVtkMapper2D.cpp b/Modules/BoundingShape/src/Rendering/mitkBoundingShapeVtkMapper2D.cpp
index be47fd4ced..638fd0c9ba 100644
--- a/Modules/BoundingShape/src/Rendering/mitkBoundingShapeVtkMapper2D.cpp
+++ b/Modules/BoundingShape/src/Rendering/mitkBoundingShapeVtkMapper2D.cpp
@@ -1,462 +1,468 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for detailocalStorage.
===================================================================*/
#include "../DataManagement/mitkBoundingShapeUtil.h"
#include <mitkBaseProperty.h>
#include <mitkBoundingShapeVtkMapper2D.h>
#include <vtkActor2D.h>
#include <vtkAppendPolyData.h>
#include <vtkCoordinate.h>
#include <vtkCubeSource.h>
#include <vtkMath.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper2D.h>
#include <vtkProperty2D.h>
#include <vtkSphereSource.h>
#include <vtkStripper.h>
#include <vtkTransformFilter.h>
#include <vtkTransformPolyDataFilter.h>
static vtkSmartPointer<vtkSphereSource> CreateHandle()
{
auto handle = vtkSmartPointer<vtkSphereSource>::New();
handle->SetPhiResolution(8);
handle->SetThetaResolution(16);
return handle;
}
namespace mitk
{
class BoundingShapeVtkMapper2D::Impl
{
public:
Impl()
{
Point3D initialPoint;
initialPoint.Fill(0);
for (int i = 0; i < 6; ++i)
HandlePropertyList.push_back(Handle(initialPoint, i, GetHandleIndices(i)));
}
std::vector<Handle> HandlePropertyList;
mitk::LocalStorageHandler<LocalStorage> LocalStorageHandler;
};
}
mitk::BoundingShapeVtkMapper2D::LocalStorage::LocalStorage()
: m_Actor(vtkSmartPointer<vtkActor>::New()),
- m_HandleActor(vtkSmartPointer<vtkActor2D>::New()),
- m_SelectedHandleActor(vtkSmartPointer<vtkActor2D>::New()),
- m_Mapper(vtkSmartPointer<vtkPolyDataMapper>::New()),
- m_HandleMapper(vtkSmartPointer<vtkPolyDataMapper2D>::New()),
- m_SelectedHandleMapper(vtkSmartPointer<vtkPolyDataMapper2D>::New()),
- m_Cutter(vtkSmartPointer<vtkCutter>::New()),
- m_CuttingPlane(vtkSmartPointer<vtkPlane>::New()),
- m_PropAssembly(vtkSmartPointer<vtkPropAssembly>::New()),
- m_ZoomFactor(1.0)
+ m_HandleActor(vtkSmartPointer<vtkActor2D>::New()),
+ m_SelectedHandleActor(vtkSmartPointer<vtkActor2D>::New()),
+ m_Mapper(vtkSmartPointer<vtkPolyDataMapper>::New()),
+ m_HandleMapper(vtkSmartPointer<vtkPolyDataMapper2D>::New()),
+ m_SelectedHandleMapper(vtkSmartPointer<vtkPolyDataMapper2D>::New()),
+ m_Cutter(vtkSmartPointer<vtkCutter>::New()),
+ m_CuttingPlane(vtkSmartPointer<vtkPlane>::New()),
+ m_LastSliceNumber(0),
+ m_PropAssembly(vtkSmartPointer<vtkPropAssembly>::New()),
+ m_ZoomFactor(1.0)
{
m_Actor->SetMapper(m_Mapper);
m_Actor->GetProperty()->SetOpacity(0.3);
m_Actor->VisibilityOn();
m_HandleActor->SetMapper(m_HandleMapper);
m_HandleActor->VisibilityOn();
m_SelectedHandleActor->VisibilityOn();
m_SelectedHandleActor->GetProperty()->SetColor(0, 1.0, 0);
m_SelectedHandleActor->SetMapper(m_SelectedHandleMapper);
vtkCoordinate *tcoord = vtkCoordinate::New();
tcoord->SetCoordinateSystemToWorld();
m_SelectedHandleMapper->SetTransformCoordinate(tcoord);
tcoord->Delete();
m_Cutter->SetCutFunction(m_CuttingPlane);
for (int i = 0; i < 6; ++i)
m_Handles.push_back(CreateHandle());
m_PropAssembly->AddPart(m_Actor);
m_PropAssembly->AddPart(m_HandleActor);
m_PropAssembly->VisibilityOn();
}
bool mitk::BoundingShapeVtkMapper2D::LocalStorage::IsUpdateRequired(mitk::BaseRenderer *renderer,
- mitk::Mapper *mapper,
- mitk::DataNode *dataNode)
+ mitk::Mapper *mapper,
+ mitk::DataNode *dataNode)
{
const mitk::PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
if (m_LastGenerateDataTime < worldGeometry->GetMTime())
return true;
+ unsigned int sliceNumber = renderer->GetSlice();
+
+ if (m_LastSliceNumber != sliceNumber)
+ return true;
+
if (mapper && m_LastGenerateDataTime < mapper->GetMTime())
return true;
if (dataNode)
{
if (m_LastGenerateDataTime < dataNode->GetMTime())
return true;
mitk::BaseData *data = dataNode->GetData();
if (data && m_LastGenerateDataTime < data->GetMTime())
return true;
}
return false;
}
mitk::BoundingShapeVtkMapper2D::LocalStorage::~LocalStorage()
{
}
void mitk::BoundingShapeVtkMapper2D::Update(mitk::BaseRenderer *renderer)
{
this->GenerateDataForRenderer(renderer);
}
void mitk::BoundingShapeVtkMapper2D::SetDefaultProperties(DataNode *node, BaseRenderer *renderer, bool overwrite)
{
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
mitk::BoundingShapeVtkMapper2D::BoundingShapeVtkMapper2D() : m_Impl(new Impl)
{
}
mitk::BoundingShapeVtkMapper2D::~BoundingShapeVtkMapper2D()
{
delete m_Impl;
}
void mitk::BoundingShapeVtkMapper2D::GenerateDataForRenderer(BaseRenderer *renderer)
{
const DataNode::Pointer node = GetDataNode();
if (node == nullptr)
return;
LocalStorage *localStorage = m_Impl->LocalStorageHandler.GetLocalStorage(renderer);
// either update if GeometryData was modified or if the zooming was performed
bool needGenerateData = localStorage->IsUpdateRequired(
renderer, this, GetDataNode()); // true; // localStorage->GetLastGenerateDataTime() < node->GetMTime() ||
- // localStorage->GetLastGenerateDataTime() < node->GetData()->GetMTime();
- // //localStorage->IsGenerateDataRequired(renderer, this, GetDataNode());
+ // localStorage->GetLastGenerateDataTime() < node->GetData()->GetMTime();
+ // //localStorage->IsGenerateDataRequired(renderer, this, GetDataNode());
double scale = renderer->GetScaleFactorMMPerDisplayUnit();
if (std::abs(scale - localStorage->m_ZoomFactor) > 0.001)
{
localStorage->m_ZoomFactor = scale;
needGenerateData = true;
}
if (needGenerateData)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if (!visible)
{
localStorage->m_Actor->VisibilityOff();
return;
}
GeometryData::Pointer shape = static_cast<GeometryData *>(node->GetData());
if (shape == nullptr)
return;
mitk::BaseGeometry::Pointer geometry = shape->GetGeometry();
mitk::Vector3D spacing = geometry->GetSpacing();
// calculate cornerpoints and extent from geometry with visualization offset
std::vector<Point3D> cornerPoints = GetCornerPoints(geometry, true);
Point3D p0 = cornerPoints[0];
Point3D p1 = cornerPoints[1];
Point3D p2 = cornerPoints[2];
Point3D p4 = cornerPoints[4];
Point3D extent;
extent[0] =
sqrt((p0[0] - p4[0]) * (p0[0] - p4[0]) + (p0[1] - p4[1]) * (p0[1] - p4[1]) + (p0[2] - p4[2]) * (p0[2] - p4[2]));
extent[1] =
sqrt((p0[0] - p2[0]) * (p0[0] - p2[0]) + (p0[1] - p2[1]) * (p0[1] - p2[1]) + (p0[2] - p2[2]) * (p0[2] - p2[2]));
extent[2] =
sqrt((p0[0] - p1[0]) * (p0[0] - p1[0]) + (p0[1] - p1[1]) * (p0[1] - p1[1]) + (p0[2] - p1[2]) * (p0[2] - p1[2]));
// calculate center based on half way of the distance between two opposing cornerpoints
mitk::Point3D center = CalcAvgPoint(cornerPoints[7], cornerPoints[0]);
if (m_Impl->HandlePropertyList.size() == 6)
{
// set handle positions
Point3D pointLeft = CalcAvgPoint(cornerPoints[5], cornerPoints[6]);
Point3D pointRight = CalcAvgPoint(cornerPoints[1], cornerPoints[2]);
Point3D pointTop = CalcAvgPoint(cornerPoints[0], cornerPoints[6]);
Point3D pointBottom = CalcAvgPoint(cornerPoints[7], cornerPoints[1]);
Point3D pointFront = CalcAvgPoint(cornerPoints[2], cornerPoints[7]);
Point3D pointBack = CalcAvgPoint(cornerPoints[4], cornerPoints[1]);
m_Impl->HandlePropertyList[0].SetPosition(pointLeft);
m_Impl->HandlePropertyList[1].SetPosition(pointRight);
m_Impl->HandlePropertyList[2].SetPosition(pointTop);
m_Impl->HandlePropertyList[3].SetPosition(pointBottom);
m_Impl->HandlePropertyList[4].SetPosition(pointFront);
m_Impl->HandlePropertyList[5].SetPosition(pointBack);
}
// caculate face normals
double result0[3], result1[3], result2[3];
double a[3], b[3];
a[0] = (cornerPoints[5][0] - cornerPoints[6][0]);
a[1] = (cornerPoints[5][1] - cornerPoints[6][1]);
a[2] = (cornerPoints[5][2] - cornerPoints[6][2]);
b[0] = (cornerPoints[5][0] - cornerPoints[4][0]);
b[1] = (cornerPoints[5][1] - cornerPoints[4][1]);
b[2] = (cornerPoints[5][2] - cornerPoints[4][2]);
vtkMath::Cross(a, b, result0);
a[0] = (cornerPoints[0][0] - cornerPoints[6][0]);
a[1] = (cornerPoints[0][1] - cornerPoints[6][1]);
a[2] = (cornerPoints[0][2] - cornerPoints[6][2]);
b[0] = (cornerPoints[0][0] - cornerPoints[2][0]);
b[1] = (cornerPoints[0][1] - cornerPoints[2][1]);
b[2] = (cornerPoints[0][2] - cornerPoints[2][2]);
vtkMath::Cross(a, b, result1);
a[0] = (cornerPoints[2][0] - cornerPoints[7][0]);
a[1] = (cornerPoints[2][1] - cornerPoints[7][1]);
a[2] = (cornerPoints[2][2] - cornerPoints[7][2]);
b[0] = (cornerPoints[2][0] - cornerPoints[6][0]);
b[1] = (cornerPoints[2][1] - cornerPoints[6][1]);
b[2] = (cornerPoints[2][2] - cornerPoints[6][2]);
vtkMath::Cross(a, b, result2);
vtkMath::Normalize(result0);
vtkMath::Normalize(result1);
vtkMath::Normalize(result2);
// create cube for rendering bounding box
auto cube = vtkCubeSource::New();
cube->SetXLength(extent[0] / spacing[0]);
cube->SetYLength(extent[1] / spacing[1]);
cube->SetZLength(extent[2] / spacing[2]);
// calculates translation based on offset+extent not on the transformation matrix
vtkSmartPointer<vtkMatrix4x4> imageTransform = geometry->GetVtkTransform()->GetMatrix();
auto translation = vtkSmartPointer<vtkTransform>::New();
translation->Translate(center[0] - imageTransform->GetElement(0, 3),
- center[1] - imageTransform->GetElement(1, 3),
- center[2] - imageTransform->GetElement(2, 3));
+ center[1] - imageTransform->GetElement(1, 3),
+ center[2] - imageTransform->GetElement(2, 3));
auto transform = vtkSmartPointer<vtkTransform>::New();
transform->SetMatrix(imageTransform);
transform->PostMultiply();
transform->Concatenate(translation);
transform->Update();
cube->Update();
auto transformFilter = vtkSmartPointer<vtkTransformFilter>::New();
transformFilter->SetInputData(cube->GetOutput());
transformFilter->SetTransform(transform);
transformFilter->Update();
cube->Delete();
vtkSmartPointer<vtkPolyData> polydata = transformFilter->GetPolyDataOutput();
if (polydata == nullptr || (polydata->GetNumberOfPoints() < 1))
{
localStorage->m_Actor->VisibilityOff();
localStorage->m_HandleActor->VisibilityOff();
localStorage->m_SelectedHandleActor->VisibilityOff();
return;
}
// estimate current image plane to decide whether the cube is visible or not
const PlaneGeometry *planeGeometry = renderer->GetCurrentWorldPlaneGeometry();
if ((planeGeometry == nullptr) || (!planeGeometry->IsValid()) || (!planeGeometry->HasReferenceGeometry()))
return;
double origin[3];
origin[0] = planeGeometry->GetOrigin()[0];
origin[1] = planeGeometry->GetOrigin()[1];
origin[2] = planeGeometry->GetOrigin()[2];
double normal[3];
normal[0] = planeGeometry->GetNormal()[0];
normal[1] = planeGeometry->GetNormal()[1];
normal[2] = planeGeometry->GetNormal()[2];
// MITK_INFO << "normal1 " << normal[0] << " " << normal[1] << " " << normal[2];
localStorage->m_CuttingPlane->SetOrigin(origin);
localStorage->m_CuttingPlane->SetNormal(normal);
// add cube polydata to local storage
localStorage->m_Cutter->SetInputData(polydata);
localStorage->m_Cutter->SetGenerateCutScalars(1);
localStorage->m_Cutter->Update();
if (localStorage->m_PropAssembly->GetParts()->IsItemPresent(localStorage->m_HandleActor))
localStorage->m_PropAssembly->RemovePart(localStorage->m_HandleActor);
if (localStorage->m_PropAssembly->GetParts()->IsItemPresent(localStorage->m_Actor))
localStorage->m_PropAssembly->RemovePart(localStorage->m_Actor);
vtkCoordinate *tcoord = vtkCoordinate::New();
tcoord->SetCoordinateSystemToWorld();
localStorage->m_HandleMapper->SetTransformCoordinate(tcoord);
tcoord->Delete();
if (localStorage->m_Cutter->GetOutput()->GetNumberOfPoints() > 0) // if plane is visible in the renderwindow
{
mitk::DoubleProperty::Pointer handleSizeProperty =
dynamic_cast<mitk::DoubleProperty *>(this->GetDataNode()->GetProperty("Bounding Shape.Handle Size Factor"));
ScalarType initialHandleSize;
if (handleSizeProperty != nullptr)
initialHandleSize = handleSizeProperty->GetValue();
else
initialHandleSize = 1.0 / 40.0;
mitk::Point2D displaySize = renderer->GetDisplaySizeInMM();
double handleSize = ((displaySize[0] + displaySize[1]) / 2.0) * initialHandleSize;
auto appendPoly = vtkSmartPointer<vtkAppendPolyData>::New();
unsigned int i = 0;
// add handles and their assigned properties to the local storage
mitk::IntProperty::Pointer activeHandleId =
dynamic_cast<mitk::IntProperty *>(node->GetProperty("Bounding Shape.Active Handle ID"));
bool visible = false;
bool selected = false;
for (auto handle : localStorage->m_Handles)
{
Point3D handleCenter = m_Impl->HandlePropertyList[i].GetPosition();
handle->SetRadius(handleSize);
handle->SetCenter(handleCenter[0], handleCenter[1], handleCenter[2]);
vtkMath::Normalize(normal);
double angle = vtkMath::DegreesFromRadians(acos(vtkMath::Dot(normal, result0)));
double angle1 = vtkMath::DegreesFromRadians(acos(vtkMath::Dot(normal, result1)));
double angle2 = vtkMath::DegreesFromRadians(acos(vtkMath::Dot(normal, result2)));
// show handles only if the corresponding face is aligned to the render window
if ((((std::abs(angle - 0) < 0.001) || (std::abs(angle - 180) < 0.001)) && i != 0 && i != 1) ||
- (((std::abs(angle1 - 0) < 0.001) || (std::abs(angle1 - 180) < 0.001)) && i != 2 && i != 3) ||
- (((std::abs(angle2 - 0) < 0.001) || (std::abs(angle2 - 180) < 0.001)) && i != 4 && i != 5))
+ (((std::abs(angle1 - 0) < 0.001) || (std::abs(angle1 - 180) < 0.001)) && i != 2 && i != 3) ||
+ (((std::abs(angle2 - 0) < 0.001) || (std::abs(angle2 - 180) < 0.001)) && i != 4 && i != 5))
{
if (activeHandleId == nullptr)
{
appendPoly->AddInputConnection(handle->GetOutputPort());
}
else
{
if ((activeHandleId->GetValue() != m_Impl->HandlePropertyList[i].GetIndex()))
{
appendPoly->AddInputConnection(handle->GetOutputPort());
}
else
{
handle->Update();
localStorage->m_SelectedHandleMapper->SetInputData(handle->GetOutput());
localStorage->m_SelectedHandleActor->VisibilityOn();
selected = true;
}
}
visible = true;
}
i++;
}
if (visible)
{
appendPoly->Update();
}
else
{
localStorage->m_HandleActor->VisibilityOff();
localStorage->m_SelectedHandleActor->VisibilityOff();
}
auto stripper = vtkSmartPointer<vtkStripper>::New();
stripper->SetInputData(localStorage->m_Cutter->GetOutput());
stripper->Update();
auto cutPolyData = vtkSmartPointer<vtkPolyData>::New();
cutPolyData->SetPoints(stripper->GetOutput()->GetPoints());
cutPolyData->SetPolys(stripper->GetOutput()->GetLines());
localStorage->m_Actor->GetMapper()->SetInputDataObject(cutPolyData);
mitk::ColorProperty::Pointer selectedColor = dynamic_cast<mitk::ColorProperty *>(node->GetProperty("color"));
if (selectedColor != nullptr)
{
mitk::Color color = selectedColor->GetColor();
localStorage->m_Actor->GetProperty()->SetColor(color[0], color[1], color[2]);
}
if (activeHandleId != nullptr)
{
localStorage->m_HandleActor->GetProperty()->SetColor(1, 0, 0);
}
else
{
localStorage->m_HandleActor->GetProperty()->SetColor(1, 1, 1);
}
localStorage->m_HandleActor->GetMapper()->SetInputDataObject(appendPoly->GetOutput());
// add parts to the overall storage
localStorage->m_PropAssembly->AddPart(localStorage->m_Actor);
localStorage->m_PropAssembly->AddPart(localStorage->m_HandleActor);
if (selected)
{
localStorage->m_PropAssembly->AddPart(localStorage->m_SelectedHandleActor);
}
localStorage->m_PropAssembly->VisibilityOn();
localStorage->m_Actor->VisibilityOn();
localStorage->m_HandleActor->VisibilityOn();
}
else
{
localStorage->m_PropAssembly->VisibilityOff();
localStorage->m_Actor->VisibilityOff();
localStorage->m_HandleActor->VisibilityOff();
localStorage->m_SelectedHandleActor->VisibilityOff();
localStorage->UpdateGenerateDataTime();
}
localStorage->UpdateGenerateDataTime();
}
}
vtkProp *mitk::BoundingShapeVtkMapper2D::GetVtkProp(BaseRenderer *renderer)
{
return m_Impl->LocalStorageHandler.GetLocalStorage(renderer)->m_PropAssembly;
}
void mitk::BoundingShapeVtkMapper2D::ApplyColorAndOpacityProperties(BaseRenderer *, vtkActor *)
{
}
diff --git a/Modules/Core/include/mitkExtractSliceFilter.h b/Modules/Core/include/mitkExtractSliceFilter.h
index a1117f200f..c921e04044 100644
--- a/Modules/Core/include/mitkExtractSliceFilter.h
+++ b/Modules/Core/include/mitkExtractSliceFilter.h
@@ -1,189 +1,202 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; 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 "MitkCoreExports.h"
#include "mitkImageToImageFilter.h"
-#include <vtkSmartPointer.h>
#include <vtkAbstractTransform.h>
#include <vtkImageData.h>
#include <vtkImageReslice.h>
#include <vtkMatrix4x4.h>
#include <vtkPoints.h>
+#include <vtkSmartPointer.h>
#include <vtkTransform.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.
+ and is also able to reslice an arbitrary oriented oblique plane.
Curved planes are specified via an AbstractTransformGeometry as the input worldgeometry.
- The convinient workflow is:
+ Additionally the filter extracts the specified component of a multi-component input image.
+ This is done only if the caller requests an mitk::Image output ('m_VtkOutputRequested' set to false).
+ The default component to be extracted is '0'.
+
+ The convenient workflow is:
1. Set an image as input.
2. Set the worldPlaneGeometry. 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.
+ - a transform this is a convenient way to adapt the reslice axis for the case
+ that the image is transformed e.g. rotated.
- time step the time step in a times volume.
- - resample by geometry wether the resampling grid corresponds to the specs of the
- worldgeometry or is directly derived from the input image
+ - the component to extract from a multi-component input image
+ - vtkoutputrequested, to define whether an mitk::image should be initialized
+ - resample by geometry whether 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.
+ - component 0.
- resample by geometry false (Corresponds to input image).
*/
class MITKCORE_EXPORT ExtractSliceFilter : public ImageToImageFilter
{
public:
mitkClassMacro(ExtractSliceFilter, ImageToImageFilter);
itkFactorylessNewMacro(Self) itkCloneMacro(Self)
mitkNewMacro1Param(Self, vtkImageReslice *);
/** \brief Set the axis where to reslice at.*/
void SetWorldGeometry(const PlaneGeometry *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; }
+ void SetTimeStep(unsigned int timestep) { m_TimeStep = timestep; }
+ unsigned int GetTimeStep() { return m_TimeStep; }
+
+ /** \brief Set the component of an image to be extracted */
+ void SetComponent(unsigned int component) { m_Component = component; }
+
/** \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 BaseGeometry *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 BaseGeometry*, const PlaneGeometry*, double*)
* 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 BaseGeometry *boundingGeometry,
const PlaneGeometry *planeGeometry,
double *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(); }
void SetBackgroundLevel(double backgroundLevel) { m_BackgroundLevel = backgroundLevel; }
enum ResliceInterpolation
{
RESLICE_NEAREST = 0,
RESLICE_LINEAR = 1,
RESLICE_CUBIC = 3
};
void SetInterpolationMode(ExtractSliceFilter::ResliceInterpolation interpolation)
{
this->m_InterpolationMode = interpolation;
}
protected:
ExtractSliceFilter(vtkImageReslice *reslicer = nullptr);
virtual ~ExtractSliceFilter();
virtual void GenerateData() override;
virtual void GenerateOutputInformation() override;
virtual void GenerateInputRequestedRegion() override;
const PlaneGeometry *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;
BaseGeometry::ConstPointer m_ResliceTransform;
bool m_InPlaneResampleExtentByGeometry; // Resampling grid corresponds to: false->image true->worldgeometry
mitk::ScalarType *m_OutPutSpacing;
bool m_VtkOutputRequested;
double m_BackgroundLevel;
+
+ unsigned int m_Component;
};
}
#endif // mitkExtractSliceFilter_h_Included
diff --git a/Modules/Core/src/Algorithms/mitkExtractSliceFilter.cpp b/Modules/Core/src/Algorithms/mitkExtractSliceFilter.cpp
index bad16c38b1..369d002eff 100644
--- a/Modules/Core/src/Algorithms/mitkExtractSliceFilter.cpp
+++ b/Modules/Core/src/Algorithms/mitkExtractSliceFilter.cpp
@@ -1,462 +1,480 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; 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 <mitkAbstractTransformGeometry.h>
#include <mitkPlaneClipping.h>
+
#include <vtkGeneralTransform.h>
#include <vtkImageChangeInformation.h>
#include <vtkImageData.h>
+#include <vtkImageExtractComponents.h>
#include <vtkLinearTransform.h>
-#include <vtkSmartPointer.h>
mitk::ExtractSliceFilter::ExtractSliceFilter(vtkImageReslice *reslicer)
{
if (reslicer == nullptr)
{
m_Reslicer = vtkSmartPointer<vtkImageReslice>::New();
}
else
{
m_Reslicer = reslicer;
}
m_TimeStep = 0;
m_Reslicer->ReleaseDataFlagOn();
m_InterpolationMode = ExtractSliceFilter::RESLICE_NEAREST;
m_ResliceTransform = nullptr;
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;
m_BackgroundLevel = -32768.0;
+ m_Component = 0;
}
mitk::ExtractSliceFilter::~ExtractSliceFilter()
{
m_ResliceTransform = nullptr;
m_WorldGeometry = nullptr;
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 TimeGeometry *inputTimeGeometry = this->GetInput()->GetTimeGeometry();
if ((inputTimeGeometry == nullptr) || (inputTimeGeometry->CountTimeSteps() <= 0))
{
itkWarningMacro(<< "Error reading input image TimeGeometry.");
return;
}
// is it a valid timeStep?
if (inputTimeGeometry->IsValidTimeStep(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================*/
+ /*================#BEGIN setup vtkImageReslice properties================*/
Point3D origin;
Vector3D right, bottom, normal;
double widthInMM, heightInMM;
Vector2D extent;
const PlaneGeometry *planeGeometry = dynamic_cast<const PlaneGeometry *>(m_WorldGeometry);
// 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 != nullptr)
{
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->GetGeometryForTimeStep(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 PlaneGeometryDataVtkMapper3D)
// Note: Backgroundlevel was hardcoded before to -1023
m_Reslicer->SetBackgroundLevel(m_BackgroundLevel);
}
else
{
if (planeGeometry != nullptr)
{
- // if the worldGeomatry is a PlaneGeometry everthing is straight forward
+ // if the worldGeomatry is a PlaneGeometry everything 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->GetGeometryForTimeStep(m_TimeStep)->WorldToIndex(right, rightInIndex);
inputTimeGeometry->GetGeometryForTimeStep(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 PlaneGeometryDataVtkMapper3D),
// else the background of the image turns out gray
// Note: Backgroundlevel was hardcoded to -32768
m_Reslicer->SetBackgroundLevel(m_BackgroundLevel);
}
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->SetInputData(input->GetVtkImageData(m_TimeStep));
m_Reslicer->SetInputConnection(unitSpacingImageFilter->GetOutputPort());
}
else
{
- // if no tranform is set the image can be used directly
+ // if no transform is set the image can be used directly
m_Reslicer->SetInputData(input->GetVtkImageData(m_TimeStep));
}
/*setup the plane where vktImageReslice extracts the slice*/
- // ResliceAxesOrigin is the ancor point of the plane
+ // ResliceAxesOrigin is the anchor 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]);
if (m_WorldGeometry->GetReferenceGeometry())
{
double sliceBounds[6];
for (auto &sliceBound : sliceBounds)
{
sliceBound = 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
+ // TODO check the following lines, they are responsible whether 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================*/
+ /*================ #END setup vtkImageReslice properties================*/
if (m_VtkOutputRequested)
{
- return;
- // no converting to mitk
+ // no conversion to mitk
// no mitk geometry will be set, as the output is vtkImageData only!!!
+ // no image component will be extracted, as the caller might need the whole multi-component image as vtk output
+ return;
}
else
{
- /*================ #BEGIN Get the slice from vtkImageReslice and convert it to mit::Image================*/
- vtkImageData *reslicedImage;
+ auto reslicedImage = vtkSmartPointer<vtkImageData>::New();
reslicedImage = m_Reslicer->GetOutput();
- if (!reslicedImage)
+ if (nullptr == reslicedImage)
{
itkWarningMacro(<< "Reslicer returned empty image");
return;
}
- mitk::Image::Pointer resultImage = this->GetOutput();
+ /*================ #BEGIN Extract component from image slice ================*/
+ int numberOfScalarComponent = reslicedImage->GetNumberOfScalarComponents();
+ if (numberOfScalarComponent > 1 && static_cast<unsigned int>(numberOfScalarComponent) >= m_Component)
+ {
+ // image has more than one component, extract the correct component information with the given 'component' parameter
+ auto vectorComponentExtractor = vtkSmartPointer<vtkImageExtractComponents>::New();
+ vectorComponentExtractor->SetInputData(reslicedImage);
+ vectorComponentExtractor->SetComponents(m_Component);
+ vectorComponentExtractor->Update();
+
+ reslicedImage = vectorComponentExtractor->GetOutput();
+ }
+ /*================ #END Extract component from image slice ================*/
+
+ /*================ #BEGIN Convert the slice to an mitk::Image ================*/
+ mitk::Image::Pointer resultImage = 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
// mitk::AffineGeometryFrame3D::Pointer originalGeometryAGF = m_WorldGeometry->Clone();
// PlaneGeometry::Pointer originalGeometry = dynamic_cast<PlaneGeometry*>( originalGeometryAGF.GetPointer() );
PlaneGeometry::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
+ This causes errors on transferring 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].
+ The new bounds are set via the max values of the calculated 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================*/
+ /*================ #END Convert the slice to an mitk::Image ================*/
}
}
bool mitk::ExtractSliceFilter::GetClippedPlaneBounds(double 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 BaseGeometry *boundingGeometry,
const PlaneGeometry *planeGeometry,
double *bounds)
{
bool b = mitk::PlaneClipping::CalculateClippedPlaneBounds(boundingGeometry, planeGeometry, bounds);
return b;
}
diff --git a/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp b/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp
index f28fd4cd94..90a629b1f1 100644
--- a/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp
+++ b/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp
@@ -1,622 +1,622 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetDataInteractor.h"
#include "mitkMouseMoveEvent.h"
#include "mitkInteractionConst.h" // TODO: refactor file
#include "mitkInternalEvent.h"
#include "mitkOperationEvent.h"
#include "mitkRenderingManager.h"
#include <mitkPointOperation.h>
//
#include "mitkBaseRenderer.h"
#include "mitkDispatcher.h"
#include "mitkUndoController.h"
void mitk::PointSetDataInteractor::ConnectActionsAndFunctions()
{
// Condition which is evaluated before transition is taken
// following actions in the statemachine are only executed if it returns TRUE
CONNECT_CONDITION("isoverpoint", CheckSelection);
CONNECT_FUNCTION("addpoint", AddPoint);
CONNECT_FUNCTION("selectpoint", SelectPoint);
CONNECT_FUNCTION("unselect", UnSelectPointAtPosition);
CONNECT_FUNCTION("unselectAll", UnSelectAll);
CONNECT_FUNCTION("initMove", InitMove);
CONNECT_FUNCTION("movePoint", MovePoint);
CONNECT_FUNCTION("finishMovement", FinishMove);
CONNECT_FUNCTION("removePoint", RemovePoint);
}
void mitk::PointSetDataInteractor::AddPoint(StateMachineAction *stateMachineAction, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
// disallow adding of new points if maximum number of points is reached
if (m_MaxNumberOfPoints > 1 && m_PointSet->GetSize(timeStep) >= m_MaxNumberOfPoints)
{
return;
}
// To add a point the minimal information is the position, this method accepts all InteractionsPositionEvents
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
mitk::Point3D itkPoint = positionEvent->GetPositionInWorld();
this->UnselectAll(timeStep, timeInMs);
int lastPosition = 0;
mitk::PointSet::PointsIterator it, end;
it = m_PointSet->Begin(timeStep);
end = m_PointSet->End(timeStep);
while (it != end)
{
if (!m_PointSet->IndexExists(lastPosition, timeStep))
break;
++it;
++lastPosition;
}
// Insert a Point to the PointSet
// 2) Create the Operation inserting the point
-
+ if (m_PointSet->IsEmpty()) { lastPosition = 0; }
PointOperation *doOp = new mitk::PointOperation(OpINSERT, timeInMs, itkPoint, lastPosition);
// 3) If Undo is enabled, also create the inverse Operation
if (m_UndoEnabled)
{
PointOperation *undoOp = new mitk::PointOperation(OpREMOVE, timeInMs, itkPoint, lastPosition);
// 4) Do and Undo Operations are combined in an Operation event which also contains the target of the operations
// (here m_PointSet)
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Add point");
// 5) Store the Operation in the UndoController
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}
// 6) Execute the Operation performs the actual insertion of the point into the PointSet
m_PointSet->ExecuteOperation(doOp);
// 7) If Undo is not enabled the Do-Operation is to be dropped to prevent memory leaks.
if (!m_UndoEnabled)
delete doOp;
// Request update
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
// Check if points form a closed contour now, if so fire an InternalEvent
IsClosedContour(stateMachineAction, interactionEvent);
if (m_MaxNumberOfPoints > 0 && m_PointSet->GetSize(timeStep) >= m_MaxNumberOfPoints)
{
// Signal that DataNode is fully filled
this->NotifyResultReady();
// Send internal event that can be used by StateMachines to switch in a different state
InternalEvent::Pointer event = InternalEvent::New(NULL, this, "MaximalNumberOfPoints");
positionEvent->GetSender()->GetDispatcher()->QueueEvent(event.GetPointer());
}
}
}
void mitk::PointSetDataInteractor::SelectPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
Point3D point = positionEvent->GetPositionInWorld();
// iterate over point set and check if it contains a point close enough to the pointer to be selected
int index = GetPointIndexByPosition(point, timeStep);
if (index != -1)
{
// first deselect the other points
// undoable deselect of all points in the DataList
this->UnselectAll(timeStep, timeInMs);
PointOperation *doOp = new mitk::PointOperation(OpSELECTPOINT, timeInMs, point, index);
/*if (m_UndoEnabled)
{
PointOperation* undoOp = new mitk::PointOperation(OpDESELECTPOINT,timeInMs,point, index);
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Select Point");
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}*/
// execute the Operation
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
}
}
mitk::PointSetDataInteractor::PointSetDataInteractor() : m_MaxNumberOfPoints(0), m_SelectionAccuracy(3.5)
{
}
mitk::PointSetDataInteractor::~PointSetDataInteractor()
{
}
void mitk::PointSetDataInteractor::RemovePoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
mitk::Point3D itkPoint = positionEvent->GetPositionInWorld();
// search the point in the list
int position = m_PointSet->SearchPoint(itkPoint, m_SelectionAccuracy, timeStep);
if (position >= 0) // found a point
{
PointSet::PointType pt = m_PointSet->GetPoint(position, timeStep);
itkPoint[0] = pt[0];
itkPoint[1] = pt[1];
itkPoint[2] = pt[2];
PointOperation *doOp = new mitk::PointOperation(OpREMOVE, timeInMs, itkPoint, position);
if (m_UndoEnabled) // write to UndoMechanism
{
PointOperation *undoOp = new mitk::PointOperation(OpINSERT, timeInMs, itkPoint, position);
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Remove point");
mitk::OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}
// execute the Operation
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
/*now select the point "position-1",
and if it is the first in list,
then continue at the last in list*/
// only then a select of a point is possible!
if (m_PointSet->GetSize(timeStep) > 0)
{
this->SelectPoint(m_PointSet->Begin(timeStep)->Index(), timeStep, timeInMs);
}
}
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
}
void mitk::PointSetDataInteractor::IsClosedContour(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
Point3D point = positionEvent->GetPositionInWorld();
// iterate over point set and check if it contains a point close enough to the pointer to be selected
if (GetPointIndexByPosition(point, timeStep) != -1 && m_PointSet->GetSize(timeStep) >= 3)
{
InternalEvent::Pointer event = InternalEvent::New(NULL, this, "ClosedContour");
positionEvent->GetSender()->GetDispatcher()->QueueEvent(event.GetPointer());
}
}
}
void mitk::PointSetDataInteractor::MovePoint(StateMachineAction *stateMachineAction, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
IsClosedContour(stateMachineAction, interactionEvent);
mitk::Point3D newPoint, resultPoint;
newPoint = positionEvent->GetPositionInWorld();
// search the elements in the list that are selected then calculate the
// vector, because only with the vector we can move several elements in
// the same direction
// newPoint - lastPoint = vector
// then move all selected and set the lastPoint = newPoint.
// then add all vectors to a summeryVector (to be able to calculate the
// startpoint for undoOperation)
mitk::Vector3D dirVector = newPoint - m_LastPoint;
// sum up all Movement for Undo in FinishMovement
m_SumVec = m_SumVec + dirVector;
mitk::PointSet::PointsIterator it, end;
it = m_PointSet->Begin(timeStep);
end = m_PointSet->End(timeStep);
while (it != end)
{
int position = it->Index();
if (m_PointSet->GetSelectInfo(position, timeStep)) // if selected
{
PointSet::PointType pt = m_PointSet->GetPoint(position, timeStep);
mitk::Point3D sumVec;
sumVec[0] = pt[0];
sumVec[1] = pt[1];
sumVec[2] = pt[2];
resultPoint = sumVec + dirVector;
PointOperation *doOp = new mitk::PointOperation(OpMOVE, timeInMs, resultPoint, position);
// execute the Operation
// here no undo is stored, because the movement-steps aren't interesting.
// only the start and the end is interisting to store for undo.
m_PointSet->ExecuteOperation(doOp);
delete doOp;
}
++it;
}
m_LastPoint = newPoint; // for calculation of the direction vector
// Update the display
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
IsClosedContour(stateMachineAction, interactionEvent);
}
}
void mitk::PointSetDataInteractor::UnSelectPointAtPosition(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
Point3D point = positionEvent->GetPositionInWorld();
// iterate over point set and check if it contains a point close enough to the pointer to be selected
int index = GetPointIndexByPosition(point, timeStep);
// here it is ensured that we don't switch from one point being selected to another one being selected,
// without accepting the unselect of the current point
if (index != -1)
{
PointOperation *doOp = new mitk::PointOperation(OpDESELECTPOINT, timeInMs, point, index);
/*if (m_UndoEnabled)
{
PointOperation* undoOp = new mitk::PointOperation(OpSELECTPOINT,timeInMs, point, index);
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Unselect Point");
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}*/
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
}
}
void mitk::PointSetDataInteractor::UnSelectAll(mitk::StateMachineAction *, mitk::InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
Point3D positioninWorld = positionEvent->GetPositionInWorld();
PointSet::PointsContainer::Iterator it, end;
PointSet::DataType *itkPointSet = m_PointSet->GetPointSet(timeStep);
end = itkPointSet->GetPoints()->End();
for (it = itkPointSet->GetPoints()->Begin(); it != end; it++)
{
int position = it->Index();
// then declare an operation which unselects this point;
// UndoOperation as well!
if (m_PointSet->GetSelectInfo(position, timeStep))
{
float distance = sqrt(positioninWorld.SquaredEuclideanDistanceTo(m_PointSet->GetPoint(position, timeStep)));
if (distance > m_SelectionAccuracy)
{
mitk::Point3D noPoint;
noPoint.Fill(0);
mitk::PointOperation *doOp = new mitk::PointOperation(OpDESELECTPOINT, timeInMs, noPoint, position);
/*if ( m_UndoEnabled )
{
mitk::PointOperation* undoOp = new mitk::PointOperation(OpSELECTPOINT, timeInMs, noPoint, position);
OperationEvent *operationEvent = new OperationEvent( m_PointSet, doOp, undoOp, "Unselect Point" );
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent( operationEvent );
}*/
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
}
}
}
else
{
this->UnselectAll(timeStep, timeInMs);
}
}
void mitk::PointSetDataInteractor::UpdatePointSet(mitk::StateMachineAction *, mitk::InteractionEvent *)
{
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(this->GetDataNode()->GetData());
if (pointSet == NULL)
{
MITK_ERROR << "PointSetDataInteractor:: No valid point set .";
return;
}
m_PointSet = pointSet;
}
void mitk::PointSetDataInteractor::Abort(StateMachineAction *, InteractionEvent *interactionEvent)
{
InternalEvent::Pointer event = InternalEvent::New(NULL, this, IntDeactivateMe);
interactionEvent->GetSender()->GetDispatcher()->QueueEvent(event.GetPointer());
}
/*
* Check whether the DataNode contains a pointset, if not create one and add it.
*/
void mitk::PointSetDataInteractor::DataNodeChanged()
{
if (GetDataNode() != nullptr)
{
PointSet *points = dynamic_cast<PointSet *>(GetDataNode()->GetData());
if (points == NULL)
{
m_PointSet = PointSet::New();
GetDataNode()->SetData(m_PointSet);
}
else
{
m_PointSet = points;
}
// load config file parameter: maximal number of points
mitk::PropertyList::Pointer properties = GetAttributes();
std::string strNumber;
if (properties->GetStringProperty("MaxPoints", strNumber))
{
m_MaxNumberOfPoints = atoi(strNumber.c_str());
}
}
}
void mitk::PointSetDataInteractor::InitMove(StateMachineAction *, InteractionEvent *interactionEvent)
{
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent == NULL)
return;
// start of the Movement is stored to calculate the undoKoordinate
// in FinishMovement
m_LastPoint = positionEvent->GetPositionInWorld();
// initialize a value to calculate the movement through all
// MouseMoveEvents from MouseClick to MouseRelease
m_SumVec.Fill(0);
GetDataNode()->SetProperty("contourcolor", ColorProperty::New(1.0, 1.0, 1.0));
}
void mitk::PointSetDataInteractor::FinishMove(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
// finish the movement:
// the final point is m_LastPoint
// m_SumVec stores the movement in a vector
// the operation would not be necessary, but we need it for the undo Operation.
// m_LastPoint is for the Operation
// the point for undoOperation calculates from all selected
// elements (point) - m_SumVec
// search all selected elements and move them with undo-functionality.
mitk::PointSet::PointsIterator it, end;
it = m_PointSet->Begin(timeStep);
end = m_PointSet->End(timeStep);
while (it != end)
{
int position = it->Index();
if (m_PointSet->GetSelectInfo(position, timeStep)) // if selected
{
PointSet::PointType pt = m_PointSet->GetPoint(position, timeStep);
Point3D itkPoint;
itkPoint[0] = pt[0];
itkPoint[1] = pt[1];
itkPoint[2] = pt[2];
PointOperation *doOp = new mitk::PointOperation(OpMOVE, timeInMs, itkPoint, position);
if (m_UndoEnabled) //&& (posEvent->GetType() == mitk::Type_MouseButtonRelease)
{
// set the undo-operation, so the final position is undo-able
// calculate the old Position from the already moved position - m_SumVec
mitk::Point3D undoPoint = (itkPoint - m_SumVec);
PointOperation *undoOp = new mitk::PointOperation(OpMOVE, timeInMs, undoPoint, position);
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Move point");
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}
// execute the Operation
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
++it;
}
// Update the display
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
else
{
return;
}
this->NotifyResultReady();
}
void mitk::PointSetDataInteractor::SetAccuracy(float accuracy)
{
m_SelectionAccuracy = accuracy;
}
void mitk::PointSetDataInteractor::SetMaxPoints(unsigned int maxNumber)
{
m_MaxNumberOfPoints = maxNumber;
}
int mitk::PointSetDataInteractor::GetPointIndexByPosition(Point3D position, unsigned int time, float accuracy)
{
// iterate over point set and check if it contains a point close enough to the pointer to be selected
PointSet *points = dynamic_cast<PointSet *>(GetDataNode()->GetData());
int index = -1;
if (points == NULL)
{
return index;
}
if (points->GetPointSet(time) == nullptr)
return -1;
PointSet::PointsContainer *pointsContainer = points->GetPointSet(time)->GetPoints();
float minDistance = m_SelectionAccuracy;
if (accuracy != -1)
minDistance = accuracy;
for (PointSet::PointsIterator it = pointsContainer->Begin(); it != pointsContainer->End(); it++)
{
float distance = sqrt(position.SquaredEuclideanDistanceTo(points->GetPoint(it->Index(), time)));
if (distance <
minDistance) // if several points fall within the margin, choose the one with minimal distance to position
{
index = it->Index();
}
}
return index;
}
bool mitk::PointSetDataInteractor::CheckSelection(const mitk::InteractionEvent *interactionEvent)
{
const InteractionPositionEvent *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
int timeStep = positionEvent->GetSender()->GetTimeStep();
Point3D point = positionEvent->GetPositionInWorld();
// iterate over point set and check if it contains a point close enough to the pointer to be selected
int index = GetPointIndexByPosition(point, timeStep);
if (index != -1)
return true;
}
return false;
}
void mitk::PointSetDataInteractor::UnselectAll(unsigned int timeStep, ScalarType timeInMs)
{
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(GetDataNode()->GetData());
if (pointSet == NULL)
{
return;
}
mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet(timeStep);
if (itkPointSet == NULL)
{
return;
}
mitk::PointSet::PointsContainer::Iterator it, end;
end = itkPointSet->GetPoints()->End();
for (it = itkPointSet->GetPoints()->Begin(); it != end; it++)
{
int position = it->Index();
PointSet::PointDataType pointData = {0, false, PTUNDEFINED};
itkPointSet->GetPointData(position, &pointData);
// then declare an operation which unselects this point;
// UndoOperation as well!
if (pointData.selected)
{
mitk::Point3D noPoint;
noPoint.Fill(0);
mitk::PointOperation *doOp = new mitk::PointOperation(OpDESELECTPOINT, timeInMs, noPoint, position);
/*if ( m_UndoEnabled )
{
mitk::PointOperation *undoOp =
new mitk::PointOperation(OpSELECTPOINT, timeInMs, noPoint, position);
OperationEvent *operationEvent = new OperationEvent( pointSet, doOp, undoOp, "Unselect Point" );
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent( operationEvent );
}*/
pointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
}
}
void mitk::PointSetDataInteractor::SelectPoint(int position, unsigned int timeStep, ScalarType timeInMS)
{
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(this->GetDataNode()->GetData());
// if List is empty, then no selection of a point can be done!
if ((pointSet == NULL) || (pointSet->GetSize(timeStep) <= 0))
{
return;
}
// dummyPoint... not needed anyway
mitk::Point3D noPoint;
noPoint.Fill(0);
mitk::PointOperation *doOp = new mitk::PointOperation(OpSELECTPOINT, timeInMS, noPoint, position);
/*if ( m_UndoEnabled )
{
mitk::PointOperation* undoOp = new mitk::PointOperation(OpDESELECTPOINT,timeInMS, noPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp, "Select Point");
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}*/
pointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
diff --git a/Modules/Core/test/mitkSliceNavigationControllerTest.cpp b/Modules/Core/test/mitkSliceNavigationControllerTest.cpp
index 78799c862a..13876749d4 100644
--- a/Modules/Core/test/mitkSliceNavigationControllerTest.cpp
+++ b/Modules/Core/test/mitkSliceNavigationControllerTest.cpp
@@ -1,649 +1,649 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkInteractionConst.h"
#include "mitkPlaneGeometry.h"
#include "mitkPlanePositionManager.h"
#include "mitkRotationOperation.h"
#include "mitkSliceNavigationController.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkTestingMacros.h"
#include "usGetModuleContext.h"
#include "usModuleContext.h"
#include "usServiceReference.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::TimeGeometry &timeGeometry,
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)
{
// Probleme durch umstellung von Time-SlicedGeometry auf TimeGeometry?
// Eventuell gibt es keine Entsprechung mehr.
const mitk::BaseGeometry::Pointer geometry = timeGeometry.GetGeometryForTimeStep(0);
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, (double)vnl_math::float_eps) == 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->SetInputWorldGeometry3D(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.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);
// Create another slicedgeo which will be rotated
mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New();
slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices);
// 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->SetPlaneGeometry(geo2d, i);
}
for (int i = 0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry2->SetPlaneGeometry(geo2d, i);
}
slicedgeometry1->SetReferenceGeometry(geometry);
slicedgeometry2->SetReferenceGeometry(geometry);
// Create SNC
mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1);
sliceCtrl1->Update();
mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
sliceCtrl2->SetInputWorldGeometry3D(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, 1E-12)) ||
(!mitk::Equal(orientAxis1, newAxis1, 1E-12)))
{
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.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);
// Create another slicedgeo which will be rotated
mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New();
slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices);
// 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->SetPlaneGeometry(geo2d, i);
}
for (int i = 0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry2->SetPlaneGeometry(geo2d, i);
}
slicedgeometry1->SetReferenceGeometry(geometry);
slicedgeometry2->SetReferenceGeometry(geometry);
// Create SNC
mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1);
sliceCtrl1->Update();
mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
sliceCtrl2->SetInputWorldGeometry3D(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();
us::ServiceReference<mitk::PlanePositionManagerService> serviceRef =
us::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService *service = us::GetModuleContext()->GetService(serviceRef);
service->AddNewPlanePosition(slicedgeometry2->GetPlaneGeometry(0), 178);
sliceCtrl1->ExecuteOperation(service->GetPlanePosition(0));
sliceCtrl1->Update();
mitk::PlaneGeometry *planeRotated = slicedgeometry2->GetPlaneGeometry(178);
mitk::PlaneGeometry *planeRestored =
dynamic_cast<const mitk::SlicedGeometry3D *>(sliceCtrl1->GetCurrentGeometry3D())->GetPlaneGeometry(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.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);
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.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;
// Re-Orient planes not working as it should on windows
// However, this might be adjusted during a geometry redesign.
/*
//Testing ReorientPlanes
result = testReorientPlanes();
if(result!=EXIT_SUCCESS)
return result;
*/
std::cout << "[TEST DONE]" << std::endl;
return EXIT_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.cpp
index f8c8292534..04a190ddaa 100644
--- a/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.cpp
@@ -1,1282 +1,1335 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkNDITrackingDevice.h"
#include "mitkIGTTimeStamp.h"
#include "mitkIGTHardwareException.h"
#include <stdio.h>
#include <itksys/SystemTools.hxx>
#include <itkMutexLockHolder.h>
#include <mitkUnspecifiedTrackingTypeInformation.h>
#include <mitkNDIPolarisTypeInformation.h>
#include <mitkNDIAuroraTypeInformation.h>
+// vtk
+#include <vtkSphereSource.h>
+
typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
const unsigned char CR = 0xD; // == '\r' - carriage return
const unsigned char LF = 0xA; // == '\n' - line feed
mitk::NDITrackingDevice::NDITrackingDevice() :
TrackingDevice(),m_DeviceName(""), m_PortNumber(mitk::SerialCommunication::COM5), m_BaudRate(mitk::SerialCommunication::BaudRate9600),
m_DataBits(mitk::SerialCommunication::DataBits8), m_Parity(mitk::SerialCommunication::None), m_StopBits(mitk::SerialCommunication::StopBits1),
m_HardwareHandshake(mitk::SerialCommunication::HardwareHandshakeOff),
m_IlluminationActivationRate(Hz20), m_DataTransferMode(TX), m_6DTools(), m_ToolsMutex(nullptr),
m_SerialCommunication(nullptr), m_SerialCommunicationMutex(nullptr), m_DeviceProtocol(nullptr),
m_MultiThreader(nullptr), m_ThreadID(0), m_OperationMode(ToolTracking6D), m_MarkerPointsMutex(nullptr), m_MarkerPoints()
{
m_Data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
m_6DTools.clear();
m_SerialCommunicationMutex = itk::FastMutexLock::New();
m_DeviceProtocol = NDIProtocol::New();
m_DeviceProtocol->SetTrackingDevice(this);
m_DeviceProtocol->UseCRCOn();
m_MultiThreader = itk::MultiThreader::New();
m_ToolsMutex = itk::FastMutexLock::New();
m_MarkerPointsMutex = itk::FastMutexLock::New();
m_MarkerPoints.reserve(50); // a maximum of 50 marker positions can be reported by the tracking device
}
bool mitk::NDITrackingDevice::UpdateTool(mitk::TrackingTool* tool)
{
if (this->GetState() != Setup)
{
mitk::NDIPassiveTool* ndiTool = dynamic_cast<mitk::NDIPassiveTool*>(tool);
if (ndiTool == nullptr)
return false;
std::string portHandle = ndiTool->GetPortHandle();
//return false if the SROM Data has not been set
if (ndiTool->GetSROMData() == nullptr)
return false;
NDIErrorCode returnvalue;
returnvalue = m_DeviceProtocol->PVWR(&portHandle, ndiTool->GetSROMData(), ndiTool->GetSROMDataLength());
if (returnvalue != NDIOKAY)
return false;
returnvalue = m_DeviceProtocol->PINIT(&portHandle);
if (returnvalue != NDIOKAY)
return false;
returnvalue = m_DeviceProtocol->PENA(&portHandle, ndiTool->GetTrackingPriority()); // Enable tool
if (returnvalue != NDIOKAY)
return false;
return true;
}
else
{
return false;
}
}
void mitk::NDITrackingDevice::SetRotationMode(RotationMode r)
{
m_RotationMode = r;
}
mitk::NDITrackingDevice::~NDITrackingDevice()
{
/* stop tracking and disconnect from tracking device */
if (GetState() == Tracking)
{
this->StopTracking();
}
if (GetState() == Ready)
{
this->CloseConnection();
}
/* cleanup tracking thread */
if ((m_ThreadID != 0) && (m_MultiThreader.IsNotNull()))
{
m_MultiThreader->TerminateThread(m_ThreadID);
}
m_MultiThreader = nullptr;
/* free serial communication interface */
if (m_SerialCommunication.IsNotNull())
{
m_SerialCommunication->ClearReceiveBuffer();
m_SerialCommunication->ClearSendBuffer();
m_SerialCommunication->CloseConnection();
m_SerialCommunication = nullptr;
}
}
void mitk::NDITrackingDevice::SetPortNumber(const PortNumber _arg)
{
if (this->GetState() != Setup)
return;
itkDebugMacro("setting PortNumber to " << _arg);
if (this->m_PortNumber != _arg)
{
this->m_PortNumber = _arg;
this->Modified();
}
}
void mitk::NDITrackingDevice::SetDeviceName(std::string _arg)
{
if (this->GetState() != Setup)
return;
itkDebugMacro("setting eviceName to " << _arg);
if (this->m_DeviceName != _arg)
{
this->m_DeviceName = _arg;
this->Modified();
}
}
void mitk::NDITrackingDevice::SetBaudRate(const BaudRate _arg)
{
if (this->GetState() != Setup)
return;
itkDebugMacro("setting BaudRate to " << _arg);
if (this->m_BaudRate != _arg)
{
this->m_BaudRate = _arg;
this->Modified();
}
}
void mitk::NDITrackingDevice::SetDataBits(const DataBits _arg)
{
if (this->GetState() != Setup)
return;
itkDebugMacro("setting DataBits to " << _arg);
if (this->m_DataBits != _arg)
{
this->m_DataBits = _arg;
this->Modified();
}
}
void mitk::NDITrackingDevice::SetParity(const Parity _arg)
{
if (this->GetState() != Setup)
return;
itkDebugMacro("setting Parity to " << _arg);
if (this->m_Parity != _arg)
{
this->m_Parity = _arg;
this->Modified();
}
}
void mitk::NDITrackingDevice::SetStopBits(const StopBits _arg)
{
if (this->GetState() != Setup)
return;
itkDebugMacro("setting StopBits to " << _arg);
if (this->m_StopBits != _arg)
{
this->m_StopBits = _arg;
this->Modified();
}
}
void mitk::NDITrackingDevice::SetHardwareHandshake(const HardwareHandshake _arg)
{
if (this->GetState() != Setup)
return;
itkDebugMacro("setting HardwareHandshake to " << _arg);
if (this->m_HardwareHandshake != _arg)
{
this->m_HardwareHandshake = _arg;
this->Modified();
}
}
void mitk::NDITrackingDevice::SetIlluminationActivationRate(const IlluminationActivationRate _arg)
{
if (this->GetState() == Tracking)
return;
itkDebugMacro("setting IlluminationActivationRate to " << _arg);
if (this->m_IlluminationActivationRate != _arg)
{
this->m_IlluminationActivationRate = _arg;
this->Modified();
if (this->GetState() == Ready) // if the connection to the tracking system is established, send the new rate to the tracking device too
m_DeviceProtocol->IRATE(this->m_IlluminationActivationRate);
}
}
void mitk::NDITrackingDevice::SetDataTransferMode(const DataTransferMode _arg)
{
itkDebugMacro("setting DataTransferMode to " << _arg);
if (this->m_DataTransferMode != _arg)
{
this->m_DataTransferMode = _arg;
this->Modified();
}
}
mitk::NDIErrorCode mitk::NDITrackingDevice::Send(const std::string* input, bool addCRC)
{
if (input == nullptr)
return SERIALSENDERROR;
std::string message;
if (addCRC == true)
message = *input + CalcCRC(input) + std::string(1, CR);
else
message = *input + std::string(1, CR);
//unsigned int messageLength = message.length() + 1; // +1 for CR
// Clear send buffer
this->ClearSendBuffer();
// Send the date to the device
MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
long returnvalue = m_SerialCommunication->Send(message);
if (returnvalue == 0)
return SERIALSENDERROR;
else
return NDIOKAY;
}
mitk::NDIErrorCode mitk::NDITrackingDevice::Receive(std::string* answer, unsigned int numberOfBytes)
{
if (answer == nullptr)
return SERIALRECEIVEERROR;
MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
long returnvalue = m_SerialCommunication->Receive(*answer, numberOfBytes); // never read more bytes than the device has send, the function will block until enough bytes are send...
if (returnvalue == 0)
return SERIALRECEIVEERROR;
else
return NDIOKAY;
}
mitk::NDIErrorCode mitk::NDITrackingDevice::ReceiveByte(char* answer)
{
if (answer == nullptr)
return SERIALRECEIVEERROR;
std::string m;
MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
long returnvalue = m_SerialCommunication->Receive(m, 1);
if ((returnvalue == 0) ||(m.size() != 1))
return SERIALRECEIVEERROR;
*answer = m.at(0);
return NDIOKAY;
}
mitk::NDIErrorCode mitk::NDITrackingDevice::ReceiveLine(std::string* answer)
{
if (answer == nullptr)
return SERIALRECEIVEERROR;
std::string m;
MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
do
{
long returnvalue = m_SerialCommunication->Receive(m, 1);
if ((returnvalue == 0) ||(m.size() != 1))
return SERIALRECEIVEERROR;
*answer += m;
} while (m.at(0) != LF);
return NDIOKAY;
}
void mitk::NDITrackingDevice::ClearSendBuffer()
{
MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
m_SerialCommunication->ClearSendBuffer();
}
void mitk::NDITrackingDevice::ClearReceiveBuffer()
{
MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
m_SerialCommunication->ClearReceiveBuffer();
}
const std::string mitk::NDITrackingDevice::CalcCRC(const std::string* input)
{
if (input == nullptr)
return "";
/* the crc16 calculation code is taken from the NDI API guide example code section */
static int oddparity[16] = {0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0};
unsigned int data; // copy of the input string's current character
unsigned int crcValue = 0; // the crc value is stored here
unsigned int* puCRC16 = &crcValue; // the algorithm uses a pointer to crcValue, so it's easier to provide that than to change the algorithm
for (unsigned int i = 0; i < input->length(); i++)
{
data = (*input)[i];
data = (data ^ (*(puCRC16) & 0xff)) & 0xff;
*puCRC16 >>= 8;
if (oddparity[data & 0x0f] ^ oddparity[data >> 4])
{
*(puCRC16) ^= 0xc001;
}
data <<= 6;
*puCRC16 ^= data;
data <<= 1;
*puCRC16 ^= data;
}
// crcValue contains now the CRC16 value. Convert it to a string and return it
char returnvalue[13];
sprintf(returnvalue,"%04X", crcValue); // 4 hexadecimal digit with uppercase format
return std::string(returnvalue);
}
bool mitk::NDITrackingDevice::OpenConnection()
{
//this->m_ModeMutex->Lock();
if (this->GetState() != Setup)
{mitkThrowException(mitk::IGTException) << "Can only try to open the connection if in setup mode";}
m_SerialCommunication = mitk::SerialCommunication::New();
/* init local com port to standard com settings for a NDI tracking device:
9600 baud, 8 data bits, no parity, 1 stop bit, no hardware handshake */
if (m_DeviceName.empty())
m_SerialCommunication->SetPortNumber(m_PortNumber);
else
m_SerialCommunication->SetDeviceName(m_DeviceName);
m_SerialCommunication->SetBaudRate(mitk::SerialCommunication::BaudRate9600);
m_SerialCommunication->SetDataBits(mitk::SerialCommunication::DataBits8);
m_SerialCommunication->SetParity(mitk::SerialCommunication::None);
m_SerialCommunication->SetStopBits(mitk::SerialCommunication::StopBits1);
m_SerialCommunication->SetSendTimeout(5000);
m_SerialCommunication->SetReceiveTimeout(5000);
if (m_SerialCommunication->OpenConnection() == 0) // 0 == ERROR_VALUE
{
m_SerialCommunication->CloseConnection();
m_SerialCommunication = nullptr;
mitkThrowException(mitk::IGTHardwareException) << "Can not open serial port";
}
/* Reset Tracking device by sending a serial break for 500ms */
m_SerialCommunication->SendBreak(400);
/* Read answer from tracking device (RESETBE6F) */
static const std::string reset("RESETBE6F\r");
std::string answer = "";
this->Receive(&answer, reset.length()); // read answer (should be RESETBE6F)
this->ClearReceiveBuffer(); // flush the receive buffer of all remaining data (carriage return, strings other than reset
if (reset.compare(answer) != 0) // check for RESETBE6F
{
if (m_SerialCommunication.IsNotNull())
{
m_SerialCommunication->CloseConnection();
m_SerialCommunication = nullptr;
}
mitkThrowException(mitk::IGTHardwareException) << "Hardware Reset of tracking device did not work";
}
/* Now the tracking device isSetData reset, start initialization */
NDIErrorCode returnvalue;
/* set device com settings to new values and wait for the device to change them */
returnvalue = m_DeviceProtocol->COMM(m_BaudRate, m_DataBits, m_Parity, m_StopBits, m_HardwareHandshake);
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << "Could not set comm settings in trackingdevice";}
//after changing COMM wait at least 100ms according to NDI Api documentation page 31
itksys::SystemTools::Delay(500);
/* now change local com settings accordingly */
m_SerialCommunication->CloseConnection();
m_SerialCommunication->SetBaudRate(m_BaudRate);
m_SerialCommunication->SetDataBits(m_DataBits);
m_SerialCommunication->SetParity(m_Parity);
m_SerialCommunication->SetStopBits(m_StopBits);
m_SerialCommunication->SetHardwareHandshake(m_HardwareHandshake);
m_SerialCommunication->SetSendTimeout(5000);
m_SerialCommunication->SetReceiveTimeout(5000);
m_SerialCommunication->OpenConnection();
/* initialize the tracking device */
returnvalue = m_DeviceProtocol->INIT();
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << "Could not initialize the tracking device";}
if (this->GetType() == mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName()) // if the type of tracking device is not specified, try to query the connected device
{
mitk::TrackingDeviceType deviceType;
returnvalue = m_DeviceProtocol->VER(deviceType);
if ((returnvalue != NDIOKAY) || (deviceType == mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName()))
{mitkThrowException(mitk::IGTHardwareException) << "Could not determine tracking device type. Please set manually and try again.";}
this->SetType(deviceType);
}
/**** Optional Polaris specific code, Work in progress
// start diagnostic mode
returnvalue = m_DeviceProtocol->DSTART();
if (returnvalue != NDIOKAY)
{
this->SetErrorMessage("Could not start diagnostic mode");
return false;
}
else // we are in diagnostic mode
{
// initialize extensive IR checking
returnvalue = m_DeviceProtocol->IRINIT();
if (returnvalue != NDIOKAY)
{
this->SetErrorMessage("Could not initialize intense infrared light checking");
return false;
}
bool intenseIR = false;
returnvalue = m_DeviceProtocol->IRCHK(&intenseIR);
if (returnvalue != NDIOKAY)
{
this->SetErrorMessage("Could not execute intense infrared light checking");
return false;
}
if (intenseIR == true)
// do something - warn the user, raise exception, write to protocol or similar
std::cout << "Warning: Intense infrared light detected. Accurate tracking will probably not be possible.\n";
// stop diagnictic mode
returnvalue = m_DeviceProtocol->DSTOP();
if (returnvalue != NDIOKAY)
{
this->SetErrorMessage("Could not stop diagnostic mode");
return false;
}
}
*** end of optional polaris code ***/
/**
* now add tools to the tracking system
**/
/* First, check if the tracking device has port handles that need to be freed and free them */
returnvalue = FreePortHandles();
// non-critical, therefore no error handling
/**
* POLARIS: initialize the tools that were added manually
**/
{
MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
std::string portHandle;
auto endIt = m_6DTools.end();
for(auto it = m_6DTools.begin(); it != endIt; ++it)
{
/* get a port handle for the tool */
returnvalue = m_DeviceProtocol->PHRQ(&portHandle);
if (returnvalue == NDIOKAY)
{
(*it)->SetPortHandle(portHandle.c_str());
/* now write the SROM file of the tool to the tracking system using PVWR */
if (this->m_Data.Line == mitk::NDIPolarisTypeInformation::GetTrackingDeviceName())
{
returnvalue = m_DeviceProtocol->PVWR(&portHandle, (*it)->GetSROMData(), (*it)->GetSROMDataLength());
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not write SROM file for tool '") + (*it)->GetToolName() + std::string("' to tracking device")).c_str();}
returnvalue = m_DeviceProtocol->PINIT(&portHandle);
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not initialize tool '") + (*it)->GetToolName()).c_str();}
if ((*it)->IsEnabled() == true)
{
returnvalue = m_DeviceProtocol->PENA(&portHandle, (*it)->GetTrackingPriority()); // Enable tool
if (returnvalue != NDIOKAY)
{
mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not enable port '") + portHandle +
std::string("' for tool '")+ (*it)->GetToolName() + std::string("'")).c_str();
}
}
}
}
}
} // end of toolsmutexlockholder scope
/* check for wired tools and add them too */
if (this->DiscoverWiredTools() == false) // query the tracking device for wired tools and add them to our tool list
return false; // \TODO: could we continue anyways?
/*POLARIS: set the illuminator activation rate */
if (this->m_Data.Line == mitk::NDIPolarisTypeInformation::GetTrackingDeviceName())
{
returnvalue = m_DeviceProtocol->IRATE(this->m_IlluminationActivationRate);
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << "Could not set the illuminator activation rate";}
}
/* finish - now all tools should be added, initialized and enabled, so that tracking can be started */
this->SetState(Ready);
try
{
SetVolume(this->m_Data);
}
catch (mitk::IGTHardwareException e)
{
MITK_WARN<<e.GetDescription();
}
return true;
}
bool mitk::NDITrackingDevice::InitializeWiredTools()
{
NDIErrorCode returnvalue;
std::string portHandle;
returnvalue = m_DeviceProtocol->PHSR(OCCUPIED, &portHandle);
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << "Could not obtain a list of port handles that are connected";}
/* if there are port handles that need to be initialized, initialize them. Furthermore instantiate tools for each handle that has no tool yet. */
std::string ph;
for (unsigned int i = 0; i < portHandle.size(); i += 2)
{
ph = portHandle.substr(i, 2);
mitk::NDIPassiveTool* pt = this->GetInternalTool(ph);
if ( pt == nullptr) // if we don't have a tool, something is wrong. Tools should be discovered first by calling DiscoverWiredTools()
continue;
if (pt->GetSROMData() == nullptr)
continue;
returnvalue = m_DeviceProtocol->PVWR(&ph, pt->GetSROMData(), pt->GetSROMDataLength());
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not write SROM file for tool '") + pt->GetToolName() + std::string("' to tracking device")).c_str();}
returnvalue = m_DeviceProtocol->PINIT(&ph);
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not initialize tool '") + pt->GetToolName()).c_str();}
if (pt->IsEnabled() == true)
{
returnvalue = m_DeviceProtocol->PENA(&ph, pt->GetTrackingPriority()); // Enable tool
if (returnvalue != NDIOKAY)
{
mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not enable port '") + portHandle +
std::string("' for tool '")+ pt->GetToolName() + std::string("'")).c_str();
}
}
}
return true;
}
mitk::TrackingDeviceType mitk::NDITrackingDevice::TestConnection()
{
if (this->GetState() != Setup)
{
return mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
}
m_SerialCommunication = mitk::SerialCommunication::New();
//m_DeviceProtocol = mitk::NDIProtocol::New();
//m_DeviceProtocol->SetTrackingDevice(this);
//m_DeviceProtocol->UseCRCOn();
/* init local com port to standard com settings for a NDI tracking device:
9600 baud, 8 data bits, no parity, 1 stop bit, no hardware handshake
*/
if (m_DeviceName.empty())
m_SerialCommunication->SetPortNumber(m_PortNumber);
else
m_SerialCommunication->SetDeviceName(m_DeviceName);
m_SerialCommunication->SetBaudRate(mitk::SerialCommunication::BaudRate9600);
m_SerialCommunication->SetDataBits(mitk::SerialCommunication::DataBits8);
m_SerialCommunication->SetParity(mitk::SerialCommunication::None);
m_SerialCommunication->SetStopBits(mitk::SerialCommunication::StopBits1);
m_SerialCommunication->SetSendTimeout(5000);
m_SerialCommunication->SetReceiveTimeout(5000);
if (m_SerialCommunication->OpenConnection() == 0) // error
{
m_SerialCommunication = nullptr;
return mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
}
/* Reset Tracking device by sending a serial break for 500ms */
m_SerialCommunication->SendBreak(400);
/* Read answer from tracking device (RESETBE6F) */
static const std::string reset("RESETBE6F\r");
std::string answer = "";
this->Receive(&answer, reset.length()); // read answer (should be RESETBE6F)
this->ClearReceiveBuffer(); // flush the receive buffer of all remaining data (carriage return, strings other than reset
if (reset.compare(answer) != 0) // check for RESETBE6F
{
m_SerialCommunication->CloseConnection();
m_SerialCommunication = nullptr;
mitkThrowException(mitk::IGTHardwareException) << "Hardware Reset of tracking device did not work";
}
/* Now the tracking device is reset, start initialization */
NDIErrorCode returnvalue;
/* initialize the tracking device */
//returnvalue = m_DeviceProtocol->INIT();
//if (returnvalue != NDIOKAY)
//{
// this->SetErrorMessage("Could not initialize the tracking device");
// return mitk::TrackingSystemNotSpecified;
//}
mitk::TrackingDeviceType deviceType;
returnvalue = m_DeviceProtocol->VER(deviceType);
if ((returnvalue != NDIOKAY) || (deviceType == mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName()))
{
m_SerialCommunication = nullptr;
return mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
}
m_SerialCommunication = nullptr;
return deviceType;
}
bool mitk::NDITrackingDevice::CloseConnection()
{
if (this->GetState() != Setup)
{
//init before closing to force the field generator from aurora to switch itself off
m_DeviceProtocol->INIT();
/* close the serial connection */
m_SerialCommunication->CloseConnection();
/* invalidate all tools */
this->InvalidateAll();
/* return to setup mode */
this->SetState(Setup);
m_SerialCommunication = nullptr;
}
return true;
}
ITK_THREAD_RETURN_TYPE mitk::NDITrackingDevice::ThreadStartTracking(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
NDITrackingDevice *trackingDevice = (NDITrackingDevice*)pInfo->UserData;
if (trackingDevice != nullptr)
{
if (trackingDevice->GetOperationMode() == ToolTracking6D)
trackingDevice->TrackTools(); // call TrackTools() from the original object
else if (trackingDevice->GetOperationMode() == MarkerTracking3D)
trackingDevice->TrackMarkerPositions(); // call TrackMarkerPositions() from the original object
else if (trackingDevice->GetOperationMode() == ToolTracking5D)
trackingDevice->TrackMarkerPositions(); // call TrackMarkerPositions() from the original object
else if (trackingDevice->GetOperationMode() == HybridTracking)
{
trackingDevice->TrackToolsAndMarkers();
}
}
trackingDevice->m_ThreadID = 0; // erase thread id, now that this thread will end.
return ITK_THREAD_RETURN_VALUE;
}
bool mitk::NDITrackingDevice::StartTracking()
{
if (this->GetState() != Ready)
return false;
this->SetState(Tracking); // go to mode Tracking
this->m_StopTrackingMutex->Lock(); // update the local copy of m_StopTracking
this->m_StopTracking = false;
this->m_StopTrackingMutex->Unlock();
m_ThreadID = m_MultiThreader->SpawnThread(this->ThreadStartTracking, this); // start a new thread that executes the TrackTools() method
mitk::IGTTimeStamp::GetInstance()->Start(this);
return true;
}
void mitk::NDITrackingDevice::TrackTools()
{
/* lock the TrackingFinishedMutex to signal that the execution rights are now transfered to the tracking thread */
MutexLockHolder trackingFinishedLockHolder(*m_TrackingFinishedMutex); // keep lock until end of scope
if (this->GetState() != Tracking)
return;
NDIErrorCode returnvalue;
returnvalue = m_DeviceProtocol->TSTART();
if (returnvalue != NDIOKAY)
return;
bool localStopTracking; // Because m_StopTracking is used by two threads, access has to be guarded by a mutex. To minimize thread locking, a local copy is used here
this->m_StopTrackingMutex->Lock(); // update the local copy of m_StopTracking
localStopTracking = this->m_StopTracking;
this->m_StopTrackingMutex->Unlock();
while ((this->GetState() == Tracking) && (localStopTracking == false))
{
if (this->m_DataTransferMode == TX)
{
returnvalue = this->m_DeviceProtocol->TX();
if (!((returnvalue == NDIOKAY) || (returnvalue == NDICRCERROR) || (returnvalue == NDICRCDOESNOTMATCH))) // right now, do not stop on crc errors
break;
}
else
{
returnvalue = this->m_DeviceProtocol->BX();
if (returnvalue != NDIOKAY)
break;
}
/* Update the local copy of m_StopTracking */
this->m_StopTrackingMutex->Lock();
localStopTracking = m_StopTracking;
this->m_StopTrackingMutex->Unlock();
}
/* StopTracking was called, thus the mode should be changed back to Ready now that the tracking loop has ended. */
returnvalue = m_DeviceProtocol->TSTOP();
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << "An error occured while tracking tools.";}
return; // returning from this function (and ThreadStartTracking()) this will end the thread and transfer control back to main thread by releasing trackingFinishedLockHolder
}
void mitk::NDITrackingDevice::TrackMarkerPositions()
{
MutexLockHolder trackingFinishedLockHolder(*m_TrackingFinishedMutex); // keep lock until end of scope
if (m_OperationMode == ToolTracking6D)
return;
if (this->GetState() != Tracking)
return;
NDIErrorCode returnvalue;
returnvalue = m_DeviceProtocol->DSTART(); // Start Diagnostic Mode
if (returnvalue != NDIOKAY)
return;
bool localStopTracking; // Because m_StopTracking is used by two threads, access has to be guarded by a mutex. To minimize thread locking, a local copy is used here
this->m_StopTrackingMutex->Lock(); // update the local copy of m_StopTracking
localStopTracking = this->m_StopTracking;
this->m_StopTrackingMutex->Unlock();
while ((this->GetState() == Tracking) && (localStopTracking == false))
{
m_MarkerPointsMutex->Lock(); // lock points data structure
returnvalue = this->m_DeviceProtocol->POS3D(&m_MarkerPoints); // update points data structure with new position data from tracking device
m_MarkerPointsMutex->Unlock();
if (!((returnvalue == NDIOKAY) || (returnvalue == NDICRCERROR) || (returnvalue == NDICRCDOESNOTMATCH))) // right now, do not stop on crc errors
{
std::cout << "Error in POS3D: could not read data. Possibly no markers present." << std::endl;
}
/* Update the local copy of m_StopTracking */
this->m_StopTrackingMutex->Lock();
localStopTracking = m_StopTracking;
this->m_StopTrackingMutex->Unlock();
itksys::SystemTools::Delay(1);
}
/* StopTracking was called, thus the mode should be changed back to Ready now that the tracking loop has ended. */
returnvalue = m_DeviceProtocol->DSTOP();
if (returnvalue != NDIOKAY)
return; // how can this thread tell the application, that an error has occured?
this->SetState(Ready);
return; // returning from this function (and ThreadStartTracking()) this will end the thread
}
void mitk::NDITrackingDevice::TrackToolsAndMarkers()
{
MutexLockHolder trackingFinishedLockHolder(*m_TrackingFinishedMutex); // keep lock until end of scope
if (m_OperationMode != HybridTracking)
return;
NDIErrorCode returnvalue;
returnvalue = m_DeviceProtocol->TSTART(); // Start Diagnostic Mode
if (returnvalue != NDIOKAY)
return;
bool localStopTracking; // Because m_StopTracking is used by two threads, access has to be guarded by a mutex. To minimize thread locking, a local copy is used here
this->m_StopTrackingMutex->Lock(); // update the local copy of m_StopTracking
localStopTracking = this->m_StopTracking;
this->m_StopTrackingMutex->Unlock();
while ((this->GetState() == Tracking) && (localStopTracking == false))
{
m_MarkerPointsMutex->Lock(); // lock points data structure
returnvalue = this->m_DeviceProtocol->TX(true, &m_MarkerPoints); // update points data structure with new position data from tracking device
m_MarkerPointsMutex->Unlock();
if (!((returnvalue == NDIOKAY) || (returnvalue == NDICRCERROR) || (returnvalue == NDICRCDOESNOTMATCH))) // right now, do not stop on crc errors
{
std::cout << "Error in TX: could not read data. Possibly no markers present." << std::endl;
}
/* Update the local copy of m_StopTracking */
this->m_StopTrackingMutex->Lock();
localStopTracking = m_StopTracking;
this->m_StopTrackingMutex->Unlock();
}
/* StopTracking was called, thus the mode should be changed back to Ready now that the tracking loop has ended. */
returnvalue = m_DeviceProtocol->TSTOP();
if (returnvalue != NDIOKAY)
return; // how can this thread tell the application, that an error has occurred?
this->SetState(Ready);
return; // returning from this function (and ThreadStartTracking()) this will end the thread
}
mitk::TrackingTool* mitk::NDITrackingDevice::GetTool(unsigned int toolNumber) const
{
MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
if (toolNumber < m_6DTools.size())
return m_6DTools.at(toolNumber);
return nullptr;
}
mitk::TrackingTool* mitk::NDITrackingDevice::GetToolByName(std::string name) const
{
MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
auto end = m_6DTools.end();
for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
if (name.compare((*iterator)->GetToolName()) == 0)
return *iterator;
return nullptr;
}
mitk::NDIPassiveTool* mitk::NDITrackingDevice::GetInternalTool(std::string portHandle)
{
MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
auto end = m_6DTools.end();
for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
if (portHandle.compare((*iterator)->GetPortHandle()) == 0)
return *iterator;
return nullptr;
}
unsigned int mitk::NDITrackingDevice::GetToolCount() const
{
MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
return m_6DTools.size();
}
bool mitk::NDITrackingDevice::Beep(unsigned char count)
{
if (this->GetState() != Setup)
{
return (m_DeviceProtocol->BEEP(count) == NDIOKAY);
}
else
{
return false;
}
}
mitk::TrackingTool* mitk::NDITrackingDevice::AddTool( const char* toolName, const char* fileName, TrackingPriority p /*= NDIPassiveTool::Dynamic*/ )
{
mitk::NDIPassiveTool::Pointer t = mitk::NDIPassiveTool::New();
if (t->LoadSROMFile(fileName) == false)
return nullptr;
t->SetToolName(toolName);
t->SetTrackingPriority(p);
if (this->InternalAddTool(t) == false)
return nullptr;
return t.GetPointer();
}
bool mitk::NDITrackingDevice::InternalAddTool(mitk::NDIPassiveTool* tool)
{
if (tool == nullptr)
return false;
NDIPassiveTool::Pointer p = tool;
/* if the connection to the tracking device is already established, add the new tool to the device now */
if (this->GetState() == Ready)
{
/* get a port handle for the tool */
std::string newPortHandle;
NDIErrorCode returnvalue;
returnvalue = m_DeviceProtocol->PHRQ(&newPortHandle);
if (returnvalue == NDIOKAY)
{
p->SetPortHandle(newPortHandle.c_str());
/* now write the SROM file of the tool to the tracking system using PVWR */
returnvalue = m_DeviceProtocol->PVWR(&newPortHandle, p->GetSROMData(), p->GetSROMDataLength());
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not write SROM file for tool '") + p->GetToolName() + std::string("' to tracking device")).c_str();}
/* initialize the port handle */
returnvalue = m_DeviceProtocol->PINIT(&newPortHandle);
if (returnvalue != NDIOKAY)
{
mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not initialize port '") + newPortHandle +
std::string("' for tool '")+ p->GetToolName() + std::string("'")).c_str();
}
/* enable the port handle */
if (p->IsEnabled() == true)
{
returnvalue = m_DeviceProtocol->PENA(&newPortHandle, p->GetTrackingPriority()); // Enable tool
if (returnvalue != NDIOKAY)
{
mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not enable port '") + newPortHandle +
std::string("' for tool '")+ p->GetToolName() + std::string("'")).c_str();
}
}
}
/* now that the tool is added to the device, add it to list too */
m_ToolsMutex->Lock();
this->m_6DTools.push_back(p);
m_ToolsMutex->Unlock();
this->Modified();
return true;
}
else if (this->GetState() == Setup)
{
/* In Setup mode, we only add it to the list, so that OpenConnection() can add it later */
m_ToolsMutex->Lock();
this->m_6DTools.push_back(p);
m_ToolsMutex->Unlock();
this->Modified();
return true;
}
else // in Tracking mode, no tools can be added
return false;
}
bool mitk::NDITrackingDevice::RemoveTool(mitk::TrackingTool* tool)
{
mitk::NDIPassiveTool* ndiTool = dynamic_cast<mitk::NDIPassiveTool*>(tool);
if (ndiTool == nullptr)
return false;
std::string portHandle = ndiTool->GetPortHandle();
/* a valid portHandle has length 2. If a valid handle exists, the tool is already added to the tracking device, so we have to remove it there
if the connection to the tracking device has already been established.
*/
if ((portHandle.length() == 2) && (this->GetState() == Ready)) // do not remove a tool in tracking mode
{
NDIErrorCode returnvalue;
returnvalue = m_DeviceProtocol->PHF(&portHandle);
if (returnvalue != NDIOKAY)
return false;
/* Now that the tool is removed from the tracking device, remove it from our tool list too */
MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex (scope is inside the if-block
auto end = m_6DTools.end();
for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
{
if (iterator->GetPointer() == ndiTool)
{
m_6DTools.erase(iterator);
this->Modified();
return true;
}
}
return false;
}
else if (this->GetState() == Setup) // in Setup Mode, we are not connected to the tracking device, so we can just remove the tool from the tool list
{
MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
auto end = m_6DTools.end();
for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
{
if ((*iterator).GetPointer() == ndiTool)
{
m_6DTools.erase(iterator);
this->Modified();
return true;
}
}
return false;
}
return false;
}
void mitk::NDITrackingDevice::InvalidateAll()
{
MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
auto end = m_6DTools.end();
for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
(*iterator)->SetDataValid(false);
}
bool mitk::NDITrackingDevice::SetOperationMode(OperationMode mode)
{
if (GetState() == Tracking)
return false;
m_OperationMode = mode;
return true;
}
mitk::OperationMode mitk::NDITrackingDevice::GetOperationMode()
{
return m_OperationMode;
}
bool mitk::NDITrackingDevice::GetMarkerPositions(MarkerPointContainerType* markerpositions)
{
m_MarkerPointsMutex->Lock();
*markerpositions = m_MarkerPoints; // copy the internal vector to the one provided
m_MarkerPointsMutex->Unlock();
return (markerpositions->size() != 0) ;
}
bool mitk::NDITrackingDevice::DiscoverWiredTools()
{
/* First, check for disconnected tools and remove them */
this->FreePortHandles();
/* check for new tools, add and initialize them */
NDIErrorCode returnvalue;
std::string portHandle;
returnvalue = m_DeviceProtocol->PHSR(OCCUPIED, &portHandle);
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << "Could not obtain a list of port handles that are connected";}
/* if there are port handles that need to be initialized, initialize them. Furthermore instantiate tools for each handle that has no tool yet. */
std::string ph;
/* we need to remember the ports which are occupied to be able to readout the serial numbers of the connected tools later */
std::vector<int> occupiedPorts = std::vector<int>();
int numberOfToolsAtStart = this->GetToolCount(); //also remember the number of tools at start to identify the automatically detected tools later
for (unsigned int i = 0; i < portHandle.size(); i += 2)
{
ph = portHandle.substr(i, 2);
if (this->GetInternalTool(ph) != nullptr) // if we already have a tool with this handle
continue; // then skip the initialization
//instantiate an object for each tool that is connected
mitk::NDIPassiveTool::Pointer newTool = mitk::NDIPassiveTool::New();
newTool->SetPortHandle(ph.c_str());
newTool->SetTrackingPriority(mitk::NDIPassiveTool::Dynamic);
//set a name for identification
newTool->SetToolName((std::string("Port ") + ph).c_str());
returnvalue = m_DeviceProtocol->PINIT(&ph);
if (returnvalue != NDIINITIALIZATIONFAILED) //if the initialization failed (AURORA) it can not be enabled. A srom file will have to be specified manually first. Still return true to be able to continue
{
if (returnvalue != NDIOKAY)
{
mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not initialize port '") + ph +
std::string("' for tool '")+ newTool->GetToolName() + std::string("'")).c_str();
}
/* enable the port handle */
returnvalue = m_DeviceProtocol->PENA(&ph, newTool->GetTrackingPriority()); // Enable tool
if (returnvalue != NDIOKAY)
{
mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not enable port '") + ph +
std::string("' for tool '")+ newTool->GetToolName() + std::string("'")).c_str();
}
}
//we have to temporarily unlock m_ModeMutex here to avoid a deadlock with another lock inside InternalAddTool()
if (this->InternalAddTool(newTool) == false)
{mitkThrowException(mitk::IGTException) << "Error while adding new tool";}
else occupiedPorts.push_back(i);
}
// after initialization readout serial numbers of automatically detected tools
for (unsigned int i = 0; i < occupiedPorts.size(); i++)
{
ph = portHandle.substr(occupiedPorts.at(i), 2);
std::string portInfo;
NDIErrorCode returnvaluePort = m_DeviceProtocol->PHINF(ph, &portInfo);
if ((returnvaluePort==NDIOKAY) && (portInfo.size()>31)) dynamic_cast<mitk::NDIPassiveTool*>(this->GetTool(i+numberOfToolsAtStart))->SetSerialNumber(portInfo.substr(23,8));
itksys::SystemTools::Delay(10);
}
return true;
}
mitk::NDIErrorCode mitk::NDITrackingDevice::FreePortHandles()
{
/* first search for port handles that need to be freed: e.g. because of a reset of the tracking system */
NDIErrorCode returnvalue = NDIOKAY;
std::string portHandle;
returnvalue = m_DeviceProtocol->PHSR(FREED, &portHandle);
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << "Could not obtain a list of port handles that need to be freed";}
/* if there are port handles that need to be freed, free them */
if (portHandle.empty() == true)
return returnvalue;
std::string ph;
for (unsigned int i = 0; i < portHandle.size(); i += 2)
{
ph = portHandle.substr(i, 2);
mitk::NDIPassiveTool* t = this->GetInternalTool(ph);
if (t != nullptr) // if we have a tool for the port handle that needs to be freed
{
if (this->RemoveTool(t) == false) // remove it (this will free the port too)
returnvalue = NDIERROR;
}
else // we don't have a tool, the port handle exists only in the tracking device
{
returnvalue = m_DeviceProtocol->PHF(&ph); // free it there
// What to do if port handle could not be freed? This seems to be a non critical error
if (returnvalue != NDIOKAY)
{mitkThrowException(mitk::IGTHardwareException) << "Could not free all port handles";}
}
}
return returnvalue;
}
int mitk::NDITrackingDevice::GetMajorFirmwareRevisionNumber()
{
std::string revision;
if (m_DeviceProtocol->APIREV(&revision) != mitk::NDIOKAY || revision.empty() || (revision.size() != 9) )
{
MITK_ERROR << "Could not receive firmware revision number!";
return 0;
}
const std::string majrevno = revision.substr(2,3); //cut out "004" from "D.004.001"
return std::atoi(majrevno.c_str());
}
const char* mitk::NDITrackingDevice::GetFirmwareRevisionNumber()
{
static std::string revision;
if (m_DeviceProtocol->APIREV(&revision) != mitk::NDIOKAY || revision.empty() || (revision.size() != 9) )
{
MITK_ERROR << "Could not receive firmware revision number!";
revision = "";
return revision.c_str();
}
return revision.c_str();
}
+bool mitk::NDITrackingDevice::AutoDetectToolsAvailable()
+{
+ if (this->GetType() == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) { return true; }
+ else { return false; }
+}
+
+mitk::NavigationToolStorage::Pointer mitk::NDITrackingDevice::AutoDetectTools()
+{
+ mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New();
+ if (this->GetType() == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName())
+ {
+ try
+ {
+ this->OpenConnection();
+ this->StartTracking();
+ }
+ catch (mitk::Exception& e)
+ {
+ MITK_WARN << "Warning, can not auto-detect tools! (" << e.GetDescription() << ")";
+ return autoDetectedStorage;
+ }
+
+ for (unsigned int i = 0; i < this->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*>(this->GetTool(i))->GetSerialNumber());
+ newTool->SetIdentifier(toolname.str());
+ newTool->SetTrackingDeviceType(mitk::NDIAuroraTypeInformation::GetTrackingDeviceName());
+ 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);
+ }
+ this->StopTracking();
+ this->CloseConnection();
+ }
+ return autoDetectedStorage;
+}
+
bool mitk::NDITrackingDevice::GetSupportedVolumes(unsigned int* numberOfVolumes, mitk::NDITrackingDevice::NDITrackingVolumeContainerType* volumes, mitk::NDITrackingDevice::TrackingVolumeDimensionType* volumesDimensions)
{
if (numberOfVolumes == nullptr || volumes == nullptr || volumesDimensions == nullptr)
return false;
static std::string info;
if (m_DeviceProtocol->SFLIST(&info) != mitk::NDIOKAY || info.empty())
{
MITK_ERROR << "Could not receive tracking volume information of tracking system!";
return false;
}
/*info contains the following:
<HEX:number of volumes> (+n times:) <HEX:shape type> <shape parameters D1-D10> <HEX:reserved / number of wavelength supported> <metal resistant / supported wavelength>
*/
(*numberOfVolumes) = (unsigned int) std::atoi(info.substr(0,1).c_str());
for (unsigned int i=0; i<(*numberOfVolumes); i++)
{
//e.g. for cube: "9-025000+025000-025000+025000-055000-005000+000000+000000+000000+00000011"
//for dome: "A+005000+048000+005000+066000+000000+000000+000000+000000+000000+00000011"
std::string::size_type offset, end;
offset = (i*73)+1;
end = 73+(i*73);
std::string currentVolume = info.substr(offset, end);//i=0: from 1 to 73 characters; i=1: from 75 to 148 char;
// if i>0 then we have a return statement <LF> infront
if (i>0)
currentVolume = currentVolume.substr(1, currentVolume.size());
if (currentVolume.compare(0, 1, NDIPolarisTypeInformation::GetDeviceDataPolarisOldModel().HardwareCode) == 0)
volumes->push_back(NDIPolarisTypeInformation::GetDeviceDataPolarisOldModel().Model);
if (currentVolume.compare(0, 3, NDIPolarisTypeInformation::GetDeviceDataPolarisSpectra().HardwareCode) == 0)
volumes->push_back(NDIPolarisTypeInformation::GetDeviceDataPolarisSpectra().Model);
if (currentVolume.compare(1, 3, NDIPolarisTypeInformation::GetDeviceDataSpectraExtendedPyramid().HardwareCode) == 0)
{
currentVolume = currentVolume.substr(1,currentVolume.size());
volumes->push_back(NDIPolarisTypeInformation::GetDeviceDataSpectraExtendedPyramid().Model);
}
if (currentVolume.compare(0, 1, NDIPolarisTypeInformation::GetDeviceDataPolarisVicra().HardwareCode) == 0)
volumes->push_back(NDIPolarisTypeInformation::GetDeviceDataPolarisVicra().Model);
else if (currentVolume.compare(0, 1, mitk::NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarCube().HardwareCode) == 0)
volumes->push_back(mitk::NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarCube().Model);//alias cube
else if (currentVolume.compare(0, 1, mitk::NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarDome().HardwareCode) == 0)
volumes->push_back(mitk::NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarDome().Model);
//fill volumesDimensions
for (unsigned int index = 0; index < 10; index++)
{
std::string::size_type offD, endD;
offD = 1+(index*7); //7 digits per dimension and the first is the type of volume
endD = offD+7;
int dimension = std::atoi(currentVolume.substr(offD, endD).c_str());
dimension /= 100; //given in mm. 7 digits are xxxx.xx according to NDI //strange, the last two digits (11) also for the metal flag get read also...
volumesDimensions->push_back(dimension);
}
}
return true;
}
bool mitk::NDITrackingDevice::SetVolume(mitk::TrackingDeviceData volume)
{
if (m_DeviceProtocol->VSEL(volume) != mitk::NDIOKAY)
{
mitkThrowException(mitk::IGTHardwareException) << "Could not set volume!";
}
return true;
}
diff --git a/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.h b/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.h
index ce05dd0425..5c2a47cc90 100644
--- a/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.h
+++ b/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.h
@@ -1,324 +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.
===================================================================*/
#ifndef MITKNDITRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2
#define MITKNDITRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2
#include "mitkTrackingDevice.h"
#include <MitkIGTExports.h>
#include <itkMultiThreader.h>
#include "itkFastMutexLock.h"
#include <vector>
#include "mitkNDIProtocol.h"
#include "mitkNDIPassiveTool.h"
#include "mitkSerialCommunication.h"
namespace mitk
{
class NDIProtocol;
/** Documentation
* \brief superclass for specific NDI tracking Devices that use serial communication.
*
* implements the TrackingDevice interface for NDI tracking devices (POLARIS, AURORA)
*
* \ingroup IGT
*/
class MITKIGT_EXPORT NDITrackingDevice : public TrackingDevice
{
friend class NDIProtocol;
public:
typedef std::vector<NDIPassiveTool::Pointer> Tool6DContainerType; ///< List of 6D tools of the correct type for this tracking device
typedef mitk::TrackingDeviceType NDITrackingDeviceType; ///< This enumeration includes the two types of NDI tracking devices (Polaris, Aurora).
typedef mitk::SerialCommunication::PortNumber PortNumber; ///< Port number of the serial connection
typedef mitk::SerialCommunication::BaudRate BaudRate; ///< Baud rate of the serial connection
typedef mitk::SerialCommunication::DataBits DataBits; ///< Number of data bits used in the serial connection
typedef mitk::SerialCommunication::Parity Parity; ///< Parity mode used in the serial connection
typedef mitk::SerialCommunication::StopBits StopBits; ///< Number of stop bits used in the serial connection
typedef mitk::SerialCommunication::HardwareHandshake HardwareHandshake; ///< Hardware handshake mode of the serial connection
typedef mitk::NDIPassiveTool::TrackingPriority TrackingPriority; ///< Tracking priority used for tracking a tool
mitkClassMacro(NDITrackingDevice, TrackingDevice);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/**
* \brief Set the type of the NDI Tracking Device because it can not jet handle this itself
*/
//itkSetMacro(Type, TrackingDeviceType);
/**
* \brief initialize the connection to the tracking device
*
* OpenConnection() establishes the connection to the tracking device by:
* - initializing the serial port with the given parameters (port number, baud rate, ...)
* - connection to the tracking device
* - initializing the device
* - initializing all manually added passive tools (user supplied srom file)
* - initializing active tools that are connected to the tracking device
* @throw mitk::IGTHardwareException Throws an exception if there are errors while connecting to the device.
* @throw mitk::IGTException Throws a normal IGT exception if an error occures which is not related to the hardware.
*/
virtual bool OpenConnection() override;
/**
* \brief Closes the connection
*
* CloseConnection() resets the tracking device, invalidates all tools and then closes the serial port.
*/
virtual bool CloseConnection() override;
/** @throw mitk::IGTHardwareException Throws an exception if there are errors while connecting to the device. */
bool InitializeWiredTools();
/** Sets the rotation mode of this class. See documentation of enum RotationMode for details
* on the different modes.
*/
virtual void SetRotationMode(RotationMode r) override;
/**
* \brief TestConnection() tries to connect to a NDI tracking device on the current port/device and returns which device it has found
*
* TestConnection() tries to connect to a NDI tracking device on the current port/device.
* \return It returns the type of the device that answers at the port/device. Throws an exception if no device is available on that port.
* @throw mitk::IGTHardwareException Throws an exception if there are errors while connecting to the device.
*/
virtual mitk::TrackingDeviceType TestConnection();
/**
* \brief retrieves all wired tools from the tracking device
*
* This method queries the tracking device for all wired tools, initializes them and creates TrackingTool representation objects
* for them
* \return True if the method was executed successful.
* @throw mitk::IGTHardwareException Throws an exception if there are errors while connecting to the device.
* @throw mitk::IGTException Throws a normal IGT exception if an error occures which is not related to the hardware.
*/
bool DiscoverWiredTools();
/**
* \brief Start the tracking.
*
* A new thread is created, which continuously reads the position and orientation information of each tool and stores them inside the tools.
* Depending on the current operation mode (see SetOperationMode()), either the 6D tools (ToolTracking6D), 5D tools (ToolTracking5D),
* 3D marker positions (MarkerTracking3D) or both 6D tools and 3D markers (HybridTracking) are updated.
* Call StopTracking() to stop the tracking thread.
*/
virtual bool StartTracking() override;
/**
* \brief return the tool with index toolNumber
*/
virtual TrackingTool* GetTool(unsigned int toolNumber) const override;
virtual mitk::TrackingTool* GetToolByName(std::string name) const override;
/**
* \brief return current number of tools
*/
virtual unsigned int GetToolCount() const override;
/**
* \brief Create a passive 6D tool with toolName and fileName and add it to the list of tools
*
* This method will create a new NDIPassiveTool object, load the SROM file fileName,
* set the tool name toolName and the tracking priority p and then add
* it to the list of tools. It returns a pointer of type mitk::TrackingTool to the tool
* that can be used to read tracking data from it.
* This is the only way to add tools to NDITrackingDevice.
* @throw mitk::IGTHardwareException Throws an exception if there are errors while adding the tool.
*
* \warning adding tools is not possible in tracking mode, only in setup and ready.
*/
mitk::TrackingTool* AddTool(const char* toolName, const char* fileName, TrackingPriority p = NDIPassiveTool::Dynamic);
/**
* \brief Remove a passive 6D tool from the list of tracked tools.
*
* \warning removing tools is not possible in tracking mode, only in setup and ready modes.
*/
virtual bool RemoveTool(TrackingTool* tool);
/**
* \brief reloads the srom file and reinitializes the tool
*/
virtual bool UpdateTool(mitk::TrackingTool* tool);
virtual void SetPortNumber(const PortNumber _arg); ///< set port number for serial communication
itkGetConstMacro(PortNumber, PortNumber); ///< returns the port number for serial communication
virtual void SetDeviceName(std::string _arg); ///< set device name (e.g. COM1, /dev/ttyUSB0). If this is set, PortNumber will be ignored
itkGetStringMacro(DeviceName); ///< returns the device name for serial communication
virtual void SetBaudRate(const BaudRate _arg); ///< set baud rate for serial communication
itkGetConstMacro(BaudRate, BaudRate); ///< returns the baud rate for serial communication
virtual void SetDataBits(const DataBits _arg); ///< set number of data bits
itkGetConstMacro(DataBits, DataBits); ///< returns the data bits for serial communication
virtual void SetParity(const Parity _arg); ///< set parity mode
itkGetConstMacro(Parity, Parity); ///< returns the parity mode
virtual void SetStopBits(const StopBits _arg); ///< set number of stop bits
itkGetConstMacro(StopBits, StopBits); ///< returns the number of stop bits
virtual void SetHardwareHandshake(const HardwareHandshake _arg); ///< set use hardware handshake for serial communication
itkGetConstMacro(HardwareHandshake, HardwareHandshake); ///< returns the hardware handshake setting
virtual void SetIlluminationActivationRate(const IlluminationActivationRate _arg); ///< set activation rate of IR illumator for polaris
itkGetConstMacro(IlluminationActivationRate, IlluminationActivationRate); ///< returns the activation rate of IR illumator for polaris
virtual void SetDataTransferMode(const DataTransferMode _arg); ///< set data transfer mode to text (TX) or binary (BX). \warning: only TX is supportet at the moment
itkGetConstMacro(DataTransferMode, DataTransferMode); ///< returns the data transfer mode
virtual bool Beep(unsigned char count); ///< Beep the tracking device 1 to 9 times
NDIErrorCode GetErrorCode(const std::string* input); ///< returns the error code for a string that contains an error code in hexadecimal format
virtual bool SetOperationMode(OperationMode mode); ///< set operation mode to 6D tool tracking, 3D marker tracking or 6D&3D hybrid tracking (see OperationMode)
virtual OperationMode GetOperationMode(); ///< get current operation mode
/**
* \brief Get 3D marker positions (operation mode must be set to MarkerTracking3D or HybridTracking)
*/
virtual bool GetMarkerPositions(MarkerPointContainerType* markerpositions);
/**
* \brief Get major revision number from tracking device
* should not be called directly after starting to track
**/
virtual int GetMajorFirmwareRevisionNumber();
/**
* \brief Get revision number from tracking device as string
* should not be called directly after starting to track
**/
virtual const char* GetFirmwareRevisionNumber();
+ /** @return Returns true if this device can autodetects its tools. */
+ virtual bool AutoDetectToolsAvailable();
+ /** Autodetects tools from this device and returns them as a navigation tool storage.
+ * @return Returns the detected tools. Returns an empty storage if no tools are present
+ * or if detection is not possible
+ */
+ virtual mitk::NavigationToolStorage::Pointer AutoDetectTools();
protected:
typedef std::vector<std::string> NDITrackingVolumeContainerType; ///< vector of tracking volumes
typedef std::vector<int> TrackingVolumeDimensionType; ///< List of the supported tracking volume dimensions.
/**
* \brief Get number of supported tracking volumes, a vector containing the supported volumes and
* a vector containing the signed dimensions in mm. For each volume 10 boundaries are stored in the order of
* the supported volumes (see AURORA API GUIDE: SFLIST p.54).
**/
virtual bool GetSupportedVolumes(unsigned int* numberOfVolumes, NDITrackingVolumeContainerType* volumes, TrackingVolumeDimensionType* volumesDimensions);
/**
* \brief Sets the desired tracking volume. Returns true if the volume type could be set. It is set in the OpenConnection() Method and sets the tracking volume out of m_Data.
* @throw mitk::IGTHardwareException Throws an IGT hardware exception if the volume could not be set.
**/
virtual bool SetVolume(mitk::TrackingDeviceData volume);
/**
* \brief Add a passive 6D tool to the list of tracked tools. This method is used by AddTool
* @throw mitk::IGTHardwareException Throws an exception if there are errors while adding the tool.
* \warning adding tools is not possible in tracking mode, only in setup and ready.
*/
virtual bool InternalAddTool(NDIPassiveTool* tool);
/* Methods for NDIProtocol friend class */
virtual void InvalidateAll(); ///< invalidate all tools
NDIPassiveTool* GetInternalTool(std::string portHandle); ///< returns the tool object that has been assigned the port handle or NULL if no tool can be found
/**
* \brief free all port handles that need to be freed
*
* This method retrieves a list of all port handles that need to be freed (e.g. tool got disconnected)
* and frees the handles at the tracking device and it removes the tools from the internal tool list
* \warning This method can remove TrackingTools from the tool list! After calling this method, GetTool(i) could return
* a different tool, because tool indices could have changed.
* @throw mitk::IGTHardwareException Throws an exception if there are errors while communicating with the device.
* \return returns NDIOKAY if everything was sucessfull, returns an error code otherwise
*/
NDIErrorCode FreePortHandles();
NDIErrorCode Send(const std::string* message, bool addCRC = true); ///< Send message to tracking device
NDIErrorCode Receive(std::string* answer, unsigned int numberOfBytes); ///< receive numberOfBytes bytes from tracking device
NDIErrorCode ReceiveByte(char* answer); ///< lightweight receive function, that reads just one byte
NDIErrorCode ReceiveLine(std::string* answer); ///< receive characters until the first LF (The LF is included in the answer string)
void ClearSendBuffer(); ///< empty send buffer of serial communication interface
void ClearReceiveBuffer(); ///< empty receive buffer of serial communication interface
const std::string CalcCRC(const std::string* input); ///< returns the CRC16 for input as a std::string
public:
/**
* \brief TrackTools() continuously polls serial interface for new 6d tool positions until StopTracking is called.
*
* Continuously tracks the 6D position of all tools until StopTracking() is called.
* This function is executed by the tracking thread (through StartTracking() and ThreadStartTracking()).
* It should not be called directly.
* @throw mitk::IGTHardwareException Throws an exception if there are errors while tracking the tools.
*/
virtual void TrackTools();
/**
* \brief continuously polls serial interface for new 3D marker positions until StopTracking is called.
*
* Continuously tracks the 3D position of all markers until StopTracking() is called.
* This function is executed by the tracking thread (through StartTracking() and ThreadStartTracking()).
* It should not be called directly.
*/
virtual void TrackMarkerPositions();
/**
* \brief continuously polls serial interface for new 3D marker positions and 6D tool positions until StopTracking is called.
*
* Continuously tracks the 3D position of all markers and the 6D position of all tools until StopTracking() is called.
* This function is executed by the tracking thread (through StartTracking() and ThreadStartTracking()).
* It should not be called directly.
*/
virtual void TrackToolsAndMarkers();
/**
* \brief static start method for the tracking thread.
*/
static ITK_THREAD_RETURN_TYPE ThreadStartTracking(void* data);
protected:
NDITrackingDevice(); ///< Constructor
virtual ~NDITrackingDevice(); ///< Destructor
std::string m_DeviceName;///< Device Name
PortNumber m_PortNumber; ///< COM Port Number
BaudRate m_BaudRate; ///< COM Port Baud Rate
DataBits m_DataBits; ///< Number of Data Bits per token
Parity m_Parity; ///< Parity mode for communication
StopBits m_StopBits; ///< number of stop bits per token
HardwareHandshake m_HardwareHandshake; ///< use hardware handshake for serial port connection
///< which tracking volume is currently used (if device supports multiple volumes) (\warning This parameter is not used yet)
IlluminationActivationRate m_IlluminationActivationRate; ///< update rate of IR illuminator for Polaris
DataTransferMode m_DataTransferMode; ///< use TX (text) or BX (binary) (\warning currently, only TX mode is supported)
Tool6DContainerType m_6DTools; ///< list of 6D tools
itk::FastMutexLock::Pointer m_ToolsMutex; ///< mutex for coordinated access of tool container
mitk::SerialCommunication::Pointer m_SerialCommunication; ///< serial communication interface
itk::FastMutexLock::Pointer m_SerialCommunicationMutex; ///< mutex for coordinated access of serial communication interface
NDIProtocol::Pointer m_DeviceProtocol; ///< create and parse NDI protocol strings
itk::MultiThreader::Pointer m_MultiThreader; ///< creates tracking thread that continuously polls serial interface for new tracking data
int m_ThreadID; ///< ID of tracking thread
OperationMode m_OperationMode; ///< tracking mode (6D tool tracking, 3D marker tracking,...)
itk::FastMutexLock::Pointer m_MarkerPointsMutex; ///< mutex for marker point data container
MarkerPointContainerType m_MarkerPoints; ///< container for markers (3D point tracking mode)
};
} // namespace mitk
#endif /* MITKNDITRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2 */
diff --git a/Modules/IGT/TrackingDevices/mitkTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkTrackingDevice.cpp
index ba47a9f700..dbb8bafa2d 100644
--- a/Modules/IGT/TrackingDevices/mitkTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkTrackingDevice.cpp
@@ -1,138 +1,148 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTrackingDevice.h"
#include "mitkIGTTimeStamp.h"
#include "mitkTrackingTool.h"
#include <itkMutexLockHolder.h>
#include <usModuleContext.h>
#include <usGetModuleContext.h>
#include "mitkUnspecifiedTrackingTypeInformation.h"
#include "mitkTrackingDeviceTypeCollection.h"
typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
mitk::TrackingDevice::TrackingDevice() :
m_Data(mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified()),
m_State(mitk::TrackingDevice::Setup),
m_StopTracking(false),
m_RotationMode(mitk::TrackingDevice::RotationStandard)
{
m_StopTrackingMutex = itk::FastMutexLock::New();
m_StateMutex = itk::FastMutexLock::New();
m_TrackingFinishedMutex = itk::FastMutexLock::New();
}
mitk::TrackingDevice::~TrackingDevice()
{
}
bool mitk::TrackingDevice::IsDeviceInstalled()
{
return true;
//this is the default for all tracking device
//If a device needs installation please reimplement
//this method in the subclass.
}
+bool mitk::TrackingDevice::AutoDetectToolsAvailable()
+{
+ return false;
+}
+
+mitk::NavigationToolStorage::Pointer mitk::TrackingDevice::AutoDetectTools()
+{
+ return mitk::NavigationToolStorage::New();
+}
+
mitk::TrackingDevice::TrackingDeviceState mitk::TrackingDevice::GetState() const
{
MutexLockHolder lock(*m_StateMutex);
return m_State;
}
void mitk::TrackingDevice::SetState( TrackingDeviceState state )
{
itkDebugMacro("setting m_State to " << state);
MutexLockHolder lock(*m_StateMutex); // lock and unlock the mutex
if (m_State == state)
{
return;
}
m_State = state;
this->Modified();
}
void mitk::TrackingDevice::SetRotationMode(RotationMode r)
{
MITK_WARN << "Rotation mode switching is not implemented for this device. Leaving it at mitk::TrackingDevice::RotationStandard";
}
mitk::TrackingDeviceType mitk::TrackingDevice::GetType() const{
return m_Data.Line;
}
void mitk::TrackingDevice::SetType(mitk::TrackingDeviceType deviceType){
us::ModuleContext* context = us::GetModuleContext();
std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
if (refs.empty())
{
MITK_ERROR << "No tracking device service found!";
}
mitk::TrackingDeviceTypeCollection* deviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
m_Data = deviceTypeCollection->GetFirstCompatibleDeviceDataForLine(deviceType);
}
mitk::TrackingDeviceData mitk::TrackingDevice::GetData() const{
return m_Data;
}
void mitk::TrackingDevice::SetData(mitk::TrackingDeviceData data){
m_Data = data;
}
bool mitk::TrackingDevice::StopTracking()
{
if (this->GetState() == Tracking) // Only if the object is in the correct state
{
m_StopTrackingMutex->Lock(); // m_StopTracking is used by two threads, so we have to ensure correct thread handling
m_StopTracking = true;
m_StopTrackingMutex->Unlock();
//we have to wait here that the other thread recognizes the STOP-command and executes it
m_TrackingFinishedMutex->Lock();
mitk::IGTTimeStamp::GetInstance()->Stop(this); // notify realtime clock
// StopTracking was called, thus the mode should be changed back
// to Ready now that the tracking loop has ended.
this->SetState(Ready);
m_TrackingFinishedMutex->Unlock();
}
return true;
}
mitk::TrackingTool* mitk::TrackingDevice::GetToolByName( std::string name ) const
{
unsigned int toolCount = this->GetToolCount();
for (unsigned int i = 0; i < toolCount; ++i)
if (name == this->GetTool(i)->GetToolName())
return this->GetTool(i);
return nullptr;
}
diff --git a/Modules/IGT/TrackingDevices/mitkTrackingDevice.h b/Modules/IGT/TrackingDevices/mitkTrackingDevice.h
index 4b47e4a53b..e58e014bc0 100644
--- a/Modules/IGT/TrackingDevices/mitkTrackingDevice.h
+++ b/Modules/IGT/TrackingDevices/mitkTrackingDevice.h
@@ -1,189 +1,199 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKTRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2
#define MITKTRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2
#include <MitkIGTExports.h>
#include "itkObject.h"
#include "mitkCommon.h"
#include "mitkTrackingTypes.h"
#include "itkFastMutexLock.h"
+#include "mitkNavigationToolStorage.h"
namespace mitk {
class TrackingTool; // interface for a tool that can be tracked by the TrackingDevice
/**Documentation
* \brief Interface for all Tracking Devices
*
* Defines the methods that are common for all tracking devices.
*
* \ingroup IGT
*/
class MITKIGT_EXPORT TrackingDevice : public itk::Object
{
public:
mitkClassMacroItkParent(TrackingDevice, itk::Object);
/** Defines the rotation modes of this tracking device which results in different representations
* of quaternions.
*
* - Standard: normal representation, rawdata from the device is not changed (DEFAULT)
*
* - Transposed: the rotation is stored transposed, which is (by mistake!) expected by some older MITK classes due
* to an ambigious method naming in VNL.
*
* CAUTION: The rotation mode can only be changed for backward compatibility of old WRONG code.
* PLEASE DO NOT CHANGE THE ROTATION MODE UNLESS YOU ARE KNOWING EXACTLY WHAT YOU ARE DOING!
*
* use SetRotationMode to change the mode.
*/
enum RotationMode {RotationStandard, RotationTransposed};
enum TrackingDeviceState {Setup, Ready, Tracking}; ///< Type for state variable. The trackingdevice is always in one of these states
/**
* \brief Opens a connection to the device
*
* This may only be called if there is currently no connection to the device.
* If OpenConnection() is successful, the object will change from Setup state to Ready state
*/
virtual bool OpenConnection() = 0;
/**
* \brief Closes the connection to the device
*
* This may only be called if there is currently a connection to the device, but tracking is
* not running (e.g. object is in Ready state)
*/
virtual bool CloseConnection() = 0; ///< Closes the connection with the device
/**
* \brief start retrieving tracking data from the device.
*
* This may only be called after the connection to the device has been established
* with a call to OpenConnection() (E.g. object is in Ready mode). This will change the
* object state from Ready to Tracking
*/
virtual bool StartTracking() = 0;
/**
* \brief stop retrieving tracking data from the device.
* stop retrieving tracking data from the device.
* This may only be called after StartTracking was called
* (e.g. the object is in Tracking mode).
* This will change the object state from Tracking to Ready.
*/
virtual bool StopTracking();
/**
* \brief Return tool with index toolNumber
*
* tools are numbered from 0 to GetToolCount() - 1.
*/
virtual TrackingTool* GetTool(unsigned int toolNumber) const = 0;
/**
* \brief Returns the tool with the given tool name
*
* Note: subclasses can and should implement optimized versions of this method
* \return the given tool or NULL if no tool with that name exists
*/
virtual mitk::TrackingTool* GetToolByName(std::string name) const;
/**
* \brief Returns number of tracking tools
*/
virtual unsigned int GetToolCount() const = 0;
/** Sets the rotation mode of this class. See documentation of enum RotationMode for details
* on the different modes. This method has to be implemented in a deriving class to become
* functional / if different rotation modes should be supported.
* CAUTION: The rotation mode can only be changed for backward compatibility of old WRONG code.
* PLEASE DO NOT CHANGE THE ROTATION MODE UNLESS YOU ARE KNOWING EXACTLY WHAT YOU ARE DOING!
*/
virtual void SetRotationMode(RotationMode r);
/** @return Returns the rotation mode of this class. See documentation of enum
* RotationMode for details on the different modes.
*/
itkGetConstMacro(RotationMode,RotationMode);
/**
* \brief return current object state (Setup, Ready or Tracking)
*/
TrackingDeviceState GetState() const;
/**
* \brief Deprecated! Use the more specific getDeviceData instead. return device type identifier
*/
TrackingDeviceType GetType() const;
/**
* \brief Deprecated! Use the more specific setDeviceData instead. set device type
*/
void SetType(TrackingDeviceType type);
/**
* \brief return device data
*/
TrackingDeviceData GetData() const;
/**
* \brief set device type
*/
void SetData(TrackingDeviceData data);
/**
* @return Returns true if the device is installed on this system an can be used.
* Installed means activated in MITK, in some cases this means the MITK
* installation / build has to know the installation path of the device
* libraries on this system. This path is usually given as cmake variable
* during the build configuration in devellopers mode. If the device should
* be available for end users with an installer the libraries can be included
* into the installer or the installer has to be adapted such that it asks
* for the path.
* Returns fals if the device is not installed. It cannot be used on this build
* in this case.
*
* Note that some tracking systems communicate via a standard interface (e.g., serial
* port) and don't need any library or installation. These devices are always "installed".
*/
virtual bool IsDeviceInstalled();
+ /** @return Returns true if this device can autodetects its tools. */
+ virtual bool AutoDetectToolsAvailable();
+
+ /** Autodetects tools from this device and returns them as a navigation tool storage.
+ * @return Returns the detected tools. Returns an empty storage if no tools are present
+ * or if detection is not possible
+ */
+ virtual mitk::NavigationToolStorage::Pointer AutoDetectTools();
+
private:
TrackingDeviceState m_State; ///< current object state (Setup, Ready or Tracking)
protected:
/**
* \brief change object state
*/
void SetState(TrackingDeviceState state);
TrackingDevice();
virtual ~TrackingDevice();
TrackingDeviceData m_Data; ///< current device Data
bool m_StopTracking; ///< signal stop to tracking thread
itk::FastMutexLock::Pointer m_StopTrackingMutex; ///< mutex to control access to m_StopTracking
itk::FastMutexLock::Pointer m_TrackingFinishedMutex; ///< mutex to manage control flow of StopTracking()
itk::FastMutexLock::Pointer m_StateMutex; ///< mutex to control access to m_State
RotationMode m_RotationMode; ///< defines the rotation mode Standard or Transposed, Standard is default
};
} // namespace mitk
#endif /* MITKTRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2 */
diff --git a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
index c8977ceb22..7650ba9169 100644
--- a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
+++ b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
@@ -1,1709 +1,1731 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; 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 <mitkTestFixture.h>
#include <mitkTestingMacros.h>
#include <mitkPlanarPolygon.h>
#include <vtkStreamingDemandDrivenPipeline.h>
#include <mitkStandaloneDataStorage.h>
#include <mitkIOUtil.h>
#include <mitkImageGenerator.h>
#include <mitkImagePixelWriteAccessor.h>
#include <mitkPlanarFigureMaskGenerator.h>
#include <mitkIgnorePixelMaskGenerator.h>
#include <mitkImageMaskGenerator.h>
/**
* \brief Test class for mitkImageStatisticsCalculator
*
* This test covers:
* - instantiation of an ImageStatisticsCalculator class
* - correctness of statistics when using PlanarFigures for masking
*/
class mitkImageStatisticsCalculatorTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkImageStatisticsCalculatorTestSuite);
MITK_TEST(TestUninitializedImage);
MITK_TEST(TestCase1);
MITK_TEST(TestCase2);
MITK_TEST(TestCase3);
MITK_TEST(TestCase4);
MITK_TEST(TestCase5);
MITK_TEST(TestCase6);
MITK_TEST(TestCase7);
MITK_TEST(TestCase8);
MITK_TEST(TestCase9);
MITK_TEST(TestCase10);
MITK_TEST(TestCase11);
MITK_TEST(TestCase12);
MITK_TEST(TestImageMaskingEmpty);
MITK_TEST(TestImageMaskingNonEmpty);
MITK_TEST(TestRecomputeOnModifiedMask);
MITK_TEST(TestPic3DStatistics);
MITK_TEST(TestPic3DAxialPlanarFigureMaskStatistics);
MITK_TEST(TestPic3DSagittalPlanarFigureMaskStatistics);
MITK_TEST(TestPic3DCoronalPlanarFigureMaskStatistics);
MITK_TEST(TestPic3DImageMaskStatistics_label1);
MITK_TEST(TestPic3DImageMaskStatistics_label2);
MITK_TEST(TestPic3DIgnorePixelValueMaskStatistics);
MITK_TEST(TestPic3DSecondaryMaskStatistics);
MITK_TEST(TestUS4DCylStatistics_time1);
MITK_TEST(TestUS4DCylAxialPlanarFigureMaskStatistics_time1);
MITK_TEST(TestUS4DCylSagittalPlanarFigureMaskStatistics_time1);
MITK_TEST(TestUS4DCylCoronalPlanarFigureMaskStatistics_time1);
MITK_TEST(TestUS4DCylImageMaskStatistics_time1_label_1);
MITK_TEST(TestUS4DCylImageMaskStatistics_time2_label_1);
MITK_TEST(TestUS4DCylImageMaskStatistics_time1_label_2);
MITK_TEST(TestUS4DCylIgnorePixelValueMaskStatistics_time1);
MITK_TEST(TestUS4DCylSecondaryMaskStatistics_time1);
CPPUNIT_TEST_SUITE_END();
public:
void setUp() override;
+ void tearDown() override;
void TestUninitializedImage();
void TestCase1();
void TestCase2();
void TestCase3();
void TestCase4();
void TestCase5();
void TestCase6();
void TestCase7();
void TestCase8();
void TestCase9();
void TestCase10();
void TestCase11();
void TestCase12();
void TestImageMaskingEmpty();
void TestImageMaskingNonEmpty();
void TestRecomputeOnModifiedMask();
void TestPic3DStatistics();
void TestPic3DAxialPlanarFigureMaskStatistics();
void TestPic3DSagittalPlanarFigureMaskStatistics();
void TestPic3DCoronalPlanarFigureMaskStatistics();
void TestPic3DImageMaskStatistics_label1();
void TestPic3DImageMaskStatistics_label2();
void TestPic3DIgnorePixelValueMaskStatistics();
void TestPic3DSecondaryMaskStatistics();
void TestUS4DCylStatistics_time1();
void TestUS4DCylAxialPlanarFigureMaskStatistics_time1();
void TestUS4DCylSagittalPlanarFigureMaskStatistics_time1();
void TestUS4DCylCoronalPlanarFigureMaskStatistics_time1();
void TestUS4DCylImageMaskStatistics_time1_label_1();
void TestUS4DCylImageMaskStatistics_time2_label_1();
void TestUS4DCylImageMaskStatistics_time1_label_2();
void TestUS4DCylIgnorePixelValueMaskStatistics_time1();
void TestUS4DCylSecondaryMaskStatistics_time1();
void TestDifferentNBinsForHistogramStatistics();
void TestDifferentBinSizeForHistogramStatistic();
void TestSwitchFromBinSizeToNBins();
void TestSwitchFromNBinsToBinSize();
private:
mitk::Image::Pointer m_TestImage;
mitk::Image::Pointer m_Pic3DImage;
mitk::Image::Pointer m_Pic3DImageMask;
mitk::Image::Pointer m_Pic3DImageMask2;
mitk::PlanarFigure::Pointer m_Pic3DPlanarFigureAxial;
mitk::PlanarFigure::Pointer m_Pic3DPlanarFigureSagittal;
mitk::PlanarFigure::Pointer m_Pic3DPlanarFigureCoronal;
mitk::Image::Pointer m_US4DImage;
mitk::Image::Pointer m_US4DImageMask;
mitk::Image::Pointer m_US4DImageMask2;
mitk::PlanarFigure::Pointer m_US4DPlanarFigureAxial;
mitk::PlanarFigure::Pointer m_US4DPlanarFigureSagittal;
mitk::PlanarFigure::Pointer m_US4DPlanarFigureCoronal;
mitk::PlaneGeometry::Pointer m_Geometry;
// calculate statistics for the given image and planarpolygon
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer ComputeStatistics( mitk::Image::Pointer image,
mitk::PlanarFigure::Pointer polygon );
// calculate statistics for the given image and mask
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer ComputeStatistics( mitk::Image::Pointer image,
mitk::Image::Pointer image_mask );
// universal function to calculate statistics
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer ComputeStatisticsNew(mitk::Image::Pointer image,
int timeStep=0,
mitk::MaskGenerator::Pointer maskGen=nullptr,
mitk::MaskGenerator::Pointer secondardMaskGen=nullptr,
unsigned short label=1);
void VerifyStatistics(mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer stats,
double testMean, double testSD, double testMedian=0);
void VerifyStatistics(mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer stats,
long N,
double mean,
double MPP,
double median,
double skewness,
double kurtosis,
double uniformity,
double UPP,
double variance,
double stdev,
double min,
double max,
double RMS,
double entropy,
vnl_vector<int> minIndex,
vnl_vector<int> maxIndex);
};
+void mitkImageStatisticsCalculatorTestSuite::tearDown()
+{
+ m_TestImage = nullptr;
+
+ m_Pic3DImage = nullptr;
+ m_Pic3DImageMask = nullptr;
+ m_Pic3DImageMask2 = nullptr;
+ m_Pic3DPlanarFigureAxial = nullptr;
+ m_Pic3DPlanarFigureSagittal = nullptr;
+ m_Pic3DPlanarFigureCoronal = nullptr;
+
+ m_US4DImage = nullptr;
+ m_US4DImageMask = nullptr;
+ m_US4DImageMask2 = nullptr;
+ m_US4DPlanarFigureAxial = nullptr;
+ m_US4DPlanarFigureSagittal = nullptr;
+ m_US4DPlanarFigureCoronal = nullptr;
+
+ m_Geometry = nullptr;
+}
+
void mitkImageStatisticsCalculatorTestSuite::setUp()
{
std::string filename = this->GetTestDataFilePath("ImageStatisticsTestData/testimage.dcm");
std::string Pic3DFile = this->GetTestDataFilePath("Pic3D.nrrd");
std::string Pic3DImageMaskFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D-labels.nrrd");
std::string Pic3DImageMaskFile2 = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3D-labels2.nrrd");
std::string Pic3DAxialPlanarFigureFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3DAxialPlanarFigure.pf");
std::string Pic3DSagittalPlanarFigureFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3DSagittalPlanarFigure.pf");
std::string Pic3DCoronalPlanarFigureFile = this->GetTestDataFilePath("ImageStatisticsTestData/Pic3DCoronalPlanarFigure.pf");
std::string US4DFile = this->GetTestDataFilePath("US4DCyl.nrrd");
std::string US4DImageMaskFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4D-labels.nrrd");
std::string US4DImageMaskFile2 = this->GetTestDataFilePath("ImageStatisticsTestData/US4D-labels2.nrrd");
std::string US4DAxialPlanarFigureFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4DAxialPlanarFigure.pf");
std::string US4DSagittalPlanarFigureFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4DSagittalPlanarFigure.pf");
std::string US4DCoronalPlanarFigureFile = this->GetTestDataFilePath("ImageStatisticsTestData/US4DCoronalPlanarFigure.pf");
if (filename.empty() ||
Pic3DFile.empty() || Pic3DImageMaskFile.empty() ||
Pic3DAxialPlanarFigureFile.empty() || Pic3DSagittalPlanarFigureFile.empty() || Pic3DCoronalPlanarFigureFile.empty() ||
US4DFile.empty() || US4DImageMaskFile.empty() ||
US4DAxialPlanarFigureFile.empty() || US4DSagittalPlanarFigureFile.empty() || US4DCoronalPlanarFigureFile.empty())
{
MITK_TEST_FAILED_MSG( << "Could not find test file" )
}
MITK_TEST_OUTPUT(<< "Loading test image '" << filename << "'")
m_TestImage = mitk::IOUtil::LoadImage(filename);
MITK_TEST_CONDITION_REQUIRED( m_TestImage.IsNotNull(), "Loaded an mitk::Image" );
m_Geometry = m_TestImage->GetSlicedGeometry()->GetPlaneGeometry(0);
MITK_TEST_CONDITION_REQUIRED( m_Geometry.IsNotNull(), "Getting image geometry" );
m_Pic3DImage = mitk::IOUtil::LoadImage(Pic3DFile);
MITK_TEST_CONDITION_REQUIRED( m_Pic3DImage.IsNotNull(), "Loaded Pic3D" );
m_Pic3DImageMask = mitk::IOUtil::LoadImage(Pic3DImageMaskFile);
MITK_TEST_CONDITION_REQUIRED( m_Pic3DImageMask.IsNotNull(), "Loaded Pic3D image mask" );
m_Pic3DImageMask2 = mitk::IOUtil::LoadImage(Pic3DImageMaskFile2);
MITK_TEST_CONDITION_REQUIRED( m_Pic3DImageMask2.IsNotNull(), "Loaded Pic3D image secondary mask" );
m_Pic3DPlanarFigureAxial = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::Load(Pic3DAxialPlanarFigureFile)[0].GetPointer());
MITK_TEST_CONDITION_REQUIRED( m_Pic3DPlanarFigureAxial.IsNotNull(), "Loaded Pic3D axial planarFigure" );
m_Pic3DPlanarFigureSagittal = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::Load(Pic3DSagittalPlanarFigureFile)[0].GetPointer());
MITK_TEST_CONDITION_REQUIRED( m_Pic3DPlanarFigureSagittal.IsNotNull(), "Loaded Pic3D sagittal planarFigure" );
m_Pic3DPlanarFigureCoronal = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::Load(Pic3DCoronalPlanarFigureFile)[0].GetPointer());
MITK_TEST_CONDITION_REQUIRED( m_Pic3DPlanarFigureCoronal.IsNotNull(), "Loaded Pic3D coronal planarFigure" );
m_US4DImage = mitk::IOUtil::LoadImage(US4DFile);
MITK_TEST_CONDITION_REQUIRED( m_US4DImage.IsNotNull(), "Loaded US4D" );
m_US4DImageMask = mitk::IOUtil::LoadImage(US4DImageMaskFile);
MITK_TEST_CONDITION_REQUIRED( m_US4DImageMask.IsNotNull(), "Loaded US4D image mask" );
m_US4DImageMask2 = mitk::IOUtil::LoadImage(US4DImageMaskFile2);
MITK_TEST_CONDITION_REQUIRED( m_US4DImageMask2.IsNotNull(), "Loaded US4D image mask2" );
m_US4DPlanarFigureAxial = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::Load(US4DAxialPlanarFigureFile)[0].GetPointer());
MITK_TEST_CONDITION_REQUIRED( m_US4DPlanarFigureAxial.IsNotNull(), "Loaded US4D axial planarFigure" );
m_US4DPlanarFigureSagittal = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::Load(US4DSagittalPlanarFigureFile)[0].GetPointer());
MITK_TEST_CONDITION_REQUIRED( m_US4DPlanarFigureSagittal.IsNotNull(), "Loaded US4D sagittal planarFigure" );
m_US4DPlanarFigureCoronal = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::Load(US4DCoronalPlanarFigureFile)[0].GetPointer());
MITK_TEST_CONDITION_REQUIRED( m_US4DPlanarFigureCoronal.IsNotNull(), "Loaded US4D coronal planarFigure" );
}
void mitkImageStatisticsCalculatorTestSuite::TestCase1()
{
/*****************************
* one whole white pixel
* -> mean of 255 expected
******************************/
MITK_INFO << std::endl << "Test case 1:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
figure1->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 10.5 ; pnt1[1] = 3.5;
figure1->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
figure1->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
figure1->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 10.5; pnt4[1] = 4.5;
figure1->SetControlPoint( 3, pnt4, true );
figure1->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure1.GetPointer()), 255.0, 0.0, 255.0);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase2()
{
/*****************************
* half pixel in x-direction (white)
* -> mean of 255 expected
******************************/
MITK_INFO << std::endl << "Test case 2:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
figure1->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 10.0 ; pnt1[1] = 3.5;
figure1->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
figure1->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
figure1->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 10.0; pnt4[1] = 4.5;
figure1->SetControlPoint( 3, pnt4, true );
figure1->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure1.GetPointer()), 255.0, 0.0, 255.0);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase3()
{
/*****************************
* half pixel in diagonal-direction (white)
* -> mean of 255 expected
******************************/
MITK_INFO << std::endl << "Test case 3:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
figure1->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 10.5 ; pnt1[1] = 3.5;
figure1->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
figure1->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
figure1->SetControlPoint( 2, pnt3, true );
figure1->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure1.GetPointer()), 255.0, 0.0, 255.0);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase4()
{
/*****************************
* one pixel (white) + 2 half pixels (white) + 1 half pixel (black)
* -> mean of 191.25 expected
******************************/
MITK_INFO << std::endl << "Test case 4:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
figure1->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 1.1; pnt1[1] = 1.1;
figure1->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 2.0; pnt2[1] = 2.0;
figure1->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 3.0; pnt3[1] = 1.0;
figure1->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 2.0; pnt4[1] = 0.0;
figure1->SetControlPoint( 3, pnt4, true );
figure1->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure1.GetPointer()), 191.25, 110.41, 242.250);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase5()
{
/*****************************
* whole pixel (white) + half pixel (gray) in x-direction
* -> mean of 191.5 expected
******************************/
MITK_INFO << std::endl << "Test case 5:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
figure1->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
figure1->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
figure1->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
figure1->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5;
figure1->SetControlPoint( 3, pnt4, true );
figure1->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure1.GetPointer()), 191.50, 63.50, 134.340);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase6()
{
/*****************************
* quarter pixel (black) + whole pixel (white) + half pixel (gray) in x-direction
* -> mean of 191.5 expected
******************************/
MITK_INFO << std::endl << "Test case 6:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
figure1->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
figure1->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 9.25; pnt2[1] = 3.5;
figure1->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 9.25; pnt3[1] = 4.5;
figure1->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5;
figure1->SetControlPoint( 3, pnt4, true );
figure1->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure1.GetPointer()), 191.5, 63.50, 134.340);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase7()
{
/*****************************
* half pixel (black) + whole pixel (white) + half pixel (gray) in x-direction
* -> mean of 127.66 expected
******************************/
MITK_INFO << std::endl << "Test case 7:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
figure1->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
figure1->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 9.0; pnt2[1] = 3.5;
figure1->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 9.0; pnt3[1] = 4.0;
figure1->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.0;
figure1->SetControlPoint( 3, pnt4, true );
figure1->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure1.GetPointer()), 127.66, 104.1, 140.250);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase8()
{
/*****************************
* whole pixel (gray)
* -> mean of 128 expected
******************************/
MITK_INFO << std::endl << "Test case 8:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
figure2->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
figure2->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 11.5;
figure2->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 11.5;
figure2->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
figure2->SetControlPoint( 3, pnt4, true );
figure2->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure2.GetPointer()), 128.0, 0.0, 128.0);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase9()
{
/*****************************
* whole pixel (gray) + half pixel (white) in y-direction
* -> mean of 191.5 expected
******************************/
MITK_INFO << std::endl << "Test case 9:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
figure2->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
figure2->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 12.0;
figure2->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 12.0;
figure2->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
figure2->SetControlPoint( 3, pnt4, true );
figure2->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure2.GetPointer()), 191.5, 63.50, 134.340);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase10()
{
/*****************************
* 2 whole pixel (white) + 2 whole pixel (black) in y-direction
* -> mean of 127.66 expected
******************************/
MITK_INFO << std::endl << "Test case 10:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
figure2->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
figure2->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 13.5;
figure2->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 13.5;
figure2->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
figure2->SetControlPoint( 3, pnt4, true );
figure2->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure2.GetPointer()), 127.66, 104.1, 140.250);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase11()
{
/*****************************
* 9 whole pixels (white) + 3 half pixels (white)
* + 3 whole pixel (black) [ + 3 slightly less than half pixels (black)]
* -> mean of 204.0 expected
******************************/
MITK_INFO << std::endl << "Test case 11:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
figure2->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 0.5; pnt1[1] = 0.5;
figure2->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 3.5; pnt2[1] = 3.5;
figure2->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 8.4999; pnt3[1] = 3.5;
figure2->SetControlPoint( 2, pnt3, true );
mitk::Point2D pnt4; pnt4[0] = 5.4999; pnt4[1] = 0.5;
figure2->SetControlPoint( 3, pnt4, true );
figure2->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure2.GetPointer()), 204.0, 102.00, 242.250);
}
void mitkImageStatisticsCalculatorTestSuite::TestCase12()
{
/*****************************
* half pixel (white) + whole pixel (white) + half pixel (black)
* -> mean of 212.66 expected
******************************/
MITK_INFO << std::endl << "Test case 12:-----------------------------------------------------------------------------------";
mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
figure2->SetPlaneGeometry( m_Geometry );
mitk::Point2D pnt1; pnt1[0] = 9.5; pnt1[1] = 0.5;
figure2->PlaceFigure( pnt1 );
mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 2.5;
figure2->SetControlPoint( 1, pnt2, true );
mitk::Point2D pnt3; pnt3[0] = 11.5; pnt3[1] = 2.5;
figure2->SetControlPoint( 2, pnt3, true );
figure2->GetPolyLine(0);
this->VerifyStatistics(ComputeStatistics(m_TestImage, figure2.GetPointer()), 212.66, 59.860, 248.640);
}
void mitkImageStatisticsCalculatorTestSuite::TestImageMaskingEmpty()
{
MITK_INFO << std::endl << "TestImageMaskingEmpty:-----------------------------------------------------------------------------------";
mitk::Image::Pointer mask_image = mitk::ImageGenerator::GenerateImageFromReference<unsigned char>( m_TestImage, 0 );
this->VerifyStatistics( ComputeStatistics( m_TestImage, mask_image ), -21474836.480, -21474836.480, -21474836.480); // empty statisticsContainer (default values)
}
void mitkImageStatisticsCalculatorTestSuite::TestImageMaskingNonEmpty()
{
MITK_INFO << std::endl << "TestImageMaskingNonEmpty:-----------------------------------------------------------------------------------";
mitk::Image::Pointer mask_image = mitk::ImageGenerator::GenerateImageFromReference<unsigned char>( m_TestImage, 0 );
std::vector< itk::Index<3U> > activated_indices;
itk::Index<3U> index = {{10, 8, 0}};
activated_indices.push_back( index );
index[0] = 9; index[1] = 8; index[2] = 0;
activated_indices.push_back( index );
index[0] = 9; index[1] = 7; index[2] = 0;
activated_indices.push_back( index );
index[0] = 10; index[1] = 7; index[2] = 0;
activated_indices.push_back( index );
std::vector< itk::Index<3U> >::const_iterator indexIter = activated_indices.begin();
// activate voxel in the mask image
mitk::ImagePixelWriteAccessor< unsigned char, 3> writeAccess( mask_image );
while( indexIter != activated_indices.end() )
{
writeAccess.SetPixelByIndex( (*indexIter++), 1);
}
this->VerifyStatistics( ComputeStatistics( m_TestImage, mask_image ), 127.5, 127.5, 12.750);
}
void mitkImageStatisticsCalculatorTestSuite::TestRecomputeOnModifiedMask()
{
MITK_INFO << std::endl << "TestRecomputeOnModifiedMask:-----------------------------------------------------------------------------------";
mitk::Image::Pointer mask_image = mitk::ImageGenerator::GenerateImageFromReference<unsigned char>( m_TestImage, 0 );
mitk::ImageStatisticsCalculator::Pointer statisticsCalculator = mitk::ImageStatisticsCalculator::New();
statisticsCalculator->SetInputImage( m_TestImage );
mitk::ImageMaskGenerator::Pointer imgMaskGen = mitk::ImageMaskGenerator::New();
imgMaskGen->SetImageMask(mask_image);
statisticsCalculator->SetMask(imgMaskGen.GetPointer());
this->VerifyStatistics( statisticsCalculator->GetStatistics(), -21474836.480, -21474836.480, -21474836.480);
// activate voxel in the mask image
itk::Index<3U> test_index = {11, 8, 0};
mitk::ImagePixelWriteAccessor< unsigned char, 3> writeAccess( mask_image );
writeAccess.SetPixelByIndex( test_index, 1);
mask_image->Modified();
mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer stat = statisticsCalculator->GetStatistics();
this->VerifyStatistics( stat, 128.0, 0.0, 128.0);
MITK_TEST_CONDITION( stat->GetN() == 1, "Calculated mask voxel count '" << stat->GetN() << "' is equal to the desired value '" << 1 << "'" );
}
void mitkImageStatisticsCalculatorTestSuite::TestPic3DStatistics()
{
MITK_INFO << std::endl << "Test plain Pic3D:-----------------------------------------------------------------------------------";
long expected_N = 3211264;
double expected_mean = -365.80015345982144;
double expected_MPP = 111.80226129535752;
double expected_median = -105.16000366210938;
double expected_skewness = -0.26976612134147004;
double expected_kurtosis = 1.4655017209571437;
double expected_uniformity = 0.06087994379480554;
double expected_UPP = 0.011227934437026977;
double expected_variance = 224036.80150510342;
double expected_standarddev = 473.32525973700518;
double expected_min = -1023;
double expected_max = 1361;
double expected_RMS = 598.20276978323352;
double expected_entropy = 4.6727423654570357;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 0;
expected_minIndex[1] = 0;
expected_minIndex[2] = 0;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 139;
expected_maxIndex[1] = 182;
expected_maxIndex[2] = 43;
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_Pic3DImage, 0);
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestPic3DAxialPlanarFigureMaskStatistics()
{
MITK_INFO << std::endl << "Test Pic3D axial pf:-----------------------------------------------------------------------------------";
double expected_entropy = 5.6719817476387417;
double expected_kurtosis = 5.8846935191205221;
double expected_MPP = 230.43933685003768;
double expected_max = 1206;
double expected_mean = 182.30282131661443;
double expected_median = 95.970001220703125;
double expected_min = -156;
long expected_N = 3190;
double expected_RMS = 301.93844376702253;
double expected_skewness = 1.6400489794326298;
double expected_standarddev = 240.69172225993557;
double expected_UPP = 0.024889790784288681;
double expected_uniformity = 0.027579917650180332;
double expected_variance = 57932.505164453964;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 156;
expected_minIndex[1] = 133;
expected_minIndex[2] = 24;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 125;
expected_maxIndex[1] = 167;
expected_maxIndex[2] = 24;
mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
pfMaskGen->SetInputImage(m_Pic3DImage);
pfMaskGen->SetPlanarFigure(m_Pic3DPlanarFigureAxial);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_Pic3DImage, 0, pfMaskGen.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestPic3DSagittalPlanarFigureMaskStatistics()
{
MITK_INFO << std::endl << "Test Pic3D sagittal pf:-----------------------------------------------------------------------------------";
double expected_entropy = 5.6051911962074286;
double expected_kurtosis = 6.5814062739142338;
double expected_MPP = 249.03202846975088;
double expected_max = 1240;
double expected_mean = 233.93602693602693;
double expected_median = 174.9849853515625;
double expected_min = -83;
long expected_N = 1188;
double expected_RMS = 332.03230188484594;
double expected_skewness = 1.7489809015501814;
double expected_standarddev = 235.62551813489128;
double expected_UPP = 0.026837539253364174;
double expected_uniformity = 0.027346982734188126;
double expected_variance = 55519.384796335973;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 128;
expected_minIndex[1] = 119;
expected_minIndex[2] = 22;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 128;
expected_maxIndex[1] = 167;
expected_maxIndex[2] = 22;
mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
pfMaskGen->SetInputImage(m_Pic3DImage);
pfMaskGen->SetPlanarFigure(m_Pic3DPlanarFigureSagittal);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_Pic3DImage, 0, pfMaskGen.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestPic3DCoronalPlanarFigureMaskStatistics()
{
MITK_INFO << std::endl << "Test Pic3D coronal pf:-----------------------------------------------------------------------------------";
double expected_entropy = 6.0677398647867449;
double expected_kurtosis = 1.6242929941303372;
double expected_MPP = 76.649350649350652;
double expected_max = 156;
double expected_mean = -482.14807692307693;
double expected_median = -660.07501220703125;
double expected_min = -897;
long expected_N = 520;
double expected_RMS = 595.09446729069839;
double expected_skewness = 0.51691492278851858;
double expected_standarddev = 348.81321207686312;
double expected_UPP = 0.0021560650887573964;
double expected_uniformity = 0.020295857988165685;
double expected_variance = 121670.6569193787;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 217;
expected_minIndex[1] = 127;
expected_minIndex[2] = 43;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 209;
expected_maxIndex[1] = 127;
expected_maxIndex[2] = 39;
mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
pfMaskGen->SetInputImage(m_Pic3DImage);
pfMaskGen->SetPlanarFigure(m_Pic3DPlanarFigureCoronal);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_Pic3DImage, 0, pfMaskGen.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestPic3DImageMaskStatistics_label1()
{
MITK_INFO << std::endl << "Test Pic3D image mask label 1 pf:-----------------------------------------------------------------------------------";
double expected_entropy = 5.695858251095868;
double expected_kurtosis = 4.2728827997815717;
double expected_MPP = 413.52408256880733;
double expected_max = 1206;
double expected_mean = 413.52408256880733;
double expected_median = 324;
double expected_min = 6;
long expected_N = 872;
double expected_RMS = 472.02024695145235;
double expected_skewness = 1.3396074364415382;
double expected_standarddev = 227.59821323493802;
double expected_UPP = 0.029758648261930806;
double expected_uniformity = 0.029758648261930806;
double expected_variance = 51800.946667736309;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 135;
expected_minIndex[1] = 158;
expected_minIndex[2] = 24;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 125;
expected_maxIndex[1] = 167;
expected_maxIndex[2] = 24;
mitk::ImageMaskGenerator::Pointer imgMaskGen = mitk::ImageMaskGenerator::New();
imgMaskGen->SetImageMask(m_Pic3DImageMask);
imgMaskGen->SetInputImage(m_Pic3DImage);
imgMaskGen->SetTimeStep(0);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_Pic3DImage, 0, imgMaskGen.GetPointer(), nullptr, 1);
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestPic3DImageMaskStatistics_label2()
{
MITK_INFO << std::endl << "Test Pic3D image mask label 2 pf:-----------------------------------------------------------------------------------";
double expected_entropy = 4.3685781901212764;
double expected_kurtosis = 9.7999112757587934;
double expected_MPP = -nan("");
double expected_max = -145;
double expected_mean = -897.92833876221493;
double expected_median = -969.16499900817871;
double expected_min = -1008;
long expected_N = 307;
double expected_RMS = 913.01496468179471;
double expected_skewness = 2.6658524648889736;
double expected_standarddev = 165.29072623903585;
double expected_UPP = 0;
double expected_uniformity = 0.087544695434434425;
double expected_variance = 27321.024180627897;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 170;
expected_minIndex[1] = 60;
expected_minIndex[2] = 24;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 173;
expected_maxIndex[1] = 57;
expected_maxIndex[2] = 24;
mitk::ImageMaskGenerator::Pointer imgMaskGen = mitk::ImageMaskGenerator::New();
imgMaskGen->SetImageMask(m_Pic3DImageMask);
imgMaskGen->SetInputImage(m_Pic3DImage);
imgMaskGen->SetTimeStep(0);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_Pic3DImage, 0, imgMaskGen.GetPointer(), nullptr, 2);
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestPic3DIgnorePixelValueMaskStatistics()
{
MITK_INFO << std::endl << "Test Pic3D ignore zero pixels:-----------------------------------------------------------------------------------";
double expected_entropy = 4.671045011438645;
double expected_kurtosis = 1.4638176488404484;
double expected_MPP = 111.80226129535752;
double expected_max = 1361;
double expected_mean = -366.48547402877585;
double expected_median = -105.16000366210938;
double expected_min = -1023;
long expected_N = 3205259;
double expected_RMS = 598.76286909522139;
double expected_skewness = -0.26648854845130782;
double expected_standarddev = 473.50329537717545;
double expected_UPP = 0.011270044547276429;
double expected_uniformity = 0.061029773286547614;
double expected_variance = 224205.37073304466;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 0;
expected_minIndex[1] = 0;
expected_minIndex[2] = 0;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 139;
expected_maxIndex[1] = 182;
expected_maxIndex[2] = 43;
mitk::IgnorePixelMaskGenerator::Pointer ignPixelValMask = mitk::IgnorePixelMaskGenerator::New();
ignPixelValMask->SetInputImage(m_Pic3DImage);
ignPixelValMask->SetIgnoredPixelValue(0);
ignPixelValMask->SetTimeStep(0);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_Pic3DImage, 0, ignPixelValMask.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestPic3DSecondaryMaskStatistics()
{
MITK_INFO << std::endl << "Test Pic3D ignore zero pixels AND Image mask 2:-----------------------------------------------------------------------------------";
double expected_entropy = 5.9741637167320176;
double expected_kurtosis = 3.490663358061596;
double expected_MPP = 332.43534482758622;
double expected_max = 1206;
double expected_mean = 320.63333333333333;
double expected_median = 265.06500244140625;
double expected_min = -57;
long expected_N = 720;
double expected_RMS = 433.57749531594055;
double expected_skewness = 1.1047775627624981;
double expected_standarddev = 291.86248474238687;
double expected_UPP = 0.020628858024691339;
double expected_uniformity = 0.021377314814814797;
double expected_variance = 85183.710000000006;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 116;
expected_minIndex[1] = 170;
expected_minIndex[2] = 24;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 125;
expected_maxIndex[1] = 167;
expected_maxIndex[2] = 24;
mitk::IgnorePixelMaskGenerator::Pointer ignPixelValMask = mitk::IgnorePixelMaskGenerator::New();
ignPixelValMask->SetInputImage(m_Pic3DImage);
ignPixelValMask->SetIgnoredPixelValue(0);
ignPixelValMask->SetTimeStep(0);
mitk::ImageMaskGenerator::Pointer imgMaskGen2 = mitk::ImageMaskGenerator::New();
imgMaskGen2->SetImageMask(m_Pic3DImageMask2);
imgMaskGen2->SetInputImage(m_Pic3DImage);
imgMaskGen2->SetTimeStep(0);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_Pic3DImage, 0, imgMaskGen2.GetPointer(), ignPixelValMask.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestUS4DCylStatistics_time1()
{
MITK_INFO << std::endl << "Test plain US4D timeStep1:-----------------------------------------------------------------------------------";
double expected_entropy = 4.8272774900452502;
double expected_kurtosis = 6.1336513352934432;
double expected_MPP = 53.395358640738536;
double expected_max = 199;
double expected_mean = 35.771298153622375;
double expected_median = 20.894999504089355;
double expected_min = 0;
long expected_N = 3409920;
double expected_RMS = 59.244523377028408;
double expected_skewness = 1.8734292240015058;
double expected_standarddev = 47.226346233600559;
double expected_UPP = 0.12098731125004937;
double expected_uniformity = 0.12098731125004937;
double expected_variance = 2230.3277785759178;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 0;
expected_minIndex[1] = 0;
expected_minIndex[2] = 0;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 268;
expected_maxIndex[1] = 101;
expected_maxIndex[2] = 0;
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_US4DImage, 1);
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestUS4DCylAxialPlanarFigureMaskStatistics_time1()
{
MITK_INFO << std::endl << "Test US4D axial pf timeStep1:-----------------------------------------------------------------------------------";
double expected_entropy = 6.218151288002292;
double expected_kurtosis = 1.7322676370242023;
double expected_MPP = 121.11663807890223;
double expected_max = 199;
double expected_mean = 121.11663807890223;
double expected_median = 120.14999771118164;
double expected_min = 9;
long expected_N = 2332;
double expected_RMS = 134.41895158590751;
double expected_skewness = -0.1454808104597369;
double expected_standarddev = 58.30278317472294;
double expected_UPP = 0.021354765820606133;
double expected_uniformity = 0.021354765820606133;
double expected_variance = 3399.214525918756;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 129;
expected_minIndex[1] = 131;
expected_minIndex[2] = 19;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 126;
expected_maxIndex[1] = 137;
expected_maxIndex[2] = 19;
mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
pfMaskGen->SetInputImage(m_US4DImage);
pfMaskGen->SetPlanarFigure(m_US4DPlanarFigureAxial);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_US4DImage, 1, pfMaskGen.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestUS4DCylSagittalPlanarFigureMaskStatistics_time1()
{
MITK_INFO << std::endl << "Test US4D sagittal pf timeStep1:-----------------------------------------------------------------------------------";
double expected_entropy = 5.2003987046387508;
double expected_kurtosis = 2.7574491062430142;
double expected_MPP = 26.212534059945504;
double expected_max = 59;
double expected_mean = 26.176870748299319;
double expected_median = 26.254999160766602;
double expected_min = 0;
long expected_N = 735;
double expected_RMS = 28.084905283121476;
double expected_skewness = 0.18245181360752327;
double expected_standarddev = 10.175133541567705;
double expected_UPP = 0.032921467906890628;
double expected_uniformity = 0.032921467906890628;
double expected_variance = 103.53334258873615;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 147;
expected_minIndex[1] = 94;
expected_minIndex[2] = 21;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 147;
expected_maxIndex[1] = 77;
expected_maxIndex[2] = 24;
mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
pfMaskGen->SetInputImage(m_US4DImage);
pfMaskGen->SetPlanarFigure(m_US4DPlanarFigureSagittal);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_US4DImage, 1, pfMaskGen.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestUS4DCylCoronalPlanarFigureMaskStatistics_time1()
{
MITK_INFO << std::endl << "Test US4D coronal pf timeStep1:-----------------------------------------------------------------------------------";
double expected_entropy = 5.8892941136639161;
double expected_kurtosis = 4.6434920707409564;
double expected_MPP = 55.486426346239433;
double expected_max = 199;
double expected_mean = 55.118479221927501;
double expected_median = 36.815000534057617;
double expected_min = 0;
long expected_N = 2262;
double expected_RMS = 71.98149752438627;
double expected_skewness = 1.4988288344523237;
double expected_standarddev = 46.29567187238105;
double expected_UPP = 0.023286748110675673;
double expected_uniformity = 0.023286748110675673;
double expected_variance = 2143.2892341151742;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 214;
expected_minIndex[1] = 169;
expected_minIndex[2] = 10;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 99;
expected_maxIndex[1] = 169;
expected_maxIndex[2] = 17;
mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
pfMaskGen->SetInputImage(m_US4DImage);
pfMaskGen->SetPlanarFigure(m_US4DPlanarFigureCoronal);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_US4DImage, 1, pfMaskGen.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestUS4DCylImageMaskStatistics_time1_label_1()
{
MITK_INFO << std::endl << "Test US4D image mask time 1 label 1:-----------------------------------------------------------------------------------";
double expected_entropy = 5.0082903903398677;
double expected_kurtosis = 3.6266994778237809;
double expected_MPP = 169.58938547486034;
double expected_max = 199;
double expected_mean = 169.58938547486034;
double expected_median = 187.44000244140625;
double expected_min = 63;
long expected_N = 716;
double expected_RMS = 173.09843164831432;
double expected_skewness = -1.2248969838579555;
double expected_standarddev = 34.677188083311712;
double expected_UPP = 0.076601073624418703;
double expected_uniformity = 0.076601073624418703;
double expected_variance = 1202.5073733653758;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 82;
expected_minIndex[1] = 158;
expected_minIndex[2] = 19;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 126;
expected_maxIndex[1] = 140;
expected_maxIndex[2] = 19;
mitk::ImageMaskGenerator::Pointer imgMask1 = mitk::ImageMaskGenerator::New();
imgMask1->SetInputImage(m_US4DImage);
imgMask1->SetImageMask(m_US4DImageMask);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_US4DImage, 1, imgMask1.GetPointer(), nullptr, 1);
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestUS4DCylImageMaskStatistics_time2_label_1()
{
MITK_INFO << std::endl << "Test US4D image mask time 2 label 1:-----------------------------------------------------------------------------------";
double expected_entropy = 5.1857604214916506;
double expected_kurtosis = 3.0692303858330683;
double expected_MPP = 167.97194163860831;
double expected_max = 199;
double expected_mean = 167.97194163860831;
double expected_median = 184.39499664306641;
double expected_min = 72;
long expected_N = 891;
double expected_RMS = 171.67986611998634;
double expected_skewness = -1.1221651136259736;
double expected_standarddev = 35.488071983870803;
double expected_UPP = 0.063124070232188439;
double expected_uniformity = 0.063124070232188439;
double expected_variance = 1259.4032531323958;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 103;
expected_minIndex[1] = 212;
expected_minIndex[2] = 19;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 102;
expected_maxIndex[1] = 168;
expected_maxIndex[2] = 19;
mitk::ImageMaskGenerator::Pointer imgMask1 = mitk::ImageMaskGenerator::New();
imgMask1->SetInputImage(m_US4DImage);
imgMask1->SetImageMask(m_US4DImageMask);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_US4DImage, 2, imgMask1.GetPointer(), nullptr, 1);
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestUS4DCylImageMaskStatistics_time1_label_2()
{
MITK_INFO << std::endl << "Test US4D image mask time 1 label 2:-----------------------------------------------------------------------------------";
double expected_entropy = 5.0822234230119001;
double expected_kurtosis = 2.4346603343623747;
double expected_MPP = 20.733626373626375;
double expected_max = 46;
double expected_mean = 20.624836029733274;
double expected_median = 20.010000228881836;
double expected_min = 0;
long expected_N = 2287;
double expected_RMS = 22.508347574573804;
double expected_skewness = 0.13837218490626488;
double expected_standarddev = 9.0134260569684965;
double expected_UPP = 0.034783970308787;
double expected_uniformity = 0.034783970308787;
double expected_variance = 81.241849284438644;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 178;
expected_minIndex[1] = 76;
expected_minIndex[2] = 19;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 198;
expected_maxIndex[1] = 90;
expected_maxIndex[2] = 19;
mitk::ImageMaskGenerator::Pointer imgMask1 = mitk::ImageMaskGenerator::New();
imgMask1->SetInputImage(m_US4DImage);
imgMask1->SetImageMask(m_US4DImageMask);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_US4DImage, 1, imgMask1.GetPointer(), nullptr, 2);
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestUS4DCylIgnorePixelValueMaskStatistics_time1()
{
MITK_INFO << std::endl << "Test US4D ignore zero pixels:-----------------------------------------------------------------------------------";
double expected_entropy = 5.8609813848087962;
double expected_kurtosis = 4.7556214582883651;
double expected_MPP = 53.395358640738536;
double expected_max = 199;
double expected_mean = 53.395358640738536;
double expected_median = 35.649999618530273;
double expected_min = 1;
long expected_N = 2284417;
double expected_RMS = 72.382339046507084;
double expected_skewness = 1.588289859859108;
double expected_standarddev = 48.868585834566694;
double expected_UPP = 0.023927063695115193;
double expected_uniformity = 0.023927063695115193;
double expected_variance = 2388.1386814704128;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 187;
expected_minIndex[1] = 19;
expected_minIndex[2] = 0;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 268;
expected_maxIndex[1] = 101;
expected_maxIndex[2] = 0;
mitk::IgnorePixelMaskGenerator::Pointer ignPixelValMask = mitk::IgnorePixelMaskGenerator::New();
ignPixelValMask->SetInputImage(m_US4DImage);
ignPixelValMask->SetIgnoredPixelValue(0);
ignPixelValMask->SetTimeStep(1);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_US4DImage, 1, ignPixelValMask.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
void mitkImageStatisticsCalculatorTestSuite::TestUS4DCylSecondaryMaskStatistics_time1()
{
MITK_INFO << std::endl << "Test US4d ignore zero pixels AND Image mask 2:-----------------------------------------------------------------------------------";
double expected_entropy = 4.9955858614274558;
double expected_kurtosis = 17.471042803365179;
double expected_MPP = 32.791403286978507;
double expected_max = 199;
double expected_mean = 32.791403286978507;
double expected_median = 25.75;
double expected_min = 1;
long expected_N = 17402;
double expected_RMS = 42.776697859745241;
double expected_skewness = 3.3991813038552596;
double expected_standarddev = 27.469433016621732;
double expected_UPP = 0.043040554251756687;
double expected_uniformity = 0.043040554251756687;
double expected_variance = 754.56975025466807;
vnl_vector<int> expected_minIndex;
expected_minIndex.set_size(3);
expected_minIndex[0] = 177;
expected_minIndex[1] = 27;
expected_minIndex[2] = 36;
vnl_vector<int> expected_maxIndex;
expected_maxIndex.set_size(3);
expected_maxIndex[0] = 109;
expected_maxIndex[1] = 116;
expected_maxIndex[2] = 36;
mitk::IgnorePixelMaskGenerator::Pointer ignPixelValMask = mitk::IgnorePixelMaskGenerator::New();
ignPixelValMask->SetInputImage(m_US4DImage);
ignPixelValMask->SetIgnoredPixelValue(0);
mitk::ImageMaskGenerator::Pointer imgMaskGen2 = mitk::ImageMaskGenerator::New();
imgMaskGen2->SetImageMask(m_US4DImageMask2);
imgMaskGen2->SetInputImage(m_US4DImage);
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer result = ComputeStatisticsNew(m_US4DImage, 1, imgMaskGen2.GetPointer(), ignPixelValMask.GetPointer());
//std::cout << result->GetAsString();
VerifyStatistics(result,
expected_N,
expected_mean,
expected_MPP,
expected_median,
expected_skewness,
expected_kurtosis,
expected_uniformity,
expected_UPP,
expected_variance,
expected_standarddev,
expected_min,
expected_max,
expected_RMS,
expected_entropy,
expected_minIndex,
expected_maxIndex);
}
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer
mitkImageStatisticsCalculatorTestSuite::ComputeStatistics( mitk::Image::Pointer image, mitk::PlanarFigure::Pointer polygon )
{
mitk::ImageStatisticsCalculator::Pointer statisticsCalculator = mitk::ImageStatisticsCalculator::New();
statisticsCalculator->SetInputImage( image );
statisticsCalculator->SetNBinsForHistogramStatistics(10);
mitk::PlanarFigureMaskGenerator::Pointer planFigMaskGen = mitk::PlanarFigureMaskGenerator::New();
planFigMaskGen->SetInputImage(image);
planFigMaskGen->SetPlanarFigure(polygon);
statisticsCalculator->SetMask(planFigMaskGen.GetPointer());
try
{
return statisticsCalculator->GetStatistics();
}
catch( ... )
{
}
return mitk::ImageStatisticsCalculator::StatisticsContainer::New();
}
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer
mitkImageStatisticsCalculatorTestSuite::ComputeStatistics(mitk::Image::Pointer image, mitk::Image::Pointer image_mask )
{
mitk::ImageStatisticsCalculator::Pointer statisticsCalculator = mitk::ImageStatisticsCalculator::New();
statisticsCalculator->SetInputImage(image);
statisticsCalculator->SetNBinsForHistogramStatistics(10);
mitk::ImageMaskGenerator::Pointer imgMaskGen = mitk::ImageMaskGenerator::New();
imgMaskGen->SetImageMask(image_mask);
statisticsCalculator->SetMask(imgMaskGen.GetPointer());
return statisticsCalculator->GetStatistics();
}
const mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer
mitkImageStatisticsCalculatorTestSuite::ComputeStatisticsNew(mitk::Image::Pointer image,
int timeStep,
mitk::MaskGenerator::Pointer maskGen,
mitk::MaskGenerator::Pointer secondardMaskGen,
unsigned short label)
{
mitk::ImageStatisticsCalculator::Pointer imgStatCalc = mitk::ImageStatisticsCalculator::New();
imgStatCalc->SetInputImage(image);
if (maskGen.IsNotNull())
{
imgStatCalc->SetMask(maskGen.GetPointer());
if (secondardMaskGen.IsNotNull())
{
imgStatCalc->SetSecondaryMask(secondardMaskGen.GetPointer());
}
}
return imgStatCalc->GetStatistics(timeStep, label);
}
void mitkImageStatisticsCalculatorTestSuite::VerifyStatistics(mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer stats,
double testMean, double testSD, double testMedian)
{
int tmpMean = stats->GetMean() * 100;
double calculatedMean = tmpMean / 100.0;
MITK_TEST_CONDITION( calculatedMean == testMean,
"Calculated mean grayvalue '" << calculatedMean <<
"' is equal to the desired value '" << testMean << "'" );
int tmpSD = stats->GetStd() * 100;
double calculatedSD = tmpSD / 100.0;
MITK_TEST_CONDITION( calculatedSD == testSD,
"Calculated grayvalue sd '" << calculatedSD <<
"' is equal to the desired value '" << testSD <<"'" );
int tmpMedian = stats->GetMedian() * 100;
double calculatedMedian = tmpMedian / 100.0;
MITK_TEST_CONDITION( testMedian == calculatedMedian,
"Calculated median grayvalue '" << calculatedMedian <<
"' is equal to the desired value '" << testMedian << "'");
}
void mitkImageStatisticsCalculatorTestSuite::VerifyStatistics(mitk::ImageStatisticsCalculator::StatisticsContainer::Pointer stats,
long N,
double mean,
double MPP,
double median,
double skewness,
double kurtosis,
double uniformity,
double UPP,
double variance,
double stdev,
double min,
double max,
double RMS,
double entropy,
vnl_vector<int> minIndex,
vnl_vector<int> maxIndex)
{
MITK_TEST_CONDITION(std::abs(stats->GetN() - N) < mitk::eps, "calculated N: " << stats->GetN() << " expected N: " << N);
MITK_TEST_CONDITION(std::abs(stats->GetMean() - mean) < mitk::eps, "calculated mean: " << stats->GetMean() << " expected mean: " << mean);
// in one test case MPP is None because the roi has no positive pixels
if (!std::isnan(stats->GetMPP()))
{
MITK_TEST_CONDITION(std::abs(stats->GetMPP() - MPP) < mitk::eps, "calculated MPP: " << stats->GetMPP() << " expected MPP: " << MPP);
}
MITK_TEST_CONDITION(std::abs(stats->GetMedian() - median) < mitk::eps, "calculated median: " << stats->GetMedian() << " expected median: " << median);
MITK_TEST_CONDITION(std::abs(stats->GetSkewness() - skewness) < mitk::eps, "calculated skewness: " << stats->GetSkewness() << " expected skewness: " << skewness);
MITK_TEST_CONDITION(std::abs(stats->GetKurtosis() - kurtosis) < mitk::eps, "calculated kurtosis: " << stats->GetKurtosis() << " expected kurtosis: " << kurtosis);
MITK_TEST_CONDITION(std::abs(stats->GetUniformity() - uniformity) < mitk::eps, "calculated uniformity: " << stats->GetUniformity() << " expected uniformity: " << uniformity);
MITK_TEST_CONDITION(std::abs(stats->GetUPP() - UPP) < mitk::eps, "calculated UPP: " << stats->GetUPP() << " expected UPP: " << UPP);
MITK_TEST_CONDITION(std::abs(stats->GetVariance() - variance) < mitk::eps, "calculated variance: " << stats->GetVariance() << " expected variance: " << variance);
MITK_TEST_CONDITION(std::abs(stats->GetStd() - stdev) < mitk::eps, "calculated stdev: " << stats->GetStd() << " expected stdev: " << stdev);
MITK_TEST_CONDITION(std::abs(stats->GetMin() - min) < mitk::eps, "calculated min: " << stats->GetMin() << " expected min: " << min);
MITK_TEST_CONDITION(std::abs(stats->GetMax() - max) < mitk::eps, "calculated max: " << stats->GetMax() << " expected max: " << max);
MITK_TEST_CONDITION(std::abs(stats->GetRMS() - RMS) < mitk::eps, "calculated RMS: " << stats->GetRMS() << " expected RMS: " << RMS);
MITK_TEST_CONDITION(std::abs(stats->GetEntropy() - entropy) < mitk::eps, "calculated entropy: " << stats->GetEntropy() << " expected entropy: " << entropy);
for (unsigned int i = 0; i < minIndex.size(); ++i)
{
MITK_TEST_CONDITION(std::abs(stats->GetMinIndex()[i] - minIndex[i]) < mitk::eps, "minIndex [" << i << "] = " << stats->GetMinIndex()[i] << " expected: " << minIndex[i]);
}
for (unsigned int i = 0; i < maxIndex.size(); ++i)
{
MITK_TEST_CONDITION(std::abs(stats->GetMaxIndex()[i] - maxIndex[i]) < mitk::eps, "maxIndex [" << i << "] = " << stats->GetMaxIndex()[i] << " expected: " << maxIndex[i]);
}
}
void mitkImageStatisticsCalculatorTestSuite::TestUninitializedImage()
{
/*****************************
* loading uninitialized image to datastorage
******************************/
MITK_INFO << std::endl << "Test uninitialized image: -----------------------------------------------------------------------------------";
MITK_TEST_FOR_EXCEPTION_BEGIN(mitk::Exception)
mitk::Image::Pointer image = mitk::Image::New();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(image);
mitk::ImageStatisticsCalculator::Pointer is = mitk::ImageStatisticsCalculator::New();
is->GetStatistics();
MITK_TEST_FOR_EXCEPTION_END(mitk::Exception)
}
MITK_TEST_SUITE_REGISTRATION(mitkImageStatisticsCalculator)
diff --git a/Modules/ImageStatistics/mitkHotspotMaskGenerator.cpp b/Modules/ImageStatistics/mitkHotspotMaskGenerator.cpp
index da07560989..2f44d1affb 100644
--- a/Modules/ImageStatistics/mitkHotspotMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkHotspotMaskGenerator.cpp
@@ -1,595 +1,619 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
#include <mitkHotspotMaskGenerator.h>
#include <mitkImageTimeSelector.h>
#include <mitkImageCast.h>
#include <mitkPoint.h>
#include <itkImageRegionIterator.h>
#include "mitkImageAccessByItk.h"
#include <itkImageDuplicator.h>
#include <itkFFTConvolutionImageFilter.h>
#include <mitkITKImageImport.h>
namespace mitk
{
HotspotMaskGenerator::HotspotMaskGenerator():
m_HotspotRadiusinMM(6.2035049089940), // radius of a 1cm3 sphere in mm
m_HotspotMustBeCompletelyInsideImage(true),
m_Label(1)
{
m_TimeStep = 0;
m_InternalMask = mitk::Image::New();
m_InternalMaskUpdateTime = 0;
}
void HotspotMaskGenerator::SetInputImage(mitk::Image::Pointer inputImage)
{
if (inputImage != m_inputImage)
{
m_inputImage = inputImage;
m_ConvolutionImageMaxIndex.set_size(inputImage->GetDimension());
m_ConvolutionImageMinIndex.set_size(inputImage->GetDimension());
this->Modified();
}
}
void HotspotMaskGenerator::SetMask(MaskGenerator::Pointer mask)
{
if (mask != m_Mask)
{
m_Mask = mask;
this->Modified();
}
}
HotspotMaskGenerator::~HotspotMaskGenerator()
{
}
void HotspotMaskGenerator::SetHotspotRadiusInMM(double radiusInMillimeter)
{
if(radiusInMillimeter != m_HotspotRadiusinMM)
{
m_HotspotRadiusinMM = radiusInMillimeter;
this->Modified();
}
}
const double& HotspotMaskGenerator::GetHotspotRadiusinMM() const
{
return m_HotspotRadiusinMM;
}
bool HotspotMaskGenerator::GetHotspotMustBeCompletelyInsideImage() const
{
return m_HotspotMustBeCompletelyInsideImage;
}
void HotspotMaskGenerator::SetHotspotMustBeCompletelyInsideImage(bool mustBeCompletelyInImage)
{
if (m_HotspotMustBeCompletelyInsideImage != mustBeCompletelyInImage)
{
m_HotspotMustBeCompletelyInsideImage = mustBeCompletelyInImage;
this->Modified();
}
}
mitk::Image::Pointer HotspotMaskGenerator::GetMask()
{
if (IsUpdateRequired())
{
if ( m_inputImage.IsNull() )
{
throw std::runtime_error( "Error: image empty!" );
}
if ( m_TimeStep >= m_inputImage->GetTimeSteps() )
{
throw std::runtime_error( "Error: invalid time step!" );
}
mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
imageTimeSelector->SetInput( m_inputImage );
imageTimeSelector->SetTimeNr( m_TimeStep );
imageTimeSelector->UpdateLargestPossibleRegion();
mitk::Image::Pointer timeSliceImage = imageTimeSelector->GetOutput();
m_internalImage = timeSliceImage;
m_internalMask2D = nullptr; // is this correct when this variable holds a smart pointer?
m_internalMask3D = nullptr;
if ( m_Mask != nullptr )
{
m_Mask->SetTimeStep(m_TimeStep);
mitk::Image::Pointer timeSliceMask = m_Mask->GetMask();
if ( m_internalImage->GetDimension() == 3 )
{
CastToItkImage(timeSliceMask, m_internalMask3D);
AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 3, m_internalMask3D, m_Label);
}
else if ( m_internalImage->GetDimension() == 2 )
{
CastToItkImage(timeSliceMask, m_internalMask2D);
AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 2, m_internalMask2D, m_Label);
}
else
{
throw std::runtime_error( "Error: invalid image dimension" );
}
}
else
{
if ( m_internalImage->GetDimension() == 3 )
{
AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 3, m_internalMask3D, m_Label);
}
else if ( m_internalImage->GetDimension() == 2 )
{
AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 2, m_internalMask2D, m_Label);
}
else
{
throw std::runtime_error( "Error: invalid image dimension" );
}
}
this->Modified();
}
m_InternalMaskUpdateTime = m_InternalMask->GetMTime();
return m_InternalMask;
}
+ void HotspotMaskGenerator::SetTimeStep(unsigned int timeStep)
+ {
+ if (m_TimeStep != timeStep)
+ {
+ m_TimeStep = timeStep;
+ }
+ }
+
void HotspotMaskGenerator::SetLabel(unsigned short label)
{
if (label != m_Label)
{
m_Label = label;
this->Modified();
}
}
vnl_vector<int> HotspotMaskGenerator::GetConvolutionImageMinIndex()
{
this->GetMask(); // make sure we are up to date
return m_ConvolutionImageMinIndex;
}
vnl_vector<int> HotspotMaskGenerator::GetHotspotIndex()
{
this->GetMask(); // make sure we are up to date
return m_ConvolutionImageMaxIndex;
}
template <typename TPixel, unsigned int VImageDimension >
HotspotMaskGenerator::ImageExtrema
HotspotMaskGenerator::CalculateExtremaWorld( const itk::Image<TPixel, VImageDimension>* inputImage,
typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
double neccessaryDistanceToImageBorderInMM,
unsigned int label )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
typedef itk::ImageRegionConstIteratorWithIndex<MaskImageType> MaskImageIteratorType;
typedef itk::ImageRegionConstIteratorWithIndex<ImageType> InputImageIndexIteratorType;
typename ImageType::SpacingType spacing = inputImage->GetSpacing();
ImageExtrema minMax;
minMax.Defined = false;
minMax.MaxIndex.set_size(VImageDimension);
minMax.MaxIndex.set_size(VImageDimension);
typename ImageType::RegionType allowedExtremaRegion = inputImage->GetLargestPossibleRegion();
bool keepDistanceToImageBorders( neccessaryDistanceToImageBorderInMM > 0 );
if (keepDistanceToImageBorders)
{
long distanceInPixels[VImageDimension];
for(unsigned short dimension = 0; dimension < VImageDimension; ++dimension)
{
// To confirm that the whole hotspot is inside the image we have to keep a specific distance to the image-borders, which is as long as
// the radius. To get the amount of indices we divide the radius by spacing and add 0.5 because voxels are center based:
// For example with a radius of 2.2 and a spacing of 1 two indices are enough because 2.2 / 1 + 0.5 = 2.7 => 2.
// But with a radius of 2.7 we need 3 indices because 2.7 / 1 + 0.5 = 3.2 => 3
distanceInPixels[dimension] = int( neccessaryDistanceToImageBorderInMM / spacing[dimension] + 0.5);
}
allowedExtremaRegion.ShrinkByRadius(distanceInPixels);
}
InputImageIndexIteratorType imageIndexIt(inputImage, allowedExtremaRegion);
float maxValue = itk::NumericTraits<float>::min();
float minValue = itk::NumericTraits<float>::max();
typename ImageType::IndexType maxIndex;
typename ImageType::IndexType minIndex;
for(unsigned short i = 0; i < VImageDimension; ++i)
{
maxIndex[i] = 0;
minIndex[i] = 0;
}
if (maskImage != nullptr)
{
MaskImageIteratorType maskIt(maskImage, maskImage->GetLargestPossibleRegion());
typename ImageType::IndexType imageIndex;
typename ImageType::PointType worldPosition;
typename ImageType::IndexType maskIndex;
for(maskIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt)
{
imageIndex = maskIndex = maskIt.GetIndex();
if(maskIt.Get() == label)
{
if( allowedExtremaRegion.IsInside(imageIndex) )
{
imageIndexIt.SetIndex( imageIndex );
double value = imageIndexIt.Get();
minMax.Defined = true;
//Calculate minimum, maximum and corresponding index-values
if( value > maxValue )
{
maxIndex = imageIndexIt.GetIndex();
maxValue = value;
}
if(value < minValue )
{
minIndex = imageIndexIt.GetIndex();
minValue = value;
}
}
}
}
}
else
{
for(imageIndexIt.GoToBegin(); !imageIndexIt.IsAtEnd(); ++imageIndexIt)
{
double value = imageIndexIt.Get();
minMax.Defined = true;
//Calculate minimum, maximum and corresponding index-values
if( value > maxValue )
{
maxIndex = imageIndexIt.GetIndex();
maxValue = value;
}
if(value < minValue )
{
minIndex = imageIndexIt.GetIndex();
minValue = value;
}
}
}
minMax.MaxIndex.set_size(VImageDimension);
minMax.MinIndex.set_size(VImageDimension);
for(unsigned int i = 0; i < minMax.MaxIndex.size(); ++i)
{
minMax.MaxIndex[i] = maxIndex[i];
}
for(unsigned int i = 0; i < minMax.MinIndex.size(); ++i)
{
minMax.MinIndex[i] = minIndex[i];
}
minMax.Max = maxValue;
minMax.Min = minValue;
return minMax;
}
template <unsigned int VImageDimension>
itk::Size<VImageDimension>
HotspotMaskGenerator::CalculateConvolutionKernelSize( double spacing[VImageDimension],
double radiusInMM )
{
typedef itk::Image< float, VImageDimension > KernelImageType;
typedef typename KernelImageType::SizeType SizeType;
SizeType maskSize;
for(unsigned int i = 0; i < VImageDimension; ++i)
{
maskSize[i] = static_cast<int>( 2 * radiusInMM / spacing[i]);
// We always want an uneven size to have a clear center point in the convolution mask
if(maskSize[i] % 2 == 0 )
{
++maskSize[i];
}
}
return maskSize;
}
template <unsigned int VImageDimension>
itk::SmartPointer< itk::Image<float, VImageDimension> >
HotspotMaskGenerator::GenerateHotspotSearchConvolutionKernel(double mmPerPixel[VImageDimension],
double radiusInMM )
{
std::stringstream ss;
for (unsigned int i = 0; i < VImageDimension; ++i)
{
ss << mmPerPixel[i];
if (i < VImageDimension -1)
ss << ",";
}
MITK_DEBUG << "Update convolution kernel for spacing (" << ss.str() << ") and radius " << radiusInMM << "mm";
double radiusInMMSquared = radiusInMM * radiusInMM;
typedef itk::Image< float, VImageDimension > KernelImageType;
typename KernelImageType::Pointer convolutionKernel = KernelImageType::New();
// Calculate size and allocate mask image
typedef typename KernelImageType::SizeType SizeType;
SizeType maskSize = this->CalculateConvolutionKernelSize<VImageDimension>(mmPerPixel, radiusInMM);
mitk::Point3D convolutionMaskCenterIndex;
convolutionMaskCenterIndex.Fill(0.0);
for(unsigned int i = 0; i < VImageDimension; ++i)
{
convolutionMaskCenterIndex[i] = 0.5 * (double)(maskSize[i]-1);
}
typedef typename KernelImageType::IndexType IndexType;
IndexType maskIndex;
maskIndex.Fill(0);
typedef typename KernelImageType::RegionType RegionType;
RegionType maskRegion;
maskRegion.SetSize(maskSize);
maskRegion.SetIndex(maskIndex);
convolutionKernel->SetRegions(maskRegion);
convolutionKernel->SetSpacing(mmPerPixel);
convolutionKernel->Allocate();
// Fill mask image values by subsampling the image grid
typedef itk::ImageRegionIteratorWithIndex<KernelImageType> MaskIteratorType;
MaskIteratorType maskIt(convolutionKernel,maskRegion);
int numberOfSubVoxelsPerDimension = 2; // per dimension!
int numberOfSubVoxels = ::pow( static_cast<float>(numberOfSubVoxelsPerDimension), static_cast<float>(VImageDimension) );
double subVoxelSizeInPixels = 1.0 / (double)numberOfSubVoxelsPerDimension;
double valueOfOneSubVoxel = 1.0 / (double)numberOfSubVoxels;
double maskValue = 0.0;
mitk::Point3D subVoxelIndexPosition;
double distanceSquared = 0.0;
typedef itk::ContinuousIndex<double, VImageDimension> ContinuousIndexType;
for(maskIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt)
{
ContinuousIndexType indexPoint(maskIt.GetIndex());
mitk::Point3D voxelPosition;
for (unsigned int dimension = 0; dimension < VImageDimension; ++dimension)
{
voxelPosition[dimension] = indexPoint[dimension];
}
maskValue = 0.0;
mitk::Vector3D subVoxelOffset; subVoxelOffset.Fill(0.0);
// iterate sub-voxels by iterating all possible offsets
for (subVoxelOffset[0] = -0.5 + subVoxelSizeInPixels / 2.0;
subVoxelOffset[0] < +0.5;
subVoxelOffset[0] += subVoxelSizeInPixels)
{
for (subVoxelOffset[1] = -0.5 + subVoxelSizeInPixels / 2.0;
subVoxelOffset[1] < +0.5;
subVoxelOffset[1] += subVoxelSizeInPixels)
{
for (subVoxelOffset[2] = -0.5 + subVoxelSizeInPixels / 2.0;
subVoxelOffset[2] < +0.5;
subVoxelOffset[2] += subVoxelSizeInPixels)
{
subVoxelIndexPosition = voxelPosition + subVoxelOffset; // this COULD be integrated into the for-loops if neccessary (add voxelPosition to initializer and end condition)
distanceSquared =
(subVoxelIndexPosition[0]-convolutionMaskCenterIndex[0]) * mmPerPixel[0] * (subVoxelIndexPosition[0]-convolutionMaskCenterIndex[0]) * mmPerPixel[0]
+ (subVoxelIndexPosition[1]-convolutionMaskCenterIndex[1]) * mmPerPixel[1] * (subVoxelIndexPosition[1]-convolutionMaskCenterIndex[1]) * mmPerPixel[1]
+ (subVoxelIndexPosition[2]-convolutionMaskCenterIndex[2]) * mmPerPixel[2] * (subVoxelIndexPosition[2]-convolutionMaskCenterIndex[2]) * mmPerPixel[2];
if (distanceSquared <= radiusInMMSquared)
{
maskValue += valueOfOneSubVoxel;
}
}
}
}
maskIt.Set( maskValue );
}
return convolutionKernel;
}
template <typename TPixel, unsigned int VImageDimension>
itk::SmartPointer<itk::Image<TPixel, VImageDimension> >
HotspotMaskGenerator::GenerateConvolutionImage( const itk::Image<TPixel, VImageDimension>* inputImage )
{
double mmPerPixel[VImageDimension];
for (unsigned int dimension = 0; dimension < VImageDimension; ++dimension)
{
mmPerPixel[dimension] = inputImage->GetSpacing()[dimension];
}
// update convolution kernel
typedef itk::Image< float, VImageDimension > KernelImageType;
typename KernelImageType::Pointer convolutionKernel = this->GenerateHotspotSearchConvolutionKernel<VImageDimension>(mmPerPixel, m_HotspotRadiusinMM);
// update convolution image
typedef itk::Image< TPixel, VImageDimension > InputImageType;
typedef itk::Image< TPixel, VImageDimension > ConvolutionImageType;
typedef itk::FFTConvolutionImageFilter<InputImageType,
KernelImageType,
ConvolutionImageType> ConvolutionFilterType;
typename ConvolutionFilterType::Pointer convolutionFilter = ConvolutionFilterType::New();
typedef itk::ConstantBoundaryCondition<InputImageType, InputImageType> BoundaryConditionType;
BoundaryConditionType boundaryCondition;
boundaryCondition.SetConstant(0.0);
if (m_HotspotMustBeCompletelyInsideImage)
{
// overwrite default boundary condition
convolutionFilter->SetBoundaryCondition(&boundaryCondition);
}
convolutionFilter->SetInput(inputImage);
convolutionFilter->SetKernelImage(convolutionKernel);
convolutionFilter->SetNormalize(true);
MITK_DEBUG << "Update Convolution image for hotspot search";
convolutionFilter->UpdateLargestPossibleRegion();
typename ConvolutionImageType::Pointer convolutionImage = convolutionFilter->GetOutput();
convolutionImage->SetSpacing( inputImage->GetSpacing() ); // only workaround because convolution filter seems to ignore spacing of input image
return convolutionImage;
}
template < typename TPixel, unsigned int VImageDimension>
void
HotspotMaskGenerator::FillHotspotMaskPixels( itk::Image<TPixel, VImageDimension>* maskImage,
itk::Point<double, VImageDimension> sphereCenter,
double sphereRadiusInMM )
{
typedef itk::Image< TPixel, VImageDimension > MaskImageType;
typedef itk::ImageRegionIteratorWithIndex<MaskImageType> MaskImageIteratorType;
MaskImageIteratorType maskIt(maskImage, maskImage->GetLargestPossibleRegion());
typename MaskImageType::IndexType maskIndex;
typename MaskImageType::PointType worldPosition;
// this is not very smart. I would rather use a 0 initialized mask (not the case here -> blame CalculateHotspotMask) and find the region where I need to iterate over, then iterate only over the small region
for(maskIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt)
{
maskIndex = maskIt.GetIndex();
maskImage->TransformIndexToPhysicalPoint(maskIndex, worldPosition);
maskIt.Set( worldPosition.EuclideanDistanceTo(sphereCenter) <= sphereRadiusInMM ? 1 : 0 );
}
}
template <typename TPixel, unsigned int VImageDimension>
void
HotspotMaskGenerator::CalculateHotspotMask(itk::Image<TPixel, VImageDimension>* inputImage,
typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
unsigned int label)
{
typedef itk::Image< TPixel, VImageDimension > InputImageType;
typedef itk::Image< TPixel, VImageDimension > ConvolutionImageType;
typedef itk::Image< float, VImageDimension > KernelImageType;
typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
typename ConvolutionImageType::Pointer convolutionImage = this->GenerateConvolutionImage(inputImage);
if (convolutionImage.IsNull())
{
MITK_ERROR << "Empty convolution image in CalculateHotspotStatistics(). We should never reach this state (logic error).";
throw std::logic_error("Empty convolution image in CalculateHotspotStatistics()");
}
// if mask image is not defined, create an image of the same size as inputImage and fill it with 1's
// there is maybe a better way to do this!?
if (maskImage == nullptr)
{
maskImage = MaskImageType::New();
typename MaskImageType::RegionType maskRegion = inputImage->GetLargestPossibleRegion();
typename MaskImageType::SpacingType maskSpacing = inputImage->GetSpacing();
typename MaskImageType::PointType maskOrigin = inputImage->GetOrigin();
typename MaskImageType::DirectionType maskDirection = inputImage->GetDirection();
maskImage->SetRegions(maskRegion);
maskImage->Allocate();
maskImage->SetOrigin(maskOrigin);
maskImage->SetSpacing(maskSpacing);
maskImage->SetDirection(maskDirection);
maskImage->FillBuffer(1);
label = 1;
}
// find maximum in convolution image, given the current mask
double requiredDistanceToBorder = m_HotspotMustBeCompletelyInsideImage ? m_HotspotRadiusinMM : -1.0;
ImageExtrema convolutionImageInformation = CalculateExtremaWorld(convolutionImage.GetPointer(), maskImage, requiredDistanceToBorder, label);
bool isHotspotDefined = convolutionImageInformation.Defined;
if (!isHotspotDefined)
{
MITK_ERROR << "No origin of hotspot-sphere was calculated!";
m_InternalMask = nullptr;
}
else
{
// create a binary mask around the "hotspot" region, fill the shape of a sphere around our hotspot center
// typename DuplicatorType::Pointer copyMachine = DuplicatorType::New();
// copyMachine->SetInputImage(inputImage);
// copyMachine->Update();
// typename CastFilterType::Pointer caster = CastFilterType::New();
// caster->SetInput( copyMachine->GetOutput() );
// caster->Update();
typename MaskImageType::Pointer hotspotMaskITK = MaskImageType::New();
hotspotMaskITK->SetOrigin(inputImage->GetOrigin());
hotspotMaskITK->SetSpacing(inputImage->GetSpacing());
hotspotMaskITK->SetLargestPossibleRegion(inputImage->GetLargestPossibleRegion());
hotspotMaskITK->SetBufferedRegion(inputImage->GetBufferedRegion());
hotspotMaskITK->SetDirection(inputImage->GetDirection());
hotspotMaskITK->SetNumberOfComponentsPerPixel(inputImage->GetNumberOfComponentsPerPixel());
hotspotMaskITK->Allocate();
hotspotMaskITK->FillBuffer(1);
typedef typename InputImageType::IndexType IndexType;
IndexType maskCenterIndex;
for (unsigned int d =0; d< VImageDimension;++d)
{
maskCenterIndex[d]=convolutionImageInformation.MaxIndex[d];
}
typename ConvolutionImageType::PointType maskCenter;
inputImage->TransformIndexToPhysicalPoint(maskCenterIndex,maskCenter);
FillHotspotMaskPixels(hotspotMaskITK.GetPointer(), maskCenter, m_HotspotRadiusinMM);
//obtain mitk::Image::Pointer from itk::Image
mitk::Image::Pointer hotspotMaskAsMITKImage = mitk::GrabItkImageMemory(hotspotMaskITK);
m_InternalMask = hotspotMaskAsMITKImage;
m_ConvolutionImageMaxIndex = convolutionImageInformation.MaxIndex;
m_ConvolutionImageMinIndex = convolutionImageInformation.MinIndex;
}
}
bool HotspotMaskGenerator::IsUpdateRequired() const
{
unsigned long thisClassTimeStamp = this->GetMTime();
unsigned long internalMaskTimeStamp = m_InternalMask->GetMTime();
unsigned long maskGeneratorTimeStamp = m_Mask->GetMTime();
unsigned long inputImageTimeStamp = m_inputImage->GetMTime();
if (thisClassTimeStamp > m_InternalMaskUpdateTime) // inputs have changed
{
return true;
}
if (m_InternalMaskUpdateTime < maskGeneratorTimeStamp || m_InternalMaskUpdateTime < inputImageTimeStamp) // mask image has changed outside of this class
{
return true;
}
if (internalMaskTimeStamp > m_InternalMaskUpdateTime) // internal mask has been changed outside of this class
{
return true;
}
return false;
}
}
diff --git a/Modules/ImageStatistics/mitkHotspotMaskGenerator.h b/Modules/ImageStatistics/mitkHotspotMaskGenerator.h
index 909fb6b1a6..aa7a43622e 100644
--- a/Modules/ImageStatistics/mitkHotspotMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkHotspotMaskGenerator.h
@@ -1,164 +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 MITKHOTSPOTCALCULATOR_H
#define MITKHOTSPOTCALCULATOR_H
#include <itkObject.h>
#include <mitkImage.h>
#include <itkImage.h>
#include <itkTimeStamp.h>
#include <stdexcept>
#include <MitkImageStatisticsExports.h>
#include <mitkImageTimeSelector.h>
#include <mitkMaskGenerator.h>
namespace mitk
{
/**
* @brief The HotspotMaskGenerator class is used when a hotspot has to be found in an image. A hotspot is
* the region of the image where the mean intensity is maximal (=brightest spot). It is usually used in PET scans.
* The identification of the hotspot is done as follows: First a cubic (or circular, if image is 2d)
* mask of predefined size is generated. This mask is then convolved with the input image (in fourier domain).
* The maximum value of the convolved image then corresponds to the hotspot.
* If a maskGenerator is set, only the pixels of the convolved image where the corresponding mask is == @a label
* are searched for the maximum value.
*/
class MITKIMAGESTATISTICS_EXPORT HotspotMaskGenerator: public MaskGenerator
{
public:
/** Standard Self typedef */
typedef HotspotMaskGenerator Self;
typedef MaskGenerator Superclass;
typedef itk::SmartPointer< Self > Pointer;
typedef itk::SmartPointer< const Self > ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(HotspotMaskGenerator, MaskGenerator)
/**
@brief Set the input image. Required for this class
*/
void SetInputImage(mitk::Image::Pointer inputImage);
/**
@brief Set a mask (can be nullptr if no mask is desired)
*/
void SetMask(MaskGenerator::Pointer mask);
/**
@brief Set the radius of the hotspot (in MM)
*/
void SetHotspotRadiusInMM(double radiusInMillimeter);
const double& GetHotspotRadiusinMM() const;
/**
@brief Define whether the hotspot must be completely inside the image. Default is true
*/
void SetHotspotMustBeCompletelyInsideImage(bool hotspotCompletelyInsideImage);
bool GetHotspotMustBeCompletelyInsideImage() const;
/**
@brief If a maskGenerator is set, this detemines which mask value is used
*/
void SetLabel(unsigned short label);
/**
@brief Computes and returns the hotspot mask. The hotspot mask has the same size as the input image. The hopspot has value 1, the remaining pixels are set to 0
*/
mitk::Image::Pointer GetMask();
/**
@brief Returns the image index where the hotspot is located
*/
vnl_vector<int> GetHotspotIndex();
/**
@brief Returns the index where the convolution image is minimal (darkest spot in image)
*/
vnl_vector<int> GetConvolutionImageMinIndex();
+ /**
+ * @brief SetTimeStep is used to set the time step for which the mask is to be generated
+ * @param timeStep
+ */
+ void SetTimeStep(unsigned int timeStep);
+
protected:
HotspotMaskGenerator();
~HotspotMaskGenerator();
class ImageExtrema
{
public:
bool Defined;
double Max;
double Min;
vnl_vector<int> MaxIndex;
vnl_vector<int> MinIndex;
ImageExtrema()
:Defined(false)
,Max(itk::NumericTraits<double>::min())
,Min(itk::NumericTraits<double>::max())
{
}
};
private:
/** \brief Returns size of convolution kernel depending on spacing and radius. */
template <unsigned int VImageDimension>
itk::Size<VImageDimension>
CalculateConvolutionKernelSize(double spacing[VImageDimension], double radiusInMM);
/** \brief Generates image of kernel which is needed for convolution. */
template <unsigned int VImageDimension>
itk::SmartPointer< itk::Image<float, VImageDimension> >
GenerateHotspotSearchConvolutionKernel(double spacing[VImageDimension], double radiusInMM);
/** \brief Convolves image with spherical kernel image. Used for hotspot calculation. */
template <typename TPixel, unsigned int VImageDimension>
itk::SmartPointer< itk::Image<TPixel, VImageDimension> >
GenerateConvolutionImage( const itk::Image<TPixel, VImageDimension>* inputImage );
/** \brief Fills pixels of the spherical hotspot mask. */
template < typename TPixel, unsigned int VImageDimension>
void
FillHotspotMaskPixels( itk::Image<TPixel, VImageDimension>* maskImage,
itk::Point<double, VImageDimension> sphereCenter,
double sphereRadiusInMM);
/** \brief */
template <typename TPixel, unsigned int VImageDimension>
void
CalculateHotspotMask(itk::Image<TPixel, VImageDimension>* inputImage,
typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
unsigned int label);
template <typename TPixel, unsigned int VImageDimension >
ImageExtrema CalculateExtremaWorld( const itk::Image<TPixel, VImageDimension>* inputImage,
typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
double neccessaryDistanceToImageBorderInMM,
unsigned int label);
bool IsUpdateRequired() const;
HotspotMaskGenerator(const HotspotMaskGenerator &);
HotspotMaskGenerator & operator=(const HotspotMaskGenerator &);
MaskGenerator::Pointer m_Mask;
mitk::Image::Pointer m_internalImage;
itk::Image<unsigned short, 2>::Pointer m_internalMask2D;
itk::Image<unsigned short, 3>::Pointer m_internalMask3D;
double m_HotspotRadiusinMM;
bool m_HotspotMustBeCompletelyInsideImage;
bool m_HotspotParamsChanged;
unsigned short m_Label;
vnl_vector<int> m_ConvolutionImageMinIndex, m_ConvolutionImageMaxIndex;
unsigned long m_InternalMaskUpdateTime;
};
}
#endif // MITKHOTSPOTCALCULATOR
diff --git a/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.cpp b/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.cpp
index ba068667dd..cd78539223 100644
--- a/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.cpp
@@ -1,112 +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 <mitkIgnorePixelMaskGenerator.h>
#include <mitkImageTimeSelector.h>
#include <mitkImageAccessByItk.h>
#include <itkImageIterator.h>
#include <itkImageConstIterator.h>
#include <mitkITKImageImport.h>
namespace mitk
{
void IgnorePixelMaskGenerator::SetIgnoredPixelValue(RealType pixelValue)
{
if (pixelValue != m_IgnoredPixelValue)
{
m_IgnoredPixelValue = pixelValue;
this->Modified();
}
}
+void IgnorePixelMaskGenerator::SetTimeStep(unsigned int timeStep)
+{
+ if (m_TimeStep != timeStep)
+ {
+ m_TimeStep = timeStep;
+ }
+}
+
mitk::Image::Pointer IgnorePixelMaskGenerator::GetMask()
{
if (IsUpdateRequired())
{
if (m_inputImage.IsNull())
{
MITK_ERROR << "Image not set!";
}
if (m_IgnoredPixelValue == std::numeric_limits<RealType>::min())
{
MITK_ERROR << "IgnotePixelValue not set!";
}
if (m_TimeStep > (m_inputImage->GetTimeSteps() - 1))
{
MITK_ERROR << "Invalid time step: " << m_TimeStep << ". The image has " << m_inputImage->GetTimeSteps() << " timeSteps!";
}
// extractimage time slice
ImageTimeSelector::Pointer imgTimeSel = ImageTimeSelector::New();
imgTimeSel->SetInput(m_inputImage);
imgTimeSel->SetTimeNr(m_TimeStep);
imgTimeSel->UpdateLargestPossibleRegion();
mitk::Image::Pointer timeSliceImage = imgTimeSel->GetOutput();
// update m_InternalMask
AccessByItk(timeSliceImage, InternalCalculateMask);
m_InternalMask->SetGeometry(timeSliceImage->GetGeometry());
this->Modified();
}
m_InternalMaskUpdateTime = m_InternalMask->GetMTime();
return m_InternalMask;
}
template <typename TPixel, unsigned int VImageDimension>
void IgnorePixelMaskGenerator::InternalCalculateMask(typename itk::Image<TPixel, VImageDimension>* image)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::Image<unsigned short, VImageDimension> MaskType;
typename MaskType::Pointer mask = MaskType::New();
mask->SetOrigin(image->GetOrigin());
mask->SetSpacing(image->GetSpacing());
mask->SetLargestPossibleRegion(image->GetLargestPossibleRegion());
mask->SetBufferedRegion(image->GetBufferedRegion());
mask->SetDirection(image->GetDirection());
mask->SetNumberOfComponentsPerPixel(image->GetNumberOfComponentsPerPixel());
mask->Allocate();
mask->FillBuffer(1);
// iterate over image and mask and set mask=1 if image=m_IgnorePixelValue
itk::ImageRegionConstIterator<ImageType> imageIterator(image, image->GetLargestPossibleRegion());
itk::ImageRegionIterator<MaskType> maskIterator(mask, mask->GetLargestPossibleRegion());
for (imageIterator.GoToBegin(); !imageIterator.IsAtEnd(); ++imageIterator, ++maskIterator)
{
if (imageIterator.Value() == static_cast<TPixel>(m_IgnoredPixelValue))
{
maskIterator.Set(0);
}
}
m_InternalMask = GrabItkImageMemory(mask);
}
bool IgnorePixelMaskGenerator::IsUpdateRequired() const
{
unsigned long thisClassTimeStamp = this->GetMTime();
unsigned long internalMaskTimeStamp = m_InternalMask->GetMTime();
unsigned long inputImageTimeStamp = m_inputImage->GetMTime();
if (thisClassTimeStamp > m_InternalMaskUpdateTime) // inputs have changed
{
return true;
}
if (m_InternalMaskUpdateTime < inputImageTimeStamp) // mask image has changed outside of this class
{
return true;
}
if (internalMaskTimeStamp > m_InternalMaskUpdateTime) // internal mask has been changed outside of this class
{
return true;
}
return false;
}
} // end namespace
diff --git a/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.h b/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.h
index d8eecde982..5c9d3d44fa 100644
--- a/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.h
@@ -1,67 +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 MITKIGNOREPIXELMASKGEN_
#define MITKIGNOREPIXELMASKGEN_
#include <mitkImage.h>
#include <MitkImageStatisticsExports.h>
#include <mitkMaskGenerator.h>
#include <limits>
#include <itkImage.h>
namespace mitk
{
/**
* @brief The IgnorePixelMaskGenerator class is used to generate a mask that is zero for specific pixel values in the input image. This class requires an input image.
*/
class MITKIMAGESTATISTICS_EXPORT IgnorePixelMaskGenerator: public MaskGenerator
{
public:
/** Standard Self typedef */
typedef IgnorePixelMaskGenerator Self;
typedef MaskGenerator Superclass;
typedef itk::SmartPointer< Self > Pointer;
typedef itk::SmartPointer< const Self > ConstPointer;
typedef double RealType;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(IgnorePixelMaskGenerator, MaskGenerator)
/**
* @brief The mask will be 0 there inputImage==pixelValue and 1 otherwise
*/
void SetIgnoredPixelValue(RealType pixelValue);
/**
* @brief Computes and returns the mask
*/
mitk::Image::Pointer GetMask();
+ /**
+ * @brief SetTimeStep is used to set the time step for which the mask is to be generated
+ * @param timeStep
+ */
+ void SetTimeStep(unsigned int timeStep);
+
protected:
IgnorePixelMaskGenerator():
m_IgnoredPixelValue(std::numeric_limits<RealType>::min())
{
m_TimeStep = 0;
m_InternalMaskUpdateTime = 0;
m_InternalMask = mitk::Image::New();
}
~IgnorePixelMaskGenerator(){}
template <typename TPixel, unsigned int VImageDimension>
void InternalCalculateMask(typename itk::Image<TPixel, VImageDimension>* image);
private:
bool IsUpdateRequired() const;
RealType m_IgnoredPixelValue;
unsigned long m_InternalMaskUpdateTime;
};
}
#endif
diff --git a/Modules/ImageStatistics/mitkImageMaskGenerator.cpp b/Modules/ImageStatistics/mitkImageMaskGenerator.cpp
index a96916aebb..f4a00a6004 100644
--- a/Modules/ImageStatistics/mitkImageMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkImageMaskGenerator.cpp
@@ -1,82 +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 <mitkImageMaskGenerator.h>
#include <mitkImageTimeSelector.h>
#include <stdexcept>
namespace mitk {
void ImageMaskGenerator::SetImageMask(Image::Pointer maskImage)
{
if (m_internalMaskImage != maskImage)
{
m_internalMaskImage = maskImage;
this->Modified();
}
}
+void ImageMaskGenerator::SetTimeStep(unsigned int timeStep)
+{
+ if (timeStep != m_TimeStep)
+ {
+ m_TimeStep = timeStep;
+ UpdateInternalMask();
+ }
+}
+
+void ImageMaskGenerator::UpdateInternalMask()
+{
+ unsigned int timeStepForExtraction;
+
+ if (m_TimeStep >= m_internalMaskImage->GetTimeSteps())
+ {
+ MITK_WARN << "Warning: time step > number of time steps in mask image, using last time step";
+ timeStepForExtraction = m_internalMaskImage->GetTimeSteps() - 1;
+ }
+ else
+ {
+ timeStepForExtraction = m_TimeStep;
+ }
+ ImageTimeSelector::Pointer imageTimeSelector = ImageTimeSelector::New();
+ imageTimeSelector->SetInput(m_internalMaskImage);
+ imageTimeSelector->SetTimeNr(timeStepForExtraction);
+ imageTimeSelector->UpdateLargestPossibleRegion();
+
+ m_InternalMask = mitk::Image::New();
+ m_InternalMask = imageTimeSelector->GetOutput();
+}
+
+
mitk::Image::Pointer ImageMaskGenerator::GetMask()
{
if (m_internalMaskImage.IsNull())
{
MITK_ERROR << "Mask Image is nullptr";
}
-
- if (this->IsUpdateRequired())
+ if (IsUpdateRequired())
{
- unsigned int timeStepForExtraction;
-
- if (m_TimeStep >= m_internalMaskImage->GetTimeSteps())
- {
- MITK_WARN << "Warning: time step > number of time steps in mask image, using last time step";
- timeStepForExtraction = m_internalMaskImage->GetTimeSteps() - 1;
- }
- else
- {
- timeStepForExtraction = m_TimeStep;
- }
- ImageTimeSelector::Pointer imageTimeSelector = ImageTimeSelector::New();
- imageTimeSelector->SetInput(m_internalMaskImage);
- imageTimeSelector->SetTimeNr(timeStepForExtraction);
- imageTimeSelector->UpdateLargestPossibleRegion();
-
- m_InternalMask = mitk::Image::New();
- m_InternalMask = imageTimeSelector->GetOutput();
- this->Modified();
+ UpdateInternalMask();
}
- m_InternalMaskUpdateTime = m_InternalMask->GetMTime();
return m_InternalMask;
}
bool ImageMaskGenerator::IsUpdateRequired() const
{
- unsigned long thisClassTimeStamp = this->GetMTime();
unsigned long internalMaskTimeStamp = m_InternalMask->GetMTime();
unsigned long maskImageTimeStamp = m_internalMaskImage->GetMTime();
- if (thisClassTimeStamp > m_InternalMaskUpdateTime) // inputs have changed
- {
- return true;
- }
-
- if (m_InternalMaskUpdateTime < maskImageTimeStamp) // mask image has changed outside of this class
+ if (maskImageTimeStamp > internalMaskTimeStamp) // inputs have changed
{
return true;
}
- if (internalMaskTimeStamp > m_InternalMaskUpdateTime) // internal mask has been changed outside of this class
+ if (this->GetMTime() > maskImageTimeStamp) // input has changed
{
return true;
}
return false;
}
}
diff --git a/Modules/ImageStatistics/mitkImageMaskGenerator.h b/Modules/ImageStatistics/mitkImageMaskGenerator.h
index 0d6d12c826..90d5781c24 100644
--- a/Modules/ImageStatistics/mitkImageMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkImageMaskGenerator.h
@@ -1,48 +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.
+
+===================================================================*/
+
#ifndef mitkBinaryMaskGenerator
#define mitkBinaryMaskGenerator
#include <mitkImage.h>
#include <MitkImageStatisticsExports.h>
#include <mitkMaskGenerator.h>
#include <itkObject.h>
#include <itkSmartPointer.h>
namespace mitk
{
class MITKIMAGESTATISTICS_EXPORT ImageMaskGenerator: public MaskGenerator
{
public:
/** Standard Self typedef */
typedef ImageMaskGenerator Self;
typedef MaskGenerator Superclass;
typedef itk::SmartPointer< Self > Pointer;
typedef itk::SmartPointer< const Self > ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(BinaryImageMaskGenerator, MaskGenerator)
mitk::Image::Pointer GetMask();
+ void SetTimeStep(unsigned int timeStep);
+
void SetImageMask(mitk::Image::Pointer maskImage);
protected:
ImageMaskGenerator():Superclass(){
m_InternalMaskUpdateTime = 0;
m_InternalMask = mitk::Image::New();
}
private:
bool IsUpdateRequired() const;
+ void UpdateInternalMask();
mitk::Image::Pointer m_internalMaskImage;
unsigned long m_InternalMaskUpdateTime;
};
}
#endif
diff --git a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
index 4551c82546..f01763a49b 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
+++ b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
@@ -1,642 +1,657 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
#include <limits>
#include <math.h>
#include <itkImageToHistogramFilter.h>
#include <itkMaskedImageToHistogramFilter.h>
#include <itkHistogram.h>
#include <itkExtractImageFilter.h>
#include <itkImageRegionConstIterator.h>
#include <itkChangeInformationImageFilter.h>
#include <itkMinimumMaximumImageCalculator.h>
#include <itkMinimumMaximumImageFilter.h>
#include <itkMaskImageFilter.h>
#include <itkExceptionObject.h>
#include <mitkImageStatisticsCalculator.h>
#include <mitkImage.h>
#include <mitkHistogramStatisticsCalculator.h>
#include <mitkImageAccessByItk.h>
#include <mitkImageToItk.h>
#include <mitkExtendedStatisticsImageFilter.h>
#include <mitkExtendedLabelStatisticsImageFilter.h>
#include <mitkImageTimeSelector.h>
#include <mitkMinMaxImageFilterWithIndex.h>
#include <mitkMinMaxLabelmageFilterWithIndex.h>
#include <mitkitkMaskImageFilter.h>
#include <mitkImageCast.h>
#include <mitkMaskUtilities.h>
#include "itkImageFileWriter.h"
namespace mitk
{
void ImageStatisticsCalculator::SetInputImage(mitk::Image::Pointer image)
{
if (image != m_Image)
{
m_Image = image;
m_StatisticsByTimeStep.resize(m_Image->GetTimeSteps());
m_StatisticsUpdateTimePerTimeStep.resize(m_Image->GetTimeSteps());
std::fill(m_StatisticsUpdateTimePerTimeStep.begin(), m_StatisticsUpdateTimePerTimeStep.end(), 0);
this->Modified();
}
}
void ImageStatisticsCalculator::SetMask(mitk::MaskGenerator::Pointer mask)
{
if (mask != m_MaskGenerator)
{
m_MaskGenerator = mask;
this->Modified();
}
}
void ImageStatisticsCalculator::SetSecondaryMask(mitk::MaskGenerator::Pointer mask)
{
if (mask != m_SecondaryMaskGenerator)
{
m_SecondaryMaskGenerator = mask;
this->Modified();
}
}
void ImageStatisticsCalculator::SetNBinsForHistogramStatistics(unsigned int nBins)
{
if (nBins != m_nBinsForHistogramStatistics)
{
m_nBinsForHistogramStatistics = nBins;
this->Modified();
this->m_UseBinSizeOverNBins = false;
}
if (m_UseBinSizeOverNBins)
{
this->Modified();
this->m_UseBinSizeOverNBins = false;
}
}
unsigned int ImageStatisticsCalculator::GetNBinsForHistogramStatistics() const
{
return m_nBinsForHistogramStatistics;
}
void ImageStatisticsCalculator::SetBinSizeForHistogramStatistics(double binSize)
{
if (binSize != m_binSizeForHistogramStatistics)
{
m_binSizeForHistogramStatistics = binSize;
this->Modified();
this->m_UseBinSizeOverNBins = true;
}
if (!m_UseBinSizeOverNBins)
{
this->Modified();
this->m_UseBinSizeOverNBins = true;
}
}
double ImageStatisticsCalculator::GetBinSizeForHistogramStatistics() const
{
return m_binSizeForHistogramStatistics;
}
ImageStatisticsCalculator::StatisticsContainer::Pointer ImageStatisticsCalculator::GetStatistics(unsigned int timeStep, unsigned int label)
{
if (timeStep >= m_StatisticsByTimeStep.size())
{
mitkThrow() << "invalid timeStep in ImageStatisticsCalculator_v2::GetStatistics";
}
if (m_Image.IsNull())
{
mitkThrow() << "no image";
}
if (!m_Image->IsInitialized())
{
mitkThrow() << "Image not initialized!";
}
if (IsUpdateRequired(timeStep))
{
if (m_MaskGenerator.IsNotNull())
{
m_MaskGenerator->SetTimeStep(timeStep);
m_InternalMask = m_MaskGenerator->GetMask();
if (m_MaskGenerator->GetReferenceImage().IsNotNull())
{
m_InternalImageForStatistics = m_MaskGenerator->GetReferenceImage();
}
else
{
m_InternalImageForStatistics = m_Image;
}
}
else
{
m_InternalImageForStatistics = m_Image;
}
if (m_SecondaryMaskGenerator.IsNotNull())
{
m_SecondaryMaskGenerator->SetTimeStep(timeStep);
m_SecondaryMask = m_SecondaryMaskGenerator->GetMask();
}
ImageTimeSelector::Pointer imgTimeSel = ImageTimeSelector::New();
imgTimeSel->SetInput(m_InternalImageForStatistics);
imgTimeSel->SetTimeNr(timeStep);
imgTimeSel->UpdateLargestPossibleRegion();
m_ImageTimeSlice = imgTimeSel->GetOutput();
// Calculate statistics with/without mask
if (m_MaskGenerator.IsNull() && m_SecondaryMaskGenerator.IsNull())
{
// 1) calculate statistics unmasked:
AccessByItk_1(m_ImageTimeSlice, InternalCalculateStatisticsUnmasked, timeStep)
}
else
{
// 2) calculate statistics masked
AccessByItk_1(m_ImageTimeSlice, InternalCalculateStatisticsMasked, timeStep)
}
- this->Modified();
+ //this->Modified();
}
m_StatisticsUpdateTimePerTimeStep[timeStep] = m_StatisticsByTimeStep[timeStep][m_StatisticsByTimeStep[timeStep].size()-1]->GetMTime();
for (std::vector<StatisticsContainer::Pointer>::iterator it = m_StatisticsByTimeStep[timeStep].begin(); it != m_StatisticsByTimeStep[timeStep].end(); ++it)
{
StatisticsContainer::Pointer statCont = *it;
if (statCont->GetLabel() == label)
{
return statCont->Clone();
}
}
// these lines will ony be executed if the requested label could not be found!
MITK_WARN << "Invalid label: " << label << " in time step: " << timeStep;
return StatisticsContainer::New();
}
template < typename TPixel, unsigned int VImageDimension > void ImageStatisticsCalculator::InternalCalculateStatisticsUnmasked(
typename itk::Image< TPixel, VImageDimension >* image, unsigned int timeStep)
{
typedef typename itk::Image< TPixel, VImageDimension > ImageType;
typedef typename itk::ExtendedStatisticsImageFilter<ImageType> ImageStatisticsFilterType;
typedef typename itk::MinMaxImageFilterWithIndex<ImageType> MinMaxFilterType;
StatisticsContainer::Pointer statisticsResult = StatisticsContainer::New();
typename ImageStatisticsFilterType::Pointer statisticsFilter = ImageStatisticsFilterType::New();
statisticsFilter->SetInput(image);
statisticsFilter->SetCoordinateTolerance(0.001);
statisticsFilter->SetDirectionTolerance(0.001);
// TODO: this is single threaded. Implement our own image filter that does this multi threaded
// typename itk::MinimumMaximumImageCalculator<ImageType>::Pointer imgMinMaxFilter = itk::MinimumMaximumImageCalculator<ImageType>::New();
// imgMinMaxFilter->SetImage(image);
// imgMinMaxFilter->Compute();
vnl_vector<int> minIndex, maxIndex;
typename MinMaxFilterType::Pointer minMaxFilter = MinMaxFilterType::New();
minMaxFilter->SetInput(image);
minMaxFilter->UpdateLargestPossibleRegion();
typename ImageType::PixelType minval = minMaxFilter->GetMin();
typename ImageType::PixelType maxval = minMaxFilter->GetMax();
typename ImageType::IndexType tmpMinIndex = minMaxFilter->GetMinIndex();
typename ImageType::IndexType tmpMaxIndex = minMaxFilter->GetMaxIndex();
// typename ImageType::IndexType tmpMinIndex = imgMinMaxFilter->GetIndexOfMinimum();
// typename ImageType::IndexType tmpMaxIndex = imgMinMaxFilter->GetIndexOfMaximum();
minIndex.set_size(tmpMaxIndex.GetIndexDimension());
maxIndex.set_size(tmpMaxIndex.GetIndexDimension());
for (unsigned int i=0; i < tmpMaxIndex.GetIndexDimension(); i++)
{
minIndex[i] = tmpMinIndex[i];
maxIndex[i] = tmpMaxIndex[i];
}
statisticsResult->SetMinIndex(minIndex);
statisticsResult->SetMaxIndex(maxIndex);
//convert m_binSize in m_nBins if necessary
unsigned int nBinsForHistogram;
if (m_UseBinSizeOverNBins)
{
nBinsForHistogram = std::max(static_cast<double>(std::ceil(maxval - minval)) / m_binSizeForHistogramStatistics, 10.); // do not allow less than 10 bins
}
else
{
nBinsForHistogram = m_nBinsForHistogramStatistics;
}
statisticsFilter->SetHistogramParameters(nBinsForHistogram, minval, maxval);
try
{
statisticsFilter->Update();
}
catch (const itk::ExceptionObject& e)
{
mitkThrow() << "Image statistics calculation failed due to following ITK Exception: \n " << e.what();
}
// no mask, therefore just one label = the whole image
m_StatisticsByTimeStep[timeStep].resize(1);
statisticsResult->SetLabel(1);
statisticsResult->SetN(image->GetLargestPossibleRegion().GetNumberOfPixels());
statisticsResult->SetMean(statisticsFilter->GetMean());
statisticsResult->SetMin(statisticsFilter->GetMinimum());
statisticsResult->SetMax(statisticsFilter->GetMaximum());
statisticsResult->SetVariance(statisticsFilter->GetVariance());
statisticsResult->SetStd(statisticsFilter->GetSigma());
statisticsResult->SetSkewness(statisticsFilter->GetSkewness());
statisticsResult->SetKurtosis(statisticsFilter->GetKurtosis());
statisticsResult->SetRMS(std::sqrt(std::pow(statisticsFilter->GetMean(), 2.) + statisticsFilter->GetVariance())); // variance = sigma^2
statisticsResult->SetMPP(statisticsFilter->GetMPP());
statisticsResult->SetEntropy(statisticsFilter->GetEntropy());
statisticsResult->SetMedian(statisticsFilter->GetMedian());
statisticsResult->SetUniformity(statisticsFilter->GetUniformity());
statisticsResult->SetUPP(statisticsFilter->GetUPP());
statisticsResult->SetHistogram(statisticsFilter->GetHistogram());
m_StatisticsByTimeStep[timeStep][0] = statisticsResult;
}
template < typename TPixel, unsigned int VImageDimension > void ImageStatisticsCalculator::InternalCalculateStatisticsMasked(
typename itk::Image< TPixel, VImageDimension >* image,
unsigned int timeStep)
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< MaskPixelType, VImageDimension > MaskType;
typedef typename MaskType::PixelType LabelPixelType;
typedef itk::ExtendedLabelStatisticsImageFilter< ImageType, MaskType > ImageStatisticsFilterType;
typedef MaskUtilities< TPixel, VImageDimension > MaskUtilType;
typedef typename itk::MinMaxLabelImageFilterWithIndex<ImageType, MaskType> MinMaxLabelFilterType;
typedef typename ImageType::PixelType InputImgPixelType;
// workaround: if m_SecondaryMaskGenerator ist not null but m_MaskGenerator is! (this is the case if we request a 'ignore zuero valued pixels'
// mask in the gui but do not define a primary mask)
bool swapMasks = false;
if (m_SecondaryMask.IsNotNull() && m_InternalMask.IsNull())
{
m_InternalMask = m_SecondaryMask;
m_SecondaryMask = nullptr;
swapMasks = true;
}
// maskImage has to have the same dimension as image
typename MaskType::Pointer maskImage = MaskType::New();
try {
// try to access the pixel values directly (no copying or casting). Only works if mask pixels are of pixelType unsigned short
maskImage = ImageToItkImage< MaskPixelType, VImageDimension >(m_InternalMask);
}
catch (itk::ExceptionObject & e)
{
// if the pixel type of the mask is not short, then we have to make a copy of m_InternalMask (and cast the values)
CastToItkImage(m_InternalMask, maskImage);
}
// if we have a secondary mask (say a ignoreZeroPixelMask) we need to combine the masks (corresponds to AND)
if (m_SecondaryMask.IsNotNull())
{
// dirty workaround for a bug when pf mask + any other mask is used in conjunction. We need a proper fix for this (Fabian Isensee is responsible and probably working on it!)
if (m_InternalMask->GetDimension() == 2 && (m_SecondaryMask->GetDimension() == 3 || m_SecondaryMask->GetDimension() == 4))
{
mitk::Image::Pointer old_img = m_SecondaryMaskGenerator->GetReferenceImage();
m_SecondaryMaskGenerator->SetInputImage(m_MaskGenerator->GetReferenceImage());
m_SecondaryMask = m_SecondaryMaskGenerator->GetMask();
m_SecondaryMaskGenerator->SetInputImage(old_img);
}
typename MaskType::Pointer secondaryMaskImage = MaskType::New();
secondaryMaskImage = ImageToItkImage< MaskPixelType, VImageDimension >(m_SecondaryMask);
// secondary mask should be a ignore zero value pixel mask derived from image. it has to be cropped to the mask region (which may be planar or simply smaller)
typename MaskUtilities<MaskPixelType, VImageDimension>::Pointer secondaryMaskMaskUtil = MaskUtilities<MaskPixelType, VImageDimension>::New();
secondaryMaskMaskUtil->SetImage(secondaryMaskImage.GetPointer());
secondaryMaskMaskUtil->SetMask(maskImage.GetPointer());
typename MaskType::Pointer adaptedSecondaryMaskImage = secondaryMaskMaskUtil->ExtractMaskImageRegion();
typename itk::MaskImageFilter2<MaskType, MaskType, MaskType>::Pointer maskFilter = itk::MaskImageFilter2<MaskType, MaskType, MaskType>::New();
maskFilter->SetInput1(maskImage);
maskFilter->SetInput2(adaptedSecondaryMaskImage);
maskFilter->SetMaskingValue(1); // all pixels of maskImage where secondaryMaskImage==1 will be kept, all the others are set to 0
maskFilter->UpdateLargestPossibleRegion();
maskImage = maskFilter->GetOutput();
}
typename MaskUtilType::Pointer maskUtil = MaskUtilType::New();
maskUtil->SetImage(image);
maskUtil->SetMask(maskImage.GetPointer());
// if mask is smaller than image, extract the image region where the mask is
typename ImageType::Pointer adaptedImage = ImageType::New();
adaptedImage = maskUtil->ExtractMaskImageRegion(); // this also checks mask sanity
// find min, max, minindex and maxindex
typename MinMaxLabelFilterType::Pointer minMaxFilter = MinMaxLabelFilterType::New();
minMaxFilter->SetInput(adaptedImage);
minMaxFilter->SetLabelInput(maskImage);
minMaxFilter->UpdateLargestPossibleRegion();
// set histogram parameters for each label individually (min/max may be different for each label)
typedef typename std::map<LabelPixelType, InputImgPixelType> MapType;
typedef typename std::pair<LabelPixelType, InputImgPixelType> PairType;
std::vector<LabelPixelType> relevantLabels = minMaxFilter->GetRelevantLabels();
MapType minVals;
MapType maxVals;
std::map<LabelPixelType, unsigned int> nBins;
for (LabelPixelType label:relevantLabels)
{
minVals.insert(PairType(label, minMaxFilter->GetMin(label)));
maxVals.insert(PairType(label, minMaxFilter->GetMax(label)));
unsigned int nBinsForHistogram;
if (m_UseBinSizeOverNBins)
{
nBinsForHistogram = std::max(static_cast<double>(std::ceil(minMaxFilter->GetMax(label) - minMaxFilter->GetMin(label))) / m_binSizeForHistogramStatistics, 10.); // do not allow less than 10 bins
}
else
{
nBinsForHistogram = m_nBinsForHistogramStatistics;
}
nBins.insert(typename std::pair<LabelPixelType, unsigned int>(label, nBinsForHistogram));
}
typename ImageStatisticsFilterType::Pointer imageStatisticsFilter = ImageStatisticsFilterType::New();
imageStatisticsFilter->SetDirectionTolerance(0.001);
imageStatisticsFilter->SetCoordinateTolerance(0.001);
imageStatisticsFilter->SetInput(adaptedImage);
imageStatisticsFilter->SetLabelInput(maskImage);
imageStatisticsFilter->SetHistogramParametersForLabels(nBins, minVals, maxVals);
imageStatisticsFilter->Update();
std::list<int> labels = imageStatisticsFilter->GetRelevantLabels();
std::list<int>::iterator it = labels.begin();
m_StatisticsByTimeStep[timeStep].resize(0);
while(it != labels.end())
{
StatisticsContainer::Pointer statisticsResult = StatisticsContainer::New();
// find min, max, minindex and maxindex
// make sure to only look in the masked region, use a masker for this
vnl_vector<int> minIndex, maxIndex;
mitk::Point3D worldCoordinateMin;
mitk::Point3D worldCoordinateMax;
mitk::Point3D indexCoordinateMin;
mitk::Point3D indexCoordinateMax;
m_InternalImageForStatistics->GetGeometry()->IndexToWorld(minMaxFilter->GetMinIndex(*it), worldCoordinateMin);
m_InternalImageForStatistics->GetGeometry()->IndexToWorld(minMaxFilter->GetMaxIndex(*it), worldCoordinateMax);
m_Image->GetGeometry()->WorldToIndex(worldCoordinateMin, indexCoordinateMin);
m_Image->GetGeometry()->WorldToIndex(worldCoordinateMax, indexCoordinateMax);
//typename ImageType::IndexType tmpMinIndex = minMaxFilter->GetMinIndex(*it);
//typename ImageType::IndexType tmpMaxIndex = minMaxFilter->GetMaxIndex(*it);
//minIndex.set_size(tmpMaxIndex.GetIndexDimension());
//maxIndex.set_size(tmpMaxIndex.GetIndexDimension());
minIndex.set_size(3);
maxIndex.set_size(3);
//for (unsigned int i=0; i < tmpMaxIndex.GetIndexDimension(); i++)
for (unsigned int i=0; i < 3; i++)
{
//minIndex[i] = tmpMinIndex[i] + (maskImage->GetOrigin()[i] - image->GetOrigin()[i]) / (double) maskImage->GetSpacing()[i];
//maxIndex[i] = tmpMaxIndex[i] + (maskImage->GetOrigin()[i] - image->GetOrigin()[i]) / (double) maskImage->GetSpacing()[i];
minIndex[i] = indexCoordinateMin[i];
maxIndex[i] = indexCoordinateMax[i];
}
statisticsResult->SetMinIndex(minIndex);
statisticsResult->SetMaxIndex(maxIndex);
// just debug
TPixel min_Filter = minMaxFilter->GetMin(*it);
TPixel max_Filter = minMaxFilter->GetMax(*it);
TPixel min_Itk = imageStatisticsFilter->GetMinimum(*it);
TPixel max_Itk = imageStatisticsFilter->GetMaximum(*it);
assert(abs(minMaxFilter->GetMax(*it) - imageStatisticsFilter->GetMaximum(*it)) < mitk::eps);
assert(abs(minMaxFilter->GetMin(*it) - imageStatisticsFilter->GetMinimum(*it)) < mitk::eps);
statisticsResult->SetN(imageStatisticsFilter->GetSum(*it) / (double) imageStatisticsFilter->GetMean(*it));
statisticsResult->SetMean(imageStatisticsFilter->GetMean(*it));
statisticsResult->SetMin(imageStatisticsFilter->GetMinimum(*it));
statisticsResult->SetMax(imageStatisticsFilter->GetMaximum(*it));
statisticsResult->SetVariance(imageStatisticsFilter->GetVariance(*it));
statisticsResult->SetStd(imageStatisticsFilter->GetSigma(*it));
statisticsResult->SetSkewness(imageStatisticsFilter->GetSkewness(*it));
statisticsResult->SetKurtosis(imageStatisticsFilter->GetKurtosis(*it));
statisticsResult->SetRMS(std::sqrt(std::pow(imageStatisticsFilter->GetMean(*it), 2.) + imageStatisticsFilter->GetVariance(*it))); // variance = sigma^2
statisticsResult->SetMPP(imageStatisticsFilter->GetMPP(*it));
statisticsResult->SetLabel(*it);
statisticsResult->SetEntropy(imageStatisticsFilter->GetEntropy(*it));
statisticsResult->SetMedian(imageStatisticsFilter->GetMedian(*it));
statisticsResult->SetUniformity(imageStatisticsFilter->GetUniformity(*it));
statisticsResult->SetUPP(imageStatisticsFilter->GetUPP(*it));
statisticsResult->SetHistogram(imageStatisticsFilter->GetHistogram(*it));
m_StatisticsByTimeStep[timeStep].push_back(statisticsResult);
++it;
}
// swap maskGenerators back
if (swapMasks)
{
m_SecondaryMask = m_InternalMask;
m_InternalMask = nullptr;
}
}
bool ImageStatisticsCalculator::IsUpdateRequired(unsigned int timeStep) const
{
unsigned long thisClassTimeStamp = this->GetMTime();
unsigned long inputImageTimeStamp = m_Image->GetMTime();
unsigned long statisticsTimeStamp = m_StatisticsUpdateTimePerTimeStep[timeStep];
if (thisClassTimeStamp > statisticsTimeStamp) // inputs have changed
{
return true;
}
if (inputImageTimeStamp > statisticsTimeStamp) // image has changed
{
return true;
}
if (m_MaskGenerator.IsNotNull())
{
unsigned long maskGeneratorTimeStamp = m_MaskGenerator->GetMTime();
if (maskGeneratorTimeStamp > statisticsTimeStamp) // there is a mask generator and it has changed
{
return true;
}
}
if (m_SecondaryMaskGenerator.IsNotNull())
{
unsigned long maskGeneratorTimeStamp = m_SecondaryMaskGenerator->GetMTime();
if (maskGeneratorTimeStamp > statisticsTimeStamp) // there is a secondary mask generator and it has changed
{
return true;
}
}
return false;
}
ImageStatisticsCalculator::StatisticsContainer::StatisticsContainer():
m_N(nan("")),
m_Mean(nan("")),
m_Min(nan("")),
m_Max(nan("")),
m_Std(nan("")),
m_Variance(nan("")),
m_Skewness(nan("")),
m_Kurtosis(nan("")),
m_RMS(nan("")),
m_MPP(nan("")),
m_Median(nan("")),
m_Uniformity(nan("")),
m_UPP(nan("")),
m_Entropy(nan(""))
{
m_minIndex.set_size(0);
m_maxIndex.set_size(0);
}
ImageStatisticsCalculator::statisticsMapType ImageStatisticsCalculator::StatisticsContainer::GetStatisticsAsMap()
{
ImageStatisticsCalculator::statisticsMapType statisticsAsMap;
statisticsAsMap["N"] = m_N;
statisticsAsMap["Mean"] = m_Mean;
statisticsAsMap["Min"] = m_Min;
statisticsAsMap["Max"] = m_Max;
statisticsAsMap["StandardDeviation"] = m_Std;
statisticsAsMap["Variance"] = m_Variance;
statisticsAsMap["Skewness"] = m_Skewness;
statisticsAsMap["Kurtosis"] = m_Kurtosis;
statisticsAsMap["RMS"] = m_RMS;
statisticsAsMap["MPP"] = m_MPP;
statisticsAsMap["Median"] = m_Median;
statisticsAsMap["Uniformity"] = m_Uniformity;
statisticsAsMap["UPP"] = m_UPP;
statisticsAsMap["Entropy"] = m_Entropy;
statisticsAsMap["Label"] = m_Label;
return statisticsAsMap;
}
void ImageStatisticsCalculator::StatisticsContainer::Reset()
{
m_N = nan("");
m_Mean = nan("");
m_Min = nan("");
m_Max = nan("");
m_Std = nan("");
m_Variance = nan("");
m_Skewness = nan("");
m_Kurtosis = nan("");
m_RMS = nan("");
m_MPP = nan("");
m_Median = nan("");
m_Uniformity = nan("");
m_UPP = nan("");
m_Entropy = nan("");
m_Histogram = HistogramType::New();
m_minIndex.set_size(0);
m_maxIndex.set_size(0);
m_Label = 0;
}
void ImageStatisticsCalculator::StatisticsContainer::Print()
{
ImageStatisticsCalculator::statisticsMapType statMap = this->GetStatisticsAsMap();
// print all map key value pairs
// const auto& val:statMap
for (auto it = statMap.begin(); it != statMap.end(); ++it)
{
std::cout << it->first << ": " << it->second << std::endl;
}
// print the min and max index
std::cout << "Min Index:" << std::endl;
for (auto it = this->GetMinIndex().begin(); it != this->GetMinIndex().end(); ++it)
{
std::cout << *it << " ";
}
std::cout << std::endl;
// print the min and max index
std::cout << "Max Index:" << std::endl;
for (auto it = this->GetMaxIndex().begin(); it != this->GetMaxIndex().end(); ++it)
{
std::cout << *it << " ";
}
std::cout << std::endl;
}
std::string ImageStatisticsCalculator::StatisticsContainer::GetAsString()
{
std::string res = "";
ImageStatisticsCalculator::statisticsMapType statMap = this->GetStatisticsAsMap();
// print all map key value pairs
// const auto& val:statMap
for (auto it = statMap.begin(); it != statMap.end(); ++it)
{
res += std::string(it->first) + ": " + std::to_string(it->second) + "\n";
}
// print the min and max index
res += "Min Index:" + std::string("\n");
for (auto it = this->GetMinIndex().begin(); it != this->GetMinIndex().end(); it++)
{
res += std::to_string(*it) + std::string(" ");
}
res += "\n";
// print the min and max index
res += "Max Index:" + std::string("\n");
for (auto it = this->GetMaxIndex().begin(); it != this->GetMaxIndex().end(); it++)
{
res += std::to_string(*it) + " ";
}
res += "\n";
return res;
}
}
diff --git a/Modules/ImageStatistics/mitkMaskGenerator.cpp b/Modules/ImageStatistics/mitkMaskGenerator.cpp
index 81c3e3a7aa..39b9e1a881 100644
--- a/Modules/ImageStatistics/mitkMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkMaskGenerator.cpp
@@ -1,51 +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 <mitkMaskGenerator.h>
namespace mitk
{
-void MaskGenerator::SetTimeStep(unsigned int timeStep)
-{
- if (m_TimeStep != timeStep)
- {
- m_TimeStep = timeStep;
- this->Modified();
- }
-}
MaskGenerator::MaskGenerator():
m_TimeStep(0)
{
m_inputImage = nullptr;
}
mitk::Image::Pointer MaskGenerator::GetMask()
{
return mitk::Image::New();
}
//typename itk::Region<3>::Pointer MaskGenerator::GetImageRegionOfMask(Image::Pointer image)
//{
// if (m_InternalMask.IsNull() || m_Modified)
// {
// MITK_ERROR << "Update MaskGenerator first!";
// }
// mitk::BaseGeometry::Pointer imageGeometry = image->GetGeometry();
// mitk::BaseGeometry::Pointer maskGeometry = m_InternalMask->GetGeometry();
//}
+void MaskGenerator::SetTimeStep(unsigned int timeStep)
+{
+ if (timeStep != m_TimeStep)
+ {
+ m_TimeStep = timeStep;
+ }
+}
+
void MaskGenerator::SetInputImage(mitk::Image::Pointer inputImg)
{
if (inputImg != m_inputImage)
{
m_inputImage = inputImg;
this->Modified();
}
}
mitk::Image::Pointer MaskGenerator::GetReferenceImage()
{
return m_inputImage;
}
}
diff --git a/Modules/ImageStatistics/mitkMaskGenerator.h b/Modules/ImageStatistics/mitkMaskGenerator.h
index 627c7bc4e1..70a8378ad9 100644
--- a/Modules/ImageStatistics/mitkMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkMaskGenerator.h
@@ -1,70 +1,82 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
#ifndef MITKMASKGENERATOR
#define MITKMASKGENERATOR
#include <MitkImageStatisticsExports.h>
#include <mitkImage.h>
#include <itkRegion.h>
#include <itkObject.h>
#include <itkSmartPointer.h>
namespace mitk
{
/**
* \class MaskGenerator
* \brief Base Class for all Mask Generators. Mask generators are classes that provide functionality for the
* creation of binary (or unsigned short) masks that can be applied to an image. See dervied classes for more
* information.
*/
class MITKIMAGESTATISTICS_EXPORT MaskGenerator: public itk::Object
{
public:
/** Standard Self typedef */
typedef MaskGenerator Self;
typedef itk::Object Superclass;
typedef itk::SmartPointer< Self > Pointer;
typedef itk::SmartPointer< const Self > ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(MaskGenerator, itk::Object)
//~MaskGenerator();
/**
* @brief GetMask must be overridden by derived classes.
* @return mitk::Image::Pointer of generated mask
*/
virtual mitk::Image::Pointer GetMask();
- /**
- * @brief SetTimeStep is used to set the time step for which the mask is to be generated
- * @param timeStep
- */
- void SetTimeStep(unsigned int timeStep);
-
/**
* @brief GetReferenceImage per default returns the inputImage (as set by SetInputImage). If no input image is set it will return a nullptr.
*/
virtual mitk::Image::Pointer GetReferenceImage();
/**
* @brief SetInputImage is used to set the input image to the mask generator. Some subclasses require an input image, others don't. See the documentation of the specific Mask Generator for more information.
*/
void SetInputImage(mitk::Image::Pointer inputImg);
+ virtual void SetTimeStep(unsigned int timeStep);
+
protected:
MaskGenerator();
unsigned int m_TimeStep;
mitk::Image::Pointer m_InternalMask;
mitk::Image::Pointer m_inputImage;
private:
};
}
#endif // MITKMASKGENERATOR
diff --git a/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.cpp b/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.cpp
index 57ef871eb6..49d947a7dc 100644
--- a/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.cpp
@@ -1,418 +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 <mitkPlanarFigureMaskGenerator.h>
#include <mitkBaseGeometry.h>
#include <mitkITKImageImport.h>
#include "mitkImageAccessByItk.h"
#include <mitkExtractImageFilter.h>
#include <mitkConvert2Dto3DImageFilter.h>
#include <mitkImageTimeSelector.h>
#include <mitkIOUtil.h>
#include <itkCastImageFilter.h>
#include <itkVTKImageExport.h>
#include <itkVTKImageImport.h>
#include <itkImageDuplicator.h>
#include <itkExceptionObject.h>
#include <vtkPoints.h>
#include <vtkImageStencil.h>
#include <vtkImageImport.h>
#include <vtkImageExport.h>
#include <vtkLassoStencilSource.h>
#include <vtkSmartPointer.h>
namespace mitk
{
void PlanarFigureMaskGenerator::SetPlanarFigure(mitk::PlanarFigure::Pointer planarFigure)
{
if ( planarFigure.IsNull() )
{
throw std::runtime_error( "Error: planar figure empty!" );
}
if ( !planarFigure->IsClosed() )
{
throw std::runtime_error( "Masking not possible for non-closed figures" );
}
const PlaneGeometry *planarFigurePlaneGeometry = planarFigure->GetPlaneGeometry();
if ( planarFigurePlaneGeometry == nullptr )
{
throw std::runtime_error( "Planar-Figure not yet initialized!" );
}
const PlaneGeometry *planarFigureGeometry =
dynamic_cast< const PlaneGeometry * >( planarFigurePlaneGeometry );
if ( planarFigureGeometry == nullptr )
{
throw std::runtime_error( "Non-planar planar figures not supported!" );
}
if (planarFigure != m_PlanarFigure)
{
this->Modified();
m_PlanarFigure = planarFigure;
}
}
mitk::Image::Pointer PlanarFigureMaskGenerator::GetReferenceImage()
{
if (IsUpdateRequired())
{
this->CalculateMask();
}
return m_ReferenceImage;
}
template < typename TPixel, unsigned int VImageDimension >
void PlanarFigureMaskGenerator::InternalCalculateMaskFromPlanarFigure(
const itk::Image< TPixel, VImageDimension > *image, unsigned int axis )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< unsigned short, 2 > MaskImage2DType;
typename MaskImage2DType::Pointer maskImage = MaskImage2DType::New();
maskImage->SetOrigin(image->GetOrigin());
maskImage->SetSpacing(image->GetSpacing());
maskImage->SetLargestPossibleRegion(image->GetLargestPossibleRegion());
maskImage->SetBufferedRegion(image->GetBufferedRegion());
maskImage->SetDirection(image->GetDirection());
maskImage->SetNumberOfComponentsPerPixel(image->GetNumberOfComponentsPerPixel());
maskImage->Allocate();
maskImage->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::PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
const typename PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
const mitk::BaseGeometry *imageGeometry3D = m_inputImage->GetGeometry( 0 );
// If there is a second poly line in a closed planar figure, treat it as a hole.
PlanarFigure::PolyLineType planarFigureHolePolyline;
if (m_PlanarFigure->GetPolyLinesSize() == 2)
planarFigureHolePolyline = m_PlanarFigure->GetPolyLine(1);
// Determine x- and y-dimensions depending on principal axis
// TODO use plane geometry normal to determine that automatically, then check whether the PF is aligned with one of the three 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;
}
// 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
// Fabian: From PlaneGeometry documentation:
// Converts a 2D point given in mm (pt2d_mm) relative to the upper-left corner of the geometry into the corresponding world-coordinate (a 3D point in mm, 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.
planarFigurePlaneGeometry->Map( *it, 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 );
}
vtkSmartPointer<vtkPoints> holePoints = nullptr;
if (!planarFigureHolePolyline.empty())
{
holePoints = vtkSmartPointer<vtkPoints>::New();
Point3D point3D;
PlanarFigure::PolyLineType::const_iterator end = planarFigureHolePolyline.end();
for (it = planarFigureHolePolyline.begin(); it != end; ++it)
{
// Fabian: same as above
planarFigurePlaneGeometry->Map(*it, point3D);
imageGeometry3D->WorldToIndex(point3D, point3D);
holePoints->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 );
vtkSmartPointer<vtkLassoStencilSource> holeLassoStencil = nullptr;
if (holePoints.GetPointer() != nullptr)
{
holeLassoStencil = vtkSmartPointer<vtkLassoStencilSource>::New();
holeLassoStencil->SetShapeToPolygon();
holeLassoStencil->SetPoints(holePoints);
}
// 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( maskImage );
// 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->SetStencilConnection(lassoStencil->GetOutputPort());
imageStencilFilter->ReverseStencilOff();
imageStencilFilter->SetBackgroundValue( 0 );
imageStencilFilter->Update();
vtkSmartPointer<vtkImageStencil> holeStencilFilter = nullptr;
if (holeLassoStencil.GetPointer() != nullptr)
{
holeStencilFilter = vtkSmartPointer<vtkImageStencil>::New();
holeStencilFilter->SetInputConnection(imageStencilFilter->GetOutputPort());
holeStencilFilter->SetStencilConnection(holeLassoStencil->GetOutputPort());
holeStencilFilter->ReverseStencilOn();
holeStencilFilter->SetBackgroundValue(0);
holeStencilFilter->Update();
}
// Export from VTK back to ITK
vtkSmartPointer<vtkImageExport> vtkExporter = vtkSmartPointer<vtkImageExport>::New();
vtkExporter->SetInputConnection( holeStencilFilter.GetPointer() == nullptr
? imageStencilFilter->GetOutputPort()
: holeStencilFilter->GetOutputPort());
vtkExporter->Update();
typename ImageImportType::Pointer itkImporter = ImageImportType::New();
this->ConnectPipelines( vtkExporter, itkImporter );
itkImporter->Update();
typedef itk::ImageDuplicator< ImageImportType::OutputImageType > DuplicatorType;
DuplicatorType::Pointer duplicator = DuplicatorType::New();
duplicator->SetInputImage( itkImporter->GetOutput() );
duplicator->Update();
// Store mask
m_InternalITKImageMask2D = duplicator->GetOutput();
}
bool PlanarFigureMaskGenerator::GetPrincipalAxis(
const BaseGeometry *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 PlanarFigureMaskGenerator::CalculateMask()
{
if (m_inputImage.IsNull())
{
MITK_ERROR << "Image is not set.";
}
if (m_PlanarFigure.IsNull())
{
MITK_ERROR << "PlanarFigure is not set.";
}
if (m_TimeStep != 0)
{
MITK_WARN << "Multiple TimeSteps are not supported in PlanarFigureMaskGenerator (yet).";
}
const BaseGeometry *imageGeometry = m_inputImage->GetGeometry();
if ( imageGeometry == nullptr )
{
throw std::runtime_error( "Image geometry invalid!" );
}
if (m_inputImage->GetTimeSteps() > 0)
{
mitk::ImageTimeSelector::Pointer imgTimeSel = mitk::ImageTimeSelector::New();
imgTimeSel->SetInput(m_inputImage);
imgTimeSel->SetTimeNr(m_TimeStep);
imgTimeSel->UpdateLargestPossibleRegion();
m_InternalTimeSliceImage = imgTimeSel->GetOutput();
}
else
{
m_InternalTimeSliceImage = m_inputImage;
}
m_InternalITKImageMask2D = nullptr;
const PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
const PlaneGeometry *planarFigureGeometry = dynamic_cast< const PlaneGeometry * >( planarFigurePlaneGeometry );
//const BaseGeometry *imageGeometry = m_inputImage->GetGeometry();
// 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
itk::Image< unsigned short, 3 >::IndexType index;
imageGeometry->WorldToIndex( planarFigureGeometry->GetOrigin(), index );
unsigned int slice = index[axis];
// extract image slice which corresponds to the planarFigure and store it in m_InternalImageSlice
mitk::Image::Pointer inputImageSlice = extract2DImageSlice(axis, slice);
//mitk::IOUtil::SaveImage(inputImageSlice, "/home/fabian/inputSliceImage.nrrd");
// Compute mask from PlanarFigure
AccessFixedDimensionByItk_1(inputImageSlice,
InternalCalculateMaskFromPlanarFigure,
2, axis)
//convert itk mask to mitk::Image::Pointer and return it
mitk::Image::Pointer planarFigureMaskImage;
planarFigureMaskImage = mitk::GrabItkImageMemory(m_InternalITKImageMask2D);
//mitk::IOUtil::SaveImage(planarFigureMaskImage, "/home/fabian/planarFigureMaskImage.nrrd");
//Convert2Dto3DImageFilter::Pointer sliceTo3DImageConverter = Convert2Dto3DImageFilter::New();
//sliceTo3DImageConverter->SetInput(planarFigureMaskImage);
//sliceTo3DImageConverter->Update();
//mitk::IOUtil::SaveImage(sliceTo3DImageConverter->GetOutput(), "/home/fabian/3DsliceImage.nrrd");
m_ReferenceImage = inputImageSlice;
//mitk::IOUtil::SaveImage(m_ReferenceImage, "/home/fabian/referenceImage.nrrd");
m_InternalMask = planarFigureMaskImage;
}
+void PlanarFigureMaskGenerator::SetTimeStep(unsigned int timeStep)
+{
+ if (timeStep != m_TimeStep)
+ {
+ m_TimeStep = timeStep;
+ }
+}
+
mitk::Image::Pointer PlanarFigureMaskGenerator::GetMask()
{
if (IsUpdateRequired())
{
this->CalculateMask();
this->Modified();
}
- m_InternalMaskUpdateTime = m_InternalMask->GetMTime();
+ m_InternalMaskUpdateTime = this->GetMTime();
return m_InternalMask;
}
mitk::Image::Pointer PlanarFigureMaskGenerator::extract2DImageSlice(unsigned int axis, unsigned int slice)
{
// Extract slice with given position and direction from image
unsigned int dimension = m_InternalTimeSliceImage->GetDimension();
mitk::Image::Pointer imageSlice = mitk::Image::New();
if (dimension == 3)
{
ExtractImageFilter::Pointer imageExtractor = ExtractImageFilter::New();
imageExtractor->SetInput( m_InternalTimeSliceImage );
imageExtractor->SetSliceDimension( axis );
imageExtractor->SetSliceIndex( slice );
imageExtractor->Update();
imageSlice = imageExtractor->GetOutput();
}
else if(dimension == 2)
{
imageSlice = m_InternalTimeSliceImage;
}
else
{
MITK_ERROR << "Unsupported image dimension. Dimension is: " << dimension << ". Only 2D and 3D images are supported.";
}
return imageSlice;
}
bool PlanarFigureMaskGenerator::IsUpdateRequired() const
{
unsigned long thisClassTimeStamp = this->GetMTime();
unsigned long internalMaskTimeStamp = m_InternalMask->GetMTime();
unsigned long planarFigureTimeStamp = m_PlanarFigure->GetMTime();
unsigned long inputImageTimeStamp = m_inputImage->GetMTime();
if (thisClassTimeStamp > m_InternalMaskUpdateTime) // inputs have changed
{
return true;
}
if (m_InternalMaskUpdateTime < planarFigureTimeStamp || m_InternalMaskUpdateTime < inputImageTimeStamp) // mask image has changed outside of this class
{
return true;
}
if (internalMaskTimeStamp > m_InternalMaskUpdateTime) // internal mask has been changed outside of this class
{
return true;
}
return false;
}
}
diff --git a/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.h b/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.h
index 8585238d56..620c6c2c7c 100644
--- a/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.h
@@ -1,119 +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.
+
+===================================================================*/
+
#ifndef MITKPLANARFIGUREMASKGENERATOR
#define MITKPLANARFIGUREMASKGENERATOR
#include <MitkImageStatisticsExports.h>
#include <mitkImage.h>
#include <mitkPlanarFigure.h>
#include <itkImage.h>
#include <mitkMaskGenerator.h>
#include <vtkSmartPointer.h>
#include <itkVTKImageExport.h>
#include <itkVTKImageImport.h>
#include <vtkImageImport.h>
#include <vtkImageExport.h>
namespace mitk
{
/**
* \class PlanarFigureMaskGenerator
* \brief Derived from MaskGenerator. This class is used to convert a mitk::PlanarFigure into a binary image mask
*/
class MITKIMAGESTATISTICS_EXPORT PlanarFigureMaskGenerator: public MaskGenerator
{
public:
/** Standard Self typedef */
typedef PlanarFigureMaskGenerator Self;
typedef MaskGenerator Superclass;
typedef itk::SmartPointer< Self > Pointer;
typedef itk::SmartPointer< const Self > ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Runtime information support. */
itkTypeMacro(PlanarFigureMaskGenerator, MaskGenerator)
/**
* @brief GetMask Computes and returns the mask
* @return mitk::Image::Pointer of the generated mask
*/
mitk::Image::Pointer GetMask();
void SetPlanarFigure(mitk::PlanarFigure::Pointer planarFigure);
mitk::Image::Pointer GetReferenceImage();
+ /**
+ * @brief SetTimeStep is used to set the time step for which the mask is to be generated
+ * @param timeStep
+ */
+ void SetTimeStep(unsigned int timeStep);
+
+
protected:
PlanarFigureMaskGenerator():Superclass(){
m_InternalMaskUpdateTime = 0;
m_InternalMask = mitk::Image::New();
m_ReferenceImage = nullptr;
}
+
private:
void CalculateMask();
template < typename TPixel, unsigned int VImageDimension >
void InternalCalculateMaskFromPlanarFigure(
const itk::Image< TPixel, VImageDimension > *image, unsigned int axis );
mitk::Image::Pointer extract2DImageSlice(unsigned int axis, unsigned int slice);
bool GetPrincipalAxis(const BaseGeometry *geometry, Vector3D vector,
unsigned int &axis );
/** Connection from ITK to VTK */
template <typename ITK_Exporter, typename VTK_Importer>
void ConnectPipelines(ITK_Exporter exporter, vtkSmartPointer<VTK_Importer> importer)
{
importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
importer->SetSpacingCallback(exporter->GetSpacingCallback());
importer->SetOriginCallback(exporter->GetOriginCallback());
importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
importer->SetCallbackUserData(exporter->GetCallbackUserData());
}
/** Connection from VTK to ITK */
template <typename VTK_Exporter, typename ITK_Importer>
void ConnectPipelines(vtkSmartPointer<VTK_Exporter> exporter, ITK_Importer importer)
{
importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
importer->SetSpacingCallback(exporter->GetSpacingCallback());
importer->SetOriginCallback(exporter->GetOriginCallback());
importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
importer->SetCallbackUserData(exporter->GetCallbackUserData());
}
bool IsUpdateRequired() const;
mitk::PlanarFigure::Pointer m_PlanarFigure;
itk::Image<unsigned short, 2>::Pointer m_InternalITKImageMask2D;
mitk::Image::Pointer m_InternalTimeSliceImage;
mitk::Image::Pointer m_ReferenceImage;
unsigned int m_PlanarFigureAxis;
unsigned long m_InternalMaskUpdateTime;
};
}
#endif // MITKPLANARFIGUREMASKGENERATOR
diff --git a/Modules/OpenCVVideoSupport/CMakeLists.txt b/Modules/OpenCVVideoSupport/CMakeLists.txt
index 29a0a94615..c070905b75 100644
--- a/Modules/OpenCVVideoSupport/CMakeLists.txt
+++ b/Modules/OpenCVVideoSupport/CMakeLists.txt
@@ -1,19 +1,19 @@
set(dependencies ITK|ITKVideoBridgeOpenCV OpenCV)
if(MITK_USE_videoInput)
set(dependencies ${dependencies} videoInput)
endif(MITK_USE_videoInput)
mitk_create_module(
INCLUDE_DIRS Commands
DEPENDS MitkAlgorithmsExt
PACKAGE_DEPENDS PUBLIC ${dependencies}
ADDITIONAL_LIBS ${OPENCVVIDEOSUPPORT_ADDITIONAL_LIBS}
)
if(MODULE_IS_ENABLED)
- if(MITK_USE_QT)
+ if(MITK_USE_Qt5)
add_subdirectory(UI)
endif()
endif()
add_subdirectory(Testing)
diff --git a/Modules/QtWidgetsExt/resource/logo_dkfz.png b/Modules/QtWidgetsExt/resource/logo_dkfz.png
new file mode 100644
index 0000000000..89e49e046e
Binary files /dev/null and b/Modules/QtWidgetsExt/resource/logo_dkfz.png differ
diff --git a/Modules/QtWidgetsExt/src/QmitkAboutDialogGUI.ui b/Modules/QtWidgetsExt/src/QmitkAboutDialogGUI.ui
index 7133624533..17df210a5b 100644
--- a/Modules/QtWidgetsExt/src/QmitkAboutDialogGUI.ui
+++ b/Modules/QtWidgetsExt/src/QmitkAboutDialogGUI.ui
@@ -1,174 +1,175 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkAboutDialog</class>
<widget class="QDialog" name="QmitkAboutDialog">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>534</width>
<height>421</height>
</rect>
</property>
<property name="windowTitle">
<string>About</string>
</property>
<property name="autoFillBackground">
<bool>false</bool>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QLabel" name="m_CaptionLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<family>MS Sans Serif</family>
<pointsize>48</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>MITK</string>
</property>
<property name="alignment">
<set>Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft</set>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_RevisionLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Revision: hash
Description:</string>
</property>
<property name="alignment">
<set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_ToolkitVersionsLabel">
<property name="text">
<string>ITK x.x.x, VTK x.x.x, Qt x.x.x</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeType">
<enum>QSizePolicy::Expanding</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QLabel" name="m_LogoLabel">
<property name="maximumSize">
<size>
<width>84</width>
<height>56</height>
</size>
</property>
<property name="text">
<string><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html><head><meta name="qrichtext" content="1" /><style type="text/css">
p, li { white-space: pre-wrap; }
</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;">
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><a href="http://www.dkfz.de/en/mbi/"><span style=" text-decoration: underline; color:#0000ff;"><img src=":/QtWidgetsExt/Logo_mbiATdkfz_small.png" /></span></a></p></body></html></string>
</property>
<property name="scaledContents">
<bool>true</bool>
</property>
<property name="openExternalLinks">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QScrollArea" name="scrollArea">
<property name="widgetResizable">
<bool>true</bool>
</property>
<widget class="QWidget" name="m_ScrollArea">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>514</width>
- <height>236</height>
+ <width>520</width>
+ <height>287</height>
</rect>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="1">
<widget class="QLabel" name="m_AboutLabel">
<property name="text">
<string><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html><head><meta name="qrichtext" content="1" /><style type="text/css">
p, li { white-space: pre-wrap; }
</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:8pt; font-weight:400; font-style:normal;">
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-family:'Ubuntu'; font-size:10pt; font-weight:600;">General Information</span></p>
<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Ubuntu'; font-size:11pt;"><br /></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">MITK [1] has been developed by the Division of Medical and Biological Informatics of the German Cancer Research Center (DKFZ) [2].</p>
+<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">MITK [1] has been developed by the Division of Computer-assisted medical interventions and Junior Group Medical Image Computing of the German Cancer Research Center (DKFZ) [2,3].</p>
<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><br /></p>
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">[1] <a href="http://www.mitk.org/"><span style=" text-decoration: underline; color:#0000ff;">http://www.mitk.org/</span></a></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">[2] <a href="http://www.dkfz.de/en/mbi/index.php"><span style=" text-decoration: underline; color:#0000ff;">http://www.dkfz.de/en/mbi/index.php</span></a></p>
+<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">[2] <a href="https://www.dkfz.de/en/cami/index.php"><span style=" text-decoration: underline; color:#0000ff;">https://www.dkfz.de/en/cami/index.php</span></a></p>
+<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">[3] <a href="https://www.dkfz.de/en/mic/index.php"><span style=" text-decoration: underline; color:#0000ff;">https://www.dkfz.de/en/mic/index.php</span></a></p>
<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><br /></p>
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">To contact the MITK team, see <a href="http://www.mitk.org/wiki/Contact"><span style=" text-decoration: underline; color:#0000ff;">http://www.mitk.org/wiki/Contact</span></a>.</p>
<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Ubuntu'; font-size:11pt;"><br /></p>
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt; font-weight:600;">Third Party Libraries</span></p>
<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><br /></p>
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><a href="http://docs.mitk.org/nightly/thirdpartylibs.html"><span style=" text-decoration: underline; color:#0000ff;">http://docs.mitk.org/nightly/thirdpartylibs.html</span></a></p>
<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; text-decoration: underline; color:#0000ff;"><br /></p></body></html></string>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
<property name="openExternalLinks">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
</widget>
</item>
<item>
<widget class="QDialogButtonBox" name="m_ButtonBox">
<property name="standardButtons">
<set>QDialogButtonBox::Close</set>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>
diff --git a/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp b/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp
index f67ca89f7b..168d634586 100644
--- a/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp
@@ -1,500 +1,508 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkPointListWidget.h"
#include <QDir>
#include <QFileDialog>
#include <QHBoxLayout>
#include <QMessageBox>
#include <mitkIOUtil.h>
#include <QmitkEditPointDialog.h>
#include <mitkPointSetDataInteractor.h>
#include <mitkDataInteractor.h>
QmitkPointListWidget::QmitkPointListWidget(QWidget *parent, int orientation)
: QWidget(parent),
m_PointListView(NULL),
m_MultiWidget(NULL),
m_PointSetNode(NULL),
m_Orientation(0),
m_MovePointUpBtn(NULL),
m_MovePointDownBtn(NULL),
m_RemovePointBtn(NULL),
m_SavePointsBtn(NULL),
m_LoadPointsBtn(NULL),
m_ToggleAddPoint(NULL),
m_AddPoint(NULL),
m_Snc1(NULL),
m_Snc2(NULL),
m_Snc3(NULL),
m_DataInteractor(NULL),
m_TimeStep(0),
m_EditAllowed(true),
m_NodeObserverTag(0)
{
m_PointListView = new QmitkPointListView();
if (orientation != 0)
m_Orientation = orientation;
SetupUi();
SetupConnections();
ObserveNewNode(NULL);
}
QmitkPointListWidget::~QmitkPointListWidget()
{
m_DataInteractor = NULL;
if (m_PointSetNode && m_NodeObserverTag)
{
m_PointSetNode->RemoveObserver(m_NodeObserverTag);
m_NodeObserverTag = 0;
}
m_MultiWidget = NULL;
delete m_PointListView;
}
void QmitkPointListWidget::SetupConnections()
{
connect(this->m_LoadPointsBtn, SIGNAL(clicked()), this, SLOT(OnBtnLoadPoints()));
connect(this->m_SavePointsBtn, SIGNAL(clicked()), this, SLOT(OnBtnSavePoints()));
connect(this->m_MovePointUpBtn, SIGNAL(clicked()), this, SLOT(MoveSelectedPointUp()));
connect(this->m_MovePointDownBtn, SIGNAL(clicked()), this, SLOT(MoveSelectedPointDown()));
connect(this->m_RemovePointBtn, SIGNAL(clicked()), this, SLOT(RemoveSelectedPoint()));
connect(this->m_ToggleAddPoint, SIGNAL(toggled(bool)), this, SLOT(OnBtnAddPoint(bool)));
connect(this->m_AddPoint, SIGNAL(clicked()), this, SLOT(OnBtnAddPointManually()));
connect(this->m_PointListView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(OnListDoubleClick()));
connect(this->m_PointListView, SIGNAL(SignalPointSelectionChanged()), this, SLOT(OnPointSelectionChanged()));
}
void QmitkPointListWidget::SetupUi()
{
// Setup the buttons
m_ToggleAddPoint = new QPushButton();
m_ToggleAddPoint->setMaximumSize(25, 25);
m_ToggleAddPoint->setCheckable(true);
m_ToggleAddPoint->setToolTip("Toggle point editing (use SHIFT + Left Mouse Button to add Points)");
QIcon iconAdd(":/QtWidgetsExt/btnSetPoints.xpm");
m_ToggleAddPoint->setIcon(iconAdd);
m_AddPoint = new QPushButton();
m_AddPoint->setMaximumSize(25, 25);
m_AddPoint->setToolTip("Manually add point");
QIcon iconAddManually(":/QtWidgetsExt/btnSetPointsManually.xpm");
m_AddPoint->setIcon(iconAddManually);
m_RemovePointBtn = new QPushButton();
m_RemovePointBtn->setMaximumSize(25, 25);
const QIcon iconDel(":/QtWidgetsExt/btnClear.xpm");
m_RemovePointBtn->setIcon(iconDel);
m_RemovePointBtn->setToolTip("Erase one point from list (Hotkey: DEL)");
m_MovePointUpBtn = new QPushButton();
m_MovePointUpBtn->setMaximumSize(25, 25);
const QIcon iconUp(":/QtWidgetsExt/btnUp.xpm");
m_MovePointUpBtn->setIcon(iconUp);
m_MovePointUpBtn->setToolTip("Swap selected point upwards (Hotkey: F2)");
m_MovePointDownBtn = new QPushButton();
m_MovePointDownBtn->setMaximumSize(25, 25);
const QIcon iconDown(":/QtWidgetsExt/btnDown.xpm");
m_MovePointDownBtn->setIcon(iconDown);
m_MovePointDownBtn->setToolTip("Swap selected point downwards (Hotkey: F3)");
m_SavePointsBtn = new QPushButton();
m_SavePointsBtn->setMaximumSize(25, 25);
QIcon iconSave(":/QtWidgetsExt/btnSave.xpm");
m_SavePointsBtn->setIcon(iconSave);
m_SavePointsBtn->setToolTip("Save points to file");
m_LoadPointsBtn = new QPushButton();
m_LoadPointsBtn->setMaximumSize(25, 25);
QIcon iconLoad(":/QtWidgetsExt/btnLoad.xpm");
m_LoadPointsBtn->setIcon(iconLoad);
m_LoadPointsBtn->setToolTip("Load list of points from file (REPLACES current content)");
int i;
QBoxLayout *lay1;
QBoxLayout *lay2;
switch (m_Orientation)
{
case 0:
lay1 = new QVBoxLayout(this);
lay2 = new QHBoxLayout();
i = 0;
break;
case 1:
lay1 = new QHBoxLayout(this);
lay2 = new QVBoxLayout();
i = -1;
break;
case 2:
lay1 = new QHBoxLayout(this);
lay2 = new QVBoxLayout();
i = 0;
break;
default:
lay1 = new QVBoxLayout(this);
lay2 = new QHBoxLayout();
i = -1;
break;
}
// setup Layouts
this->setLayout(lay1);
lay1->addLayout(lay2);
lay2->stretch(true);
lay2->addWidget(m_ToggleAddPoint);
lay2->addWidget(m_AddPoint);
lay2->addWidget(m_RemovePointBtn);
lay2->addWidget(m_MovePointUpBtn);
lay2->addWidget(m_MovePointDownBtn);
lay2->addWidget(m_SavePointsBtn);
lay2->addWidget(m_LoadPointsBtn);
lay1->insertWidget(i, m_PointListView);
this->setLayout(lay1);
}
void QmitkPointListWidget::SetPointSet(mitk::PointSet *newPs)
{
if (newPs == NULL)
return;
this->m_PointSetNode->SetData(newPs);
dynamic_cast<QmitkPointListModel *>(this->m_PointListView->model())->SetPointSetNode(m_PointSetNode);
ObserveNewNode(m_PointSetNode);
}
void QmitkPointListWidget::SetPointSetNode(mitk::DataNode *newNode)
{
if (m_DataInteractor.IsNotNull())
m_DataInteractor->SetDataNode(newNode);
ObserveNewNode(newNode);
dynamic_cast<QmitkPointListModel *>(this->m_PointListView->model())->SetPointSetNode(newNode);
}
void QmitkPointListWidget::OnBtnSavePoints()
{
if ((dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData())) == NULL)
return; // don't write empty point sets. If application logic requires something else then do something else.
if ((dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData()))->GetSize() == 0)
return;
// take the previously defined name of node as proposal for filename
std::string nodeName = m_PointSetNode->GetName();
nodeName = "/" + nodeName + ".mps";
QString fileNameProposal = QString();
fileNameProposal.append(nodeName.c_str());
QString aFilename = QFileDialog::getSaveFileName(
NULL, "Save point set", QDir::currentPath() + fileNameProposal, "MITK Pointset (*.mps)");
if (aFilename.isEmpty())
return;
try
{
mitk::IOUtil::Save(m_PointSetNode->GetData(), aFilename.toStdString());
}
catch (...)
{
QMessageBox::warning(this,
"Save point set",
QString("File writer reported problems writing %1\n\n"
"PLEASE CHECK output file!")
.arg(aFilename));
}
}
void QmitkPointListWidget::OnBtnLoadPoints()
{
// get the name of the file to load
QString filename = QFileDialog::getOpenFileName(NULL, "Open MITK Pointset", "", "MITK Point Sets (*.mps)");
if (filename.isEmpty())
return;
// attempt to load file
try
{
mitk::PointSet::Pointer pointSet = mitk::IOUtil::LoadPointSet(filename.toStdString());
if (pointSet.IsNull())
{
QMessageBox::warning(this, "Load point set", QString("File reader could not read %1").arg(filename));
return;
}
// loading successful
this->SetPointSet(pointSet);
}
catch (...)
{
QMessageBox::warning(this, "Load point set", QString("File reader collapsed while reading %1").arg(filename));
}
emit PointListChanged();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
mitk::PointSet *QmitkPointListWidget::GetPointSet()
{
return dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
}
mitk::DataNode *QmitkPointListWidget::GetPointSetNode()
{
return m_PointSetNode;
}
void QmitkPointListWidget::SetMultiWidget(QmitkStdMultiWidget *multiWidget)
{
this->m_MultiWidget = multiWidget;
m_PointListView->SetMultiWidget(multiWidget);
}
void QmitkPointListWidget::RemoveSelectedPoint()
{
if (!m_PointSetNode)
return;
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
if (!pointSet)
return;
if (pointSet->GetSize() == 0)
return;
QmitkPointListModel *pointListModel = dynamic_cast<QmitkPointListModel *>(m_PointListView->model());
pointListModel->RemoveSelectedPoint();
emit PointListChanged();
}
void QmitkPointListWidget::MoveSelectedPointDown()
{
if (!m_PointSetNode)
return;
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
if (!pointSet)
return;
if (pointSet->GetSize() == 0)
return;
QmitkPointListModel *pointListModel = dynamic_cast<QmitkPointListModel *>(m_PointListView->model());
pointListModel->MoveSelectedPointDown();
emit PointListChanged();
}
void QmitkPointListWidget::MoveSelectedPointUp()
{
if (!m_PointSetNode)
return;
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
if (!pointSet)
return;
if (pointSet->GetSize() == 0)
return;
QmitkPointListModel *pointListModel = dynamic_cast<QmitkPointListModel *>(m_PointListView->model());
pointListModel->MoveSelectedPointUp();
emit PointListChanged();
}
void QmitkPointListWidget::OnBtnAddPoint(bool checked)
{
if (m_PointSetNode.IsNotNull())
{
if (checked)
{
m_DataInteractor = m_PointSetNode->GetDataInteractor();
// If no data Interactor is present create a new one
if (m_DataInteractor.IsNull())
{
// Create PointSetData Interactor
m_DataInteractor = mitk::PointSetDataInteractor::New();
// Load the according state machine for regular point set interaction
m_DataInteractor->LoadStateMachine("PointSet.xml");
// Set the configuration file that defines the triggers for the transitions
m_DataInteractor->SetEventConfig("PointSetConfig.xml");
// set the DataNode (which already is added to the DataStorage
m_DataInteractor->SetDataNode(m_PointSetNode);
}
}
else
{
m_PointSetNode->SetDataInteractor(NULL);
m_DataInteractor = NULL;
}
emit EditPointSets(checked);
}
}
void QmitkPointListWidget::OnBtnAddPointManually()
{
mitk::PointSet *pointSet = this->GetPointSet();
+ QmitkEditPointDialog editPointDialog(this);
+ if (this->GetPointSet()->IsEmpty())
+ {
+ editPointDialog.SetPoint(pointSet, 0, m_TimeStep);
+ }
+
+ else
+ {
mitk::PointSet::PointsIterator maxIt = pointSet->GetMaxId();
mitk::PointSet::PointIdentifier maxId = maxIt->Index();
-
- QmitkEditPointDialog editPointDialog(this);
editPointDialog.SetPoint(pointSet, maxId + 1, m_TimeStep);
+ }
+
editPointDialog.exec();
}
void QmitkPointListWidget::OnListDoubleClick()
{
}
void QmitkPointListWidget::OnPointSelectionChanged()
{
emit this->PointSelectionChanged();
}
void QmitkPointListWidget::DeactivateInteractor(bool)
{
}
void QmitkPointListWidget::EnableEditButton(bool enabled)
{
m_EditAllowed = enabled;
if (enabled == false)
m_ToggleAddPoint->setEnabled(false);
else
m_ToggleAddPoint->setEnabled(true);
OnBtnAddPoint(enabled);
}
void QmitkPointListWidget::ObserveNewNode(mitk::DataNode *node)
{
if (m_DataInteractor.IsNotNull())
m_DataInteractor->SetDataNode(node);
// remove old observer
if (m_PointSetNode)
{
if (m_DataInteractor)
{
m_DataInteractor = NULL;
m_ToggleAddPoint->setChecked(false);
}
m_PointSetNode->RemoveObserver(m_NodeObserverTag);
m_NodeObserverTag = 0;
}
m_PointSetNode = node;
// add new observer if necessary
if (m_PointSetNode)
{
itk::ReceptorMemberCommand<QmitkPointListWidget>::Pointer command =
itk::ReceptorMemberCommand<QmitkPointListWidget>::New();
command->SetCallbackFunction(this, &QmitkPointListWidget::OnNodeDeleted);
m_NodeObserverTag = m_PointSetNode->AddObserver(itk::DeleteEvent(), command);
}
else
{
m_NodeObserverTag = 0;
}
if (m_EditAllowed == true)
m_ToggleAddPoint->setEnabled(m_PointSetNode);
else
m_ToggleAddPoint->setEnabled(false);
m_RemovePointBtn->setEnabled(m_PointSetNode);
m_LoadPointsBtn->setEnabled(m_PointSetNode);
m_SavePointsBtn->setEnabled(m_PointSetNode);
m_AddPoint->setEnabled(m_PointSetNode);
}
void QmitkPointListWidget::OnNodeDeleted(const itk::EventObject &)
{
if (m_PointSetNode.IsNotNull() && !m_NodeObserverTag)
m_PointSetNode->RemoveObserver(m_NodeObserverTag);
m_NodeObserverTag = 0;
m_PointSetNode = NULL;
m_PointListView->SetPointSetNode(NULL);
m_ToggleAddPoint->setEnabled(false);
m_RemovePointBtn->setEnabled(false);
m_LoadPointsBtn->setEnabled(false);
m_SavePointsBtn->setEnabled(false);
m_AddPoint->setEnabled(false);
}
void QmitkPointListWidget::SetSnc1(mitk::SliceNavigationController *snc)
{
if (snc == NULL)
{
m_PointListView->RemoveSliceNavigationController(m_Snc1);
}
else
{
m_PointListView->AddSliceNavigationController(snc);
}
m_Snc1 = snc;
}
void QmitkPointListWidget::SetSnc2(mitk::SliceNavigationController *snc)
{
if (snc == NULL)
{
m_PointListView->RemoveSliceNavigationController(m_Snc2);
}
else
{
m_PointListView->AddSliceNavigationController(snc);
}
m_Snc2 = snc;
}
void QmitkPointListWidget::SetSnc3(mitk::SliceNavigationController *snc)
{
if (snc == NULL)
{
m_PointListView->RemoveSliceNavigationController(m_Snc3);
}
else
{
m_PointListView->AddSliceNavigationController(snc);
}
m_Snc3 = snc;
}
void QmitkPointListWidget::AddSliceNavigationController(mitk::SliceNavigationController *snc)
{
m_PointListView->AddSliceNavigationController(snc);
}
void QmitkPointListWidget::RemoveSliceNavigationController(mitk::SliceNavigationController *snc)
{
m_PointListView->RemoveSliceNavigationController(snc);
}
void QmitkPointListWidget::UnselectEditButton()
{
m_ToggleAddPoint->setChecked(false);
}
diff --git a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
index 8dce70574a..536413600d 100644
--- a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
@@ -1,584 +1,641 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; 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 "mitkApplicationCursor.h"
#include "mitkBaseRenderer.h"
#include "mitkImageDataItem.h"
#include "mitkImageToContourModelFilter.h"
#include "mitkOverwriteSliceImageFilter.h"
#include "mitkRegionGrowingTool.xpm"
#include "mitkRenderingManager.h"
#include "mitkToolManager.h"
#include "mitkExtractDirectedPlaneImageFilterNew.h"
#include "mitkLabelSetImage.h"
#include "mitkOverwriteDirectedPlaneImageFilter.h"
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
// ITK
#include "mitkITKImageImport.h"
#include "mitkImageAccessByItk.h"
#include <itkConnectedComponentImageFilter.h>
#include <itkConnectedThresholdImageFilter.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkNeighborhoodIterator.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, RegionGrowingTool, "Region growing tool");
}
#define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
mitk::RegionGrowingTool::RegionGrowingTool()
: FeedbackContourTool("PressMoveRelease"),
m_SeedValue(0),
m_ScreenYDifference(0),
m_ScreenXDifference(0),
m_VisibleWindow(0),
m_MouseDistanceScaleFactor(0.5),
m_FillFeedbackContour(true),
m_ConnectedComponentValue(1)
{
}
mitk::RegionGrowingTool::~RegionGrowingTool()
{
}
void mitk::RegionGrowingTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
CONNECT_FUNCTION("Move", OnMouseMoved);
CONNECT_FUNCTION("Release", OnMouseReleased);
}
const char **mitk::RegionGrowingTool::GetXPM() const
{
return mitkRegionGrowingTool_xpm;
}
us::ModuleResource mitk::RegionGrowingTool::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("RegionGrowing_48x48.png");
return resource;
}
us::ModuleResource mitk::RegionGrowingTool::GetCursorIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("RegionGrowing_Cursor_32x32.png");
return resource;
}
const char *mitk::RegionGrowingTool::GetName() const
{
return "Region Growing";
}
void mitk::RegionGrowingTool::Activated()
{
Superclass::Activated();
}
void mitk::RegionGrowingTool::Deactivated()
{
Superclass::Deactivated();
}
// Get the average pixel value of square/cube with radius=neighborhood around index
template <typename TPixel, unsigned int imageDimension>
void mitk::RegionGrowingTool::GetNeighborhoodAverage(itk::Image<TPixel, imageDimension> *itkImage,
itk::Index<imageDimension> index,
ScalarType *result,
unsigned int neighborhood)
{
// maybe assert that image dimension is only 2 or 3?
int neighborhoodInt = (int)neighborhood;
TPixel averageValue(0);
unsigned int numberOfPixels = (2 * neighborhood + 1) * (2 * neighborhood + 1);
if (imageDimension == 3)
{
numberOfPixels *= (2 * neighborhood + 1);
}
MITK_DEBUG << "Getting neighborhood of " << numberOfPixels << " pixels around " << index;
itk::Index<imageDimension> currentIndex;
for (int i = (0 - neighborhoodInt); i <= neighborhoodInt; ++i)
{
currentIndex[0] = index[0] + i;
for (int j = (0 - neighborhoodInt); j <= neighborhoodInt; ++j)
{
currentIndex[1] = index[1] + j;
if (imageDimension == 3)
{
for (int k = (0 - neighborhoodInt); k <= neighborhoodInt; ++k)
{
currentIndex[2] = index[2] + k;
if (itkImage->GetLargestPossibleRegion().IsInside(currentIndex))
{
averageValue += itkImage->GetPixel(currentIndex);
}
else
{
numberOfPixels -= 1;
}
}
}
else
{
if (itkImage->GetLargestPossibleRegion().IsInside(currentIndex))
{
averageValue += itkImage->GetPixel(currentIndex);
}
else
{
numberOfPixels -= 1;
}
}
}
}
*result = (ScalarType)averageValue;
*result /= numberOfPixels;
}
// Check whether index lies inside a segmentation
template <typename TPixel, unsigned int imageDimension>
void mitk::RegionGrowingTool::IsInsideSegmentation(itk::Image<TPixel, imageDimension> *itkImage,
itk::Index<imageDimension> index,
bool *result)
{
if (itkImage->GetPixel(index) > 0)
{
*result = true;
}
else
{
*result = false;
}
}
// Do the region growing (i.e. call an ITK filter that does it)
template <typename TPixel, unsigned int imageDimension>
void mitk::RegionGrowingTool::StartRegionGrowing(itk::Image<TPixel, imageDimension> *inputImage,
itk::Index<imageDimension> seedIndex,
std::array<ScalarType, 2> thresholds,
mitk::Image::Pointer &outputImage)
{
MITK_DEBUG << "Starting region growing at index " << seedIndex << " with lower threshold " << thresholds[0]
<< " and upper threshold " << thresholds[1];
typedef itk::Image<TPixel, imageDimension> InputImageType;
typedef itk::Image<DefaultSegmentationDataType, imageDimension> OutputImageType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, OutputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
// perform region growing in desired segmented region
regionGrower->SetInput(inputImage);
regionGrower->AddSeed(seedIndex);
regionGrower->SetLower(thresholds[0]);
regionGrower->SetUpper(thresholds[1]);
try
{
regionGrower->Update();
}
catch (...)
{
return; // Should we do something?
}
typename OutputImageType::Pointer resultImage = regionGrower->GetOutput();
// Smooth result: Every pixel is replaced by the majority of the neighborhood
typedef itk::NeighborhoodIterator<OutputImageType> NeighborhoodIteratorType;
typedef itk::ImageRegionIterator<OutputImageType> ImageIteratorType;
typename NeighborhoodIteratorType::RadiusType radius;
radius.Fill(2); // for now, maybe make this something the user can adjust in the preferences?
NeighborhoodIteratorType neighborhoodIterator(radius, resultImage, resultImage->GetRequestedRegion());
ImageIteratorType imageIterator(resultImage, resultImage->GetRequestedRegion());
for (neighborhoodIterator.GoToBegin(), imageIterator.GoToBegin(); !neighborhoodIterator.IsAtEnd();
++neighborhoodIterator, ++imageIterator)
{
DefaultSegmentationDataType voteYes(0);
DefaultSegmentationDataType voteNo(0);
for (unsigned int i = 0; i < neighborhoodIterator.Size(); ++i)
{
if (neighborhoodIterator.GetPixel(i) > 0)
{
voteYes += 1;
}
else
{
voteNo += 1;
}
}
if (voteYes > voteNo)
{
imageIterator.Set(1);
}
else
{
imageIterator.Set(0);
}
}
if (resultImage.IsNull())
{
MITK_DEBUG << "Region growing result is empty.";
}
// Can potentially have multiple regions, use connected component image filter to label disjunct regions
typedef itk::ConnectedComponentImageFilter<OutputImageType, OutputImageType> ConnectedComponentImageFilterType;
typename ConnectedComponentImageFilterType::Pointer connectedComponentFilter =
ConnectedComponentImageFilterType::New();
connectedComponentFilter->SetInput(resultImage);
connectedComponentFilter->Update();
typename OutputImageType::Pointer resultImageCC = connectedComponentFilter->GetOutput();
m_ConnectedComponentValue = resultImageCC->GetPixel(seedIndex);
outputImage = mitk::GrabItkImageMemory(resultImageCC);
}
void mitk::RegionGrowingTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
mitk::InteractionPositionEvent *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
MITK_DEBUG << "OnMousePressed";
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
m_LastScreenPosition = positionEvent->GetPointerPositionOnScreen();
// ReferenceSlice is from the underlying image, WorkingSlice from the active segmentation (can be empty)
m_ReferenceSlice = FeedbackContourTool::GetAffectedReferenceSlice(positionEvent);
m_WorkingSlice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
if (m_WorkingSlice.IsNotNull()) // can't do anything without a working slice (i.e. a possibly empty segmentation)
{
MITK_DEBUG << "OnMousePressed: got working slice";
// 2. Determine if the user clicked inside or outside of the segmentation/working slice (i.e. the whole volume)
mitk::BaseGeometry::Pointer workingSliceGeometry;
- workingSliceGeometry = m_WorkingSlice->GetTimeGeometry()->GetGeometryForTimeStep(m_LastEventSender->GetTimeStep());
+ workingSliceGeometry = m_WorkingSlice->GetGeometry();
workingSliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), m_SeedPoint);
itk::Index<2> indexInWorkingSlice2D;
indexInWorkingSlice2D[0] = m_SeedPoint[0];
indexInWorkingSlice2D[1] = m_SeedPoint[1];
if (workingSliceGeometry->IsIndexInside(m_SeedPoint))
{
MITK_DEBUG << "OnMousePressed: point " << positionEvent->GetPositionInWorld() << " (index coordinates "
<< m_SeedPoint << ") is inside working slice";
// 3. determine the pixel value under the last click to determine what to do
bool inside(true);
AccessFixedDimensionByItk_2(m_WorkingSlice, IsInsideSegmentation, 2, indexInWorkingSlice2D, &inside);
m_PaintingPixelValue = inside ? 0 : 1;
if (inside)
{
MITK_DEBUG << "Clicked inside segmentation";
// For now, we're doing nothing when the user clicks inside the segmentation. Behaviour can be implemented via
// OnMousePressedInside()
// When you do, be sure to remove the m_PaintingPixelValue check in OnMouseMoved() and OnMouseReleased()
return;
}
else
{
MITK_DEBUG << "Clicked outside of segmentation";
OnMousePressedOutside(nullptr, interactionEvent);
}
}
}
}
// Use this to implement a behaviour for when the user clicks inside a segmentation (for example remove something)
// Old IpPic code is kept as comment for reference
void mitk::RegionGrowingTool::OnMousePressedInside()
{
// mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent
// );
// //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)
// {
// int timestep = positionEvent->GetSender()->GetTimeStep();
// // 3.1.2 copy point from float* to mitk::Contour
// ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
// contourInImageIndexCoordinates->Expand(timestep + 1);
// contourInImageIndexCoordinates->SetClosed(true, timestep);
// Point3D newPoint;
// for (int index = 0; index < cutContour.deleteSize; ++index)
// {
// newPoint[0] = cutContour.deleteCurve[ 2 * index + 0 ] - 0.5;//correction is needed because the
// output of the algorithm is center based
// newPoint[1] = cutContour.deleteCurve[ 2 * index + 1 ] - 0.5;//and we want our contour displayed
// corner based.
// newPoint[2] = 0.0;
// contourInImageIndexCoordinates->AddVertex( newPoint, timestep );
// }
// free(cutContour.traceline);
// free(cutContour.deleteCurve); // perhaps visualize this for fun?
// free(cutContour.onGradient);
// ContourModel::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;
}
void mitk::RegionGrowingTool::OnMousePressedOutside(StateMachineAction *, InteractionEvent *interactionEvent)
{
mitk::InteractionPositionEvent *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (positionEvent)
{
// Get geometry and indices
mitk::BaseGeometry::Pointer workingSliceGeometry;
- workingSliceGeometry = m_WorkingSlice->GetTimeGeometry()->GetGeometryForTimeStep(m_LastEventSender->GetTimeStep());
+ workingSliceGeometry = m_WorkingSlice->GetGeometry();
itk::Index<2> indexInWorkingSlice2D;
indexInWorkingSlice2D[0] = m_SeedPoint[0];
indexInWorkingSlice2D[1] = m_SeedPoint[1];
mitk::BaseGeometry::Pointer referenceSliceGeometry;
referenceSliceGeometry =
- m_ReferenceSlice->GetTimeGeometry()->GetGeometryForTimeStep(m_LastEventSender->GetTimeStep());
+ m_ReferenceSlice->GetGeometry();
itk::Index<3> indexInReferenceSlice;
itk::Index<2> indexInReferenceSlice2D;
referenceSliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), indexInReferenceSlice);
indexInReferenceSlice2D[0] = indexInReferenceSlice[0];
indexInReferenceSlice2D[1] = indexInReferenceSlice[1];
// Get seed neighborhood
ScalarType averageValue(0);
AccessFixedDimensionByItk_3(m_ReferenceSlice, GetNeighborhoodAverage, 2, indexInReferenceSlice2D, &averageValue, 1);
m_SeedValue = averageValue;
MITK_DEBUG << "Seed value is " << m_SeedValue;
// Get level window settings
LevelWindow lw(0, 500); // default window 0 to 500, can we do something smarter here?
m_ToolManager->GetReferenceData(0)->GetLevelWindow(
lw); // will fill lw if levelwindow property is present, otherwise won't touch it.
ScalarType currentVisibleWindow = lw.GetWindow();
MITK_DEBUG << "Level window width is " << currentVisibleWindow;
m_InitialThresholds[0] = m_SeedValue - currentVisibleWindow / 20.0; // 20 is arbitrary (though works reasonably
// well), is there a better alternative (maybe
// option in preferences)?
m_InitialThresholds[1] = m_SeedValue + currentVisibleWindow / 20.0;
m_Thresholds[0] = m_InitialThresholds[0];
m_Thresholds[1] = m_InitialThresholds[1];
// Perform region growing
mitk::Image::Pointer resultImage = mitk::Image::New();
AccessFixedDimensionByItk_3(
m_ReferenceSlice, StartRegionGrowing, 2, indexInWorkingSlice2D, m_Thresholds, resultImage);
resultImage->SetGeometry(workingSliceGeometry);
// Extract contour
if (resultImage.IsNotNull() && m_ConnectedComponentValue >= 1)
{
mitk::ImageToContourModelFilter::Pointer contourExtractor = mitk::ImageToContourModelFilter::New();
contourExtractor->SetInput(resultImage);
contourExtractor->SetContourValue(m_ConnectedComponentValue - 0.5);
contourExtractor->Update();
ContourModel::Pointer resultContour = ContourModel::New();
resultContour = contourExtractor->GetOutput();
// Show contour
if (resultContour.IsNotNull())
{
ContourModel::Pointer resultContourWorld = FeedbackContourTool::BackProjectContourFrom2DSlice(
workingSliceGeometry, FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, resultContour));
- FeedbackContourTool::SetFeedbackContour(resultContourWorld);
+
+ // this is not a beautiful solution, just one that works, check T22412 for details
+ int timestep = positionEvent->GetSender()->GetTimeStep();
+ if (0 != timestep)
+ {
+ int size = resultContourWorld->GetNumberOfVertices(0);
+ auto resultContourTimeWorld = mitk::ContourModel::New();
+ resultContourTimeWorld->Expand(timestep + 1);
+ for (int loop = 0; loop < size; ++loop)
+ {
+ resultContourTimeWorld->AddVertex(resultContourWorld->GetVertexAt(loop, 0), timestep);
+ }
+ FeedbackContourTool::SetFeedbackContour(resultContourTimeWorld);
+ }
+ else
+ {
+ FeedbackContourTool::SetFeedbackContour(resultContourWorld);
+ }
+
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate(m_LastEventSender->GetRenderWindow());
}
}
}
}
void mitk::RegionGrowingTool::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Until OnMousePressedInside() implements a behaviour, we're just returning here whenever m_PaintingPixelValue is 0,
// i.e. when the user clicked inside the segmentation
if (m_PaintingPixelValue == 0)
{
return;
}
mitk::InteractionPositionEvent *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (m_ReferenceSlice.IsNotNull() && positionEvent)
{
// Get geometry and indices
mitk::BaseGeometry::Pointer workingSliceGeometry;
- workingSliceGeometry = m_WorkingSlice->GetTimeGeometry()->GetGeometryForTimeStep(m_LastEventSender->GetTimeStep());
+ workingSliceGeometry = m_WorkingSlice->GetGeometry();
itk::Index<2> indexInWorkingSlice2D;
indexInWorkingSlice2D[0] = m_SeedPoint[0];
indexInWorkingSlice2D[1] = m_SeedPoint[1];
m_ScreenYDifference += positionEvent->GetPointerPositionOnScreen()[1] - m_LastScreenPosition[1];
m_ScreenXDifference += positionEvent->GetPointerPositionOnScreen()[0] - m_LastScreenPosition[0];
m_LastScreenPosition = positionEvent->GetPointerPositionOnScreen();
// Moving the mouse up and down adjusts the width of the threshold window, moving it left and right shifts the
// threshold window
m_Thresholds[0] = std::min<ScalarType>(
m_SeedValue, m_InitialThresholds[0] - (m_ScreenYDifference - m_ScreenXDifference) * m_MouseDistanceScaleFactor);
m_Thresholds[1] = std::max<ScalarType>(
m_SeedValue, m_InitialThresholds[1] + (m_ScreenYDifference + m_ScreenXDifference) * m_MouseDistanceScaleFactor);
MITK_DEBUG << "Screen difference X: " << m_ScreenXDifference;
// Perform region growing again and show the result
mitk::Image::Pointer resultImage = mitk::Image::New();
AccessFixedDimensionByItk_3(
m_ReferenceSlice, StartRegionGrowing, 2, indexInWorkingSlice2D, m_Thresholds, resultImage);
resultImage->SetGeometry(workingSliceGeometry);
// Update the contour
if (resultImage.IsNotNull() && m_ConnectedComponentValue >= 1)
{
mitk::ImageToContourModelFilter::Pointer contourExtractor = mitk::ImageToContourModelFilter::New();
contourExtractor->SetInput(resultImage);
contourExtractor->SetContourValue(m_ConnectedComponentValue - 0.5);
contourExtractor->Update();
ContourModel::Pointer resultContour = ContourModel::New();
resultContour = contourExtractor->GetOutput();
// Show contour
if (resultContour.IsNotNull())
{
ContourModel::Pointer resultContourWorld = FeedbackContourTool::BackProjectContourFrom2DSlice(
workingSliceGeometry, FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, resultContour));
- FeedbackContourTool::SetFeedbackContour(resultContourWorld);
+
+ // this is not a beautiful solution, just one that works, check T22412 for details
+ int timestep = positionEvent->GetSender()->GetTimeStep();
+ if (0 != timestep)
+ {
+ int size = resultContourWorld->GetNumberOfVertices(0);
+ auto resultContourTimeWorld = mitk::ContourModel::New();
+ resultContourTimeWorld->Expand(timestep + 1);
+ for (int loop = 0; loop < size; ++loop)
+ {
+ resultContourTimeWorld->AddVertex(resultContourWorld->GetVertexAt(loop, 0), timestep);
+ }
+ FeedbackContourTool::SetFeedbackContour(resultContourTimeWorld);
+ }
+ else
+ {
+ FeedbackContourTool::SetFeedbackContour(resultContourWorld);
+ }
+
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(positionEvent->GetSender()->GetRenderWindow());
}
}
}
}
void mitk::RegionGrowingTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Until OnMousePressedInside() implements a behaviour, we're just returning here whenever m_PaintingPixelValue is 0,
// i.e. when the user clicked inside the segmentation
if (m_PaintingPixelValue == 0)
{
return;
}
mitk::InteractionPositionEvent *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (m_WorkingSlice.IsNotNull() && m_FillFeedbackContour && positionEvent)
{
// Project contour into working slice
ContourModel *feedbackContour(FeedbackContourTool::GetFeedbackContour());
- ContourModel::Pointer projectedContour =
- FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, feedbackContour, false, false);
+
+ ContourModel::Pointer projectedContour;
+
+ // this is not a beautiful solution, just one that works, check T22412 for details
+ int timestep = positionEvent->GetSender()->GetTimeStep();
+ if (0 != timestep)
+ {
+ int size = feedbackContour->GetNumberOfVertices(timestep);
+ auto feedbackContourTime = mitk::ContourModel::New();
+ feedbackContourTime->Expand(timestep + 1);
+ for (int loop = 0; loop < size; ++loop)
+ {
+ feedbackContourTime->AddVertex(feedbackContour->GetVertexAt(loop, timestep), 0);
+ }
+
+ projectedContour =
+ FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, feedbackContourTime, false, false);
+ }
+ else
+ {
+ projectedContour =
+ FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, feedbackContour, false, false);
+ }
// If there is a projected contour, fill it
if (projectedContour.IsNotNull())
{
// Get working data to pass to following method so we don't overwrite locked labels in a LabelSetImage
mitk::DataNode *workingNode(m_ToolManager->GetWorkingData(0));
mitk::LabelSetImage *labelImage;
if (workingNode)
{
labelImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
}
MITK_DEBUG << "Filling Segmentation";
if (labelImage)
{
// m_PaintingPixelValue only decides whether to paint or not
// For LabelSetImages we want to paint with the active label value
auto activeLabel = labelImage->GetActiveLabel(labelImage->GetActiveLayer())->GetValue();
mitk::ContourModelUtils::FillContourInSlice(projectedContour,
- positionEvent->GetSender()->GetTimeStep(),
+ 0,
m_WorkingSlice,
labelImage,
m_PaintingPixelValue * activeLabel);
}
else
{
mitk::ContourModelUtils::FillContourInSlice(projectedContour,
- positionEvent->GetSender()->GetTimeStep(),
+ 0,
m_WorkingSlice,
m_WorkingSlice,
m_PaintingPixelValue);
}
this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice);
FeedbackContourTool::SetFeedbackContourVisible(false);
}
}
}
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index 5866a7db07..ca239702eb 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,610 +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.
===================================================================*/
#include "mitkSegTool2D.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkDataStorage.h"
#include "mitkPlaneGeometry.h"
#include "mitkExtractDirectedPlaneImageFilter.h"
#include "mitkExtractImageFilter.h"
// Include of the new ImageExtractor
#include "mitkExtractDirectedPlaneImageFilterNew.h"
#include "mitkMorphologicalOperations.h"
#include "mitkOverwriteDirectedPlaneImageFilter.h"
#include "mitkOverwriteSliceImageFilter.h"
#include "mitkPlanarCircle.h"
#include "usGetModuleContext.h"
// Includes for 3DSurfaceInterpolation
#include "mitkImageTimeSelector.h"
#include "mitkImageToContourFilter.h"
#include "mitkSurfaceInterpolationController.h"
// includes for resling and overwriting
#include <mitkExtractSliceFilter.h>
#include <mitkVtkImageOverwrite.h>
#include <vtkImageData.h>
#include <vtkSmartPointer.h>
+
#include "mitkOperationEvent.h"
#include "mitkUndoController.h"
#include <mitkDiffSliceOperationApplier.h>
#include "mitkAbstractTransformGeometry.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkImageToItk.h"
#include "mitkLabelSetImage.h"
#define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
bool mitk::SegTool2D::m_SurfaceInterpolationEnabled = true;
mitk::SegTool2D::SegTool2D(const char *type)
: Tool(type), m_LastEventSender(NULL), m_LastEventSlice(0), m_Contourmarkername("Position"), m_ShowMarkerNodes(false)
{
Tool::m_EventConfig = "DisplayConfigMITKNoCrosshair.xml";
}
mitk::SegTool2D::~SegTool2D()
{
}
bool mitk::SegTool2D::FilterEvents(InteractionEvent *interactionEvent, DataNode *)
{
const InteractionPositionEvent *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
bool isValidEvent =
(positionEvent && // Only events of type mitk::InteractionPositionEvent
interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D // Only events from the 2D renderwindows
);
return isValidEvent;
}
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.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
BaseGeometry *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;
}
void mitk::SegTool2D::UpdateSurfaceInterpolation(const Image *slice,
const Image *workingImage,
const PlaneGeometry *plane,
bool detectIntersection)
{
if (!m_SurfaceInterpolationEnabled)
return;
ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
mitk::Surface::Pointer contour;
if (detectIntersection)
{
// Test whether there is something to extract or whether the slice just contains intersections of others
mitk::Image::Pointer slice2 = slice->Clone();
mitk::MorphologicalOperations::Erode(slice2, 2, mitk::MorphologicalOperations::Ball);
contourExtractor->SetInput(slice2);
contourExtractor->Update();
contour = contourExtractor->GetOutput();
if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
{
// Remove contour!
mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
contourInfo.contourNormal = plane->GetNormal();
contourInfo.contourPoint = plane->GetOrigin();
mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo);
return;
}
}
contourExtractor->SetInput(slice);
contourExtractor->Update();
contour = contourExtractor->GetOutput();
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(workingImage);
timeSelector->SetTimeNr(0);
timeSelector->SetChannelNr(0);
timeSelector->Update();
Image::Pointer dimRefImg = timeSelector->GetOutput();
if (contour->GetVtkPolyData()->GetNumberOfPoints() != 0 && dimRefImg->GetDimension() == 3)
{
mitk::SurfaceInterpolationController::GetInstance()->AddNewContour(contour);
contour->DisconnectPipeline();
}
else
{
// Remove contour!
mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
contourInfo.contourNormal = plane->GetNormal();
contourInfo.contourPoint = plane->GetOrigin();
mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo);
}
}
-mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent,
- const Image *image)
+mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent, const Image *image, unsigned int component /*= 0*/)
{
if (!positionEvent)
- return NULL;
+ {
+ return nullptr;
+ }
assert(positionEvent->GetSender()); // sure, right?
- unsigned int timeStep =
- positionEvent->GetSender()->GetTimeStep(image); // get the timestep of the visible part (time-wise) of the image
+ unsigned int timeStep = positionEvent->GetSender()->GetTimeStep(image); // get the timestep of the visible part (time-wise) of the image
- return this->GetAffectedImageSliceAs2DImage(
- positionEvent->GetSender()->GetCurrentWorldPlaneGeometry(), image, timeStep);
+ return GetAffectedImageSliceAs2DImage(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry(), image, timeStep, component);
}
-mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry,
- const Image *image,
- unsigned int timeStep)
+mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry, const Image *image, unsigned int timeStep, unsigned int component /*= 0*/)
{
if (!image || !planeGeometry)
- return NULL;
+ {
+ return nullptr;
+ }
- // 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 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->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
+ // additionally extract the given component
+ // default is 0; the extractor checks for multi-component images
+ extractor->SetComponent(component);
extractor->Modified();
extractor->Update();
Image::Pointer slice = extractor->GetOutput();
return slice;
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const InteractionPositionEvent *positionEvent)
{
DataNode *workingNode(m_ToolManager->GetWorkingData(0));
if (!workingNode)
- return NULL;
+ {
+ return nullptr;
+ }
Image *workingImage = dynamic_cast<Image *>(workingNode->GetData());
if (!workingImage)
- return NULL;
+ {
+ return nullptr;
+ }
return GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent *positionEvent)
{
DataNode *referenceNode(m_ToolManager->GetReferenceData(0));
if (!referenceNode)
- return NULL;
+ {
+ return nullptr;
+ }
Image *referenceImage = dynamic_cast<Image *>(referenceNode->GetData());
if (!referenceImage)
- return NULL;
+ {
+ return nullptr;
+ }
- return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage);
+ int displayedComponent = 0;
+ if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
+ {
+ // found the displayed component
+ return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage, displayedComponent);
+ }
+ else
+ {
+ return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage);
+ }
}
void mitk::SegTool2D::WriteBackSegmentationResult(const InteractionPositionEvent *positionEvent, Image *slice)
{
if (!positionEvent)
return;
const PlaneGeometry *planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
const AbstractTransformGeometry *abstractTransformGeometry(
dynamic_cast<const AbstractTransformGeometry *>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
if (planeGeometry && slice && !abstractTransformGeometry)
{
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);
}
}
void mitk::SegTool2D::WriteBackSegmentationResult(const PlaneGeometry *planeGeometry,
Image *slice,
unsigned int timeStep)
{
if (!planeGeometry || !slice)
return;
SliceInformation sliceInfo(slice, const_cast<mitk::PlaneGeometry *>(planeGeometry), timeStep);
this->WriteSliceToVolume(sliceInfo);
DataNode *workingNode(m_ToolManager->GetWorkingData(0));
Image *image = dynamic_cast<Image *>(workingNode->GetData());
this->UpdateSurfaceInterpolation(slice, image, planeGeometry, false);
if (m_SurfaceInterpolationEnabled)
this->AddContourmarker();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::SegTool2D::WriteBackSegmentationResult(std::vector<mitk::SegTool2D::SliceInformation> sliceList,
bool writeSliceToVolume)
{
std::vector<mitk::Surface::Pointer> contourList;
contourList.reserve(sliceList.size());
ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
DataNode *workingNode(m_ToolManager->GetWorkingData(0));
Image *image = dynamic_cast<Image *>(workingNode->GetData());
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(image);
timeSelector->SetTimeNr(0);
timeSelector->SetChannelNr(0);
timeSelector->Update();
Image::Pointer dimRefImg = timeSelector->GetOutput();
for (unsigned int i = 0; i < sliceList.size(); ++i)
{
SliceInformation currentSliceInfo = sliceList.at(i);
if (writeSliceToVolume)
this->WriteSliceToVolume(currentSliceInfo);
if (m_SurfaceInterpolationEnabled && dimRefImg->GetDimension() == 3)
{
currentSliceInfo.slice->DisconnectPipeline();
contourExtractor->SetInput(currentSliceInfo.slice);
contourExtractor->Update();
mitk::Surface::Pointer contour = contourExtractor->GetOutput();
contour->DisconnectPipeline();
contourList.push_back(contour);
}
}
mitk::SurfaceInterpolationController::GetInstance()->AddNewContours(contourList);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::SegTool2D::WriteSliceToVolume(mitk::SegTool2D::SliceInformation sliceInfo)
{
DataNode *workingNode(m_ToolManager->GetWorkingData(0));
Image *image = dynamic_cast<Image *>(workingNode->GetData());
/*============= BEGIN undo/redo feature block ========================*/
// Create undo operation by caching the not yet modified slices
mitk::Image::Pointer originalSlice = GetAffectedImageSliceAs2DImage(sliceInfo.plane, image, sliceInfo.timestep);
DiffSliceOperation *undoOperation =
new DiffSliceOperation(const_cast<mitk::Image *>(image),
originalSlice,
dynamic_cast<SlicedGeometry3D *>(originalSlice->GetGeometry()),
sliceInfo.timestep,
sliceInfo.plane);
/*============= END undo/redo feature block ========================*/
// 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(sliceInfo.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(sliceInfo.timestep);
extractor->SetWorldGeometry(sliceInfo.plane);
extractor->SetVtkOutputRequest(false);
extractor->SetResliceTransformByGeometry(image->GetGeometry(sliceInfo.timestep));
extractor->Modified();
extractor->Update();
// the image was modified within the pipeline, but not marked so
image->Modified();
image->GetVtkImageData()->Modified();
/*============= BEGIN undo/redo feature block ========================*/
// specify the undo operation with the edited slice
DiffSliceOperation *doOperation =
new DiffSliceOperation(image,
extractor->GetOutput(),
dynamic_cast<SlicedGeometry3D *>(sliceInfo.slice->GetGeometry()),
sliceInfo.timestep,
sliceInfo.plane);
// create an operation event for the undo stack
OperationEvent *undoStackItem =
new OperationEvent(DiffSliceOperationApplier::GetInstance(), doOperation, undoOperation, "Segmentation");
// add it to the undo controller
UndoStackItem::IncCurrObjectEventId();
UndoStackItem::IncCurrGroupEventId();
UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
// clear the pointers as the operation are stored in the undocontroller and also deleted from there
undoOperation = NULL;
doOperation = NULL;
/*============= END undo/redo feature block ========================*/
}
void mitk::SegTool2D::SetShowMarkerNodes(bool status)
{
m_ShowMarkerNodes = status;
}
void mitk::SegTool2D::SetEnable3DInterpolation(bool enabled)
{
m_SurfaceInterpolationEnabled = enabled;
}
int mitk::SegTool2D::AddContourmarker()
{
if (m_LastEventSender == NULL)
return -1;
us::ServiceReference<PlanePositionManagerService> serviceRef =
us::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
PlanePositionManagerService *service = us::GetModuleContext()->GetService(serviceRef);
unsigned int slicePosition = m_LastEventSender->GetSliceNavigationController()->GetSlice()->GetPos();
// the first geometry is needed otherwise restoring the position is not working
const mitk::PlaneGeometry *plane =
dynamic_cast<const PlaneGeometry *>(dynamic_cast<const mitk::SlicedGeometry3D *>(
m_LastEventSender->GetSliceNavigationController()->GetCurrentGeometry3D())
->GetPlaneGeometry(0));
unsigned int size = service->GetNumberOfPlanePositions();
unsigned int id = service->AddNewPlanePosition(plane, slicePosition);
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->SetPlaneGeometry(const_cast<PlaneGeometry *>(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, m_LastEventSender);
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)
{
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;
}
}
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
<< " https://phabricator.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;
}
template <typename TPixel, unsigned int VImageDimension>
void InternalWritePreviewOnWorkingImage(itk::Image<TPixel, VImageDimension> *targetSlice,
const mitk::Image *sourceSlice,
mitk::Image *originalImage,
int overwritevalue)
{
typedef itk::Image<TPixel, VImageDimension> SliceType;
typename SliceType::Pointer sourceSliceITK;
CastToItkImage(sourceSlice, sourceSliceITK);
// now the original slice and the ipSegmentation-painted slice are in the same format, and we can just copy all pixels
// that are non-zero
typedef itk::ImageRegionIterator<SliceType> OutputIteratorType;
typedef itk::ImageRegionConstIterator<SliceType> InputIteratorType;
InputIteratorType inputIterator(sourceSliceITK, sourceSliceITK->GetLargestPossibleRegion());
OutputIteratorType outputIterator(targetSlice, targetSlice->GetLargestPossibleRegion());
outputIterator.GoToBegin();
inputIterator.GoToBegin();
mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(originalImage);
assert(workingImage);
int activePixelValue = workingImage->GetActiveLabel()->GetValue();
if (activePixelValue == 0) // if exterior is the active label
{
while (!outputIterator.IsAtEnd())
{
if (inputIterator.Get() != 0)
{
outputIterator.Set(overwritevalue);
}
++outputIterator;
++inputIterator;
}
}
else if (overwritevalue != 0) // if we are not erasing
{
while (!outputIterator.IsAtEnd())
{
int targetValue = static_cast<int>(outputIterator.Get());
if (inputIterator.Get() != 0)
{
if (!workingImage->GetLabel(targetValue)->GetLocked())
{
outputIterator.Set(overwritevalue);
}
}
if (targetValue == overwritevalue)
{
outputIterator.Set(inputIterator.Get());
}
++outputIterator;
++inputIterator;
}
}
else // if we are erasing
{
while (!outputIterator.IsAtEnd())
{
const int targetValue = outputIterator.Get();
if (inputIterator.Get() != 0)
{
if (targetValue == activePixelValue)
outputIterator.Set(overwritevalue);
}
++outputIterator;
++inputIterator;
}
}
}
void mitk::SegTool2D::WritePreviewOnWorkingImage(
Image *targetSlice, Image *sourceSlice, mitk::Image *workingImage, int paintingPixelValue, int timestep)
{
if ((!targetSlice) || (!sourceSlice))
return;
AccessFixedDimensionByItk_3(
targetSlice, InternalWritePreviewOnWorkingImage, 2, sourceSlice, workingImage, paintingPixelValue);
}
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.h b/Modules/Segmentation/Interactions/mitkSegTool2D.h
index 48219adff2..b9b20cddae 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.h
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.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 mitkSegTool2D_h_Included
#define mitkSegTool2D_h_Included
#include "mitkCommon.h"
#include "mitkImage.h"
#include "mitkTool.h"
#include <MitkSegmentationExports.h>
#include "mitkInteractionPositionEvent.h"
#include "mitkInteractionConst.h"
#include "mitkPlanePositionManager.h"
#include "mitkRestorePlanePositionOperation.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 MITKSEGMENTATION_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);
/**
* @brief Updates the surface interpolation by extracting the contour form the given slice.
* @param slice the slice from which the contour should be extracted
* @param workingImage the segmentation image
* @param plane the plane in which the slice lies
* @param detectIntersection if true the slice is eroded before contour extraction. If the slice is empty after the
* erosion it is most
* likely an intersecting contour an will not be added to the SurfaceInterpolationController
*/
static void UpdateSurfaceInterpolation(const Image *slice,
const Image *workingImage,
const PlaneGeometry *plane,
bool detectIntersection);
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();
struct SliceInformation
{
mitk::Image::Pointer slice;
mitk::PlaneGeometry *plane;
unsigned int timestep;
SliceInformation() {}
SliceInformation(mitk::Image *slice, mitk::PlaneGeometry *plane, unsigned int timestep)
{
this->slice = slice;
this->plane = plane;
this->timestep = timestep;
}
};
/**
* \brief Filters events that cannot be handle by 2D segmentation tools
*
* Current an event is discarded if it was not sent by a 2D renderwindow and if it is
* not of type InteractionPositionEvent
*/
virtual bool FilterEvents(InteractionEvent *interactionEvent, DataNode *dataNode) override;
/**
- \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.
+ * \brief Extract the slice of an image that the user just scribbles on. The given component denotes the vector component of a dwi-image.
+ *
+ * \param component The component to be extracted of a given multi-component image. -1 is the default parameter to denote an invalid component.
+ *
+ * \return 'nullptr' 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 InteractionPositionEvent *, const Image *image);
+ Image::Pointer GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent, const Image *image, unsigned int component = 0);
/**
- \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.
+ * \brief Extract the slice of an image cut by given plane. The given component denotes the vector component of a dwi-image.
+ *
+ * \param component The component to be extracted of a given multi-component image. -1 is the default parameter to denote an invalid component.
+ *
+ * \return 'nullptr' 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);
+ unsigned int timeStep,
+ unsigned int component = 0);
/**
\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 InteractionPositionEvent *);
/**
\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 InteractionPositionEvent *);
void WriteBackSegmentationResult(const InteractionPositionEvent *, Image *);
void WriteBackSegmentationResult(const PlaneGeometry *planeGeometry, Image *, unsigned int timeStep);
void WriteBackSegmentationResult(std::vector<SliceInformation> sliceList, bool writeSliceToVolume = true);
void WritePreviewOnWorkingImage(
Image *targetSlice, Image *sourceSlice, Image *workingImage, int paintingPixelValue, int timestep);
void WriteSliceToVolume(SliceInformation sliceInfo);
/**
\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
*/
int AddContourmarker();
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;
static bool m_SurfaceInterpolationEnabled;
};
} // namespace
#endif
diff --git a/Plugins/PluginList.cmake b/Plugins/PluginList.cmake
index 4cdec681c8..c2701b02e4 100644
--- a/Plugins/PluginList.cmake
+++ b/Plugins/PluginList.cmake
@@ -1,85 +1,85 @@
# Plug-ins must be ordered according to their dependencies
set(MITK_PLUGINS
org.blueberry.core.runtime:ON
org.blueberry.core.expressions:OFF
org.blueberry.core.commands:OFF
org.blueberry.core.jobs:OFF
org.blueberry.ui.qt:OFF
- org.blueberry.ui.qt.help:OFF
+ org.blueberry.ui.qt.help:ON
org.blueberry.ui.qt.log:ON
org.blueberry.ui.qt.objectinspector:OFF
#org.blueberry.test:ON
#org.blueberry.uitest:ON
#Testing/org.blueberry.core.runtime.tests:ON
#Testing/org.blueberry.osgi.tests:ON
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:ON
org.mitk.gui.qt.basicimageprocessing:OFF
org.mitk.gui.qt.dicom:OFF
org.mitk.gui.qt.dicominspector:OFF
org.mitk.gui.qt.diffusionimaging:OFF
org.mitk.gui.qt.dosevisualization:OFF
org.mitk.gui.qt.geometrytools:OFF
org.mitk.gui.qt.igtexamples:OFF
org.mitk.gui.qt.igttracking:OFF
org.mitk.gui.qt.openigtlink:OFF
org.mitk.gui.qt.imagecropper:OFF
org.mitk.gui.qt.imagenavigator:ON
org.mitk.gui.qt.viewnavigator:OFF
org.mitk.gui.qt.materialeditor:OFF
org.mitk.gui.qt.measurementtoolbox:OFF
org.mitk.gui.qt.moviemaker:OFF
org.mitk.gui.qt.pointsetinteraction:OFF
org.mitk.gui.qt.pointsetinteractionmultispectrum:OFF
org.mitk.gui.qt.python:OFF
org.mitk.gui.qt.registration:OFF
org.mitk.gui.qt.remeshing:OFF
org.mitk.gui.qt.segmentation:OFF
org.mitk.gui.qt.simulation:OFF
org.mitk.gui.qt.aicpregistration:OFF
org.mitk.gui.qt.toftutorial:OFF
org.mitk.gui.qt.tofutil:OFF
org.mitk.gui.qt.tubegraph:OFF
org.mitk.gui.qt.ugvisualization:OFF
org.mitk.gui.qt.ultrasound:OFF
org.mitk.gui.qt.volumevisualization:OFF
org.mitk.gui.qt.eventrecorder:OFF
org.mitk.gui.qt.xnat:OFF
org.mitk.gui.qt.igt.app.echotrack:OFF
org.mitk.gui.qt.spectrocamrecorder:OFF
org.mitk.gui.qt.classificationsegmentation:OFF
org.mitk.gui.qt.overlaymanager:OFF
org.mitk.gui.qt.multilabelsegmentation:ON
org.mitk.matchpoint.core.helper:OFF
org.mitk.gui.qt.matchpoint.algorithm.browser:OFF
org.mitk.gui.qt.matchpoint.algorithm.control:OFF
org.mitk.gui.qt.matchpoint.algorithm.batch:OFF
org.mitk.gui.qt.matchpoint.mapper:OFF
org.mitk.gui.qt.matchpoint.framereg:OFF
org.mitk.gui.qt.matchpoint.visualizer:OFF
org.mitk.gui.qt.matchpoint.evaluator:OFF
org.mitk.gui.qt.matchpoint.manipulator:OFF
)
diff --git a/Plugins/org.blueberry.core.runtime/CMakeLists.txt b/Plugins/org.blueberry.core.runtime/CMakeLists.txt
index abe6673902..91029832dc 100644
--- a/Plugins/org.blueberry.core.runtime/CMakeLists.txt
+++ b/Plugins/org.blueberry.core.runtime/CMakeLists.txt
@@ -1,21 +1,21 @@
project(org_blueberry_core_runtime)
set(QT_USE_QTXML 1)
mitk_create_plugin(EXPORT_DIRECTIVE org_blueberry_core_runtime_EXPORT
EXPORTED_INCLUDE_SUFFIXES src
src/application
src/dynamichelpers
src/registry
MODULE_DEPENDS PUBLIC mbilog
)
target_link_libraries(${PLUGIN_TARGET} PUBLIC Poco::Foundation Poco::Util Poco::XML)
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
target_link_libraries(${PLUGIN_TARGET} PRIVATE Qt5::Gui Qt5::Xml)
endif()
# Set compiler flags
target_compile_definitions(${PLUGIN_TARGET} PUBLIC "$<$<PLATFORM_ID:Windows>:POCO_NO_UNWINDOWS;WIN32_LEAN_AND_MEAN>")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/berryConfig.h.in" "${CMAKE_CURRENT_BINARY_DIR}/berryConfig.h" @ONLY)
diff --git a/Plugins/org.blueberry.ui.qt.help/CMakeLists.txt b/Plugins/org.blueberry.ui.qt.help/CMakeLists.txt
index 901191428c..fe6f5509bc 100644
--- a/Plugins/org.blueberry.ui.qt.help/CMakeLists.txt
+++ b/Plugins/org.blueberry.ui.qt.help/CMakeLists.txt
@@ -1,13 +1,13 @@
-if(MITK_USE_QT_WEBENGINE)
+if(MITK_USE_Qt5_WebEngine)
project(org_blueberry_ui_qt_help)
set(QT_USE_QTHELP 1)
set(QT_USE_QTWEBENGINE 1)
set(QT_USE_QTNETWORK 1)
mitk_create_plugin(
EXPORT_DIRECTIVE org_blueberry_ui_qt_help_EXPORT
EXPORTED_INCLUDE_SUFFIXES src
PACKAGE_DEPENDS PRIVATE Qt5|Help+OpenGL+PrintSupport+WebEngineWidgets+Xml
)
endif()
diff --git a/Plugins/org.blueberry.ui.qt/CMakeLists.txt b/Plugins/org.blueberry.ui.qt/CMakeLists.txt
index e21bf58e01..9995035799 100644
--- a/Plugins/org.blueberry.ui.qt/CMakeLists.txt
+++ b/Plugins/org.blueberry.ui.qt/CMakeLists.txt
@@ -1,24 +1,24 @@
project(org_blueberry_ui_qt)
set(PLUGIN_exported_include_suffixes
src
src/actions
src/application
src/commands
src/guitk
src/handlers
src/intro
src/model
src/presentations
src/services
src/testing
src/tweaklets
src/util
)
mitk_create_plugin(EXPORT_DIRECTIVE BERRY_UI_QT
EXPORTED_INCLUDE_SUFFIXES ${PLUGIN_exported_include_suffixes})
-if(MITK_USE_QT)
+if(MITK_USE_Qt5)
target_link_libraries(${PLUGIN_TARGET} PUBLIC Qt5::Widgets)
endif()
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
index 531251a669..7c2e977513 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
@@ -1,1035 +1,1135 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; 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"
//# Own Includes
//## mitk
#include "mitkDataStorageEditorInput.h"
#include "mitkIDataStorageReference.h"
#include "mitkNodePredicateDataType.h"
#include "mitkCoreObjectFactory.h"
#include "mitkColorProperty.h"
#include "mitkCommon.h"
#include "mitkNodePredicateData.h"
#include "mitkNodePredicateNot.h"
#include "mitkNodePredicateOr.h"
#include "mitkNodePredicateProperty.h"
#include "mitkEnumerationProperty.h"
#include "mitkLookupTableProperty.h"
#include "mitkProperties.h"
#include <mitkNodePredicateAnd.h>
#include <mitkITKImageImport.h>
#include <mitkIDataStorageService.h>
#include <mitkIRenderingManager.h>
#include <mitkImageCast.h>
//## Qmitk
#include <QmitkDnDFrameWidget.h>
#include <QmitkIOUtil.h>
#include <QmitkDataStorageTreeModel.h>
#include <QmitkCustomVariants.h>
#include <QmitkFileSaveAction.h>
#include <QmitkDataStorageFilterProxyModel.h>
#include <QmitkNumberPropertySlider.h>
#include "src/internal/QmitkNodeTableViewKeyFilter.h"
#include "src/internal/QmitkInfoDialog.h"
#include "src/internal/QmitkDataManagerItemDelegate.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 <QFileDialog>
#include <QMessageBox>
#include <QToolBar>
#include <QKeyEvent>
#include <QColor>
#include <QColorDialog>
#include <QSizePolicy>
#include <QSortFilterProxyModel>
#include <QSignalMapper>
#include "mitkDataNodeObject.h"
#include "mitkIContextMenuAction.h"
#include "berryIExtensionRegistry.h"
#include "mitkRenderingModeProperty.h"
const QString QmitkDataManagerView::VIEW_ID = "org.mitk.views.datamanager";
QmitkDataManagerView::QmitkDataManagerView()
: m_GlobalReinitOnNodeDelete(true),
m_ItemDelegate(NULL)
{
}
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* prefService = berry::Platform::GetPreferencesService();
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->SetAllowHierarchyChange(
prefs->GetBool("Allow changing of parent node", false));
m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
// Prepare filters
m_HelperObjectFilterPredicate = mitk::NodePredicateOr::New(
mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)),
mitk::NodePredicateProperty::New("hidden object", mitk::BoolProperty::New(true)));
m_NodeWithNoDataFilterPredicate = mitk::NodePredicateData::New(0);
m_FilterModel = new QmitkDataStorageFilterProxyModel();
m_FilterModel->setSourceModel(m_NodeTreeModel);
m_FilterModel->AddFilterPredicate(m_HelperObjectFilterPredicate);
m_FilterModel->AddFilterPredicate(m_NodeWithNoDataFilterPredicate);
//# Tree View (experimental)
m_NodeTreeView = new QTreeView;
m_NodeTreeView->setHeaderHidden(true);
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_FilterModel);
m_NodeTreeView->setTextElideMode(Qt::ElideMiddle);
m_NodeTreeView->installEventFilter(new QmitkNodeTableViewKeyFilter(this));
m_ItemDelegate = new QmitkDataManagerItemDelegate(m_NodeTreeView);
m_NodeTreeView->setItemDelegate(m_ItemDelegate);
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();
QList<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(descriptor->GetLabel(), this);
m_ShowInActions << action;
m_ShowInMapper->connect(action, SIGNAL(triggered()), m_ShowInMapper, SLOT(map()));
m_ShowInMapper->setMapping(action, descriptor->GetId());
}
connect(m_ShowInMapper, SIGNAL(mapped(QString)), this, SLOT(ShowIn(QString)));
}
auto unknownDataNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetUnknownDataNodeDescriptor();
auto imageDataNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Image");
auto multiComponentImageDataNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("MultiComponentImage");
auto diffusionImageDataNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("DiffusionImage");
auto surfaceDataNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Surface");
auto labelSetImageDataNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("LabelSetImage");
auto pointSetNodeDescriptor =
QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PointSet");
+ auto planarLineNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarLine");
+ auto planarCircleNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarCircle");
+ auto planarEllipseNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarEllipse");
+ auto planarAngleNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarAngle");
+ auto planarFourPointAngleNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarFourPointAngle");
+ auto planarRectangleNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarRectangle");
+ auto planarPolygonNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarPolygon");
+ auto planarPathNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarPath");
+ auto planarDoubleEllipseNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarDoubleEllipse");
+ auto planarBezierCurveNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarBezierCurve");
+ auto planarSubdivisionPolygonNodeDescriptor =
+ QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarSubdivisionPolygon");
+
QAction* globalReinitAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"), tr("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 QmitkFileSaveAction(QIcon(":/org.mitk.gui.qt.datamanager/Save_48.png"),
this->GetSite()->GetWorkbenchWindow());
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"), tr("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"), tr("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::IExtensionRegistry* extensionPointService = berry::Platform::GetExtensionRegistry();
QList<berry::IConfigurationElement::Pointer> cmActions(
extensionPointService->GetConfigurationElementsFor("org.mitk.gui.qt.datamanager.contextMenuActions") );
QList<berry::IConfigurationElement::Pointer>::iterator cmActionsIt;
QmitkNodeDescriptor* tmpDescriptor;
QAction* contextMenuAction;
QVariant cmActionDataIt;
m_ConfElements.clear();
int i=1;
for (cmActionsIt = cmActions.begin()
; cmActionsIt != cmActions.end()
; ++cmActionsIt)
{
QString cmNodeDescriptorName = (*cmActionsIt)->GetAttribute("nodeDescriptorName");
QString cmLabel = (*cmActionsIt)->GetAttribute("label");
QString cmClass = (*cmActionsIt)->GetAttribute("class");
if(!cmNodeDescriptorName.isEmpty() &&
!cmLabel.isEmpty() &&
!cmClass.isEmpty())
{
QString cmIcon = (*cmActionsIt)->GetAttribute("icon");
// create context menu entry here
tmpDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(cmNodeDescriptorName);
if(!tmpDescriptor)
{
MITK_WARN << "cannot add action \"" << cmLabel << "\" because descriptor " << cmNodeDescriptorName << " does not exist";
continue;
}
// check if the user specified an icon attribute
if ( !cmIcon.isEmpty() )
{
contextMenuAction = new QAction( QIcon(cmIcon), cmLabel, parent);
}
else
{
contextMenuAction = new QAction( 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(tr("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(tr("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() ) );
{ // only give the color context menu option where appropriate
if (imageDataNodeDescriptor != NULL)
{
imageDataNodeDescriptor->AddAction(colorAction, false);
m_DescriptorActionList.push_back(
std::pair<QmitkNodeDescriptor *, QAction *>(imageDataNodeDescriptor, colorAction));
}
if (multiComponentImageDataNodeDescriptor != NULL)
{
multiComponentImageDataNodeDescriptor->AddAction(colorAction, false);
m_DescriptorActionList.push_back(
std::pair<QmitkNodeDescriptor *, QAction *>(multiComponentImageDataNodeDescriptor, colorAction));
}
if (diffusionImageDataNodeDescriptor != NULL)
{
diffusionImageDataNodeDescriptor->AddAction(colorAction, false);
m_DescriptorActionList.push_back(
std::pair<QmitkNodeDescriptor *, QAction *>(diffusionImageDataNodeDescriptor, colorAction));
}
if (surfaceDataNodeDescriptor != NULL)
{
surfaceDataNodeDescriptor->AddAction(colorAction, false);
m_DescriptorActionList.push_back(
std::pair<QmitkNodeDescriptor *, QAction *>(surfaceDataNodeDescriptor, colorAction));
}
if (pointSetNodeDescriptor != NULL)
{
pointSetNodeDescriptor->AddAction(colorAction, false);
m_DescriptorActionList.push_back(
std::pair<QmitkNodeDescriptor *, QAction *>(pointSetNodeDescriptor, colorAction));
}
+
+ if (planarLineNodeDescriptor != NULL)
+ {
+ planarLineNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarLineNodeDescriptor, colorAction));
+ }
+
+ if (planarCircleNodeDescriptor != NULL)
+ {
+ planarCircleNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarCircleNodeDescriptor, colorAction));
+ }
+
+ if (planarEllipseNodeDescriptor != NULL)
+ {
+ planarEllipseNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarEllipseNodeDescriptor, colorAction));
+ }
+
+ if (planarAngleNodeDescriptor != NULL)
+ {
+ planarAngleNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarAngleNodeDescriptor, colorAction));
+ }
+
+ if (planarFourPointAngleNodeDescriptor != NULL)
+ {
+ planarFourPointAngleNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarFourPointAngleNodeDescriptor, colorAction));
+ }
+
+ if (planarRectangleNodeDescriptor != NULL)
+ {
+ planarRectangleNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarRectangleNodeDescriptor, colorAction));
+ }
+
+ if (planarPolygonNodeDescriptor != NULL)
+ {
+ planarPolygonNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarPolygonNodeDescriptor, colorAction));
+ }
+
+ if (planarPathNodeDescriptor != NULL)
+ {
+ planarPathNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarPathNodeDescriptor, colorAction));
+ }
+
+ if (planarDoubleEllipseNodeDescriptor != NULL)
+ {
+ planarDoubleEllipseNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarDoubleEllipseNodeDescriptor, colorAction));
+ }
+
+ if (planarBezierCurveNodeDescriptor != NULL)
+ {
+ planarBezierCurveNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarBezierCurveNodeDescriptor, colorAction));
+ }
+
+ if (planarSubdivisionPolygonNodeDescriptor != NULL)
+ {
+ planarSubdivisionPolygonNodeDescriptor->AddAction(colorAction, false);
+ m_DescriptorActionList.push_back(
+ std::pair<QmitkNodeDescriptor *, QAction *>(planarSubdivisionPolygonNodeDescriptor, colorAction));
+ }
}
m_ComponentSlider = new QmitkNumberPropertySlider;
m_ComponentSlider->setOrientation(Qt::Horizontal);
//QObject::connect( m_OpacitySlider, SIGNAL( valueChanged(int) )
// , this, SLOT( OpacityChanged(int) ) );
QLabel* _ComponentLabel = new QLabel(tr("Component: "));
QHBoxLayout* _ComponentWidgetLayout = new QHBoxLayout;
_ComponentWidgetLayout->setContentsMargins(4,4,4,4);
_ComponentWidgetLayout->addWidget(_ComponentLabel);
_ComponentWidgetLayout->addWidget(m_ComponentSlider);
QLabel* _ComponentValueLabel = new QLabel();
_ComponentWidgetLayout->addWidget(_ComponentValueLabel);
connect(m_ComponentSlider, SIGNAL(valueChanged(int)), _ComponentValueLabel, SLOT(setNum(int)));
QWidget* _ComponentWidget = new QWidget;
_ComponentWidget->setLayout(_ComponentWidgetLayout);
QWidgetAction* componentAction = new QWidgetAction(this);
componentAction->setDefaultWidget(_ComponentWidget);
QObject::connect( componentAction , SIGNAL( changed() )
, this, SLOT( ComponentActionChanged() ) );
multiComponentImageDataNodeDescriptor->AddAction(componentAction, false);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(multiComponentImageDataNodeDescriptor,componentAction));
if (diffusionImageDataNodeDescriptor!=NULL)
{
diffusionImageDataNodeDescriptor->AddAction(componentAction, false);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(diffusionImageDataNodeDescriptor,componentAction));
}
m_TextureInterpolation = new QAction(tr("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));
if (diffusionImageDataNodeDescriptor!=NULL)
{
diffusionImageDataNodeDescriptor->AddAction(m_TextureInterpolation, false);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(diffusionImageDataNodeDescriptor,m_TextureInterpolation));
}
m_ColormapAction = new QAction(tr("Colormap"), this);
m_ColormapAction->setMenu(new QMenu);
QObject::connect( m_ColormapAction->menu(), SIGNAL( aboutToShow() )
, this, SLOT( ColormapMenuAboutToShow() ) );
imageDataNodeDescriptor->AddAction(m_ColormapAction, false);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(imageDataNodeDescriptor, m_ColormapAction));
if (diffusionImageDataNodeDescriptor!=NULL)
{
diffusionImageDataNodeDescriptor->AddAction(m_ColormapAction, false);
m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(diffusionImageDataNodeDescriptor, m_ColormapAction));
}
m_SurfaceRepresentation = new QAction(tr("Surface Representation"), this);
m_SurfaceRepresentation->setMenu(new QMenu(m_NodeTreeView));
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")
, tr("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")
, tr("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")
, tr("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));
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");
QString className = confElem->GetAttribute("class");
QString smoothed = confElem->GetAttribute("smoothed");
contextMenuAction->SetDataStorage(this->GetDataStorage());
if(className == "QmitkCreatePolygonModelAction")
{
if(smoothed == "false")
{
contextMenuAction->SetSmoothed(false);
}
else
{
contextMenuAction->SetSmoothed(true);
}
contextMenuAction->SetDecimated(m_SurfaceDecimation);
}
else if(className == "QmitkStatisticsAction")
{
contextMenuAction->SetFunctionality(this);
}
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() );
bool hideHelperObjects = !prefs->GetBool("Show helper objects", false);
if (m_FilterModel->HasFilterPredicate(m_HelperObjectFilterPredicate) != hideHelperObjects)
{
if (hideHelperObjects)
{
m_FilterModel->AddFilterPredicate(m_HelperObjectFilterPredicate);
}
else
{
m_FilterModel->RemoveFilterPredicate(m_HelperObjectFilterPredicate);
}
}
bool hideNodesWithNoData = !prefs->GetBool("Show nodes containing no data", false);
if (m_FilterModel->HasFilterPredicate(m_NodeWithNoDataFilterPredicate) != hideNodesWithNoData)
{
if (hideNodesWithNoData)
{
m_FilterModel->AddFilterPredicate(m_NodeWithNoDataFilterPredicate);
}
else
{
m_FilterModel->RemoveFilterPredicate(m_NodeWithNoDataFilterPredicate);
}
}
m_GlobalReinitOnNodeDelete = prefs->GetBool("Call global reinit if node is deleted", true);
m_NodeTreeView->expandAll();
m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
m_NodeTreeModel->SetAllowHierarchyChange(
prefs->GetBool("Allow changing of parent node", false));
this->GlobalReinit();
}
void QmitkDataManagerView::NodeTableViewContextMenuRequested( const QPoint & pos )
{
QModelIndex selectedProxy = m_NodeTreeView->indexAt ( pos );
QModelIndex selected = m_FilterModel->mapToSource(selectedProxy);
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(tr("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_FilterModel->mapToSource(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_FilterModel->mapToSource(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::ComponentActionChanged()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
mitk::IntProperty* componentProperty = NULL;
int numComponents = 0;
if(node)
{
componentProperty =
dynamic_cast<mitk::IntProperty*>(node->GetProperty("Image.Displayed Component"));
mitk::Image* img = dynamic_cast<mitk::Image*>(node->GetData());
if (img != NULL)
{
numComponents = img->GetPixelType().GetNumberOfComponents();
}
}
if (componentProperty && numComponents > 1)
{
m_ComponentSlider->SetProperty(componentProperty);
m_ComponentSlider->setMinValue(0);
m_ComponentSlider->setMaxValue(numComponents-1);
}
else
{
m_ComponentSlider->SetProperty(static_cast<mitk::IntProperty*>(NULL));
}
}
void QmitkDataManagerView::ColorChanged()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
if(node)
{
mitk::Color color;
mitk::ColorProperty::Pointer colorProp;
node->GetProperty(colorProp,"color");
if(colorProp.IsNull())
return;
color = colorProp->GetValue();
QColor initial(color.GetRed()*255,color.GetGreen()*255,color.GetBlue()*255);
QColor qcolor = QColorDialog::getColor(initial,0,QString(tr("Change color")));
if (!qcolor.isValid())
return;
m_ColorButton->setAutoFillBackground(true);
node->SetProperty("color",mitk::ColorProperty::New(qcolor.red()/255.0,qcolor.green()/255.0,qcolor.blue()/255.0));
if (node->GetProperty("binaryimage.selectedcolor"))
{
node->SetProperty("binaryimage.selectedcolor",mitk::ColorProperty::New(qcolor.red()/255.0,qcolor.green()/255.0,qcolor.blue()/255.0));
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkDataManagerView::ColorActionChanged()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(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_FilterModel->mapToSource(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_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
if(node)
{
node->SetBoolProperty("texture interpolation", checked);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkDataManagerView::ColormapActionToggled( bool /*checked*/ )
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
if(!node)
return;
mitk::LookupTableProperty::Pointer lookupTableProperty =
dynamic_cast<mitk::LookupTableProperty*>(node->GetProperty("LookupTable"));
if (!lookupTableProperty)
return;
QAction* senderAction = qobject_cast<QAction*>(QObject::sender());
if(!senderAction)
return;
std::string activatedItem = senderAction->text().toStdString();
mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue();
if (!lookupTable)
return;
lookupTable->SetType(activatedItem);
lookupTableProperty->SetValue(lookupTable);
mitk::RenderingModeProperty::Pointer renderingMode =
dynamic_cast<mitk::RenderingModeProperty*>(node->GetProperty("Image Rendering.Mode"));
renderingMode->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkDataManagerView::ColormapMenuAboutToShow()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
if(!node)
return;
mitk::LookupTableProperty::Pointer lookupTableProperty =
dynamic_cast<mitk::LookupTableProperty*>(node->GetProperty("LookupTable"));
if (!lookupTableProperty)
{
mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
lookupTableProperty = mitk::LookupTableProperty::New();
lookupTableProperty->SetLookupTable(mitkLut);
node->SetProperty("LookupTable", lookupTableProperty);
}
mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue();
if (!lookupTable)
return;
m_ColormapAction->menu()->clear();
QAction* tmp;
int i = 0;
std::string lutType = lookupTable->typenameList[i];
while (lutType != "END_OF_ARRAY")
{
tmp = m_ColormapAction->menu()->addAction(QString::fromStdString(lutType));
tmp->setCheckable(true);
if (lutType == lookupTable->GetActiveTypeAsString())
{
tmp->setChecked(true);
}
QObject::connect(tmp, SIGNAL(triggered(bool)), this, SLOT(ColormapActionToggled(bool)));
lutType = lookupTable->typenameList[++i];
}
}
void QmitkDataManagerView::SurfaceRepresentationMenuAboutToShow()
{
mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(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_FilterModel->mapToSource(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::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->GetTimeGeometry()->IsValid() )
{
renderWindow->GetRenderingManager()->InitializeViews(
basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
}
}
}
void QmitkDataManagerView::RemoveSelectedNodes( bool )
{
QModelIndexList indexesOfSelectedRowsFiltered = m_NodeTreeView->selectionModel()->selectedRows();
QModelIndexList indexesOfSelectedRows;
for (int i = 0; i < indexesOfSelectedRowsFiltered.size(); ++i)
{
indexesOfSelectedRows.push_back(m_FilterModel->mapToSource(indexesOfSelectedRowsFiltered[i]));
}
if(indexesOfSelectedRows.size() < 1)
{
return;
}
std::vector<mitk::DataNode::Pointer> selectedNodes;
mitk::DataNode::Pointer 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.IsNotNull() /*& strcmp(node->GetData()->GetNameOfClass(), "PlaneGeometryData") != 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(tr(" 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::Pointer>::iterator it = selectedNodes.begin()
; it != selectedNodes.end(); it++)
{
node = *it;
this->GetDataStorage()->Remove(node);
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();
}
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();
}
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::NodeChanged(const mitk::DataNode* /*node*/)
{
// m_FilterModel->invalidate();
// fix as proposed by R. Khlebnikov in the mitk-users mail from 02.09.2014
QMetaObject::invokeMethod( m_FilterModel, "invalidate", Qt::QueuedConnection );
}
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;
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
}
void QmitkDataManagerView::NodeTreeViewRowsRemoved (
const QModelIndex & /*parent*/, int /*start*/, int /*end*/ )
{
m_CurrentRowCount = m_NodeTreeModel->rowCount();
}
void QmitkDataManagerView::NodeTreeViewRowsInserted( const QModelIndex & parent, int, int )
{
QModelIndex viewIndex = m_FilterModel->mapFromSource(parent);
m_NodeTreeView->setExpanded(viewIndex, true);
// a new row was inserted
if( m_CurrentRowCount == 0 && m_NodeTreeModel->rowCount() == 1 )
{
this->OpenRenderWindowPart();
m_CurrentRowCount = m_NodeTreeModel->rowCount();
}
}
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, 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.diffusionimagingapp/CMakeLists.txt b/Plugins/org.mitk.gui.qt.diffusionimagingapp/CMakeLists.txt
index 4a74dc7711..f16503475c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimagingapp/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.diffusionimagingapp/CMakeLists.txt
@@ -1,12 +1,12 @@
-if(MITK_USE_QT_WEBENGINE)
+if(MITK_USE_Qt5_WebEngine)
# The project name must correspond to the directory name of your plug-in
# and must not contain periods.
project(org_mitk_gui_qt_diffusionimagingapp)
mitk_create_plugin(
EXPORT_DIRECTIVE DIFFUSIONIMAGING_APP_EXPORT
EXPORTED_INCLUDE_SUFFIXES src
MODULE_DEPENDS MitkQtWidgets MitkSceneSerialization
PACKAGE_DEPENDS Qt5|WebEngineWidgets
)
endif()
diff --git a/Plugins/org.mitk.gui.qt.extapplication/CMakeLists.txt b/Plugins/org.mitk.gui.qt.extapplication/CMakeLists.txt
index bacce2a1ca..fb70a1581d 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.extapplication/CMakeLists.txt
@@ -1,17 +1,17 @@
project(org_mitk_gui_qt_extapplication)
set (package_depends "")
-if(MITK_USE_QT_WEBENGINE)
+if(MITK_USE_Qt5_WebEngine)
set(package_depends Qt5|WebEngineWidgets)
endif()
mitk_create_plugin(
EXPORT_DIRECTIVE MITK_QT_EXTAPP
EXPORTED_INCLUDE_SUFFIXES src
PACKAGE_DEPENDS ${package_depends}
)
-if(MITK_USE_QT_WEBENGINE)
- target_compile_definitions(${PLUGIN_TARGET} PRIVATE -DMITK_USE_QT_WEBENGINE)
+if(MITK_USE_Qt5_WebEngine)
+ target_compile_definitions(${PLUGIN_TARGET} PRIVATE -DMITK_USE_Qt5_WebEngine)
endif()
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.cpp b/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.cpp
index a9cd5195cc..566af5834c 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.cpp
+++ b/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.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 "QmitkMitkWorkbenchIntroPart.h"
#include <berryIWorkbenchWindow.h>
#include <berryIWorkbench.h>
#include <berryIWorkbenchPage.h>
#include <berryIPerspectiveRegistry.h>
#include <berryWorkbenchPreferenceConstants.h>
#include <berryIPreferences.h>
#include <berryIPreferencesService.h>
#include <berryPlatform.h>
#include <berryIEditorReference.h>
#include <berryIEditorInput.h>
#include <ctkPluginContext.h>
#include <mitkIDataStorageService.h>
#include <mitkDataStorageEditorInput.h>
#include <mitkLogMacros.h>
#include <QLabel>
#include <QMessageBox>
#include <QtCore/qconfig.h>
#include <QString>
#include <QStringList>
#include <QRegExp>
#include <QChar>
#include <QByteArray>
#include <QDesktopServices>
#include "QmitkExtApplicationPlugin.h"
#include "mitkDataStorageEditorInput.h"
#include <string>
-#ifdef MITK_USE_QT_WEBENGINE
+#ifdef MITK_USE_Qt5_WebEngine
#include <QWebEngineView>
#include <QWebEnginePage>
#include <QUrlQuery>
#endif
class QmitkMitkWorkbenchIntroPart::Impl
{
public:
Impl()
-#ifdef MITK_USE_QT_WEBENGINE
+#ifdef MITK_USE_Qt5_WebEngine
: View(nullptr)
#endif
{
}
~Impl()
{
}
-#ifdef MITK_USE_QT_WEBENGINE
+#ifdef MITK_USE_Qt5_WebEngine
QWebEngineView* View;
#endif
private:
Impl(const Impl&);
Impl& operator=(const Impl&);
};
-#ifdef MITK_USE_QT_WEBENGINE
+#ifdef MITK_USE_Qt5_WebEngine
namespace
{
class QmitkWebEnginePage final : public QWebEnginePage
{
public:
explicit QmitkWebEnginePage(QmitkMitkWorkbenchIntroPart* introPart, QObject* parent = nullptr);
~QmitkWebEnginePage();
private:
bool acceptNavigationRequest(const QUrl& url, NavigationType type, bool isMainFrame) override;
QmitkMitkWorkbenchIntroPart* m_IntroPart;
};
QmitkWebEnginePage::QmitkWebEnginePage(QmitkMitkWorkbenchIntroPart* introPart, QObject* parent)
: QWebEnginePage(parent),
m_IntroPart(introPart)
{
}
QmitkWebEnginePage::~QmitkWebEnginePage()
{
}
bool QmitkWebEnginePage::acceptNavigationRequest(const QUrl& url, NavigationType, bool)
{
QString scheme = url.scheme();
if (scheme.contains("mitk"))
{
if (url.path().isEmpty())
return false;
if (url.host().contains("perspectives"))
{
QString id = url.path().simplified().replace("/", "");
auto introSite = m_IntroPart->GetIntroSite();
auto workbenchWindow = introSite->GetWorkbenchWindow();
auto workbench = workbenchWindow->GetWorkbench();
workbench->ShowPerspective(id, workbenchWindow);
auto context = QmitkExtApplicationPlugin::GetDefault()->GetPluginContext();
auto serviceReference = context->getServiceReference<mitk::IDataStorageService>();
mitk::IDataStorageService* service = serviceReference
? context->getService<mitk::IDataStorageService>(serviceReference)
: nullptr;
if (service)
{
berry::IEditorInput::Pointer editorInput(new mitk::DataStorageEditorInput(service->GetActiveDataStorage()));
auto page = introSite->GetPage();
auto editorPart = page->FindEditor(editorInput);
if (editorPart.IsNotNull())
page->Activate(editorPart);
}
}
}
else if (scheme.contains("http"))
{
QDesktopServices::openUrl(url);
}
else
{
return true;
}
return false;
}
}
#endif
QmitkMitkWorkbenchIntroPart::QmitkMitkWorkbenchIntroPart()
: m_Controls(nullptr),
m_Impl(new Impl)
{
berry::IPreferences::Pointer workbenchPrefs = QmitkExtApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
-#ifdef MITK_USE_QT_WEBENGINE
+#ifdef MITK_USE_Qt5_WebEngine
workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
#else
workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, false);
#endif
workbenchPrefs->Flush();
}
QmitkMitkWorkbenchIntroPart::~QmitkMitkWorkbenchIntroPart()
{
// if the workbench is not closing (that means, welcome screen was closed explicitly), set "Show_intro" false
if (!this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
{
berry::IPreferences::Pointer workbenchPrefs = QmitkExtApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, false);
workbenchPrefs->Flush();
}
else
{
berry::IPreferences::Pointer workbenchPrefs = QmitkExtApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
-#ifdef MITK_USE_QT_WEBENGINE
+#ifdef MITK_USE_Qt5_WebEngine
workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
#else
workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, false);
#endif
workbenchPrefs->Flush();
}
// if workbench is not closing (Just welcome screen closing), open last used perspective
if (this->GetIntroSite()->GetPage()->GetPerspective()->GetId()
== "org.mitk.mitkworkbench.perspectives.editor" && !this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
{
berry::IPerspectiveDescriptor::Pointer perspective = this->GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->GetPerspectiveRegistry()->FindPerspectiveWithId("org.mitk.mitkworkbench.perspectives.editor");
if (perspective)
{
this->GetIntroSite()->GetPage()->SetPerspective(perspective);
}
}
delete m_Impl;
}
void QmitkMitkWorkbenchIntroPart::CreateQtPartControl(QWidget* parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkWelcomeScreenViewControls;
m_Controls->setupUi(parent);
-#ifdef MITK_USE_QT_WEBENGINE
+#ifdef MITK_USE_Qt5_WebEngine
// create a QWebView as well as a QWebPage and QWebFrame within the QWebview
m_Impl->View = new QWebEngineView(parent);
auto page = new QmitkWebEnginePage(this, parent);
m_Impl->View->setPage(page);
QUrl urlQtResource(QString("qrc:/org.mitk.gui.qt.welcomescreen/mitkworkbenchwelcomeview.html"), QUrl::TolerantMode );
m_Impl->View->load( urlQtResource );
// adds the webview as a widget
parent->layout()->addWidget(m_Impl->View);
#endif
this->CreateConnections();
}
}
void QmitkMitkWorkbenchIntroPart::CreateConnections()
{
}
void QmitkMitkWorkbenchIntroPart::StandbyStateChanged(bool /*standby*/)
{
}
void QmitkMitkWorkbenchIntroPart::SetFocus()
{
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp
index 2afe6176cc..70ba385845 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp
@@ -1,36 +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.
===================================================================*/
#include "QmitkUSNavigationPerspective.h"
QmitkUSNavigationPerspective::QmitkUSNavigationPerspective()
{
}
void QmitkUSNavigationPerspective::CreateInitialLayout (berry::IPageLayout::Pointer layout)
{
// place navigation plugin on the right side (not closable)
- layout->AddStandaloneView("org.mitk.views.usmarkerplacement", false, berry::IPageLayout::RIGHT, 0.8f, layout->GetEditorArea());
+ layout->AddStandaloneView("org.mitk.views.usmarkerplacement", false, berry::IPageLayout::RIGHT, 0.75f, layout->GetEditorArea());
// place tracking toolbox and ultrasound support on the left into a folder
// layout (closeable)
+ layout->AddStandaloneView("org.mitk.views.ultrasoundsupport", false, berry::IPageLayout::LEFT, 0.3f, layout->GetEditorArea());
+ layout->AddStandaloneView("org.mitk.views.mitkigttrackingtoolbox", false, berry::IPageLayout::BOTTOM, 0.9f, "org.mitk.views.ultrasoundsupport");
+
+ /*
berry::IFolderLayout::Pointer leftFolder = layout->CreateFolder("left", berry::IPageLayout::LEFT, 0.3f, layout->GetEditorArea());
+ leftFolder->AddStandaloneView("org.mitk.views.ultrasoundsupport", false, berry::IPageLayout::LEFT, 0.8f, layout->GetEditorArea());
leftFolder->AddView("org.mitk.views.mitkigttrackingtoolbox");
leftFolder->AddView("org.mitk.views.ultrasoundsupport");
layout->GetViewLayout("org.mitk.views.mitkigttrackingtoolbox")->SetCloseable(false);
layout->GetViewLayout("org.mitk.views.ultrasoundsupport")->SetCloseable(false);
+ */
}
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 b7b6bf2b04..f0476ee894 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,1531 +1,1482 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY 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 "QmitkTrackingDeviceConfigurationWidget.h"
#include "QmitkStdMultiWidget.h"
// Qt
#include <QMessageBox>
#include <QSettings>
#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>
#include <mitkProgressBar.h>
#include <mitkIOUtil.h>
#include <mitkLog.h>
#include <usModule.h>
#include <mitkTrackingDeviceTypeCollection.h>
#include <mitkUnspecifiedTrackingTypeInformation.h>
#include "mitkNDIAuroraTypeInformation.h"
// vtk
#include <vtkSphereSource.h>
//for exceptions
#include <mitkIGTException.h>
#include <mitkIGTIOException.h>
//for Microservice
#include "mitkPluginActivator.h"
#include <usModuleContext.h>
#include <usGetModuleContext.h>
#include "usServiceReference.h"
const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
: QmitkFunctionality()
, m_Controls(nullptr)
, m_MultiWidget(nullptr)
, m_DeviceTypeCollection(nullptr)
{
m_TrackingLoggingTimer = new QTimer(this);
m_TrackingRenderTimer = new QTimer(this);
m_TimeoutTimer = new QTimer(this);
m_tracking = false;
m_connected = false;
m_logging = false;
m_loggedFrames = 0;
+ m_SimpleModeEnabled = false;
//create filename for autosaving of tool storage
QString loggingPathWithoutFilename = QString(mitk::LoggingBackend::GetLogFile().c_str());
if (!loggingPathWithoutFilename.isEmpty()) //if there already is a path for the MITK logging file use this one
{
//extract path from path+filename (if someone knows a better way to do this feel free to change it)
int lengthOfFilename = QFileInfo(QString::fromStdString(mitk::LoggingBackend::GetLogFile())).fileName().size();
loggingPathWithoutFilename.resize(loggingPathWithoutFilename.size() - lengthOfFilename);
m_AutoSaveFilename = loggingPathWithoutFilename + "TrackingToolboxAutoSave.IGTToolStorage";
}
else //if not: use a temporary path from IOUtil
{
m_AutoSaveFilename = QString(mitk::IOUtil::GetTempPath().c_str()) + "TrackingToolboxAutoSave.IGTToolStorage";
}
MITK_INFO("IGT Tracking Toolbox") << "Filename for auto saving of IGT ToolStorages: " << m_AutoSaveFilename.toStdString();
//! [Thread 1]
//initialize worker thread
m_WorkerThread = new QThread();
m_Worker = new QmitkMITKIGTTrackingToolboxViewWorker();
//! [Thread 1]
ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
if (pluginContext)
{
QString interfaceName = QString::fromStdString(us_service_interface_iid<mitk::TrackingDeviceTypeCollection>());
QList<ctkServiceReference> serviceReference = pluginContext->getServiceReferences(interfaceName);
if (serviceReference.size() > 0)
{
m_DeviceTypeServiceReference = serviceReference.at(0);
const ctkServiceReference& r = serviceReference.at(0);
m_DeviceTypeCollection = pluginContext->getService<mitk::TrackingDeviceTypeCollection>(r);
}
else
{
MITK_INFO << "No Tracking Device Collection!";
}
}
}
QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
{
this->StoreUISettings();
m_TrackingLoggingTimer->stop();
m_TrackingRenderTimer->stop();
m_TimeoutTimer->stop();
delete m_TrackingLoggingTimer;
delete m_TrackingRenderTimer;
delete m_TimeoutTimer;
try
{
//! [Thread 2]
// wait for thread to finish
m_WorkerThread->terminate();
m_WorkerThread->wait();
//clean up worker thread
if (m_WorkerThread) { delete m_WorkerThread; }
if (m_Worker) { delete m_Worker; }
//! [Thread 2]
//remove the tracking volume
this->GetDataStorage()->Remove(m_TrackingVolumeNode);
//unregister microservices
if (m_toolStorage) { m_toolStorage->UnRegisterMicroservice(); }
if (m_TrackingDeviceSource) { m_TrackingDeviceSource->UnRegisterMicroservice(); }
if (m_IGTLMessageProvider.IsNotNull()){ m_IGTLMessageProvider->UnRegisterMicroservice(); }
}
catch (std::exception& e) { MITK_WARN << "Unexpected exception during clean up of tracking toolbox view: " << e.what(); }
catch (...) { MITK_WARN << "Unexpected unknown error during clean up of tracking toolbox view!"; }
//store tool storage and UI settings for persistence
this->AutoSaveToolStorage();
this->StoreUISettings();
m_DeviceTypeCollection = nullptr;
mitk::PluginActivator::GetContext()->ungetService(m_DeviceTypeServiceReference);
}
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_ConnectDisconnectButton, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
connect(m_Controls->m_StartStopTrackingButton, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
+ connect(m_Controls->m_ConnectSimpleMode, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
+ connect(m_Controls->m_StartTrackingSimpleMode, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
connect(m_Controls->m_FreezeUnfreezeTrackingButton, SIGNAL(clicked()), this, SLOT(OnFreezeUnfreezeTracking()));
connect(m_TrackingLoggingTimer, SIGNAL(timeout()), this, SLOT(UpdateLoggingTrackingTimer()));
connect(m_TrackingRenderTimer, SIGNAL(timeout()), this, SLOT(UpdateRenderTrackingTimer()));
connect(m_TimeoutTimer, SIGNAL(timeout()), this, SLOT(OnTimeOut()));
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_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()));
connect(m_Controls->m_csvFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_xmlFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_UseDifferentUpdateRates, SIGNAL(clicked()), this, SLOT(OnToggleDifferentUpdateRates()));
connect(m_Controls->m_RenderUpdateRate, SIGNAL(valueChanged(int)), this, SLOT(OnChangeRenderUpdateRate()));
connect(m_Controls->m_DisableAllTimers, SIGNAL(stateChanged(int)), this, SLOT(EnableDisableTimerButtons(int)));
+ connect(m_Controls->m_advancedUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
+ connect(m_Controls->m_simpleUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
//connections for the tracking device configuration widget
connect(m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
//! [Thread 3]
//connect worker thread
connect(m_Worker, SIGNAL(AutoDetectToolsFinished(bool, QString)), this, SLOT(OnAutoDetectToolsFinished(bool, QString)));
connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), this, SLOT(OnConnectFinished(bool, QString)));
connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), this, SLOT(OnStartTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), this, SLOT(OnStopTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), this, SLOT(OnDisconnectFinished(bool, QString)));
connect(m_WorkerThread, SIGNAL(started()), m_Worker, SLOT(ThreadFunc()));
//move the worker to the thread
m_Worker->moveToThread(m_WorkerThread);
//! [Thread 3]
//initialize widgets
m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
+ m_Controls->m_simpleWidget->setVisible(false);
//initialize tracking volume node
m_TrackingVolumeNode = mitk::DataNode::New();
m_TrackingVolumeNode->SetName("TrackingVolume");
m_TrackingVolumeNode->SetBoolProperty("Backface Culling", true);
mitk::Color red;
red.SetRed(1);
m_TrackingVolumeNode->SetColor(red);
//initialize buttons
m_Controls->m_AutoDetectTools->setVisible(false); //only visible if tracking device is Aurora
m_Controls->m_StartStopTrackingButton->setEnabled(false);
+ m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//initialize warning labels
m_Controls->m_renderWarningLabel->setVisible(false);
m_Controls->m_TrackingFrozenLabel->setVisible(false);
//Update List of available models for selected tool.
std::vector<mitk::TrackingDeviceData> Compatibles;
if ((m_Controls == NULL) || //check all these stuff for NULL, latterly this causes crashes from time to time
(m_Controls->m_configurationWidget == NULL) ||
(m_Controls->m_configurationWidget->GetTrackingDevice().IsNull()))
{
MITK_ERROR << "Couldn't get current tracking device or an object is NULL, something went wrong!";
return;
}
else
{
Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType());
}
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
//initialize tool storage
m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
m_toolStorage->SetName("TrackingToolbox Default Storage");
m_toolStorage->RegisterAsMicroservice("no tracking device");
//set home directory as default path for logfile
m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(QDir::homePath()) + QDir::separator() + "logfile.csv");
//tracking device may be changed already by the persistence of the
//QmitkTrackingDeciveConfigurationWidget
this->OnTrackingDeviceChanged();
this->LoadUISettings();
//add tracking volume node only to data storage
this->GetDataStorage()->Add(m_TrackingVolumeNode);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
//Update List of available models for selected tool.
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t 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
{
this->ReplaceCurrentToolStorage(myDeserializer->Deserialize(filename.toStdString()), filename.toStdString());
}
catch (mitk::IGTException)
{
std::string errormessage = "Error during loading the tool storage file. Please only load tool storage files created with the NavigationToolManager view.";
QMessageBox::warning(NULL, "Tool Storage Loading Error", errormessage.c_str());
return;
}
if (m_toolStorage->isEmpty())
{
errorMessage = myDeserializer->GetErrorMessage();
MessageBox(errorMessage);
return;
}
//update label
UpdateToolStorageLabel(filename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
//save filename for persistent storage
m_ToolStorageFilename = filename;
}
void QmitkMITKIGTTrackingToolboxView::OnResetTools()
{
this->ReplaceCurrentToolStorage(mitk::NavigationToolStorage::New(GetDataStorage()), "TrackingToolbox Default Storage");
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
QString toolLabel = QString("<none>");
m_Controls->m_toolLabel->setText(toolLabel);
m_ToolStorageFilename = "";
}
void QmitkMITKIGTTrackingToolboxView::OnStartStopTracking()
{
if (!m_connected)
{
MITK_WARN << "Can't start tracking if no device is connected. Aborting";
return;
}
if (m_tracking) { OnStopTracking(); }
else { OnStartTracking(); }
}
void QmitkMITKIGTTrackingToolboxView::OnFreezeUnfreezeTracking()
{
if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Freeze Tracking")
{
m_TrackingDeviceSource->Freeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Unfreeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(true);
}
else if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Unfreeze Tracking")
{
m_TrackingDeviceSource->UnFreeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnConnectDisconnect()
{
if (m_connected) { OnDisconnect(); }
else { OnConnect(); }
}
void QmitkMITKIGTTrackingToolboxView::OnConnect()
{
MITK_INFO << "Connect Clicked";
//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;
}
//parse tracking device data
mitk::TrackingDeviceData data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
QString qstr = m_Controls->m_VolumeSelectionBox->currentText();
if ((!qstr.isNull()) || (!qstr.isEmpty())) {
std::string str = qstr.toStdString();
data = m_DeviceTypeCollection->GetDeviceDataByName(str); //Data will be set later, after device generation
}
//! [Thread 4]
//initialize worker thread
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eConnectDevice);
m_Worker->SetTrackingDevice(this->m_Controls->m_configurationWidget->GetTrackingDevice());
m_Worker->SetInverseMode(m_Controls->m_InverseMode->isChecked());
m_Worker->SetNavigationToolStorage(this->m_toolStorage);
m_Worker->SetTrackingDeviceData(data);
//start worker thread
m_WorkerThread->start();
//! [Thread 4]
//disable buttons
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableDisableTimerButtons(int enable)
{
bool enableBool = enable;
m_Controls->m_UpdateRateOptionsGroupBox->setEnabled(!enableBool);
m_Controls->m_renderWarningLabel->setVisible(enableBool);
}
void QmitkMITKIGTTrackingToolboxView::OnConnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
//enable buttons
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//! [Thread 6]
//get data from worker thread
m_TrackingDeviceSource = m_Worker->GetTrackingDeviceSource();
m_TrackingDeviceData = m_Worker->GetTrackingDeviceData();
m_ToolVisualizationFilter = m_Worker->GetToolVisualizationFilter();
//! [Thread 6]
//enable/disable Buttons
DisableOptionsButtons();
DisableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: connected");
m_Controls->m_ConnectDisconnectButton->setText("Disconnect");
+ m_Controls->m_ConnectSimpleMode->setText("Disconnect");
m_Controls->m_StartStopTrackingButton->setEnabled(true);
+ m_Controls->m_StartTrackingSimpleMode->setEnabled(true);
m_connected = true;
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
{
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eDisconnectDevice);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//enable/disable Buttons
m_Controls->m_StartStopTrackingButton->setEnabled(false);
+ m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
EnableOptionsButtons();
EnableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
m_Controls->m_ConnectDisconnectButton->setText("Connect");
+ m_Controls->m_ConnectSimpleMode->setText("Connect");
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
m_connected = false;
}
void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
{
//show tracking volume
this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
//Reset the view to a defined start. Do it here and not in OnStartTrackingFinished, to give other tracking devices the chance to reset the view to a different direction.
this->GlobalReinit();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStartTracking);
m_WorkerThread->start();
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStartTrackingFinished(bool success, QString errorMessage)
{
//! [Thread 5]
m_WorkerThread->quit();
m_WorkerThread->wait();
//! [Thread 5]
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
if (!(m_Controls->m_DisableAllTimers->isChecked()))
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() != 0)
m_TrackingRenderTimer->start(1000 / (m_Controls->m_RenderUpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_LogUpdateRate->value()));
}
else
{
m_TrackingRenderTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
}
}
m_Controls->m_TrackingControlLabel->setText("Status: tracking");
//connect the tool visualization widget
for (std::size_t 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); }
//if activated enable open IGT link microservice
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
//create convertion filter
m_IGTLConversionFilter = mitk::NavigationDataToIGTLMessageFilter::New();
m_IGTLConversionFilter->SetName("IGT Tracking Toolbox");
m_IGTLConversionFilter->ConnectTo(m_ToolVisualizationFilter);
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);
m_IGTLConversionFilter->RegisterAsMicroservice();
//create server and message provider
m_IGTLServer = mitk::IGTLServer::New(false);
m_IGTLServer->SetName("Tracking Toolbox IGTL Server");
m_IGTLMessageProvider = mitk::IGTLMessageProvider::New();
m_IGTLMessageProvider->SetIGTLDevice(m_IGTLServer);
m_IGTLMessageProvider->RegisterAsMicroservice();
}
m_tracking = true;
m_Controls->m_ConnectDisconnectButton->setEnabled(false);
m_Controls->m_StartStopTrackingButton->setText("Stop Tracking");
+ m_Controls->m_StartTrackingSimpleMode->setText("Stop\nTracking");
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
{
if (!m_tracking) return;
m_TrackingRenderTimer->stop();
m_TrackingLoggingTimer->stop();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStopTracking);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTrackingFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
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;
m_Controls->m_StartStopTrackingButton->setText("Start Tracking");
+ m_Controls->m_StartTrackingSimpleMode->setText("Start\nTracking");
m_Controls->m_ConnectDisconnectButton->setEnabled(true);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//unregister open IGT link micro service
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
m_IGTLConversionFilter->UnRegisterMicroservice();
m_IGTLMessageProvider->UnRegisterMicroservice();
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
{
mitk::TrackingDeviceType Type;
if (m_Controls->m_configurationWidget->GetTrackingDevice().IsNotNull())
{
Type = m_Controls->m_configurationWidget->GetTrackingDevice()->GetType();
//enable controls because device is valid
m_Controls->m_TrackingToolsGoupBox->setEnabled(true);
m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
}
else
{
Type = mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
MessageBox("Error: This tracking device is not included in this project. Please make sure that the device is installed and activated in your MITK build.");
m_Controls->m_TrackingToolsGoupBox->setEnabled(false);
m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
return;
}
// Code to enable/disable device specific buttons
+ if (m_Controls->m_configurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
+ { m_Controls->m_AutoDetectTools->setVisible(true); }
+ else
+ { m_Controls->m_AutoDetectTools->setVisible(false); }
+
if (Type == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) //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);
- }
+ { m_Controls->m_AddSingleTool->setEnabled(false);}
+ else //other trackers
+ { m_Controls->m_AddSingleTool->setEnabled(true); }
// Code to select appropriate tracking volume for current type
std::vector<mitk::TrackingDeviceData> Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(Type);
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t 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;
mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
std::string str = qstr.toStdString();
mitk::TrackingDeviceData data = m_DeviceTypeCollection->GetDeviceDataByName(str);
m_TrackingDeviceData = data;
volumeGenerator->SetTrackingDeviceData(data);
volumeGenerator->Update();
mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
m_TrackingVolumeNode->SetData(volumeSurface);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
{
if (m_Controls->m_ShowTrackingVolume->isChecked())
{
OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
m_TrackingVolumeNode->SetOpacity(0.25);
}
else
{
m_TrackingVolumeNode->SetOpacity(0.0);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
{
- if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName())
+ if (m_Controls->m_configurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
{
DisableTrackingConfigurationButtons();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eAutoDetectTools);
m_Worker->SetTrackingDevice(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
m_Worker->SetDataStorage(this->GetDataStorage());
m_WorkerThread->start();
m_TimeoutTimer->start(5000);
- MITK_INFO << "Timeout Timer started";
//disable controls until worker thread is finished
this->m_Controls->m_MainWidget->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectToolsFinished(bool success, QString errorMessage)
{
m_TimeoutTimer->stop();
m_WorkerThread->quit();
m_WorkerThread->wait();
//enable controls again
this->m_Controls->m_MainWidget->setEnabled(true);
EnableTrackingConfigurationButtons();
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
EnableTrackingConfigurationButtons();
return;
}
mitk::NavigationToolStorage::Pointer autoDetectedStorage = m_Worker->GetNavigationToolStorage();
//save detected tools
this->ReplaceCurrentToolStorage(autoDetectedStorage, "Autodetected NDI Aurora Storage");
//auto save the new storage to hard disc (for persistence)
AutoSaveToolStorage();
//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);
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;
- }
- }
//print a logging message about the detected tools
switch (m_toolStorage->GetToolCount())
{
case 0:
MITK_INFO("IGT Tracking Toolbox") << "Found no tools. Empty ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
case 1:
MITK_INFO("IGT Tracking Toolbox") << "Found one tool. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
default:
MITK_INFO("IGT Tracking Toolbox") << "Found " << m_toolStorage->GetToolCount() << " tools. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
}
}
void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkMITKIGTTrackingToolboxView::UpdateRenderTrackingTimer()
{
//update filter
m_ToolVisualizationFilter->Update();
MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
//update tool colors to show tool status
for (unsigned int i = 0; i < m_ToolVisualizationFilter->GetNumberOfIndexedOutputs(); i++)
{
mitk::NavigationData::Pointer currentTool = m_ToolVisualizationFilter->GetOutput(i);
if (currentTool->IsDataValid())
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_VALID);
}
else
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_WARNING);
}
}
//refresh view and status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_Controls->m_TrackingToolsStatusWidget->Refresh();
//code to better isolate bug 17713, could be removed when bug 17713 is fixed
static int i = 0;
static mitk::Point3D lastPositionTool1 = m_ToolVisualizationFilter->GetOutput(0)->GetPosition();
static itk::TimeStamp lastTimeStamp = m_ToolVisualizationFilter->GetOutput(0)->GetTimeStamp();
i++;
//every 20 frames: check if tracking is frozen
if (i > 20)
{
i = 0;
if (m_ToolVisualizationFilter->GetOutput(0)->IsDataValid())
{
if (mitk::Equal(lastPositionTool1, m_ToolVisualizationFilter->GetOutput(0)->GetPosition(), 0.000000001, false)
&& m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != "Da Vinci")
{
MITK_WARN << "Seems as tracking (of at least tool 1) is frozen which means that bug 17713 occurred. Restart tracking might help.";
//display further information to find the bug
MITK_WARN << "Timestamp of current navigation data: " << m_ToolVisualizationFilter->GetOutput(0)->GetTimeStamp();
MITK_WARN << "Timestamp of last navigation data (which holds the same values): " << lastTimeStamp;
}
lastPositionTool1 = m_ToolVisualizationFilter->GetOutput(0)->GetPosition();
lastTimeStamp = m_ToolVisualizationFilter->GetOutput(0)->GetTimeStamp();
}
}
}
void QmitkMITKIGTTrackingToolboxView::UpdateLoggingTrackingTimer()
{
//update logging
if (m_logging)
{
this->m_loggingFilter->Update();
m_loggedFrames = this->m_loggingFilter->GetNumberOfRecordedSteps();
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(); }
}
//refresh status widget
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
{
QDir currentPath = QFileInfo(m_Controls->m_LoggingFileName->text()).dir();
// if no path was selected (QDir would select current working dir then) or the
// selected path does not exist -> use home directory
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir(QDir::homePath());
}
QString filename = QFileDialog::getSaveFileName(NULL, tr("Choose Logging File"), currentPath.absolutePath(), "*.*");
if (filename == "") return;
this->m_Controls->m_LoggingFileName->setText(filename);
this->OnToggleFileExtension();
}
// bug-16470: toggle file extension after clicking on radio button
void QmitkMITKIGTTrackingToolboxView::OnToggleFileExtension()
{
QString currentInputText = this->m_Controls->m_LoggingFileName->text();
QString currentFile = QFileInfo(currentInputText).baseName();
QDir currentPath = QFileInfo(currentInputText).dir();
if (currentFile.isEmpty())
{
currentFile = "logfile";
}
// Setting currentPath to default home path when currentPath is empty or it does not exist
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir::homePath();
}
// check if csv radio button is clicked
if (this->m_Controls->m_csvFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".csv");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".csv");
}
}
// check if xml radio button is clicked
else if (this->m_Controls->m_xmlFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".xml");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".xml");
}
}
}
+void QmitkMITKIGTTrackingToolboxView::OnToggleAdvancedSimpleMode()
+{
+ if (m_SimpleModeEnabled)
+ {
+ m_Controls->m_simpleWidget->setVisible(false);
+ m_Controls->m_MainWidget->setVisible(true);
+ m_Controls->m_simpleUI->setChecked(false);
+ m_SimpleModeEnabled = false;
+ }
+ else
+ {
+ m_Controls->m_simpleWidget->setVisible(true);
+ m_Controls->m_MainWidget->setVisible(false);
+ m_SimpleModeEnabled = true;
+ }
+}
+
void QmitkMITKIGTTrackingToolboxView::OnToggleDifferentUpdateRates()
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_renderWarningLabel->setVisible(true);
else
m_Controls->m_renderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(true);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(true);
m_Controls->m_LogUpdateRate->setEnabled(true);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(true);
}
else
{
m_Controls->m_renderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(true);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnChangeRenderUpdateRate()
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_renderWarningLabel->setVisible(true);
else
m_Controls->m_renderWarningLabel->setVisible(false);
}
void QmitkMITKIGTTrackingToolboxView::StartLogging()
{
if (m_ToolVisualizationFilter.IsNull())
{
MessageBox("Cannot activate logging without a connected device. Configure and connect a tracking device first.");
return;
}
if (!m_logging)
{
//initialize logging filter
m_loggingFilter = mitk::NavigationDataRecorder::New();
m_loggingFilter->ConnectTo(m_ToolVisualizationFilter);
if (m_Controls->m_LoggingLimit->isChecked()){ m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value()); }
//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)
{
//stop logging
m_loggingFilter->StopRecording();
m_logging = false;
//update GUI
this->m_Controls->m_LoggingLabel->setText("Logging OFF");
EnableLoggingButtons();
//write the results to a file
if (m_Controls->m_csvFormat->isChecked())
{
mitk::IOUtil::SaveBaseData(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
}
else if (m_Controls->m_xmlFormat->isChecked())
{
mitk::IOUtil::SaveBaseData(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
}
}
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
{
QString Identifier = "Tool#";
QString Name = "NewTool";
if (m_toolStorage.IsNotNull()) {
Identifier += QString::number(m_toolStorage->GetToolCount());
Name += QString::number(m_toolStorage->GetToolCount());
}
else {
Identifier += "0";
Name += "0";
}
m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(), Identifier.toStdString(), Name.toStdString());
m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType(), false);
m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
//disable tracking volume during tool editing
lastTrackingVolumeState = m_Controls->m_ShowTrackingVolume->isChecked();
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
if (this->m_toolStorage.IsNull())
{
//this shouldn't happen!
MITK_WARN << "No ToolStorage available, cannot add tool, aborting!";
return;
}
m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_Controls->m_toolLabel->setText("<manually added>");
//auto save current storage for persistence
MITK_INFO << "Auto saving manually added tools for persistence.";
AutoSaveToolStorage();
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
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::TimeGeometry::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_UseDifferentUpdateRates->setEnabled(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
m_Controls->m_DisableAllTimers->setEnabled(false);
m_Controls->m_OtherOptionsGroupBox->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(true);
m_Controls->m_UseDifferentUpdateRates->setEnabled(true);
m_Controls->m_DisableAllTimers->setEnabled(true);
m_Controls->m_OtherOptionsGroupBox->setEnabled(true);
OnToggleDifferentUpdateRates();
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingControls()
{
m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingControls()
{
m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(true);
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) 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::NDIAuroraTypeInformation::GetTrackingDeviceName()) m_Controls->m_AddSingleTool->setEnabled(false);
m_Controls->m_LoadTools->setEnabled(false);
m_Controls->m_ResetTools->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName)
{
//first: get rid of the old one
//don't reset if there is no tool storage. BugFix #17793
if (m_toolStorage.IsNotNull()){
m_toolStorage->UnLockStorage(); //only to be sure...
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = nullptr;
}
//now: replace by the new one
m_toolStorage = newStorage;
m_toolStorage->SetName(newStorageName);
m_toolStorage->RegisterAsMicroservice("no tracking device");
}
void QmitkMITKIGTTrackingToolboxView::OnTimeOut()
{
- MITK_INFO << "Time Out";
m_WorkerThread->terminate();
m_WorkerThread->wait();
-
m_TimeoutTimer->stop();
}
//! [StoreUISettings]
void QmitkMITKIGTTrackingToolboxView::StoreUISettings()
{
// persistence service does not directly work in plugins for now
// -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
-
+ MITK_INFO << "Store UI settings";
// set the values of some widgets and attrbutes to the QSettings
settings.setValue("ShowTrackingVolume", QVariant(m_Controls->m_ShowTrackingVolume->isChecked()));
settings.setValue("toolStorageFilename", QVariant(m_ToolStorageFilename));
settings.setValue("VolumeSelectionBox", QVariant(m_Controls->m_VolumeSelectionBox->currentIndex()));
+ settings.setValue("SimpleModeEnabled", QVariant(m_SimpleModeEnabled));
settings.endGroup();
}
//! [StoreUISettings]
//! [LoadUISettings]
void QmitkMITKIGTTrackingToolboxView::LoadUISettings()
{
// persistence service does not directly work in plugins for now
// -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
// set some widgets and attributes by the values from the QSettings
m_Controls->m_ShowTrackingVolume->setChecked(settings.value("ShowTrackingVolume", true).toBool());
m_Controls->m_VolumeSelectionBox->setCurrentIndex(settings.value("VolumeSelectionBox", 0).toInt());
m_ToolStorageFilename = settings.value("toolStorageFilename", QVariant("")).toString();
-
+ if (settings.value("SimpleModeEnabled", false).toBool()) { this->OnToggleAdvancedSimpleMode(); }
settings.endGroup();
//! [LoadUISettings]
//! [LoadToolStorage]
// try to deserialize the tool storage from the given tool storage file name
if (!m_ToolStorageFilename.isEmpty())
{
// try-catch block for exceptions
try
{
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = myDeserializer->Deserialize(m_ToolStorageFilename.toStdString());
m_toolStorage->RegisterAsMicroservice("no tracking device");
//update label
UpdateToolStorageLabel(m_ToolStorageFilename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
}
catch (mitk::IGTException)
{
MITK_WARN("QmitkMITKIGTTrackingToolBoxView") << "Error during restoring tools. Problems with file (" << m_ToolStorageFilename.toStdString() << "), please check the file?";
this->OnResetTools(); //if there where errors reset the tool storage to avoid problems later on
}
}
//! [LoadToolStorage]
}
void QmitkMITKIGTTrackingToolboxView::UpdateToolStorageLabel(QString pathOfLoadedStorage)
{
QFileInfo myPath(pathOfLoadedStorage); //use this to seperate filename from path
QString toolLabel = myPath.fileName();
if (toolLabel.size() > 45) //if the tool storage name is to long trimm the string
{
toolLabel.resize(40);
toolLabel += "[...]";
}
m_Controls->m_toolLabel->setText(toolLabel);
}
void QmitkMITKIGTTrackingToolboxView::AutoSaveToolStorage()
{
m_ToolStorageFilename = m_AutoSaveFilename;
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
mySerializer->Serialize(m_ToolStorageFilename.toStdString(), m_toolStorage);
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetWorkerMethod(WorkerMethod w)
{
m_WorkerMethod = w;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDevice(mitk::TrackingDevice::Pointer t)
{
m_TrackingDevice = t;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetDataStorage(mitk::DataStorage::Pointer d)
{
m_DataStorage = d;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetInverseMode(bool mode)
{
m_InverseMode = mode;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDeviceData(mitk::TrackingDeviceData d)
{
m_TrackingDeviceData = d;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n)
{
m_NavigationToolStorage = n;
}
//! [Thread 7]
void QmitkMITKIGTTrackingToolboxViewWorker::ThreadFunc()
{
switch (m_WorkerMethod)
{
case eAutoDetectTools:
this->AutoDetectTools();
break;
case eConnectDevice:
this->ConnectDevice();
break;
case eStartTracking:
this->StartTracking();
break;
case eStopTracking:
this->StopTracking();
break;
case eDisconnectDevice:
this->DisconnectDevice();
break;
default:
MITK_WARN << "Undefined worker method was set ... something went wrong!";
break;
}
}
//! [Thread 7]
void QmitkMITKIGTTrackingToolboxViewWorker::AutoDetectTools()
{
- mitk::ProgressBar::GetInstance()->AddStepsToDo(4);
+ mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(m_DataStorage);
- mitk::NDITrackingDevice::Pointer currentDevice = dynamic_cast<mitk::NDITrackingDevice*>(m_TrackingDevice.GetPointer());
try
{
- currentDevice->OpenConnection();
+ mitk::NavigationToolStorage::Pointer tempStorage = m_TrackingDevice->AutoDetectTools();
mitk::ProgressBar::GetInstance()->Progress();
- currentDevice->StartTracking();
+ for (int i = 0; i < tempStorage->GetToolCount(); i++) { autoDetectedStorage->AddTool(tempStorage->GetTool(i)); }
}
catch (mitk::Exception& e)
{
- QString message = QString("Warning, can not auto-detect tools! (") + QString(e.GetDescription()) + QString(")");
- //MessageBox(message.toStdString()); //TODO: give message to the user here!
-
- MITK_WARN << message.toStdString();
- mitk::ProgressBar::GetInstance()->Progress(4);
- emit AutoDetectToolsFinished(false, message.toStdString().c_str());
+ MITK_WARN << e.GetDescription();
+ mitk::ProgressBar::GetInstance()->Progress(2);
+ emit AutoDetectToolsFinished(false, e.GetDescription());
return;
}
-
- for (unsigned 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::NDIAuroraTypeInformation::GetTrackingDeviceName());
- 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);
- }
-
m_NavigationToolStorage = autoDetectedStorage;
-
- currentDevice->StopTracking();
mitk::ProgressBar::GetInstance()->Progress();
- currentDevice->CloseConnection();
-
emit AutoDetectToolsFinished(true, "");
- mitk::ProgressBar::GetInstance()->Progress(4);
+ mitk::ProgressBar::GetInstance()->Progress(2);
}
void QmitkMITKIGTTrackingToolboxViewWorker::ConnectDevice()
{
std::string message = "";
mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
//build the IGT pipeline
mitk::TrackingDevice::Pointer trackingDevice = m_TrackingDevice;
trackingDevice->SetData(m_TrackingDeviceData);
//set device to rotation mode transposed becaus we are working with VNL style quaternions
if (m_InverseMode)
{
trackingDevice->SetRotationMode(mitk::TrackingDevice::RotationTransposed);
}
//Get Tracking Volume Data
mitk::TrackingDeviceData data = m_TrackingDeviceData;
mitk::ProgressBar::GetInstance()->Progress();
//Create Navigation Data Source with the factory class
mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(m_NavigationToolStorage, trackingDevice);
m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(m_ToolVisualizationFilter);
mitk::ProgressBar::GetInstance()->Progress();
if (m_TrackingDeviceSource.IsNull())
{
message = std::string("Cannot connect to device: ") + myTrackingDeviceSourceFactory->GetErrorMessage();
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
//set filter to rotation mode transposed becaus we are working with VNL style quaternions
if (m_InverseMode)
m_ToolVisualizationFilter->SetRotationMode(mitk::NavigationDataObjectVisualizationFilter::RotationTransposed);
//First check if the created object is valid
if (m_TrackingDeviceSource.IsNull())
{
message = myTrackingDeviceSourceFactory->GetErrorMessage();
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
MITK_INFO << "Number of tools: " << m_TrackingDeviceSource->GetNumberOfOutputs();
mitk::ProgressBar::GetInstance()->Progress();
//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_NavigationToolStorage->DeleteAllTools();
for (int i=0; i < toolsInNewOrder->GetToolCount(); i++) {m_NavigationToolStorage->AddTool(toolsInNewOrder->GetTool(i));}
This was replaced and thereby fixed Bug 18318 DeleteAllTools() is not Threadsafe!
*/
for (int i = 0; i < toolsInNewOrder->GetToolCount(); i++)
{
m_NavigationToolStorage->AssignToolNumber(toolsInNewOrder->GetTool(i)->GetIdentifier(), i);
}
}
mitk::ProgressBar::GetInstance()->Progress();
//connect to device
try
{
m_TrackingDeviceSource->Connect();
mitk::ProgressBar::GetInstance()->Progress();
//Microservice registration:
m_TrackingDeviceSource->RegisterAsMicroservice();
m_NavigationToolStorage->UnRegisterMicroservice();
m_NavigationToolStorage->RegisterAsMicroservice(m_TrackingDeviceSource->GetMicroserviceID());
m_NavigationToolStorage->LockStorage();
}
catch (...) //todo: change to mitk::IGTException
{
message = "Error on connecting the tracking device.";
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
emit ConnectDeviceFinished(true, QString(message.c_str()));
mitk::ProgressBar::GetInstance()->Progress(10);
}
void QmitkMITKIGTTrackingToolboxViewWorker::StartTracking()
{
QString errorMessage = "";
try
{
m_TrackingDeviceSource->StartTracking();
}
catch (...) //todo: change to mitk::IGTException
{
errorMessage += "Error while starting the tracking device!";
emit StartTrackingFinished(false, errorMessage);
return;
}
//remember the original colors of the tools
m_OriginalColors = std::map<mitk::DataNode::Pointer, mitk::Color>();
for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
float c[3];
currentToolNode->GetColor(c);
mitk::Color color;
color.SetRed(c[0]);
color.SetGreen(c[1]);
color.SetBlue(c[2]);
m_OriginalColors[currentToolNode] = color;
}
emit StartTrackingFinished(true, errorMessage);
}
void QmitkMITKIGTTrackingToolboxViewWorker::StopTracking()
{
//stop tracking
try
{
m_TrackingDeviceSource->StopTracking();
}
catch (mitk::Exception& e)
{
emit StopTrackingFinished(false, e.GetDescription());
}
//restore the original colors of the tools
for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
if (m_OriginalColors.find(currentToolNode) == m_OriginalColors.end())
{
MITK_WARN << "Cannot restore original color of tool " << m_NavigationToolStorage->GetTool(i)->GetToolName();
}
else
{
currentToolNode->SetColor(m_OriginalColors[currentToolNode]);
}
}
//emit signal
emit StopTrackingFinished(true, "");
}
void QmitkMITKIGTTrackingToolboxViewWorker::DisconnectDevice()
{
try
{
if (m_TrackingDeviceSource->IsTracking()) { m_TrackingDeviceSource->StopTracking(); }
m_TrackingDeviceSource->Disconnect();
m_TrackingDeviceSource->UnRegisterMicroservice();
m_NavigationToolStorage->UnLockStorage();
}
catch (mitk::Exception& e)
{
emit DisconnectDeviceFinished(false, e.GetDescription());
}
emit DisconnectDeviceFinished(true, "");
}
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
index 406dcfafd6..e9376fd998 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
@@ -1,306 +1,308 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef QmitkMITKIGTTrackingToolboxView_h
#define QmitkMITKIGTTrackingToolboxView_h
#include <berryISelectionListener.h>
#include <QmitkFunctionality.h>
#include "ui_QmitkMITKIGTTrackingToolboxViewControls.h"
//mitk headers
#include <mitkNavigationToolStorage.h>
#include <mitkTrackingDeviceSource.h>
#include <mitkNavigationDataObjectVisualizationFilter.h>
#include <mitkNavigationDataRecorder.h>
#include <mitkNavigationDataToIGTLMessageFilter.h>
#include <mitkIGTLServer.h>
#include <mitkIGTLMessageProvider.h>
//QT headers
#include <QTimer>
class QmitkMITKIGTTrackingToolboxViewWorker;
/*!
\brief QmitkMITKIGTTrackingToolboxView
This is the view of the bundle IGT Tracking Toolbox. The IGT Tracking Toolbox can be used to access tracking devices with MITK-IGT. The Tracking Toolbox can be used to log tracking data in XML or CSV format for measurement purposes. The Tracking Toolbox further allows for visualization of tools with given surfaces in combination with the NaviagtionToolManager.
\sa QmitkFunctionality
\ingroup Functionalities
*/
class QmitkMITKIGTTrackingToolboxView : 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;
QmitkMITKIGTTrackingToolboxView();
virtual ~QmitkMITKIGTTrackingToolboxView();
virtual void CreateQtPartControl(QWidget *parent) override;
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
virtual void StdMultiWidgetNotAvailable() override;
protected slots:
/** @brief changes name of the filename when switching fileextension by radio button */
void OnToggleFileExtension();
/** @brief This slot is called if the user wants to load a new tool file. A new window opens where the user can choose a file. If the chosen file is
corrupt or not valid the user gets an error message. If the file was loaded successfully the tools are show in the tool status widget. */
void OnLoadTools();
/** Starts tracking if tracking is stopped / stops tracking if tracking is started. */
void OnStartStopTracking();
/** Connects the device if it is disconnected / disconnects the device if it is connected. */
void OnConnectDisconnect();
/** Freezes the device if it is not frozen / unfreezes the device if it is frozen. */
void OnFreezeUnfreezeTracking();
/** @brief This slot connects to the device. In status "connected" configuration of the device is disabled. */
void OnConnect();
/** @brief This slot disconnects from the device. */
void OnDisconnect();
/** @brief This slot tries to start tracking with the current device. If start tracking fails the user gets an error message and tracking stays off.*/
void OnStartTracking();
/** @brief This slot stops tracking. If tracking is not strated it does nothing.*/
void OnStopTracking();
/** @brief This slot is called if the user want's to choose a file name for logging. A new windows to navigate through the file system and choose
a file opens.*/
void OnChooseFileClicked();
/** @brief This slot starts logging. Logging is only possible if a device is tracking. If not the logging mechanism start when the start tracking
is called.*/
void StartLogging();
/** @brief This slot stops logging. If logging is not running it does nothing.*/
void StopLogging();
/** @brief This slot enables / disables UI elements depending on the tracking device after a device is changed.*/
void OnTrackingDeviceChanged();
/** @brief This slot selects the Tracking Volume appropriate for a given model */
void OnTrackingVolumeChanged(QString qstr);
/** @brief Shows or hides the tracking volume according to the checkboxe's state */
void OnShowTrackingVolumeChanged();
/** @brief This slot auto detects tools of a NDI Aurora tracking device. If tools where found they will be stored internally as a tool storage.
The user is also asked if he wants to save this tool storage to load it later. Only call it if a Aurora device was configured because other
devices don't support auto detection.*/
void OnAutoDetectTools();
/** @brief Slot for tracking timer. The timer updates the IGT pipline and also the logging filter if logging is activated.*/
void UpdateRenderTrackingTimer();
void UpdateLoggingTrackingTimer();
/** @brief Slot for showing the rendering disabled warning label*/
void OnChangeRenderUpdateRate();
/** @brief Resets the Tracking Tools: this means all tools are removed. */
void OnResetTools();
/** @brief Opens a dialog where a new navigation tool can be created. */
void OnAddSingleTool();
/** @brief This slot is called if the user finishes the creation of a new tool. */
void OnAddSingleToolFinished();
/** @brief This slot is called if the user cancels the creation of a new tool. */
void OnAddSingleToolCanceled();
void OnTimeOut();
protected slots:
//help slots for enable/disable buttons
void DisableLoggingButtons();
void EnableLoggingButtons();
void DisableOptionsButtons();
void EnableOptionsButtons();
void EnableTrackingConfigurationButtons();
void DisableTrackingConfigurationButtons();
void EnableTrackingControls();
void DisableTrackingControls();
void EnableDisableTimerButtons(int enable);
-
+ void OnToggleAdvancedSimpleMode();
void OnToggleDifferentUpdateRates();
//slots for worker thread
void OnAutoDetectToolsFinished(bool success, QString errorMessage);
void OnConnectFinished(bool success, QString errorMessage);
void OnStartTrackingFinished(bool success, QString errorMessage);
void OnStopTrackingFinished(bool success, QString errorMessage);
void OnDisconnectFinished(bool success, QString errorMessage);
protected:
Ui::QmitkMITKIGTTrackingToolboxViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
bool m_tracking; ///> bool which is true if tracking is running, false if not
bool m_connected; ///> bool that is true when a tracking device is connected
bool m_logging; ///> bool which is true if logging is running, false if not
int m_loggedFrames; ///> stores the current number of logged frames if logging is on
mitk::NavigationToolStorage::Pointer m_toolStorage; ///>stores the loaded tools
mitk::DataNode::Pointer m_TrackingVolumeNode; ///>holds the data node of the tracking volume if volume is visualized
bool lastTrackingVolumeState; ///>temporary holds the state of the tracking volume (activated/not activated) during some methods
QString m_ToolStorageFilename; ///>stores the filename of the current tool storage
QString m_AutoSaveFilename; ///>a filename for auto saving tools if no m_ToolStorageFilename was given by the user
/** @brief Shows a message box with the text given as parameter. */
void MessageBox(std::string s);
/** @brief reinits the view globally. */
void GlobalReinit();
//members for the filter pipeline
mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
mitk::NavigationDataRecorder::Pointer m_loggingFilter; ///> holds the logging filter if logging is on (third filter of the IGT pipeline)
//members for open IGT link server
mitk::NavigationDataToIGTLMessageFilter::Pointer m_IGTLConversionFilter; ///> Converts the navigation data as open IGT link message and makes this filter available as microservice
mitk::IGTLServer::Pointer m_IGTLServer;
mitk::IGTLMessageProvider::Pointer m_IGTLMessageProvider;
/** @brief This timer updates the IGT pipline and also the logging filter if logging is activated.*/
QTimer* m_TrackingRenderTimer;
QTimer* m_TrackingLoggingTimer;
QTimer* m_TimeoutTimer;
+ bool m_SimpleModeEnabled; ///>Stores if simple UI mode is enabled
+
/** Replaces the current navigation tool storage which is stored in m_toolStorage.
* Basically handles the microservice stuff: unregisteres the old storage, then
* replaces the storage and registers the new one.
*/
void ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName);
/**
* \brief Stores the properties of some QWidgets (and the tool storage file name) to QSettings.
*/
void StoreUISettings();
/**
* \brief Loads the properties of some QWidgets (and the tool storage file name) from QSettings.
*/
void LoadUISettings();
/**
* Help method for updating the tool label
*/
void UpdateToolStorageLabel(QString pathOfLoadedStorage);
/**
* Auto saves the current tool storage to a temporary file. This ist used for persistence.
*/
void AutoSaveToolStorage();
//members for worker thread
QThread* m_WorkerThread;
QmitkMITKIGTTrackingToolboxViewWorker* m_Worker;
private:
ctkServiceReference m_DeviceTypeServiceReference;
mitk::TrackingDeviceTypeCollection* m_DeviceTypeCollection;
};
/**
* Worker thread class for this view.
*/
class QmitkMITKIGTTrackingToolboxViewWorker : public QObject
{
Q_OBJECT
public:
enum WorkerMethod{
eAutoDetectTools = 0,
eConnectDevice = 1,
eStartTracking = 2,
eStopTracking = 3,
eDisconnectDevice = 4
};
void SetWorkerMethod(WorkerMethod w);
void SetTrackingDevice(mitk::TrackingDevice::Pointer t);
void SetDataStorage(mitk::DataStorage::Pointer d);
void SetInverseMode(bool mode);
void SetTrackingDeviceData(mitk::TrackingDeviceData d);
void SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n);
itkGetMacro(NavigationToolStorage,mitk::NavigationToolStorage::Pointer);
itkGetMacro(TrackingDeviceSource,mitk::TrackingDeviceSource::Pointer);
itkGetMacro(TrackingDeviceData,mitk::TrackingDeviceData);
itkGetMacro(ToolVisualizationFilter,mitk::NavigationDataObjectVisualizationFilter::Pointer);
public slots:
void ThreadFunc();
signals:
void AutoDetectToolsFinished(bool success, QString errorMessage);
void ConnectDeviceFinished(bool success, QString errorMessage);
void StartTrackingFinished(bool success, QString errorMessage);
void StopTrackingFinished(bool success, QString errorMessage);
void DisconnectDeviceFinished(bool success, QString errorMessage);
protected:
mitk::TrackingDevice::Pointer m_TrackingDevice;
WorkerMethod m_WorkerMethod;
mitk::DataStorage::Pointer m_DataStorage;
mitk::NavigationToolStorage::Pointer m_NavigationToolStorage;
//members for the filter pipeline which is created in the worker thread during ConnectDevice()
mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
//members some internal flags
bool m_InverseMode; //flag that is true when the inverse mode is enabled
//stores the original colors of the tracking tools
std::map<mitk::DataNode::Pointer,mitk::Color> m_OriginalColors;
//internal methods
void AutoDetectTools();
void ConnectDevice();
void StartTracking();
void StopTracking();
void DisconnectDevice();
};
#endif // _QMITKMITKIGTTRACKINGTOOLBOXVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
index ecad7c0c5b..80774c501b 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
@@ -1,805 +1,889 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkMITKIGTTrackingToolboxViewControls</class>
<widget class="QWidget" name="QmitkMITKIGTTrackingToolboxViewControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>370</width>
- <height>1009</height>
+ <height>747</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_3">
<item>
<widget class="QTabWidget" name="m_MainWidget">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="tab">
<attribute name="title">
<string>Tracking</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_9">
<item>
<widget class="QGroupBox" name="groupBox_3">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<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>280</height>
</size>
</property>
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_4">
<item>
<widget class="QmitkTrackingDeviceConfigurationWidget" name="m_configurationWidget" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_TrackingToolsGoupBox">
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_5">
<item>
<widget class="QLabel" name="label_2">
<property name="font">
<font>
<pointsize>6</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html><head><meta name="qrichtext" content="1" /><style type="text/css">
p, li { white-space: pre-wrap; }
</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;">
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt; font-weight:600;">Tracking Tools</span></p></body></html></string>
</property>
</widget>
</item>
<item>
<widget class="QStackedWidget" name="m_TrackingToolsWidget">
<property name="lineWidth">
<number>0</number>
</property>
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="page">
<layout class="QVBoxLayout" name="verticalLayout_11">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QLabel" name="label_4">
<property name="text">
<string>ToolStorage:</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_toolLabel">
<property name="text">
<string><none></string>
</property>
</widget>
</item>
<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>
</layout>
</item>
<item>
<widget class="QmitkToolTrackingStatusWidget" name="m_TrackingToolsStatusWidget" native="true">
<property name="minimumSize">
<size>
<width>200</width>
<height>80</height>
</size>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_9">
<item>
<spacer name="horizontalSpacer_7">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>13</width>
<height>49</height>
</size>
</property>
</spacer>
</item>
<item>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QPushButton" name="m_AutoDetectTools">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Auto Detection</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_AddSingleTool">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Add Single Tool</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_LoadTools">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Load Tool Storage</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_ResetTools">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Reset</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</item>
</layout>
</widget>
<widget class="QWidget" name="page_2">
<layout class="QVBoxLayout" name="verticalLayout_10">
<item>
<widget class="QmitkNavigationToolCreationWidget" name="m_NavigationToolCreationWidget" native="true"/>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_TrackingControlsGroupBox">
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QLabel" name="label_3">
<property name="text">
<string><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html><head><meta name="qrichtext" content="1" /><style type="text/css">
p, li { white-space: pre-wrap; }
</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;">
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt; font-weight:600;">Tracking Control</span></p></body></html></string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_TrackingControlLabel">
<property name="text">
<string>Status: disconnected</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<spacer name="horizontalSpacer_11">
<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_ConnectDisconnectButton">
<property name="minimumSize">
<size>
<width>142</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Connect</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<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_StartStopTrackingButton">
<property name="minimumSize">
<size>
<width>142</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Start Tracking</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_11">
<item>
<spacer name="horizontalSpacer_9">
<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="m_TrackingFrozenLabel">
<property name="text">
<string><html><head/><body><p><span style=" color:#ff0000;">Tracking Frozen!</span></p></body></html></string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_FreezeUnfreezeTrackingButton">
<property name="enabled">
<bool>true</bool>
</property>
<property name="minimumSize">
<size>
<width>142</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Freeze Tracking</string>
</property>
</widget>
</item>
</layout>
</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>
<widget class="QWidget" name="tab_2">
<attribute name="title">
<string>Options</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_13">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_12">
<item>
<widget class="QCheckBox" name="m_DisableAllTimers">
<property name="text">
<string>Disable All Timers</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_renderWarningLabel">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string><html><head/><body><p align="right"><span style=" color:#ff0000;">Rendering Disabled!</span></p></body></html></string>
</property>
<property name="textFormat">
<enum>Qt::AutoText</enum>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QGroupBox" name="m_UpdateRateOptionsGroupBox">
<property name="title">
<string>Update Rate Options</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_14">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_6">
<item>
<widget class="QLabel" name="m_OptionsUpdateRateLabel">
<property name="text">
<string>Update Rate [per second]</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_5">
<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_UpdateRate">
<property name="maximum">
<number>100</number>
</property>
<property name="value">
<number>10</number>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QCheckBox" name="m_UseDifferentUpdateRates">
<property name="text">
<string>Use different Render and Log Update Rates</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_8" stretch="0,0,0">
<item>
<widget class="QLabel" name="m_OptionsRenderUpdateRateLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Render Update Rate [fps]</string>
</property>
</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="QSpinBox" name="m_RenderUpdateRate">
<property name="enabled">
<bool>false</bool>
</property>
<property name="minimum">
<number>0</number>
</property>
<property name="maximum">
<number>100</number>
</property>
<property name="value">
<number>10</number>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_10">
<item>
<widget class="QLabel" name="m_OptionsLogUpdateRateLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Log Update Rate [per second]</string>
</property>
</widget>
</item>
<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="QSpinBox" name="m_LogUpdateRate">
<property name="enabled">
<bool>false</bool>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>120</number>
</property>
<property name="singleStep">
<number>10</number>
</property>
<property name="value">
<number>60</number>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox">
<property name="title">
<string>Tracking Volume Options</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_7">
<item>
<widget class="QCheckBox" name="m_ShowTrackingVolume">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string>Show Tracking Volume</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_5">
<property name="text">
<string>Select Model:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="m_VolumeSelectionBox"/>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_OtherOptionsGroupBox">
<property name="title">
<string>Other Options</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_12">
<item>
<widget class="QCheckBox" name="m_ShowToolQuaternions">
<property name="text">
<string>Show Tool Quaternions</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="m_EnableOpenIGTLinkMicroService">
<property name="text">
<string>Enable Open IGT Link MicroService</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
+ <item>
+ <widget class="QCheckBox" name="m_simpleUI">
+ <property name="text">
+ <string>Simple UI</string>
+ </property>
+ </widget>
+ </item>
<item>
<widget class="QLabel" name="label_6">
<property name="text">
<string>Caution, only for backward compatibility:</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="m_InverseMode">
<property name="text">
<string>Inverse mode (Quaternions are stored inverse)</string>
</property>
</widget>
</item>
</layout>
</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>600</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_3">
<attribute name="title">
<string>Logging</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_8">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Filename:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="m_LoggingFileName"/>
</item>
<item>
<widget class="QPushButton" name="m_ChooseFile">
<property name="text">
<string>Choose File</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_7">
<item>
<widget class="QCheckBox" name="m_LoggingLimit">
<property name="text">
<string>Limit Number Of Logged Frames:</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_6">
<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_LoggedFramesLimit">
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>9999</number>
</property>
<property name="value">
<number>300</number>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QRadioButton" name="m_csvFormat">
<property name="text">
<string>CSV format</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QRadioButton" name="m_xmlFormat">
<property name="text">
<string>XML format</string>
</property>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_4">
<property name="title">
<string>Logging Status</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_6">
<item>
<widget class="QLabel" name="m_LoggingLabel">
<property name="text">
<string>Logging OFF</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_LoggedFramesLabel">
<property name="text">
<string>Logged Frames: 0</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<spacer name="horizontalSpacer_4">
<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_StartLogging">
<property name="text">
<string>Start Logging</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_StopLogging">
<property name="text">
<string>Stop Logging</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>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</widget>
</item>
+ <item>
+ <widget class="QWidget" name="m_simpleWidget" native="true">
+ <layout class="QHBoxLayout" name="horizontalLayout_13">
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_25">
+ <item>
+ <widget class="QPushButton" name="m_ConnectSimpleMode">
+ <property name="minimumSize">
+ <size>
+ <width>70</width>
+ <height>50</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Connect</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_StartTrackingSimpleMode">
+ <property name="minimumSize">
+ <size>
+ <width>70</width>
+ <height>50</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Start
+Tracking</string>
+ </property>
+ </widget>
+ </item>
+ <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_advancedUI">
+ <property name="minimumSize">
+ <size>
+ <width>70</width>
+ <height>50</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Advanced
+Mode</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </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>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
<customwidget>
<class>QmitkTrackingDeviceConfigurationWidget</class>
<extends>QWidget</extends>
<header>QmitkTrackingDeviceConfigurationWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkToolTrackingStatusWidget</class>
<extends>QWidget</extends>
<header>QmitkToolTrackingStatusWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkNavigationToolCreationWidget</class>
<extends>QWidget</extends>
<header>QmitkNavigationToolCreationWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
index 90d835c996..2ea3c9cace 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
@@ -1,529 +1,531 @@
-/*=========================================================================
+/*===================================================================
-Program: Medical Imaging & Interaction Toolkit
-Language: C++
-Date: $Date$
-Version: $Revision$
+The Medical Imaging Interaction Toolkit (MITK)
-Copyright (c) German Cancer Research Center, Division of Medical and
-Biological Informatics. All rights reserved.
-See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
-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.
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
-=========================================================================*/
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
#include "QmitkImageCropper.h"
#include <QAction>
#include <QCheckBox>
#include <QColorDialog>
#include <QInputDialog>
#include <QMessageBox>
#include <QSpinBox>
#include <QSlider>
#include <vtkCommand.h>
#include <vtkCubeSource.h>
#include <vtkObjectFactory.h>
#include <vtkRenderWindow.h>
#include <vtkPlaneWidget.h>
#include <vtkProperty.h>
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
#include <vtkTransformFilter.h>
#include <mitkBoundingShapeInteractor.h>
#include <mitkBoundingShapeCropper.h>
#include <mitkDisplayInteractor.h>
#include <mitkIDataStorageService.h>
#include <mitkImageCast.h> // Includes for image casting between ITK and MITK: added after using Plugin Generator
#include <mitkImageAccessByItk.h>
#include <mitkImageStatisticsHolder.h>
#include <mitkInteractionConst.h>
#include <mitkITKImageImport.h>
#include <mitkLabelSetImage.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkRenderingManager.h>
#include <mitkProperties.h>
#include <itkBoundingBox.h>
#include <itkCommand.h>
#include <usModuleRegistry.h>
#include <usGetModuleContext.h>
const std::string QmitkImageCropper::VIEW_ID = "org.mitk.views.qmitkimagecropper";
QmitkImageCropper::QmitkImageCropper(QObject *parent)
: m_ParentWidget(0),
m_ImageNode(nullptr),
m_CroppingObject(nullptr),
m_CroppingObjectNode(nullptr),
m_BoundingShapeInteractor(nullptr),
m_CropOutsideValue(0),
m_Advanced(0),
m_Active(0),
m_ScrollEnabled(true)
{
CreateBoundingShapeInteractor(false);
}
QmitkImageCropper::~QmitkImageCropper()
{
//delete pointer objects
m_CroppingObjectNode = nullptr;
m_CroppingObject = nullptr;
//disable interactor
if (m_BoundingShapeInteractor != nullptr)
{
m_BoundingShapeInteractor->SetDataNode(nullptr);
m_BoundingShapeInteractor->EnableInteraction(false);
}
}
void QmitkImageCropper::SetFocus()
{
m_Controls.buttonCreateNewBoundingBox->setFocus();
}
void QmitkImageCropper::CreateQtPartControl(QWidget *parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Controls.boundingShapeSelector->SetDataStorage(this->GetDataStorage());
m_Controls.boundingShapeSelector->SetPredicate(mitk::NodePredicateAnd::New(
mitk::TNodePredicateDataType<mitk::GeometryData>::New(),
mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))));
m_CroppingObjectNode = m_Controls.boundingShapeSelector->GetSelectedNode();
connect(m_Controls.buttonCropping, SIGNAL(clicked()), this, SLOT(DoCropping()));
connect(m_Controls.buttonMasking, SIGNAL(clicked()), this, SLOT(DoMasking()));
connect(m_Controls.boundingShapeSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)),
this, SLOT(OnDataSelectionChanged(const mitk::DataNode*)));
connect(m_Controls.buttonCreateNewBoundingBox, SIGNAL(clicked()), this, SLOT(DoCreateNewBoundingObject()));
connect(m_Controls.buttonAdvancedSettings, SIGNAL(clicked()), this, SLOT(OnAdvancedSettingsButtonToggled()));
connect(m_Controls.spinBox, SIGNAL(valueChanged(int)), this, SLOT(OnSliderValueChanged(int)));
m_Controls.spinBox->setValue(-1000);
m_Controls.spinBox->setEnabled(false);
m_Controls.buttonCreateNewBoundingBox->setEnabled(false);
m_Controls.buttonCropping->setEnabled(false);
m_Controls.boundingShapeSelector->setEnabled(false);
m_Controls.labelWarningRotation->setVisible(false);
m_Controls.buttonAdvancedSettings->setEnabled(false);
m_Advanced = false;
this->OnAdvancedSettingsButtonToggled();
m_ParentWidget = parent;
}
void QmitkImageCropper::OnDataSelectionChanged(const mitk::DataNode* node)
{
m_Controls.boundingShapeSelector->setEnabled(true);
m_CroppingObjectNode = m_Controls.boundingShapeSelector->GetSelectedNode();
if (m_CroppingObjectNode.IsNotNull() && dynamic_cast<mitk::GeometryData*>(this->m_CroppingObjectNode->GetData()))
{
m_Controls.buttonAdvancedSettings->setEnabled(true);
m_Controls.labelWarningBB->setText(QString::fromStdString(""));
m_CroppingObject = dynamic_cast<mitk::GeometryData*>(m_CroppingObjectNode->GetData());
m_Advanced = true;
mitk::RenderingManager::GetInstance()->InitializeViews();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
else
{
m_Controls.buttonAdvancedSettings->setEnabled(false);
m_CroppingObject = nullptr;
m_BoundingShapeInteractor->EnableInteraction(false);
m_BoundingShapeInteractor->SetDataNode(nullptr);
m_Advanced = false;
this->OnAdvancedSettingsButtonToggled();
}
}
void QmitkImageCropper::OnAdvancedSettingsButtonToggled()
{
m_Controls.groupImageSettings->setVisible(m_Advanced);
m_Advanced = !m_Advanced;
}
void QmitkImageCropper::CreateBoundingShapeInteractor(bool rotationEnabled)
{
if (m_BoundingShapeInteractor.IsNull())
{
m_BoundingShapeInteractor = mitk::BoundingShapeInteractor::New();
m_BoundingShapeInteractor->LoadStateMachine("BoundingShapeInteraction.xml", us::ModuleRegistry::GetModule("MitkBoundingShape"));
m_BoundingShapeInteractor->SetEventConfig("BoundingShapeMouseConfig.xml", us::ModuleRegistry::GetModule("MitkBoundingShape"));
}
m_BoundingShapeInteractor->SetRotationEnabled(rotationEnabled);
}
mitk::Geometry3D::Pointer QmitkImageCropper::InitializeWithImageGeometry(mitk::BaseGeometry::Pointer geometry)
{
// convert a basegeometry into a Geometry3D (otherwise IO is not working properly)
if (geometry == nullptr)
mitkThrow() << "Geometry is not valid.";
auto boundingGeometry = mitk::Geometry3D::New();
boundingGeometry->SetBounds(geometry->GetBounds());
boundingGeometry->SetImageGeometry(geometry->GetImageGeometry());
boundingGeometry->SetOrigin(geometry->GetOrigin());
boundingGeometry->SetSpacing(geometry->GetSpacing());
boundingGeometry->SetIndexToWorldTransform(geometry->GetIndexToWorldTransform());
boundingGeometry->Modified();
return boundingGeometry;
}
void QmitkImageCropper::DoCreateNewBoundingObject()
{
if (m_ImageNode.IsNotNull())
{
bool ok = false;
QString name = QInputDialog::getText(QApplication::activeWindow()
, "Add cropping shape...", "Enter name for the new cropping shape", QLineEdit::Normal, "BoundingShape", &ok);
- if (!ok || name.isEmpty())
+ if (!ok)
return;
m_Controls.buttonCropping->setEnabled(true);
m_Controls.buttonMasking->setEnabled(true);
m_Controls.boundingShapeSelector->setEnabled(true);
// to do: check whether stdmulti.widget is valid
// get current timestep to support 3d+t images //to do: check if stdmultiwidget is valid
int timeStep = mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))->GetTimeStep();
mitk::BaseGeometry::Pointer imageGeometry = static_cast<mitk::BaseGeometry*>(m_ImageNode->GetData()->GetGeometry(timeStep));
m_CroppingObject = mitk::GeometryData::New();
m_CroppingObject->SetGeometry(static_cast<mitk::Geometry3D*>(this->InitializeWithImageGeometry(imageGeometry)));
m_CroppingObjectNode = mitk::DataNode::New();
m_CroppingObjectNode->SetData(m_CroppingObject);
m_CroppingObjectNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
m_CroppingObjectNode->SetProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
m_CroppingObjectNode->SetProperty("opacity", mitk::FloatProperty::New(0.6));
m_CroppingObjectNode->SetProperty("layer", mitk::IntProperty::New(99));
m_CroppingObjectNode->AddProperty("handle size factor", mitk::DoubleProperty::New(1.0 / 40.0));
m_CroppingObjectNode->SetBoolProperty("pickable", true);
if (!this->GetDataStorage()->Exists(m_CroppingObjectNode))
{
GetDataStorage()->Add(m_CroppingObjectNode, m_ImageNode);
m_Controls.boundingShapeSelector->SetSelectedNode(m_CroppingObjectNode);
m_CroppingObjectNode->SetVisibility(true);
m_BoundingShapeInteractor->EnableInteraction(true);
m_BoundingShapeInteractor->SetDataNode(this->m_CroppingObjectNode);
this->OnDataSelectionChanged(m_CroppingObjectNode);
}
}
// Adjust coordinate system by doing a reinit on
auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
tempDataStorage->InsertElement(0, m_CroppingObjectNode);
- // initialize the views to the bounding geometry
- mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
- mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ //// initialize the views to the bounding geometry
+ //mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
+ //mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
+ //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkImageCropper::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
const QList<mitk::DataNode::Pointer>& nodes)
{
bool rotationEnabled = false;
if (nodes.empty())
{
m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
m_Controls.labelWarningImage->setText(QString::fromStdString("Select an image."));
m_Controls.labelWarningBB->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
m_Controls.labelWarningBB->setText(QString::fromStdString("Create a bounding shape below."));
m_Controls.buttonCreateNewBoundingBox->setEnabled(false);
m_Controls.buttonCropping->setEnabled(false);
m_Controls.buttonMasking->setEnabled(false);
m_Controls.labelWarningRotation->setVisible(false);
return;
}
m_ParentWidget->setEnabled(true);
foreach(mitk::DataNode::Pointer node, nodes)
{
if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
{
m_ImageNode = nodes[0];
m_Controls.groupBoundingObject->setEnabled(true);
m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(0, 0, 0) }");
m_Controls.labelWarningImage->setText(QString::fromStdString("File name: " + m_ImageNode->GetName()));
m_Controls.buttonCreateNewBoundingBox->setEnabled(true);
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_ImageNode->GetData());
if (image != nullptr)
{
vtkSmartPointer<vtkMatrix4x4> imageMat = image->GetGeometry()->GetVtkMatrix();
// check whether the image geometry is rotated, if so, no pixel aligned cropping or masking can be performed
if ((imageMat->GetElement(1, 0) == 0.0) && (imageMat->GetElement(0, 1) == 0.0) &&
(imageMat->GetElement(1, 2) == 0.0) && (imageMat->GetElement(2, 1) == 0.0) &&
(imageMat->GetElement(2, 0) == 0.0) && (imageMat->GetElement(0, 2) == 0.0))
{
rotationEnabled = false;
m_Controls.labelWarningRotation->setVisible(false);
}
else
{
rotationEnabled = true;
m_Controls.labelWarningRotation->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
m_Controls.labelWarningRotation->setVisible(true);
}
this->CreateBoundingShapeInteractor(rotationEnabled);
m_CroppingObjectNode = m_Controls.boundingShapeSelector->GetSelectedNode();
if (m_CroppingObjectNode != nullptr)
{
this->OnDataSelectionChanged(m_CroppingObjectNode);
m_BoundingShapeInteractor->EnableInteraction(true);
m_BoundingShapeInteractor->SetDataNode(this->m_CroppingObjectNode);
m_Controls.boundingShapeSelector->setEnabled(true);
}
if (image->GetPixelType().GetPixelType() == itk::ImageIOBase::SCALAR)
{
- // TODO: ImageStatistics Plugin? Min/Max Value?
- int minPixelValue = static_cast<int>(image->GetScalarValueMin());
+ // Might be changed with the upcoming new image statistics plugin
+ int minPixelValue = static_cast<int>(image->GetScalarValueMinNoRecompute());
//static_cast<int>image->GetStatistics()->GetScalarValueMinNoRecompute();
- int maxPixelValue = static_cast<int>(image->GetScalarValueMax());
+ int maxPixelValue = static_cast<int>(image->GetScalarValueMaxNoRecompute());
//static_cast<int>image->GetStatistics()->GetScalarValueMaxNoRecompute();
m_Controls.spinBox->setEnabled(true);
m_Controls.spinBox->setMaximum(maxPixelValue);
m_Controls.spinBox->setMinimum(minPixelValue);
m_Controls.spinBox->setValue(minPixelValue);
}
else
m_Controls.spinBox->setEnabled(false);
unsigned int dim = image->GetDimension();
if (dim < 2 || dim > 4)
{
m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
m_Controls.labelWarningImage->setText(QString::fromStdString("Select an image."));
m_ParentWidget->setEnabled(false);
}
if (m_CroppingObjectNode != nullptr)
{
m_Controls.buttonCropping->setEnabled(true);
m_Controls.buttonMasking->setEnabled(true);
m_Controls.boundingShapeSelector->setEnabled(true);
m_Controls.labelWarningBB->setVisible(false);
}
else
{
m_Controls.buttonCropping->setEnabled(false);
m_Controls.buttonMasking->setEnabled(false);
m_Controls.boundingShapeSelector->setEnabled(false);
m_Controls.labelWarningBB->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
m_Controls.labelWarningBB->setText(QString::fromStdString("Create a bounding shape below."));
}
return;
}
// iterate all selected objects, adjust warning visibility
m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
m_Controls.labelWarningImage->setText(QString::fromStdString("Select an image."));
m_Controls.buttonCropping->setEnabled(false);
m_Controls.buttonMasking->setEnabled(false);
m_Controls.buttonCreateNewBoundingBox->setEnabled(false);
m_Controls.boundingShapeSelector->setEnabled(false);
m_ParentWidget->setEnabled(true);
m_Controls.labelWarningRotation->setVisible(false);
}
}
}
void QmitkImageCropper::OnComboBoxSelectionChanged(const mitk::DataNode* node)
{
mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
if (selectedNode != nullptr)
{
if (m_ImageNode.IsNotNull())
selectedNode->SetDataInteractor(m_ImageNode->GetDataInteractor());
// m_ImageNode->GetDataInteractor()->SetDataNode(selectedNode);
m_ImageNode = selectedNode;
}
}
void QmitkImageCropper::OnSliderValueChanged(int slidervalue)
{
m_CropOutsideValue = slidervalue;
}
void QmitkImageCropper::DoMasking()
{
this->ProcessImage(true);
}
void QmitkImageCropper::DoCropping()
{
this->ProcessImage(false);
}
void QmitkImageCropper::ProcessImage(bool mask)
{
// cropping only possible if valid bounding shape as well as a valid image are loaded
QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
// to do: check whether stdmultiwidget is valid
int timeStep = mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))->GetTimeStep();
+
if (nodes.empty()) return;
mitk::DataNode* node = nodes[0];
if (node == nullptr)
{
QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
return;
}
if (m_CroppingObject == nullptr)
{
QMessageBox::information(nullptr, "Warning", "Please load and select a cropping object before starting image processing.");
return;
}
mitk::BaseData* data = node->GetData(); //get data from node
if (data != nullptr)
{
QString imageName;
if (mask)
imageName = QString::fromStdString(node->GetName() + "_masked");
else
imageName = QString::fromStdString(node->GetName() + "_cropped");
+ if (m_Controls.checkBoxCropTimeStepOnly->isChecked())
+ imageName = imageName + "_T" + QString::number(timeStep);
+
// image and bounding shape ok, set as input
auto croppedImageNode = mitk::DataNode::New();
auto cutter = mitk::BoundingShapeCropper::New();
cutter->SetGeometry(m_CroppingObject);
// adjustable in advanced settings
cutter->SetUseWholeInputRegion(mask); //either mask (mask=true) or crop (mask=false)
cutter->SetOutsideValue(m_CropOutsideValue);
cutter->SetUseCropTimeStepOnly(m_Controls.checkBoxCropTimeStepOnly->isChecked());
cutter->SetCurrentTimeStep(timeStep);
// TODO: Add support for MultiLayer (right now only Mulitlabel support)
mitk::LabelSetImage* labelsetImageInput = dynamic_cast<mitk::LabelSetImage*>(data);
if (labelsetImageInput != nullptr)
{
- cutter->SetInput(labelsetImageInput);
+ cutter->SetInput(labelsetImageInput);
// do the actual cutting
try
{
cutter->Update();
}
catch (const itk::ExceptionObject& e)
{
std::string message = std::string("The Cropping filter could not process because of: \n ") + e.GetDescription();
QMessageBox::warning(nullptr,
tr("Cropping not possible!"),
tr(message.c_str()),
QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
return;
}
auto labelSetImage = mitk::LabelSetImage::New();
labelSetImage->InitializeByLabeledImage(cutter->GetOutput());
for (int i = 0; i < labelsetImageInput->GetNumberOfLayers(); i++)
{
labelSetImage->AddLabelSetToLayer(i, labelsetImageInput->GetLabelSet(i));
}
croppedImageNode->SetData(labelSetImage);
croppedImageNode->SetProperty("name", mitk::StringProperty::New(imageName.toStdString()));
//add cropping result to the current data storage as child node to the image node
if (!m_Controls.checkOverwriteImage->isChecked())
{
if (!this->GetDataStorage()->Exists(croppedImageNode))
{
this->GetDataStorage()->Add(croppedImageNode, m_ImageNode);
}
}
else // original image will be overwritten by the result image and the bounding box of the result is adjusted
{
node->SetData(labelSetImage);
node->Modified();
// Adjust coordinate system by doing a reinit on
auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
tempDataStorage->InsertElement(0, node);
// initialize the views to the bounding geometry
mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
else
{
mitk::Image::Pointer imageInput = dynamic_cast<mitk::Image*>(data);
if (imageInput != nullptr)
{
cutter->SetInput(imageInput);
// do the actual cutting
try
{
cutter->Update();
}
catch (const itk::ExceptionObject& e)
{
std::string message = std::string("The Cropping filter could not process because of: \n ") + e.GetDescription();
QMessageBox::warning(nullptr,
tr("Cropping not possible!"),
tr(message.c_str()),
QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
return;
}
//add cropping result to the current data storage as child node to the image node
if (!m_Controls.checkOverwriteImage->isChecked())
{
croppedImageNode->SetData(cutter->GetOutput());
croppedImageNode->SetProperty("name", mitk::StringProperty::New(imageName.toStdString()));
- croppedImageNode->SetProperty("color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
- croppedImageNode->SetProperty("opacity", mitk::FloatProperty::New(0.4));
+ croppedImageNode->SetProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
croppedImageNode->SetProperty("layer", mitk::IntProperty::New(99)); // arbitrary, copied from segmentation functionality
if (!this->GetDataStorage()->Exists(croppedImageNode))
{
this->GetDataStorage()->Add(croppedImageNode, m_ImageNode);
}
}
else // original image will be overwritten by the result image and the bounding box of the result is adjusted
{
node->SetData(cutter->GetOutput());
node->Modified();
// Adjust coordinate system by doing a reinit on
auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
tempDataStorage->InsertElement(0, node);
// initialize the views to the bounding geometry
mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
}
else
{
QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
}
}
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/plugin.xml b/Plugins/org.mitk.gui.qt.multilabelsegmentation/plugin.xml
index c0d36be55e..3abf5b0e4e 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/plugin.xml
@@ -1,42 +1,44 @@
<?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.multilabelsegmentation"
name="MultiLabel Segmentation"
icon="resources/multilabelsegmentation.png"
class="QmitkMultiLabelSegmentationView" />
+<!-- Disabled due to most functions not working right now. See T22330
<view id="org.mitk.views.multilabelsegmentationutilities"
name="MultiLabel Segmentation Utilities"
class="QmitkMultiLabelSegmentationUtilitiesView"
icon="resources/MultiLabelSegmentationUtilities_48x48.png" />
+-->
</extension>
<extension point="org.blueberry.ui.preferencePages">
<page id="org.mitk.gui.qt.application.MultiLabelSegmentationPreferencePage" name="MultiLabel Segmentation" class="QmitkMultiLabelSegmentationPreferencePage">
<keywordreference id="org.mitk.gui.qt.application.MultiLabelSegmentationPreferencePageKeywords"></keywordreference>
</page>
</extension>
<extension point="org.blueberry.ui.keywords">
<keyword id="org.mitk.gui.qt.application.MultiLabelSegmentationPreferencePageKeywords" label="multi segmentation label multilabel multilabelsegmentation 2d display 3d outline draw transparent overlay show volume rendering data node selection mode enable auto-selection mode smoothed surface creation smoothing value decimation rate"></keyword>
</extension>
<extension point="org.mitk.gui.qt.datamanager.contextMenuActions">
<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="Autocrop" icon="" class="QmitkAutocropAction" />
<contextMenuAction nodeDescriptorName="ImageMask" label="Convert to Label" icon="" class="QmitkConvertMaskToLabelAction" />
<contextMenuAction nodeDescriptorName="Surface" label="Convert to Label" icon="" class="QmitkConvertSurfaceToLabelAction" />
<contextMenuAction nodeDescriptorName="Image" label="Create Segmentation" icon="" class="QmitkCreateMultiLabelSegmentationAction" />
<contextMenuAction nodeDescriptorName="Image" label="Convert to Segmentation" icon="" class="QmitkConvertToMultiLabelSegmentationAction" />
<contextMenuAction nodeDescriptorName="LabelSetImage" label="Create Preset" icon="" class="QmitkCreateMultiLabelPresetAction" />
<contextMenuAction nodeDescriptorName="LabelSetImage" label="Load Preset" icon="" class="QmitkLoadMultiLabelPresetAction" />
</extension>
</plugin>
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/BooleanOperations_48x48.png b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/BooleanOperations_48x48.png
index 27d28f9926..86c3262938 100644
Binary files a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/BooleanOperations_48x48.png and b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/BooleanOperations_48x48.png differ
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/Icons.svg b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/Icons.svg
index 2fd004fb64..c1eb90def4 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/Icons.svg
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/Icons.svg
@@ -1,3069 +1,3502 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="744.09448819"
height="1052.3622047"
id="svg2985"
version="1.1"
- inkscape:version="0.48.4 r9939"
+ inkscape:version="0.91 r13725"
sodipodi:docname="Icons.svg">
<sodipodi:namedview
id="base"
pagecolor="#ffffff"
bordercolor="#ffffff"
borderopacity="0.0"
inkscape:pageopacity="0.0"
inkscape:pageshadow="0"
- inkscape:zoom="8"
- inkscape:cx="-137.69045"
- inkscape:cy="-24.220797"
+ inkscape:zoom="1.4142135"
+ inkscape:cx="246.84648"
+ inkscape:cy="-150.51995"
inkscape:document-units="px"
- inkscape:current-layer="g4297-7"
+ inkscape:current-layer="g4191"
showgrid="false"
- inkscape:window-width="1920"
- inkscape:window-height="1018"
+ inkscape:window-width="2560"
+ inkscape:window-height="1377"
inkscape:window-x="-8"
inkscape:window-y="-8"
inkscape:window-maximized="1" />
<defs
id="defs2987">
<marker
style="overflow:visible"
id="TriangleInM"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInM">
<path
transform="scale(-0.4)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path4144" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutM"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutM">
<path
transform="scale(0.4)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path4153" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutS"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutS">
<path
transform="scale(0.2)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path4156" />
</marker>
<marker
style="overflow:visible;"
id="Arrow2Send"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="Arrow2Send">
<path
transform="scale(0.3) rotate(180) translate(-2.3,0)"
d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
style="fill-rule:evenodd;stroke-width:0.62500000;stroke-linejoin:round;"
id="path4041" />
</marker>
<marker
style="overflow:visible;"
id="Arrow1Send"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="Arrow1Send">
<path
transform="scale(0.2) rotate(180) translate(6,0)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;"
d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
id="path4023" />
</marker>
<marker
style="overflow:visible;"
id="Arrow1Lend"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="Arrow1Lend">
<path
transform="scale(0.8) rotate(180) translate(12.5,0)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;"
d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
id="path4011" />
</marker>
<linearGradient
id="linearGradient4088">
<stop
id="stop4090"
offset="0"
style="stop-color:#5987bf;stop-opacity:1;" />
<stop
id="stop4092"
offset="1"
style="stop-color:#7399c9;stop-opacity:1;" />
</linearGradient>
<linearGradient
id="linearGradient4072">
<stop
id="stop4074"
offset="0"
style="stop-color:#ffffff;stop-opacity:1;" />
<stop
id="stop4076"
offset="1"
style="stop-color:#d0d0d0;stop-opacity:1;" />
</linearGradient>
<radialGradient
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(1.1851902,1.2536729,-0.63371657,0.5990994,644.67638,376.10397)"
r="15.388403"
fy="1025.4568"
fx="27.931225"
cy="1025.4568"
cx="27.931225"
id="radialGradient4078"
xlink:href="#linearGradient4072"
inkscape:collect="always" />
<radialGradient
r="15.388403"
fy="1025.4568"
fx="27.931225"
cy="1025.4568"
cx="27.931225"
gradientTransform="matrix(1.1851902,1.2536729,-0.63371657,0.5990994,644.67638,376.10397)"
gradientUnits="userSpaceOnUse"
id="radialGradient4170"
xlink:href="#linearGradient4072"
inkscape:collect="always" />
<radialGradient
r="9.2674198"
fy="1025.1075"
fx="41.430496"
cy="1025.1075"
cx="41.430496"
gradientTransform="matrix(1,0,0,1.0441688,1.7301136,-46.291947)"
gradientUnits="userSpaceOnUse"
id="radialGradient4324"
xlink:href="#linearGradient4072"
inkscape:collect="always" />
<linearGradient
y2="1038.6952"
x2="26.321873"
y1="1042.3344"
x1="30.288902"
gradientUnits="userSpaceOnUse"
id="linearGradient4326"
xlink:href="#linearGradient4088"
inkscape:collect="always" />
<radialGradient
r="15.388403"
fy="1025.4568"
fx="27.931225"
cy="1025.4568"
cx="27.931225"
gradientTransform="matrix(1.1851902,1.2536729,-0.63371657,0.5990994,644.67638,376.10397)"
gradientUnits="userSpaceOnUse"
id="radialGradient4328"
xlink:href="#linearGradient4072"
inkscape:collect="always" />
<linearGradient
inkscape:collect="always"
xlink:href="#linearGradient4826"
id="linearGradient3095"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-0.70439223,-0.70981095,0.70981095,-0.70439223,-164.03247,785.42253)"
x1="83.578606"
y1="420.98395"
x2="74.169212"
y2="434.27652" />
<linearGradient
inkscape:collect="always"
xlink:href="#linearGradient5120"
id="linearGradient5143"
gradientUnits="userSpaceOnUse"
x1="61.28059"
y1="451.38803"
x2="50.8452"
y2="451.70779" />
<linearGradient
inkscape:collect="always"
xlink:href="#linearGradient5112"
id="linearGradient5141"
gradientUnits="userSpaceOnUse"
x1="70.3125"
y1="413.84039"
x2="66.868843"
y2="406.96539" />
<linearGradient
id="linearGradient4826">
<stop
style="stop-color:#f0a0a0;stop-opacity:1;"
offset="0"
id="stop4828" />
<stop
style="stop-color:#c86464;stop-opacity:0;"
offset="1"
id="stop4830" />
</linearGradient>
<inkscape:path-effect
effect="spiro"
id="path-effect4914"
is_visible="true" />
<linearGradient
id="linearGradient4928">
<stop
id="stop4930"
offset="0"
style="stop-color:#f0a0a0;stop-opacity:1;" />
<stop
id="stop4932"
offset="1"
style="stop-color:#f0a0a0;stop-opacity:1;" />
</linearGradient>
<inkscape:path-effect
effect="spiro"
id="path-effect4938"
is_visible="true" />
<inkscape:path-effect
effect="spiro"
id="path-effect5003"
is_visible="true" />
<inkscape:path-effect
effect="spiro"
id="path-effect5007"
is_visible="true" />
<inkscape:path-effect
effect="spiro"
id="path-effect5017"
is_visible="true" />
<linearGradient
id="linearGradient5112">
<stop
style="stop-color:#00adff;stop-opacity:1;"
offset="0"
id="stop5114" />
<stop
style="stop-color:#bfebff;stop-opacity:1;"
offset="1"
id="stop5116" />
</linearGradient>
<linearGradient
id="linearGradient5120">
<stop
style="stop-color:#00a6f4;stop-opacity:1;"
offset="0"
id="stop5122" />
<stop
style="stop-color:#00618e;stop-opacity:1;"
offset="1"
id="stop5124" />
</linearGradient>
<marker
style="overflow:visible"
id="TriangleOutM-1"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleOutM">
<path
transform="scale(0.4,0.4)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path4153-7"
inkscape:connector-curvature="0" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutM-0"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleOutM">
<path
transform="scale(0.4,0.4)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path4153-9"
inkscape:connector-curvature="0" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutM-8"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleOutM">
<path
transform="scale(0.4,0.4)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path4153-2"
inkscape:connector-curvature="0" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutM-5"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleOutM">
<path
transform="scale(0.4,0.4)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path4153-1"
inkscape:connector-curvature="0" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutM-11"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleOutM">
<path
transform="scale(0.4,0.4)"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path4153-5"
inkscape:connector-curvature="0" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMx"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMx">
<path
transform="scale(0.4)"
style="stroke:#00adff;stroke-width:1.0pt;fill:#00adff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5510" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMo"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMo">
<path
transform="scale(0.4)"
style="stroke:#00adff;stroke-width:1.0pt;fill:#00adff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5513" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMi"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMi">
<path
transform="scale(0.4)"
style="stroke:#00adff;stroke-width:1.0pt;fill:#00adff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5516" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMX"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMX">
<path
transform="scale(0.4)"
style="stroke:#00adff;stroke-width:1.0pt;fill:#00adff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5519" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMI"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMI">
<path
transform="scale(0.4)"
style="stroke:#00adff;stroke-width:1.0pt;fill:#00adff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5522" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMW"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMW">
<path
transform="scale(0.4)"
style="stroke:#00adff;stroke-width:1.0pt;fill:#00adff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5525" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMxc"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMxc">
<path
transform="scale(0.4)"
style="fill-rule:evenodd;stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path6105" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMoV"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMoV">
<path
transform="scale(0.4)"
style="fill-rule:evenodd;stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path6108" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMib"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMib">
<path
transform="scale(0.4)"
style="fill-rule:evenodd;stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path6111" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMXW"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMXW">
<path
transform="scale(0.4)"
style="fill-rule:evenodd;stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path6114" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMIc"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMIc">
<path
transform="scale(0.4)"
style="fill-rule:evenodd;stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path6117" />
</marker>
<marker
style="overflow:visible"
id="TriangleOutMWR"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleOutMWR">
<path
transform="scale(0.4)"
style="fill-rule:evenodd;stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path6120" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMt"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMt">
<path
transform="scale(-0.4)"
style="stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path7211" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMF"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMF">
<path
transform="scale(-0.4)"
style="stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path7214" />
</marker>
<marker
style="overflow:visible"
id="TriangleInM2"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInM2">
<path
transform="scale(-0.4)"
style="stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path7217" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMU"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMU">
<path
transform="scale(-0.4)"
style="stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path7220" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMf"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMf">
<path
transform="scale(-0.4)"
style="stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path7223" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMb"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMb">
<path
transform="scale(-0.4)"
style="stroke:#0064ff;stroke-width:1.0pt;fill:#0064ff;fill-rule:evenodd"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path7226" />
</marker>
<marker
inkscape:stockid="TriangleOutM"
orient="auto"
refY="0"
refX="0"
id="TriangleOutM-7"
style="overflow:visible">
<path
inkscape:connector-curvature="0"
id="path4153-6"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt"
transform="scale(0.4,0.4)" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMU-4"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleInMU">
<path
inkscape:connector-curvature="0"
transform="scale(-0.4,-0.4)"
style="fill:#0064ff;fill-rule:evenodd;stroke:#0064ff;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path7220-2" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMU-2"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleInMU">
<path
inkscape:connector-curvature="0"
transform="scale(-0.4,-0.4)"
style="fill:#0064ff;fill-rule:evenodd;stroke:#0064ff;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path7220-21" />
</marker>
<marker
style="overflow:visible"
id="marker7835"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleInMU">
<path
inkscape:connector-curvature="0"
transform="scale(-0.4,-0.4)"
style="fill:#0064ff;fill-rule:evenodd;stroke:#0064ff;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path7837" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMU-5"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleInMU">
<path
inkscape:connector-curvature="0"
transform="scale(-0.4,-0.4)"
style="fill:#0064ff;fill-rule:evenodd;stroke:#0064ff;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path7220-7" />
</marker>
<marker
style="overflow:visible"
id="marker7876"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleInMU">
<path
inkscape:connector-curvature="0"
transform="scale(-0.4,-0.4)"
style="fill:#0064ff;fill-rule:evenodd;stroke:#0064ff;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path7878" />
</marker>
<marker
style="overflow:visible"
id="marker7880"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleInMU">
<path
inkscape:connector-curvature="0"
transform="scale(-0.4,-0.4)"
style="fill:#0064ff;fill-rule:evenodd;stroke:#0064ff;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path7882" />
</marker>
<marker
style="overflow:visible"
id="marker7884"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="TriangleInMU">
<path
inkscape:connector-curvature="0"
transform="scale(-0.4,-0.4)"
style="fill:#0064ff;fill-rule:evenodd;stroke:#0064ff;stroke-width:1pt"
d="m 5.77,0 -8.65,5 0,-10 8.65,5 z"
id="path7886" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMUl"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMUl">
<path
transform="scale(-0.4)"
style="fill-rule:evenodd;stroke:#00adff;stroke-width:1.0pt;fill:#00adff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path4164" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMUX"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMUX">
<path
transform="scale(-0.4)"
style="fill-rule:evenodd;stroke:#00adff;stroke-width:1.0pt;fill:#00adff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path4167" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMUm"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMUm">
<path
transform="scale(-0.4)"
style="fill-rule:evenodd;stroke:#00adff;stroke-width:1.0pt;fill:#00adff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path4170" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMUF"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMUF">
<path
transform="scale(-0.4)"
style="fill-rule:evenodd;stroke:#00adff;stroke-width:1.0pt;fill:#00adff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path4173" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMUg"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMUg">
<path
transform="scale(-0.4)"
style="fill-rule:evenodd;stroke:#00adff;stroke-width:1.0pt;fill:#00adff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5644" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMUe"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMUe">
<path
transform="scale(-0.4)"
style="fill-rule:evenodd;stroke:#00adff;stroke-width:1.0pt;fill:#00adff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5647" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMUZ"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMUZ">
<path
transform="scale(-0.4)"
style="fill-rule:evenodd;stroke:#00adff;stroke-width:1.0pt;fill:#00adff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5650" />
</marker>
<marker
style="overflow:visible"
id="TriangleInMUt"
refX="0.0"
refY="0.0"
orient="auto"
inkscape:stockid="TriangleInMUt">
<path
transform="scale(-0.4)"
style="fill-rule:evenodd;stroke:#00adff;stroke-width:1.0pt;fill:#00adff"
d="M 5.77,0.0 L -2.88,5.0 L -2.88,-5.0 L 5.77,0.0 z "
id="path5653" />
</marker>
+ <filter
+ style="color-interpolation-filters:sRGB;"
+ inkscape:label="Drop Shadow"
+ id="filter5322">
+ <feFlood
+ flood-opacity="0.247059"
+ flood-color="rgb(0,0,0)"
+ result="flood"
+ id="feFlood5324" />
+ <feComposite
+ in="flood"
+ in2="SourceGraphic"
+ operator="in"
+ result="composite1"
+ id="feComposite5326" />
+ <feGaussianBlur
+ in="composite1"
+ stdDeviation="1"
+ result="blur"
+ id="feGaussianBlur5328" />
+ <feOffset
+ dx="2"
+ dy="-2"
+ result="offset"
+ id="feOffset5330" />
+ <feComposite
+ in="SourceGraphic"
+ in2="offset"
+ operator="over"
+ result="composite2"
+ id="feComposite5332" />
+ </filter>
+ <filter
+ style="color-interpolation-filters:sRGB;"
+ inkscape:label="Drop Shadow"
+ id="filter5647">
+ <feFlood
+ flood-opacity="0.247059"
+ flood-color="rgb(0,0,0)"
+ result="flood"
+ id="feFlood5649" />
+ <feComposite
+ in="flood"
+ in2="SourceGraphic"
+ operator="in"
+ result="composite1"
+ id="feComposite5651" />
+ <feGaussianBlur
+ in="composite1"
+ stdDeviation="1"
+ result="blur"
+ id="feGaussianBlur5653" />
+ <feOffset
+ dx="2"
+ dy="2"
+ result="offset"
+ id="feOffset5655" />
+ <feComposite
+ in="SourceGraphic"
+ in2="offset"
+ operator="over"
+ result="composite2"
+ id="feComposite5657" />
+ </filter>
</defs>
<metadata
id="metadata2990">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
</metadata>
<g
- sodipodi:insensitive="true"
style="display:inline"
inkscape:label="Boolean Operations"
id="layer2"
inkscape:groupmode="layer">
<g
- inkscape:export-ydpi="91.087982"
- inkscape:export-xdpi="91.087982"
- inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\boolean_48x48.png"
- transform="translate(-922.66699,114.10169)"
- id="g4197">
- <g
- id="g4126"
- transform="translate(49.125,0.0625)">
- <rect
- y="914.43219"
- x="873.54199"
- height="5.4800777"
- width="5.4800777"
- id="rect3005"
- style="fill:#999999;fill-opacity:1;stroke:none" />
- <rect
- y="914.43219"
- x="879.58081"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="914.43219"
- x="885.61963"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-7"
- style="fill:#d499a6;fill-opacity:1;stroke:none" />
- <rect
- y="914.43219"
- x="891.65845"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="914.43219"
- x="897.69727"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-9"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="920.56781"
- x="879.58081"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-4"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="920.56781"
- x="891.65845"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-8"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="920.56781"
- x="897.69727"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-82"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="920.56781"
- x="903.73608"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-45"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="926.70343"
- x="879.58081"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-5"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="926.70343"
- x="885.61963"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-1"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="926.70343"
- x="897.69727"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-7"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="926.70343"
- x="903.73608"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-11"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="932.83905"
- x="891.65845"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-52"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="932.83905"
- x="897.69727"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-76"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="932.83905"
- x="903.73608"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-14"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="926.70343"
- x="873.54199"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-2"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="926.70343"
- x="915.81372"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-3"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="932.83905"
- x="915.81372"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-22"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="920.56781"
- x="909.7749"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-1"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="914.43219"
- x="909.7749"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-6"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="920.56781"
- x="885.61963"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-8"
- style="fill:#e1d0da;fill-opacity:1;stroke:none" />
- <rect
- y="926.70343"
- x="891.65845"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-8-7"
- style="fill:#e1d0da;fill-opacity:1;stroke:none" />
- <rect
- y="932.83905"
- x="885.61963"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-8-6"
- style="fill:#e1d0da;fill-opacity:1;stroke:none" />
- <rect
- y="914.43219"
- x="903.73608"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-8-1"
- style="fill:#e1d0da;fill-opacity:1;stroke:none" />
- <rect
- y="920.56781"
- x="873.54199"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8"
- style="fill:#4d4d4d;fill-opacity:1;stroke:none" />
- <rect
- y="932.83905"
- x="873.54199"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-2"
- style="fill:#4d4d4d;fill-opacity:1;stroke:none" />
- <rect
- y="926.70343"
- x="909.7749"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-7"
- style="fill:#4d4d4d;fill-opacity:1;stroke:none" />
- <rect
- y="914.43219"
- x="915.81372"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-9"
- style="fill:#4d4d4d;fill-opacity:1;stroke:none" />
- <rect
- y="932.83905"
- x="879.58081"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-5"
- style="fill:#cf98a3;fill-opacity:1;stroke:none" />
- <rect
- y="932.83905"
- x="909.7749"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-5-3"
- style="fill:#cf98a3;fill-opacity:1;stroke:none" />
- <rect
- y="920.56781"
- x="915.81372"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-2"
- style="fill:#999999;fill-opacity:1;stroke:none" />
- </g>
+ style="display:inline"
+ id="g3213-9-6-2"
+ transform="translate(-44.937494,-29.374988)"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\BooleanOperations_48x48.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90">
+ <rect
+ style="fill:#999999;fill-opacity:1;stroke:none"
+ id="rect3005-74-4-7-0"
+ width="5.4800777"
+ height="5.4800777"
+ x="47.999092"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-0-8-3-1"
+ width="5.4800777"
+ height="5.4800777"
+ x="54.03791"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#e991a6;fill-opacity:1;stroke:none"
+ id="rect3005-7-9-8-9-7"
+ width="5.4800777"
+ height="5.4800777"
+ x="60.076729"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-48-2-7-2"
+ width="5.4800777"
+ height="5.4800777"
+ x="66.115547"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-9-8-4-2-4"
+ width="5.4800777"
+ height="5.4800777"
+ x="72.154366"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#e991a6;fill-opacity:1;stroke:none"
+ id="rect3005-4-4-2-5-9-0"
+ width="5.4800777"
+ height="5.4800777"
+ x="54.03791"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-8-4-5-55-1"
+ width="5.4800777"
+ height="5.4800777"
+ x="66.115547"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-82-5-1-0-4"
+ width="5.4800777"
+ height="5.4800777"
+ x="72.154366"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-45-5-7-0-0"
+ width="5.4800777"
+ height="5.4800777"
+ x="78.193184"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-5-1-1-3-6"
+ width="5.4800777"
+ height="5.4800777"
+ x="54.03791"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-1-7-1-8-7"
+ width="5.4800777"
+ height="5.4800777"
+ x="60.076729"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-7-1-5-8-9"
+ width="5.4800777"
+ height="5.4800777"
+ x="72.154366"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-11-1-2-0-4"
+ width="5.4800777"
+ height="5.4800777"
+ x="78.193184"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-52-5-7-1-5"
+ width="5.4800777"
+ height="5.4800777"
+ x="66.115547"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-76-2-6-5-1"
+ width="5.4800777"
+ height="5.4800777"
+ x="72.154366"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-14-7-1-1-6"
+ width="5.4800777"
+ height="5.4800777"
+ x="78.193184"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-2-6-4-0-8"
+ width="5.4800777"
+ height="5.4800777"
+ x="47.999092"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-3-1-2-6-6"
+ width="5.4800777"
+ height="5.4800777"
+ x="90.270821"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-22-4-3-4-1"
+ width="5.4800777"
+ height="5.4800777"
+ x="90.270821"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-1-2-2-2-3"
+ width="5.4800777"
+ height="5.4800777"
+ x="84.232002"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-6-3-2-9-6"
+ width="5.4800777"
+ height="5.4800777"
+ x="84.232002"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-1-8-2-1-79-5"
+ width="5.4800777"
+ height="5.4800777"
+ x="60.076729"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-1-8-7-2-6-4-7"
+ width="5.4800777"
+ height="5.4800777"
+ x="66.115547"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-1-8-6-1-8-8-9"
+ width="5.4800777"
+ height="5.4800777"
+ x="60.076729"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#9fcde2;fill-opacity:1;stroke:none"
+ id="rect3005-1-8-1-6-5-6-6"
+ width="5.4800777"
+ height="5.4800777"
+ x="78.193184"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#4d4d4d;fill-opacity:1;stroke:none"
+ id="rect3005-8-8-7-5-8"
+ width="5.4800777"
+ height="5.4800777"
+ x="47.999092"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#4d4d4d;fill-opacity:1;stroke:none"
+ id="rect3005-8-2-5-6-8-6"
+ width="5.4800777"
+ height="5.4800777"
+ x="47.999092"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#4d4d4d;fill-opacity:1;stroke:none"
+ id="rect3005-8-7-7-1-0-9"
+ width="5.4800777"
+ height="5.4800777"
+ x="84.232002"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#4d4d4d;fill-opacity:1;stroke:none"
+ id="rect3005-8-9-6-8-5-5"
+ width="5.4800777"
+ height="5.4800777"
+ x="90.270821"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-8-5-1-9-4-1"
+ width="5.4800777"
+ height="5.4800777"
+ x="54.03791"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#9fcde2;fill-opacity:1;stroke:none"
+ id="rect3005-8-5-3-8-2-6-8"
+ width="5.4800777"
+ height="5.4800777"
+ x="84.232002"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#999999;fill-opacity:1;stroke:none"
+ id="rect3005-2-9-7-4-2"
+ width="5.4800777"
+ height="5.4800777"
+ x="90.270821"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ </g>
+ <g
+ inkscape:export-ydpi="90"
+ inkscape:export-xdpi="90"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\BooleanOperations_48x48.png"
+ transform="matrix(0.70391111,0,0,0.70391111,-637.47636,396.77122)"
+ id="g4197"
+ style="fill:#00adff;fill-opacity:1">
<g
- id="g4191">
+ id="g4191"
+ style="fill:#00adff;fill-opacity:1;filter:url(#filter5647)"
+ transform="translate(-12.638594,-5.9299745)">
<text
sodipodi:linespacing="125%"
id="text4160"
- y="905.98718"
- x="922.875"
- style="font-size:22px;font-style:normal;font-weight:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#00afdc;fill-opacity:1;stroke:none;font-family:Sans"
- xml:space="preserve"><tspan
+ y="902.84796"
+ x="924.8374"
+ style="font-style:normal;font-weight:normal;font-size:14.94364452px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#00adff;fill-opacity:1;stroke:none"
+ xml:space="preserve"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\BooleanOperations_48x48.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90"><tspan
dx="0"
- style="font-size:21px;font-weight:bold;letter-spacing:-0.99000007px;-inkscape-font-specification:Sans Bold"
+ style="font-weight:bold;font-size:14.26438808px;-inkscape-font-specification:'Sans Bold';letter-spacing:-0.67246401px;fill:#00adff;fill-opacity:1"
id="tspan4164"
- y="905.98718"
- x="922.875"
+ y="902.84796"
+ x="924.8374"
sodipodi:role="line">AND</tspan></text>
<text
sodipodi:linespacing="125%"
id="text4160-3"
- y="922.48621"
- x="939.82056"
- style="font-size:20px;font-style:normal;font-weight:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#00afdc;fill-opacity:1;stroke:none;font-family:Sans"
- xml:space="preserve"><tspan
- style="font-size:21px;font-weight:bold;letter-spacing:-0.99000007px;-inkscape-font-specification:Sans Bold"
+ y="903.00098"
+ x="960.38025"
+ style="font-style:normal;font-weight:normal;font-size:13.49872208px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#bf264a;fill-opacity:1;stroke:none"
+ xml:space="preserve"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\BooleanOperations_48x48.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90"><tspan
+ style="font-weight:bold;font-size:14.17365837px;-inkscape-font-specification:'Sans Bold';letter-spacing:-0.66818678px;fill:#bf264a;fill-opacity:1"
id="tspan4164-3"
- y="922.48621"
- x="939.82056"
+ y="903.00098"
+ x="960.38025"
sodipodi:role="line">OR</tspan></text>
</g>
</g>
- </g>
- <g
- sodipodi:insensitive="true"
- inkscape:label="Segmentation Utilities"
- id="layer1"
- inkscape:groupmode="layer">
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;display:inline;fill:#bf264a;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="2.000154"
+ y="1018.2798"
+ id="text4859-4-0"
+ sodipodi:linespacing="125%"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\BooleanOperations_48x48.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90"><tspan
+ sodipodi:role="line"
+ id="tspan4861-1-0"
+ x="2.000154"
+ y="1018.2798"
+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:19.375px;font-family:'Roboto Condensed';-inkscape-font-specification:'Roboto Condensed, Bold';fill:#bf264a;fill-opacity:1">MULTI</tspan></text>
+ <rect
+ style="fill:#00adff;fill-opacity:0;stroke:none;stroke-width:3;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+ id="rect5677"
+ width="47.875"
+ height="47.875004"
+ x="3.0000005"
+ y="1005.0497"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\BooleanOperations_48x48.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ </g>
+ <g
+ inkscape:label="Segmentation Utilities"
+ id="layer1"
+ inkscape:groupmode="layer">
+ <g
+ style="display:inline"
+ id="g3213-9-6"
+ transform="translate(-98.45001,-29.221517)"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\MultiLabelSegmentationUtilities_48x48.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90">
+ <rect
+ style="fill:#999999;fill-opacity:1;stroke:none"
+ id="rect3005-74-4-7"
+ width="5.4800777"
+ height="5.4800777"
+ x="47.999092"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-0-8-3"
+ width="5.4800777"
+ height="5.4800777"
+ x="54.03791"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#e991a6;fill-opacity:1;stroke:none"
+ id="rect3005-7-9-8-9"
+ width="5.4800777"
+ height="5.4800777"
+ x="60.076729"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-48-2-7"
+ width="5.4800777"
+ height="5.4800777"
+ x="66.115547"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-9-8-4-2"
+ width="5.4800777"
+ height="5.4800777"
+ x="72.154366"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#e991a6;fill-opacity:1;stroke:none"
+ id="rect3005-4-4-2-5-9"
+ width="5.4800777"
+ height="5.4800777"
+ x="54.03791"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-8-4-5-55"
+ width="5.4800777"
+ height="5.4800777"
+ x="66.115547"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-82-5-1-0"
+ width="5.4800777"
+ height="5.4800777"
+ x="72.154366"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-45-5-7-0"
+ width="5.4800777"
+ height="5.4800777"
+ x="78.193184"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-5-1-1-3"
+ width="5.4800777"
+ height="5.4800777"
+ x="54.03791"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-1-7-1-8"
+ width="5.4800777"
+ height="5.4800777"
+ x="60.076729"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-7-1-5-8"
+ width="5.4800777"
+ height="5.4800777"
+ x="72.154366"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-11-1-2-0"
+ width="5.4800777"
+ height="5.4800777"
+ x="78.193184"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-4-52-5-7-1"
+ width="5.4800777"
+ height="5.4800777"
+ x="66.115547"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-76-2-6-5"
+ width="5.4800777"
+ height="5.4800777"
+ x="72.154366"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
+ id="rect3005-4-14-7-1-1"
+ width="5.4800777"
+ height="5.4800777"
+ x="78.193184"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-2-6-4-0"
+ width="5.4800777"
+ height="5.4800777"
+ x="47.999092"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-3-1-2-6"
+ width="5.4800777"
+ height="5.4800777"
+ x="90.270821"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-22-4-3-4"
+ width="5.4800777"
+ height="5.4800777"
+ x="90.270821"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-1-2-2-2"
+ width="5.4800777"
+ height="5.4800777"
+ x="84.232002"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#b3b3b3;fill-opacity:1;stroke:none"
+ id="rect3005-1-6-3-2-9"
+ width="5.4800777"
+ height="5.4800777"
+ x="84.232002"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-1-8-2-1-79"
+ width="5.4800777"
+ height="5.4800777"
+ x="60.076729"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-1-8-7-2-6-4"
+ width="5.4800777"
+ height="5.4800777"
+ x="66.115547"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-1-8-6-1-8-8"
+ width="5.4800777"
+ height="5.4800777"
+ x="60.076729"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#9fcde2;fill-opacity:1;stroke:none"
+ id="rect3005-1-8-1-6-5-6"
+ width="5.4800777"
+ height="5.4800777"
+ x="78.193184"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#4d4d4d;fill-opacity:1;stroke:none"
+ id="rect3005-8-8-7-5"
+ width="5.4800777"
+ height="5.4800777"
+ x="47.999092"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#4d4d4d;fill-opacity:1;stroke:none"
+ id="rect3005-8-2-5-6-8"
+ width="5.4800777"
+ height="5.4800777"
+ x="47.999092"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#4d4d4d;fill-opacity:1;stroke:none"
+ id="rect3005-8-7-7-1-0"
+ width="5.4800777"
+ height="5.4800777"
+ x="84.232002"
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#4d4d4d;fill-opacity:1;stroke:none"
+ id="rect3005-8-9-6-8-5"
+ width="5.4800777"
+ height="5.4800777"
+ x="90.270821"
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
+ id="rect3005-8-5-1-9-4"
+ width="5.4800777"
+ height="5.4800777"
+ x="54.03791"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#9fcde2;fill-opacity:1;stroke:none"
+ id="rect3005-8-5-3-8-2-6"
+ width="5.4800777"
+ height="5.4800777"
+ x="84.232002"
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ style="fill:#999999;fill-opacity:1;stroke:none"
+ id="rect3005-2-9-7-4"
+ width="5.4800777"
+ height="5.4800777"
+ x="90.270821"
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ </g>
<g
inkscape:export-ydpi="90.470001"
inkscape:export-xdpi="90.470001"
- inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\SegmentationUtilities_48x48.png"
- transform="translate(-57.851365,-13.716184)"
- id="g4285">
- <g
- transform="translate(-43.125,-15.75)"
- id="g3213"
- style="display:inline">
- <rect
- y="1058.4187"
- x="47.999092"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-74"
- style="fill:#999999;fill-opacity:1;stroke:none" />
- <rect
- y="1058.4187"
- x="54.03791"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-0"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="1058.4187"
- x="60.076729"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-7-9"
- style="fill:#d499a6;fill-opacity:1;stroke:none" />
- <rect
- y="1058.4187"
- x="66.115547"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-48"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1058.4187"
- x="72.154366"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-9-8"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1064.5543"
- x="54.03791"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-4-2"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1064.5543"
- x="66.115547"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-8-4"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1064.5543"
- x="72.154366"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-82-5"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1064.5543"
- x="78.193184"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-45-5"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1070.6899"
- x="54.03791"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-5-1"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1070.6899"
- x="60.076729"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-1-7"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1070.6899"
- x="72.154366"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-7-1"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1070.6899"
- x="78.193184"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-11-1"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1076.8256"
- x="66.115547"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-52-5"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1076.8256"
- x="72.154366"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-76-2"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1076.8256"
- x="78.193184"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-4-14-7"
- style="fill:#bf264b;fill-opacity:1;stroke:none" />
- <rect
- y="1070.6899"
- x="47.999092"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-2-6"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="1070.6899"
- x="90.270821"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-3-1"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="1076.8256"
- x="90.270821"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-22-4"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="1064.5543"
- x="84.232002"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-1-2"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="1058.4187"
- x="84.232002"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-6-3"
- style="fill:#b3b3b3;fill-opacity:1;stroke:none" />
- <rect
- y="1064.5543"
- x="60.076729"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-8-2"
- style="fill:#e1d0da;fill-opacity:1;stroke:none" />
- <rect
- y="1070.6899"
- x="66.115547"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-8-7-2"
- style="fill:#e1d0da;fill-opacity:1;stroke:none" />
- <rect
- y="1076.8256"
- x="60.076729"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-8-6-1"
- style="fill:#e1d0da;fill-opacity:1;stroke:none" />
- <rect
- y="1058.4187"
- x="78.193184"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-1-8-1-6"
- style="fill:#e1d0da;fill-opacity:1;stroke:none" />
- <rect
- y="1064.5543"
- x="47.999092"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-8"
- style="fill:#4d4d4d;fill-opacity:1;stroke:none" />
- <rect
- y="1076.8256"
- x="47.999092"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-2-5"
- style="fill:#4d4d4d;fill-opacity:1;stroke:none" />
- <rect
- y="1070.6899"
- x="84.232002"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-7-7"
- style="fill:#4d4d4d;fill-opacity:1;stroke:none" />
- <rect
- y="1058.4187"
- x="90.270821"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-9-6"
- style="fill:#4d4d4d;fill-opacity:1;stroke:none" />
- <rect
- y="1076.8256"
- x="54.03791"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-5-1"
- style="fill:#cf98a3;fill-opacity:1;stroke:none" />
- <rect
- y="1076.8256"
- x="84.232002"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-8-5-3-8"
- style="fill:#cf98a3;fill-opacity:1;stroke:none" />
- <rect
- y="1064.5543"
- x="90.270821"
- height="5.4800777"
- width="5.4800777"
- id="rect3005-2-9"
- style="fill:#999999;fill-opacity:1;stroke:none" />
- </g>
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\MultiLabelSegmentationUtilities_48x48.png"
+ transform="translate(-58.226365,-3.6536836)"
+ id="g4285"
+ style="filter:url(#filter5322)">
<g
transform="translate(-0.23863636,4.2386364)"
id="g4280">
<path
sodipodi:nodetypes="ccccccccc"
inkscape:connector-curvature="0"
id="path4052"
d="m 34.24319,1031.4717 8.747098,-8.5733 -0.05204,-2.9235 5.054758,-5.2082 4.085023,3.7843 -5.303659,5.7251 -2.41443,0.092 -8.683803,8.8731 z"
- style="fill:url(#radialGradient4324);fill-opacity:1;stroke:#797b7b;stroke-width:0.69999999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+ style="fill:url(#radialGradient4324);fill-opacity:1;stroke:#797b7b;stroke-width:0.69999999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
<path
sodipodi:nodetypes="ssccss"
inkscape:connector-curvature="0"
id="path4050"
d="m 19.70767,1047.6527 c -1.846592,-1.8185 -1.043705,-4.3471 0.596591,-6.2643 1.640296,-1.9172 10.738637,-10.5596 10.738637,-10.5596 l 4.892045,5.1307 c 0,0 -8.378356,9.6654 -9.545454,11.1562 -1.54887,1.9785 -4.835227,2.3555 -6.681819,0.537 z"
- style="fill:url(#linearGradient4326);fill-opacity:1;stroke:#50718c;stroke-width:0.69999999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+ style="fill:url(#linearGradient4326);fill-opacity:1;stroke:#50718c;stroke-width:0.69999999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
<path
- style="fill:url(#radialGradient4328);fill-opacity:1;stroke:#797b7b;stroke-width:0.69999999;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ style="fill:url(#radialGradient4328);fill-opacity:1;stroke:#797b7b;stroke-width:0.69999999;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
d="m 46.855397,1040.1669 c 4.488776,4.7242 0.778133,8.5155 -4.125,3.5 -4.903132,-5.0155 -13.375,-14.125 -13.375,-14.125 -10.133107,1.6369 -10.676747,-2.9634 -10.541192,-6.8466 0.08814,-2.525 2.091948,-2.329 2.791193,0.2216 1.904554,6.9471 11.320358,-1.2275 4.374999,-4.25 -1.946512,-0.8471 -2.069672,-2.6063 0,-2.625 3.838646,-0.035 7.576804,0.7182 7.75,10 0,0 8.636225,9.4008 13.125,14.125 z"
id="path3280"
inkscape:connector-curvature="0"
sodipodi:nodetypes="zzcsssscz" />
</g>
</g>
+ <rect
+ style="fill:#e2dc9f;fill-opacity:0;stroke:none;stroke-width:3;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+ id="rect5382"
+ width="47.84375"
+ height="47.84375"
+ x="-50.500004"
+ y="1005.1122"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\MultiLabelSegmentationUtilities_48x48.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
</g>
<g
- sodipodi:insensitive="true"
inkscape:label="Segmentation"
id="layer4"
- inkscape:groupmode="layer">
+ inkscape:groupmode="layer"
+ style="display:inline">
<g
inkscape:export-ydpi="90.470001"
inkscape:export-xdpi="90.470001"
- inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\segmentation.png"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
transform="translate(43.909091,9.0681818)"
id="g4075">
<g
style="display:inline"
id="g3213-9"
transform="translate(-198.35226,-38.284079)">
<rect
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-74-4"
width="5.4800777"
height="5.4800777"
x="47.999092"
- y="1058.4187" />
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#b3b3b3;fill-opacity:1;stroke:none"
id="rect3005-1-0-8"
width="5.4800777"
height="5.4800777"
x="54.03791"
- y="1058.4187" />
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#d499a6;fill-opacity:1;stroke:none"
+ style="fill:#e991a6;fill-opacity:1;stroke:none"
id="rect3005-7-9-8"
width="5.4800777"
height="5.4800777"
x="60.076729"
- y="1058.4187" />
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
id="rect3005-4-48-2"
width="5.4800777"
height="5.4800777"
x="66.115547"
- y="1058.4187" />
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
id="rect3005-4-9-8-4"
width="5.4800777"
height="5.4800777"
x="72.154366"
- y="1058.4187" />
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#e991a6;fill-opacity:1;stroke:none"
id="rect3005-4-4-2-5"
width="5.4800777"
height="5.4800777"
x="54.03791"
- y="1064.5543" />
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
id="rect3005-4-8-4-5"
width="5.4800777"
height="5.4800777"
x="66.115547"
- y="1064.5543" />
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
id="rect3005-4-82-5-1"
width="5.4800777"
height="5.4800777"
x="72.154366"
- y="1064.5543" />
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
id="rect3005-4-45-5-7"
width="5.4800777"
height="5.4800777"
x="78.193184"
- y="1064.5543" />
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
id="rect3005-4-5-1-1"
width="5.4800777"
height="5.4800777"
x="54.03791"
- y="1070.6899" />
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
id="rect3005-4-1-7-1"
width="5.4800777"
height="5.4800777"
x="60.076729"
- y="1070.6899" />
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
id="rect3005-4-7-1-5"
width="5.4800777"
height="5.4800777"
x="72.154366"
- y="1070.6899" />
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
id="rect3005-4-11-1-2"
width="5.4800777"
height="5.4800777"
x="78.193184"
- y="1070.6899" />
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
id="rect3005-4-52-5-7"
width="5.4800777"
height="5.4800777"
x="66.115547"
- y="1076.8256" />
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
id="rect3005-4-76-2-6"
width="5.4800777"
height="5.4800777"
x="72.154366"
- y="1076.8256" />
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#bf264b;fill-opacity:1;stroke:none"
+ style="fill:#73b6d5;fill-opacity:1;stroke:none"
id="rect3005-4-14-7-1"
width="5.4800777"
height="5.4800777"
x="78.193184"
- y="1076.8256" />
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#b3b3b3;fill-opacity:1;stroke:none"
id="rect3005-1-2-6-4"
width="5.4800777"
height="5.4800777"
x="47.999092"
- y="1070.6899" />
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#b3b3b3;fill-opacity:1;stroke:none"
id="rect3005-1-3-1-2"
width="5.4800777"
height="5.4800777"
x="90.270821"
- y="1070.6899" />
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#b3b3b3;fill-opacity:1;stroke:none"
id="rect3005-1-22-4-3"
width="5.4800777"
height="5.4800777"
x="90.270821"
- y="1076.8256" />
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#b3b3b3;fill-opacity:1;stroke:none"
id="rect3005-1-1-2-2"
width="5.4800777"
height="5.4800777"
x="84.232002"
- y="1064.5543" />
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#b3b3b3;fill-opacity:1;stroke:none"
id="rect3005-1-6-3-2"
width="5.4800777"
height="5.4800777"
x="84.232002"
- y="1058.4187" />
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#e1d0da;fill-opacity:1;stroke:none"
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
id="rect3005-1-8-2-1"
width="5.4800777"
height="5.4800777"
x="60.076729"
- y="1064.5543" />
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#e1d0da;fill-opacity:1;stroke:none"
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
id="rect3005-1-8-7-2-6"
width="5.4800777"
height="5.4800777"
x="66.115547"
- y="1070.6899" />
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#e1d0da;fill-opacity:1;stroke:none"
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
id="rect3005-1-8-6-1-8"
width="5.4800777"
height="5.4800777"
x="60.076729"
- y="1076.8256" />
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#e1d0da;fill-opacity:1;stroke:none"
+ style="fill:#9fcde2;fill-opacity:1;stroke:none"
id="rect3005-1-8-1-6-5"
width="5.4800777"
height="5.4800777"
x="78.193184"
- y="1058.4187" />
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#4d4d4d;fill-opacity:1;stroke:none"
id="rect3005-8-8-7"
width="5.4800777"
height="5.4800777"
x="47.999092"
- y="1064.5543" />
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#4d4d4d;fill-opacity:1;stroke:none"
id="rect3005-8-2-5-6"
width="5.4800777"
height="5.4800777"
x="47.999092"
- y="1076.8256" />
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#4d4d4d;fill-opacity:1;stroke:none"
id="rect3005-8-7-7-1"
width="5.4800777"
height="5.4800777"
x="84.232002"
- y="1070.6899" />
+ y="1070.6899"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#4d4d4d;fill-opacity:1;stroke:none"
id="rect3005-8-9-6-8"
width="5.4800777"
height="5.4800777"
x="90.270821"
- y="1058.4187" />
+ y="1058.4187"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#cf98a3;fill-opacity:1;stroke:none"
+ style="fill:#de5a7a;fill-opacity:1;stroke:none"
id="rect3005-8-5-1-9"
width="5.4800777"
height="5.4800777"
x="54.03791"
- y="1076.8256" />
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
- style="fill:#cf98a3;fill-opacity:1;stroke:none"
+ style="fill:#9fcde2;fill-opacity:1;stroke:none"
id="rect3005-8-5-3-8-2"
width="5.4800777"
height="5.4800777"
x="84.232002"
- y="1076.8256" />
+ y="1076.8256"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
<rect
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-2-9-7"
width="5.4800777"
height="5.4800777"
x="90.270821"
- y="1064.5543" />
+ y="1064.5543"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
</g>
<g
inkscape:label="Add"
id="layer3"
transform="matrix(1.7960075,0,0,1.7960075,-176.17936,-805.38135)"
- style="stroke-width:0.89086491;stroke-miterlimit:4;stroke-dasharray:none">
+ style="stroke:#00adff;stroke-width:0.89086491;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90">
<g
transform="translate(-178.3781,580.55863)"
id="g4949"
- style="stroke-width:0.89086491;stroke-miterlimit:4;stroke-dasharray:none">
+ style="stroke:#00adff;stroke-width:0.89086491;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1">
<g
id="g3125"
- style="stroke-width:0.89086491;stroke-miterlimit:4;stroke-dasharray:none">
+ style="stroke:#00adff;stroke-width:0.89086491;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1">
<path
sodipodi:nodetypes="aaaaa"
inkscape:connector-curvature="0"
id="path3004"
d="m 204.375,433.36218 c 2.66059,2.30475 8.06002,1.41215 10.5,-1.125 1.70795,-1.77597 2.30703,-5.69994 0.5,-7.375 -2.77871,-2.57579 -8.82218,-1.28388 -11.25,1.625 -1.4694,1.76055 -1.48328,5.37353 0.25,6.875 z"
- style="fill:none;stroke:#00adff;stroke-width:1.67037165;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+ style="fill:none;stroke:#00adff;stroke-width:1.67037165;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
<path
sodipodi:nodetypes="cc"
inkscape:connector-curvature="0"
id="path3774"
d="m 199.875,443.36218 c 6.84332,-2.29563 3.78655,-5.82877 5.625,-8.75"
- style="fill:none;stroke:#00adff;stroke-width:1.67037165;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
- <path
+ style="fill:none;stroke:#00adff;stroke-width:1.67037165;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+ <circle
transform="matrix(1.7077889,0.59262847,-0.4791464,1.3807655,-23.440489,-258.11706)"
- d="m 247,396.11218 c 0,0.89747 -0.72754,1.625 -1.625,1.625 -0.89746,0 -1.625,-0.72753 -1.625,-1.625 0,-0.89746 0.72754,-1.625 1.625,-1.625 0.89746,0 1.625,0.72754 1.625,1.625 z"
- sodipodi:ry="1.625"
- sodipodi:rx="1.625"
- sodipodi:cy="396.11218"
- sodipodi:cx="245.375"
id="path3776"
- style="fill:#00adff;fill-opacity:1;stroke:none"
- sodipodi:type="arc" />
+ style="fill:#00adff;fill-opacity:1;stroke:#00adff;stroke-opacity:1"
+ cx="245.375"
+ cy="396.11218"
+ r="1.625" />
</g>
</g>
</g>
</g>
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#bf264a;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="-107.10523"
+ y="1021.035"
+ id="text4859"
+ sodipodi:linespacing="125%"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\multilabelsegmentation.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90"><tspan
+ sodipodi:role="line"
+ id="tspan4861"
+ x="-107.10523"
+ y="1021.035"
+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:19.375px;font-family:'Roboto Condensed';-inkscape-font-specification:'Roboto Condensed, Bold';fill:#bf264a;fill-opacity:1">MULTI</tspan></text>
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;display:inline;fill:#bf264a;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="-51.062347"
+ y="1020.8423"
+ id="text4859-4"
+ sodipodi:linespacing="125%"
+ inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.multilabelsegmentation\resources\MultiLabelSegmentationUtilities_48x48.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90"><tspan
+ sodipodi:role="line"
+ id="tspan4861-1"
+ x="-51.062347"
+ y="1020.8423"
+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:19.375px;font-family:'Roboto Condensed';-inkscape-font-specification:'Roboto Condensed, Bold';fill:#bf264a;fill-opacity:1">MULTI</tspan></text>
</g>
<g
inkscape:label="Image Masking"
id="layer5"
inkscape:groupmode="layer"
- sodipodi:insensitive="true">
+ sodipodi:insensitive="true"
+ style="display:inline">
<g
transform="translate(-1.1869722,0.39565741)"
inkscape:export-ydpi="89.07"
inkscape:export-xdpi="89.07"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\ImageMasking_48x48.png"
id="g4347">
<g
id="g4297"
style="fill:#d2d2d2;fill-opacity:1">
<rect
y="1029.8"
x="-160.56647"
height="5.4800777"
width="5.4800777"
id="rect3005-74-4-6"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1029.8"
x="-154.39507"
height="5.4800777"
width="5.4800777"
id="rect3005-1-0-8-0"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1035.9357"
x="-154.39507"
height="5.4800777"
width="5.4800777"
id="rect3005-4-4-2-5-7"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1042.0714"
x="-154.39507"
height="5.4800777"
width="5.4800777"
id="rect3005-4-5-1-1-2"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1042.0714"
x="-148.09108"
height="5.4800777"
width="5.4800777"
id="rect3005-4-1-7-1-0"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1042.0714"
x="-136.01344"
height="5.4800777"
width="5.4800777"
id="rect3005-4-7-1-5-0"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1042.0714"
x="-129.97462"
height="5.4800777"
width="5.4800777"
id="rect3005-4-11-1-2-1"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1048.2069"
x="-142.05226"
height="5.4800777"
width="5.4800777"
id="rect3005-4-52-5-7-4"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1048.2069"
x="-136.01344"
height="5.4800777"
width="5.4800777"
id="rect3005-4-76-2-6-6"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1048.2069"
x="-129.97462"
height="5.4800777"
width="5.4800777"
id="rect3005-4-14-7-1-0"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1042.0714"
x="-160.56647"
height="5.4800777"
width="5.4800777"
id="rect3005-1-2-6-4-7"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1042.0714"
x="-117.54343"
height="5.4800777"
width="5.4800777"
id="rect3005-1-3-1-2-1"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1048.2069"
x="-117.54343"
height="5.4800777"
width="5.4800777"
id="rect3005-1-22-4-3-7"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1035.9357"
x="-123.71484"
height="5.4800777"
width="5.4800777"
id="rect3005-1-1-2-2-7"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1029.8"
x="-123.71484"
height="5.4800777"
width="5.4800777"
id="rect3005-1-6-3-2-7"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1042.0714"
x="-142.05226"
height="5.4800777"
width="5.4800777"
id="rect3005-1-8-7-2-6-3"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1048.2069"
x="-148.09108"
height="5.4800777"
width="5.4800777"
id="rect3005-1-8-6-1-8-3"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1035.9357"
x="-160.56647"
height="5.4800777"
width="5.4800777"
id="rect3005-8-8-7-9"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1048.2069"
x="-160.56647"
height="5.4800777"
width="5.4800777"
id="rect3005-8-2-5-6-9"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1042.0714"
x="-123.71484"
height="5.4800777"
width="5.4800777"
id="rect3005-8-7-7-1-8"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1029.8"
x="-117.54343"
height="5.4800777"
width="5.4800777"
id="rect3005-8-9-6-8-1"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1048.2069"
x="-154.39507"
height="5.4800777"
width="5.4800777"
id="rect3005-8-5-1-9-8"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1048.2069"
x="-123.71484"
height="5.4800777"
width="5.4800777"
id="rect3005-8-5-3-8-2-2"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="1035.9357"
x="-117.54343"
height="5.4800777"
width="5.4800777"
id="rect3005-2-9-7-6"
style="fill:#d2d2d2;fill-opacity:1;stroke:none" />
<rect
y="-1029.2865"
x="112.06335"
height="5.4800777"
width="5.4800777"
id="rect3005-74-4-6-0"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1029.2865"
x="118.23475"
height="5.4800777"
width="5.4800777"
id="rect3005-1-0-8-0-3"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1023.1509"
x="118.23475"
height="5.4800777"
width="5.4800777"
id="rect3005-4-4-2-5-7-2"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1017.0153"
x="118.23475"
height="5.4800777"
width="5.4800777"
id="rect3005-4-5-1-1-2-4"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1017.0153"
x="124.49454"
height="5.4800777"
width="5.4800777"
id="rect3005-4-1-7-1-0-7"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1017.0153"
x="136.57217"
height="5.4800777"
width="5.4800777"
id="rect3005-4-7-1-5-0-8"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1017.0153"
x="142.61099"
height="5.4800777"
width="5.4800777"
id="rect3005-4-11-1-2-1-3"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1010.8796"
x="130.53336"
height="5.4800777"
width="5.4800777"
id="rect3005-4-52-5-7-4-5"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1010.8796"
x="136.57217"
height="5.4800777"
width="5.4800777"
id="rect3005-4-76-2-6-6-1"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1010.8796"
x="142.61099"
height="5.4800777"
width="5.4800777"
id="rect3005-4-14-7-1-0-2"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1017.0153"
x="112.06335"
height="5.4800777"
width="5.4800777"
id="rect3005-1-2-6-4-7-0"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1017.0153"
x="155.08638"
height="5.4800777"
width="5.4800777"
id="rect3005-1-3-1-2-1-1"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1010.8796"
x="155.08638"
height="5.4800777"
width="5.4800777"
id="rect3005-1-22-4-3-7-6"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1023.1509"
x="148.91498"
height="5.4800777"
width="5.4800777"
id="rect3005-1-1-2-2-7-4"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1029.2865"
x="148.91498"
height="5.4800777"
width="5.4800777"
id="rect3005-1-6-3-2-7-0"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1017.0153"
x="130.53336"
height="5.4800777"
width="5.4800777"
id="rect3005-1-8-7-2-6-3-1"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1010.8796"
x="124.49454"
height="5.4800777"
width="5.4800777"
id="rect3005-1-8-6-1-8-3-8"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1023.1509"
x="112.06335"
height="5.4800777"
width="5.4800777"
id="rect3005-8-8-7-9-8"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1010.8796"
x="112.06335"
height="5.4800777"
width="5.4800777"
id="rect3005-8-2-5-6-9-4"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1017.0153"
x="148.91498"
height="5.4800777"
width="5.4800777"
id="rect3005-8-7-7-1-8-1"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1029.2865"
x="155.08638"
height="5.4800777"
width="5.4800777"
id="rect3005-8-9-6-8-1-4"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1010.8796"
x="118.23475"
height="5.4800777"
width="5.4800777"
id="rect3005-8-5-1-9-8-3"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1010.8796"
x="148.91498"
height="5.4800777"
width="5.4800777"
id="rect3005-8-5-3-8-2-2-9"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
<rect
y="-1023.1509"
x="155.08638"
height="5.4800777"
width="5.4800777"
id="rect3005-2-9-7-6-8"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
transform="scale(-1,-1)" />
</g>
<g
id="g4275"
transform="translate(0.29674306,42.186971)">
<g
id="g3485">
<rect
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-7-9-8-1"
width="5.4800777"
height="5.4800777"
x="-148.09108"
y="987.79999" />
<rect
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-48-2-6"
width="5.4800777"
height="5.4800777"
x="-142.05226"
y="987.79999" />
<rect
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-9-8-4-5"
width="5.4800777"
height="5.4800777"
x="-136.01344"
y="987.79999" />
<rect
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-8-4-5-5"
width="5.4800777"
height="5.4800777"
x="-142.05226"
y="993.93573" />
<rect
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-82-5-1-4"
width="5.4800777"
height="5.4800777"
x="-136.01344"
y="993.93573" />
<rect
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-4-45-5-7-1"
width="5.4800777"
height="5.4800777"
x="-129.97462"
y="993.93573" />
<rect
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-8-2-1-7"
width="5.4800777"
height="5.4800777"
x="-148.09108"
y="993.93573" />
<rect
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-1-8-1-6-5-5"
width="5.4800777"
height="5.4800777"
x="-129.97462"
y="987.79999" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-7-9-8-1-8"
width="5.4800777"
height="5.4800777"
x="124.49454"
y="-987.2865" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-48-2-6-0"
width="5.4800777"
height="5.4800777"
x="130.53336"
y="-987.2865" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-9-8-4-5-1"
width="5.4800777"
height="5.4800777"
x="136.57217"
y="-987.2865" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-8-4-5-5-5"
width="5.4800777"
height="5.4800777"
x="130.53336"
y="-981.15088" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-82-5-1-4-0"
width="5.4800777"
height="5.4800777"
x="136.57217"
y="-981.15088" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-4-45-5-7-1-9"
width="5.4800777"
height="5.4800777"
x="142.61099"
y="-981.15088" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-8-2-1-7-6"
width="5.4800777"
height="5.4800777"
x="124.49454"
y="-981.15088" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-1-8-1-6-5-5-9"
width="5.4800777"
height="5.4800777"
x="142.61099"
y="-987.2865" />
</g>
<g
transform="translate(-5.2457258,-39.238029)"
id="g4271">
<rect
y="1013.8058"
x="-143.93018"
height="25.713068"
width="25.59375"
id="rect4533-7"
- style="fill:none;stroke:#ffffff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:1;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
+ style="fill:none;stroke:#ffffff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:1;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
<rect
y="1013.8058"
x="-143.93018"
height="25.713068"
width="25.59375"
id="rect4533"
- style="fill:none;stroke:#000000;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:1;stroke-opacity:1;stroke-dasharray:5, 2.5;stroke-dashoffset:0" />
+ style="fill:none;stroke:#000000;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:1;stroke-dasharray:5, 2.5;stroke-dashoffset:0;stroke-opacity:1" />
</g>
</g>
</g>
</g>
<g
inkscape:groupmode="layer"
id="layer10"
- inkscape:label="Surface To Image">
+ inkscape:label="Surface To Image"
+ style="display:inline"
+ sodipodi:insensitive="true">
<g
transform="translate(-1.185093,57.81894)"
inkscape:export-ydpi="89.07"
inkscape:export-xdpi="89.07"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\ImageMasking_48x48.png"
id="g4347-1">
<g
id="g4297-7"
style="fill:#d2d2d2;fill-opacity:1"
sodipodi:insensitive="true">
<g
id="g4874"
transform="matrix(-1,0,0,1,-273.1298,0)"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\SurfaceToImage_48x48.png"
inkscape:export-xdpi="89.07"
inkscape:export-ydpi="89.07">
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-5-1-1-2-4-8"
width="5.4800777"
height="5.4800777"
x="118.45951"
y="-1017.0087" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-1-7-1-0-7-9"
width="5.4800777"
height="5.4800777"
x="124.60566"
y="-1017.0087" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-7-1-5-0-8-2"
width="5.4800777"
height="5.4800777"
x="136.89793"
y="-1017.0087" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-11-1-2-1-3-7"
width="5.4800777"
height="5.4800777"
x="143.04408"
y="-1017.0087" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-2-6-4-7-0-3"
width="5.4800777"
height="5.4800777"
x="112.31335"
y="-1017.0087" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-3-1-2-1-1-1"
width="5.4800777"
height="5.4800777"
x="155.33638"
y="-1017.0087" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-8-7-2-6-3-1-4"
width="5.4800777"
height="5.4800777"
x="130.7518"
y="-1017.0087" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-8-7-7-1-8-1-8"
width="5.4800777"
height="5.4800777"
x="149.19023"
y="-1017.0087" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-52-5-7-4-5-9"
width="5.4800777"
height="5.4800777"
x="130.7518"
y="-1010.8796" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-4-76-2-6-6-1-5"
width="5.4800777"
height="5.4800777"
x="136.89793"
y="-1010.8796" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-4-14-7-1-0-2-4"
width="5.4800777"
height="5.4800777"
x="143.04408"
y="-1010.8796" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-22-4-3-7-6-2"
width="5.4800777"
height="5.4800777"
x="155.33638"
y="-1010.8796" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-8-6-1-8-3-8-1"
width="5.4800777"
height="5.4800777"
x="124.60566"
y="-1010.8796" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-8-2-5-6-9-4-3"
width="5.4800777"
height="5.4800777"
x="112.31335"
y="-1010.8796" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-8-5-1-9-8-3-4"
width="5.4800777"
height="5.4800777"
x="118.45951"
y="-1010.8796" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-8-5-3-8-2-2-9-2"
width="5.4800777"
height="5.4800777"
x="149.19023"
y="-1010.8796" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-5-1-1-2-4-8-6"
width="5.4800777"
height="5.4800777"
x="118.45951"
y="-1023.1378" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-1-7-1-0-7-9-1"
width="5.4800777"
height="5.4800777"
x="124.60566"
y="-1023.1378" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-7-1-5-0-8-2-3"
width="5.4800777"
height="5.4800777"
x="136.89793"
y="-1023.1378" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-11-1-2-1-3-7-8"
width="5.4800777"
height="5.4800777"
x="143.04408"
y="-1023.1378" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-2-6-4-7-0-3-9"
width="5.4800777"
height="5.4800777"
x="112.31335"
y="-1023.1378" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-3-1-2-1-1-1-3"
width="5.4800777"
height="5.4800777"
x="155.33638"
y="-1023.1378" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-8-7-2-6-3-1-4-4"
width="5.4800777"
height="5.4800777"
x="130.7518"
y="-1023.1378" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-8-7-7-1-8-1-8-4"
width="5.4800777"
height="5.4800777"
x="149.19023"
y="-1023.1378" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-5-1-1-2-4-8-0"
width="5.4800777"
height="5.4800777"
x="118.45951"
y="-1029.2668" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-1-7-1-0-7-9-6"
width="5.4800777"
height="5.4800777"
x="124.60566"
y="-1029.2668" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-7-1-5-0-8-2-6"
width="5.4800777"
height="5.4800777"
x="136.89793"
y="-1029.2668" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-11-1-2-1-3-7-1"
width="5.4800777"
height="5.4800777"
x="143.04408"
y="-1029.2668" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-2-6-4-7-0-3-8"
width="5.4800777"
height="5.4800777"
x="112.31335"
y="-1029.2668" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-3-1-2-1-1-1-4"
width="5.4800777"
height="5.4800777"
x="155.33638"
y="-1029.2668" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-8-7-2-6-3-1-4-9"
width="5.4800777"
height="5.4800777"
x="130.7518"
y="-1029.2668" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-8-7-7-1-8-1-8-6"
width="5.4800777"
height="5.4800777"
x="149.19023"
y="-1029.2668" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-5-1-1-2-4-8-7"
width="5.4800777"
height="5.4800777"
x="118.45951"
y="-1035.396" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-1-7-1-0-7-9-8"
width="5.4800777"
height="5.4800777"
x="124.60566"
y="-1035.396" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-7-1-5-0-8-2-8"
width="5.4800777"
height="5.4800777"
x="136.89793"
y="-1035.396" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-11-1-2-1-3-7-2"
width="5.4800777"
height="5.4800777"
x="143.04408"
y="-1035.396" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-2-6-4-7-0-3-91"
width="5.4800777"
height="5.4800777"
x="112.31335"
y="-1035.396" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-3-1-2-1-1-1-35"
width="5.4800777"
height="5.4800777"
x="155.33638"
y="-1035.396" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-8-7-2-6-3-1-4-98"
width="5.4800777"
height="5.4800777"
x="130.7518"
y="-1035.396" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-8-7-7-1-8-1-8-40"
width="5.4800777"
height="5.4800777"
x="149.19023"
y="-1035.396" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-5-1-1-2-4-8-63"
width="5.4800777"
height="5.4800777"
x="118.45951"
y="-1041.525" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-1-7-1-0-7-9-61"
width="5.4800777"
height="5.4800777"
x="124.60566"
y="-1041.525" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-7-1-5-0-8-2-5"
width="5.4800777"
height="5.4800777"
x="136.89793"
y="-1041.525" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-11-1-2-1-3-7-4"
width="5.4800777"
height="5.4800777"
x="143.04408"
y="-1041.525" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-2-6-4-7-0-3-2"
width="5.4800777"
height="5.4800777"
x="112.31335"
y="-1041.525" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-3-1-2-1-1-1-0"
width="5.4800777"
height="5.4800777"
x="155.33638"
y="-1041.525" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-8-7-2-6-3-1-4-97"
width="5.4800777"
height="5.4800777"
x="130.7518"
y="-1041.525" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-8-7-7-1-8-1-8-3"
width="5.4800777"
height="5.4800777"
x="149.19023"
y="-1041.525" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-5-1-1-2-4-8-60"
width="5.4800777"
height="5.4800777"
x="118.45951"
y="-1047.6542" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-1-7-1-0-7-9-16"
width="5.4800777"
height="5.4800777"
x="124.60566"
y="-1047.6542" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-7-1-5-0-8-2-57"
width="5.4800777"
height="5.4800777"
x="136.89793"
y="-1047.6542" />
<rect
transform="scale(-1,-1)"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3005-4-11-1-2-1-3-7-5"
width="5.4800777"
height="5.4800777"
x="143.04408"
y="-1047.6542" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-2-6-4-7-0-3-4"
width="5.4800777"
height="5.4800777"
x="112.31335"
y="-1047.6542" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-3-1-2-1-1-1-1"
width="5.4800777"
height="5.4800777"
x="155.33638"
y="-1047.6542" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-8-7-2-6-3-1-4-2"
width="5.4800777"
height="5.4800777"
x="130.7518"
y="-1047.6542" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-8-7-7-1-8-1-8-0"
width="5.4800777"
height="5.4800777"
x="149.19023"
y="-1047.6542" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-5-1-1-2-4-8-4"
width="5.4800777"
height="5.4800777"
x="118.45951"
y="-1053.7833" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-4-1-7-1-0-7-9-60"
width="5.4800777"
height="5.4800777"
x="124.60566"
y="-1053.7833" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-4-7-1-5-0-8-2-7"
width="5.4800777"
height="5.4800777"
x="136.89793"
y="-1053.7833" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-4-11-1-2-1-3-7-17"
width="5.4800777"
height="5.4800777"
x="143.04408"
y="-1053.7833" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-2-6-4-7-0-3-7"
width="5.4800777"
height="5.4800777"
x="112.31335"
y="-1053.7833" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-1-3-1-2-1-1-1-7"
width="5.4800777"
height="5.4800777"
x="155.33638"
y="-1053.7833" />
<rect
transform="scale(-1,-1)"
style="fill:#d2d2d2;fill-opacity:1;stroke:none"
id="rect3005-1-8-7-2-6-3-1-4-7"
width="5.4800777"
height="5.4800777"
x="130.7518"
y="-1053.7833" />
<rect
transform="scale(-1,-1)"
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3005-8-7-7-1-8-1-8-33"
width="5.4800777"
height="5.4800777"
x="149.19023"
y="-1053.7833" />
<g
- style="fill:#000000;fill-opacity:0;stroke:#00adff;stroke-width:2.5;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ style="fill:#000000;fill-opacity:0;stroke:#00adff;stroke-width:2.5;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
id="g4869">
<path
- style="fill:#000000;fill-opacity:0;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ style="fill:#000000;fill-opacity:0;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
d="m -137.625,1069.3622 12,4.875 5.875,13 -5.75,13.625 -12,4.75 z"
id="path4863"
inkscape:connector-curvature="0"
transform="translate(1.185093,-57.81894)" />
<path
- style="fill:#000000;fill-opacity:0;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ style="fill:#000000;fill-opacity:0;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
d="m -125.625,1074.3622 -12.125,13.125"
id="path4865"
inkscape:connector-curvature="0"
transform="translate(1.185093,-57.81894)" />
<path
- style="fill:#000000;fill-opacity:0;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ style="fill:#000000;fill-opacity:0;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
d="m -120.25,1087.2372 -17.25,0.125 12,13.375"
id="path4867"
inkscape:connector-curvature="0"
transform="translate(1.185093,-57.81894)" />
</g>
</g>
</g>
<g
id="g4275-7"
transform="translate(0.29674306,42.186971)" />
</g>
</g>
<g
inkscape:label="Morphological Operations"
id="layer7"
inkscape:groupmode="layer"
sodipodi:insensitive="true">
<g
inkscape:export-ydpi="90.470001"
inkscape:export-xdpi="90.470001"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\MorphologicalOperations_48x48.png"
transform="translate(-109.1111,123.0997)"
id="g4984">
<path
style="fill:#bf264a;fill-opacity:0.32978725;stroke:#c0264b;stroke-width:0.99999994;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:0.71808543;stroke-dasharray:none"
d="m -108.14089,906.34775 c -4.69686,-21.37148 26.795676,-29.59419 38.148906,-20.16936 10.11729,8.39884 12.92174,37.39802 -3.99393,42.87973 -4.33136,1.40362 -6.5528,-4.31454 -9.77824,-9.2112 -2.95178,-4.48121 -9.83544,-5.58262 -14.18533,-8.41713 -3.117706,-2.03159 -9.282166,-0.94484 -10.191406,-5.08204 z"
id="path4970"
inkscape:connector-curvature="0"
sodipodi:nodetypes="sassss" />
<path
style="fill:#bf264a;fill-opacity:0.37765958;stroke:#c0264a;stroke-width:0.99999988;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:0.70744683;stroke-dasharray:none"
d="m -103.44466,903.12804 c -2.30997,-13.73691 22.213165,-19.81546 30.682509,-13.32011 7.988188,6.12632 10.465752,30.47133 -3.478182,32.94222 -3.259751,0.57764 -4.279427,-9.59405 -7.577458,-9.59621 -4.475588,-0.004 -11.530283,-7.45772 -12.794727,-7.01813 -2.777961,0.96576 -6.292672,0.20031 -6.832142,-3.00777 z"
id="path4968"
inkscape:connector-curvature="0"
sodipodi:nodetypes="ssssss" />
<path
style="fill:#bf264a;fill-opacity:0.48404254;stroke:#c0264b;stroke-width:1.29999983;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
d="m -97.037608,899.72564 c 1.053535,-7.83495 17.4303,-12.31753 23.208337,-5.65907 4.665289,5.37616 5.313738,21.46326 -2.279392,23.53663 -2.84013,0.77552 -2.97128,-10.19566 -5.284037,-8.61723 -1.784315,1.21777 -6.79947,-1.84848 -8.910347,-5.01601 -1.604756,-2.40805 -7.573523,1.99493 -6.734561,-4.24432 z"
id="path4955"
inkscape:connector-curvature="0"
sodipodi:nodetypes="sassss" />
</g>
</g>
<g
inkscape:groupmode="layer"
id="g7924"
inkscape:label="Closing"
sodipodi:insensitive="true">
<g
id="g7926"
transform="translate(-103.6111,307.0997)"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\Closing_48x48.png"
inkscape:export-xdpi="91.980354"
inkscape:export-ydpi="91.980354">
<path
style="fill:#bf264a;fill-opacity:1;stroke:none"
d="m -186.71875,1189.4062 c -13.09987,0.1051 -28.40712,8.6705 -25.03125,24.0313 0.90924,4.1372 7.06979,3.0623 10.1875,5.0937 4.34989,2.8347 11.23572,3.9251 14.1875,8.4063 3.22544,4.8967 5.44989,10.6225 9.78125,9.2187 16.91567,-5.4816 14.11729,-34.476 4,-42.875 -3.1931,-2.6506 -7.99897,-3.9159 -13.125,-3.875 z m -7.21875,5.5626 c 5.77684,0 10.46875,4.6919 10.46875,10.4687 0,5.7768 -4.69191,10.4375 -10.46875,10.4375 -5.77684,0 -10.46875,-4.6607 -10.46875,-10.4375 0,-5.7768 4.69191,-10.4687 10.46875,-10.4687 z m 16.65625,18.4062 c 2.87653,0 5.1875,2.3422 5.1875,5.2188 0,2.8765 -2.31097,5.1874 -5.1875,5.1874 -2.87653,0 -5.21875,-2.3109 -5.21875,-5.1874 0,-2.8766 2.34222,-5.2188 5.21875,-5.2188 z"
transform="translate(103.6111,-307.0997)"
id="path7928"
inkscape:connector-curvature="0"
sodipodi:nodetypes="cscscccssssssssss" />
<g
id="g7976"
transform="translate(-0.74999999,1.1344127e-8)"
style="stroke:#00adff;stroke-opacity:1">
<path
inkscape:connector-curvature="0"
id="path7956"
d="m -77.8889,917.01249 10.5,-10.5"
style="fill:none;stroke:#00adff;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
<path
inkscape:connector-curvature="0"
id="path7956-5"
d="m -67.3889,917.01249 -10.5,-10.5"
style="fill:none;stroke:#00adff;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
</g>
</g>
</g>
<g
inkscape:label="Fill Holes"
id="g4366"
inkscape:groupmode="layer"
sodipodi:insensitive="true">
<g
inkscape:export-ydpi="91.980324"
inkscape:export-xdpi="91.980324"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\FillHoles_48x48.png"
transform="translate(-97.954246,422.71166)"
id="g4368">
<path
sodipodi:nodetypes="cscscccssssssssss"
inkscape:connector-curvature="0"
id="path4370"
transform="translate(103.6111,-307.0997)"
d="m -186.71875,1189.4062 c -13.09987,0.1051 -28.40712,8.6705 -25.03125,24.0313 0.90924,4.1372 7.06979,3.0623 10.1875,5.0937 4.34989,2.8347 11.23572,3.9251 14.1875,8.4063 3.22544,4.8967 5.44989,10.6225 9.78125,9.2187 16.91567,-5.4816 14.11729,-34.476 4,-42.875 -3.1931,-2.6506 -7.99897,-3.9159 -13.125,-3.875 z m -7.21875,5.5626 c 5.77684,0 10.46875,4.6919 10.46875,10.4687 0,5.7768 -4.69191,10.4375 -10.46875,10.4375 -5.77684,0 -10.46875,-4.6607 -10.46875,-10.4375 0,-5.7768 4.69191,-10.4687 10.46875,-10.4687 z m 16.65625,18.4062 c 2.87653,0 5.1875,2.3422 5.1875,5.2188 0,2.8765 -2.31097,5.1874 -5.1875,5.1874 -2.87653,0 -5.21875,-2.3109 -5.21875,-5.1874 0,-2.8766 2.34222,-5.2188 5.21875,-5.2188 z"
style="fill:#bf264a;fill-opacity:1;stroke:none" />
<g
transform="translate(-0.74999999,1.1344127e-8)"
id="g4372"
style="stroke:#00adff;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none">
<path
style="fill:none;stroke:#00adff;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
d="m -77.8889,917.01249 10.5,-10.5"
id="path4374"
inkscape:connector-curvature="0" />
<path
style="fill:none;stroke:#00adff;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
d="m -67.3889,917.01249 -10.5,-10.5"
id="path4376"
inkscape:connector-curvature="0" />
</g>
<g
transform="matrix(1.6788225,0,0,1.6788225,31.811662,-632.3363)"
id="g4372-4"
style="stroke:#00adff;stroke-width:1.19131112;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none">
<path
style="fill:none;stroke:#00adff;stroke-width:1.19131112;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
d="m -77.8889,917.01249 10.5,-10.5"
id="path4374-0"
inkscape:connector-curvature="0" />
<path
style="fill:none;stroke:#00adff;stroke-width:1.19131112;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
d="m -67.3889,917.01249 -10.5,-10.5"
id="path4376-9"
inkscape:connector-curvature="0" />
</g>
</g>
</g>
<g
inkscape:label="Opening"
id="g3324"
inkscape:groupmode="layer"
sodipodi:insensitive="true">
<g
inkscape:export-ydpi="90.470001"
inkscape:export-xdpi="90.470001"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\Opening_48x48.png"
transform="translate(-100.8611,360.5997)"
id="g3326">
<path
sodipodi:nodetypes="cscscccssssssssss"
inkscape:connector-curvature="0"
id="path3328"
d="m -81.185775,884.6034 c -13.09987,0.1051 -28.407115,8.6705 -25.031245,24.0313 0.90924,4.1372 7.069785,3.0623 10.187495,5.0937 4.34989,2.8347 11.23572,3.9251 14.1875,8.4063 3.22544,4.8967 5.44989,10.6225 9.78125,9.2187 16.91567,-5.4816 14.11729,-34.476 4,-42.875 -3.1931,-2.6506 -7.99897,-3.9159 -13.125,-3.875 z m -7.21875,5.5626 c 5.77684,0 10.46875,4.6919 10.46875,10.4687 0,5.7768 -4.69191,10.4375 -10.46875,10.4375 -5.77684,0 -10.46875,-4.6607 -10.46875,-10.4375 0,-5.7768 4.69191,-10.4687 10.46875,-10.4687 z m 16.65625,18.4062 c 2.87653,0 5.1875,2.3422 5.1875,5.2188 0,2.8765 -2.31097,5.1874 -5.1875,5.1874 -2.87653,0 -5.21875,-2.3109 -5.21875,-5.1874 0,-2.8766 2.34222,-5.2188 5.21875,-5.2188 z"
style="fill:#bf264a;fill-opacity:0.32978725;stroke:#c0264b;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:0;stroke-dasharray:none"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\Opening_48x48.png"
inkscape:export-xdpi="90"
inkscape:export-ydpi="90" />
<path
style="fill:#bf264a;fill-opacity:1;stroke:none"
d="m -81.2014,884.5878 c -3.0869,0.0248 -6.28505,0.5575 -9.34375,1.5 -0.18346,1.4226 -0.09951,2.9722 0.15625,4.25 0.63395,-0.1201 1.30015,-0.1875 1.96875,-0.1875 5.77684,0 10.46875,4.692 10.46875,10.4688 0,1.1769 -0.20351,2.3206 -0.5625,3.375 2.00945,2.1884 3.47913,3.4015 5.8125,4.6562 0.30872,-0.0572 0.61253,-0.0625 0.9375,-0.0625 2.87653,0 5.1875,2.3109 5.1875,5.1875 0,2.8765 -2.31097,5.1875 -5.1875,5.1875 -2.87653,0 -5.21875,-2.311 -5.21875,-5.1875 0,-0.0738 -0.0031,-0.1457 0,-0.2188 -1.65474,-2.0148 -3.24164,-3.2089 -5.53125,-4.2812 -1.67813,1.139 -3.72408,1.8125 -5.90625,1.8125 -0.51403,0 -1.00569,-0.0537 -1.5,-0.125 -1.02993,1.8634 -1.12047,3.6519 -0.59375,5.4375 3.36987,1.4176 6.79365,2.8911 8.65625,5.7188 3.22544,4.8967 5.44989,10.6225 9.78125,9.2187 16.91567,-5.4816 14.11729,-34.476 4,-42.875 -3.1931,-2.6506 -7.99897,-3.9159 -13.125,-3.875 z m -17.9375,5.75 c -5.48357,4.0778 -8.8624,10.2337 -7.09375,18.2813 0.65259,2.9694 4.0037,3.2936 7,3.9687 1.67262,-1.2671 3.13022,-3.098 3.625,-4.375 -2.02329,-1.9014 -3.28125,-4.5957 -3.28125,-7.5937 0,-2.763 1.06042,-5.2843 2.8125,-7.1563 -0.68689,-1.4325 -1.75339,-2.4391 -3.0625,-3.125 z"
id="path3328-1"
inkscape:connector-curvature="0"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\Opening_48x48.png"
inkscape:export-xdpi="90"
inkscape:export-ydpi="90" />
</g>
</g>
<g
inkscape:groupmode="layer"
id="g3224"
inkscape:label="Erode"
sodipodi:insensitive="true">
<g
id="g3226"
transform="translate(-105.47406,184.64955)"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\Erode_48x48.png"
inkscape:export-xdpi="91.564468"
inkscape:export-ydpi="91.564468">
<g
id="g6644">
<path
style="fill:#bf264a;fill-opacity:0.32978725;stroke:none"
d="m -108.14089,906.34775 c -4.69686,-21.37148 26.795676,-29.59419 38.148906,-20.16936 10.11729,8.39884 12.92174,37.39802 -3.99393,42.87973 -4.33136,1.40362 -6.5528,-4.31454 -9.77824,-9.2112 -2.95178,-4.48121 -9.83544,-5.58262 -14.18533,-8.41713 -3.117706,-2.03159 -9.282166,-0.94484 -10.191406,-5.08204 z"
id="path3228"
inkscape:connector-curvature="0"
sodipodi:nodetypes="sassss" />
<path
style="fill:#bf264a;fill-opacity:1;stroke:none"
d="m -99.015895,899.4289 c 1.053535,-7.83495 18.783308,-11.07876 25.186624,-5.36233 5.880037,5.24929 5.313738,21.46326 -2.279392,23.53663 -2.84013,0.77552 -2.58498,-3.13574 -4.294893,-5.35306 -1.88323,-2.44206 -7.039508,-5.76376 -12.075607,-6.79646 -2.834789,-0.58131 -7.375694,0.21447 -6.536732,-6.02478 z"
id="path3232"
inkscape:connector-curvature="0"
sodipodi:nodetypes="sassss" />
</g>
<g
id="g7858-6"
transform="matrix(0.61016652,0,0,0.61016652,-48.204939,369.60786)"
style="stroke:#00adff;stroke-opacity:1">
<path
style="fill:#00adff;fill-opacity:1;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#TriangleInMUm);marker-end:none"
d="m -76.049605,896.6784 8.71058,-8.78881"
id="path6666-1"
inkscape:connector-curvature="0" />
<path
style="fill:#00adff;fill-opacity:1;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#TriangleInMUF);marker-end:none"
d="m -76.070477,907.99147 8.7888,8.71058"
id="path6666-3-89"
inkscape:connector-curvature="0" />
<path
style="fill:#00adff;fill-opacity:1;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#TriangleInMUl);marker-end:none"
d="m -86.796124,896.67838 -8.71058,-8.7888"
id="path6666-6-2"
inkscape:connector-curvature="0" />
<path
style="fill:#00adff;fill-opacity:1;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#TriangleInMUX);marker-end:none"
d="m -86.775251,907.99147 -8.7888,8.71058"
id="path6666-3-8-7"
inkscape:connector-curvature="0" />
</g>
</g>
</g>
<g
inkscape:label="Dilate"
id="g6654"
inkscape:groupmode="layer"
sodipodi:insensitive="true">
<g
inkscape:export-ydpi="91.761711"
inkscape:export-xdpi="91.761711"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\Dilate_48x48.png"
transform="translate(-104.76695,244.40007)"
id="g6656">
<g
id="g6658">
<path
sodipodi:nodetypes="sassss"
inkscape:connector-curvature="0"
id="path6660"
d="m -108.14089,906.34775 c -4.69686,-21.37148 26.795676,-29.59419 38.148906,-20.16936 10.11729,8.39884 12.92174,37.39802 -3.99393,42.87973 -4.33136,1.40362 -6.5528,-4.31454 -9.77824,-9.2112 -2.95178,-4.48121 -9.83544,-5.58262 -14.18533,-8.41713 -3.117706,-2.03159 -9.282166,-0.94484 -10.191406,-5.08204 z"
style="fill:#bf264a;fill-opacity:0.32978725;stroke:none" />
<path
sodipodi:nodetypes="sassss"
inkscape:connector-curvature="0"
id="path6662"
d="m -99.015895,899.4289 c 1.053535,-7.83495 18.783308,-11.07876 25.186624,-5.36233 5.880037,5.24929 5.313738,21.46326 -2.279392,23.53663 -2.84013,0.77552 -2.58498,-3.13574 -4.294893,-5.35306 -1.88323,-2.44206 -7.039508,-5.76376 -12.075607,-6.79646 -2.834789,-0.58131 -7.375694,0.21447 -6.536732,-6.02478 z"
style="fill:#bf264a;fill-opacity:1;stroke:none" />
<g
id="g7858"
transform="matrix(0.59392347,0,0,0.59392347,-49.465386,384.04206)"
style="stroke:#00adff;stroke-opacity:1">
<path
style="fill:#00adff;fill-opacity:1;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#TriangleInMUe);marker-end:none"
d="m -70.775752,891.36279 -8.710577,8.78881"
id="path6666"
inkscape:connector-curvature="0" />
<path
style="fill:#00adff;fill-opacity:1;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#TriangleInMUt);marker-end:none"
d="m -70.754879,913.26532 -8.7888,-8.71058"
id="path6666-3"
inkscape:connector-curvature="0" />
<path
style="fill:#00adff;fill-opacity:1;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#TriangleInMUg);marker-end:none"
d="m -92.069976,891.36279 8.71058,8.7888"
id="path6666-6"
inkscape:connector-curvature="0" />
<path
style="fill:#00adff;fill-opacity:1;stroke:#00adff;stroke-width:2.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#TriangleInMUZ);marker-end:none"
d="m -92.090849,913.26532 8.7888,-8.71058"
id="path6666-3-8"
inkscape:connector-curvature="0" />
</g>
</g>
</g>
</g>
<g
sodipodi:insensitive="true"
inkscape:label="Boolean Difference"
id="layer6"
inkscape:groupmode="layer">
<g
inkscape:export-ydpi="89.07"
inkscape:export-xdpi="89.07"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\BooleanDifference_48x48.png"
id="g3986-1"
transform="translate(-54.972257,-38.513914)">
<g
transform="translate(-6.7261759,37.587454)"
id="g4014">
<rect
y="1022.3405"
x="-274.9819"
height="32"
width="32"
id="rect3982-7"
style="fill:#bf264b;fill-opacity:1;stroke:none" />
<path
transform="matrix(0.86040482,0,0,0.86040482,47.623043,174.07452)"
- d="m -318.89986,985.89172 c 0,10.27023 -8.32567,18.59588 -18.5959,18.59588 -10.27023,0 -18.5959,-8.32565 -18.5959,-18.59588 0,-10.27023 8.32567,-18.59589 18.5959,-18.59589 10.27023,0 18.5959,8.32566 18.5959,18.59589 z"
+ d="m -318.89986,985.89172 a 18.595898,18.595898 0 0 1 -18.5959,18.59588 18.595898,18.595898 0 0 1 -18.5959,-18.59588 18.595898,18.595898 0 0 1 18.5959,-18.59589 18.595898,18.595898 0 0 1 18.5959,18.59589 z"
sodipodi:ry="18.595898"
sodipodi:rx="18.595898"
sodipodi:cy="985.89172"
sodipodi:cx="-337.49576"
id="path3984-4"
style="fill:#999999;fill-opacity:1;stroke:none"
sodipodi:type="arc" />
</g>
</g>
</g>
<g
sodipodi:insensitive="true"
inkscape:label="Boolean Union"
id="layer8"
inkscape:groupmode="layer">
<g
inkscape:export-ydpi="89.07"
inkscape:export-xdpi="89.07"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\BooleanUnion_48x48.png"
style="fill:#bf264b;fill-opacity:1"
transform="translate(-3.5367938,-1.3221171)"
id="g3986">
<rect
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="rect3982"
width="32"
height="32"
x="-274.9819"
y="1022.3405" />
<path
sodipodi:type="arc"
style="fill:#bf264b;fill-opacity:1;stroke:none"
id="path3984"
sodipodi:cx="-337.49576"
sodipodi:cy="985.89172"
sodipodi:rx="18.595898"
sodipodi:ry="18.595898"
- d="m -318.89986,985.89172 c 0,10.27023 -8.32567,18.59588 -18.5959,18.59588 -10.27023,0 -18.5959,-8.32565 -18.5959,-18.59588 0,-10.27023 8.32567,-18.59589 18.5959,-18.59589 10.27023,0 18.5959,8.32566 18.5959,18.59589 z"
+ d="m -318.89986,985.89172 a 18.595898,18.595898 0 0 1 -18.5959,18.59588 18.595898,18.595898 0 0 1 -18.5959,-18.59588 18.595898,18.595898 0 0 1 18.5959,-18.59589 18.595898,18.595898 0 0 1 18.5959,18.59589 z"
transform="matrix(0.86040482,0,0,0.86040482,47.623043,174.07452)" />
</g>
</g>
<g
sodipodi:insensitive="true"
inkscape:label="Boolean Intersection"
id="layer9"
- inkscape:groupmode="layer">
+ inkscape:groupmode="layer"
+ style="display:inline">
<g
transform="translate(-121.4427,-2.9047467)"
id="g3986-0">
<g
inkscape:export-ydpi="89.07"
inkscape:export-xdpi="89.07"
inkscape:export-filename="D:\MITK\Plugins\org.mitk.gui.qt.segmentation\resources\BooleanIntersection_48x48.png"
transform="translate(-18.744726,34.691732)"
id="g4069">
<rect
style="fill:#999999;fill-opacity:1;stroke:none"
id="rect3982-2"
width="32"
height="32"
x="-256.78168"
y="988.70966" />
- <path
- sodipodi:type="arc"
+ <circle
style="fill:#999999;fill-opacity:1;stroke:none"
id="path3984-45"
- sodipodi:cx="-337.49576"
- sodipodi:cy="985.89172"
- sodipodi:rx="18.595898"
- sodipodi:ry="18.595898"
- d="m -318.89986,985.89172 c 0,10.27023 -8.32567,18.59588 -18.5959,18.59588 -10.27023,0 -18.5959,-8.32565 -18.5959,-18.59588 0,-10.27023 8.32567,-18.59589 18.5959,-18.59589 10.27023,0 18.5959,8.32566 18.5959,18.59589 z"
- transform="matrix(0.86040482,0,0,0.86040482,65.823282,140.44364)" />
+ transform="matrix(0.86040482,0,0,0.86040482,65.823282,140.44364)"
+ cx="-337.49576"
+ cy="985.89172"
+ r="18.595898" />
<path
style="fill:#bf264b;fill-opacity:1;stroke:none"
d="m -240.53168,988.70966 c 0,8.7535 7.02819,15.86694 15.75,15.99994 l 0,-15.99994 -15.75,0 z"
id="rect3982-9"
inkscape:connector-curvature="0" />
</g>
</g>
</g>
</svg>
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/MultiLabelSegmentationUtilities_48x48.png b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/MultiLabelSegmentationUtilities_48x48.png
index d441187899..09c380240b 100644
Binary files a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/MultiLabelSegmentationUtilities_48x48.png and b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/MultiLabelSegmentationUtilities_48x48.png differ
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/multilabelsegmentation.png b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/multilabelsegmentation.png
index d13c72b5b6..3a66134cd4 100644
Binary files a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/multilabelsegmentation.png and b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/multilabelsegmentation.png differ
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
index 820a80a8fb..5bf605aec6 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
@@ -1,991 +1,993 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkMultiLabelSegmentationView.h"
// blueberry
#include <berryIWorkbenchPage.h>
#include <berryConstants.h>
// mitk
#include "mitkLabelSetImage.h"
#include "mitkStatusBar.h"
#include "mitkApplicationCursor.h"
#include "mitkToolManagerProvider.h"
//#include "mitkSegmentationObjectFactory.h"
#include "mitkSegTool2D.h"
#include "mitkPlanePositionManager.h"
#include "mitkPluginActivator.h"
#include "mitkInteractionEventObserver.h"
// Qmitk
#include "QmitkSegmentationOrganNamesHandling.cpp"
#include "QmitkRenderWindow.h"
#include "QmitkNewSegmentationDialog.h"
// us
#include <usModule.h>
#include <usModuleResource.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
#include <usModuleResourceStream.h>
// Qt
#include <QMessageBox>
#include <QInputDialog>
#include <QFileDialog>
#include <QDateTime>
#include "tinyxml.h"
#include <itksys/SystemTools.hxx>
const std::string QmitkMultiLabelSegmentationView::VIEW_ID = "org.mitk.views.multilabelsegmentation";
QmitkMultiLabelSegmentationView::QmitkMultiLabelSegmentationView() :
m_Parent(NULL),
m_IRenderWindowPart(NULL),
m_ReferenceNode(NULL),
m_ToolManager(NULL),
m_WorkingNode(NULL),
m_MouseCursorSet(false)
{
m_SegmentationPredicate = mitk::NodePredicateAnd::New();
m_SegmentationPredicate->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
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 isMask = mitk::NodePredicateAnd::New(isBinary, isImage);
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 validImages = mitk::NodePredicateOr::New();
validImages->AddPredicate(isImage);
validImages->AddPredicate(isDwi);
validImages->AddPredicate(isDti);
validImages->AddPredicate(isQbi);
m_ReferencePredicate = mitk::NodePredicateAnd::New();
m_ReferencePredicate->AddPredicate(validImages);
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(m_SegmentationPredicate));
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(isMask));
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
}
QmitkMultiLabelSegmentationView::~QmitkMultiLabelSegmentationView()
{
//m_ToolManager->ActivateTool(-1);
/*
todo: check this
m_Controls.m_SliceBasedInterpolatorWidget->EnableInterpolation(false);
ctkPluginContext* context = mitk::PluginActivator::getContext();
ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
service->RemoveAllPlanePositions();
context->ungetService(ppmRef);
*/
//m_ToolManager->SetReferenceData(NULL);
//m_ToolManager->SetWorkingData(NULL);
//m_ServiceRegistration.Unregister();
//Loose LabelSetConnections
OnLooseLabelSetConnection();
}
void QmitkMultiLabelSegmentationView::CreateQtPartControl(QWidget* parent)
{
// setup the basic GUI of this view
m_Parent = parent;
m_Controls.setupUi(parent);
// *------------------------
// * DATA SELECTION WIDGETS
// *------------------------
m_Controls.m_cbReferenceNodeSelector->SetAutoSelectNewItems(true);
m_Controls.m_cbReferenceNodeSelector->SetPredicate(m_ReferencePredicate);
m_Controls.m_cbReferenceNodeSelector->SetDataStorage(this->GetDataStorage());
m_Controls.m_cbWorkingNodeSelector->SetAutoSelectNewItems(true);
m_Controls.m_cbWorkingNodeSelector->SetPredicate(m_SegmentationPredicate);
m_Controls.m_cbWorkingNodeSelector->SetDataStorage(this->GetDataStorage());
connect( m_Controls.m_cbReferenceNodeSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnReferenceSelectionChanged( const mitk::DataNode* ) ) );
connect( m_Controls.m_cbWorkingNodeSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnSegmentationSelectionChanged( const mitk::DataNode* ) ) );
// *------------------------
// * ToolManager
// *------------------------
m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
assert(m_ToolManager);
m_ToolManager->SetDataStorage( *(this->GetDataStorage()) );
m_ToolManager->InitializeTools();
//use the same ToolManager instance for our 3D Tools
m_Controls.m_ManualToolSelectionBox3D->SetToolManager(*m_ToolManager);
// *------------------------
// * LabelSetWidget
// *------------------------
m_Controls.m_LabelSetWidget->SetDataStorage(this->GetDataStorage());
m_Controls.m_LabelSetWidget->SetOrganColors(mitk::OrganNamesHandling::GetDefaultOrganColorString());
m_Controls.m_LabelSetWidget->hide();
// *------------------------
// * Interpolation
// *------------------------
m_Controls.m_SurfaceBasedInterpolatorWidget->SetDataStorage( *(this->GetDataStorage()) );
m_Controls.m_SliceBasedInterpolatorWidget->SetDataStorage( *(this->GetDataStorage()) );
connect( m_Controls.m_cbInterpolation, SIGNAL( activated (int) ), this, SLOT( OnInterpolationSelectionChanged(int) ) );
m_Controls.m_cbInterpolation->setCurrentIndex(0);
m_Controls.m_swInterpolation->hide();
+ // Disabled, see T22330
+ m_Controls.m_gbInterpolation->hide();
// *------------------------
// * ToolSelection 2D
// *------------------------
m_Controls.m_ManualToolSelectionBox2D->SetGenerateAccelerators(true);
m_Controls.m_ManualToolSelectionBox2D->SetToolGUIArea( m_Controls.m_ManualToolGUIContainer2D );
m_Controls.m_ManualToolSelectionBox2D->SetDisplayedToolGroups("Add Subtract Fill Erase Paint Wipe 'Region Growing' FastMarching2D Correction 'Live Wire'");// todo: "Correction 'Live Wire'"
m_Controls.m_ManualToolSelectionBox2D->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
connect( m_Controls.m_ManualToolSelectionBox2D, SIGNAL(ToolSelected(int)), this, SLOT(OnManualTool2DSelected(int)) );
// *------------------------
// * ToolSelection 3D
// *------------------------
m_Controls.m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
m_Controls.m_ManualToolSelectionBox3D->SetToolGUIArea( m_Controls.m_ManualToolGUIContainer3D );
m_Controls.m_ManualToolSelectionBox3D->SetDisplayedToolGroups("Threshold 'Two Thresholds' 'Auto Threshold' 'Multiple Otsu'"); // todo add : FastMarching3D RegionGrowing Watershed
m_Controls.m_ManualToolSelectionBox3D->SetLayoutColumns(2);
m_Controls.m_ManualToolSelectionBox3D->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
// *------------------------*
// * Connect PushButtons (pb)
// *------------------------*
connect( m_Controls.m_pbNewLabel, SIGNAL(clicked()), this, SLOT( OnNewLabel()) );
connect( m_Controls.m_pbNewSegmentationSession, SIGNAL(clicked()), this, SLOT( OnNewSegmentationSession()) );
connect( m_Controls.m_pbShowLabelTable, SIGNAL(toggled(bool)), this, SLOT( OnShowLabelTable(bool)) );
// *------------------------*
// * Connect LabelSetWidget
// *------------------------*
connect(m_Controls.m_LabelSetWidget, SIGNAL(goToLabel(const mitk::Point3D&)), this, SLOT(OnGoToLabel(const mitk::Point3D&)) );
connect(m_Controls.m_LabelSetWidget, SIGNAL(resetView()), this, SLOT(OnResetView()) );
// *------------------------*
// * DATA SLECTION WIDGET
// *------------------------*
m_IRenderWindowPart = this->GetRenderWindowPart();
if (m_IRenderWindowPart)
{
QList<mitk::SliceNavigationController*> controllers;
controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
m_Controls.m_SliceBasedInterpolatorWidget->SetSliceNavigationControllers(controllers);
// m_Controls.m_LabelSetWidget->SetRenderWindowPart(this->m_IRenderWindowPart);
}
// this->InitializeListeners();
connect( m_Controls.m_btAddLayer, SIGNAL(clicked()), this, SLOT( OnAddLayer()) );
connect( m_Controls.m_btDeleteLayer, SIGNAL(clicked()), this, SLOT( OnDeleteLayer()) );
connect( m_Controls.m_btPreviousLayer, SIGNAL(clicked()), this, SLOT( OnPreviousLayer()) );
connect( m_Controls.m_btNextLayer, SIGNAL(clicked()), this, SLOT( OnNextLayer()) );
connect( m_Controls.m_btLockExterior, SIGNAL(toggled(bool)), this, SLOT( OnLockExteriorToggled(bool)) );
connect( m_Controls.m_cbActiveLayer, SIGNAL(currentIndexChanged(int)), this, SLOT( OnChangeLayer(int)) );
m_Controls.m_btAddLayer->setEnabled(false);
m_Controls.m_btDeleteLayer->setEnabled(false);
m_Controls.m_btNextLayer->setEnabled(false);
m_Controls.m_btPreviousLayer->setEnabled(false);
m_Controls.m_cbActiveLayer->setEnabled(false);
m_Controls.m_pbNewLabel->setEnabled(false);
m_Controls.m_btLockExterior->setEnabled(false);
m_Controls.m_pbShowLabelTable->setEnabled(false);
// Make sure the GUI notices if appropriate data is already present on creation
this->OnReferenceSelectionChanged(m_Controls.m_cbReferenceNodeSelector->GetSelectedNode());
this->OnSegmentationSelectionChanged(m_Controls.m_cbWorkingNodeSelector->GetSelectedNode());
}
void QmitkMultiLabelSegmentationView::Activated()
{
m_ToolManager->SetReferenceData(m_Controls.m_cbReferenceNodeSelector->GetSelectedNode());
m_ToolManager->SetWorkingData(m_Controls.m_cbWorkingNodeSelector->GetSelectedNode());
}
void QmitkMultiLabelSegmentationView::Deactivated()
{
// Not yet implemented
}
void QmitkMultiLabelSegmentationView::Visible()
{
// Not yet implemented
}
void QmitkMultiLabelSegmentationView::Hidden()
{
// Not yet implemented
}
void QmitkMultiLabelSegmentationView::InitializeListeners()
{
if (m_Interactor.IsNull())
{
us::Module* module = us::GetModuleContext()->GetModule();
std::vector<us::ModuleResource> resources = module->FindResources("/", "*", true);
for (std::vector<us::ModuleResource>::iterator iter = resources.begin(); iter != resources.end(); ++iter)
{
MITK_INFO << iter->GetResourcePath();
}
m_Interactor = mitk::SegmentationInteractor::New();
if (!m_Interactor->LoadStateMachine("SegmentationInteraction.xml", module))
{
MITK_WARN << "Error loading state machine";
}
if (!m_Interactor->SetEventConfig ("ConfigSegmentation.xml", module))
{
MITK_WARN << "Error loading state machine configuration";
}
// Register as listener via micro services
us::ServiceProperties props;
props["name"] = std::string("SegmentationInteraction");
m_ServiceRegistration = us::GetModuleContext()->RegisterService<mitk::InteractionEventObserver>(m_Interactor.GetPointer(), props);
}
}
void QmitkMultiLabelSegmentationView::SetFocus ()
{
}
bool QmitkMultiLabelSegmentationView::CheckForSameGeometry(const mitk::Image *image1, const mitk::Image *image2) const
{
bool isSameGeometry(true);
if (image1 && image2)
{
mitk::BaseGeometry::Pointer geo1 = image1->GetGeometry();
mitk::BaseGeometry::Pointer 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 QmitkMultiLabelSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
{
if (m_IRenderWindowPart != renderWindowPart)
{
m_IRenderWindowPart = renderWindowPart;
m_Parent->setEnabled(true);
QList<mitk::SliceNavigationController*> controllers;
controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
m_Controls.m_SliceBasedInterpolatorWidget->SetSliceNavigationControllers(controllers);
}
}
void QmitkMultiLabelSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
{
m_ToolManager->ActivateTool(-1);
m_IRenderWindowPart = 0;
m_Parent->setEnabled(false);
}
int QmitkMultiLabelSegmentationView::GetSizeFlags(bool width)
{
if(!width)
{
return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
}
else
{
return 0;
}
}
int QmitkMultiLabelSegmentationView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
{
if(width==false)
{
return 100;
}
else
{
return preferredResult;
}
}
void QmitkMultiLabelSegmentationView::UpdateControls()
{
mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
bool hasReferenceNode = referenceNode != NULL;
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
bool hasValidWorkingNode = workingNode != NULL;
m_Controls.m_pbNewLabel->setEnabled(false);
m_Controls.m_gbInterpolation->setEnabled(false);
m_Controls.m_SliceBasedInterpolatorWidget->setEnabled(false);
m_Controls.m_SurfaceBasedInterpolatorWidget->setEnabled(false);
m_Controls.m_LabelSetWidget->setEnabled(false);
m_Controls.m_btAddLayer->setEnabled(false);
m_Controls.m_btDeleteLayer->setEnabled(false);
m_Controls.m_cbActiveLayer->setEnabled(false);
m_Controls.m_btPreviousLayer->setEnabled(false);
m_Controls.m_btNextLayer->setEnabled(false);
m_Controls.m_btLockExterior->setChecked(false);
m_Controls.m_btLockExterior->setEnabled(false);
m_Controls.m_pbShowLabelTable->setChecked(false);
m_Controls.m_pbShowLabelTable->setEnabled(false);
m_Controls.m_ManualToolSelectionBox3D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
m_Controls.m_ManualToolSelectionBox2D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
if(hasValidWorkingNode)
{
// TODO adapt tool manager so that this check is done there, e.g. convenience function
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
hasValidWorkingNode = workingImage != nullptr;
if (hasValidWorkingNode)
{
m_Controls.m_pbNewLabel->setEnabled(true);
m_Controls.m_btLockExterior->setEnabled(true);
m_Controls.m_pbShowLabelTable->setEnabled(true);
m_Controls.m_gbInterpolation->setEnabled(true);
m_Controls.m_SliceBasedInterpolatorWidget->setEnabled(true);
m_Controls.m_SurfaceBasedInterpolatorWidget->setEnabled(true);
m_Controls.m_LabelSetWidget->setEnabled(true);
m_Controls.m_btAddLayer->setEnabled(true);
int activeLayer = workingImage->GetActiveLayer();
int numberOfLayers = workingImage->GetNumberOfLayers();
m_Controls.m_cbActiveLayer->blockSignals(true);
m_Controls.m_cbActiveLayer->clear();
for (unsigned int lidx=0; lidx<workingImage->GetNumberOfLayers(); ++lidx)
m_Controls.m_cbActiveLayer->addItem(QString::number(lidx));
m_Controls.m_cbActiveLayer->setCurrentIndex(activeLayer);
m_Controls.m_cbActiveLayer->blockSignals(false);
m_Controls.m_cbActiveLayer->setEnabled(numberOfLayers > 1);
m_Controls.m_btDeleteLayer->setEnabled(numberOfLayers > 1);
m_Controls.m_btPreviousLayer->setEnabled(activeLayer > 0);
m_Controls.m_btNextLayer->setEnabled(activeLayer != numberOfLayers - 1);
m_Controls.m_btLockExterior->setChecked(workingImage->GetLabel(0, activeLayer)->GetLocked());
m_Controls.m_pbShowLabelTable->setChecked(workingImage->GetNumberOfLabels() > 1 /*1st is exterior*/);
//MLI TODO
//m_Controls.m_ManualToolSelectionBox2D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithWorkingDataVisible);
}
}
if(hasValidWorkingNode && hasReferenceNode)
{
int layer = -1;
referenceNode->GetIntProperty("layer", layer);
workingNode->SetIntProperty("layer", layer + 1);
}
this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_ALL);
}
void QmitkMultiLabelSegmentationView::OnNewSegmentationSession()
{
mitk::DataNode* referenceNode = m_Controls.m_cbReferenceNodeSelector->GetSelectedNode();
if (!referenceNode)
{
QMessageBox::information( m_Parent, "New Segmentation Session", "Please load and select a patient image before starting some action.");
return;
}
m_ToolManager->ActivateTool(-1);
mitk::Image* referenceImage = dynamic_cast<mitk::Image*>( referenceNode->GetData() );
assert(referenceImage);
QString newName = QString::fromStdString(referenceNode->GetName());
newName.append("-labels");
bool ok = false;
newName = QInputDialog::getText(m_Parent, "New Segmentation Session", "New name:", QLineEdit::Normal, newName, &ok);
if(!ok) return;
this->WaitCursorOn();
mitk::LabelSetImage::Pointer workingImage = mitk::LabelSetImage::New();
try
{
workingImage->Initialize(referenceImage);
}
catch ( mitk::Exception& e )
{
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(m_Parent, "New Segmentation Session", "Could not create a new segmentation session.\n");
return;
}
this->WaitCursorOff();
mitk::DataNode::Pointer workingNode = mitk::DataNode::New();
workingNode->SetData(workingImage);
workingNode->SetName(newName.toStdString());
workingImage->GetExteriorLabel()->SetProperty("name.parent",mitk::StringProperty::New(referenceNode->GetName().c_str()));
workingImage->GetExteriorLabel()->SetProperty("name.image",mitk::StringProperty::New(newName.toStdString().c_str()));
if (!this->GetDataStorage()->Exists(workingNode))
this->GetDataStorage()->Add(workingNode, referenceNode);
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
OnNewLabel();
}
void QmitkMultiLabelSegmentationView::OnNewLabel()
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
if (!workingNode)
{
QMessageBox::information(m_Parent, "New Segmentation Session", "Please load and select a patient image before starting some action.");
return;
}
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (!workingImage)
{
QMessageBox::information(m_Parent, "New Segmentation Session", "Please load and select a patient image before starting some action.");
return;
}
QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog( m_Parent );
dialog->SetSuggestionList( mitk::OrganNamesHandling::GetDefaultOrganColorString() );
dialog->setWindowTitle("New Label");
int dialogReturnValue = dialog->exec();
if ( dialogReturnValue == QDialog::Rejected ) return;
QString segName = dialog->GetSegmentationName();
if(segName.isEmpty()) segName = "Unnamed";
workingImage->GetActiveLabelSet()->AddLabel(segName.toStdString(), dialog->GetColor());
UpdateControls();
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
}
void QmitkMultiLabelSegmentationView::OnShowLabelTable(bool value)
{
if (value)
m_Controls.m_LabelSetWidget->show();
else
m_Controls.m_LabelSetWidget->hide();
}
void QmitkMultiLabelSegmentationView::OnNextLayer()
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
assert(workingImage);
OnChangeLayer(workingImage->GetActiveLayer() + 1 );
}
void QmitkMultiLabelSegmentationView::OnPreviousLayer()
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
assert(workingImage);
OnChangeLayer(workingImage->GetActiveLayer() - 1 );
}
void QmitkMultiLabelSegmentationView::OnChangeLayer(int layer)
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
assert(workingImage);
this->WaitCursorOn();
workingImage->SetActiveLayer(layer);
this->WaitCursorOff();
UpdateControls();
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
}
void QmitkMultiLabelSegmentationView::OnDeleteLayer()
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
assert(workingImage);
if (workingImage->GetNumberOfLayers() < 2)
return;
QString question = "Do you really want to delete the current layer?";
QMessageBox::StandardButton answerButton = QMessageBox::question( m_Controls.m_LabelSetWidget, "Delete layer",
question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton != QMessageBox::Yes) return;
try
{
this->WaitCursorOn();
workingImage->RemoveLayer();
this->WaitCursorOff();
}
catch ( mitk::Exception& e )
{
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(m_Controls.m_LabelSetWidget, "Delete Layer", "Could not delete the currently active layer. See error log for details.\n");
return;
}
UpdateControls();
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
}
void QmitkMultiLabelSegmentationView::OnAddLayer()
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
assert(workingImage);
QString question = "Do you really want to add a layer to the current segmentation session?";
QMessageBox::StandardButton answerButton = QMessageBox::question( m_Controls.m_LabelSetWidget, "Add layer",
question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton != QMessageBox::Yes) return;
int newLabelSetId = -1;
try
{
WaitCursorOn();
newLabelSetId = workingImage->AddLayer();
WaitCursorOff();
}
catch ( mitk::Exception& e )
{
WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(m_Controls.m_LabelSetWidget, "Add Layer", "Could not add a new layer. See error log for details.\n");
return;
}
// Update controls and label set list for direct response
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
OnNewLabel();
UpdateControls();
}
void QmitkMultiLabelSegmentationView::OnDeactivateActiveTool()
{
m_ToolManager->ActivateTool(-1);
}
void QmitkMultiLabelSegmentationView::OnLockExteriorToggled(bool checked)
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
assert(workingImage);
workingImage->GetLabel(0)->SetLocked(checked);
}
void QmitkMultiLabelSegmentationView::NodeAdded(const mitk::DataNode*)
{
/*
bool isHelperObject(false);
node->GetBoolProperty("helper object", isHelperObject);
if (isHelperObject) return;
if (m_ReferenceNode.IsNotNull() && dynamic_cast<mitk::LabelSetImage*>(node->GetData()))
{
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
if (workingImage->GetNumberOfLabels() > 2)
m_Controls.m_LabelSetWidget->show();
else
m_Controls.m_LabelSetWidget->hide();
}
*/
}
void QmitkMultiLabelSegmentationView::NodeRemoved(const mitk::DataNode* node)
{
bool isHelperObject(false);
node->GetBoolProperty("helper object", isHelperObject);
if (isHelperObject) return;
if (m_ReferenceNode.IsNotNull() && dynamic_cast<mitk::LabelSetImage*>(node->GetData()))
{
// 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)));
ctkPluginContext* context = mitk::PluginActivator::getContext();
ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
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());
}
context->ungetService(ppmRef);
service = NULL;
}
}
void QmitkMultiLabelSegmentationView::OnInterpolationSelectionChanged(int index)
{
if (index == 1)
{
m_Controls.m_SurfaceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);//OnToggleWidgetActivation(false);
m_Controls.m_swInterpolation->setCurrentIndex(0);
m_Controls.m_swInterpolation->show();
}
else if (index == 2)
{
m_Controls.m_SliceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
m_Controls.m_swInterpolation->setCurrentIndex(1);
m_Controls.m_swInterpolation->show();
}
else
{
m_Controls.m_SurfaceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
m_Controls.m_SliceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
m_Controls.m_swInterpolation->setCurrentIndex(2);
m_Controls.m_swInterpolation->hide();
}
}
void QmitkMultiLabelSegmentationView::OnReferenceSelectionChanged( const mitk::DataNode* node )
{
m_ToolManager->ActivateTool(-1);
m_ReferenceNode = const_cast<mitk::DataNode*>(node);
m_ToolManager->SetReferenceData(m_ReferenceNode);
//check match of segmentation and reference image geometries
if (node && m_WorkingNode.IsNotNull())
{
mitk::Image* workingImage = dynamic_cast<mitk::Image*>(m_WorkingNode->GetData());
assert(workingImage);
mitk::Image* refImage = dynamic_cast<mitk::Image*>(node->GetData());
assert(refImage);
if (!this->CheckForSameGeometry(refImage, workingImage))
return;
}
this->UpdateControls();
//m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
}
void QmitkMultiLabelSegmentationView::OnEstablishLabelSetConnection()
{
MITK_INFO << "Connection Established";
if (m_WorkingNode.IsNull())
{
return;
}
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
assert(workingImage);
workingImage->GetActiveLabelSet()->AddLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->RemoveLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ModifyLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ActiveLabelEvent +=
mitk::MessageDelegate1<QmitkLabelSetWidget, mitk::Label::PixelType>(m_Controls.m_LabelSetWidget,
&QmitkLabelSetWidget::SelectLabelByPixelValue);
workingImage->BeforeChangeLayerEvent += mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
}
void QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection()
{
MITK_INFO << "Connection Lost";
if (m_WorkingNode.IsNull())
{
return;
}
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
assert(workingImage);
// Reset LabelSetWidget Events
workingImage->GetActiveLabelSet()->AddLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->RemoveLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ModifyLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ActiveLabelEvent -=
mitk::MessageDelegate1<QmitkLabelSetWidget, mitk::Label::PixelType>(m_Controls.m_LabelSetWidget,
&QmitkLabelSetWidget::SelectLabelByPixelValue);
workingImage->BeforeChangeLayerEvent -= mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
}
void QmitkMultiLabelSegmentationView::OnSegmentationSelectionChanged(const mitk::DataNode *node)
{
m_ToolManager->ActivateTool(-1);
if(m_WorkingNode.IsNotNull())
{
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
assert(workingImage);
//Loose LabelSetConnections
OnLooseLabelSetConnection();
}
m_WorkingNode = const_cast<mitk::DataNode*>(node);
if(m_WorkingNode.IsNotNull())
{
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
assert(workingImage);
//Establish LabelSetConnection
OnEstablishLabelSetConnection();
}
m_ToolManager->SetWorkingData(m_WorkingNode);
//check match of segmentation and reference image geometries
if (node && m_ReferenceNode.IsNotNull())
{
mitk::Image* refImage = dynamic_cast<mitk::Image*>(m_ReferenceNode->GetData());
assert(refImage);
mitk::Image* workingImage = dynamic_cast<mitk::Image*>(node->GetData());
assert(workingImage);
if (!this->CheckForSameGeometry(refImage, workingImage))
return;
}
if (m_WorkingNode.IsNotNull())
{
mitk::DataStorage::SetOfObjects::ConstPointer segNodes = this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
for(mitk::DataStorage::SetOfObjects::const_iterator iter = segNodes->begin(); iter != segNodes->end(); ++iter)
{
mitk::DataNode* _segNode = *iter;
_segNode->SetVisibility(false);
}
m_WorkingNode->SetVisibility(true);
}
this->UpdateControls();
if (m_WorkingNode.IsNotNull())
{
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
}
}
void QmitkMultiLabelSegmentationView::OnManualTool2DSelected(int id)
{
this->ResetMouseCursor();
mitk::StatusBar::GetInstance()->DisplayText("");
if (id >= 0)
{
std::string text = "Active Tool: \"";
text += m_ToolManager->GetToolById(id)->GetName();
text += "\"";
mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
us::ModuleResource resource = m_ToolManager->GetToolById(id)->GetCursorIconResource();
if (resource.IsValid())
this->SetMouseCursor(resource, 0, 0);
}
}
void QmitkMultiLabelSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
{
if (m_Parent && m_WorkingNode.IsNotNull())
{
mitk::BoolProperty::Pointer drawOutline = mitk::BoolProperty::New(prefs->GetBool("draw outline", true));
mitk::BoolProperty::Pointer volumeRendering = mitk::BoolProperty::New(prefs->GetBool("volume rendering", false));
mitk::LabelSetImage* labelSetImage;
mitk::DataNode* segmentation;
// iterate all segmentations (binary (single label) and LabelSetImages)
mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateOr::Pointer allSegmentationsPredicate = mitk::NodePredicateOr::New(isBinaryPredicate, m_SegmentationPredicate);
mitk::DataStorage::SetOfObjects::ConstPointer allSegmentations = GetDataStorage()->GetSubset(allSegmentationsPredicate);
for (mitk::DataStorage::SetOfObjects::const_iterator it = allSegmentations->begin(); it != allSegmentations->end(); ++it)
{
segmentation = *it;
labelSetImage = dynamic_cast<mitk::LabelSetImage*>(segmentation->GetData());
if (nullptr != labelSetImage)
{
// segmentation node is a multi label segmentation
segmentation->SetProperty("labelset.contour.active", drawOutline);
segmentation->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
segmentation->SetProperty("volumerendering", volumeRendering);
// force render window update to show outline
segmentation->GetData()->Modified();
}
else
{
// node is actually a 'single label' segmentation,
// but its outline property can be set in the 'multi label' segmentation preference page as well
bool isBinary = false;
segmentation->GetBoolProperty("binary", isBinary);
if (isBinary)
{
segmentation->SetProperty("outline binary", drawOutline);
segmentation->SetProperty("outline width", mitk::FloatProperty::New(2.0));
segmentation->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
segmentation->SetProperty("volumerendering", volumeRendering);
// force render window update to show outline
segmentation->GetData()->Modified();
}
}
}
}
}
void QmitkMultiLabelSegmentationView::ResetMouseCursor()
{
if ( m_MouseCursorSet )
{
mitk::ApplicationCursor::GetInstance()->PopCursor();
m_MouseCursorSet = false;
}
}
void QmitkMultiLabelSegmentationView::SetMouseCursor( const us::ModuleResource resource, int hotspotX, int hotspotY )
{
// Remove previously set mouse cursor
if ( m_MouseCursorSet )
{
mitk::ApplicationCursor::GetInstance()->PopCursor();
}
us::ModuleResourceStream cursor(resource, std::ios::binary);
mitk::ApplicationCursor::GetInstance()->PushCursor( cursor, hotspotX, hotspotY );
m_MouseCursorSet = true;
}
void QmitkMultiLabelSegmentationView::OnGoToLabel(const mitk::Point3D& pos)
{
if (m_IRenderWindowPart)
m_IRenderWindowPart->SetSelectedPosition(pos);
}
void QmitkMultiLabelSegmentationView::OnResetView()
{
if (m_IRenderWindowPart)
m_IRenderWindowPart->ForceImmediateUpdate();
}
QString QmitkMultiLabelSegmentationView::GetLastFileOpenPath()
{
return this->GetPreferences()->Get("LastFileOpenPath", "");
}
void QmitkMultiLabelSegmentationView::SetLastFileOpenPath(const QString& path)
{
this->GetPreferences()->Put("LastFileOpenPath", path);
this->GetPreferences()->Flush();
}
diff --git a/README.md b/README.md
index f5cff17721..fcd3cfef7d 100644
--- a/README.md
+++ b/README.md
@@ -1,94 +1,94 @@
![MITK Logo][logo]
The [Medical Imaging Interaction Toolkit][mitk] (MITK) is a free open-source software
system for development of interactive medical image processing software. MITK
combines the [Insight Toolkit][itk] (ITK) and the [Visualization Toolkit][vtk] (VTK) with an application framework.
The links below provide high-level and reference documentation targeting different
usage scenarios:
- Get a [high-level overview][mitk-overview] about MITK with pointers to further
documentation
- End-users looking for help with MITK applications should read the
[MITK User Manual][mitk-usermanual]
- Developers contributing to or using MITK, please see the [MITK Developer Manual][mitk-devmanual]
as well as the [MITK API Reference][mitk-apiref]
See the [MITK homepage][mitk] for details.
Supported Platforms
-----------------------------
MITK is a cross-platform C++ toolkit and officially supports:
- Windows
- - MacOS X
+ - macOS
- Linux
For details, please read the [Supported Platforms][platforms] page.
License
-----------
Copyright (c) [German Cancer Research Center][dkfz].
MITK is available as free open-source software under a [BSD-style license][license].
Download
---------
The MITK source code and binaries for the *MitkWorkbench* application are released regularly according to the [MITK release cycle][release-cycle]. See the [Download][download] page for a list of releases.
The official MITK source code is available in the [MITK Git repository][diffusion]. The Git clone command is
- git clone https://phabricator.mitk.org/diffusion/MITK/mitk.git
+ git clone https://phabricator.mitk.org/source/mitk.git MITK
Active development takes place in the MITK master branch and its usage is advised for advanced users only.
How to Contribute
--------------
Contributions of all kind are happily accepted. However, to make the contribution process as smooth as possible, please read the [How to contribute to MITK][contribute] page if you plan to contribute to MITK.
Build Instructions
------------------------
MITK uses [CMake][cmake] to configure a build tree. The following is a crash course about cloning, configuring, and building MITK on a Linux/Unix system:
- git clone https://phabricator.mitk.org/diffusion/MITK/mitk.git MITK
+ git clone https://phabricator.mitk.org/source/mitk.git MITK
mkdir MITK-build
cd MITK-build
cmake ../MITK
make -j4
Read the comprehensive [Build Instructions][build] page for details.
Useful Links
------------------
- [Homepage][mitk]
- [Download][download]
- [Mailing List][mailinglist]
- [Bug Tracker][bugs]
[logo]: https://github.com/MITK/MITK/raw/master/mitk.png
[mitk]: http://mitk.org
-[itk]: http://www.itk.org
-[vtk]: http://www.vtk.org
-[mitk-overview]: http://docs.mitk.org/2016.03/Overview.html
-[mitk-usermanual]: http://docs.mitk.org/2016.03/UserManualPortal.html
-[mitk-devmanual]: http://docs.mitk.org/2016.03/DeveloperManualPortal.html
-[mitk-apiref]: http://docs.mitk.org/2016.03/usergroup0.html
-[platforms]: http://docs.mitk.org/2016.03/SupportedPlatformsPage.html
-[dkfz]: http://www.dkfz.de
-[license]: http://mitk.org/git/?p=MITK.git;a=blob_plain;f=LICENSE.txt
+[itk]: https://itk.org
+[vtk]: http://vtk.org
+[mitk-overview]: http://docs.mitk.org/2016.11/Overview.html
+[mitk-usermanual]: http://docs.mitk.org/2016.11/UserManualPortal.html
+[mitk-devmanual]: http://docs.mitk.org/2016.11/DeveloperManualPortal.html
+[mitk-apiref]: http://docs.mitk.org/2016.11/usergroup0.html
+[platforms]: http://docs.mitk.org/2016.11/SupportedPlatformsPage.html
+[dkfz]: https://www.dkfz.de
+[license]: https://github.com/MITK/MITK/blob/master/LICENSE.txt
[release-cycle]: http://mitk.org/MitkReleaseCycle
[download]: http://mitk.org/Download
-[diffusion]: https://phabricator.mitk.org/diffusion/MITK/
+[diffusion]: https://phabricator.mitk.org/source/mitk/
[contribute]: http://mitk.org/How_to_contribute
-[cmake]: http://www.cmake.org
-[build]: http://docs.mitk.org/2016.03/BuildInstructionsPage.html
+[cmake]: https://www.cmake.org
+[build]: http://docs.mitk.org/2016.11/BuildInstructionsPage.html
[mailinglist]: http://mitk.org/Mailinglist
[bugs]: https://phabricator.mitk.org/maniphest/
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index 7013532270..63b863e7a4 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,434 +1,434 @@
include(mitkFunctionInstallExternalCMakeProject)
#-----------------------------------------------------------------------------
# Convenient macro allowing to download a file
#-----------------------------------------------------------------------------
if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL)
set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty)
endif()
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()
# We need a proper patch program. On Linux and MacOS, we assume
# that "patch" is available. On Windows, we download patch.exe
# if not patch program is found.
find_program(PATCH_COMMAND patch)
if((NOT PATCH_COMMAND OR NOT EXISTS ${PATCH_COMMAND}) AND WIN32)
downloadFile(${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/patch.exe
${CMAKE_CURRENT_BINARY_DIR}/patch.exe)
find_program(PATCH_COMMAND patch ${CMAKE_CURRENT_BINARY_DIR})
endif()
if(NOT PATCH_COMMAND)
message(FATAL_ERROR "No patch program found.")
endif()
#-----------------------------------------------------------------------------
# ExternalProjects
#-----------------------------------------------------------------------------
get_property(external_projects GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
if(MITK_CTEST_SCRIPT_MODE)
# Write a file containing the list of enabled external project targets.
# This file can be read by a ctest script to separately build projects.
set(SUPERBUILD_TARGETS )
foreach(proj ${external_projects})
if(MITK_USE_${proj})
list(APPEND SUPERBUILD_TARGETS ${proj})
endif()
endforeach()
file(WRITE "${CMAKE_BINARY_DIR}/SuperBuildTargets.cmake" "set(SUPERBUILD_TARGETS ${SUPERBUILD_TARGETS})")
endif()
# A list of "nice" external projects, playing well together with CMake
set(nice_external_projects ${external_projects})
list(REMOVE_ITEM nice_external_projects Boost Python)
foreach(proj ${nice_external_projects})
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()
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()
# Setup file for setting custom ctest vars
configure_file(
CMake/SuperbuildCTestCustom.cmake.in
${MITK_BINARY_DIR}/CTestCustom.cmake
@ONLY
)
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()
#-----------------------------------------------------------------------------
# External project settings
#-----------------------------------------------------------------------------
include(ExternalProject)
set(ep_prefix "${CMAKE_BINARY_DIR}/ep")
set_property(DIRECTORY PROPERTY EP_PREFIX ${ep_prefix})
# 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()
# This is a workaround for passing linker flags
# actually down to the linker invocation
set(_cmake_required_flags_orig ${CMAKE_REQUIRED_FLAGS})
set(CMAKE_REQUIRED_FLAGS "-Wl,-rpath")
mitkFunctionCheckCompilerFlags(${CMAKE_REQUIRED_FLAGS} _has_rpath_flag)
set(CMAKE_REQUIRED_FLAGS ${_cmake_required_flags_orig})
set(_install_rpath_linkflag )
if(_has_rpath_flag)
if(APPLE)
set(_install_rpath_linkflag "-Wl,-rpath,@loader_path/../lib")
else()
set(_install_rpath_linkflag "-Wl,-rpath='$ORIGIN/../lib'")
endif()
endif()
set(_install_rpath)
if(APPLE)
set(_install_rpath "@loader_path/../lib")
elseif(UNIX)
# this work for libraries as well as executables
set(_install_rpath "\$ORIGIN/../lib")
endif()
set(ep_common_args
-DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
-DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
-DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
-DCMAKE_MACOSX_RPATH:BOOL=TRUE
"-DCMAKE_INSTALL_RPATH:STRING=${_install_rpath}"
-DBUILD_TESTING:BOOL=OFF
-DCMAKE_INSTALL_PREFIX:PATH=<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} ${MITK_CXX11_FLAG}"
#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}
)
set(DCMTK_CMAKE_DEBUG_POSTFIX )
# python libraries wont work with it
if(NOT MITK_USE_Python)
list(APPEND ep_common_args -DCMAKE_DEBUG_POSTFIX:STRING=d)
set(DCMTK_CMAKE_DEBUG_POSTFIX d)
endif()
set(ep_common_cache_args
)
set(ep_common_cache_default_args
"-DCMAKE_PREFIX_PATH:PATH=<INSTALL_DIR>;${CMAKE_PREFIX_PATH}"
"-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
"-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
)
# Pass the CMAKE_OSX variables to external projects
if(APPLE)
set(MAC_OSX_ARCHITECTURE_ARGS
-DCMAKE_OSX_ARCHITECTURES:PATH=${CMAKE_OSX_ARCHITECTURES}
-DCMAKE_OSX_DEPLOYMENT_TARGET:PATH=${CMAKE_OSX_DEPLOYMENT_TARGET}
-DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT}
)
set(ep_common_args
${MAC_OSX_ARCHITECTURE_ARGS}
${ep_common_args}
)
endif()
set(mitk_superbuild_ep_args)
set(mitk_depends )
# Include external projects
include(CMakeExternals/MITKData.cmake)
foreach(p ${external_projects})
include(CMakeExternals/${p}.cmake)
list(APPEND mitk_superbuild_ep_args
-DMITK_USE_${p}:BOOL=${MITK_USE_${p}}
)
get_property(_package GLOBAL PROPERTY MITK_${p}_PACKAGE)
if(_package)
list(APPEND mitk_superbuild_ep_args -D${p}_DIR:PATH=${${p}_DIR})
endif()
list(APPEND mitk_depends ${${p}_DEPENDS})
endforeach()
#-----------------------------------------------------------------------------
# Set superbuild boolean args
#-----------------------------------------------------------------------------
set(mitk_cmake_boolean_args
BUILD_SHARED_LIBS
WITH_COVERAGE
BUILD_TESTING
MITK_BUILD_ALL_PLUGINS
MITK_BUILD_ALL_APPS
MITK_BUILD_EXAMPLES
- MITK_USE_QT
- MITK_USE_QT_WEBENGINE
+ MITK_USE_Qt5
+ MITK_USE_Qt5_WebEngine
MITK_USE_SYSTEM_Boost
MITK_USE_BLUEBERRY
MITK_USE_OpenCL
MITK_ENABLE_PIC_READER
)
#-----------------------------------------------------------------------------
# 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
${mitk_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
-DMITK_USE_Python:BOOL=${MITK_USE_Python}
-DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
-DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
-DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
-DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
-DMITK_USE_SYSTEM_PYTHON:BOOL=${MITK_USE_SYSTEM_PYTHON}
)
endif()
set(proj MITK-Configure)
ExternalProject_Add(${proj}
LIST_SEPARATOR ${sep}
DOWNLOAD_COMMAND ""
CMAKE_GENERATOR ${gen}
CMAKE_CACHE_ARGS
# --------------- Build options ----------------
-DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
"-DCMAKE_PREFIX_PATH:PATH=${ep_prefix};${CMAKE_PREFIX_PATH}"
"-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
"-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
# --------------- 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
-DMITK_BUILD_CONFIGURATION:STRING=${MITK_BUILD_CONFIGURATION}
-DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
# ----------------- Miscellaneous ---------------
-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}
-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}
-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_WHITELIST:STRING=${MITK_WHITELIST}
-DMITK_WHITELISTS_EXTERNAL_PATH:STRING=${MITK_WHITELISTS_EXTERNAL_PATH}
-DMITK_WHITELISTS_INTERNAL_PATH:STRING=${MITK_WHITELISTS_INTERNAL_PATH}
-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_VECTOR_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
-DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS}
# --------------- External project options ---------------
-DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
-DMITK_EXTERNAL_PROJECT_PREFIX:PATH=${ep_prefix}
-DCppMicroServices_DIR:PATH=${CppMicroServices_DIR}
-DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE}
-DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=${DCMTK_CMAKE_DEBUG_POSTFIX}
-DBOOST_ROOT:PATH=${BOOST_ROOT}
-DBOOST_LIBRARYDIR:PATH=${BOOST_LIBRARYDIR}
-DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
CMAKE_ARGS
${mitk_initial_cache_arg}
${MAC_OSX_ARCHITECTURE_ARGS}
${mitk_superbuild_ep_args}
SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
BUILD_COMMAND ""
INSTALL_COMMAND ""
DEPENDS
MITK-Utilities
)
mitkFunctionInstallExternalCMakeProject(${proj})
#-----------------------------------------------------------------------------
# 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
)
diff --git a/Widget b/Widget
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/xml b/xml
deleted file mode 100644
index e69de29bb2..0000000000